Changeset 47


Ignore:
Timestamp:
Nov 1, 2002 3:04:25 PM (17 years ago)
Author:
forrest
Message:

Some tidying up

Location:
branches/devel-1
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • branches/devel-1/ClpPrimalColumnSteepest.cpp

    r40 r47  
    542542      tolerance *= model_->largestDualError()/checkTolerance;
    543543  }
     544  // stop last one coming immediately
     545  double saveOutInfeasibility=0.0;
     546  if (sequenceOut>=0) {
     547    saveOutInfeasibility = infeas[sequenceOut];
     548    infeas[sequenceOut]=0.0;
     549  }
    544550  tolerance *= tolerance; // as we are using squares
    545551  for (i=0;i<number;i++) {
     
    559565      }
    560566    }
     567  }
     568  if (sequenceOut>=0) {
     569    infeas[sequenceOut]=saveOutInfeasibility;
    561570  }
    562571  /*if (model_->numberIterations()%100==0)
  • branches/devel-1/ClpSimplex.cpp

    r45 r47  
    352352  for (iRow=0;iRow<numberRows_;iRow++) {
    353353    int iPivot=pivotVariable_[iRow];
    354     if (iPivot>=numberColumns_) {
    355       // slack
    356       array[iRow] = rowObjectiveWork_[iPivot-numberColumns_];
    357     } else {
    358       // column
    359       array[iRow]=objectiveWork_[iPivot];
    360     }
     354    array[iRow]=cost_[iPivot];
    361355  }
    362356  ClpDisjointCopyN ( array, numberRows_ , save);
     
    717711          if (getRowStatus(iRow)==basic)
    718712            numberBasic++;
    719           else
     713          else {
    720714            setRowStatus(iRow,superBasic);
     715            // but put to bound if close
     716            if (fabs(rowActivityWork_[iRow]-rowLowerWork_[iRow])
     717                <=primalTolerance_)
     718              rowActivityWork_[iRow]=rowLowerWork_[iRow];
     719            else if (fabs(rowActivityWork_[iRow]-rowUpperWork_[iRow])
     720                <=primalTolerance_)
     721              rowActivityWork_[iRow]=rowUpperWork_[iRow];
     722          }
     723         
    721724        }
    722725        totalSlacks=numberBasic;
    723726        for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    724727          if (getColumnStatus(iColumn)==basic) {
    725             if (numberBasic==numberRows_)
     728            if (numberBasic==numberRows_) {
    726729              // take out of basis
    727730              setColumnStatus(iColumn,superBasic);
    728             else
     731              // but put to bound if close
     732              if (fabs(columnActivityWork_[iColumn]-columnLowerWork_[iColumn])
     733                  <=primalTolerance_)
     734                columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
     735              else if (fabs(columnActivityWork_[iColumn]
     736                            -columnUpperWork_[iColumn])
     737                       <=primalTolerance_)
     738                columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
     739            } else
    729740              numberBasic++;
    730741          } else {
    731742            setColumnStatus(iColumn,superBasic);
     743            // but put to bound if close
     744            if (fabs(columnActivityWork_[iColumn]-columnLowerWork_[iColumn])
     745                <=primalTolerance_)
     746              columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
     747            else if (fabs(columnActivityWork_[iColumn]
     748                          -columnUpperWork_[iColumn])
     749                     <=primalTolerance_)
     750              columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
    732751          }
    733752        }
     
    744763        for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    745764          setColumnStatus(iColumn,superBasic);
     765          // but put to bound if close
     766          if (fabs(columnActivityWork_[iColumn]-columnLowerWork_[iColumn])
     767              <=primalTolerance_)
     768            columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
     769          else if (fabs(columnActivityWork_[iColumn]
     770                        -columnUpperWork_[iColumn])
     771                   <=primalTolerance_)
     772            columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
    746773        }
    747774      }
     
    9801007        value = upperOut_;
    9811008      }
    982       nonLinearCost_->setOne(sequenceOut_,value);
    9831009      double lowerValue = lower_[sequenceOut_];
    9841010      double upperValue = upper_[sequenceOut_];
     
    10021028      }
    10031029      solution_[sequenceOut_]=value;
     1030      nonLinearCost_->setOne(sequenceOut_,value);
    10041031    }
    10051032  }
     
    10151042  handler_->printing(algorithm_>0)<<dualIn_<<theta_;
    10161043  handler_->message()<<CoinMessageEol;
    1017 
    10181044  if (numberIterations_>=maximumIterations_)
    10191045    return 2;
     
    27742800    bool matchedOnInfeasibilities =
    27752801      (numberInfeasibilities==numberInfeasibilities_[i]);
     2802
    27762803    if (matchedOnObjective&&matchedOnInfeasibility&&matchedOnInfeasibilities) {
    27772804      matched |= (1<<i);
  • branches/devel-1/ClpSimplexPrimal.cpp

    r43 r47  
    500500#endif
    501501      if ((saveDj*dualIn_<1.0e-20&&!ifValuesPass)||
    502           fabs(saveDj-dualIn_)>1.0e-5*(1.0+fabs(saveDj))) {
     502          fabs(saveDj-dualIn_)>1.0e-3*(1.0+fabs(saveDj))) {
    503503        handler_->message(CLP_PRIMAL_DJ,messages_)
    504504          <<saveDj<<dualIn_
     
    509509          pivotRow_=-1; // say no weights update
    510510          returnCode=-2;
     511          if(saveNumber+1 == numberIterations_) {
     512            // not looking wonderful - try cleaning bounds
     513            // put non-basics to bounds in case tolerance moved
     514            nonLinearCost_->checkInfeasibilities(true);
     515          }
    511516          break;
    512517        } else {
    513518          // take on more relaxed criterion
    514519          if (saveDj*dualIn_<1.0e-20||
    515               fabs(saveDj-dualIn_)>1.0e-4*(1.0+fabs(dualIn_))) {
     520              fabs(saveDj-dualIn_)>1.0e-1*(1.0+fabs(dualIn_))) {
    516521            // need to reject something
    517522            char x = isColumn(sequenceIn_) ? 'C' :'R';
     
    737742      // save nonlinear cost as we are going to switch off costs
    738743      ClpNonLinearCost * nonLinear = nonLinearCost_;
     744      // do twice to make sure Primal solution has settled
     745      // put non-basics to bounds in case tolerance moved
     746      nonLinearCost_->checkInfeasibilities(true);
     747      gutsOfSolution(rowActivityWork_, columnActivityWork_);
     748
    739749      infeasibilityCost_=1.0e100;
    740750      // put back original bounds
     
    12251235    sequenceOut_ = pivotVariable_[pivotRow_];
    12261236    valueOut_ = solution(sequenceOut_);
     1237    lowerOut_=lower_[sequenceOut_];
     1238    upperOut_=upper_[sequenceOut_];
     1239
    12271240    if (way<0.0)
    12281241      theta_ = - theta_;
     
    12301243    if (alpha_*way<0.0) {
    12311244      directionOut_=-1;      // to upper bound
    1232       if (fabs(theta_)>0.1)
     1245      if (fabs(theta_)>1.0e-6)
    12331246        upperOut_ = nonLinearCost_->nearest(sequenceOut_,newValue);
    12341247      else
     
    12361249    } else {
    12371250      directionOut_=1;      // to lower bound
    1238       if (fabs(theta_)>0.1)
     1251      if (fabs(theta_)>1.0e-6)
    12391252        lowerOut_ = nonLinearCost_->nearest(sequenceOut_,newValue);
    12401253      else
  • branches/devel-1/Makefile.Clp

    r43 r47  
    4444LIBSRC += PresolveUseless.cpp             
    4545
     46#LIBSRC += Idiot.cpp
     47#LIBSRC += IdiSolve.cpp
     48
    4649##############################################################################
    4750# You should not need to edit below this line.
     
    5356include ${MakefileDir}/Makefile.location
    5457
     58# Say Idiot code can use Clp interface
     59#CXXFLAGS += -DCLP_IDIOT
    5560CXXFLAGS += -DUSE_PRESOLVE
    5661ifeq ($(OptLevel),-g)
  • branches/devel-1/Presolve.cpp

    r46 r47  
    551551    int iLoop;
    552552#if     DEBUG_PRESOLVE
    553         check_sol(prob,1.0e0);
    554 #endif
    555 
     553    check_sol(prob,1.0e0);
     554#endif
     555
     556    // Check number rows dropped
     557    int lastDropped=0;
    556558    for (iLoop=0;iLoop<numberPasses_;iLoop++) {
    557559#ifdef PRESOLVE_SUMMARY
     
    715717        printf("%d rows dropped after pass %d\n",numberDropped,
    716718               iLoop+1);
     719        if (numberDropped==lastDropped)
     720          break;
     721        else
     722          lastDropped = numberDropped;
    717723      }
    718724      if (paction_ == paction0)
  • branches/devel-1/Test/ClpMain.cpp

    r44 r47  
    3232
    3333#include "Presolve.hpp"
     34#ifdef CLP_IDIOT
     35#include "Idiot.hpp"
     36#endif
    3437// For Branch and bound
    3538//  #include "OsiClpSolverInterface.hpp"
     
    6871
    6972int mainTest (int argc, const char *argv[],bool doDual,
    70               ClpSimplex empty, bool doPresolve);
     73              ClpSimplex empty, bool doPresolve,int doIdiot);
    7174enum ClpParameterType {
    7275  GENERALQUERY=-100,
     
    7477  DUALTOLERANCE=1,PRIMALTOLERANCE,DUALBOUND,PRIMALWEIGHT,
    7578
    76   LOGLEVEL=101,MAXFACTOR,PERTURBATION,MAXITERATION,PRESOLVEPASS,
     79  LOGLEVEL=101,MAXFACTOR,PERTURBATION,MAXITERATION,PRESOLVEPASS,IDIOT,
    7780 
    7881  DIRECTION=201,DUALPIVOT,SCALING,ERRORSALLOWED,KEEPNAMES,SPARSEFACTOR,
     
    800803    parameters[numberParameters-1].append("on");
    801804    parameters[numberParameters++]=
     805      ClpItem("idiot!Crash","Whether to try idiot crash",
     806              0,200,IDIOT);
     807    parameters[numberParameters++]=
    802808      ClpItem("passP!resolve","How many passes in presolve",
    803809              0,100,PRESOLVEPASS);
     
    898904    int keepImportNames=1;
    899905    int preSolve=0;
     906    int doIdiot=0;
    900907   
    901908    int iModel=0;
     
    9991006            if (parameters[iParam].type()==PRESOLVEPASS)
    10001007              preSolve = value;
     1008            else if (parameters[iParam].type()==IDIOT)
     1009              doIdiot = value;
    10011010            else
    10021011              parameters[iParam].setIntParameter(models+iModel,value);
     
    11041113              currentModel = model2;
    11051114#endif
    1106               if (type==DUALSIMPLEX)
     1115              if (type==DUALSIMPLEX) {
    11071116                model2->dual();
    1108               else
    1109                 model2->primal();
     1117              } else {
     1118#ifdef CLP_IDIOT
     1119                if (doIdiot) {
     1120                  Idiot info(*model2);
     1121                  info.crash(doIdiot);
     1122                }
     1123#endif
     1124                model2->primal(1);
     1125              }
    11101126#ifdef USE_PRESOLVE
    11111127              if (preSolve) {
     
    11191135#endif
    11201136                models[iModel].primal(1);
    1121 #ifdef CLP_DEBUG
     1137#ifdef CLP_DEBUG_not
    11221138                models[iModel].checkSolution();
    11231139                printf("%g dual %g(%d) Primal %g(%d)\n",
     
    13921408                std::cerr<<"Doing netlib with primal agorithm"<<std::endl;
    13931409              mainTest(nFields,fields,(type==NETLIB_DUAL),models[iModel],
    1394                        (preSolve!=0));
     1410                       (preSolve!=0),doIdiot);
    13951411            }
    13961412            break;
     
    14061422                nFields=3;
    14071423              }
    1408               mainTest(nFields,fields,false,models[iModel],(preSolve!=0));
     1424              mainTest(nFields,fields,false,models[iModel],(preSolve!=0),
     1425                       false);
    14091426            }
    14101427            break;
  • branches/devel-1/Test/Makefile.test

    r33 r47  
    2525CXXFLAGS += $(OPTFLAG)
    2626CXXFLAGS += -DUSE_PRESOLVE
     27#CXXFLAGS += -DCLP_IDIOT
    2728#ifeq ($(OPTFLAG),-g)
    28     CXXFLAGS += -DCLP_DEBUG -DPRESOLVE_SUMMARY=1
     29#    CXXFLAGS += -DCLP_DEBUG -DPRESOLVE_SUMMARY=1
    2930#endif
    3031
  • branches/devel-1/Test/unitTest.cpp

    r45 r47  
    3232
    3333#include "Presolve.hpp"
     34#ifdef CLP_IDIOT
     35#include "Idiot.hpp"
     36#endif
    3437
    3538//#############################################################################
     
    5760
    5861int mainTest (int argc, const char *argv[],bool doDual,
    59               ClpSimplex empty, bool doPresolve)
     62              ClpSimplex empty, bool doPresolve,int doIdiot)
    6063{
    6164  int i;
     
    269272        Presolve pinfo;
    270273        ClpSimplex * model2 = pinfo.presolvedModel(solution,1.0e-8);
    271         if (doDual)
     274        if (doDual) {
    272275          model2->dual();
    273         else
    274           model2->primal();
     276        } else {
     277#ifdef CLP_IDIOT
     278          if (doIdiot) {
     279            Idiot info(*model2);
     280            info.crash(doIdiot);
     281          }
     282#endif
     283          model2->primal(1);
     284        }
    275285        pinfo.postsolve(true);
    276286       
     
    301311          solution.dual();
    302312        } else {
    303           solution.primal();
     313#ifdef CLP_IDIOT
     314          if (doIdiot) {
     315            Idiot info(solution);
     316            info.crash(doIdiot);
     317          }
     318#endif
     319          solution.primal(1);
    304320        }
    305321#endif
     
    308324          solution.dual();
    309325        } else {
    310           solution.primal();
     326#ifdef CLP_IDIOT
     327          if (doIdiot) {
     328            Idiot info(solution);
     329            info.crash(doIdiot);
     330          }
     331#endif
     332          solution.primal(1);
    311333        }
    312334      }
  • branches/devel-1/include/ClpSimplex.hpp

    r45 r47  
    760760  //@}
    761761  /**@name Data  */
    762 #define CLP_PROGRESS 4
     762#define CLP_PROGRESS 5
    763763  //@{
    764764  /// Objective values
  • branches/devel-1/include/Presolve.hpp

    r45 r47  
    102102  ClpSimplex * originalModel_;
    103103
    104   /// Presolved model - up to user to destroy
     104  /// Presolved model - up to user to destroy by deletePresolvedModel
    105105  ClpSimplex * presolvedModel_;
    106106  /// Original column numbers
Note: See TracChangeset for help on using the changeset viewer.