Changeset 1926


Ignore:
Timestamp:
Mar 26, 2013 11:23:38 AM (6 years ago)
Author:
forrest
Message:

try to fix infeasibility ray,
changes as in stable (for presolve),
stuff for Cbc parameters

Location:
trunk/Clp/src
Files:
17 edited

Legend:

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

    r1924 r1926  
    21902190     );
    21912191     parameters[numberParameters++] =
     2192          CbcOrClpParam("GMI!Cuts", "Whether to use alternative Gomory cuts",
     2193                        "off", CBC_PARAM_STR_GMICUTS);
     2194     parameters[numberParameters-1].append("on");
     2195     parameters[numberParameters-1].append("root");
     2196     parameters[numberParameters-1].append("ifmove");
     2197     parameters[numberParameters-1].append("forceOn");
     2198     parameters[numberParameters-1].append("endonly");
     2199     parameters[numberParameters-1].append("long");
     2200     parameters[numberParameters-1].append("longroot");
     2201     parameters[numberParameters-1].append("longifmove");
     2202     parameters[numberParameters-1].append("forceLongOn");
     2203     parameters[numberParameters-1].append("longendonly");
     2204     parameters[numberParameters-1].setLonghelp
     2205     (
     2206          "This switches on an alternative Gomory cut generator (either at root or in entire tree) \
     2207This version is by Giacomo Nannicini and may be more robust \
     2208See branchAndCut for information on options."
     2209     );
     2210     parameters[numberParameters++] =
    21922211          CbcOrClpParam("gomory!Cuts", "Whether to use Gomory cuts",
    21932212                        "off", CBC_PARAM_STR_GOMORYCUTS);
     
    24822501          CbcOrClpParam("maxN!odes", "Maximum number of nodes to do",
    24832502                        -1, 2147483647, CBC_PARAM_INT_MAXNODES);
    2484      parameters[numberParameters-1].setLonghelp
     2503     parameters[numberParameters-1].setLonghelp 
    24852504     (
    24862505          "This is a repeatable way to limit search.  Normally using time is easier \
     
    26202639cc is number of times to do root phase.  Yet another one from the Italian idea factory \
    26212640(This time - Andrea Lodi , Matteo Fischetti , Michele Monaci , Domenico Salvagnin , \
    2622 +and Andrea Tramontani). \
    2623 +The solvers do not interact with each other.  However if extra passes are specified \
    2624 +then cuts are collected and used in later passes - so there is interaction there."
     2641and Andrea Tramontani). \
     2642The solvers do not interact with each other.  However if extra passes are specified \
     2643then cuts are collected and used in later passes - so there is interaction there."
    26252644     );
    26262645     parameters[numberParameters++] =
     
    31953214Standard setting only uses rows in tableau <=256, long uses all \
    31963215May be slow \
     3216See branchAndCut for information on options."
     3217     );
     3218     parameters[numberParameters++] =
     3219          CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
     3220                        "off", CBC_PARAM_STR_REDSPLIT2CUTS);
     3221     parameters[numberParameters-1].append("on");
     3222     parameters[numberParameters-1].append("root");
     3223     parameters[numberParameters-1].append("longOn");
     3224     parameters[numberParameters-1].append("longRoot");
     3225     parameters[numberParameters-1].setLonghelp
     3226     (
     3227          "This switches on reduce and split  cuts (either at root or in entire tree) \
     3228This version is by Giacomo Nannicini based on Francois Margot's version \
     3229Standard setting only uses rows in tableau <=256, long uses all \
    31973230See branchAndCut for information on options."
    31983231     );
  • trunk/Clp/src/ClpMain.cpp

    r1924 r1926  
    930930                                            double * bound = farkas + numberColumns;
    931931                                            double * effectiveRhs = bound + numberColumns;
    932                                              double * ray = simplex->ray();
     932                                            // get ray as user would
     933                                            double * ray = simplex->infeasibilityRay();
    933934                                            // get farkas row
    934935                                            memset(farkas,0,(2*numberColumns+numberRows)*sizeof(double));
     
    993994                                              }
    994995                                              effectiveRhs[i]=rhsValue;
     996                                              if (fabs(effectiveRhs[i])>1.0e10)
     997                                                printf("Large rhs row %d %g\n",
     998                                                       i,effectiveRhs[i]);
    995999                                            }
    9961000                                            simplex->times(-1.0,bound,effectiveRhs);
    997                                             simplex->swapRowScale(saveScale);
    998                                             simplex->swapScaledMatrix(saveMatrix);
    9991001                                            double bSum=0.0;
    10001002                                            for (int i=0;i<numberRows;i++) {
    10011003                                              bSum += effectiveRhs[i]*ray[i];
     1004                                              if (fabs(effectiveRhs[i])>1.0e10)
     1005                                                printf("Large rhs row %d %g after\n",
     1006                                                       i,effectiveRhs[i]);
    10021007                                            }
    1003                                             if (numberBad||bSum>-1.0e-4) {
     1008                                            if (numberBad||bSum>1.0e-6) {
    10041009                                              printf("Bad infeasibility ray %g  - %d bad\n",
    10051010                                                     bSum,numberBad);
     
    10081013                                              //     -bSum);
    10091014                                            }
     1015                                            delete [] ray;
    10101016                                            delete [] farkas;
     1017                                            simplex->swapRowScale(saveScale);
     1018                                            simplex->swapScaledMatrix(saveMatrix);
    10111019                                          } else {
    10121020                                            //printf("No dual ray\n");
  • trunk/Clp/src/ClpMessage.cpp

    r1878 r1926  
    4545     {CLP_POSSIBLELOOP, 23, 2, "Possible loop - %d matches (%x) after %d checks"},
    4646     {CLP_SMALLELEMENTS, 24, 1, "Matrix will be packed to eliminate %d small elements"},
     47     {CLP_DUPLICATEELEMENTS, 26, 1, "Matrix will be packed to eliminate %d duplicate elements"},
    4748     {CLP_SIMPLEX_HOUSE1, 101, 32, "dirOut %d, dirIn %d, theta %g, out %g, dj %g, alpha %g"},
    4849     {CLP_SIMPLEX_HOUSE2, 102, 4, "%d %g In: %c%d Out: %c%d%? dj ratio %g distance %g%? dj %g distance %g"},
     
    6162     {CLP_BAD_MATRIX, 6003, 1, "Matrix has %d large values, first at column %d, row %d is %g"},
    6263     {CLP_LOOP, 6004, 1, "Can't get out of loop - stopping"},
    63      {CLP_DUPLICATEELEMENTS, 26, 1, "Matrix will be packed to eliminate %d duplicate elements"},
    6464     {CLP_IMPORT_RESULT, 27, 1, "Model was imported from %s in %g seconds"},
    6565     {CLP_IMPORT_ERRORS, 3001, 1, " There were %d errors when importing model from %s"},
  • trunk/Clp/src/ClpMessage.hpp

    r1817 r1926  
    104104     CLP_PARAMETRICS_STATS,
    105105     CLP_PARAMETRICS_STATS2,
    106      CLP_GENERAL,
    107      CLP_GENERAL2,
    108      CLP_GENERAL_WARNING,
    109106#ifndef NO_FATHOM_PRINT
    110107     CLP_FATHOM_STATUS,
     
    112109     CLP_FATHOM_FINISH,
    113110#endif
     111     CLP_GENERAL,
     112     CLP_GENERAL2,
     113     CLP_GENERAL_WARNING,
    114114     CLP_DUMMY_END
    115115};
  • trunk/Clp/src/ClpModel.cpp

    r1924 r1926  
    123123     intParam_[ClpMaxNumIteration] = 2147483647;
    124124     intParam_[ClpMaxNumIterationHotStart] = 9999999;
    125      intParam_[ClpNameDiscipline] = 0;
     125     intParam_[ClpNameDiscipline] = 1;
    126126
    127127     dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
     
    27552755// Infeasibility/unbounded ray (NULL returned if none/wrong)
    27562756double *
    2757 ClpModel::infeasibilityRay() const
     2757ClpModel::infeasibilityRay(bool fullRay) const
    27582758{
    27592759     double * array = NULL;
    27602760     if (problemStatus_ == 1 && ray_) {
    2761           array = ClpCopyOfArray(ray_, numberRows_);
    2762 #if 0 //ndef CLP_NO_SWAP_SIGN
    2763           // swap signs to be consistent with norm
    2764           for (int i = 0; i < numberRows_; i++)
    2765                array[i] = -array[i];
    2766 #endif
    2767 #if 0
    2768           // clean up
    2769           double largest = 1.0e-30;
    2770           double smallest = COIN_DBL_MAX;
    2771           int i;
    2772           for (i = 0; i < numberRows_; i++) {
    2773                double value = fabs(array[i]);
    2774                smallest = CoinMin(smallest, value);
    2775                largest = CoinMax(largest, value);
    2776           }
    2777 #endif
     2761       if (!fullRay) {
     2762         array = ClpCopyOfArray(ray_, numberRows_);
     2763       } else {
     2764         array = new double [numberRows_+numberColumns_];
     2765         memcpy(array,ray_,numberRows_*sizeof(double));
     2766         memset(array+numberRows_,0,numberColumns_*sizeof(double));
     2767         transposeTimes(-1.0,array,array+numberRows_);
     2768       }
    27782769     }
    27792770     return array;
     
    28502841     defaultHandler_ = oldDefault;
    28512842     handler_ = oldHandler;
     2843}
     2844// Overrides message handler with a default one
     2845void
     2846ClpModel::setDefaultMessageHandler()
     2847{
     2848     int logLevel = handler_->logLevel();
     2849     if (defaultHandler_)
     2850          delete handler_;
     2851     defaultHandler_ = true;
     2852     handler_ = new CoinMessageHandler();
     2853     handler_->setLogLevel(logLevel);
    28522854}
    28532855// Set language
  • trunk/Clp/src/ClpModel.hpp

    r1924 r1926  
    765765     /** Infeasibility/unbounded ray (NULL returned if none/wrong)
    766766         Up to user to use delete [] on these arrays.  */
    767      double * infeasibilityRay() const;
     767     double * infeasibilityRay(bool fullRay=false) const;
    768768     double * unboundedRay() const;
    769769     /// For advanced users - no need to delete - sign not changed
     
    840840          newLanguage(language);
    841841     }
     842     /// Overrides message handler with a default one
     843     void setDefaultMessageHandler();
    842844     /// Return handler
    843845     inline CoinMessageHandler * messageHandler() const       {
  • trunk/Clp/src/ClpPackedMatrix.cpp

    r1923 r1926  
    2525#include "mkl_spblas.h"
    2626#endif
    27 
     27//#define DO_CHECK_FLAGS 1
    2828//=============================================================================
    2929#ifdef COIN_PREFETCH
     
    6969     : ClpMatrixBase(rhs)
    7070{
     71#ifdef DO_CHECK_FLAGS
     72     rhs.checkFlags(0);
     73#endif
    7174#ifndef COIN_SPARSE_MATRIX
    7275     // Guaranteed no gaps or small elements
     
    98101          columnCopy_ = NULL;
    99102     }
     103#ifdef DO_CHECK_FLAGS
     104     checkFlags(0);
     105#endif
    100106}
    101107//-------------------------------------------------------------------
     
    111117     columnCopy_ = NULL;
    112118     setType(1);
     119#ifdef DO_CHECK_FLAGS
     120     checkFlags(0);
     121#endif
    113122
    114123}
     
    128137     columnCopy_ = NULL;
    129138     setType(1);
     139#ifdef DO_CHECK_FLAGS
     140     checkFlags(0);
     141#endif
    130142
    131143}
     
    173185               columnCopy_ = NULL;
    174186          }
     187#ifdef DO_CHECK_FLAGS
     188          checkFlags(0);
     189#endif
    175190     }
    176191     return *this;
     
    191206     assert (matrix_->isColOrdered() == rhs->matrix_->isColOrdered());
    192207     matrix_->copyReuseArrays(*rhs->matrix_);
     208#ifdef DO_CHECK_FLAGS
     209     checkFlags(0);
     210#endif
    193211}
    194212/* Subset clone (without gaps).  Duplicates are allowed
     
    216234     flags_ = rhs.flags_&(~0x02) ; // no gaps
    217235     columnCopy_ = NULL;
     236#ifdef DO_CHECK_FLAGS
     237     checkFlags(0);
     238#endif
    218239}
    219240ClpPackedMatrix::ClpPackedMatrix (
     
    230251     columnCopy_ = NULL;
    231252     setType(1);
     253#ifdef DO_CHECK_FLAGS
     254     checkFlags(0);
     255#endif
    232256}
    233257
     
    244268     copy->numberActiveColumns_ = copy->matrix_->getNumCols();
    245269     copy->flags_ = flags_&(~0x02) ; // no gaps
     270#ifdef DO_CHECK_FLAGS
     271     checkFlags(0);
     272#endif
    246273     return copy;
    247274}
     
    34083435          // if scalingMethod 3 then may change
    34093436          bool extraDetails = (model->logLevel() > 2);
     3437#if 0
     3438          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     3439            if (columnUpper[iColumn] >
     3440                columnLower[iColumn] + 1.0e-12 && columnLength[iColumn])
     3441              assert(usefulColumn[iColumn]!=0);
     3442            else
     3443              assert(usefulColumn[iColumn]==0);
     3444          }
     3445#endif
    34103446          while (!finished) {
    34113447               int numberPass = 3;
     
    36543690                         //overallSmallest = CoinMin(overallSmallest,smallest*columnScale[iColumn]);
    36553691                    } else {
    3656                          assert(columnScale[iColumn] == 1.0);
     3692                      assert(columnScale[iColumn] == 1.0);
    36573693                         //columnScale[iColumn]=1.0;
    36583694                    }
     
    38773913          }
    38783914     }
     3915#ifdef DO_CHECK_FLAGS
     3916     checkFlags(0);
     3917#endif
    38793918}
    38803919/* Unpacks a column into an CoinIndexedvector
     
    40524091#else
    40534092               checkGaps();
     4093#ifdef DO_CHECK_FLAGS
     4094               checkFlags(0);
     4095#endif
    40544096#endif
    40554097#ifdef COIN_DEVELOP
     
    46444686     flags_ &= ~(4 + 8);
    46454687     checkGaps();
     4688#ifdef DO_CHECK_FLAGS
     4689     checkFlags(0);
     4690#endif
    46464691}
    46474692// makes sure active columns correct
     
    46694714#endif
    46704715     checkGaps();
     4716#ifdef DO_CHECK_FLAGS
     4717     checkFlags(0);
     4718#endif
    46714719     return 0;
    46724720}
     
    47774825     // may now have gaps
    47784826     checkGaps();
     4827#ifdef DO_CHECK_FLAGS
     4828     checkFlags(0);
     4829#endif
    47794830     matrix_->setExtraGap(0.0);
    47804831}
     
    47894840     // may now have gaps
    47904841     checkGaps();
     4842#ifdef DO_CHECK_FLAGS
     4843     checkFlags(0);
     4844#endif
    47914845     matrix_->setExtraGap(0.0);
    47924846}
     
    48084862     // may now have gaps
    48094863     checkGaps();
     4864#ifdef DO_CHECK_FLAGS
     4865     checkFlags(0);
     4866#endif
    48104867     clearCopies();
    48114868}
     
    48204877{
    48214878     matrix_->setDimensions(numrows, numcols);
     4879#ifdef DO_CHECK_FLAGS
     4880     checkFlags(0);
     4881#endif
    48224882}
    48234883/* Append a set of rows/columns to the end of the matrix. Returns number of errors
  • trunk/Clp/src/ClpPredictorCorrector.cpp

    r1726 r1926  
    211211     int saveIteration2 = -1;
    212212     bool sloppyOptimal = false;
     213     // this just to be used to exit
     214     bool sloppyOptimal2 = false;
    213215     CoinWorkDouble * savePi = NULL;
    214216     CoinWorkDouble * savePrimal = NULL;
     
    359361                         CoinMemcpyN(solution_, numberTotal, savePrimal2);
    360362                    }
    361                     if (sloppyOptimal) {
     363                    if (sloppyOptimal2) {
    362364                         // vaguely optimal
    363365                         if (maximumBoundInfeasibility_ > 1.0e-2 ||
     
    401403               }
    402404          }
     405          // See if we should be thinking about exit if diverging
     406          double relativeMultiplier = 1.0 + fabs(primalObjective_) + fabs(dualObjective_);
     407          // Quadratic coding is rubbish so be more forgiving?
     408          if (quadraticObj)
     409            relativeMultiplier *= 5.0;
     410          if (gapO < 1.0e-5 + 1.0e-9 * relativeMultiplier
     411              || complementarityGap_ < 0.1 + 1.0e-9 * relativeMultiplier)
     412              sloppyOptimal2 = true;
    403413          if ((gapO < 1.0e-6 || (gapO < 1.0e-4 && complementarityGap_ < 0.1)) && !sloppyOptimal) {
    404414               sloppyOptimal = true;
     415               sloppyOptimal2 = true;
    405416               handler_->message(CLP_BARRIER_CLOSE_TO_OPTIMAL, messages_)
    406417                         << numberIterations_ << static_cast<double>(complementarityGap_)
     
    415426                         << static_cast<double>(complementarityGap_) << "increasing"
    416427                         << CoinMessageEol;
    417                if (saveIteration >= 0 && sloppyOptimal) {
     428               if (saveIteration >= 0 && sloppyOptimal2) {
    418429                    handler_->message(CLP_BARRIER_EXIT2, messages_)
    419430                              << saveIteration
  • trunk/Clp/src/ClpPresolve.cpp

    r1924 r1926  
    994994          if (duprow) {
    995995            possibleSkip;
    996             int nTightened=tightenDoubletons2(prob);
    997             if (nTightened)
    998                PRESOLVE_DETAIL_PRINT(printf("%d doubletons tightened\n",
    999                                             nTightened));
     996            if (doTwoxTwo()) {
     997              int nTightened=tightenDoubletons2(prob);
     998              if (nTightened)
     999                PRESOLVE_DETAIL_PRINT(printf("%d doubletons tightened\n",
     1000                                             nTightened));
     1001            }
    10001002            paction_ = duprow_action::presolve(prob, paction_);
    10011003            printProgress('D',0);
  • trunk/Clp/src/ClpPresolve.hpp

    r1878 r1926  
    170170     /// Whether we want to do twoxtwo part of presolve
    171171     inline bool doTwoxTwo() const {
    172           return (presolveActions_ & 2048) == 0;
     172          return (presolveActions_ & 2048) != 0;
    173173     }
    174174     inline void setDoTwoxtwo(bool doTwoxTwo) {
    175           if (doTwoxTwo) presolveActions_  &= ~2048;
     175          if (!doTwoxTwo) presolveActions_  &= ~2048;
    176176          else presolveActions_ |= 2048;
    177177     }
  • trunk/Clp/src/ClpSimplex.cpp

    r1924 r1926  
    54095409               && sumDualInfeasibilities_ < 1000.0 * dualTolerance_ && perturbation_ >= 100)
    54105410          problemStatus_ = 0; // ignore
     5411     if (problemStatus_==1&&((specialOptions_&(1024 | 4096)) == 0 || (specialOptions_ & 32) != 0)
     5412         &&numberFake_) {
     5413       problemStatus_ = 10; // clean up in primal as fake bounds
     5414     }
    54115415     if (problemStatus_ == 10) {
    54125416          //printf("Cleaning up with primal\n");
     
    87108714     otherModel.directionOut_ = directionOut_;
    87118715     otherModel.pivotRow_ = pivotRow_;
     8716     otherModel.algorithm_ = algorithm_;
    87128717     otherModel.sumDualInfeasibilities_ = sumDualInfeasibilities_;
    87138718     otherModel.numberDualInfeasibilities_ = numberDualInfeasibilities_;
     
    1006210067     objectiveValue -= dblParam_[ClpObjOffset];
    1006310068     return objectiveValue;
     10069}
     10070// Infeasibility/unbounded ray (NULL returned if none/wrong)
     10071double *
     10072ClpSimplex::infeasibilityRay(bool fullRay) const
     10073{
     10074     double * array = NULL;
     10075     if (problemStatus_ == 1 && ray_) {
     10076       if (!fullRay) {
     10077         array = ClpCopyOfArray(ray_, numberRows_);
     10078       } else {
     10079         array = new double [numberRows_+numberColumns_];
     10080         memcpy(array,ray_,numberRows_*sizeof(double));
     10081         memset(array+numberRows_,0,numberColumns_*sizeof(double));
     10082         transposeTimes(-1.0,array,array+numberRows_);
     10083       }
     10084#ifdef PRINT_RAY_METHOD
     10085       printf("Infeasibility ray obtained by algorithm %s - direction out %d\n",algorithm_>0 ?
     10086              "primal" : "dual",directionOut_);
     10087#endif
     10088     }
     10089     return array;
    1006410090}
    1006510091// If user left factorization frequency then compute
  • trunk/Clp/src/ClpSimplex.hpp

    r1924 r1926  
    13021302     /// Compute minimization objective value from internal solution without perturbation
    13031303     double computeInternalObjectiveValue();
     1304     /** Infeasibility/unbounded ray (NULL returned if none/wrong)
     1305         Up to user to use delete [] on these arrays.  */
     1306     double * infeasibilityRay(bool fullRay=false) const;
    13041307     /** Number of extra rows.  These are ones which will be dynamically created
    13051308         each iteration.  This is for GUB but may have other uses.
  • trunk/Clp/src/ClpSimplexDual.cpp

    r1924 r1926  
    15941594                    solution_[sequenceOut_] = valueOut_;
    15951595                    int whatNext = housekeeping(objectiveChange);
     1596#if 0
     1597                    for (int i=0;i<numberRows_+numberColumns_;i++) {
     1598                      if (getStatus(i)==atLowerBound) {
     1599                        assert (dj_[i]>-1.0e-5);
     1600                        assert (solution_[i]<=lower_[i]+1.0e-5);
     1601                      } else if (getStatus(i)==atUpperBound) {
     1602                        assert (dj_[i]<1.0e-5);
     1603                        assert (solution_[i]>=upper_[i]-1.0e-5);
     1604                      }
     1605                    }
     1606#endif
    15961607#ifdef CLP_REPORT_PROGRESS
    15971608                    if (ixxxxxx > ixxyyyy - 5) {
     
    17421753#endif
    17431754                    // no incoming column is valid
     1755                    spareIntArray_[3]=pivotRow_;
    17441756                    pivotRow_ = -1;
    17451757#ifdef CLP_DEBUG
     
    17531765                         if ((specialOptions_&(1024 | 4096)) == 0 || (specialOptions_ & 32) != 0) {
    17541766                              // create ray anyway
     1767#ifdef PRINT_RAY_METHOD
     1768                           printf("Dual creating infeasibility ray direction out %d - pivRow %d seqOut %d lower %g,val %g,upper %g\n",
     1769                                  directionOut_,spareIntArray_[3],sequenceOut_,lowerOut_,valueOut_,upperOut_);
     1770#endif
    17551771                              ray_ = new double [ numberRows_];
    17561772                              rowArray_[0]->expand(); // in case packed
    1757                               // swap sign NO
    17581773                              const double * array = rowArray_[0]->denseVector();
    17591774                              for (int i=0;i<numberRows_;i++)
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r1924 r1926  
    13011301                              for (int i=0;i<numberRows_;i++)
    13021302                                ray_[i] = -dual_[i];
     1303#ifdef PRINT_RAY_METHOD
     1304                              printf("Primal creating infeasibility ray\n");
     1305#endif
    13031306                              // and get feasible duals
    13041307                              infeasibilityCost_ = 0.0;
  • trunk/Clp/src/Clp_C_Interface.cpp

    r1924 r1926  
    649649          array = static_cast<double*>(malloc(numberRows*sizeof(double)));
    650650          memcpy(array,ray,numberRows*sizeof(double));
    651 #if 0 //ndef CLP_NO_SWAP_SIGN
    652           // swap signs to be consistent with norm
    653           for (int i = 0; i < numberRows; i++)
    654                array[i] = -array[i];
     651#ifdef PRINT_RAY_METHOD
     652          printf("Infeasibility ray obtained by algorithm %s\n",model->model_->algorithm()>0 ?
     653              "primal" : "dual");
    655654#endif
    656655     }
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r1924 r1926  
    133133  int saveMessageLevel2 = messageLevel;
    134134  // Set message handler
    135   solver->passInMessageHandler(handler_);
     135  if (!defaultHandler_)
     136    solver->passInMessageHandler(handler_);
    136137  // But keep log level
    137138  solver->messageHandler()->setLogLevel(saveMessageLevel);
     
    778779  }
    779780  modelPtr_->whatsChanged_ |= 0x30000;
     781#if 0
     782  // delete scaled matrix and rowcopy for safety
     783  delete modelPtr_->scaledMatrix_;
     784  modelPtr_->scaledMatrix_=NULL;
     785  delete modelPtr_->rowCopy_;
     786  modelPtr_->rowCopy_=NULL;
     787#endif
    780788  //std::cout<<time1<<" seconds - total "<<totalTime<<std::endl;
    781789  delete pinfo;
     
    919927  int messageLevel=messageHandler()->logLevel();
    920928  bool oldDefault;
    921   CoinMessageHandler * saveHandler = modelPtr_->pushMessageHandler(handler_,oldDefault);
     929  CoinMessageHandler * saveHandler = NULL;
     930  if (!defaultHandler_)
     931    saveHandler = modelPtr_->pushMessageHandler(handler_,oldDefault);
    922932  //printf("basis before dual\n");
    923933  //basis_.print();
     
    12571267  //printf("basis after dual\n");
    12581268  //basis_.print();
    1259   modelPtr_->popMessageHandler(saveHandler,oldDefault);
     1269  if (!defaultHandler_)
     1270    modelPtr_->popMessageHandler(saveHandler,oldDefault);
    12601271  modelPtr_->messageHandler()->setLogLevel(saveMessageLevel);
    12611272  if (saveSolveType==2) {
     
    29042915                                                        bool fullRay) const
    29052916{
    2906   if (fullRay == true) {
    2907     throw CoinError("Full dual rays not yet implemented.","getDualRays",
    2908                     "OsiClpSolverInterface");
    2909   }
    2910   return std::vector<double*>(1, modelPtr_->infeasibilityRay());
     2917  return std::vector<double*>(1, modelPtr_->infeasibilityRay(fullRay));
    29112918}
    29122919//------------------------------------------------------------------
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.hpp

    r1828 r1926  
    177177  */
    178178  virtual void enableSimplexInterface(bool doingPrimal);
     179  /// Copy across enabled stuff from one solver to another
     180  void copyEnabledSuff(OsiClpSolverInterface & rhs);
    179181 
    180182  /*! \brief Undo setting changes made by #enableSimplexInterface */
    181183  virtual void disableSimplexInterface();
     184  /// Copy across enabled stuff from one solver to another
     185  void copyEnabledStuff(ClpSimplex & rhs);
    182186
    183187  /** Perform a pivot by substituting a colIn for colOut in the basis.
Note: See TracChangeset for help on using the changeset viewer.