Changeset 1732 for trunk/Clp


Ignore:
Timestamp:
May 31, 2011 4:09:41 AM (8 years ago)
Author:
forrest
Message:

various fixes plus slightly weighted pricing plus lagomory switches

Location:
trunk/Clp/src
Files:
17 edited

Legend:

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

    r1726 r1732  
    22192219          "This switches on knapsack cuts (either at root or in entire tree) \
    22202220See branchAndCut for information on options."
     2221     );
     2222     parameters[numberParameters++] =
     2223          CbcOrClpParam("lagomory!Cuts", "Whether to use Lagrangean Gomory cuts",
     2224                        "off", CBC_PARAM_STR_LAGOMORYCUTS);
     2225     parameters[numberParameters-1].append("endonlyroot");
     2226     parameters[numberParameters-1].append("endcleanroot");
     2227     parameters[numberParameters-1].append("endbothroot");
     2228     parameters[numberParameters-1].append("endonly");
     2229     parameters[numberParameters-1].append("endclean");
     2230     parameters[numberParameters-1].append("endboth");
     2231     parameters[numberParameters-1].append("onlyaswell");
     2232     parameters[numberParameters-1].append("cleanaswell");
     2233     parameters[numberParameters-1].append("bothaswell");
     2234     parameters[numberParameters-1].append("onlyinstead");
     2235     parameters[numberParameters-1].append("cleaninstead");
     2236     parameters[numberParameters-1].append("bothinstead");
     2237     parameters[numberParameters-1].setLonghelp
     2238     (
     2239          "This is a gross simplification of 'A Relax-and-Cut Framework for Gomory's Mixed-Integer Cuts' \
     2240by Matteo Fischetti & Domenico Salvagnin.  This simplification \
     2241just uses original constraints while modifying objective using other cuts. \
     2242So you don't use messy constraints generated by Gomory etc. \
     2243A variant is to allow non messy cuts e.g. clique cuts. \
     2244So 'only' does this while clean also allows integral valued cuts.  \
     2245'End' is recommended which waits until other cuts have finished and then \
     2246does a few passes. \
     2247The length options for gomory cuts are used."
    22212248     );
    22222249     parameters[numberParameters++] =
  • trunk/Clp/src/CbcOrClpParam.hpp

    r1724 r1732  
    201201     CBC_PARAM_STR_PIVOTANDCOMPLEMENT,
    202202     CBC_PARAM_STR_VND,
     203     CBC_PARAM_STR_LAGOMORYCUTS,
    203204
    204205     CLP_PARAM_ACTION_DIRECTORY = 301,
  • trunk/Clp/src/ClpCholeskyBase.cpp

    r1723 r1732  
    32763276     CoinWorkDouble largest = doubleParameters_[3];
    32773277     CoinWorkDouble smallest = doubleParameters_[4];
    3278      int numberDropped = integerParameters_[20];
    32793278     // probably done before
    32803279     largest = 0.0;
    32813280     smallest = COIN_DBL_MAX;
    3282      numberDropped = 0;
    32833281     double dropValue = doubleParameters_[10];
    32843282     int firstPositive = integerParameters_[34];
     
    33023300     bool endClique = false;
    33033301     int lastRow = 0;
    3304      int cliqueSize = 0;
    33053302     CoinBigIndex cliquePointer = 0;
    33063303     int nextRow2 = -1;
     
    34003397               lastRow = iRow;
    34013398               cliquePointer = choleskyStart_[iRow];
    3402                cliqueSize = choleskyStart_[iRow+1] - cliquePointer + 1;
    34033399          }
    34043400          // for each column L[*,kRow] that affects L[*,iRow]
  • trunk/Clp/src/ClpDualRowDantzig.cpp

    r1665 r1732  
    1010#include "CoinIndexedVector.hpp"
    1111#include "CoinHelperFunctions.hpp"
     12#ifndef CLP_DUAL_COLUMN_MULTIPLIER
     13#define CLP_DUAL_COLUMN_MULTIPLIER 1.01
     14#endif
    1215
    1316//#############################################################################
     
    6063     int iRow;
    6164     const int * pivotVariable = model_->pivotVariable();
    62      double largest = model_->currentPrimalTolerance();
     65     double tolerance = model_->currentPrimalTolerance();
    6366     // we can't really trust infeasibilities if there is primal error
    6467     if (model_->largestPrimalError() > 1.0e-8)
    65           largest *= model_->largestPrimalError() / 1.0e-8;
     68          tolerance *= model_->largestPrimalError() / 1.0e-8;
     69     double largest = 0.0;
    6670     int chosenRow = -1;
    67      for (iRow = 0; iRow < model_->numberRows(); iRow++) {
    68           int iPivot = pivotVariable[iRow];
    69           double value = model_->solution(iPivot);
    70           double lower = model_->lower(iPivot);
    71           double upper = model_->upper(iPivot);
    72           if (CoinMax(value - upper, lower - value) > largest) {
    73                int iSequence = pivotVariable[iRow];
    74                if (!model_->flagged(iSequence)) {
    75                     chosenRow = iRow;
    76                     largest = CoinMax(value - upper, lower - value);
    77                }
     71     int numberRows = model_->numberRows();
     72#ifdef CLP_DUAL_COLUMN_MULTIPLIER
     73     int numberColumns = model_->numberColumns();
     74#endif
     75     for (iRow = 0; iRow < numberRows; iRow++) {
     76          int iSequence = pivotVariable[iRow];
     77          double value = model_->solution(iSequence);
     78          double lower = model_->lower(iSequence);
     79          double upper = model_->upper(iSequence);
     80          double infeas = CoinMax(value - upper , lower - value);
     81          if (infeas > tolerance) {
     82#ifdef CLP_DUAL_COLUMN_MULTIPLIER
     83              if (iSequence < numberColumns)
     84                infeas *= CLP_DUAL_COLUMN_MULTIPLIER;
     85#endif
     86              if (infeas > largest) {
     87                if (!model_->flagged(iSequence)) {
     88                  chosenRow = iRow;
     89                  largest = infeas;
     90                }
     91              }
    7892          }
    7993     }
  • trunk/Clp/src/ClpDualRowPivot.hpp

    r1665 r1732  
    122122     //@}
    123123};
    124 
     124#ifndef CLP_DUAL_COLUMN_MULTIPLIER
     125//#define CLP_DUAL_COLUMN_MULTIPLIER 0.99999
    125126#endif
     127#endif
  • trunk/Clp/src/ClpDualRowSteepest.cpp

    r1665 r1732  
    236236     double * upper = model_->upperRegion();
    237237     // do last pivot row one here
    238      //#define COLUMN_BIAS 4.0
    239      //#define FIXED_BIAS 10.0
     238     //#define CLP_DUAL_FIXED_COLUMN_MULTIPLIER 10.0
    240239     if (lastPivotRow >= 0 && lastPivotRow < model_->numberRows()) {
    241 #ifdef COLUMN_BIAS
     240#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    242241          int numberColumns = model_->numberColumns();
    243242#endif
     
    249248               value -= upper;
    250249               value *= value;
    251 #ifdef COLUMN_BIAS
     250#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    252251               if (iPivot < numberColumns)
    253                     value *= COLUMN_BIAS; // bias towards columns
    254                k
     252                    value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
    255253#endif
    256254               // store square in list
     
    262260               value -= lower;
    263261               value *= value;
    264 #ifdef COLUMN_BIAS
     262#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    265263               if (iPivot < numberColumns)
    266                     value *= COLUMN_BIAS; // bias towards columns
     264                    value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
    267265#endif
    268266               // store square in list
     
    685683     const double * COIN_RESTRICT lowerModel = model_->lowerRegion();
    686684     const double * COIN_RESTRICT upperModel = model_->upperRegion();
    687 #ifdef COLUMN_BIAS
     685#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    688686     int numberColumns = model_->numberColumns();
    689687#endif
     
    704702                    value -= lower;
    705703                    value *= value;
    706 #ifdef COLUMN_BIAS
     704#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    707705                    if (iPivot < numberColumns)
    708                          value *= COLUMN_BIAS; // bias towards columns
    709 #endif
    710 #ifdef FIXED_BIAS
     706                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     707#endif
     708#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    711709                    if (lower == upper)
    712                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     710                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    713711#endif
    714712                    // store square in list
     
    720718                    value -= upper;
    721719                    value *= value;
    722 #ifdef COLUMN_BIAS
     720#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    723721                    if (iPivot < numberColumns)
    724                          value *= COLUMN_BIAS; // bias towards columns
    725 #endif
    726 #ifdef FIXED_BIAS
     722                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     723#endif
     724#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    727725                    if (lower == upper)
    728                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     726                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    729727#endif
    730728                    // store square in list
     
    754752                    value -= lower;
    755753                    value *= value;
    756 #ifdef COLUMN_BIAS
     754#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    757755                    if (iPivot < numberColumns)
    758                          value *= COLUMN_BIAS; // bias towards columns
    759 #endif
    760 #ifdef FIXED_BIAS
     756                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     757#endif
     758#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    761759                    if (lower == upper)
    762                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     760                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    763761#endif
    764762                    // store square in list
     
    770768                    value -= upper;
    771769                    value *= value;
    772 #ifdef COLUMN_BIAS
     770#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    773771                    if (iPivot < numberColumns)
    774                          value *= COLUMN_BIAS; // bias towards columns
    775 #endif
    776 #ifdef FIXED_BIAS
     772                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     773#endif
     774#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    777775                    if (lower == upper)
    778                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     776                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    779777#endif
    780778                    // store square in list
     
    979977                    value -= lower;
    980978                    value *= value;
    981 #ifdef COLUMN_BIAS
     979#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    982980                    if (iPivot < numberColumns)
    983                          value *= COLUMN_BIAS; // bias towards columns
    984 #endif
    985 #ifdef FIXED_BIAS
     981                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     982#endif
     983#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    986984                    if (lower == upper)
    987                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     985                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    988986#endif
    989987                    // store square in list
     
    992990                    value -= upper;
    993991                    value *= value;
    994 #ifdef COLUMN_BIAS
     992#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    995993                    if (iPivot < numberColumns)
    996                          value *= COLUMN_BIAS; // bias towards columns
    997 #endif
    998 #ifdef FIXED_BIAS
     994                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     995#endif
     996#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    999997                    if (lower == upper)
    1000                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     998                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    1001999#endif
    10021000                    // store square in list
  • trunk/Clp/src/ClpDynamicMatrix.cpp

    r1726 r1732  
    20212021                              double dj = cost[i] - dual;
    20222022                              double improvement = 0.0;
    2023                               double distance = 0.0;
    20242023                              if (iphase || i < numberInSet)
    20252024                                   assert (solution[i] >= lower[i] && solution[i] <= upper[i]);
     
    20332032                                   if (dj < 0.0) {
    20342033                                        way = 1;
    2035                                         distance = upper[i] - solution[i];
    20362034                                   } else {
    20372035                                        way = -1;
    2038                                         distance = solution[i] - lower[i];
    20392036                                   }
    20402037                              }
  • trunk/Clp/src/ClpFactorization.cpp

    r1717 r1732  
    13991399     } else if (!coinFactorizationA_) {
    14001400          coinFactorizationA_ = new CoinFactorization();
     1401          goOslThreshold_ = -1;
     1402          goDenseThreshold_ = -1;
     1403          goSmallThreshold_ = -1;
    14011404     }
    14021405}
  • trunk/Clp/src/ClpGubDynamicMatrix.cpp

    r1665 r1732  
    12291229                                   double dj = cost[i] - dual;
    12301230                                   double improvement = 0.0;
    1231                                    double distance = 0.0;
    12321231                                   if (iphase || i < numberInSet)
    12331232                                        assert (solution[i] >= lower[i] && solution[i] <= upper[i]);
     
    12411240                                        if (dj < 0.0) {
    12421241                                             way = 1;
    1243                                              distance = upper[i] - solution[i];
    12441242                                        } else {
    12451243                                             way = -1;
    1246                                              distance = solution[i] - lower[i];
    12471244                                        }
    12481245                                   }
  • trunk/Clp/src/ClpGubMatrix.cpp

    r1665 r1732  
    32103210                                        double dj = cost[i] - dual;
    32113211                                        double improvement = 0.0;
    3212                                         double distance = 0.0;
    32133212                                        if (iphase || i < numberInSet)
    32143213                                             assert (solution[i] >= lower[i] && solution[i] <= upper[i]);
     
    32223221                                             if (dj < 0.0) {
    32233222                                                  way = 1;
    3224                                                   distance = upper[i] - solution[i];
    32253223                                             } else {
    32263224                                                  way = -1;
    3227                                                   distance = solution[i] - lower[i];
    32283225                                             }
    32293226                                        }
  • trunk/Clp/src/ClpModel.cpp

    r1727 r1732  
    15011501     rowScale_ = NULL;
    15021502     columnScale_ = NULL;
     1503     delete scaledMatrix_;
     1504     scaledMatrix_ = NULL;
    15031505}
    15041506// Deletes columns
  • trunk/Clp/src/ClpNetworkBasis.cpp

    r1665 r1732  
    8585     // it pivots on row permuteBack[0]
    8686     // a known root is given by permuteBack[numberRows_-1]
    87      int lastPivot = numberRows_;
    8887     for (i = 0; i < numberRows_; i++) {
    8988          int iPivot = permuteBack[i];
    90           lastPivot = iPivot;
    9189          double sign;
    9290          if (pivotRegion[i] > 0.0)
     
    117115     }
    118116     // do depth
    119      int iPivot = numberRows_;
    120117     int nStack = 1;
    121118     stack_[0] = descendant_[numberRows_];
     
    126123          if (iNext >= 0) {
    127124               depth_[iNext] = nStack;
    128                iPivot = iNext;
    129125               int iRight = rightSibling_[iNext];
    130126               stack_[nStack++] = iRight;
     
    344340{
    345341     // check depth
    346      int iPivot = numberRows_;
    347342     int nStack = 1;
    348343     stack_[0] = descendant_[numberRows_];
     
    354349               //assert (depth_[iNext]==nStack);
    355350               depth_[iNext] = nStack;
    356                iPivot = iNext;
    357351               int iRight = rightSibling_[iNext];
    358352               stack_[nStack++] = iRight;
  • trunk/Clp/src/ClpPrimalColumnDantzig.cpp

    r1665 r1732  
    132132     reducedCost = model_->djRegion();
    133133
     134#ifndef CLP_PRIMAL_SLACK_MULTIPLIER
    134135     for (iSequence = 0; iSequence < number; iSequence++) {
    135136          // check flagged variable
     
    164165          }
    165166     }
     167#else
     168     // Columns
     169     int numberColumns = model_->numberColumns();
     170     for (iSequence = 0; iSequence < numberColumns; iSequence++) {
     171          // check flagged variable
     172          if (!model_->flagged(iSequence)) {
     173               double value = reducedCost[iSequence];
     174               ClpSimplex::Status status = model_->getStatus(iSequence);
     175
     176               switch(status) {
     177
     178               case ClpSimplex::basic:
     179               case ClpSimplex::isFixed:
     180                    break;
     181               case ClpSimplex::isFree:
     182               case ClpSimplex::superBasic:
     183                    if (fabs(value) > bestFreeDj) {
     184                         bestFreeDj = fabs(value);
     185                         bestFreeSequence = iSequence;
     186                    }
     187                    break;
     188               case ClpSimplex::atUpperBound:
     189                    if (value > bestDj) {
     190                         bestDj = value;
     191                         bestSequence = iSequence;
     192                    }
     193                    break;
     194               case ClpSimplex::atLowerBound:
     195                    if (value < -bestDj) {
     196                         bestDj = -value;
     197                         bestSequence = iSequence;
     198                    }
     199               }
     200          }
     201     }
     202     // Rows
     203     for ( ; iSequence < number; iSequence++) {
     204          // check flagged variable
     205          if (!model_->flagged(iSequence)) {
     206               double value = reducedCost[iSequence] * CLP_PRIMAL_SLACK_MULTIPLIER;
     207               ClpSimplex::Status status = model_->getStatus(iSequence);
     208
     209               switch(status) {
     210
     211               case ClpSimplex::basic:
     212               case ClpSimplex::isFixed:
     213                    break;
     214               case ClpSimplex::isFree:
     215               case ClpSimplex::superBasic:
     216                    if (fabs(value) > bestFreeDj) {
     217                         bestFreeDj = fabs(value);
     218                         bestFreeSequence = iSequence;
     219                    }
     220                    break;
     221               case ClpSimplex::atUpperBound:
     222                    if (value > bestDj) {
     223                         bestDj = value;
     224                         bestSequence = iSequence;
     225                    }
     226                    break;
     227               case ClpSimplex::atLowerBound:
     228                    if (value < -bestDj) {
     229                         bestDj = -value;
     230                         bestSequence = iSequence;
     231                    }
     232               }
     233          }
     234     }
     235#endif
    166236     // bias towards free
    167237     if (bestFreeSequence >= 0 && bestFreeDj > 0.1 * bestDj)
  • trunk/Clp/src/ClpPrimalColumnPivot.hpp

    r1665 r1732  
    150150     //@}
    151151};
    152 
     152#ifndef CLP_PRIMAL_SLACK_MULTIPLIER
     153#define CLP_PRIMAL_SLACK_MULTIPLIER 1.01
    153154#endif
     155#endif
  • trunk/Clp/src/ClpPrimalColumnSteepest.cpp

    r1723 r1732  
    625625          reducedCost = model_->djRegion(iSection);
    626626          int addSequence;
     627#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     628          double slack_multiplier;
     629#endif
    627630
    628631          if (!iSection) {
     
    631634               updateBy = updates->denseVector();
    632635               addSequence = model_->numberColumns();
     636#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     637               slack_multiplier = CLP_PRIMAL_SLACK_MULTIPLIER;
     638#endif
    633639          } else {
    634640               number = spareColumn1->getNumElements();
     
    636642               updateBy = spareColumn1->denseVector();
    637643               addSequence = 0;
     644#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     645               slack_multiplier = 1.0;
     646#endif
    638647          }
    639648
     
    667676                    break;
    668677               case ClpSimplex::atUpperBound:
     678                    iSequence += addSequence;
    669679                    if (value > tolerance) {
     680#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     681                        value *= value*slack_multiplier;
     682#else
     683                        value *= value;
     684#endif
    670685                         // store square in list
    671                          if (infeas[iSequence+addSequence])
    672                               infeas[iSequence+addSequence] = value * value; // already there
     686                         if (infeas[iSequence])
     687                              infeas[iSequence] = value; // already there
    673688                         else
    674                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     689                              infeasible_->quickAdd(iSequence, value);
    675690                    } else {
    676                          infeasible_->zero(iSequence + addSequence);
     691                         infeasible_->zero(iSequence);
    677692                    }
    678693                    break;
    679694               case ClpSimplex::atLowerBound:
     695                    iSequence += addSequence;
    680696                    if (value < -tolerance) {
     697#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     698                        value *= value*slack_multiplier;
     699#else
     700                        value *= value;
     701#endif
    681702                         // store square in list
    682                          if (infeas[iSequence+addSequence])
    683                               infeas[iSequence+addSequence] = value * value; // already there
     703                         if (infeas[iSequence])
     704                              infeas[iSequence] = value; // already there
    684705                         else
    685                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     706                              infeasible_->quickAdd(iSequence, value);
    686707                    } else {
    687                          infeasible_->zero(iSequence + addSequence);
     708                         infeasible_->zero(iSequence);
    688709                    }
    689710               }
     
    725746     model_->factorization()->updateColumnTranspose(spareRow2, updates);
    726747     // and we can see if reference
    727      double referenceIn = 0.0;
     748     //double referenceIn = 0.0;
    728749     int sequenceIn = model_->sequenceIn();
    729      if (mode_ != 1 && reference(sequenceIn))
    730           referenceIn = 1.0;
     750     //if (mode_ != 1 && reference(sequenceIn))
     751     //   referenceIn = 1.0;
    731752     // save outgoing weight round update
    732753     double outgoingWeight = 0.0;
     
    798819                    value3 += 1.0;
    799820               weight[iSequence] = CoinMax(0.99 * thisWeight, value3);
     821               iSequence += addSequence;
    800822               if (value > tolerance) {
    801823                    // store square in list
    802                     if (infeas[iSequence+addSequence])
    803                          infeas[iSequence+addSequence] = value * value; // already there
     824#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     825                    value *= value*CLP_PRIMAL_SLACK_MULTIPLIER;
     826#else
     827                    value *= value;
     828#endif
     829                    if (infeas[iSequence])
     830                         infeas[iSequence] = value; // already there
    804831                    else
    805                          infeasible_->quickAdd(iSequence + addSequence, value * value);
     832                         infeasible_->quickAdd(iSequence , value);
    806833               } else {
    807                     infeasible_->zero(iSequence + addSequence);
     834                    infeasible_->zero(iSequence);
    808835               }
    809836               break;
     
    816843                    value3 += 1.0;
    817844               weight[iSequence] = CoinMax(0.99 * thisWeight, value3);
     845               iSequence += addSequence;
    818846               if (value < -tolerance) {
    819847                    // store square in list
    820                     if (infeas[iSequence+addSequence])
    821                          infeas[iSequence+addSequence] = value * value; // already there
     848#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     849                    value *= value*CLP_PRIMAL_SLACK_MULTIPLIER;
     850#else
     851                    value *= value;
     852#endif
     853                    if (infeas[iSequence])
     854                         infeas[iSequence] = value; // already there
    822855                    else
    823                          infeasible_->quickAdd(iSequence + addSequence, value * value);
     856                         infeasible_->quickAdd(iSequence , value);
    824857               } else {
    825                     infeasible_->zero(iSequence + addSequence);
     858                    infeasible_->zero(iSequence);
    826859               }
    827860          }
     
    10741107               }
    10751108               weight[iSequence] = thisWeight;
     1109               iSequence += addSequence;
    10761110               if (value > tolerance) {
    10771111                    // store square in list
    1078                     if (infeas[iSequence+addSequence])
    1079                          infeas[iSequence+addSequence] = value * value; // already there
     1112#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1113                    value *= value*CLP_PRIMAL_SLACK_MULTIPLIER;
     1114#else
     1115                    value *= value;
     1116#endif
     1117                    if (infeas[iSequence])
     1118                         infeas[iSequence] = value; // already there
    10801119                    else
    1081                          infeasible_->quickAdd(iSequence + addSequence, value * value);
     1120                         infeasible_->quickAdd(iSequence , value);
    10821121               } else {
    1083                     infeasible_->zero(iSequence + addSequence);
     1122                    infeasible_->zero(iSequence);
    10841123               }
    10851124               break;
     
    11071146               }
    11081147               weight[iSequence] = thisWeight;
     1148               iSequence += addSequence;
    11091149               if (value < -tolerance) {
    11101150                    // store square in list
    1111                     if (infeas[iSequence+addSequence])
    1112                          infeas[iSequence+addSequence] = value * value; // already there
     1151#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1152                    value *= value*CLP_PRIMAL_SLACK_MULTIPLIER;
     1153#else
     1154                    value *= value;
     1155#endif
     1156                    if (infeas[iSequence])
     1157                         infeas[iSequence] = value; // already there
    11131158                    else
    1114                          infeasible_->quickAdd(iSequence + addSequence, value * value);
     1159                         infeasible_->quickAdd(iSequence, value);
    11151160               } else {
    1116                     infeasible_->zero(iSequence + addSequence);
     1161                    infeasible_->zero(iSequence);
    11171162               }
    11181163          }
     
    12381283          reducedCost = model_->djRegion(iSection);
    12391284          int addSequence;
     1285#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1286          double slack_multiplier;
     1287#endif
    12401288
    12411289          if (!iSection) {
     
    12441292               updateBy = updates->denseVector();
    12451293               addSequence = model_->numberColumns();
     1294#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1295               slack_multiplier = CLP_PRIMAL_SLACK_MULTIPLIER;
     1296#endif
    12461297          } else {
    12471298               number = spareColumn1->getNumElements();
     
    12491300               updateBy = spareColumn1->denseVector();
    12501301               addSequence = 0;
     1302#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1303               slack_multiplier = 1.0;
     1304#endif
    12511305          }
    12521306
     
    12801334                    break;
    12811335               case ClpSimplex::atUpperBound:
     1336                    iSequence += addSequence;
    12821337                    if (value > tolerance) {
     1338#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1339                        value *= value*slack_multiplier;
     1340#else
     1341                        value *= value;
     1342#endif
    12831343                         // store square in list
    1284                          if (infeas[iSequence+addSequence])
    1285                               infeas[iSequence+addSequence] = value * value; // already there
     1344                         if (infeas[iSequence])
     1345                              infeas[iSequence] = value; // already there
    12861346                         else
    1287                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     1347                              infeasible_->quickAdd(iSequence, value);
    12881348                    } else {
    1289                          infeasible_->zero(iSequence + addSequence);
     1349                         infeasible_->zero(iSequence);
    12901350                    }
    12911351                    break;
    12921352               case ClpSimplex::atLowerBound:
     1353                    iSequence += addSequence;
    12931354                    if (value < -tolerance) {
     1355#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1356                        value *= value*slack_multiplier;
     1357#else
     1358                        value *= value;
     1359#endif
    12941360                         // store square in list
    1295                          if (infeas[iSequence+addSequence])
    1296                               infeas[iSequence+addSequence] = value * value; // already there
     1361                         if (infeas[iSequence])
     1362                              infeas[iSequence] = value; // already there
    12971363                         else
    1298                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     1364                              infeasible_->quickAdd(iSequence, value);
    12991365                    } else {
    1300                          infeasible_->zero(iSequence + addSequence);
     1366                         infeasible_->zero(iSequence);
    13011367                    }
    13021368               }
     
    13191385          infeasible_->zero(sequenceIn);
    13201386          // and we can see if reference
    1321           double referenceIn = 0.0;
    1322           if (mode_ != 1 && reference(sequenceIn))
    1323                referenceIn = 1.0;
     1387          //double referenceIn = 0.0;
     1388          //if (mode_ != 1 && reference(sequenceIn))
     1389          //   referenceIn = 1.0;
    13241390          // save outgoing weight round update
    13251391          double outgoingWeight = 0.0;
     
    14291495          reducedCost = model_->djRegion(iSection);
    14301496          int addSequence;
     1497#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1498          double slack_multiplier;
     1499#endif
    14311500
    14321501          if (!iSection) {
     
    14351504               updateBy = updates->denseVector();
    14361505               addSequence = model_->numberColumns();
     1506#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1507               slack_multiplier = CLP_PRIMAL_SLACK_MULTIPLIER;
     1508#endif
    14371509          } else {
    14381510               number = spareColumn1->getNumElements();
     
    14401512               updateBy = spareColumn1->denseVector();
    14411513               addSequence = 0;
     1514#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1515               slack_multiplier = 1.0;
     1516#endif
    14421517          }
    14431518
     
    14711546                    break;
    14721547               case ClpSimplex::atUpperBound:
     1548                    iSequence += addSequence;
    14731549                    if (value > tolerance) {
     1550#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1551                        value *= value*slack_multiplier;
     1552#else
     1553                        value *= value;
     1554#endif
    14741555                         // store square in list
    1475                          if (infeas[iSequence+addSequence])
    1476                               infeas[iSequence+addSequence] = value * value; // already there
     1556                         if (infeas[iSequence])
     1557                              infeas[iSequence] = value; // already there
    14771558                         else
    1478                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     1559                              infeasible_->quickAdd(iSequence, value);
    14791560                    } else {
    1480                          infeasible_->zero(iSequence + addSequence);
     1561                         infeasible_->zero(iSequence);
    14811562                    }
    14821563                    break;
    14831564               case ClpSimplex::atLowerBound:
     1565                    iSequence += addSequence;
    14841566                    if (value < -tolerance) {
     1567#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1568                        value *= value*slack_multiplier;
     1569#else
     1570                        value *= value;
     1571#endif
    14851572                         // store square in list
    1486                          if (infeas[iSequence+addSequence])
    1487                               infeas[iSequence+addSequence] = value * value; // already there
     1573                         if (infeas[iSequence])
     1574                              infeas[iSequence] = value; // already there
    14881575                         else
    1489                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     1576                              infeasible_->quickAdd(iSequence, value);
    14901577                    } else {
    1491                          infeasible_->zero(iSequence + addSequence);
     1578                         infeasible_->zero(iSequence);
    14921579                    }
    14931580               }
     
    17471834     infeasible_->zero(sequenceIn);
    17481835     // and we can see if reference
    1749      double referenceIn = 0.0;
    1750      if (mode_ != 1 && reference(sequenceIn))
    1751           referenceIn = 1.0;
     1836     //double referenceIn = 0.0;
     1837     //if (mode_ != 1 && reference(sequenceIn))
     1838     //   referenceIn = 1.0;
    17521839     // save outgoing weight round update
    17531840     double outgoingWeight = 0.0;
     
    29493036
    29503037          if (!model_->nonLinearCost()->lookBothWays()) {
     3038#ifndef CLP_PRIMAL_SLACK_MULTIPLIER
    29513039               for (iSequence = 0; iSequence < number; iSequence++) {
    29523040                    double value = reducedCost[iSequence];
     
    29783066                    }
    29793067               }
     3068#else
     3069               // Columns
     3070               int numberColumns = model_->numberColumns();
     3071               for (iSequence = 0; iSequence < numberColumns; iSequence++) {
     3072                    double value = reducedCost[iSequence];
     3073                    ClpSimplex::Status status = model_->getStatus(iSequence);
     3074
     3075                    switch(status) {
     3076
     3077                    case ClpSimplex::basic:
     3078                    case ClpSimplex::isFixed:
     3079                         break;
     3080                    case ClpSimplex::isFree:
     3081                    case ClpSimplex::superBasic:
     3082                         if (fabs(value) > FREE_ACCEPT * tolerance) {
     3083                              // we are going to bias towards free (but only if reasonable)
     3084                              value *= FREE_BIAS;
     3085                              // store square in list
     3086                              infeasible_->quickAdd(iSequence, value * value);
     3087                         }
     3088                         break;
     3089                    case ClpSimplex::atUpperBound:
     3090                         if (value > tolerance) {
     3091                              infeasible_->quickAdd(iSequence, value * value);
     3092                         }
     3093                         break;
     3094                    case ClpSimplex::atLowerBound:
     3095                         if (value < -tolerance) {
     3096                              infeasible_->quickAdd(iSequence, value * value);
     3097                         }
     3098                    }
     3099               }
     3100               // Rows
     3101               for ( ; iSequence < number; iSequence++) {
     3102                    double value = reducedCost[iSequence];
     3103                    ClpSimplex::Status status = model_->getStatus(iSequence);
     3104
     3105                    switch(status) {
     3106
     3107                    case ClpSimplex::basic:
     3108                    case ClpSimplex::isFixed:
     3109                         break;
     3110                    case ClpSimplex::isFree:
     3111                    case ClpSimplex::superBasic:
     3112                         if (fabs(value) > FREE_ACCEPT * tolerance) {
     3113                              // we are going to bias towards free (but only if reasonable)
     3114                              value *= FREE_BIAS;
     3115                              // store square in list
     3116                              infeasible_->quickAdd(iSequence, value * value);
     3117                         }
     3118                         break;
     3119                    case ClpSimplex::atUpperBound:
     3120                         if (value > tolerance) {
     3121                              infeasible_->quickAdd(iSequence, value * value * CLP_PRIMAL_SLACK_MULTIPLIER);
     3122                         }
     3123                         break;
     3124                    case ClpSimplex::atLowerBound:
     3125                         if (value < -tolerance) {
     3126                              infeasible_->quickAdd(iSequence, value * value * CLP_PRIMAL_SLACK_MULTIPLIER);
     3127                         }
     3128                    }
     3129               }
     3130#endif
    29803131          } else {
    29813132               ClpNonLinearCost * nonLinear = model_->nonLinearCost();
     
    35323683     // Rows
    35333684     reducedCost = model_->djRegion(0);
    3534      int addSequence;
    35353685
    35363686     number = updates->getNumElements();
    35373687     index = updates->getIndices();
    35383688     updateBy = updates->denseVector();
    3539      addSequence = numberColumns;
    35403689     int j;
    35413690     double * duals = model_->dualRowSolution();
  • trunk/Clp/src/ClpSimplex.cpp

    r1729 r1732  
    18841884                    double tolerance = 10.0 * primalTolerance_;
    18851885                    double mostAway = 0.0;
    1886                     int iAway = -1;
    18871886                    for (int i = 0; i < numberColumns_; i++) {
    18881887                         // Save anyway
     
    19031902                                        if (mostAway < fabs(value - closest)) {
    19041903                                             mostAway = fabs(value - closest);
    1905                                              iAway = i;
    19061904                                        }
    19071905                                   } else {
     
    57035701     int savePerturbation = perturbation_;
    57045702     perturbation_ = 100;
    5705      int returnCode = static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
     5703     /*int returnCode =*/ static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
    57065704     if (problemStatus_ == 10) {
    57075705          //printf("Cleaning up with dual\n");
     
    57165714               if (upperOut_ > 0.0)
    57175715                    dualBound_ = 2.0 * upperOut_;
    5718                returnCode = static_cast<ClpSimplexDual *> (this)->dual(0, 1);
     5716               /*returnCode =*/ static_cast<ClpSimplexDual *> (this)->dual(0, 1);
    57195717               dualBound_ = saveBound;
    57205718          } else {
    5721                returnCode = static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
     5719                /*returnCode =*/ static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
    57225720          }
    57235721          setInitialDenseFactorization(denseFactorization);
     
    57535751     int savePerturbation = perturbation_;
    57545752     perturbation_ = 100;
    5755      int returnCode = static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
     5753     /*int returnCode =*/ static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
    57565754     if (problemStatus_ == 10) {
    57575755          //printf("Cleaning up with dual\n");
     
    57665764               if (upperOut_ > 0.0)
    57675765                    dualBound_ = 2.0 * upperOut_;
    5768                returnCode = static_cast<ClpSimplexDual *> (this)->dual(0, 1);
     5766               /*returnCode =*/ static_cast<ClpSimplexDual *> (this)->dual(0, 1);
    57695767               dualBound_ = saveBound;
    57705768          } else {
    5771                returnCode = static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
     5769                /*returnCode =*/ static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
    57725770          }
    57735771          setInitialDenseFactorization(denseFactorization);
     
    1098010978        depth 0 will be putNode-1, 1 putNode-2 etc */
    1098110979     int useDepth = putNode - 1;
    10982      bool lastFeasible = true;
    1098310980     bool justDive = (info->solverOptions_ & 32) != 0;
    1098410981     //printf("putNode %d nDepth %d\n");
     
    1104811045                    (problemStatus_ == 0 && objectiveValue()*optimizationDirection_ > bestObjective)) {
    1104911046               backtrack = true;
    11050                lastFeasible = false;
    1105111047               if (printing)
    1105211048                    printf("infeasible at depth %d\n", depth);
     
    1119011186               if (node->sequence() < 0) {
    1119111187                    // solution
    11192                     lastFeasible = false;
    1119311188                    double objectiveValue = doubleCheck();
    1119411189                    if (printing)
     
    1123811233                    backtrack = true;
    1123911234               } else {
    11240                     lastFeasible = true;
    1124111235                    //if (printing)
    1124211236                    //printf("depth %d variable %d\n",depth,node->sequence());
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.hpp

    r1725 r1732  
    10121012  { return specialOptions_;}
    10131013  void setSpecialOptions(unsigned int value);
    1014   /// Last algorithm used , 1 = primal, 2 = dual
     1014  /// Last algorithm used , 1 = primal, 2 = dual other unknown
    10151015  inline int lastAlgorithm() const
    10161016  { return lastAlgorithm_;}
     1017  /// Set last algorithm used , 1 = primal, 2 = dual other unknown
     1018  inline void setLastAlgorithm(int value)
     1019  { lastAlgorithm_ = value;}
    10171020  /// Get scaling action option
    10181021  inline int cleanupScaling() const
Note: See TracChangeset for help on using the changeset viewer.