# Changeset 210

Ignore:
Timestamp:
Sep 19, 2003 5:01:35 PM (17 years ago)
Message:

Trying

Location:
branches/pre
Files:
28 edited

Unmodified
Removed
• ## branches/pre/ClpDualRowSteepest.cpp

 r208 //largestWeight = dubious; } } else { // just to make sure we don't exit before got something numberWanted++; } }
• ## branches/pre/ClpMatrixBase.cpp

 r205 return weights; } // Append Columns void ClpMatrixBase::appendCols(int number, const CoinPackedVectorBase * const * columns) { std::cerr<<"appendCols not supported - ClpMatrixBase"<
• ## branches/pre/ClpMessage.cpp

 r208 {CLP_DUAL_CHECKB,12,2,"New dual bound of %g"}, {CLP_DUAL_ORIGINAL,13,3,"Going back to original objective"}, {CLP_SIMPLEX_PERTURB,14,1,"Perturbing problem by %g %% of %g - largest change %g (%% %g) - largest zero change %g"}, {CLP_SIMPLEX_PERTURB,14,1,"Perturbing problem by %g %% of %g - largest nonzero change %g (%% %g) - largest zero change %g"}, {CLP_PRIMAL_ORIGINAL,15,2,"Going back to original tolerance"}, {CLP_PRIMAL_WEIGHT,16,2,"New infeasibility weight of %g"}, {CLP_TIMING,32,1,"%s objective %.9g - %d iterations time %.2f2%?, Presolve %.2f%?, Idiot %.2f%?"}, {CLP_INTERVAL_TIMING,33,2,"%s took %.2f seconds (total %.2f)"}, {CLP_SPRINT,34,1,"Pass %d took %d iterations, objective %g, dual infeasibilities %g( %d)"}, {CLP_DUMMY_END,999999,0,""} };
• ## branches/pre/ClpModel.cpp

 r208 #include "CoinHelperFunctions.hpp" #include "CoinTime.hpp" #include "ClpModel.hpp" #include "ClpPackedMatrix.hpp" solveType_(0), problemStatus_(-1), secondaryStatus_(0), lengthNames_(0), defaultHandler_(true), solveType_ = rhs.solveType_; problemStatus_ = rhs.problemStatus_; secondaryStatus_ = rhs.secondaryStatus_; numberRows_ = rhs.numberRows_; numberColumns_ = rhs.numberColumns_; status_ = ClpCopyOfArray( rhs.status_,numberColumns_+numberRows_); ray_ = NULL; if (problemStatus_==1) if (problemStatus_==1&&!secondaryStatus_) ray_ = ClpCopyOfArray (rhs.ray_,numberRows_); else if (problemStatus_==2) otherModel.numberIterations_ = numberIterations_; otherModel.problemStatus_ = problemStatus_; otherModel.secondaryStatus_ = secondaryStatus_; rowActivity_ = NULL; columnActivity_ = NULL; // set state back to unknown problemStatus_ = -1; secondaryStatus_ = 0; delete [] ray_; ray_ = NULL; // set state back to unknown problemStatus_ = -1; secondaryStatus_ = 0; delete [] ray_; ray_ = NULL; // set state back to unknown problemStatus_ = -1; secondaryStatus_ = 0; delete [] ray_; ray_ = NULL; if (!matrix_) createEmptyMatrix(); // Use matrix() to get round virtual problem matrix()->appendRows(number,rows); matrix_->appendRows(number,rows); } // Add columns if (!matrix_) createEmptyMatrix(); // Use matrix() to get round virtual problem matrix()->appendCols(number,columns); matrix_->appendCols(number,columns); } // Infeasibility/unbounded ray (NULL returned if none/wrong) { double * array = NULL; if (problemStatus_==1) if (problemStatus_==1&&!secondaryStatus_) array = ClpCopyOfArray(ray_,numberRows_); return array; } CoinMpsIO m; bool savePrefix =m.messageHandler()->prefix(); m.messageHandler()->setPrefix(handler_->prefix()); double time1 = CoinCpuTime(),time2; int status=m.readMps(fileName,""); m.messageHandler()->setPrefix(savePrefix); if (!status||ignoreErrors) { loadProblem(*m.getMatrixByCol(), solveType_ = rhs->solveType_; problemStatus_ = rhs->problemStatus_; secondaryStatus_ = rhs->secondaryStatus_; // check valid lists int numberBad=0; delete [] columnStatus; ray_ = NULL; if (problemStatus_==1) if (problemStatus_==1&&!secondaryStatus_) ray_ = whichDouble (rhs->ray_,numberRows,whichRow); else if (problemStatus_==2)
