Changeset 205 for branches


Ignore:
Timestamp:
Sep 5, 2003 2:19:26 PM (16 years ago)
Author:
forrest
Message:

Trying to go faster

Location:
branches/pre
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • branches/pre/ClpDualRowSteepest.cpp

    r196 r205  
    2424    infeasible_(NULL),
    2525    alternateWeights_(NULL),
    26     savedWeights_(NULL)
     26    savedWeights_(NULL),
     27    dubiousWeights_(NULL)
    2728{
    2829  type_=2+64*mode;
     
    6162    savedWeights_=NULL;
    6263  }
     64  if (rhs.dubiousWeights_) {
     65    assert(model_);
     66    int number = model_->numberRows();
     67    dubiousWeights_= new int[number];
     68    ClpDisjointCopyN(rhs.dubiousWeights_,number,dubiousWeights_);
     69  } else {
     70    dubiousWeights_=NULL;
     71  }
    6372}
    6473
     
    6978{
    7079  delete [] weights_;
     80  delete [] dubiousWeights_;
    7181  delete infeasible_;
    7282  delete alternateWeights_;
     
    8696    model_ = rhs.model_;
    8797    delete [] weights_;
     98    delete [] dubiousWeights_;
    8899    delete infeasible_;
    89100    delete alternateWeights_;
     
    111122    } else {
    112123      savedWeights_=NULL;
     124    }
     125    if (rhs.dubiousWeights_) {
     126      assert(model_);
     127      int number = model_->numberRows();
     128      dubiousWeights_= new int[number];
     129      ClpDisjointCopyN(rhs.dubiousWeights_,number,dubiousWeights_);
     130    } else {
     131      dubiousWeights_=NULL;
    113132    }
    114133  }
     
    205224  start[0]=(int) dstart;
    206225  start[3]=start[0];
     226  //double largestWeight=0.0;
    207227  for (iPass=0;iPass<2;iPass++) {
    208228    int end = start[2*iPass+1];
     
    211231      double value = infeas[iRow];
    212232      if (value>tolerance) {
    213         if (value>largest*weights_[iRow]) {
     233        double weight = weights_[iRow];
     234        //double dubious = dubiousWeights_[iRow];
     235        //weight *= dubious;
     236        //if (value>2.0*largest*weight||(value>0.5*largest*weight&&value*largestWeight>dubious*largest*weight)) {
     237        if (value>largest*weight) {
    214238          // make last pivot row last resort choice
    215239          if (iRow==lastPivotRow) {
    216             if (value*1.0e-10<largest*weights_[iRow])
     240            if (value*1.0e-10<largest*weight)
    217241              continue;
    218242            else
     
    233257                solution[iSequence]<lower[iSequence]-tolerance) {
    234258              chosenRow=iRow;
    235               largest=value/weights_[iRow];
     259              largest=value/weight;
     260              //largestWeight = dubious;
    236261            }
    237262          }
     
    701726  }
    702727  if (mode>=2) {
     728    // Get dubious weights
     729    //if (!dubiousWeights_)
     730    //dubiousWeights_=new int[numberRows];
     731    //model_->factorization()->getWeights(dubiousWeights_);
    703732    infeasible_->clear();
    704733    int iRow;
     
    780809  delete [] weights_;
    781810  weights_=NULL;
     811  delete [] dubiousWeights_;
     812  dubiousWeights_=NULL;
    782813  delete infeasible_;
    783814  infeasible_ = NULL;
  • branches/pre/ClpMatrixBase.cpp

    r199 r205  
    77
    88#include "ClpMatrixBase.hpp"
     9#include "ClpSimplex.hpp"
    910
    1011//#############################################################################
     
    9192  abort();
    9293}
     94/* Given positive integer weights for each row fills in sum of weights
     95   for each column (and slack).
     96   Returns weights vector
     97   Default returns vector of ones
     98*/
     99CoinBigIndex *
     100ClpMatrixBase::dubiousWeights(const ClpSimplex * model,int * inputWeights) const
     101{
     102  int number = model->numberRows()+model->numberColumns();
     103  CoinBigIndex * weights = new CoinBigIndex[number];
     104  int i;
     105  for (i=0;i<number;i++)
     106    weights[i]=1;
     107  return weights;
     108}
  • branches/pre/ClpModel.cpp

    r204 r205  
    124124    dblParam_[ClpDualTolerance]=value;
    125125}
    126 void ClpModel::setOptimizationDirection( int value)
    127 {
    128   if (value>=-1&&value<=1)
    129     optimizationDirection_=value;
     126void ClpModel::setOptimizationDirection( double value)
     127{
     128  optimizationDirection_=value;
    130129}
    131130void
     
    11091108   
    11101109  const double obj = objectiveValue();
    1111   const int maxmin = optimizationDirection();
     1110  const double maxmin = optimizationDirection();
    11121111
    11131112  if (problemStatus_ == 0) // optimal
     
    11301129   
    11311130  const double obj = objectiveValue();
    1132   const int maxmin = optimizationDirection();
     1131  const double maxmin = optimizationDirection();
    11331132
    11341133  if (problemStatus_ == 0) // optimal
  • branches/pre/ClpPackedMatrix.cpp

    r200 r205  
    15201520  return true;
    15211521}
     1522/* Given positive integer weights for each row fills in sum of weights
     1523   for each column (and slack).
     1524   Returns weights vector
     1525*/
     1526CoinBigIndex *
     1527ClpPackedMatrix::dubiousWeights(const ClpSimplex * model,int * inputWeights) const
     1528{
     1529  int numberRows = model->numberRows();
     1530  int numberColumns =model->numberColumns();
     1531  int number = numberRows+numberColumns;
     1532  CoinBigIndex * weights = new CoinBigIndex[number];
     1533  // get matrix data pointers
     1534  const int * row = matrix_->getIndices();
     1535  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
     1536  const int * columnLength = matrix_->getVectorLengths();
     1537  int i;
     1538  for (i=0;i<numberColumns;i++) {
     1539    CoinBigIndex j;
     1540    CoinBigIndex count=0;
     1541    for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
     1542      int iRow=row[j];
     1543      count += inputWeights[iRow];
     1544    }
     1545    weights[i]=count;
     1546  }
     1547  for (i=0;i<numberRows;i++) {
     1548    weights[i+numberColumns]=inputWeights[i];
     1549  }
     1550  return weights;
     1551}
    15221552
    15231553
  • branches/pre/ClpSimplex.cpp

    r204 r205  
    19341934  if ((what&(16+32))!=0) {
    19351935    // move information to work arrays
    1936     if (optimizationDirection_<0.0) {
     1936    double direction = optimizationDirection_;
     1937    // direction is actually scale out not scale in
     1938    if (direction)
     1939      direction = 1.0/direction;
     1940    if (direction!=1.0) {
    19371941      // reverse all dual signs
    19381942      for (i=0;i<numberColumns_;i++)
    1939         reducedCost_[i] = -reducedCost_[i];
     1943        reducedCost_[i] *= direction;
    19401944      for (i=0;i<numberRows_;i++)
    1941         dual_[i] = -dual_[i];
     1945        dual_[i] *= direction;
    19421946    }
    19431947    // row reduced costs
     
    21912195    }
    21922196  }
    2193   // direction may have been modified by scaling - clean up
    2194   if (optimizationDirection_>0.0) {
    2195     optimizationDirection_ = 1.0;
    2196   }  else if (optimizationDirection_<0.0) {
    2197     optimizationDirection_ = -1.0;
    2198     // and reverse all dual signs
     2197  if (optimizationDirection_!=1.0) {
     2198    // and modify all dual signs
    21992199    for (i=0;i<numberColumns_;i++)
    2200       reducedCost_[i] = -reducedCost_[i];
     2200      reducedCost_[i] *= optimizationDirection_;
    22012201    for (i=0;i<numberRows_;i++)
    2202       dual_[i] = -dual_[i];
     2202      dual_[i] *= optimizationDirection_;
    22032203  }
    22042204  // scaling may have been turned off
     
    34763476    //double objectiveValue=0.0;
    34773477    int iColumn;
     3478    double direction = optimizationDirection_;
     3479    // direction is actually scale out not scale in
     3480    if (direction)
     3481      direction = 1.0/direction;
    34783482    for (iColumn=0;iColumn<numberColumns_;iColumn++)
    3479       dj[iColumn] = optimizationDirection_*linearObjective[iColumn];
     3483      dj[iColumn] = direction*linearObjective[iColumn];
    34803484    for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    34813485      // assume natural place is closest to zero
  • branches/pre/ClpSimplexDual.cpp

    r204 r205  
    362362    ((double ) (numberPrimalInfeasibilities_+1));
    363363
     364  // Get dubious weights
     365  factorization_->getWeights(rowArray_[0]->getIndices());
     366  CoinBigIndex * dubiousWeights = matrix_->dubiousWeights(this,rowArray_[0]->getIndices());
    364367  // If values pass then get list of candidates
    365368  int * candidateList = NULL;
     
    584587        // do ratio test for normal iteration
    585588        dualColumn(rowArray_[0],columnArray_[0],columnArray_[1],
    586                  rowArray_[3],acceptablePivot);
     589                 rowArray_[3],acceptablePivot,dubiousWeights);
    587590      } else {
    588591        double direction=directionOut_;
     
    595598        // do ratio test
    596599        checkPossibleValuesMove(rowArray_[0],columnArray_[0],
    597                                             acceptablePivot);
     600                                            acceptablePivot,NULL);
    598601
    599602        // recompute true dualOut_
     
    927930    delete [] candidateList;
    928931  }
     932  delete [] dubiousWeights;
    929933  return returnCode;
    930934}
     
    15661570                           CoinIndexedVector * spareArray,
    15671571                           CoinIndexedVector * spareArray2,
    1568                            double acceptablePivot)
     1572                           double acceptablePivot,
     1573                           CoinBigIndex * dubiousWeights)
    15691574{
    15701575  double * work;
     
    19081913          bestPivot=acceptablePivot;
    19091914          sequenceIn_=-1;
     1915          double bestWeight=COIN_DBL_MAX;
     1916          double largestPivot=acceptablePivot;
    19101917          // now choose largest and sum all ones which will go through
     1918          //printf("XX it %d number %d\n",numberIterations_,interesting[iFlip]);
    19111919          for (i=0;i<interesting[iFlip];i++) {
    19121920            int iSequence=index[i];
     
    19511959              index2[numberPossiblySwapped]=iSequence;
    19521960              // select if largest pivot
    1953               if (fabs(alpha)>bestPivot) {
     1961              bool take=false;
     1962              double absAlpha = fabs(alpha);
     1963              double weight;
     1964              if (dubiousWeights)
     1965                weight=dubiousWeights[iSequence];
     1966              else
     1967                weight=1.0;
     1968              weight += CoinDrand48()*1.0e-2;
     1969              if (absAlpha>2.0*bestPivot) {
     1970                take=true;
     1971              } else if (absAlpha>0.5*largestPivot) {
     1972                // could multiply absAlpha and weight
     1973                if (weight*bestPivot<bestWeight*absAlpha)
     1974                  take=true;
     1975              }
     1976              if (take) {
    19541977                sequenceIn_ = numberPossiblySwapped;
    1955                 bestPivot =  fabs(alpha);
     1978                bestPivot =  absAlpha;
    19561979                theta_ = dj_[iSequence]/alpha;
     1980                largestPivot = max(largestPivot,bestPivot);
     1981                bestWeight = weight;
     1982                //printf(" taken seq %d alpha %g weight %d\n",
     1983                //   iSequence,absAlpha,dubiousWeights[iSequence]);
     1984              } else {
     1985                //printf(" not taken seq %d alpha %g weight %d\n",
     1986                //   iSequence,absAlpha,dubiousWeights[iSequence]);
    19571987              }
    19581988              double range = upper[iSequence] - lower[iSequence];
     
    20072037            iFlip = 1 -iFlip;
    20082038            modifyCosts=true; // fine grain - we can modify costs
    2009         }
     2039          }
    20102040        }
    20112041        if (iTry==MAXTRY)
     
    23462376    double largest;
    23472377    largest=0.0;
     2378    // direction is actually scale out not scale in
     2379    if (direction)
     2380      direction = 1.0/direction;
    23482381    for (i=0;i<numberRows_;i++) {
    2349       rowObjectiveSimplex[i] *= optimizationDirection_;
     2382      rowObjectiveSimplex[i] *= direction;
    23502383      double difference = fabs(rowObjectiveWork_[i]-rowObjectiveSimplex[i]);
    23512384      if (difference>largest)
     
    23532386    }
    23542387    for (i=0;i<numberColumns_;i++) {
    2355       objectiveSimplex[i] *= optimizationDirection_;
     2388      objectiveSimplex[i] *= direction;
    23562389      double difference = fabs(objectiveWork_[i]-objectiveSimplex[i]);
    23572390      if (difference>largest)
     
    28692902  if (perturbation_>100)
    28702903    return; //perturbed already
    2871   bool modifyRowCosts=true;
     2904  bool modifyRowCosts=false;
    28722905  // dual perturbation
    28732906  double perturbation=1.0e-20;
     
    28752908  double maximumFraction = 1.0e-4;
    28762909  double factor=1.0e-8;
    2877   // If > 70 then do not do rows
     2910  // If > 70 then do rows
    28782911  if (perturbation_>70) {
    2879     modifyRowCosts=false;
     2912    modifyRowCosts=true;
    28802913    perturbation_ -= 20;
    2881     //printf("Row costs not modified, ");
     2914    //printf("Row costs modified, ");
    28822915  }
    28832916  if (perturbation_>50) {
     
    29142947    // but some experiments
    29152948    if (perturbation_<=-900) {
    2916       modifyRowCosts=false;
     2949      modifyRowCosts=true;
    29172950      perturbation_ += 1000;
    2918       //printf("Row costs not modified, ");
     2951      //printf("Row costs modified, ");
    29192952    }
    29202953    if (perturbation_<-50) {
     
    34753508ClpSimplexDual::checkPossibleValuesMove(CoinIndexedVector * rowArray,
    34763509                                        CoinIndexedVector * columnArray,
    3477                                         double acceptablePivot)
     3510                                        double acceptablePivot,
     3511                                        CoinBigIndex * dubiousWeights)
    34783512{
    34793513  double * work;
  • branches/pre/ClpSimplexPrimalQuadratic.cpp

    r204 r205  
    6060  // Are we minimizing or maximizing
    6161  double whichWay=optimizationDirection();
     62  if (whichWay<0.0)
     63    whichWay=-1.0;
     64  else if (whichWay>0.0)
     65    whichWay=1.0;
     66
    6267  // This is as a user would see
    6368
     
    461466  // redo values
    462467  setDblParam(ClpObjOffset,objectiveOffset);
    463   objectiveValue_ += optimizationDirection_*offset;
     468  objectiveValue_ += whichWay*offset;
    464469  for (jNon=0;jNon<numberNonLinearColumns;jNon++) {
    465470    iColumn=listNonLinearColumn[jNon];
  • branches/pre/Test/ClpMain.cpp

    r204 r205  
    1414#include "CoinPragma.hpp"
    1515#include "CoinHelperFunctions.hpp"
    16 #define CLPVERSION "0.97.4"
     16#define CLPVERSION "0.98.1"
    1717
    1818#include "CoinMpsIO.hpp"
     
    5555  GENERALQUERY=-100,
    5656 
    57   DUALTOLERANCE=1,PRIMALTOLERANCE,DUALBOUND,PRIMALWEIGHT,
     57  DUALTOLERANCE=1,PRIMALTOLERANCE,DUALBOUND,PRIMALWEIGHT,MAXTIME,OBJSCALE,
    5858
    5959  LOGLEVEL=101,MAXFACTOR,PERTURBATION,MAXITERATION,PRESOLVEPASS,IDIOT,
     
    6262  PRIMALPIVOT,PRESOLVE,CRASH,BIASLU,
    6363 
    64   DIRECTORY=301,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,BAB,
     64  DIRECTORY=301,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,
    6565  MAXIMIZE,MINIMIZE,EXIT,STDIN,UNITTEST,NETLIB_DUAL,NETLIB_PRIMAL,SOLUTION,
    6666  TIGHTEN,FAKEBOUND,VERSION,PLUSMINUS,NETWORK,
     
    7878  ClpItem (  );
    7979  ClpItem (std::string name, std::string help,
    80            double lower, double upper, ClpParameterType type);
     80           double lower, double upper, ClpParameterType type,bool display=true);
    8181  ClpItem (std::string name, std::string help,
    82            int lower, int upper, ClpParameterType type);
     82           int lower, int upper, ClpParameterType type,bool display=true);
    8383  // Other strings will be added by insert
    8484  ClpItem (std::string name, std::string help, std::string defaultValue,
    85            ClpParameterType type);
     85           ClpParameterType type,bool display=true);
    8686  // Action
    8787  ClpItem (std::string name, std::string help,
    88            ClpParameterType type);
     88           ClpParameterType type,bool display=true);
    8989  /// Copy constructor.
    9090  ClpItem(const ClpItem &);
     
    134134  inline ClpParameterType type() const
    135135  { return type_;};
     136  /// whether to display
     137  inline bool displayThis() const
     138  { return display_;};
    136139private:
    137140  /// gutsOfConstructor
     
    169172  /// Current keyWord (if a keyword parameter)
    170173  int currentKeyWord_;
     174  /// Display on ?
     175  bool display_;
    171176  //@}
    172177};
     
    191196    longHelp_(),
    192197    action_(INVALID),
    193     currentKeyWord_(-1)
     198    currentKeyWord_(-1),
     199    display_(false)
    194200{
    195201}
    196202// Other constructors
    197203ClpItem::ClpItem (std::string name, std::string help,
    198            double lower, double upper, ClpParameterType type)
     204           double lower, double upper, ClpParameterType type,bool display)
    199205  : type_(type),
    200206    lowerIntValue_(0),
     
    205211    longHelp_(),
    206212    action_(type),
    207     currentKeyWord_(-1)
     213    currentKeyWord_(-1),
     214    display_(display)
    208215{
    209216  lowerDoubleValue_ = lower;
     
    212219}
    213220ClpItem::ClpItem (std::string name, std::string help,
    214            int lower, int upper, ClpParameterType type)
     221           int lower, int upper, ClpParameterType type,bool display)
    215222  : type_(type),
    216223    lowerDoubleValue_(0.0),
     
    221228    longHelp_(),
    222229    action_(type),
    223     currentKeyWord_(-1)
     230    currentKeyWord_(-1),
     231    display_(display)
    224232{
    225233  gutsOfConstructor();
     
    230238ClpItem::ClpItem (std::string name, std::string help,
    231239                  std::string defaultValue,
    232                   ClpParameterType type)
     240                  ClpParameterType type,bool display)
    233241  : type_(type),
    234242    lowerDoubleValue_(0.0),
     
    241249    longHelp_(),
    242250    action_(type),
    243     currentKeyWord_(0)
     251    currentKeyWord_(0),
     252    display_(display)
    244253{
    245254  gutsOfConstructor();
     
    248257// Action
    249258ClpItem::ClpItem (std::string name, std::string help,
    250            ClpParameterType type)
     259           ClpParameterType type,bool display)
    251260  : type_(type),
    252261    lowerDoubleValue_(0.0),
     
    259268    longHelp_(),
    260269    action_(type),
    261     currentKeyWord_(-1)
     270    currentKeyWord_(-1),
     271    display_(display)
    262272{
    263273  gutsOfConstructor();
     
    282292  action_ = rhs.action_;
    283293  currentKeyWord_ = rhs.currentKeyWord_;
    284  
     294  display_=rhs.display_;
    285295}
    286296
     
    312322    action_ = rhs.action_;
    313323    currentKeyWord_ = rhs.currentKeyWord_;
     324    display_=rhs.display_;
    314325  }
    315326  return *this;
     
    453464      model->setInfeasibilityCost(value);
    454465      break;
     466    case MAXTIME:
     467      model->setMaximumSeconds(value);
     468      break;
     469    case OBJSCALE:
     470      model->setOptimizationDirection(value);
     471      break;
    455472    default:
    456473      abort();
     
    475492  case PRIMALWEIGHT:
    476493    value=model->infeasibilityCost();
     494    break;
     495  case MAXTIME:
     496    value=model->maximumSeconds();
     497    break;
     498  case OBJSCALE:
     499    value=model->optimizationDirection();
    477500    break;
    478501  default:
     
    527550    break;
    528551  case DIRECTION:
    529     value=model->optimizationDirection();
     552    {
     553      double value2=model->optimizationDirection();
     554      if (value2>0.0)
     555        value=1;
     556      else if (value2<0.0)
     557        value=-1;
     558      else
     559        value=0;
     560    }
    530561    break;
    531562  case PERTURBATION:
     
    731762    int numberParameters=0;
    732763    parameters[numberParameters++]=
    733       ClpItem("?","For help",GENERALQUERY);
    734     parameters[numberParameters++]=
    735       ClpItem("dualT!olerance","For an optimal solution \
    736 no dual infeasibility may exceed this value",
    737               1.0e-20,1.0e12,DUALTOLERANCE);
    738     parameters[numberParameters++]=
    739       ClpItem("primalT!olerance","For an optimal solution \
    740 no primal infeasibility may exceed this value",
    741               1.0e-20,1.0e12,PRIMALTOLERANCE);
     764      ClpItem("?","For help",GENERALQUERY,false);
     765    parameters[numberParameters++]=
     766      ClpItem("-","From stdin",
     767              STDIN,false);
     768    parameters[numberParameters++]=
     769      ClpItem("biasLU","Whether factorization biased towards U",
     770              "UU",BIASLU,false);
     771    parameters[numberParameters-1].append("UX");
     772    parameters[numberParameters-1].append("LX");
     773    parameters[numberParameters-1].append("LL");
     774    parameters[numberParameters++]=
     775      ClpItem("crash","Whether to create basis for problem",
     776              "off",CRASH);
     777    parameters[numberParameters-1].append("on");
     778    parameters[numberParameters++]=
     779      ClpItem("direction","Minimize or Maximize",
     780              "min!imize",DIRECTION);
     781    parameters[numberParameters-1].append("max!imize");
     782    parameters[numberParameters++]=
     783      ClpItem("directory","Set Default import directory",
     784              DIRECTORY);
    742785    parameters[numberParameters++]=
    743786      ClpItem("dualB!ound","Initially algorithm acts as if no \
    744787gap between bounds exceeds this value",
    745788              1.0e-20,1.0e12,DUALBOUND);
    746     parameters[numberParameters++]=
    747       ClpItem("primalW!eight","Initially algorithm acts as if it \
    748 costs this much to be infeasible",
    749               1.0e-20,1.0e12,PRIMALWEIGHT);
    750     parameters[numberParameters++]=
    751       ClpItem("log!Level","Level of detail in output",
    752               0,63,LOGLEVEL);
    753     parameters[numberParameters++]=
    754       ClpItem("maxF!actor","Maximum number of iterations between \
    755 refactorizations",
    756               1,999999,MAXFACTOR);
    757     parameters[numberParameters++]=
    758       ClpItem("maxIt!erations","Maximum number of iterations before \
    759 stopping",
    760               0,99999999,MAXITERATION);
    761     parameters[numberParameters++]=
    762       ClpItem("pert!urbation","Method of perturbation",
    763               -5000,102,PERTURBATION);
    764     parameters[numberParameters++]=
    765       ClpItem("direction","Minimize or Maximize",
    766               "min!imize",DIRECTION);
    767     parameters[numberParameters-1].append("max!imize");
    768789    parameters[numberParameters++]=
    769790      ClpItem("dualP!ivot","Dual pivot choice algorithm",
     
    772793    parameters[numberParameters-1].append("partial");
    773794    parameters[numberParameters++]=
     795      ClpItem("dualS!implex","Do dual simplex algorithm",
     796              DUALSIMPLEX);
     797    parameters[numberParameters++]=
     798      ClpItem("dualT!olerance","For an optimal solution \
     799no dual infeasibility may exceed this value",
     800              1.0e-20,1.0e12,DUALTOLERANCE);
     801    parameters[numberParameters++]=
     802      ClpItem("end","Stops clp execution",
     803              EXIT);
     804    parameters[numberParameters++]=
     805      ClpItem("error!sAllowed","Whether to allow import errors",
     806              "off",ERRORSALLOWED);
     807    parameters[numberParameters++]=
     808      ClpItem("exit","Stops clp execution",
     809              EXIT);
     810    parameters[numberParameters++]=
     811      ClpItem("export","Export model as mps file",
     812              EXPORT);
     813    parameters[numberParameters++]=
     814      ClpItem("fakeB!ound","All bounds <= this value - DEBUG",
     815              1.0,1.0e15,FAKEBOUND,false);
     816    parameters[numberParameters++]=
     817      ClpItem("idiot!Crash","Whether to try idiot crash",
     818              0,200,IDIOT);
     819    parameters[numberParameters++]=
     820      ClpItem("import","Import model from mps file",
     821              IMPORT);
     822    parameters[numberParameters++]=
     823      ClpItem("keepN!ames","Whether to keep names from import",
     824              "on",KEEPNAMES);
     825    parameters[numberParameters-1].append("off");
     826    parameters[numberParameters++]=
     827      ClpItem("log!Level","Level of detail in output",
     828              0,63,LOGLEVEL);
     829    parameters[numberParameters++]=
     830      ClpItem("max!imize","Set optimization direction to maximize",
     831              MAXIMIZE);
     832    parameters[numberParameters++]=
     833      ClpItem("maxF!actor","Maximum number of iterations between \
     834refactorizations",
     835              1,999999,MAXFACTOR);
     836    parameters[numberParameters++]=
     837      ClpItem("maxIt!erations","Maximum number of iterations before \
     838stopping",
     839              0,99999999,MAXITERATION);
     840    parameters[numberParameters++]=
     841      ClpItem("min!imize","Set optimization direction to minimize",
     842              MINIMIZE);
     843    parameters[numberParameters++]=
     844      ClpItem("netlib","Solve entire netlib test set",
     845              NETLIB_DUAL);
     846    parameters[numberParameters++]=
     847      ClpItem("netlibP!rimal","Solve entire netlib test set (primal)",
     848              NETLIB_PRIMAL);
     849    parameters[numberParameters++]=
     850      ClpItem("network","Tries to make network matrix",
     851              NETWORK);
     852    parameters[numberParameters++]=
     853      ClpItem("objective!Scale","Scale factor to apply to objective",
     854              -1.0e20,1.0e20,OBJSCALE);
     855    parameters[numberParameters++]=
     856      ClpItem("passP!resolve","How many passes in presolve",
     857              0,100,PRESOLVEPASS);
     858    parameters[numberParameters++]=
     859      ClpItem("pert!urbation","Method of perturbation",
     860              -5000,102,PERTURBATION);
     861    parameters[numberParameters++]=
     862      ClpItem("plus!Minus","Tries to make +- 1 matrix",
     863              PLUSMINUS);
     864    parameters[numberParameters++]=
     865      ClpItem("presolve","Whether to presolve problem",
     866              "on",PRESOLVE);
     867    parameters[numberParameters-1].append("off");
     868    parameters[numberParameters++]=
    774869      ClpItem("primalP!ivot","Primal pivot choice algorithm",
    775870              "steep!est",PRIMALPIVOT);
     
    777872    parameters[numberParameters-1].append("dant!zig");
    778873    parameters[numberParameters++]=
     874      ClpItem("primalS!implex","Do primal simplex algorithm",
     875              PRIMALSIMPLEX);
     876    parameters[numberParameters++]=
     877      ClpItem("primalT!olerance","For an optimal solution \
     878no primal infeasibility may exceed this value",
     879              1.0e-20,1.0e12,PRIMALTOLERANCE);
     880    parameters[numberParameters++]=
     881      ClpItem("primalW!eight","Initially algorithm acts as if it \
     882costs this much to be infeasible",
     883              1.0e-20,1.0e12,PRIMALWEIGHT);
     884    parameters[numberParameters++]=
     885      ClpItem("quit","Stops clp execution",
     886              EXIT);
     887    parameters[numberParameters++]=
     888      ClpItem("restore!Model","Restore model from binary file",
     889              RESTORE);
     890    parameters[numberParameters++]=
     891      ClpItem("save!Model","Save model to binary file",
     892              SAVE);
     893    parameters[numberParameters++]=
    779894      ClpItem("scal!ing","Whether to scale problem",
    780895              "on",SCALING);
    781896    parameters[numberParameters-1].append("off");
    782897    parameters[numberParameters++]=
    783       ClpItem("presolve","Whether to presolve problem",
    784               "off",PRESOLVE);
     898      ClpItem("sec!onds","maximum seconds",
     899              0.0,1.0e12,MAXTIME);
     900    parameters[numberParameters++]=
     901      ClpItem("sol!ution","Prints solution to file",
     902              SOLUTION);
     903    parameters[numberParameters++]=
     904      ClpItem("spars!eFactor","Whether factorization treated as sparse",
     905              "on",SPARSEFACTOR,false);
     906    parameters[numberParameters-1].append("off");
    785907    parameters[numberParameters-1].append("on");
    786908    parameters[numberParameters++]=
    787       ClpItem("crash","Whether to create basis for problem",
    788               "off",CRASH);
    789     parameters[numberParameters-1].append("on");
    790     parameters[numberParameters++]=
    791       ClpItem("idiot!Crash","Whether to try idiot crash",
    792               0,200,IDIOT);
    793     parameters[numberParameters++]=
    794       ClpItem("passP!resolve","How many passes in presolve",
    795               0,100,PRESOLVEPASS);
    796     parameters[numberParameters++]=
    797       ClpItem("spars!eFactor","Whether factorization treated as sparse",
    798               "on",SPARSEFACTOR);
    799     parameters[numberParameters-1].append("off");
    800     parameters[numberParameters++]=
    801       ClpItem("biasLU","Whether factorization biased towards U",
    802               "UU",BIASLU);
    803     parameters[numberParameters-1].append("UX");
    804     parameters[numberParameters-1].append("LX");
    805     parameters[numberParameters-1].append("LL");
    806     parameters[numberParameters++]=
    807       ClpItem("error!sAllowed","Whether to allow import errors",
    808               "off",ERRORSALLOWED);
    809     parameters[numberParameters-1].append("on");
    810     parameters[numberParameters++]=
    811       ClpItem("keepN!ames","Whether to keep names from import",
    812               "on",KEEPNAMES);
    813     parameters[numberParameters-1].append("off");
    814     parameters[numberParameters++]=
    815       ClpItem("directory","Set Default import directory",
    816               DIRECTORY);
    817     parameters[numberParameters++]=
    818       ClpItem("import","Import model from mps file",
    819               IMPORT);
    820     parameters[numberParameters++]=
    821       ClpItem("export","Export model as mps file",
    822               EXPORT);
    823     parameters[numberParameters++]=
    824       ClpItem("save!Model","Save model to binary file",
    825               SAVE);
    826     parameters[numberParameters++]=
    827       ClpItem("restore!Model","Restore model from binary file",
    828               RESTORE);
    829     parameters[numberParameters++]=
    830       ClpItem("dualS!implex","Do dual simplex algorithm",
    831               DUALSIMPLEX);
    832     parameters[numberParameters++]=
    833       ClpItem("primalS!implex","Do primal simplex algorithm",
    834               PRIMALSIMPLEX);
    835     parameters[numberParameters++]=
    836       ClpItem("branch!Andbound","Do Branch and Bound",
    837               BAB);
     909      ClpItem("stdin","From stdin",
     910              STDIN,false);
     911    parameters[numberParameters++]=
     912      ClpItem("stop","Stops clp execution",
     913              EXIT);
    838914    parameters[numberParameters++]=
    839915      ClpItem("tight!en","Poor person's preSolve for now",
    840916              TIGHTEN);
    841917    parameters[numberParameters++]=
    842       ClpItem("plus!Minus","Tries to make +- 1",
    843               PLUSMINUS);
    844     parameters[numberParameters++]=
    845       ClpItem("network","Tries to make network",
    846               NETWORK);
    847     parameters[numberParameters++]=
    848       ClpItem("sol!ution","Prints solution to file",
    849               SOLUTION);
    850     parameters[numberParameters++]=
    851       ClpItem("max!imize","Set optimization direction to maximize",
    852               MAXIMIZE);
    853     parameters[numberParameters++]=
    854       ClpItem("min!imize","Set optimization direction to minimize",
    855               MINIMIZE);
    856     parameters[numberParameters++]=
    857       ClpItem("exit","Stops clp execution",
    858               EXIT);
    859     parameters[numberParameters++]=
    860       ClpItem("stop","Stops clp execution",
    861               EXIT);
    862     parameters[numberParameters++]=
    863       ClpItem("quit","Stops clp execution",
    864               EXIT);
    865     parameters[numberParameters++]=
    866       ClpItem("-","From stdin",
    867               STDIN);
    868     parameters[numberParameters++]=
    869       ClpItem("stdin","From stdin",
    870               STDIN);
    871     parameters[numberParameters++]=
    872918      ClpItem("unitTest","Do unit test",
    873919              UNITTEST);
    874920    parameters[numberParameters++]=
    875       ClpItem("netlib","Solve entire netlib test set",
    876               NETLIB_DUAL);
    877     parameters[numberParameters++]=
    878       ClpItem("netlibP!rimal","Solve entire netlib test set (primal)",
    879               NETLIB_PRIMAL);
    880     parameters[numberParameters++]=
    881       ClpItem("fakeB!ound","All bounds <= this value - DEBUG",
    882               1.0,1.0e15,FAKEBOUND);
    883     parameters[numberParameters++]=
    884       ClpItem("ver!sion","Print out version",
     921      ClpItem("ver!sion","Print out version and non-standard options",
    885922              VERSION);
    886923    assert(numberParameters<MAXPARAMETERS);
     
    892929    bool * goodModels = new bool[1];
    893930    int getNewMatrix=0;
    894     models->setPerturbation(73);
    895931#ifdef READLINE     
    896932    currentModel = models;
     
    902938    int allowImportErrors=0;
    903939    int keepImportNames=1;
    904     int preSolve=0;
    905940    int doIdiot=0;
    906941   
     
    908943    goodModels[0]=false;
    909944    // set reasonable defaults
     945    int preSolve=5;
     946    models->setPerturbation(53);
    910947    //models[0].scaling(1);
    911948    //models[0].setDualBound(1.0e6);
    912949    //models[0].setDualTolerance(1.0e-7);
    913     ClpDualRowSteepest steep;
    914     models[0].setDualRowPivotAlgorithm(steep);
     950    //ClpDualRowSteepest steep;
     951    //models[0].setDualRowPivotAlgorithm(steep);
    915952    //models[0].setPrimalTolerance(1.0e-7);
    916     ClpPrimalColumnSteepest steepP;
    917     models[0].setPrimalColumnPivotAlgorithm(steepP);
     953    //ClpPrimalColumnSteepest steepP;
     954    //models[0].setPrimalColumnPivotAlgorithm(steepP);
    918955    std::string directory ="./";
    919956    std::string field;
     
    926963      if (!field.length()) {
    927964        if (numberGoodCommands==1&&goodModels[0]) {
    928           // we just had file name
    929           models[0].scaling(1);
    930           int saveMaxIterations = models[0].maximumIterations();
    931           models[0].dual();
    932           models[0].setMaximumIterations(saveMaxIterations);
     965          // we just had file name - do dual
     966          field="duals";
    933967        } else if (!numberGoodCommands) {
    934968          // let's give the sucker a hint
     
    938972            <<"Enter ? for list of commands, (-)unitTest or (-)netlib"
    939973            <<" for tests"<<std::endl;
     974          break;
     975        } else {
     976          break;
    940977        }
    941         break;
    942978      }
    943979     
     
    9821018          std::cout<<"abcd value or abcd = value sets value"<<std::endl;
    9831019          std::cout<<"Commands are:"<<std::endl;
    984           for ( iParam=0; iParam<numberParameters; iParam+=4 ) {
    985             int i;
    986             for (i=iParam;i<min(numberParameters,iParam+4);i++)
    987               std::cout<<parameters[i].matchName()<<"  ";
     1020          int across=0;
     1021          int maxAcross=4;
     1022          for ( iParam=0; iParam<numberParameters; iParam++ ) {
     1023            if (parameters[iParam].displayThis()) {
     1024              std::cout<<parameters[iParam].matchName()<<"  ";
     1025              across++;
     1026              if (across==maxAcross) {
     1027                std::cout<<std::endl;
     1028                across=0;
     1029              }
     1030            }
     1031          }
     1032          if (across)
    9881033            std::cout<<std::endl;
    989           }
    9901034        } else if (type<101) {
    9911035          // get next field as double
     
    10791123              break;
    10801124            case PRESOLVE:
    1081               preSolve = action*5;
     1125              preSolve = (1-action)*5;
    10821126              break;
    10831127            case CRASH:
     
    10971141            if (goodModels[iModel]) {
    10981142              int saveMaxIterations = models[iModel].maximumIterations();
     1143              int finalStatus=-1;
    10991144              int numberIterations=0;
    11001145              time1 = CoinCpuTime();
    11011146              ClpMatrixBase * saveMatrix=NULL;
    1102 #ifdef USE_PRESOLVE
    11031147              ClpSimplex * model2 = models+iModel;
    11041148              ClpPresolve pinfo;
     1149              double timePresolve=0.0;
    11051150              if (preSolve) {
    11061151                model2 = pinfo.presolvedModel(models[iModel],1.0e-8,
    11071152                                              false,preSolve,true);
     1153                timePresolve = CoinCpuTime()-time1;
     1154               
     1155                std::cout<<"Presolve took "<<timePresolve<<" seconds"<<std::endl;
    11081156                if (model2) {
    1109                   model2->checkSolution();
    1110 #ifdef CLP_DEBUG
    1111                   printf("%g %g (%d) %g (%d)\n"
    1112                          ,model2->objectiveValue()
    1113                          ,model2->sumDualInfeasibilities()
    1114                          ,model2->numberDualInfeasibilities()
    1115                          ,model2->sumPrimalInfeasibilities()
    1116                          ,model2->numberPrimalInfeasibilities());
    1117 #endif
    1118 #if 1
     1157                  //model2->checkSolution();
    11191158                  if (type==DUALSIMPLEX) {
    11201159                    int numberInfeasibilities = model2->tightenPrimalBounds();
     
    11261165                    }
    11271166                  }
    1128 #endif
    11291167#ifdef READLINE     
    11301168                currentModel = model2;
     
    11851223#endif
    11861224                int savePerturbation = model2->perturbation();
    1187                 if (savePerturbation==73)
     1225                if (savePerturbation==53)
    11881226                  model2->setPerturbation(100);
    11891227                model2->primal(1);
     
    11961234              }
    11971235              numberIterations = model2->numberIterations();
     1236              finalStatus=model2->status();
    11981237              if (preSolve) {
    1199 #if 0
    1200                 {
    1201                   int numberRows = model2->numberRows();
    1202                   double * rowPrimal = model2->primalRowSolution();
    1203                   double * rowDual = model2->dualRowSolution();
    1204                   double * rowLower = model2->rowLower();
    1205                   double * rowUpper = model2->rowUpper();
    1206                  
    1207                   int iRow;
    1208                   double largest;
    1209                   largest=0.0;
    1210                  
    1211                   for (iRow=0;iRow<numberRows;iRow++) {
    1212                     double value1 = rowPrimal[iRow];
    1213                     double value2 = min(value1-rowLower[iRow],
    1214                                         rowUpper[iRow]-value1);
    1215                     if (value1-rowLower[iRow]>50000.0)
    1216                       rowLower[iRow] = value1-50000.0;
    1217                     if (rowUpper[iRow]-value1>50000.0)
    1218                       rowUpper[iRow] = value1+50000.0;
    1219                     largest = max(largest,value2);
    1220 #if 0
    1221                     double value2 = rowDual[iRow];
    1222                     if (fabs(value1)<1.0e-9)
    1223                       value1=0.0;
    1224                     if (fabs(value2)<1.0e-9)
    1225                       value2=0.0;
    1226                     printf("%d stat %d primal %g dual %g\n",
    1227                            iRow,model2->getRowStatus(iRow),
    1228                            value1,value2);
    1229 #endif
    1230                   }
    1231                   printf("largest away %g\n",largest);
    1232                   int numberColumns = model2->numberColumns();
    1233                   double * columnPrimal = model2->primalColumnSolution();
    1234                   double * columnDual = model2->dualColumnSolution();
    1235                   //double * originalUpper = models->columnUpper();
    1236                   //double * originalLower = models->columnLower();
    1237                   double * columnLower = model2->columnLower();
    1238                   double * columnUpper = model2->columnUpper();
    1239                  
    1240                   int iColumn;
    1241                  
    1242                   for (iColumn=0;iColumn<numberColumns;iColumn++) {
    1243                     double value1 = columnPrimal[iColumn];
    1244                     double value2 = min(value1-columnLower[iColumn],
    1245                                         columnUpper[iColumn]-value1);
    1246                     if (value1-columnLower[iColumn]>50000.0)
    1247                       columnLower[iColumn] = value1-50000.0;
    1248                     if (columnUpper[iColumn]-value1>50000.0)
    1249                       columnUpper[iColumn] = value1+50000.0;
    1250                     largest = max(largest,value2);
    1251 #if 0
    1252                     double value2 = columnDual[iColumn];
    1253                     if (fabs(value1)<1.0e-9)
    1254                       value1=0.0;
    1255                     if (fabs(value2)<1.0e-9)
    1256                       value2=0.0;
    1257                     printf("%d stat %d primal %g dual %g\n",
    1258                            iColumn,model2->getColumnStatus(iColumn),
    1259                            value1,value2);
    1260 #endif
    1261                     if (model2->getColumnStatus(iColumn)!=ClpSimplex::basic) {
    1262                       //assert (fabs(value1-originalLower[iColumn])<1.01e-7||
    1263                       //      fabs(value1-originalUpper[iColumn])<1.01e-7);
    1264                     }
    1265                   }
    1266                   printf("largest away %g\n",largest);
    1267                   CoinMpsIO writer;
    1268                   writer.setMpsData(*model2->matrix(), COIN_DBL_MAX,
    1269                                     model2->getColLower(), model2->getColUpper(),
    1270                                     model2->getObjCoefficients(),
    1271                                     (const char*) 0 /*integrality*/,
    1272                                     model2->getRowLower(), model2->getRowUpper(),
    1273                                     NULL,NULL);
    1274                   writer.writeMps("pilotx.mps");
    1275                 }
    1276 #endif
    1277                 //model2->primal(1);
     1238                double timeX=CoinCpuTime();
    12781239                pinfo.postsolve(true);
    1279                 if (0) {
    1280                   ClpSimplex * model2 = models+iModel;
    1281                   int numberRows = model2->numberRows();
    1282                   double * rowPrimal = model2->primalRowSolution();
    1283                   double * rowDual = model2->dualRowSolution();
    1284                  
    1285                   int iRow;
    1286                  
    1287                   for (iRow=0;iRow<numberRows;iRow++) {
    1288                     double value1 = rowPrimal[iRow];
    1289                     double value2 = rowDual[iRow];
    1290                     if (fabs(value1)<1.0e-9)
    1291                       value1=0.0;
    1292                     if (fabs(value2)<1.0e-9)
    1293                       value2=0.0;
    1294                     printf("%d stat %d primal %g dual %g\n",
    1295                            iRow,model2->getRowStatus(iRow),
    1296                            value1,value2);
    1297                   }
    1298                   int numberColumns = model2->numberColumns();
    1299                   double * columnPrimal = model2->primalColumnSolution();
    1300                   double * columnDual = model2->dualColumnSolution();
    1301                  
    1302                   int iColumn;
    1303                  
    1304                   for (iColumn=0;iColumn<numberColumns;iColumn++) {
    1305                     double value1 = columnPrimal[iColumn];
    1306                     double value2 = columnDual[iColumn];
    1307                     if (fabs(value1)<1.0e-9)
    1308                       value1=0.0;
    1309                     if (fabs(value2)<1.0e-9)
    1310                       value2=0.0;
    1311                     printf("%d stat %d primal %g dual %g\n",
    1312                            iColumn,model2->getColumnStatus(iColumn),
    1313                            value1,value2);
    1314                   }
    1315                 }
     1240                timePresolve += CoinCpuTime()-timeX;
    13161241
    13171242                delete model2;
     
    13211246#endif
    13221247                models[iModel].checkSolution();
    1323                 if (!models[iModel].isProvenOptimal()) {
     1248                if (!finalStatus&&finalStatus!=3) {
    13241249                  printf("Resolving from postsolved model\n");
    13251250                 
     
    13291254                  models[iModel].setPerturbation(savePerturbation);
    13301255                  numberIterations += models[iModel].numberIterations();
     1256                  finalStatus=models[iModel].status();
    13311257                }
    1332 #ifdef CLP_DEBUG_not
    1333                 models[iModel].checkSolution();
    1334                 printf("%g dual %g(%d) Primal %g(%d)\n",
    1335                        models[iModel].objectiveValue(),
    1336                        models[iModel].sumDualInfeasibilities(),
    1337                        models[iModel].numberDualInfeasibilities(),
    1338                        models[iModel].sumPrimalInfeasibilities(),
    1339                        models[iModel].numberPrimalInfeasibilities());
    1340                 {
    1341                   ClpPresolve pinfoA;
    1342                   model2 = pinfoA.presolvedModel(models[iModel],1.0e-8);
    1343                  
    1344                   printf("Resolving from presolved optimal solution\n");
    1345                   model2->primal(1);
    1346                  
    1347                   delete model2;
    1348                 }
    1349 #endif
    1350               }
    1351 #else
    1352 #ifdef READLINE     
    1353               currentModel = models+iModel;
    1354 #endif
    1355               if (type==DUALSIMPLEX) {
    1356                 models[iModel].dual();
    1357               } else {
    1358                 models[iModel].primal(1);
    1359               }
    1360 #endif
     1258              }
    13611259              models[iModel].setMaximumIterations(saveMaxIterations);
    13621260              time2 = CoinCpuTime();
    13631261              totalTime += time2-time1;
    1364               std::cout<<"Result "<<models[iModel].status()<<
     1262              std::cout<<"Result "<<finalStatus<<
    13651263                " - "<<models[iModel].objectiveValue()<<
    13661264                " iterations "<<numberIterations<<
    1367                 " took "<<time2-time1<<" seconds - total "<<totalTime<<std::endl;
    1368               if (models[iModel].status())
    1369                 std::cerr<<"Non zero status "<<models[iModel].status()<<
     1265                " took "<<time2-time1<<" seconds - total "<<totalTime;
     1266              if (preSolve)
     1267                std::cout<<" (Presolve took "<<timePresolve<<")";
     1268              std::cout<<std::endl;
     1269              if (finalStatus)
     1270                std::cerr<<"Non zero status "<<finalStatus<<
    13701271                  std::endl;
    13711272              time1=time2;
     
    13881289          case NETWORK:
    13891290            getNewMatrix=2;
    1390             break;
    1391           case BAB:
    1392 #if 0
    1393             if (goodModels[iModel]) {
    1394               int saveMaxIterations = models[iModel].maximumIterations();
    1395 #ifdef READLINE     
    1396               currentModel = models+iModel;
    1397 #endif
    1398               {
    1399                 // get OsiClp stuff
    1400                 OsiClpSolverInterface m(models+iModel);
    1401                 m.getModelPtr()->messageHandler()->setLogLevel(0);
    1402                 m.branchAndBound();
    1403                 m.resolve();
    1404                 std::cout<<"Optimal solution "<<m.getObjValue()<<std::endl;
    1405                 m.releaseClp();
    1406               }
    1407               models[iModel].setMaximumIterations(saveMaxIterations);
    1408               time2 = CoinCpuTime();
    1409               totalTime += time2-time1;
    1410               std::cout<<"Result "<<models[iModel].status()<<
    1411                 " - "<<models[iModel].objectiveValue()<<
    1412                 " iterations "<<models[iModel].numberIterations()<<
    1413                 " took "<<time2-time1<<" seconds - total "<<totalTime<<std::endl;
    1414               if (models[iModel].status())
    1415                 std::cerr<<"Non zero status "<<models[iModel].status()<<
    1416                   std::endl;
    1417               time1=time2;
    1418             } else {
    1419               std::cout<<"** Current model not valid"<<std::endl;
    1420             }
    1421 #endif
    14221291            break;
    14231292          case IMPORT:
     
    17431612            std::cout<<"Coin LP version "<<CLPVERSION
    17441613                     <<", build "<<__DATE__<<std::endl;
     1614            std::cout<<"Non default values:-"<<std::endl;
     1615            std::cout<<"Perturbation "<<models[0].perturbation()
     1616                     <<" (default 100), Presolve being done with 5 passes"<<std::endl;
    17451617            break;
    17461618          case SOLUTION:
     
    18321704          for ( iParam=0; iParam<numberParameters; iParam++ ) {
    18331705            int match = parameters[iParam].matches(field);
    1834             if (match)
     1706            if (match&&parameters[iParam].displayThis())
    18351707              std::cout<<parameters[iParam].matchName()<<std::endl;
    18361708          }
     
    18401712          for ( iParam=0; iParam<numberParameters; iParam++ ) {
    18411713            int match = parameters[iParam].matches(field);
    1842             if (match) {
     1714            if (match&&parameters[iParam].displayThis()) {
    18431715              std::cout<<parameters[iParam].matchName()<<" : ";
    18441716              std::cout<<parameters[iParam].shortHelp()<<std::endl;
     
    18541726        for ( iParam=0; iParam<numberParameters; iParam++ ) {
    18551727          int match = parameters[iParam].matches(field);
    1856           if (match) {
     1728          if (match&&parameters[iParam].displayThis()) {
    18571729            std::cout<<parameters[iParam].matchName();
    18581730            if (numberQuery>=2)
  • branches/pre/include/ClpDualRowSteepest.hpp

    r180 r205  
    110110  /// save weight array (so we can use checkpoint)
    111111  CoinIndexedVector * savedWeights_;
     112  /// Dubious weights
     113  int * dubiousWeights_;
    112114  //@}
    113115};
  • branches/pre/include/ClpMatrixBase.hpp

    r199 r205  
    112112  int refresh(ClpSimplex * model)
    113113    { return 0;};
    114 
     114  /** Given positive integer weights for each row fills in sum of weights
     115      for each column (and slack).
     116      Returns weights vector
     117      Default returns vector of ones
     118  */
     119  virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
    115120  /** Adds multiple of a column into an CoinIndexedvector
    116121      You can use quickAdd to add to vector */
  • branches/pre/include/ClpModel.hpp

    r204 r205  
    235235   bool isIterationLimitReached() const { return problemStatus_==3; }
    236236   /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
    237    inline int optimizationDirection() const {
    238       return (int) optimizationDirection_;
     237   inline double optimizationDirection() const {
     238      return optimizationDirection_;
    239239   }
    240240   inline double getObjSense() const    { return optimizationDirection_; }
    241    void setOptimizationDirection(int value);
     241   void setOptimizationDirection(double value);
    242242   /// Primal row solution
    243243   inline double * primalRowSolution() const    { return rowActivity_; }
  • branches/pre/include/ClpPackedMatrix.hpp

    r180 r205  
    111111   /// Allow any parts of a created CoinPackedMatrix to be deleted
    112112   virtual void releasePackedMatrix() const { };
     113  /** Given positive integer weights for each row fills in sum of weights
     114      for each column (and slack).
     115      Returns weights vector
     116  */
     117  virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
    113118   //@}
    114119
  • branches/pre/include/ClpSimplex.hpp

    r204 r205  
    482482  inline int * pivotVariable() const
    483483          { return pivotVariable_;};
     484  /// Scaling of objective 12345.0 (auto), 0.0 (off), other user
     485  inline double objectiveScale() const
     486          { return objectiveScale_;} ;
     487  inline void setObjectiveScale(double value)
     488          { objectiveScale_ = value;} ;
    484489  /// Current dual tolerance
    485490  inline double currentDualTolerance() const
     
    737742  /// Large bound value (for complementarity etc)
    738743  double largeValue_;
     744  /// Scaling of objective
     745  double objectiveScale_;
    739746  /// Largest error on Ax-b
    740747  double largestPrimalError_;
  • branches/pre/include/ClpSimplexDual.hpp

    r196 r205  
    188188                  CoinIndexedVector * spareArray,
    189189                  CoinIndexedVector * spareArray2,
    190                   double accpetablePivot);
     190                  double accpetablePivot,
     191                  CoinBigIndex * dubiousWeights);
    191192  /**
    192193      Row array has row part of pivot row
     
    198199  int checkPossibleValuesMove(CoinIndexedVector * rowArray,
    199200                               CoinIndexedVector * columnArray,
    200                                double acceptablePivot);
     201                              double acceptablePivot,
     202                              CoinBigIndex * dubiousWeights);
    201203  /**
    202204      This sees if we can move duals in dual values pass.
Note: See TracChangeset for help on using the changeset viewer.