Changeset 1453 for trunk/Clp


Ignore:
Timestamp:
Oct 28, 2009 11:01:57 AM (10 years ago)
Author:
forrest
Message:

second try at changes for seg fault and idiot

Location:
trunk/Clp/src
Files:
11 edited

Legend:

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

    r1440 r1453  
    14621462  parameters[numberParameters-1].append("forceOn");
    14631463  parameters[numberParameters-1].append("onglobal");
    1464   parameters[numberParameters-1].append("rootglobal");
    14651464  parameters[numberParameters-1].setLonghelp
    14661465    (
     
    19491948                  -1,COIN_INT_MAX,EXTRA4,0);
    19501949  parameters[numberParameters-1].setIntValue(-1);
     1950  parameters[numberParameters-1].setLonghelp
     1951    (
     1952     "This switches on yet more special options!! \
     1953The bottom digit is a strategy when to used shadow price stuff e.g. 3 \
     1954means use until a solution is found.  The next two digits say what sort \
     1955of dual information to use.  After that it goes back to powers of 2 so -\n\
     1956\t1000 - switches on experimental hotstart\n\
     1957\t2,4,6000 - switches on experimental methods of stopping cuts\n\
     1958\t8000 - increase minimum drop gradually\n\
     1959\t16000 - switches on alternate gomory criterion"
     1960     );
    19511961#endif
    19521962#ifdef COIN_HAS_CLP
     
    19952005    parameters[numberParameters-1].append("ifmove");
    19962006    parameters[numberParameters-1].append("forceOn");
    1997   parameters[numberParameters-1].append("onglobal");
    1998   parameters[numberParameters-1].append("rootglobal");
     2007    parameters[numberParameters-1].append("onglobal");
    19992008    parameters[numberParameters-1].setLonghelp
    20002009    (
     
    20422051  parameters[numberParameters-1].append("forceOn");
    20432052  parameters[numberParameters-1].append("onglobal");
    2044   parameters[numberParameters-1].append("rootglobal");
     2053  parameters[numberParameters-1].append("forceandglobal");
    20452054  parameters[numberParameters-1].append("forceLongOn");
    20462055  parameters[numberParameters-1].append("long");
     
    21052114  parameters[numberParameters++]=
    21062115    CbcOrClpParam("idiot!Crash","Whether to try idiot crash",
    2107                   -1,999999,IDIOT);
     2116                  -1,99999999,IDIOT);
    21082117  parameters[numberParameters-1].setLonghelp
    21092118    (
     
    21862195  parameters[numberParameters-1].append("forceOn");
    21872196  parameters[numberParameters-1].append("onglobal");
    2188   parameters[numberParameters-1].append("rootglobal");
     2197  parameters[numberParameters-1].append("forceandglobal");
    21892198  parameters[numberParameters-1].setLonghelp
    21902199    (
     
    23032312  parameters[numberParameters-1].append("forceOn");
    23042313  parameters[numberParameters-1].append("onglobal");
    2305   parameters[numberParameters-1].append("rootglobal");
    23062314  parameters[numberParameters-1].setLonghelp
    23072315    (
     
    23282336    (
    23292337     "Yet more ideas for Feasibility Pump \n\
     2338\t/100000 == 1 use box constraints and original obj in cleanup\n\
    23302339\t/1000 == 1 Pump will run twice if no solution found\n\
    23312340\t/1000 == 2 Pump will only run after root cuts if no solution found\n\
     
    27112720  parameters[numberParameters-1].append("forceOn");
    27122721  parameters[numberParameters-1].append("onglobal");
    2713   parameters[numberParameters-1].append("rootglobal");
     2722  parameters[numberParameters-1].append("forceonglobal");
    27142723  parameters[numberParameters-1].append("forceOnBut");
    27152724  parameters[numberParameters-1].append("forceOnStrong");
     
    31753184  parameters[numberParameters-1].append("forceOn");
    31763185  parameters[numberParameters-1].append("onglobal");
    3177   parameters[numberParameters-1].append("rootglobal");
     3186  parameters[numberParameters-1].append("forceandglobal");
    31783187  parameters[numberParameters-1].append("forceLongOn");
    31793188  parameters[numberParameters-1].setLonghelp
     
    32083217It is possible you can get same effect by using example driver4.cpp."
    32093218     );
     3219  parameters[numberParameters++]=
     3220      CbcOrClpParam("Vnd!VariableNeighborhoodSearch","Whether to try Variable Neighborhood Search",
     3221                    "off",VND);
     3222    parameters[numberParameters-1].append("on");
     3223    parameters[numberParameters-1].append("both");
     3224    parameters[numberParameters-1].append("before");
     3225    parameters[numberParameters-1].append("intree");
     3226  parameters[numberParameters-1].setLonghelp
     3227    (
     3228     "This switches on variable neighborhood Search. \
     3229Doh option does heuristic before preprocessing"     );
    32103230#endif
    32113231  parameters[numberParameters++]=
     
    32343254     );
    32353255  parameters[numberParameters-1].setIntValue(-1);
    3236 #if 0
     3256#ifdef ZERO_HALF_CUTS
    32373257  parameters[numberParameters++]=
    32383258    CbcOrClpParam("zero!HalfCuts","Whether to use zero half cuts",
     
    32433263  parameters[numberParameters-1].append("forceOn");
    32443264  parameters[numberParameters-1].append("onglobal");
    3245   parameters[numberParameters-1].append("rootglobal");
    32463265  parameters[numberParameters-1].setLonghelp
    32473266    (
  • trunk/Clp/src/CbcOrClpParam.hpp

    r1440 r1453  
    8585    LANDPCUTS,RINS,RESIDCUTS,RENS,DIVINGS,DIVINGC,DIVINGF,DIVINGG,DIVINGL,
    8686    DIVINGP,DIVINGV,DINS,PIVOTANDFIX,RANDROUND,NAIVE,ZEROHALFCUTS,CPX,
    87     CROSSOVER2,PIVOTANDCOMPLEMENT,
     87    CROSSOVER2,PIVOTANDCOMPLEMENT,VND,
    8888   
    8989    DIRECTORY=301,DIRSAMPLE,DIRNETLIB,DIRMIPLIB,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,EITHERSIMPLEX,
  • trunk/Clp/src/ClpPrimalColumnPivot.hpp

    r1370 r1453  
    101101  /// Clone
    102102  virtual ClpPrimalColumnPivot * clone(bool copyData = true) const = 0;
    103  
     103
    104104  //@}
    105105
     
    109109  inline ClpSimplex * model()
    110110  { return model_;}
     111  /// Sets model
     112  inline void setModel(ClpSimplex * model)
     113  { model_=model;}
    111114 
    112115  /// Returns type (above 63 is extra information)
  • trunk/Clp/src/ClpPrimalColumnSteepest.cpp

    r1403 r1453  
    4040  type_=2+64*mode;
    4141}
    42 
    4342//-------------------------------------------------------------------
    4443// Copy constructor
     
    6766      assert(model_);
    6867      int number = model_->numberRows()+model_->numberColumns();
     68      assert (number == rhs.model_->numberRows()+rhs.model_->numberColumns());
    6969      weights_= new double[number];
    70       ClpDisjointCopyN(rhs.weights_,number,weights_);
     70      CoinMemcpyN(rhs.weights_,number,weights_);
    7171      savedWeights_= new double[number];
    72       ClpDisjointCopyN(rhs.savedWeights_,number,savedWeights_);
     72      CoinMemcpyN(rhs.savedWeights_,number,savedWeights_);
    7373      if (mode_!=1) {
    7474        reference_ = CoinCopyOfArray(rhs.reference_,(number+31)>>5);
     
    137137      assert(model_);
    138138      int number = model_->numberRows()+model_->numberColumns();
     139      assert (number == rhs.model_->numberRows()+rhs.model_->numberColumns());
    139140      weights_= new double[number];
    140       ClpDisjointCopyN(rhs.weights_,number,weights_);
     141      CoinMemcpyN(rhs.weights_,number,weights_);
    141142      savedWeights_= new double[number];
    142       ClpDisjointCopyN(rhs.savedWeights_,number,savedWeights_);
     143      CoinMemcpyN(rhs.savedWeights_,number,savedWeights_);
    143144      if (mode_!=1) {
    144145        reference_ = CoinCopyOfArray(rhs.reference_,(number+31)>>5);
  • trunk/Clp/src/ClpPrimalColumnSteepest.hpp

    r1402 r1453  
    153153 
    154154  /// Copy constructor
    155   ClpPrimalColumnSteepest(const ClpPrimalColumnSteepest &);
     155  ClpPrimalColumnSteepest(const ClpPrimalColumnSteepest & rhs);
    156156 
    157157  /// Assignment operator
  • trunk/Clp/src/ClpSimplex.cpp

    r1449 r1453  
    23482348  numberPrimalInfeasibilities_ = rhs.numberPrimalInfeasibilities_;
    23492349  dualRowPivot_ = rhs.dualRowPivot_->clone(true);
     2350  dualRowPivot_->setModel(this);
    23502351  primalColumnPivot_ = rhs.primalColumnPivot_->clone(true);
     2352  primalColumnPivot_->setModel(this);
    23512353  numberTimesOptimal_ = rhs.numberTimesOptimal_;
    23522354  disasterArea_ = NULL;
     
    44204422  delete dualRowPivot_;
    44214423  dualRowPivot_ = choice.clone(true);
     4424  dualRowPivot_->setModel(this);
    44224425}
    44234426// Sets row pivot choice algorithm in dual
     
    44274430  delete primalColumnPivot_;
    44284431  primalColumnPivot_ = choice.clone(true);
     4432  primalColumnPivot_->setModel(this);
    44294433}
    44304434void
     
    45844588
    45854589  int iRow, iColumn;
     4590  // If wanted compute a reasonable dualBound_
     4591  if (factor==COIN_DBL_MAX) {
     4592    factor=0.0;
     4593    if (dualBound_==1.0e10) {
     4594      // get largest scaled away from bound
     4595      double largest=1.0e-12;
     4596      double largestScaled=1.0e-12;
     4597      int iRow;
     4598      for (iRow=0;iRow<numberRows_;iRow++) {
     4599        double value = rowActivity_[iRow];
     4600        double above = value-rowLower_[iRow];
     4601        double below = rowUpper_[iRow]-value;
     4602        if (above<1.0e12) {
     4603          largest = CoinMax(largest,above);
     4604        }
     4605        if (below<1.0e12) {
     4606          largest = CoinMax(largest,below);
     4607        }
     4608        if (rowScale_) {
     4609          double multiplier = rowScale_[iRow];
     4610          above *= multiplier;
     4611          below *= multiplier;
     4612        }
     4613        if (above<1.0e12) {
     4614          largestScaled = CoinMax(largestScaled,above);
     4615        }
     4616        if (below<1.0e12) {
     4617          largestScaled = CoinMax(largestScaled,below);
     4618        }
     4619      }
     4620     
     4621      int iColumn;
     4622      for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     4623        double value = columnActivity_[iColumn];
     4624        double above = value-columnLower_[iColumn];
     4625        double below = columnUpper_[iColumn]-value;
     4626        if (above<1.0e12) {
     4627          largest = CoinMax(largest,above);
     4628        }
     4629        if (below<1.0e12) {
     4630          largest = CoinMax(largest,below);
     4631        }
     4632        if (columnScale_) {
     4633          double multiplier = 1.0/columnScale_[iColumn];
     4634          above *= multiplier;
     4635          below *= multiplier;
     4636        }
     4637        if (above<1.0e12) {
     4638          largestScaled = CoinMax(largestScaled,above);
     4639        }
     4640        if (below<1.0e12) {
     4641          largestScaled = CoinMax(largestScaled,below);
     4642        }
     4643      }
     4644      std::cout<<"Largest (scaled) away from bound "<<largestScaled
     4645               <<" unscaled "<<largest<<std::endl;
     4646      dualBound_=CoinMax(1.0001e7,CoinMin(100.0*largest,1.00001e10));
     4647    }
     4648  }
    45864649
    45874650  // If wanted - tighten column bounds using solution
     
    54835546    }
    54845547  }
     5548  //firstFree_=-1;
    54855549  /*  Note use of "down casting".  The only class the user sees is ClpSimplex.
    54865550      Classes ClpSimplexDual, ClpSimplexPrimal, (ClpSimplexNonlinear)
     
    60286092  delete dualRowPivot_;
    60296093  dualRowPivot_ = otherModel.dualRowPivot_->clone(true);
     6094  dualRowPivot_->setModel(this);
    60306095  delete primalColumnPivot_;
    60316096  primalColumnPivot_ = otherModel.primalColumnPivot_->clone(true);
     6097  primalColumnPivot_->setModel(this);
    60326098  perturbation_ = otherModel.perturbation_;
    60336099  moreSpecialOptions_ = otherModel.moreSpecialOptions_;
     
    80468112          // solution will be done again - skip if absolutely sure
    80478113          if ((specialOptions_&512)==0||numberThrownOut==numberRows_+1) {
     8114            //int saveFirstFree=firstFree_;
    80488115            numberThrownOut = gutsOfSolution(  NULL,NULL,
    80498116                                               ifValuesPass!=0);
     8117            //firstFree_=saveFirstFree;
    80508118            if (largestPrimalError_>10.0&&!ifValuesPass&&!numberThrownOut) {
    80518119              // throw out up to 1000 structurals
  • trunk/Clp/src/ClpSimplex.hpp

    r1428 r1453  
    586586      indicated bound and if any values changed (or ==2)  basic values re-computed.
    587587  */
    588   void checkSolution(int setToBounds=false);
     588  void checkSolution(int setToBounds=0);
    589589  /** Just check solution (for internal use) - sets sum of
    590590      infeasibilities etc. */
  • trunk/Clp/src/ClpSimplexOther.cpp

    r1429 r1453  
    5858    assert (integerType_);
    5959  dualTolerance_ = dblParam_[ClpDualTolerance];
     60  double * arrayX = rowArray_[0]->denseVector();
    6061  for ( i=0;i<numberCheck;i++) {
    6162    rowArray_[0]->clear();
     
    102103        checkDualRatios(rowArray_[0],columnArray_[0],costIncrease,sequenceIncrease,alphaIncrease,
    103104                    costDecrease,sequenceDecrease,alphaDecrease);
    104         if (valueIncrease) {
    105           if (sequenceIncrease>=0)
    106             valueIncrease[i] = primalRanging1(sequenceIncrease,iSequence);
    107           if (sequenceDecrease>=0)
    108             valueDecrease[i] = primalRanging1(sequenceDecrease,iSequence);
    109         }
    110         if (inCBC) {
     105        if (!inCBC) {
     106          if (valueIncrease) {
     107            if (sequenceIncrease>=0)
     108              valueIncrease[i] = primalRanging1(sequenceIncrease,iSequence);
     109            if (sequenceDecrease>=0)
     110              valueDecrease[i] = primalRanging1(sequenceDecrease,iSequence);
     111          }
     112        } else {
     113          int number = rowArray_[0]->getNumElements();
     114          double scale2=0.0;
     115          int j;
     116          for (j=0;j<number;j++) {
     117            scale2+=arrayX[j]*arrayX[j];
     118          }
     119          scale2 = 1.0/sqrt(scale2);
     120          valueIncrease[i]=scale2;
    111121          if (sequenceIncrease>=0) {
    112122            double djValue = dj_[sequenceIncrease];
     
    141151            }
    142152          }
     153          costIncrease *= scale2;
     154          costDecrease *= scale2;
    143155        }
    144156      }
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r1428 r1453  
    14561456  // make sure first free monotonic
    14571457  if (firstFree_>=0&&saveFirstFree>=0) {
    1458     firstFree_=saveFirstFree;
     1458    firstFree_= (numberIterations_) ? saveFirstFree : -1;
    14591459    nextSuperBasic(1,NULL);
    14601460  }
     
    31523152*/
    31533153int
    3154 ClpSimplexPrimal::nextSuperBasic(int superBasicType,CoinIndexedVector * columnArray)
     3154ClpSimplexPrimal::nextSuperBasic(int superBasicType,
     3155                                 CoinIndexedVector * columnArray)
    31553156{
    3156   if (firstFree_>=0&&superBasicType) {
    3157     int returnValue=-1;
    3158     bool finished=false;
    3159     while (!finished) {
    3160       returnValue=firstFree_;
    3161       int iColumn=firstFree_+1;
    3162       if (superBasicType>1) {
    3163         if (superBasicType>2) {
    3164           // Initialize list
    3165           // Wild guess that lower bound more natural than upper
    3166           int number=0;
    3167           double * work=columnArray->denseVector();
    3168           int * which=columnArray->getIndices();
    3169           for (iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
    3170             if (!flagged(iColumn)) {
    3171               if (getStatus(iColumn)==superBasic) {
    3172                 if (fabs(solution_[iColumn]-lower_[iColumn])<=primalTolerance_) {
    3173                   solution_[iColumn]=lower_[iColumn];
    3174                   setStatus(iColumn,atLowerBound);
    3175                 } else if (fabs(solution_[iColumn]-upper_[iColumn])
    3176                            <=primalTolerance_) {
    3177                   solution_[iColumn]=upper_[iColumn];
    3178                   setStatus(iColumn,atUpperBound);
    3179                 } else if (lower_[iColumn]<-1.0e20&&upper_[iColumn]>1.0e20) {
    3180                   setStatus(iColumn,isFree);
    3181                   break;
    3182                 } else if (!flagged(iColumn)) {
    3183                   // put ones near bounds at end after sorting
    3184                   work[number]= - CoinMin(0.1*(solution_[iColumn]-lower_[iColumn]),
    3185                                       upper_[iColumn]-solution_[iColumn]);
    3186                   which[number++] = iColumn;
    3187                 }
    3188               }
    3189             }
    3190           }
    3191           CoinSort_2(work,work+number,which);
    3192           columnArray->setNumElements(number);
    3193           CoinZeroN(work,number);
    3194         }
     3157  int returnValue=-1;
     3158  bool finished=false;
     3159  while (!finished) {
     3160    returnValue=firstFree_;
     3161    int iColumn=firstFree_+1;
     3162    if (superBasicType>1) {
     3163      if (superBasicType>2) {
     3164        // Initialize list
     3165        // Wild guess that lower bound more natural than upper
     3166        int number=0;
     3167        double * work=columnArray->denseVector();
    31953168        int * which=columnArray->getIndices();
    3196         int number = columnArray->getNumElements();
    3197         if (!number) {
    3198           // finished
    3199           iColumn = numberRows_+numberColumns_;
    3200           returnValue=-1;
    3201         } else {
    3202           number--;
    3203           returnValue=which[number];
    3204           iColumn=returnValue;
    3205           columnArray->setNumElements(number);
    3206         }     
    3207       } else {
    3208         for (;iColumn<numberRows_+numberColumns_;iColumn++) {
     3169        for (iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
    32093170          if (!flagged(iColumn)) {
    32103171            if (getStatus(iColumn)==superBasic) {
     
    32193180                setStatus(iColumn,isFree);
    32203181                break;
    3221               } else {
    3222                 break;
     3182              } else if (!flagged(iColumn)) {
     3183                // put ones near bounds at end after sorting
     3184                work[number]= - CoinMin(0.1*(solution_[iColumn]-lower_[iColumn]),
     3185                                        upper_[iColumn]-solution_[iColumn]);
     3186                which[number++] = iColumn;
    32233187              }
    32243188            }
    32253189          }
    32263190        }
    3227       }
    3228       firstFree_ = iColumn;
    3229       finished=true;
    3230       if (firstFree_==numberRows_+numberColumns_)
    3231         firstFree_=-1;
    3232       if (returnValue>=0&&getStatus(returnValue)!=superBasic&&getStatus(returnValue)!=isFree)
    3233         finished=false; // somehow picked up odd one
    3234     }
    3235     return returnValue;
    3236   } else {
    3237     return -1;
    3238   }
     3191        CoinSort_2(work,work+number,which);
     3192        columnArray->setNumElements(number);
     3193        CoinZeroN(work,number);
     3194      }
     3195      int * which=columnArray->getIndices();
     3196      int number = columnArray->getNumElements();
     3197      if (!number) {
     3198        // finished
     3199        iColumn = numberRows_+numberColumns_;
     3200        returnValue=-1;
     3201      } else {
     3202        number--;
     3203        returnValue=which[number];
     3204        iColumn=returnValue;
     3205        columnArray->setNumElements(number);
     3206      }     
     3207    } else {
     3208      for (;iColumn<numberRows_+numberColumns_;iColumn++) {
     3209        if (!flagged(iColumn)) {
     3210          if (getStatus(iColumn)==superBasic) {
     3211            if (fabs(solution_[iColumn]-lower_[iColumn])<=primalTolerance_) {
     3212              solution_[iColumn]=lower_[iColumn];
     3213              setStatus(iColumn,atLowerBound);
     3214            } else if (fabs(solution_[iColumn]-upper_[iColumn])
     3215                       <=primalTolerance_) {
     3216              solution_[iColumn]=upper_[iColumn];
     3217              setStatus(iColumn,atUpperBound);
     3218            } else if (lower_[iColumn]<-1.0e20&&upper_[iColumn]>1.0e20) {
     3219              setStatus(iColumn,isFree);
     3220              break;
     3221            } else {
     3222              break;
     3223            }
     3224          }
     3225        }
     3226      }
     3227    }
     3228    firstFree_ = iColumn;
     3229    finished=true;
     3230    if (firstFree_==numberRows_+numberColumns_)
     3231      firstFree_=-1;
     3232    if (returnValue>=0&&getStatus(returnValue)!=superBasic&&getStatus(returnValue)!=isFree)
     3233      finished=false; // somehow picked up odd one
     3234  }
     3235  return returnValue;
    32393236}
    32403237void
  • trunk/Clp/src/ClpSolve.cpp

    r1439 r1453  
    12291229      if (doIdiot>0) {
    12301230        // pick up number passes
    1231         nPasses=options.getExtraInfo(1);
     1231        nPasses=options.getExtraInfo(1)%1000000;
    12321232        if (nPasses>70) {
    12331233          info.setStartingWeight(1.0e3);
    12341234          info.setReduceIterations(6);
    12351235          if (nPasses>=5000) {
    1236             int k= nPasses&100;
     1236            int k= nPasses%100;
    12371237            nPasses /= 100;
    12381238            info.setReduceIterations(3);
     
    12571257        }
    12581258      }
     1259      if (options.getExtraInfo(1)>1000000)
     1260        nPasses += 1000000;
    12591261      if (nPasses) {
    12601262        doCrash=0;
     
    13261328    }
    13271329#endif
    1328     if (dynamic_cast< ClpPackedMatrix*>(matrix_)) {
    1329       // See if original wanted vector
    1330       ClpPackedMatrix * clpMatrixO = dynamic_cast< ClpPackedMatrix*>(matrix_);
    1331       ClpMatrixBase * matrix = model2->clpMatrix();
    1332       if (dynamic_cast< ClpPackedMatrix*>(matrix)&&clpMatrixO->wantsSpecialColumnCopy()) {
    1333         ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
    1334         clpMatrix->makeSpecialColumnCopy();
    1335         //model2->setSpecialOptions(model2->specialOptions()|256); // to say no row copy for comparisons
    1336         model2->primal(primalStartup);
    1337         clpMatrix->releaseSpecialColumnCopy();
     1330    if (options.getSpecialOption(1)!=2||
     1331        options.getExtraInfo(1)<1000000) {
     1332      if (dynamic_cast< ClpPackedMatrix*>(matrix_)) {
     1333        // See if original wanted vector
     1334        ClpPackedMatrix * clpMatrixO = dynamic_cast< ClpPackedMatrix*>(matrix_);
     1335        ClpMatrixBase * matrix = model2->clpMatrix();
     1336        if (dynamic_cast< ClpPackedMatrix*>(matrix)&&clpMatrixO->wantsSpecialColumnCopy()) {
     1337          ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
     1338          clpMatrix->makeSpecialColumnCopy();
     1339          //model2->setSpecialOptions(model2->specialOptions()|256); // to say no row copy for comparisons
     1340          model2->primal(primalStartup);
     1341          clpMatrix->releaseSpecialColumnCopy();
     1342        } else {
     1343          model2->primal(primalStartup);
     1344        }
    13381345      } else {
    13391346        model2->primal(primalStartup);
    13401347      }
    1341     } else {
    1342       model2->primal(primalStartup);
    13431348    }
    13441349    time2 = CoinCpuTime();
     
    25322537    objective_=savedObjective;
    25332538  }
     2539  if (options.getSpecialOption(1)==2&&
     2540        options.getExtraInfo(1)>1000000) {
     2541    ClpObjective * savedObjective=objective_;
     2542    // make up zero objective
     2543    double * obj = new double[numberColumns_];
     2544    for (int i=0;i<numberColumns_;i++)
     2545      obj[i]=0.0;
     2546    objective_= new ClpLinearObjective(obj,numberColumns_);
     2547    delete [] obj;
     2548    primal(1);
     2549    delete objective_;
     2550    objective_=savedObjective;
     2551    finalStatus=status();
     2552  }
    25342553  return finalStatus;
    25352554}
  • trunk/Clp/src/Idiot.cpp

    r1439 r1453  
    342342    maxIts_=2;
    343343  if (numberPass<=0)
    344     // Cast to double to avoid VACPP complaining
    345344    majorIterations_=static_cast<int>(2+log10(static_cast<double>(numberColumns+1)));
    346345  else
     
    368367    crossOver(16+1);
    369368  else
    370     crossOver(3);
     369    crossOver(majorIterations_<1000000 ? 3 : 2);
    371370#endif
    372371}
     
    392391  int logLevel=logLevel_;
    393392  int saveMajorIterations = majorIterations_;
     393  majorIterations_ = majorIterations_%1000000;
    394394  if (handler) {
    395395    if (handler->logLevel()>0&&handler->logLevel()<3)
     
    12041204  double * saveRowUpper = NULL;
    12051205  double * saveRowLower = NULL;
    1206   bool allowInfeasible = (strategy_&8192)!=0;
     1206  bool allowInfeasible = ((strategy_&8192)!=0)||(majorIterations_>1000000);
    12071207  if (addAll<3) {
    12081208    saveUpper = new double [ncols];
     
    15741574    maxmin=1.0;
    15751575  }
     1576  bool justValuesPass=majorIterations_>1000000;
    15761577  if (slackStart>=0) {
    15771578    for (i=0;i<nrows;i++) {
     
    16691670        double * rowupper = model_->rowUpper();
    16701671        double * rowlower= model_->rowLower();
     1672        saveRowUpper = CoinCopyOfArray(rowupper,nrows);
     1673        saveRowLower = CoinCopyOfArray(rowlower,nrows);
    16711674        double sum = 0.0;
    16721675        for (i=0;i<nrows;i++) {
     
    16911694        //#define TWO_GOES
    16921695#ifndef TWO_GOES
    1693         model_->primal(1);
     1696        model_->primal(justValuesPass ? 2 : 1);
    16941697#else
    16951698        model_->primal(1+11);
     
    17151718      model_ = saveModel;
    17161719      saveModel=NULL;
     1720      if (justValuesPass)
     1721        model_->primal(2);
    17171722    }
    17181723    if (allowInfeasible) {
     
    17551760             CoinCpuTime()-startTime,n);
    17561761#endif
     1762      if (justValuesPass)
     1763        return;
    17571764      if (addAll)
    17581765        presolve=0;
Note: See TracChangeset for help on using the changeset viewer.