• ## branches/pre/ClpNonLinearCost.cpp

 r192 } } else { if (fabs(value-upperValue)<=fabs(value-lowerValue)) { solution[iSequence] = upperValue; } else { model_->setStatus(iSequence,ClpSimplex::atLowerBound); solution[iSequence] = lowerValue; } // Set to nearest and make at upper bound int kRange; iRange=-1; double nearest = COIN_DBL_MAX; for (kRange=start; kRange=0); iRange--; solution[iSequence]=lower_[iRange+1]; } break; } } else { if (fabs(value-lowerValue)<=fabs(value-upperValue)) { solution[iSequence] = lowerValue; } else { model_->setStatus(iSequence,ClpSimplex::atUpperBound); solution[iSequence] = upperValue; } // Set to nearest and make at lower bound int kRange; iRange=-1; double nearest = COIN_DBL_MAX; for (kRange=start; kRange=0); solution[iSequence]=lower_[iRange]; } break; case ClpSimplex::isFixed: if (toNearest) { // Set to true fixed for (iRange=start; iRangecurrentPrimalTolerance(); // get where in bound sequence int iRange; int currentRange = whichRange_[iPivot]; int start = start_[iPivot]; int end = start_[iPivot+1]-1; // Set perceived direction out int direction; if (value<=lower_[currentRange]+1.001*primalTolerance) { direction=1; } else if (value>=lower_[currentRange+1]-1.001*primalTolerance) { direction=-1; } else { // odd direction=0; } // If fixed try and get feasible if (lower_[start+1]==lower_[start+2]&&fabs(value-lower_[start+1])<1.001*primalTolerance) { iRange =start+1; } else { // See if exact for (iRange=start; iRange=lower_[iRange+1]-primalTolerance&&infeasible(iRange)&&iRange==start) iRange++; break; } } } } assert(iRangelowerAddress(iPivot); double & upper = model_->upperAddress(iPivot); double & cost = model_->costAddress(iPivot); lower = lower_[iRange]; upper = lower_[iRange+1]; if (upper==lower) { value=upper; } else { // set correctly if (fabs(value-lower)<=primalTolerance*1.001){ value = min(value,lower+primalTolerance); } else if (fabs(value-upper)<=primalTolerance*1.001){ value = max(value,upper-primalTolerance); } else { printf("*** variable wandered off bound %g %g %g!\n", lower,value,upper); if (value-lower<=upper-value) value = lower+primalTolerance; else value = upper-primalTolerance; } } double difference = cost-cost_[iRange]; cost = cost_[iRange]; changeCost_ += value*difference; return direction; } // Returns nearest bound double
• ## branches/pre/ClpPlusMinusOneMatrix.cpp

 r208 delete [] indices_; // put in message printf("Not all +-1 - can test if indices_ null\n"); indices_=NULL; numberRows_=0; // bad column numberBad++; printf("%d %d %d %d\n",iColumn,numberMajor,numberMajor1,kColumn); } } else if (numberRows*2numberIterations()%50==0) printf("%d nonzero\n",numberInRowArray); } if (numberInRowArray>factor*numberRows||!rowCopy) { ClpPlusMinusOneMatrix::deleteCols(const int numDel, const int * indDel) { abort(); int iColumn; int newSize=startPositive_[numberColumns_];; int numberBad=0; // Use array to make sure we can have duplicates int * which = new int[numberColumns_]; memset(which,0,numberColumns_*sizeof(int)); int nDuplicate=0; for (iColumn=0;iColumn=numberColumns_) { numberBad++; } else { newSize -= startPositive_[jColumn+1]-startPositive_[jColumn]; if (which[jColumn]) nDuplicate++; else which[jColumn]=1; } } if (numberBad) throw CoinError("Indices out of range", "deleteCols", "ClpPlusMinusOneMatrix"); int newNumber = numberColumns_-numDel+nDuplicate; // Get rid of temporary arrays delete [] lengths_; lengths_=NULL; delete [] elements_; elements_= NULL; int * newPositive = new int [newNumber+1]; int * newNegative = new int [newNumber]; int * newIndices = new int [newSize]; newNumber=0; newSize=0; for (iColumn=0;iColumnindDel. */ ClpPlusMinusOneMatrix::deleteRows(const int numDel, const int * indDel) { abort(); int iRow; int numberBad=0; // Use array to make sure we can have duplicates int * which = new int[numberRows_]; memset(which,0,numberRows_*sizeof(int)); int nDuplicate=0; for (iRow=0;iRow=numberRows_) { numberBad++; } else { if (which[jRow]) nDuplicate++; else which[jRow]=1; } } if (numberBad) throw CoinError("Indices out of range", "deleteCols", "ClpPlusMinusOneMatrix"); int iElement; int numberElements=startPositive_[numberColumns_]; int newSize=0; for (iElement=0;iElementgetNumElements(); const double * element = columns[iColumn]->getElements(); size += n; int i; for (i=0;igetNumElements(); const int * row = columns[iColumn]->getIndices(); const double * element = columns[iColumn]->getElements(); int i; for (i=0;igetNumElements(); const int * column = rows[iRow]->getIndices(); const double * element = rows[iRow]->getElements(); size += n; int i; for (i=0;igetNumElements(); const int * column = rows[iRow]->getIndices(); const double * element = rows[iRow]->getElements(); int i; for (i=0;i

• ## branches/pre/ClpSimplex.cpp

 r208 } } arrayVector.setNumElements(number); setStatus(sequenceIn_,basic); if (upper_[sequenceOut_]-lower_[sequenceOut_]>0) { if (directionOut_>0) { // As Nonlinear costs may have moved bounds (to more feasible) // Redo using value if (fabs(valueOut_-lower_[sequenceOut_])primal(ifValuesPass); int returnCode = ((ClpSimplexPrimal *) this)->primal(ifValuesPass); if (problemStatus_==10) { //printf("Cleaning up with dual\n"); int savePerturbation = perturbation_; perturbation_=100; returnCode = ((ClpSimplexDual *) this)->dual(0); perturbation_=savePerturbation; } return returnCode; } #include "ClpSimplexPrimalQuadratic.hpp" sequenceIn_=-1; sequenceOut_=-1; secondaryStatus_=0; primalTolerance_=dblParam_[ClpPrimalTolerance]; factorization_->slackValue(-1.0); factorization_->zeroTolerance(1.0e-13); // Switch off dense // Switch off dense (unless special option set) int saveThreshold = factorization_->denseThreshold(); factorization_->setDenseThreshold(0); #if 0 // do perturbation if asked for if (perturbation_<100) { if (algorithm_>0) { ((ClpSimplexPrimal *) this)->perturb(); } else if (algorithm_<0) { // If values pass then perturb (otherwise may be optimal so leave a bit) if (ifValuesPass) { // do perturbation if asked for if (perturbation_<100) { if (algorithm_>0) { ((ClpSimplexPrimal *) this)->perturb(0); } else if (algorithm_<0) { ((ClpSimplexDual *) this)->perturb(); } } #endif } } } // for primal we will change bounds using infeasibilityCost_ if (nonLinearCost_==NULL&&algorithm_>0) { return matched; } // Allow initial dense factorization void ClpSimplex::setInitialDenseFactorization(bool onOff) { if (onOff) specialOptions_ |= 8; else specialOptions_ &= ~8; } bool ClpSimplex::initialDenseFactorization() const { return (specialOptions_&8)!=0; }
• ## branches/pre/ClpSimplexDual.cpp

 r208 matrix_->refresh(this); // If getting nowhere - why not give it a kick #if 0 // does not seem to work too well - do some more work if (perturbation_<101&&numberIterations_>2*(numberRows_+numberColumns_)) if (perturbation_<101&&numberIterations_>2*(numberRows_+numberColumns_)) { perturb(); #endif // Can't get here if values pass gutsOfSolution(NULL,NULL); if (handler_->logLevel()>2) { handler_->message(CLP_SIMPLEX_STATUS,messages_) <printing(sumPrimalInfeasibilities_>0.0) <printing(sumDualInfeasibilities_>0.0) <printing(numberDualInfeasibilitiesWithoutFree_ message()<logLevel()&32)) { double * objectiveSimplex = ClpCopyOfArray(objective(),numberColumns_,0.0); double * rowObjectiveSimplex = ClpCopyOfArray(rowObjective_,numberRows_,0.0); int i; double largest; largest=0.0; // direction is actually scale out not scale in if (direction) direction = 1.0/direction; for (i=0;ilargest) largest=difference; } for (i=0;ilargest) largest=difference; } if ((handler_->logLevel()&16)) printf("difference in obj %g\n",largest); delete [] objectiveSimplex; delete [] rowObjectiveSimplex; } #endif handler_->message(CLP_SIMPLEX_STATUS,messages_) <
• ## branches/pre/ClpSimplexPrimal.cpp

 r207 // This says whether to restore things etc int factorType=0; if (problemStatus_<0&&perturbation_<100) { perturb(0); // Can't get here if values pass assert (!ifValuesPass); gutsOfSolution(NULL,NULL); if (handler_->logLevel()>2) { handler_->message(CLP_SIMPLEX_STATUS,messages_) <printing(sumPrimalInfeasibilities_>0.0) <printing(sumDualInfeasibilities_>0.0) <printing(numberDualInfeasibilitiesWithoutFree_ message()<refresh(this); // If getting nowhere - why not give it a kick #if 0 // primal perturbation not coded yet #if 1 if (perturbation_<101&&numberIterations_>2*(numberRows_+numberColumns_)) perturb(); perturb(1); #endif // If we have done no iterations - special gutsOfSolution(NULL,NULL); } // Flag to say whether to go to dual to clean up bool goToDual=false; // really for free variables in //if((progressFlag_&2)!=0) <message()<checkInfeasibilities(primalTolerance_); gutsOfSolution(NULL,NULL); } // we may wish to say it is optimal even if infeasible bool alwaysOptimal = (specialOptions_&1)!=0; if ((infeasibilityCost_>=1.0e18|| numberDualInfeasibilities_==0)&&perturbation_==101) { unPerturb(); // stop any further perturbation goToDual=unPerturb(); // stop any further perturbation numberDualInfeasibilities_=1; // carry on } // may be optimal if (perturbation_==101) { unPerturb(); // stop any further perturbation goToDual=unPerturb(); // stop any further perturbation lastCleaned=-1; // carry on } if ( lastCleaned!=numberIterations_||unflag()) { bool unflagged = unflag(); if ( lastCleaned!=numberIterations_||unflagged) { handler_->message(CLP_PRIMAL_OPTIMAL,messages_) <numberInfeasibilities()&&lastCleaned>=0) problemStatus_=0; else problemStatus_ = -1; } else { problemStatus_=0; // optimal // back off weight infeasibilityCost_ = 1.0e13; unPerturb(); // stop any further perturbation goToDual=unPerturb(); // stop any further perturbation } //we need infeasiblity cost changed } lastGoodIteration_ = numberIterations_; if (goToDual) problemStatus_=10; // try dual #if 0 double thisObj = progress->lastObjective(0); int iIndex; #if 0 if (numberIterations_==1147) if (numberIterations_<=39) handler_->setLogLevel(63); else handler_->setLogLevel(2); if (numberIterations_==38) printf("trouble\n"); assert (solution_[29176]>-1.0e20); #endif for (iIndex=0;iIndex100) double perturbation=1.0e-20; // maximum fraction of rhs/bounds to perturb double maximumFraction = 1.0e-4; double maximumFraction = 1.0e-8; if (perturbation_>=50) { perturbation = 1.0e-4; } } perturbation *= 1.0e-8; } else if (perturbation_<100) { perturbation = pow(10.0,perturbation_); // user is in charge maximumFraction = 1.0e100; } maximumFraction = 1.0; } double largestZero=0.0; double largest=0.0; double largestPerCent=0.0; bool printOut=(handler_->logLevel()==63); // Check if all slack int number=0; int iSequence; for (iSequence=0;iSequence=numberColumns_) { // may not be at bound - but still perturb (unless free) if (upperValue>1.0e30&&lowerValue<-1.0e30) value=0.0; else value = - value; // as -1.0 in matrix } else { value = 0.0; } #else value=0.0; #endif } if (value) { if (printOut) printf("col %d lower from %g to %g, upper from %g to %g\n", iSequence,lower_[iSequence],lowerValue,upper_[iSequence],upperValue); if (solutionValue) { largest = max(largest,value); if (value>(fabs(solutionValue)+1.0)*largestPerCent) largestPerCent=value/(fabs(solutionValue)+1.0); } else { largestZero = max(largestZero,value); } } } } } else { for (i=0;ilowerValue+primalTolerance_) { double value = CoinDrand48()*perturbation*maximumFraction; if (lowerValue>-1.0e20&&lowerValue) lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue))); if (upperValue<1.0e20&&upperValue) upperValue += value * (max(1.0,1.0e-5*fabs(upperValue))); if (lowerValue!=lower_[i]) { double difference = fabs(lowerValue-lower_[i]); largest = max(largest,difference); if (difference>fabs(lower_[i])*largestPerCent) largestPerCent=fabs(difference/lower_[i]); } if (upperValue!=upper_[i]) { double difference = fabs(upperValue-upper_[i]); largest = max(largest,difference); if (difference>fabs(upper_[i])*largestPerCent) largestPerCent=fabs(difference/upper_[i]); } if (printOut) printf("col %d lower from %g to %g, upper from %g to %g\n", i,lower_[i],lowerValue,upper_[i],upperValue); } if (solution_[i]==lower_[i]) solution_[i]=lowerValue; else if (solution_[i]==upper_[i]) solution_[i]=upperValue; lower_[i]=lowerValue; upper_[i]=upperValue; } for (;ilowerValue+primalTolerance_) { if (lowerValue>-1.0e20&&lowerValue) lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue))); if (upperValue<1.0e20&&upperValue) upperValue += value * (max(1.0,1.0e-5*fabs(upperValue))); } else if (upperValue>0.0) { upperValue -= value * (max(1.0,1.0e-5*fabs(lowerValue))); lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue))); } else if (upperValue<0.0) { upperValue += value * (max(1.0,1.0e-5*fabs(lowerValue))); lowerValue += value * (max(1.0,1.0e-5*fabs(lowerValue))); } else { } if (lowerValue!=lower_[i]) { double difference = fabs(lowerValue-lower_[i]); largest = max(largest,difference); if (difference>fabs(lower_[i])*largestPerCent) largestPerCent=fabs(difference/lower_[i]); } if (upperValue!=upper_[i]) { double difference = fabs(upperValue-upper_[i]); largest = max(largest,difference); if (difference>fabs(upper_[i])*largestPerCent) largestPerCent=fabs(difference/upper_[i]); } if (printOut) printf("row %d lower from %g to %g, upper from %g to %g\n", i-numberColumns_,lower_[i],lowerValue,upper_[i],upperValue); if (solution_[i]==lower_[i]) solution_[i]=lowerValue; else if (solution_[i]==upper_[i]) solution_[i]=upperValue; lower_[i]=lowerValue; upper_[i]=upperValue; } } handler_->message(CLP_SIMPLEX_PERTURB,messages_) <lowerValue+primalTolerance_) { double value = CoinDrand48()*perturbation; if (lowerValue>-1.0e20&&lowerValue) lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue))); if (upperValue<1.0e20&&upperValue) upperValue += value * (max(1.0,1.0e-5*fabs(upperValue))); } lower_[i]=lowerValue; upper_[i]=upperValue; } for (;ilowerValue+primalTolerance_) { if (lowerValue>-1.0e20) lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue))); if (upperValue<1.0e20) upperValue += value * (max(1.0,1.0e-5*fabs(upperValue))); } else if (upperValue>0.0) { lowerValue -= value * (max(1.0,1.0e-5*fabs(lowerValue))); upperValue -= value * (max(1.0,1.0e-5*fabs(lowerValue))); } else if (upperValue<0.0) { lowerValue += value * (max(1.0,1.0e-5*fabs(lowerValue))); upperValue += value * (max(1.0,1.0e-5*fabs(lowerValue))); } else { } lower_[i]=lowerValue; upper_[i]=upperValue; } // redo nonlinear costs // say perturbed perturbation_=101; } // un perturb void bool ClpSimplexPrimal::unPerturb() { if (perturbation_!=101) return false; // put back original bounds and costs createRim(7); // move non basic variables to new bounds nonLinearCost_->checkInfeasibilities(0.0); #if 1 // Try using dual return true; #else gutsOfSolution(NULL,NULL); return false; #endif } // Unflag all variables and return number unflagged valueOut_ = upperOut_; } double lowerValue = lower_[sequenceOut_]; double upperValue = upper_[sequenceOut_]; assert(valueOut_>=lowerValue-primalTolerance_&& valueOut_<=upperValue+primalTolerance_); assert(valueOut_>=lower_[sequenceOut_]-primalTolerance_&& valueOut_<=upper_[sequenceOut_]+primalTolerance_); // may not be exactly at bound and bounds may have changed // Make sure outgoing looks feasible double useValue=valueOut_; if (valueOut_<=lowerValue+primalTolerance_) { directionOut_=1; useValue= lower_[sequenceOut_]; } else if (valueOut_>=upperValue-primalTolerance_) { directionOut_=-1; useValue= upper_[sequenceOut_]; } else { printf("*** variable wandered off bound %g %g %g!\n", lowerValue,valueOut_,upperValue); if (valueOut_-lowerValue<=upperValue-valueOut_) { useValue= lower_[sequenceOut_]; valueOut_=lowerValue; directionOut_=1; } else { useValue= upper_[sequenceOut_]; valueOut_=upperValue; directionOut_=-1; } } directionOut_=nonLinearCost_->setOneOutgoing(sequenceOut_,valueOut_); solution_[sequenceOut_]=valueOut_; nonLinearCost_->setOne(sequenceOut_,useValue); } // change cost and bounds on incoming if primal

 r205 valueOut_<=upperValue+primalTolerance_); // may not be exactly at bound and bounds may have changed #if 1 // Make sure outgoing looks feasible double useValue=valueOut_; solution_[sequenceOut_]=valueOut_; nonLinearCost_->setOne(sequenceOut_,useValue); #else directionOut_=nonLinearCost_->setOneOutgoing(sequenceOut_,valueOut_); solution_[sequenceOut_]=valueOut_; #endif } // change cost and bounds on incoming if primal

• ## branches/pre/IdiSolve.cpp

 r208 obj[DROP-1]=best; if (test-best50) { printf("Exiting on low dj %g after %d iterations\n",maxDj,iter); //printf("Exiting on low dj %g after %d iterations\n",maxDj,iter); break; }
• ## branches/pre/Idiot.cpp

 r208 #include "ClpPresolve.hpp" #include "Idiot.hpp" #include "CoinHelperFunctions.hpp" #include "CoinTime.hpp" #include "CoinMessageHandler.hpp" // Redefine stuff for Clp } sum /= (double) (nnzero+1); mu_= max(1.0e-3,sum*1.0e-5); // If mu not changed then compute if (mu_==1e-4) mu_= max(1.0e-3,sum*1.0e-5); maxIts_=20; maxIts2_=105; #endif } int numberAway=-1; iterationTotal = lastResult.iteration; firstInfeas=lastResult.infeas; #endif } if (iteration>50&&n==numberAway&&result.infeas<1.0e-4) break; // not much happening numberAway=n; keepinfeas = result.infeas; lastWeighted=result.weighted; (((lambdaIteration%10)==0 && smallInfeas
• ## branches/pre/Makefile.Clp

 r208 # highest level of optimization the compiler supports. If want something in # between then specify the exact level you want, e.g., -O1 or -O2 OptLevel := -O3 #OptLevel := -g #OptLevel := -O1 OptLevel := -g OptLevel := -O1 LIBNAME := Clp ifeq (\$(OptLevel),-g) #     CXXFLAGS += -DCLP_DEBUG #    CXXFLAGS += -DPRESOLVE_SUMMARY=1 -DDEBUG_PRESOLVE -DCHECK_CONSISTENCY=1 endif ifeq (\$(OptLevel),-O2) #     CXXFLAGS += -DNDEBUG #    CXXFLAGS += -DPRESOLVE_SUMMARY=1 -DDEBUG_PRESOLVE -DCHECK_CONSISTENCY=1 endif
• ## branches/pre/Samples/Makefile

 r200 #       LDFLAGS += -lhistory -lreadline -ltermcap endif LDFLAGS += -lefence #if DENSE and using given libraries LDFLAGS += -llapack -lblas -lg2c #LDFLAGS += -lefence ###############################################################################
• ## branches/pre/Samples/sprint.cpp

 r181 for (iPass=0;iPass
• ## branches/pre/Test/ClpMain.cpp

 r208 #include "ClpFactorization.hpp" #include "CoinTime.hpp" #include "ClpSimplex.hpp" #include "ClpSolve.hpp" #include "ClpPackedMatrix.hpp" #include "ClpPlusMinusOneMatrix.hpp" DUALTOLERANCE=1,PRIMALTOLERANCE,DUALBOUND,PRIMALWEIGHT,MAXTIME,OBJSCALE, LOGLEVEL=101,MAXFACTOR,PERTVALUE,MAXITERATION,PRESOLVEPASS,IDIOT, LOGLEVEL=101,MAXFACTOR,PERTVALUE,MAXITERATION,PRESOLVEPASS,IDIOT,SPRINT, DIRECTION=201,DUALPIVOT,SCALING,ERRORSALLOWED,KEEPNAMES,SPARSEFACTOR, PRIMALPIVOT,PRESOLVE,CRASH,BIASLU,PERTURBATION, PRIMALPIVOT,PRESOLVE,CRASH,BIASLU,PERTURBATION,MESSAGES, DIRECTORY=301,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX, MAXIMIZE,MINIMIZE,EXIT,STDIN,UNITTEST,NETLIB_DUAL,NETLIB_PRIMAL,SOLUTION, TIGHTEN,FAKEBOUND,VERSION,PLUSMINUS,NETWORK, TIGHTEN,FAKEBOUND,HELP,PLUSMINUS,NETWORK,ALLSLACK, INVALID=1000 }; static void printit(const char * input) { int length =strlen(input); char temp[101]; int i; int n=0; for (i=0;i=65&&input[i]==' ') { temp[n]='\0'; std::cout< longHelp_; std::string longHelp_; /// Action ClpParameterType action_; /// Display on ? bool display_; /// Integer parameter - current value int intValue_; /// Double parameter - current value double doubleValue_; /// String parameter - current value std::string stringValue_; /// index number to use for display purposes int indexNumber_; //@} }; action_(INVALID), currentKeyWord_(-1), display_(false) display_(false), intValue_(-1), doubleValue_(-1.0), stringValue_(""), indexNumber_(INVALID) { } action_(type), currentKeyWord_(-1), display_(display) display_(display), intValue_(-1), doubleValue_(-1.0), stringValue_(""), indexNumber_(type) { lowerDoubleValue_ = lower; action_(type), currentKeyWord_(-1), display_(display) display_(display), intValue_(-1), doubleValue_(-1.0), stringValue_(""), indexNumber_(type) { gutsOfConstructor(); // Other strings will be added by append ClpItem::ClpItem (std::string name, std::string help, std::string defaultValue, ClpParameterType type,bool display) std::string firstValue, ClpParameterType type, int defaultIndex,bool display) : type_(type), lowerDoubleValue_(0.0), longHelp_(), action_(type), currentKeyWord_(0), display_(display) currentKeyWord_(defaultIndex), display_(display), intValue_(-1), doubleValue_(-1.0), stringValue_(""), indexNumber_(type) { gutsOfConstructor(); definedKeyWords_.push_back(defaultValue); definedKeyWords_.push_back(firstValue); } // Action ClpItem::ClpItem (std::string name, std::string help, ClpParameterType type,bool display) ClpParameterType type,int indexNumber,bool display) : type_(type), lowerDoubleValue_(0.0), action_(type), currentKeyWord_(-1), display_(display) { display_(display), intValue_(-1), doubleValue_(-1.0), stringValue_("") { if (indexNumber<0) indexNumber_=type; else indexNumber_=indexNumber; gutsOfConstructor(); } currentKeyWord_ = rhs.currentKeyWord_; display_=rhs.display_; intValue_=rhs.intValue_; doubleValue_=rhs.doubleValue_; stringValue_=rhs.stringValue_; indexNumber_=rhs.indexNumber_; } currentKeyWord_ = rhs.currentKeyWord_; display_=rhs.display_; intValue_=rhs.intValue_; doubleValue_=rhs.doubleValue_; stringValue_=rhs.stringValue_; indexNumber_=rhs.indexNumber_; } return *this; } } // Print action and string void ClpItem::printString() const { if (name_=="directory") std::cout<<"Current working directory is "<factorization()->maximumPivots(value); break; case DIRECTION: model->setOptimizationDirection(value); break; case PERTVALUE: model->setPerturbation(value); value=model->factorization()->maximumPivots(); break; case DIRECTION: { double value2=model->optimizationDirection(); if (value2>0.0) value=1; else if (value2<0.0) value=-1; else value=0; } break; case PERTVALUE: } return value; } // Print Long help void ClpItem::printLongHelp() const { if (type_>=1&&type_<400) { if (type_setPerturbation(50); models->messageHandler()->setPrefix(false); std::string directory ="./"; std::string importFile =""; std::string exportFile ="default.mps"; std::string saveFile ="default.prob"; std::string restoreFile ="default.prob"; std::string solutionFile ="default.sol"; #define MAXPARAMETERS 100 ClpItem parameters[MAXPARAMETERS]; int numberParameters=0; parameters[numberParameters++]= ClpItem("?","For help",GENERALQUERY,false); ClpItem("?","For help",GENERALQUERY,-1,false); parameters[numberParameters++]= ClpItem("-","From stdin", STDIN,false); STDIN,299,false); parameters[numberParameters++]= ClpItem("allS!lack","Set basis back to all slack", ALLSLACK); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("biasLU","Whether factorization biased towards U", "UU",BIASLU,false); "UU",BIASLU,2,false); parameters[numberParameters-1].append("UX"); parameters[numberParameters-1].append("LX"); "off",CRASH); parameters[numberParameters-1].append("on"); parameters[numberParameters-1].setLonghelp ( "If crash is set on and there is an all slack basis then Clp will put structural\ variables into basis with the aim of getting dual feasible.  On the whole dual seems to be\ better without it and there alernative types of 'crash' for primal e.g. 'idiot' or 'sprint'." ); parameters[numberParameters++]= ClpItem("direction","Minimize or Maximize", "min!imize",DIRECTION); parameters[numberParameters-1].append("max!imize"); parameters[numberParameters++]= ClpItem("directory","Set Default import directory", DIRECTORY); parameters[numberParameters-1].append("zero"); parameters[numberParameters-1].setLonghelp ( "The default is minimize - use 'direction maximize' for maximization.\n\ You can also use the parameters 'maximize' or 'minimize'." ); parameters[numberParameters++]= ClpItem("directory","Set Default directory for import etc.", DIRECTORY,299); parameters[numberParameters-1].setLonghelp ( "This sets the directory which import, export, saveModel and restoreModel will use" ); parameters[numberParameters-1].setStringValue(directory); parameters[numberParameters++]= ClpItem("dualB!ound","Initially algorithm acts as if no \ gap between bounds exceeds this value", 1.0e-20,1.0e12,DUALBOUND); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setDoubleValue(models->dualBound()); parameters[numberParameters++]= ClpItem("dualP!ivot","Dual pivot choice algorithm", parameters[numberParameters-1].append("partial"); parameters[numberParameters-1].append("steep!est"); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("dualS!implex","Do dual simplex algorithm", DUALSIMPLEX); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("dualT!olerance","For an optimal solution \ no dual infeasibility may exceed this value", 1.0e-20,1.0e12,DUALTOLERANCE); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setDoubleValue(models->dualTolerance()); parameters[numberParameters++]= ClpItem("end","Stops clp execution", EXIT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("error!sAllowed","Whether to allow import errors", "off",ERRORSALLOWED); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("exit","Stops clp execution", EXIT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("export","Export model as mps file", EXPORT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setStringValue(exportFile); parameters[numberParameters++]= ClpItem("fakeB!ound","All bounds <= this value - DEBUG", 1.0,1.0e15,FAKEBOUND,false); parameters[numberParameters++]= ClpItem("help","Print out version, non-standard options and some help", HELP); parameters[numberParameters++]= ClpItem("idiot!Crash","Whether to try idiot crash", 0,200,IDIOT); -2,200,IDIOT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setIntValue(doIdiot); parameters[numberParameters++]= ClpItem("import","Import model from mps file", IMPORT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setStringValue(importFile); parameters[numberParameters++]= ClpItem("keepN!ames","Whether to keep names from import", "on",KEEPNAMES); parameters[numberParameters-1].append("off"); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("log!Level","Level of detail in output", 0,63,LOGLEVEL); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setIntValue(models->logLevel()); parameters[numberParameters++]= ClpItem("max!imize","Set optimization direction to maximize", MAXIMIZE); MAXIMIZE,299); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("maxF!actor","Maximum number of iterations between \ refactorizations", 1,999999,MAXFACTOR); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setIntValue(models->factorizationFrequency()); parameters[numberParameters++]= ClpItem("maxIt!erations","Maximum number of iterations before \ stopping", 0,99999999,MAXITERATION); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setIntValue(models->maximumIterations()); parameters[numberParameters++]= ClpItem("min!imize","Set optimization direction to minimize", MINIMIZE); MINIMIZE,299); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("mess!ages","Controls if Clpnnnn is printed", "off",MESSAGES); parameters[numberParameters-1].append("on"); parameters[numberParameters-1].setLonghelp ("" ); parameters[numberParameters++]= ClpItem("netlib","Solve entire netlib test set", NETLIB_DUAL); NETLIB_DUAL,-1,false); parameters[numberParameters++]= ClpItem("netlibP!rimal","Solve entire netlib test set (primal)", NETLIB_PRIMAL); NETLIB_PRIMAL,-1,false); parameters[numberParameters++]= ClpItem("network","Tries to make network matrix", NETWORK); NETWORK,-1,false); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("objective!Scale","Scale factor to apply to objective", -1.0e20,1.0e20,OBJSCALE); -1.0e20,1.0e20,OBJSCALE,false); parameters[numberParameters-1].setDoubleValue(models->optimizationDirection()); parameters[numberParameters++]= ClpItem("passP!resolve","How many passes in presolve", 0,100,PRESOLVEPASS); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setIntValue(preSolve); parameters[numberParameters++]= ClpItem("pertV!alue","Method of perturbation", -5000,102,PERTVALUE,false); parameters[numberParameters-1].setIntValue(models->perturbation()); parameters[numberParameters++]= ClpItem("perturb!ation","Whether to perturb problem", "on",PERTURBATION); parameters[numberParameters-1].append("off"); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("plus!Minus","Tries to make +- 1 matrix", PLUSMINUS); PLUSMINUS,-1,false); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("presolve","Whether to presolve problem", parameters[numberParameters-1].append("off"); parameters[numberParameters-1].append("more"); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("primalP!ivot","Primal pivot choice algorithm", "steep!est",PRIMALPIVOT); "auto!matic",PRIMALPIVOT); parameters[numberParameters-1].append("exa!ct"); parameters[numberParameters-1].append("dant!zig"); parameters[numberParameters-1].append("part!ial"); parameters[numberParameters-1].append("steep!est"); //parameters[numberParameters-1].append("change"); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("primalS!implex","Do primal simplex algorithm", PRIMALSIMPLEX); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("primalT!olerance","For an optimal solution \ no primal infeasibility may exceed this value", 1.0e-20,1.0e12,PRIMALTOLERANCE); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setDoubleValue(models->primalTolerance()); parameters[numberParameters++]= ClpItem("primalW!eight","Initially algorithm acts as if it \ costs this much to be infeasible", 1.0e-20,1.0e12,PRIMALWEIGHT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setDoubleValue(models->infeasibilityCost()); parameters[numberParameters++]= ClpItem("quit","Stops clp execution", EXIT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("restore!Model","Restore model from binary file", RESTORE); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setStringValue(restoreFile); parameters[numberParameters++]= ClpItem("save!Model","Save model to binary file", SAVE); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setStringValue(saveFile); parameters[numberParameters++]= ClpItem("scal!ing","Whether to scale problem", "on",SCALING); parameters[numberParameters-1].append("off"); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("sec!onds","maximum seconds", 0.0,1.0e12,MAXTIME); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setDoubleValue(models->maximumSeconds()); parameters[numberParameters++]= ClpItem("sol!ution","Prints solution to file", SOLUTION); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setStringValue(solutionFile); parameters[numberParameters++]= ClpItem("spars!eFactor","Whether factorization treated as sparse", "on",SPARSEFACTOR,false); "on",SPARSEFACTOR,0,false); parameters[numberParameters-1].append("off"); parameters[numberParameters-1].append("on"); parameters[numberParameters++]= ClpItem("sprint!Crash","Whether to try sprint crash", 0,200,SPRINT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters-1].setIntValue(doSprint); ClpItem("stdin","From stdin", STDIN,false); STDIN,-1,false); parameters[numberParameters++]= ClpItem("stop","Stops clp execution", EXIT); parameters[numberParameters-1].setLonghelp ( "" ); parameters[numberParameters++]= ClpItem("tight!en","Poor person's preSolve for now", TIGHTEN); TIGHTEN,-1,false); parameters[numberParameters++]= ClpItem("unitTest","Do unit test", UNITTEST); parameters[numberParameters++]= ClpItem("ver!sion","Print out version and non-standard options", VERSION); UNITTEST,-1,false); assert(numberParameterssetPerturbation(50); //models[0].scaling(1); //models[0].setDualBound(1.0e6); //ClpPrimalColumnSteepest steepP; //models[0].setPrimalColumnPivotAlgorithm(steepP); std::string directory ="./"; std::string field; std::cout<<"Coin LP version "<>1; } std::cout<<"abcd?? adds explanation, if only one fuller help(LATER)"< types; types.push_back("Double parameters:"); types.push_back("Int parameters:"); types.push_back("Keyword parameters and others:"); types.push_back("Actions:"); int iType; for (iType=0;iType<4;iType++) { int across=0; std::cout<=limits[iType] &&typesetPrefix(action!=0); break; default: case PRIMALSIMPLEX: if (goodModels[iModel]) { ClpSimplex::SolveType method; ClpSimplex::PresolveType presolveType; ClpSolve::SolveType method; ClpSolve::PresolveType presolveType; ClpSimplex * model2 = models+iModel; if (preSolve>5) presolveType=ClpSimplex::presolveMaximum; ClpSolve solveOptions; if (preSolve!=5&&preSolve) presolveType=ClpSolve::presolveNumber; else if (preSolve) presolveType=ClpSimplex::presolveOn; presolveType=ClpSolve::presolveOn; else presolveType=ClpSimplex::presolveOff; presolveType=ClpSolve::presolveOff; solveOptions.setPresolveType(presolveType,preSolve); if (type==DUALSIMPLEX) method=ClpSimplex::useDual; method=ClpSolve::useDual; else method=ClpSimplex::usePrimal; int option=0; if (model2->perturbation()==100||method==ClpSimplex::usePrimal) option |= 1; if (!model2->scalingFlag()) option |= 2; if (doIdiot==-1) option |=4; if (doIdiot==0) option |= 8; model2->initialSolve(method,presolveType,option); method=ClpSolve::usePrimalorSprint; solveOptions.setSolveType(method); if (method==ClpSolve::useDual) { // dual if (doCrash) solveOptions.setSpecialOption(0,1); // crash } else { // primal if (doCrash) { solveOptions.setSpecialOption(0,1); // crash } else if (doSprint>0) { // sprint overrides idiot solveOptions.setSpecialOption(1,3,doSprint); // sprint } else if (doIdiot>0) { solveOptions.setSpecialOption(1,2,doIdiot); // idiot } else { if (doIdiot==0) { if (doSprint==0) solveOptions.setSpecialOption(1,4); // all slack else solveOptions.setSpecialOption(1,9); // all slack or sprint } else { if (doSprint==0) solveOptions.setSpecialOption(1,8); // all slack or idiot else solveOptions.setSpecialOption(1,7); // initiative } } } model2->initialSolve(solveOptions); } else { std::cout<<"** Current model not valid"<rowName(iRow).c_str()); #ifdef STRIPBLANKS char * xx = rowNames[iRow]; int i; int length = strlen(xx); int n=0; for (i=0;icolumnName(iColumn).c_str()); #ifdef STRIPBLANKS char * xx = columnNames[iColumn]; int i; int length = strlen(xx); int n=0; for (i=0;i=2) parameters[firstMatch].printLongHelp(); } } else {
• ## branches/pre/Test/unitTest.cpp

 r208 #include "CoinPackedVector.hpp" #include "CoinHelperFunctions.hpp" #include "CoinTime.hpp" #include "ClpFactorization.hpp"
• ## branches/pre/include/ClpMatrixBase.hpp

 r205 /** Delete the rows whose indices are listed in indDel. */ virtual void deleteRows(const int numDel, const int * indDel) = 0; /// Append Columns virtual void appendCols(int number, const CoinPackedVectorBase * const * columns); /// Append Rows virtual void appendRows(int number, const CoinPackedVectorBase * const * rows); /** Returns a new matrix in reverse order without gaps
• ## branches/pre/include/ClpMessage.hpp

 r208 CLP_TIMING, CLP_INTERVAL_TIMING, CLP_SPRINT, CLP_DUMMY_END };
• ## branches/pre/include/ClpModel.hpp

 r205 inline void setProblemStatus(int problemStatus) { problemStatus_ = problemStatus;}; /** Secondary status of problem - may get extended 0 - none 1 - primal infeasible because dual limit reached */ inline int secondaryStatus() const            { return secondaryStatus_; } inline void setSecondaryStatus(int status) { secondaryStatus_ = status;}; /// Are there a numerical difficulties? bool isAbandoned() const             { return problemStatus_==4; } /// Status of problem int problemStatus_; /// Secondary status of problem int secondaryStatus_; /// length of names (0 means no names) int lengthNames_;
• ## branches/pre/include/ClpNonLinearCost.hpp

 r185 May need to be inline for speed */ double setOne(int sequence, double solutionValue); /** Sets bounds and cost for outgoing variable may change value Returns direction */ int setOneOutgoing(int sequence, double &solutionValue); /// Returns nearest bound double nearest(int sequence, double solutionValue);
• ## branches/pre/include/ClpPackedMatrix.hpp

 r205 virtual void deleteRows(const int numDel, const int * indDel) { matrix_->deleteRows(numDel,indDel);}; /// Append Columns virtual void appendCols(int number, const CoinPackedVectorBase * const * columns) { matrix_->appendCols(number,columns);}; /// Append Rows virtual void appendRows(int number, const CoinPackedVectorBase * const * rows) { matrix_->appendRows(number,rows);}; /** Replace the elements of a vector.  The indices remain the same. This is only needed if scaling and a row copy is used.
• ## branches/pre/include/ClpPlusMinusOneMatrix.hpp

 r207 /** Delete the rows whose indices are listed in indDel. */ virtual void deleteRows(const int numDel, const int * indDel); /// Append Columns virtual void appendCols(int number, const CoinPackedVectorBase * const * columns); /// Append Rows virtual void appendRows(int number, const CoinPackedVectorBase * const * rows); /** Returns a new matrix in reverse order without gaps */ virtual ClpMatrixBase * reverseOrderedCopy() const;
• ## branches/pre/include/ClpPrimalColumnSteepest.hpp

 r180 ///@name Constructors and destructors //@{ /// Default Constructor ClpPrimalColumnSteepest(int mode=0); /** Default Constructor 0 is exact devex, 1 full steepest, 2 is partial exact devex 3 switches between 0 and 2 depending on factorization 4 starts as partial dantzig but then may switch between 0 and 2. By partial exact devex is meant that the weights are updated as normal but only part of the nonbasic variables are scanned. This can be faster on very easy problems. */ ClpPrimalColumnSteepest(int mode=3); /// Copy constructor */ int state_; /// If 0 then we are using exact devex, 1 then full /** 0 is exact devex, 1 full steepest, 2 is partial exact devex 3 switches between 0 and 2 depending on factorization 4 starts as partial dantzig but then may switch between 0 and 2. By partial exact devex is meant that the weights are updated as normal but only part of the nonbasic variables are scanned. This can be faster on very easy problems.*/ int mode_; /// Number of times switched from partial dantzig to 0/2 int numberSwitched_; // This is pivot row (or pivot sequence round re-factorization) int pivotSequence_;
• ## branches/pre/include/ClpSimplex.hpp

 r208 #include "ClpModel.hpp" #include "ClpMatrixBase.hpp" #include "ClpSolve.hpp" class ClpDualRowPivot; class ClpPrimalColumnPivot; public: /** enums for solve function */ enum SolveType { useDual=0, usePrimal, useSprint, automatic }; enum PresolveType { presolveOn=0, presolveOff, presolveMaximum }; /** enums for status of various sorts. First 4 match CoinWarmStartBasis, /**@name Functions most useful to user */ //@{ /** General solve algorithm which can do presolve special options (bits) 1 - do not perturb 2 - do not scale 4 - use crash (default allslack in dual, idiot in primal) 8 - all slack basis in primal 16 - switch off interrupt handling 32 - do not try and make plus minus one matrix /** General solve algorithm which can do presolve. See  ClpSolve.hpp for options */ int initialSolve(SolveType method=useDual, PresolveType presolve=presolveOn, int specialOptions=0); int initialSolve(ClpSolve & options); /** Dual algorithm - see ClpSimplexDual.hpp for method */ int dual(int ifValuesPass=0); st_byte |= status; }; /** Normally the first factorization does sparse coding because the factorization could be singular.  This allows initial dense factorization when it is known to be safe */ void setInitialDenseFactorization(bool onOff); bool  initialDenseFactorization() const; /** Return sequence In or Out */ inline int sequenceIn() const 2 - Keep nonLinearCost round solves 4 - Force outgoing variables to exact bound (primal) 8 - Safe to use dense initial factorization */ unsigned int specialOptions_;
• ## branches/pre/include/ClpSimplexPrimal.hpp

 r180 ClpSimplexProgress * progress); /// Perturbs problem (method depends on perturbation()) void perturb(); /// Take off effect of perturbation void unPerturb(); void perturb(int type); /// Take off effect of perturbation and say whether to try dual bool unPerturb(); /// Unflag all variables and return number unflagged int unflag();
Note: See TracChangeset for help on using the changeset viewer.