Changeset 1458 for stable

Timestamp:

Nov 5, 2009 7:34:07 AM (12 years ago)

Author:

forrest

Message:

Creating new stable branch 1.11 from trunk (rev 1457)

Location:

stable/1.11

Files:

• . (copied) (copied from stable/1.10)
• Clp/src/CbcOrClpParam.cpp (modified) (124 diffs)
• Clp/src/CbcOrClpParam.hpp (modified) (10 diffs)
• Clp/src/ClpCholeskyBase.cpp (modified) (81 diffs)
• Clp/src/ClpCholeskyBase.hpp (modified) (5 diffs)
• Clp/src/ClpCholeskyDense.cpp (modified) (82 diffs)
• Clp/src/ClpCholeskyDense.hpp (modified) (4 diffs)
• Clp/src/ClpCholeskyMumps.cpp (modified) (1 diff)
• Clp/src/ClpCholeskyMumps.hpp (modified) (1 diff)
• Clp/src/ClpCholeskyTaucs.cpp (modified) (1 diff)
• Clp/src/ClpCholeskyTaucs.hpp (modified) (1 diff)
• Clp/src/ClpCholeskyUfl.cpp (modified) (1 diff)
• Clp/src/ClpCholeskyUfl.hpp (modified) (1 diff)
• Clp/src/ClpCholeskyWssmp.cpp (modified) (1 diff)
• Clp/src/ClpCholeskyWssmp.hpp (modified) (1 diff)
• Clp/src/ClpCholeskyWssmpKKT.cpp (modified) (1 diff)
• Clp/src/ClpCholeskyWssmpKKT.hpp (modified) (1 diff)
• Clp/src/ClpConfig.h (modified) (2 diffs)
• Clp/src/ClpConstraint.cpp (modified) (1 diff)
• Clp/src/ClpConstraint.hpp (modified) (1 diff)
• Clp/src/ClpConstraintLinear.cpp (modified) (2 diffs)
• Clp/src/ClpConstraintLinear.hpp (modified) (1 diff)
• Clp/src/ClpConstraintQuadratic.cpp (modified) (2 diffs)
• Clp/src/ClpConstraintQuadratic.hpp (modified) (1 diff)
• Clp/src/ClpDualRowDantzig.cpp (modified) (2 diffs)
• Clp/src/ClpDualRowDantzig.hpp (modified) (1 diff)
• Clp/src/ClpDualRowPivot.cpp (modified) (2 diffs)
• Clp/src/ClpDualRowPivot.hpp (modified) (1 diff)
• Clp/src/ClpDualRowSteepest.cpp (modified) (6 diffs)
• Clp/src/ClpDualRowSteepest.hpp (modified) (1 diff)
• Clp/src/ClpDummyMatrix.cpp (modified) (16 diffs)
• Clp/src/ClpDummyMatrix.hpp (modified) (2 diffs)
• Clp/src/ClpDynamicExampleMatrix.cpp (modified) (1 diff)
• Clp/src/ClpDynamicExampleMatrix.hpp (modified) (1 diff)
• Clp/src/ClpDynamicMatrix.cpp (modified) (3 diffs)
• Clp/src/ClpDynamicMatrix.hpp (modified) (2 diffs)
• Clp/src/ClpEventHandler.cpp (modified) (1 diff)
• Clp/src/ClpEventHandler.hpp (modified) (1 diff)
• Clp/src/ClpFactorization.cpp (modified) (31 diffs)
• Clp/src/ClpFactorization.hpp (modified) (11 diffs)
• Clp/src/ClpGubDynamicMatrix.cpp (modified) (3 diffs)
• Clp/src/ClpGubDynamicMatrix.hpp (modified) (1 diff)
• Clp/src/ClpGubMatrix.cpp (modified) (10 diffs)
• Clp/src/ClpGubMatrix.hpp (modified) (2 diffs)
• Clp/src/ClpHelperFunctions.cpp (modified) (2 diffs)
• Clp/src/ClpHelperFunctions.hpp (modified) (2 diffs)
• Clp/src/ClpInterior.cpp (modified) (37 diffs)
• Clp/src/ClpInterior.hpp (modified) (8 diffs)
• Clp/src/ClpLinearObjective.cpp (modified) (4 diffs)
• Clp/src/ClpLinearObjective.hpp (modified) (1 diff)
• Clp/src/ClpLsqr.cpp (modified) (1 diff)
• Clp/src/ClpLsqr.hpp (modified) (1 diff)
• Clp/src/ClpMain.cpp (modified) (35 diffs)
• Clp/src/ClpMatrixBase.cpp (modified) (20 diffs)
• Clp/src/ClpMatrixBase.hpp (modified) (6 diffs)
• Clp/src/ClpMessage.cpp (modified) (4 diffs)
• Clp/src/ClpMessage.hpp (modified) (1 diff)
• Clp/src/ClpModel.cpp (modified) (22 diffs)
• Clp/src/ClpModel.hpp (modified) (6 diffs)
• Clp/src/ClpNetworkBasis.cpp (modified) (2 diffs)
• Clp/src/ClpNetworkBasis.hpp (modified) (2 diffs)
• Clp/src/ClpNetworkMatrix.cpp (modified) (11 diffs)
• Clp/src/ClpNetworkMatrix.hpp (modified) (2 diffs)
• Clp/src/ClpNode.cpp (modified) (23 diffs)
• Clp/src/ClpNode.hpp (modified) (4 diffs)
• Clp/src/ClpNonLinearCost.cpp (modified) (1 diff)
• Clp/src/ClpNonLinearCost.hpp (modified) (1 diff)
• Clp/src/ClpObjective.cpp (modified) (3 diffs)
• Clp/src/ClpObjective.hpp (modified) (1 diff)
• Clp/src/ClpPackedMatrix.cpp (modified) (23 diffs)
• Clp/src/ClpPackedMatrix.hpp (modified) (6 diffs)
• Clp/src/ClpParameters.hpp (modified) (1 diff)
• Clp/src/ClpPdco.cpp (modified) (1 diff)
• Clp/src/ClpPdco.hpp (modified) (1 diff)
• Clp/src/ClpPdcoBase.cpp (modified) (1 diff)
• Clp/src/ClpPdcoBase.hpp (modified) (1 diff)
• Clp/src/ClpPlusMinusOneMatrix.cpp (modified) (13 diffs)
• Clp/src/ClpPlusMinusOneMatrix.hpp (modified) (3 diffs)
• Clp/src/ClpPredictorCorrector.cpp (modified) (199 diffs)
• Clp/src/ClpPredictorCorrector.hpp (modified) (3 diffs)
• Clp/src/ClpPresolve.cpp (modified) (4 diffs)
• Clp/src/ClpPresolve.hpp (modified) (1 diff)
• Clp/src/ClpPrimalColumnDantzig.cpp (modified) (2 diffs)
• Clp/src/ClpPrimalColumnDantzig.hpp (modified) (2 diffs)
• Clp/src/ClpPrimalColumnPivot.cpp (modified) (4 diffs)
• Clp/src/ClpPrimalColumnPivot.hpp (modified) (3 diffs)
• Clp/src/ClpPrimalColumnSteepest.cpp (modified) (21 diffs)
• Clp/src/ClpPrimalColumnSteepest.hpp (modified) (10 diffs)
• Clp/src/ClpPrimalQuadraticDantzig.hpp (modified) (1 diff)
• Clp/src/ClpQuadraticObjective.cpp (modified) (1 diff)
• Clp/src/ClpQuadraticObjective.hpp (modified) (1 diff)
• Clp/src/ClpSimplex.cpp (modified) (79 diffs)
• Clp/src/ClpSimplex.hpp (modified) (9 diffs)
• Clp/src/ClpSimplexDual.cpp (modified) (54 diffs)
• Clp/src/ClpSimplexDual.hpp (modified) (2 diffs)
• Clp/src/ClpSimplexNonlinear.cpp (modified) (7 diffs)
• Clp/src/ClpSimplexNonlinear.hpp (modified) (1 diff)
• Clp/src/ClpSimplexOther.cpp (modified) (14 diffs)
• Clp/src/ClpSimplexOther.hpp (modified) (1 diff)
• Clp/src/ClpSimplexPrimal.cpp (modified) (23 diffs)
• Clp/src/ClpSimplexPrimal.hpp (modified) (2 diffs)
• Clp/src/ClpSolve.cpp (modified) (23 diffs)
• Clp/src/ClpSolve.hpp (modified) (1 diff)
• Clp/src/Clp_C_Interface.cpp (modified) (3 diffs)
• Clp/src/Clp_C_Interface.h (modified) (1 diff)
• Clp/src/IdiSolve.cpp (modified) (2 diffs)
• Clp/src/Idiot.cpp (modified) (15 diffs)
• Clp/src/Idiot.hpp (modified) (1 diff)
• Clp/src/MyEventHandler.cpp (modified) (1 diff)
• Clp/src/MyEventHandler.hpp (modified) (1 diff)
• Clp/src/MyMessageHandler.cpp (modified) (4 diffs)
• Clp/src/MyMessageHandler.hpp (modified) (1 diff)
• Clp/src/unitTest.cpp (modified) (7 diffs)

stable/1.11/Clp/src/CbcOrClpParam.cpp

@@ +1 @@
+/* $Id$ */
 // Copyright (C) 2002, International Business Machines
 // Corporation and others.  All Rights Reserved.
@@ -33 +34 @@
 #else
 static char coin_prompt[]="Clp:";
+#endif
+#ifdef CLP_CILK
+#ifndef CBC_THREAD
+#define CBC_THREAD
+#endif
 #endif
 #if WSSMP_BARRIER>=2
@@ -67 +73 @@
     action_(INVALID),
     currentKeyWord_(-1),
-    display_(false),
+    display_(0),
     intValue_(-1),
     doubleValue_(-1.0),
@@ -77 +83 @@
 CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
            double lower, double upper, CbcOrClpParameterType type,
-                    bool display)
+                    int display)
   : type_(type),
     lowerIntValue_(0),
@@ -99 +105 @@
 CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
            int lower, int upper, CbcOrClpParameterType type,
-                    bool display)
+                    int display)
   : type_(type),
     lowerDoubleValue_(0.0),
@@ -123 +129 @@
                     std::string firstValue,
                     CbcOrClpParameterType type,int whereUsed,
-                    bool display)
+                    int display)
   : type_(type),
     lowerDoubleValue_(0.0),
@@ -147 +153 @@
 CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
                     CbcOrClpParameterType type,int whereUsed,
-                    bool display)
+                    int display)
   : type_(type),
     lowerDoubleValue_(0.0),
@@ -232 +238 @@
 {
   std::string::size_type  shriekPos = name_.find('!');
-  lengthName_ = (unsigned int)name_.length();
+  lengthName_ = name_.length();
   if ( shriekPos==std::string::npos ) {
     //does not contain '!'
     lengthMatch_= lengthName_;
   } else {
-    lengthMatch_=(unsigned int)shriekPos;
+    lengthMatch_=shriekPos;
     name_ = name_.substr(0,shriekPos)+name_.substr(shriekPos+1);
     lengthName_--;
   }
+}
+// Returns length of name for printing
+int 
+CbcOrClpParam::lengthMatchName (  ) const
+{
+  if (lengthName_==lengthMatch_)
+    return lengthName_;
+  else
+    return lengthName_+2;
 }
 // Insert string (only valid for keywords)
@@ -285 +300 @@
 CbcOrClpParam::parameterOption ( std::string check ) const
 {
-  size_t numberItems = definedKeyWords_.size();
+  int numberItems = definedKeyWords_.size();
   if (!numberItems) {
     return -1;
   } else {
-    size_t whichItem=0;
+    int whichItem=0;
     unsigned int it;
     for (it=0;it<definedKeyWords_.size();it++) {
       std::string thisOne = definedKeyWords_[it];
-      std::string::size_type shriekPos = thisOne.find('!');
-      std::string::size_type length1 = thisOne.length();
-      std::string::size_type length2 = length1;
+      std::string::size_type  shriekPos = thisOne.find('!');
+      unsigned int length1 = thisOne.length();
+      unsigned int length2 = length1;
       if ( shriekPos!=std::string::npos ) {
         //contains '!'
@@ -304 +319 @@
       }
       if (check.length()<=length1&&length2<=check.length()) {
-        std::string::size_type i;
+        unsigned int i;
         for (i=0;i<check.length();i++) {
           if (tolower(thisOne[i])!=tolower(check[i])) 
@@ -319 +334 @@
     }
     if (whichItem<numberItems)
-      return (int)whichItem;
+      return whichItem;
     else
       return -1;
@@ -364 +379 @@
 void CoinReadPrintit(const char * input)
 {
-  size_t length =strlen(input);
+  int length =strlen(input);
   char temp[101];
-  size_t i;
+  int i;
   int n=0;
   for (i=0;i<length;i++) {
@@ -644 +659 @@
 #ifdef COIN_HAS_CBC
 double 
-CbcOrClpParam::doubleParameter (OsiSolverInterface * model) const
+CbcOrClpParam::doubleParameter (OsiSolverInterface * 
+#ifndef NDEBUG
+model
+#endif
+) const
 {
   double value=0.0;
@@ -858 +877 @@
       model.setNumberAnalyzeIterations(value);
       break;
-    case NUMBERMINI:
-      oldValue=model.sizeMiniTree();
-      model.setSizeMiniTree(value);
-      break;
     case CUTPASSINTREE:
       oldValue=model.getMaximumCutPasses();
@@ -912 +927 @@
   case NUMBERANALYZE:
     value=model.numberAnalyzeIterations();
-    break;
-  case NUMBERMINI:
-    value=model.sizeMiniTree();
     break;
   case CUTPASSINTREE:
@@ -999 +1011 @@
 static char * where=NULL;
 extern int CbcOrClpRead_mode;
+int CbcOrClpEnvironmentIndex=-1;
+static int fillEnv()
+{
+  char * environ = getenv("CBC_CLP_ENVIRONMENT");
+  int length=0;
+  if (environ) {
+    length = strlen(environ);
+    if (CbcOrClpEnvironmentIndex<length) {
+      // find next non blank
+      char * whereEnv = environ+ CbcOrClpEnvironmentIndex;
+      // munch white space
+      while(*whereEnv==' '||*whereEnv=='\t'||*whereEnv<' ')
+        whereEnv++;
+      // copy
+      char * put = line;
+      while ( *whereEnv != '\0' ) {
+        if ( *whereEnv == ' '||*whereEnv == '\t' || *whereEnv < ' ' ) {
+          break;
+        }
+        *put=*whereEnv;
+        put++;
+        assert (put-line<1000);
+        whereEnv++;
+      }
+      CbcOrClpEnvironmentIndex=whereEnv-environ;
+      *put='\0';
+      length=strlen(line);
+    } else {
+      length=0;
+    }
+  }
+  if (!length)
+    CbcOrClpEnvironmentIndex=-1;
+  return length;
+}
 extern FILE * CbcOrClpReadCommand;
 // Simple read stuff
@@ -1072 +1119 @@
   while (field=="EOL") {
     if (CbcOrClpRead_mode>0) {
-      if (CbcOrClpRead_mode<argc&&argv[CbcOrClpRead_mode]) {
-        field = argv[CbcOrClpRead_mode++];
+      if ((CbcOrClpRead_mode<argc&&argv[CbcOrClpRead_mode])||
+          CbcOrClpEnvironmentIndex>=0) {
+        if(CbcOrClpEnvironmentIndex<0) {
+          field = argv[CbcOrClpRead_mode++];
+        } else {
+          if (fillEnv()) {
+            field=line;
+          } else {
+            // not there
+            continue;
+          }
+        }
         if (field=="-") {
           std::cout<<"Switching to line mode"<<std::endl;
@@ -1082 +1139 @@
             // now allow std::cout<<"skipping non-command "<<field<<std::endl;
             // field="EOL"; // skip
-          } else {
+          } else if (CbcOrClpEnvironmentIndex<0) {
             // special dispensation - taken as -import name
             CbcOrClpRead_mode--;
@@ -1119 +1176 @@
   if (afterEquals=="") {
     if (CbcOrClpRead_mode>0) {
-      if (CbcOrClpRead_mode<argc) {
-        if (argv[CbcOrClpRead_mode][0]!='-') { 
-          field = argv[CbcOrClpRead_mode++];
-        } else if (!strcmp(argv[CbcOrClpRead_mode],"--")) {
-          field = argv[CbcOrClpRead_mode++];
-          // -- means import from stdin
-          field = "-";
-        }
+      if (CbcOrClpRead_mode<argc||CbcOrClpEnvironmentIndex>=0) {
+        if(CbcOrClpEnvironmentIndex<0) {
+          if (argv[CbcOrClpRead_mode][0]!='-') { 
+            field = argv[CbcOrClpRead_mode++];
+          } else if (!strcmp(argv[CbcOrClpRead_mode],"--")) {
+            field = argv[CbcOrClpRead_mode++];
+            // -- means import from stdin
+            field = "-";
+          }
+        } else {
+          fillEnv();
+          field=line;
+        }
       }
     } else {
@@ -1145 +1207 @@
   if (afterEquals=="") {
     if (CbcOrClpRead_mode>0) {
-      if (CbcOrClpRead_mode<argc) {
-        // may be negative value so do not check for -
-        field = argv[CbcOrClpRead_mode++];
+      if (CbcOrClpRead_mode<argc||CbcOrClpEnvironmentIndex>=0) {
+        if(CbcOrClpEnvironmentIndex<0) {
+          // may be negative value so do not check for -
+          field = argv[CbcOrClpRead_mode++];
+        } else {
+          fillEnv();
+          field=line;
+        }
       }
     } else {
@@ -1156 +1223 @@
     afterEquals = "";
   }
-  size_t value=0;
+  int value=0;
   //std::cout<<field<<std::endl;
   if (field!="EOL") {
@@ -1172 +1239 @@
     *valid=2;
   }
-  return (int)value;
+  return value;
 }
 double
@@ -1180 +1247 @@
   if (afterEquals=="") {
     if (CbcOrClpRead_mode>0) {
-      if (CbcOrClpRead_mode<argc) {
-        // may be negative value so do not check for -
-        field = argv[CbcOrClpRead_mode++];
+      if (CbcOrClpRead_mode<argc||CbcOrClpEnvironmentIndex>=0) {
+        if(CbcOrClpEnvironmentIndex<0) {
+          // may be negative value so do not check for -
+          field = argv[CbcOrClpRead_mode++];
+        } else {
+          fillEnv();
+          field=line;
+        }
       }
     } else {
@@ -1218 +1290 @@
   numberParameters=0;
   parameters[numberParameters++]=
-    CbcOrClpParam("?","For help",GENERALQUERY,7,false);
-  parameters[numberParameters++]=
-    CbcOrClpParam("???","For help",FULLGENERALQUERY,7,false);
+    CbcOrClpParam("?","For help",GENERALQUERY,7,0);
+  parameters[numberParameters++]=
+    CbcOrClpParam("???","For help",FULLGENERALQUERY,7,0);
   parameters[numberParameters++]=
     CbcOrClpParam("-","From stdin",
-                  STDIN,3,false);
+                  STDIN,3,0);
+  parameters[numberParameters++]=
+    CbcOrClpParam("allC!ommands","Whether to print less used commands",
+                  "no",ALLCOMMANDS);
+  parameters[numberParameters-1].append("more");
+  parameters[numberParameters-1].append("all");
+  parameters[numberParameters-1].setLonghelp
+    (
+     "For the sake of your sanity, only the more useful and simple commands \
+are printed out on ?."
+     ); 
 #ifdef COIN_HAS_CBC
     parameters[numberParameters++]=
@@ -1245 +1327 @@
 basis anyway."
      ); 
+#endif
+#ifdef COIN_HAS_CBC
+  parameters[numberParameters++]=
+    CbcOrClpParam("artif!icialCost","Costs >= this treated as artificials in feasibility pump",
+                  0.0,COIN_DBL_MAX,ARTIFICIALCOST,1);
+  parameters[numberParameters-1].setDoubleValue(0.0);
+    parameters[numberParameters-1].setLonghelp
+    (
+     "0.0 off - otherwise variables with costs >= this are treated as artificials and fixed to lower bound in feasibility pump"
+     ); 
+#endif
+#ifdef COIN_HAS_CLP
   parameters[numberParameters++]=
     CbcOrClpParam("auto!Scale","Whether to scale objective, rhs and bounds of problem if they look odd",
-                  "off",AUTOSCALE,7,false);
+                  "off",AUTOSCALE,7,0);
   parameters[numberParameters-1].append("on");
   parameters[numberParameters-1].setLonghelp
@@ -1253 +1347 @@
      "If you think you may get odd objective values or large equality rows etc then\
  it may be worth setting this true.  It is still experimental and you may prefer\
- to use objective!Scale and rhs!Scale"
+ to use objective!Scale and rhs!Scale."
      ); 
   parameters[numberParameters++]=
@@ -1261 +1355 @@
     (
      "This command solves the current model using the  primal dual predictor \
-corrector algorithm.  You will probably want to link in and choose a better \
-ordering and factorization than the default ones provided.  It will also solve models \
+corrector algorithm.  You may want to link in an alternative \
+ordering and factorization.  It will also solve models \
 with quadratic objectives."
      
@@ -1274 +1368 @@
  directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
  is initialized to '', i.e. it must be set.  If you have libz then it can read compressed\
- files 'xxxxxxxx.gz'.."
+ files 'xxxxxxxx.gz' or xxxxxxxx.bz2."
      ); 
   parameters[numberParameters++]=
@@ -1287 +1381 @@
   parameters[numberParameters++]=
     CbcOrClpParam("biasLU","Whether factorization biased towards U",
-                  "UU",BIASLU,2,false);
+                  "UU",BIASLU,2,0);
   parameters[numberParameters-1].append("UX");
   parameters[numberParameters-1].append("LX");
@@ -1312 +1406 @@
 were obtained fairly early in the search so the important point is to select the best variable to branch on.  \
 See whether strong branching did a good job - or did it just take a lot of iterations.  Adjust the strongBranching \
-and trustPseudoCosts parameters."
-     ); 
-#endif
-  parameters[numberParameters++]=
-    CbcOrClpParam("bscale","Whether to scale in barrier",
-                  "off",BARRIERSCALE,7,false);
-  parameters[numberParameters-1].append("on");
+and trustPseudoCosts parameters.  If cuts did a good job, then you may wish to \
+have more rounds of cuts - see passC!uts and passT!ree."
+     ); 
+#endif
+  parameters[numberParameters++]=
+    CbcOrClpParam("bscale","Whether to scale in barrier (and ordering speed)",
+                  "off",BARRIERSCALE,7,0);
+  parameters[numberParameters-1].append("on");
+  parameters[numberParameters-1].append("off1");
+  parameters[numberParameters-1].append("on1");
+  parameters[numberParameters-1].append("off2");
+  parameters[numberParameters-1].append("on2");
   parameters[numberParameters++]=
     CbcOrClpParam("chol!esky","Which cholesky algorithm",
@@ -1327 +1426 @@
   parameters[numberParameters-1].append("fudge!Long");
   parameters[numberParameters-1].append("wssmp");
-#define REAL_BARRIER
 #else
   parameters[numberParameters-1].append("fudge!Long_dummy");
@@ -1334 +1432 @@
 #ifdef UFL_BARRIER
   parameters[numberParameters-1].append("Uni!versityOfFlorida");
-#define REAL_BARRIER
 #else
   parameters[numberParameters-1].append("Uni!versityOfFlorida_dummy");    
@@ -1340 +1437 @@
 #ifdef TAUCS_BARRIER
   parameters[numberParameters-1].append("Taucs");
-#define REAL_BARRIER
 #else
   parameters[numberParameters-1].append("Taucs_dummy");
@@ -1346 +1442 @@
 #ifdef MUMPS_BARRIER
   parameters[numberParameters-1].append("Mumps");
-#define REAL_BARRIER
 #else
   parameters[numberParameters-1].append("Mumps_dummy");    
@@ -1353 +1448 @@
     (
      "For a barrier code to be effective it needs a good Cholesky ordering and factorization.  \
-You will need to link in one from another source.  See Makefile.locations for some \
+The native ordering and factorization is not state of the art, although acceptable.  \
+You may want to link in one from another source.  See Makefile.locations for some \
 possibilities."
      ); 
@@ -1366 +1462 @@
   parameters[numberParameters-1].append("forceOn");
   parameters[numberParameters-1].append("onglobal");
-  parameters[numberParameters-1].append("rootglobal");
   parameters[numberParameters-1].setLonghelp
     (
@@ -1382 +1477 @@
      "This switches on a heuristic which does branch and cut on the problem given by just \
 using variables which have appeared in one or more solutions. \
+It obviously only tries after two or more solutions. \
+See Rounding for meaning of on,both,before"
+     ); 
+  parameters[numberParameters++]=
+    CbcOrClpParam("combine2!Solutions","Whether to use crossover solution heuristic",
+                  "off",CROSSOVER2);
+  parameters[numberParameters-1].append("on");
+  parameters[numberParameters-1].append("both");
+  parameters[numberParameters-1].append("before");
+  parameters[numberParameters-1].setLonghelp
+    (
+     "This switches on a heuristic which does branch and cut on the problem given by \
+fixing variables which have same value in two or more solutions. \
 It obviously only tries after two or more solutions. \
 See Rounding for meaning of on,both,before"
@@ -1405 +1513 @@
   parameters[numberParameters-1].setLonghelp
     (
-     " If the user has Cplex, but wants to use some of Cbc'sheuristics \
+     " If the user has Cplex, but wants to use some of Cbc's heuristics \
 then you can!  If this is on, then Cbc will get to the root node and then \
 hand over to Cplex.  If heuristics find a solution this can be significantly \
@@ -1416 +1524 @@
   parameters[numberParameters++]=
     CbcOrClpParam("cpp!Generate","Generates C++ code",
-                  -1,50000,CPP);
+                  -1,50000,CPP,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1423 +1531 @@
 0 gives simplest driver, 1 generates saves and restores, 2 \
 generates saves and restores even for variables at default value. \
-4 bit in cbc generates size dependent code rather than computed values."
+4 bit in cbc generates size dependent code rather than computed values.  \
+This is now deprecated as you can call stand-alone solver - see \
+Cbc/examples/driver4.cpp."
      );
 #ifdef COIN_HAS_CLP
@@ -1438 +1548 @@
      "If crash is set on and there is an all slack basis then Clp will flip or 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'. \
+ better without it and there are alternative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \
 I have also added a variant due to Solow and Halim which is as on but just flip."); 
   parameters[numberParameters++]=
@@ -1458 +1568 @@
   parameters[numberParameters++]=
     CbcOrClpParam("csv!Statistics","Create one line of statistics",
-                  CSVSTATISTICS,2,false);
+                  CSVSTATISTICS,2,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1474 +1584 @@
 every so often.  The original method was every so many nodes but it is more logical \
 to do it whenever depth in tree is a multiple of K.  This option does that and defaults \
-to -1 (off)."
+to -1 (off -> code decides)."
+     );
+  parameters[numberParameters-1].setIntValue(-1);
+  parameters[numberParameters++]=
+    CbcOrClpParam("cutL!ength","Length of a cut",
+                  -1,COIN_INT_MAX,CUTLENGTH);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "At present this only applies to Gomory cuts. -1 (default) leaves as is. \
+Any value >0 says that all cuts <= this length can be generated both at \
+root node and in tree. 0 says to use some dynamic lengths.  If value >=10,000,000 \
+then the length in tree is value%10000000 - so 10000100 means unlimited length \
+at root and 100 in tree."
      );
   parameters[numberParameters-1].setIntValue(-1);
@@ -1502 +1624 @@
   parameters[numberParameters++]=
     CbcOrClpParam("debug!In","read valid solution from file",
-                  DEBUG,7,false);
+                  DEBUG,7,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1518 +1640 @@
   parameters[numberParameters++]=
     CbcOrClpParam("dense!Threshold","Whether to use dense factorization",
-                  -1,10000,DENSE,false);
+                  -1,10000,DENSE,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1528 +1650 @@
 #ifdef COIN_HAS_CBC
   parameters[numberParameters++]=
-    CbcOrClpParam("dextra1","Extra double parameter 1",
-                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA1,false);
+    CbcOrClpParam("depth!MiniBab","Depth at which to try mini BAB",
+                  -COIN_INT_MAX,COIN_INT_MAX,DEPTHMINIBAB);
+  parameters[numberParameters-1].setIntValue(-1);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "Rather a complicated parameter but can be useful. -1 means off for large problems but on as if -12 for problems where rows+columns<500, -2 \
+means use Cplex if it is linked in.  Otherwise if negative then go into depth first complete search fast branch and bound when depth>= -value-2 (so -3 will use this at depth>=1).  This mode is only switched on after 500 nodes.  If you really want to switch it off for small problems then set this to -999.  If >=0 the value doesn't matter very much.  The code will do approximately 100 nodes of fast branch and bound every now and then at depth>=5.  The actual logic is too twisted to describe here."
+     ); 
+  parameters[numberParameters++]=
+    CbcOrClpParam("dextra3","Extra double parameter 3",
+                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA3,0);
   parameters[numberParameters-1].setDoubleValue(0.0);
   parameters[numberParameters++]=
-    CbcOrClpParam("dextra2","Extra double parameter 2",
-                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA2,false);
+    CbcOrClpParam("dextra4","Extra double parameter 4",
+                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA4,0);
   parameters[numberParameters-1].setDoubleValue(0.0);
   parameters[numberParameters++]=
-    CbcOrClpParam("dextra3","Extra double parameter 3",
-                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA3,false);
-  parameters[numberParameters-1].setDoubleValue(0.0);
-  parameters[numberParameters++]=
-    CbcOrClpParam("dextra4","Extra double parameter 4",
-                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA4,false);
-  parameters[numberParameters-1].setDoubleValue(0.0);
-  parameters[numberParameters++]=
     CbcOrClpParam("dextra5","Extra double parameter 5",
-                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA5,false);
+                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA5,0);
   parameters[numberParameters-1].setDoubleValue(0.0);
   parameters[numberParameters++]=
@@ -1580 +1703 @@
   parameters[numberParameters++]=
     CbcOrClpParam("dirSample","Set directory where the COIN-OR sample problems are.",
-                  DIRSAMPLE);
+                  DIRSAMPLE,7,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1590 +1713 @@
   parameters[numberParameters++]=
     CbcOrClpParam("dirNetlib","Set directory where the netlib problems are.",
-                  DIRNETLIB);
+                  DIRNETLIB,7,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1602 +1725 @@
   parameters[numberParameters++]=
     CbcOrClpParam("dirMiplib","Set directory where the miplib 2003 problems are.",
-                  DIRMIPLIB);
+                  DIRMIPLIB,7,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1615 +1738 @@
   parameters[numberParameters++]=
     CbcOrClpParam("diveO!pt","Diving options",
-                  -1,200,DIVEOPT,false);
-  parameters[numberParameters-1].setLonghelp
-    (
-     "If >2 && <7 then modify diving options"
+                  -1,200000,DIVEOPT,1);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "If >2 && <8 then modify diving options - \
+         \t3 only at root and if no solution,  \
+         \t4 only at root and if this heuristic has not got solution, \
+         \t5 only at depth <4, \
+         \t6 decay, \
+         \t7 run up to 2 times if solution found 4 otherwise."
      ); 
   parameters[numberParameters-1].setIntValue(-1);
@@ -1676 +1804 @@
     (
      "Normally heuristics are done in branch and bound.  It may be useful to do them outside. \
-Doing this may also set cutoff."
+Only those heuristics with 'both' or 'before' set will run.  \
+Doing this may also set cutoff, which can help with preprocessing."
      ); 
 #endif
@@ -1698 +1827 @@
   parameters[numberParameters++]=
     CbcOrClpParam("dualize","Solves dual reformulation",
-                  0,3,DUALIZE,false);
+                  0,3,DUALIZE,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1705 +1834 @@
   parameters[numberParameters++]=
     CbcOrClpParam("dualP!ivot","Dual pivot choice algorithm",
-                  "auto!matic",DUALPIVOT);
+                  "auto!matic",DUALPIVOT,7,1);
   parameters[numberParameters-1].append("dant!zig");
   parameters[numberParameters-1].append("partial");
@@ -1757 +1886 @@
      ); 
   parameters[numberParameters++]=
+    CbcOrClpParam("environ!ment","Read commands from environment",
+                  ENVIRONMENT,7,0);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "This starts reading from environment variable CBC_CLP_ENVIRONMENT."
+     );
+  parameters[numberParameters++]=
     CbcOrClpParam("error!sAllowed","Whether to allow import errors",
                   "off",ERRORSALLOWED,3);
@@ -1777 +1913 @@
   parameters[numberParameters++]=
     CbcOrClpParam("exp!eriment","Whether to use testing features",
-                  -1,200,EXPERIMENT,false);
+                  -1,200,EXPERIMENT,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1792 +1928 @@
      "This will write an MPS format file to the given file name.  It will use the default\
  directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
- is initialized to 'default.mps'."
+ is initialized to 'default.mps'.  \
+It can be useful to get rid of the original names and go over to using Rnnnnnnn and Cnnnnnnn.  This can be done by setting 'keepnames' off before importing mps file."
      ); 
 #ifdef COIN_HAS_CBC
   parameters[numberParameters++]=
     CbcOrClpParam("extra1","Extra integer parameter 1",
-                  -COIN_INT_MAX,COIN_INT_MAX,EXTRA1,false);
+                  -COIN_INT_MAX,COIN_INT_MAX,EXTRA1,0);
   parameters[numberParameters-1].setIntValue(-1);
   parameters[numberParameters++]=
     CbcOrClpParam("extra2","Extra integer parameter 2",
-                  -100,COIN_INT_MAX,EXTRA2,false);
+                  -100,COIN_INT_MAX,EXTRA2,0);
   parameters[numberParameters-1].setIntValue(-1);
   parameters[numberParameters++]=
     CbcOrClpParam("extra3","Extra integer parameter 3",
-                  -1,COIN_INT_MAX,EXTRA3,false);
+                  -1,COIN_INT_MAX,EXTRA3,0);
   parameters[numberParameters-1].setIntValue(-1);
   parameters[numberParameters++]=
     CbcOrClpParam("extra4","Extra integer parameter 4",
-                  -COIN_INT_MAX,COIN_INT_MAX,EXTRA4,false);
+                  -1,COIN_INT_MAX,EXTRA4,0);
   parameters[numberParameters-1].setIntValue(-1);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "This switches on yet more special options!! \
+The bottom digit is a strategy when to used shadow price stuff e.g. 3 \
+means use until a solution is found.  The next two digits say what sort \
+of dual information to use.  After that it goes back to powers of 2 so -\n\
+\t1000 - switches on experimental hotstart\n\
+\t2,4,6000 - switches on experimental methods of stopping cuts\n\
+\t8000 - increase minimum drop gradually\n\
+\t16000 - switches on alternate gomory criterion"
+     ); 
 #endif
 #ifdef COIN_HAS_CLP
   parameters[numberParameters++]=
+    CbcOrClpParam("fact!orization","Which factorization to use",
+                  "normal",FACTORIZATION);
+  parameters[numberParameters-1].append("dense");
+  parameters[numberParameters-1].append("simple");
+  parameters[numberParameters-1].append("osl");
+  parameters[numberParameters-1].setLonghelp
+    (
+     "The default is to use the normal CoinFactorization, but \
+other choices are a dense one, osl's or one designed for small problems."
+     ); 
+  parameters[numberParameters++]=
     CbcOrClpParam("fakeB!ound","All bounds <= this value - DEBUG",
-                  1.0,1.0e15,FAKEBOUND,false);
+                  1.0,1.0e15,FAKEBOUND,0);
 #ifdef COIN_HAS_CBC
   parameters[numberParameters++]=
@@ -1833 +1992 @@
     CbcOrClpParam("fix!OnDj","Try heuristic based on fixing variables with \
 reduced costs greater than this",
-                  -1.0e20,1.0e20,DJFIX,false);
+                  -1.0e20,1.0e20,DJFIX,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1846 +2005 @@
     parameters[numberParameters-1].append("ifmove");
     parameters[numberParameters-1].append("forceOn");
-  parameters[numberParameters-1].append("onglobal");
-  parameters[numberParameters-1].append("rootglobal");
+    parameters[numberParameters-1].append("onglobal");
     parameters[numberParameters-1].setLonghelp
     (
@@ -1861 +2019 @@
      "-1 off.  If 1 then tries to branch to solution given by AMPL or priorities file. \
 If 0 then just tries to set as best solution \
-If 1 then also does that many nodes on fixed problem."
+If >1 then also does that many nodes on fixed problem."
+     ); 
+  parameters[numberParameters++]=
+    CbcOrClpParam("fraction!forBAB","Fraction in feasibility pump",
+                  1.0e-5,1.1,SMALLBAB,1);
+  parameters[numberParameters-1].setDoubleValue(0.5);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "After a pass in feasibility pump, variables which have not moved \
+about are fixed and if the preprocessed model is small enough a few nodes \
+of branch and bound are done on reduced problem.  Small problem has to be less than this fraction of original."
      ); 
 #endif
   parameters[numberParameters++]=
     CbcOrClpParam("gamma!(Delta)","Whether to regularize barrier",
-                  "off",GAMMA,7,false);
+                  "off",GAMMA,7,1);
   parameters[numberParameters-1].append("on");
   parameters[numberParameters-1].append("gamma");
@@ -1883 +2051 @@
   parameters[numberParameters-1].append("forceOn");
   parameters[numberParameters-1].append("onglobal");
-  parameters[numberParameters-1].append("rootglobal");
+  parameters[numberParameters-1].append("forceandglobal");
   parameters[numberParameters-1].append("forceLongOn");
   parameters[numberParameters-1].append("long");
@@ -1929 +2097 @@
   parameters[numberParameters++]=
     CbcOrClpParam("hOp!tions","Heuristic options",
-                  -9999999,9999999,HOPTIONS);
+                  -9999999,9999999,HOPTIONS,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1941 +2109 @@
   parameters[numberParameters++]=
     CbcOrClpParam("hot!StartMaxIts","Maximum iterations on hot start",
-                  0,COIN_INT_MAX,MAXHOTITS,false);
+                  0,COIN_INT_MAX,MAXHOTITS);
 #endif
 #ifdef COIN_HAS_CLP
   parameters[numberParameters++]=
     CbcOrClpParam("idiot!Crash","Whether to try idiot crash",
-                  -1,999999,IDIOT);
+                  -1,99999999,IDIOT);
   parameters[numberParameters-1].setLonghelp
     (
@@ -1963 +2131 @@
  directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
  is initialized to '', i.e. it must be set.  If you have libgz then it can read compressed\
- files 'xxxxxxxx.gz'.."
+ files 'xxxxxxxx.gz' or 'xxxxxxxx.bz2'.  \
+If 'keepnames' is off, then names are dropped -> Rnnnnnnn and Cnnnnnnn."
      );
 #ifdef COIN_HAS_CBC
@@ -1980 +2149 @@
     CbcOrClpParam("inf!easibilityWeight","Each integer infeasibility is expected \
 to cost this much",
-                  0.0,1.0e20,INFEASIBILITYWEIGHT);
+                  0.0,1.0e20,INFEASIBILITYWEIGHT,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2014 +2183 @@
   parameters[numberParameters++]=
     CbcOrClpParam("KKT","Whether to use KKT factorization",
-                  "off",KKT,7,false);
+                  "off",KKT,7,1);
   parameters[numberParameters-1].append("on");
 #endif
@@ -2026 +2195 @@
   parameters[numberParameters-1].append("forceOn");
   parameters[numberParameters-1].append("onglobal");
-  parameters[numberParameters-1].append("rootglobal");
+  parameters[numberParameters-1].append("forceandglobal");
   parameters[numberParameters-1].setLonghelp
     (
@@ -2098 +2267 @@
      "This can be used for testing purposes.  The corresponding library call\n\
       \tsetMaximumIterations(value)\n can be useful.  If the code stops on\
- seconds or by an interrupt this will be treated as stopping on maximum iterations"
+ seconds or by an interrupt this will be treated as stopping on maximum iterations.  This is ignored in branchAndCut - use maxN!odes."
      ); 
 #endif
@@ -2115 +2284 @@
   parameters[numberParameters-1].setLonghelp
     (
-     "You may want to stop after (say) two solutions or an hour."
+     "You may want to stop after (say) two solutions or an hour.  \
+This is checked every node in tree, so it is possible to get more solutions from heuristics." 
      ); 
 #endif
@@ -2130 +2300 @@
   parameters[numberParameters++]=
     CbcOrClpParam("mipO!ptions","Dubious options for mip",
-                  0,COIN_INT_MAX,MIPOPTIONS,false);
+                  0,COIN_INT_MAX,MIPOPTIONS,0);
   parameters[numberParameters++]=
     CbcOrClpParam("more!MipOptions","More dubious options for mip",
-                  -1,COIN_INT_MAX,MOREMIPOPTIONS,false);
+                  -1,COIN_INT_MAX,MOREMIPOPTIONS,0);
   parameters[numberParameters++]=
     CbcOrClpParam("mixed!IntegerRoundingCuts","Whether to use Mixed Integer Rounding cuts",
@@ -2142 +2312 @@
   parameters[numberParameters-1].append("forceOn");
   parameters[numberParameters-1].append("onglobal");
-  parameters[numberParameters-1].append("rootglobal");
   parameters[numberParameters-1].setLonghelp
     (
@@ -2158 +2327 @@
 but this program turns this off to make it look more friendly.  It can be useful\
  to turn them back on if you want to be able to 'grep' for particular messages or if\
- you intend to override the behavior of a particular message."
+ you intend to override the behavior of a particular message.  This only affects Clp not Cbc."
      );
 #ifdef COIN_HAS_CBC
   parameters[numberParameters++]=
-    CbcOrClpParam("miniT!ree","Size of fast mini tree",
-                  0,COIN_INT_MAX,NUMBERMINI,false);
-  parameters[numberParameters-1].setLonghelp
-    (
-     "The idea is that I can do a small tree fast. \
-This is a first try and will hopefully become more sophisticated."
-     ); 
+    CbcOrClpParam("moreT!une","Yet more dubious ideas for feasibility pump",
+                  0,100000000,FPUMPTUNE2,0);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "Yet more ideas for Feasibility Pump \n\
+\t/100000 == 1 use box constraints and original obj in cleanup\n\
+\t/1000 == 1 Pump will run twice if no solution found\n\
+\t/1000 == 2 Pump will only run after root cuts if no solution found\n\
+\t/1000 >10 as above but even if solution found\n\
+\t/100 == 1,3.. exact 1.0 for objective values\n\
+\t/100 == 2,3.. allow more iterations per pass\n\
+\t n fix if value of variable same for last n iterations."
+     ); 
+  parameters[numberParameters-1].setIntValue(0);
   parameters[numberParameters++]=
     CbcOrClpParam("miplib","Do some of miplib test set",
-                  MIPLIB,3);
+                  MIPLIB,3,1);
   parameters[numberParameters++]=
       CbcOrClpParam("naive!Heuristics","Whether to try some stupid heuristic",
-                    "off",NAIVE);
+                    "off",NAIVE,7,1);
   parameters[numberParameters-1].append("on");
   parameters[numberParameters-1].append("both");
@@ -2181 +2357 @@
     (
      "Really silly stuff e.g. fix all integers with costs to zero!. \
-Do options does heuristic before preprocessing"     ); 
+Doh option does heuristic before preprocessing"     ); 
 #endif 
 #ifdef COIN_HAS_CLP
   parameters[numberParameters++]=
     CbcOrClpParam("netlib","Solve entire netlib test set",
-                  NETLIB_EITHER,3);
+                  NETLIB_EITHER,3,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2192 +2368 @@
 The user can set options before e.g. clp -presolve off -netlib"
      ); 
-#ifdef REAL_BARRIER
   parameters[numberParameters++]=
     CbcOrClpParam("netlibB!arrier","Solve entire netlib test set with barrier",
-                  NETLIB_BARRIER,3);
+                  NETLIB_BARRIER,3,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2201 +2376 @@
 The user can set options before e.g. clp -kkt on -netlib"
      ); 
-#endif
   parameters[numberParameters++]=
     CbcOrClpParam("netlibD!ual","Solve entire netlib test set (dual)",
-                  NETLIB_DUAL,3);
+                  NETLIB_DUAL,3,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2212 +2386 @@
   parameters[numberParameters++]=
     CbcOrClpParam("netlibP!rimal","Solve entire netlib test set (primal)",
-                  NETLIB_PRIMAL,3);
+                  NETLIB_PRIMAL,3,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2220 +2394 @@
   parameters[numberParameters++]=
     CbcOrClpParam("netlibT!une","Solve entire netlib test set with 'best' algorithm",
-                  NETLIB_TUNE,3);
+                  NETLIB_TUNE,3,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2230 +2404 @@
   parameters[numberParameters++]=
     CbcOrClpParam("network","Tries to make network matrix",
-                  NETWORK,7,false);
+                  NETWORK,7,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2257 +2431 @@
   parameters[numberParameters++]=
     CbcOrClpParam("numberA!nalyze","Number of analysis iterations",
-                  -COIN_INT_MAX,COIN_INT_MAX,NUMBERANALYZE,false);
+                  -COIN_INT_MAX,COIN_INT_MAX,NUMBERANALYZE,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2266 +2440 @@
   parameters[numberParameters++]=
     CbcOrClpParam("objective!Scale","Scale factor to apply to objective",
-                  -1.0e20,1.0e20,OBJSCALE,false);
+                  -1.0e20,1.0e20,OBJSCALE,1);
   parameters[numberParameters-1].setLonghelp
     (
      "If the objective function has some very large values, you may wish to scale them\
- internally by this amount.  It can also be set by autoscale.  It is applied after scaling"
+ internally by this amount.  It can also be set by autoscale.  It is applied after scaling.  You are unlikely to need this."
      ); 
   parameters[numberParameters-1].setDoubleValue(1.0);
@@ -2277 +2451 @@
   parameters[numberParameters++]=
     CbcOrClpParam("outDup!licates","takes duplicate rows etc out of integer model",
-                  OUTDUPROWS,7,false);
+                  OUTDUPROWS,7,0);
 #endif
   parameters[numberParameters++]=
@@ -2312 +2486 @@
   parameters[numberParameters++]=
     CbcOrClpParam("passP!resolve","How many passes in presolve",
-                  -200,100,PRESOLVEPASS,false);
+                  -200,100,PRESOLVEPASS,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2332 +2506 @@
   parameters[numberParameters++]=
     CbcOrClpParam("pertV!alue","Method of perturbation",
-                  -5000,102,PERTVALUE,false);
+                  -5000,102,PERTVALUE,1);
   parameters[numberParameters++]=
     CbcOrClpParam("perturb!ation","Whether to perturb problem",
@@ -2346 +2520 @@
   parameters[numberParameters++]=
     CbcOrClpParam("PFI","Whether to use Product Form of Inverse in simplex",
-                  "off",PFI,7,false);
+                  "off",PFI,7,0);
   parameters[numberParameters-1].append("on");
   parameters[numberParameters-1].setLonghelp
@@ -2355 +2529 @@
 #ifdef COIN_HAS_CBC
   parameters[numberParameters++]=
-      CbcOrClpParam("pivot!AndFix","Whether to try Pivot and Fix heuristic",
-                    "off",PIVOTANDFIX);
+      CbcOrClpParam("pivotAndC!omplement","Whether to try Pivot and Complement heuristic",
+                    "off",PIVOTANDCOMPLEMENT);
   parameters[numberParameters-1].append("on");
   parameters[numberParameters-1].append("both");
@@ -2363 +2537 @@
     (
      "stuff needed. \
-Do options does heuristic before preprocessing"     ); 
+Doh option does heuristic before preprocessing"     ); 
+  parameters[numberParameters++]=
+      CbcOrClpParam("pivotAndF!ix","Whether to try Pivot and Fix heuristic",
+                    "off",PIVOTANDFIX);
+  parameters[numberParameters-1].append("on");
+  parameters[numberParameters-1].append("both");
+  parameters[numberParameters-1].append("before");
+  parameters[numberParameters-1].setLonghelp
+    (
+     "stuff needed. \
+Doh option does heuristic before preprocessing"     ); 
 #endif 
 #ifdef COIN_HAS_CLP
   parameters[numberParameters++]=
     CbcOrClpParam("plus!Minus","Tries to make +- 1 matrix",
-                  PLUSMINUS,7,false);
+                  PLUSMINUS,7,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2377 +2561 @@
   parameters[numberParameters++]=
     CbcOrClpParam("pO!ptions","Dubious print options",
-                  0,COIN_INT_MAX,PRINTOPTIONS,false);
+                  0,COIN_INT_MAX,PRINTOPTIONS,1);
   parameters[numberParameters-1].setIntValue(0);
   parameters[numberParameters-1].setLonghelp
@@ -2385 +2569 @@
   parameters[numberParameters++]=
     CbcOrClpParam("preO!pt","Presolve options",
-                  0,COIN_INT_MAX,PRESOLVEOPTIONS,false);
+                  0,COIN_INT_MAX,PRESOLVEOPTIONS,0);
 #endif
   parameters[numberParameters++]=
@@ -2436 +2620 @@
   parameters[numberParameters++]=
     CbcOrClpParam("primalP!ivot","Primal pivot choice algorithm",
-                  "auto!matic",PRIMALPIVOT);
+                  "auto!matic",PRIMALPIVOT,7,1);
   parameters[numberParameters-1].append("exa!ct");
   parameters[numberParameters-1].append("dant!zig");
@@ -2536 +2720 @@
   parameters[numberParameters-1].append("forceOn");
   parameters[numberParameters-1].append("onglobal");
-  parameters[numberParameters-1].append("rootglobal");
+  parameters[numberParameters-1].append("forceonglobal");
   parameters[numberParameters-1].append("forceOnBut");
   parameters[numberParameters-1].append("forceOnStrong");
@@ -2548 +2732 @@
      ); 
   parameters[numberParameters++]=
+    CbcOrClpParam("pumpC!utoff","Fake cutoff for use in feasibility pump",
+                  -COIN_DBL_MAX,COIN_DBL_MAX,FAKECUTOFF);
+  parameters[numberParameters-1].setDoubleValue(0.0);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "0.0 off - otherwise add a constraint forcing objective below this value\
+ in feasibility pump"
+     ); 
+  parameters[numberParameters++]=
+    CbcOrClpParam("pumpI!ncrement","Fake increment for use in feasibility pump",
+                  -COIN_DBL_MAX,COIN_DBL_MAX,FAKEINCREMENT,1);
+  parameters[numberParameters-1].setDoubleValue(0.0);
+  parameters[numberParameters-1].setLonghelp
+    (
+     "0.0 off - otherwise use as absolute increment to cutoff \
+when solution found in feasibility pump"
+     ); 
+  parameters[numberParameters++]=
     CbcOrClpParam("pumpT!une","Dubious ideas for feasibility pump",
                   0,100000000,FPUMPTUNE);
@@ -2553 +2755 @@
     (
      "This fine tunes Feasibility Pump \n\
+\t>=10000000 use as objective weight switch\n\
 \t>=1000000 use as accumulate switch\n\
 \t>=1000 use index+1 as number of large loops\n\
-\t==100 use objvalue +0.05*fabs(objvalue) as cutoff OR dextra1 if set\n\
-\t%100 == 10,20 etc for experimentation\n\
-\t1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds"
+\t==100 use objvalue +0.05*fabs(objvalue) as cutoff OR fakeCutoff if set\n\
+\t%100 == 10,20 affects how each solve is done\n\
+\t1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds. \
+If accumulate is on then after a major pass, variables which have not moved \
+are fixed and a small branch and bound is tried."
      ); 
   parameters[numberParameters-1].setIntValue(0);
@@ -2578 +2783 @@
     (
      "stuff needed. \
-Do options does heuristic before preprocessing"     ); 
+Doh option does heuristic before preprocessing"     ); 
   parameters[numberParameters++]=
     CbcOrClpParam("ratio!Gap","Stop when gap between best possible and \
@@ -2592 +2797 @@
   parameters[numberParameters++]=
     CbcOrClpParam("readS!tored","Import stored cuts from file",
-                  STOREDFILE,3,false);
+                  STOREDFILE,3,0);
 #endif
 #ifdef COIN_HAS_CLP
   parameters[numberParameters++]=
     CbcOrClpParam("reallyO!bjectiveScale","Scale factor to apply to objective in place",
-                  -1.0e20,1.0e20,OBJSCALE2,false);
+                  -1.0e20,1.0e20,OBJSCALE2,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2605 +2810 @@
   parameters[numberParameters++]=
     CbcOrClpParam("reallyS!cale","Scales model in place",
-                  REALLY_SCALE,7,false);
+                  REALLY_SCALE,7,0);
 #endif
 #ifdef COIN_HAS_CBC
@@ -2636 +2841 @@
   parameters[numberParameters++]=
     CbcOrClpParam("restore!Model","Restore model from binary file",
-                  RESTORE);
+                  RESTORE,7,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2645 +2850 @@
   parameters[numberParameters++]=
     CbcOrClpParam("reverse","Reverses sign of objective",
-                  REVERSE,7,false);
+                  REVERSE,7,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2652 +2857 @@
   parameters[numberParameters++]=
     CbcOrClpParam("rhs!Scale","Scale factor to apply to rhs and bounds",
-                  -1.0e20,1.0e20,RHSSCALE,false);
+                  -1.0e20,1.0e20,RHSSCALE,0);
   parameters[numberParameters-1].setLonghelp
     (
      "If the rhs or bounds have some very large meaningful values, you may wish to scale them\
- internally by this amount.  It can also be set by autoscale"
+ internally by this amount.  It can also be set by autoscale.  This should not be needed."
      ); 
   parameters[numberParameters-1].setDoubleValue(1.0);
@@ -2673 +2878 @@
     (
      "This switches on Relaxation enforced neighborhood Search. \
-on just does feasibility pump \
+on just does 50 nodes \
 200 or 1000 does that many nodes. \
-Do options does heuristic before preprocessing"     ); 
+Doh option does heuristic before preprocessing"     ); 
   parameters[numberParameters++]=
       CbcOrClpParam("Rins","Whether to try Relaxed Induced Neighborhood Search",
@@ -2686 +2891 @@
     (
      "This switches on Relaxed induced neighborhood Search. \
-Do options does heuristic before preprocessing"     ); 
+Doh option does heuristic before preprocessing"     ); 
   parameters[numberParameters++]=
     CbcOrClpParam("round!ingHeuristic","Whether to use Rounding heuristic",
@@ -2704 +2909 @@
   parameters[numberParameters++]=
     CbcOrClpParam("saveM!odel","Save model to binary file",
-                  SAVE);
+                  SAVE,7,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2730 +2935 @@
   parameters[numberParameters-1].append("geo!metric");
   parameters[numberParameters-1].append("auto!matic");
+  parameters[numberParameters-1].append("dynamic");
+  parameters[numberParameters-1].append("rows!only");
   parameters[numberParameters-1].setLonghelp
     (
@@ -2745 +2952 @@
     (
      "After this many seconds clp will act as if maximum iterations had been reached \
-(if value >=0).  \
-In this program it is really only useful for testing but the library function\n\
-      \tsetMaximumSeconds(value)\n can be useful."
+(if value >=0)."
      );
 #else
@@ -2760 +2965 @@
   parameters[numberParameters++]=
     CbcOrClpParam("sleep","for debug",
-                  DUMMY,7,false);
+                  DUMMY,7,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2768 +2973 @@
   parameters[numberParameters++]=
     CbcOrClpParam("slp!Value","Number of slp passes before primal",
-                  -1,50000,SLPVALUE,false);
+                  -1,50000,SLPVALUE,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2777 +2982 @@
   parameters[numberParameters++]=
     CbcOrClpParam("small!Factorization","Whether to use small factorization",
-                  -1,10000,SMALLFACT,false);
+                  -1,10000,SMALLFACT,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2815 +3020 @@
      ); 
   parameters[numberParameters++]=
-    CbcOrClpParam("slog!Level","Level of detail in Solver output",
+    CbcOrClpParam("slog!Level","Level of detail in (LP) Solver output",
                   -1,63,SOLVERLOGLEVEL);
   parameters[numberParameters-1].setLonghelp
     (
      "If 0 then there should be no output in normal circumstances.  1 is probably the best\
- value for most uses, while 2 and 3 give more information."
+ value for most uses, while 2 and 3 give more information.  This parameter is only used inside MIP - for Clp use 'log'"
      );
 #else
@@ -2836 +3041 @@
   parameters[numberParameters++]=
     CbcOrClpParam("spars!eFactor","Whether factorization treated as sparse",
-                  "on",SPARSEFACTOR,7,false);
+                  "on",SPARSEFACTOR,7,0);
   parameters[numberParameters-1].append("off");
   parameters[numberParameters++]=
     CbcOrClpParam("special!Options","Dubious options for Simplex - see ClpSimplex.hpp",
-                  0,COIN_INT_MAX,SPECIALOPTIONS,false);
+                  0,COIN_INT_MAX,SPECIALOPTIONS,0);
   parameters[numberParameters++]=
     CbcOrClpParam("sprint!Crash","Whether to try sprint crash",
@@ -2883 +3088 @@
      ); 
   parameters[numberParameters-1].setIntValue(1);
+#ifdef CBC_KEEP_DEPRECATED
   parameters[numberParameters++]=
     CbcOrClpParam("strengthen","Create strengthened problem",
@@ -2890 +3096 @@
      "This creates a new problem by applying the root node cuts.  All tight constraints \
 will be in resulting problem"
-     ); 
+     );
+#endif 
   parameters[numberParameters++]=
     CbcOrClpParam("strong!Branching","Number of variables to look at in strong branching",
@@ -2905 +3112 @@
   parameters[numberParameters++]=
     CbcOrClpParam("subs!titution","How long a column to substitute for in presolve",
-                  0,10000,SUBSTITUTION,false);
+                  0,10000,SUBSTITUTION,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2916 +3123 @@
   parameters[numberParameters++]=
     CbcOrClpParam("testO!si","Test OsiObject stuff",
-                  -1,COIN_INT_MAX,TESTOSI,false);
+                  -1,COIN_INT_MAX,TESTOSI,0);
 #endif
 #ifdef CBC_THREAD
   parameters[numberParameters++]=
     CbcOrClpParam("thread!s","Number of threads to try and use",
-                  -100,100000,THREADS,false);
+                  -100,100000,THREADS,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2934 +3141 @@
     CbcOrClpParam("tighten!Factor","Tighten bounds using this times largest \
 activity at continuous solution",
-                  1.0e-3,1.0e20,TIGHTENFACTOR,false);
+                  1.0e-3,1.0e20,TIGHTENFACTOR,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2943 +3150 @@
   parameters[numberParameters++]=
     CbcOrClpParam("tightLP","Poor person's preSolve for now",
-                  TIGHTEN,7,false);
+                  TIGHTEN,7,0);
 #endif
 #ifdef COIN_HAS_CBC
@@ -2958 +3165 @@
   parameters[numberParameters++]=
     CbcOrClpParam("tune!PreProcess","Dubious tuning parameters",
-                  0,20000000,PROCESSTUNE,false);
+                  0,20000000,PROCESSTUNE,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2977 +3184 @@
   parameters[numberParameters-1].append("forceOn");
   parameters[numberParameters-1].append("onglobal");
-  parameters[numberParameters-1].append("rootglobal");
+  parameters[numberParameters-1].append("forceandglobal");
   parameters[numberParameters-1].append("forceLongOn");
   parameters[numberParameters-1].setLonghelp
@@ -2987 +3194 @@
   parameters[numberParameters++]=
     CbcOrClpParam("unitTest","Do unit test",
-                  UNITTEST,3);
+                  UNITTEST,3,1);
   parameters[numberParameters-1].setLonghelp
     (
@@ -2994 +3201 @@
   parameters[numberParameters++]=
     CbcOrClpParam("userClp","Hand coded Clp stuff",
-                  USERCLP);
+                  USERCLP,0,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -3003 +3210 @@
   parameters[numberParameters++]=
     CbcOrClpParam("userCbc","Hand coded Cbc stuff",
-                  USERCBC);
+                  USERCBC,0,0);
   parameters[numberParameters-1].setLonghelp
     (
      "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
-Look for USERCBC in main driver and modify sample code."
-     ); 
+Look for USERCBC in main driver and modify sample code. \
+It is possible you can get same effect by using example driver4.cpp."
+     ); 
+  parameters[numberParameters++]=
+      CbcOrClpParam("Vnd!VariableNeighborhoodSearch","Whether to try Variable Neighborhood Search",
+                    "off",VND);
+    parameters[numberParameters-1].append("on");
+    parameters[numberParameters-1].append("both");
+    parameters[numberParameters-1].append("before");
+    parameters[numberParameters-1].append("intree");
+  parameters[numberParameters-1].setLonghelp
+    (
+     "This switches on variable neighborhood Search. \
+Doh option does heuristic before preprocessing"     ); 
 #endif
   parameters[numberParameters++]=
     CbcOrClpParam("vector","Whether to use vector? Form of matrix in simplex",
-                  "off",VECTOR,7,false);
-  parameters[numberParameters-1].append("on");
-  parameters[numberParameters-1].setLonghelp
-    (
-     "If this is on and ClpPackedMatrix uses extra column copy in odd format."
+                  "off",VECTOR,7,0);
+  parameters[numberParameters-1].append("on");
+  parameters[numberParameters-1].setLonghelp
+    (
+     "If this is on ClpPackedMatrix uses extra column copy in odd format."
      ); 
   parameters[numberParameters++]=
     CbcOrClpParam("verbose","Switches on longer help on single ?",
-                  0,15,VERBOSE,false);
+                  0,31,VERBOSE,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -3029 +3248 @@
   parameters[numberParameters++]=
     CbcOrClpParam("vub!heuristic","Type of vub heuristic",
-                  -2,20,VUBTRY,false);
+                  -2,20,VUBTRY,0);
   parameters[numberParameters-1].setLonghelp
     (
@@ -3035 +3254 @@
      ); 
   parameters[numberParameters-1].setIntValue(-1);
+#ifdef ZERO_HALF_CUTS
   parameters[numberParameters++]=
     CbcOrClpParam("zero!HalfCuts","Whether to use zero half cuts",
@@ -3043 +3263 @@
   parameters[numberParameters-1].append("forceOn");
   parameters[numberParameters-1].append("onglobal");
-  parameters[numberParameters-1].append("rootglobal");
-  parameters[numberParameters-1].setLonghelp
-    (
-     "This switches on knapsack cuts (either at root or in entire tree) \
+  parameters[numberParameters-1].setLonghelp
+    (
+     "This switches on zero-half cuts (either at root or in entire tree) \
 See branchAndCut for information on options."
-     ); 
+     );
+#endif 
 #endif 
   assert(numberParameters<CBCMAXPARAMETERS);
@@ -3078 +3298 @@
     int numberColumnsFile;
     double objectiveValue;
-    fread(&numberRowsFile,sizeof(int),1,fp);
-    fread(&numberColumnsFile,sizeof(int),1,fp);
-    fread(&objectiveValue,sizeof(double),1,fp);
+    int nRead;
+    nRead=fread(&numberRowsFile,sizeof(int),1,fp);
+    if (nRead!=1)
+      throw("Error in fread");
+    nRead=fread(&numberColumnsFile,sizeof(int),1,fp);
+    if (nRead!=1)
+      throw("Error in fread");
+    nRead=fread(&objectiveValue,sizeof(double),1,fp);
+    if (nRead!=1)
+      throw("Error in fread");
     double * dualRowSolution = lpSolver->dualRowSolution();
     double * primalRowSolution = lpSolver->primalRowSolution();
@@ -3103 +3330 @@
       lpSolver->setObjectiveValue(objectiveValue);
       if (numberRows==numberRowsFile&&numberColumns==numberColumnsFile) {
-        fread(primalRowSolution,sizeof(double),numberRows,fp);
-        fread(dualRowSolution,sizeof(double),numberRows,fp);
-        fread(primalColumnSolution,sizeof(double),numberColumns,fp);
-        fread(dualColumnSolution,sizeof(double),numberColumns,fp);
+        nRead=fread(primalRowSolution,sizeof(double),numberRows,fp);
+        if (nRead!=numberRows)
+          throw("Error in fread");
+        nRead=fread(dualRowSolution,sizeof(double),numberRows,fp);
+        if (nRead!=numberRows)
+          throw("Error in fread");
+        nRead=fread(primalColumnSolution,sizeof(double),numberColumns,fp);
+        if (nRead!=numberColumns)
+          throw("Error in fread");
+        nRead=fread(dualColumnSolution,sizeof(double),numberColumns,fp);
+        if (nRead!=numberColumns)
+          throw("Error in fread");
       } else {
         std::cout<<"Mismatch on rows and/or columns - truncating"<<std::endl;
         double * temp = new double [CoinMax(numberRowsFile,numberColumnsFile)];
-        fread(temp,sizeof(double),numberRowsFile,fp);
- CoinMemcpyN(temp,numberRows,primalRowSolution);
-        fread(temp,sizeof(double),numberRowsFile,fp);
- CoinMemcpyN(temp,numberRows,dualRowSolution);
-        fread(temp,sizeof(double),numberColumnsFile,fp);
- CoinMemcpyN(temp,numberColumns,primalColumnSolution);
-        fread(temp,sizeof(double),numberColumnsFile,fp);
- CoinMemcpyN(temp,numberColumns,dualColumnSolution);
+        nRead=fread(temp,sizeof(double),numberRowsFile,fp);
+        if (nRead!=numberRowsFile)
+          throw("Error in fread");
+        CoinMemcpyN(temp,numberRows,primalRowSolution);
+        nRead=fread(temp,sizeof(double),numberRowsFile,fp);
+        if (nRead!=numberRowsFile)
+          throw("Error in fread");
+        CoinMemcpyN(temp,numberRows,dualRowSolution);
+        nRead=fread(temp,sizeof(double),numberColumnsFile,fp);
+        if (nRead!=numberColumnsFile)
+          throw("Error in fread");
+        CoinMemcpyN(temp,numberColumns,primalColumnSolution);
+        nRead=fread(temp,sizeof(double),numberColumnsFile,fp);
+        if (nRead!=numberColumnsFile)
+          throw("Error in fread");
+        CoinMemcpyN(temp,numberColumns,dualColumnSolution);
         delete [] temp;
       }
@@ -3177 +3420 @@
     int numberColumns=lpSolver->numberColumns();
     double objectiveValue = lpSolver->objectiveValue();
-    fwrite(&numberRows,sizeof(int),1,fp);
-    fwrite(&numberColumns,sizeof(int),1,fp);
-    fwrite(&objectiveValue,sizeof(double),1,fp);
+    int nWrite;
+    nWrite=fwrite(&numberRows,sizeof(int),1,fp);
+    if (nWrite!=1)
+      throw("Error in fwrite");
+    nWrite=fwrite(&numberColumns,sizeof(int),1,fp);
+    if (nWrite!=1)
+      throw("Error in fwrite");
+    nWrite=fwrite(&objectiveValue,sizeof(double),1,fp);
+    if (nWrite!=1)
+      throw("Error in fwrite");
     double * dualRowSolution = lpSolver->dualRowSolution();
     double * primalRowSolution = lpSolver->primalRowSolution();
-    fwrite(primalRowSolution,sizeof(double),numberRows,fp);
-    fwrite(dualRowSolution,sizeof(double),numberRows,fp);
+    nWrite=fwrite(primalRowSolution,sizeof(double),numberRows,fp);
+    if (nWrite!=numberRows)
+      throw("Error in fwrite");
+    nWrite=fwrite(dualRowSolution,sizeof(double),numberRows,fp);
+    if (nWrite!=numberRows)
+      throw("Error in fwrite");
     double * dualColumnSolution = lpSolver->dualColumnSolution();
     double * primalColumnSolution = lpSolver->primalColumnSolution();
-    fwrite(primalColumnSolution,sizeof(double),numberColumns,fp);
-    fwrite(dualColumnSolution,sizeof(double),numberColumns,fp);
+    nWrite=fwrite(primalColumnSolution,sizeof(double),numberColumns,fp);
+    if (nWrite!=numberColumns)
+      throw("Error in fwrite");
+    nWrite=fwrite(dualColumnSolution,sizeof(double),numberColumns,fp);
+    if (nWrite!=numberColumns)
+      throw("Error in fwrite");
     fclose(fp);
   } else {

stable/1.11/Clp/src/CbcOrClpParam.hpp

@@ +1 @@
+
+/* $Id$ */
 // Copyright (C) 2002, International Business Machines
 // Corporation and others.  All Rights Reserved.
@@ -53 +55 @@
     
     DJFIX = 81, TIGHTENFACTOR,PRESOLVETOLERANCE,OBJSCALE2,
-    DEXTRA1, DEXTRA2, DEXTRA3, DEXTRA4, DEXTRA5,
+    FAKEINCREMENT, FAKECUTOFF, ARTIFICIALCOST,DEXTRA3, SMALLBAB, DEXTRA4, DEXTRA5,
 
     SOLVERLOGLEVEL=101,
@@ -64 +66 @@
 
     STRONGBRANCHING=151,CUTDEPTH, MAXNODES,NUMBERBEFORE,NUMBERANALYZE,
-    NUMBERMINI,MIPOPTIONS,MOREMIPOPTIONS,MAXHOTITS,FPUMPITS,MAXSOLS,
-    FPUMPTUNE,TESTOSI,EXTRA1,EXTRA2,EXTRA3,EXTRA4,CUTPASSINTREE,
+    MIPOPTIONS,MOREMIPOPTIONS,MAXHOTITS,FPUMPITS,MAXSOLS,
+    FPUMPTUNE,TESTOSI,EXTRA1,EXTRA2,EXTRA3,EXTRA4,DEPTHMINIBAB,CUTPASSINTREE,
     THREADS,CUTPASS,VUBTRY,DENSE,EXPERIMENT,DIVEOPT,STRATEGY,SMALLFACT,
-    HOPTIONS,
+    HOPTIONS,CUTLENGTH,FPUMPTUNE2,
 #ifdef COIN_HAS_CBC 
     LOGLEVEL , 
@@ -75 +77 @@
     PRIMALPIVOT,PRESOLVE,CRASH,BIASLU,PERTURBATION,MESSAGES,AUTOSCALE,
     CHOLESKY,KKT,BARRIERSCALE,GAMMA,CROSSOVER,PFI,INTPRINT,VECTOR,
+    FACTORIZATION,ALLCOMMANDS,
     
     NODESTRATEGY = 251,BRANCHSTRATEGY,CUTSSTRATEGY,HEURISTICSTRATEGY,
@@ -82 +85 @@
     LANDPCUTS,RINS,RESIDCUTS,RENS,DIVINGS,DIVINGC,DIVINGF,DIVINGG,DIVINGL,
     DIVINGP,DIVINGV,DINS,PIVOTANDFIX,RANDROUND,NAIVE,ZEROHALFCUTS,CPX,
+    CROSSOVER2,PIVOTANDCOMPLEMENT,VND,
     
     DIRECTORY=301,DIRSAMPLE,DIRNETLIB,DIRMIPLIB,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,EITHERSIMPLEX,
@@ -87 +91 @@
     TIGHTEN,FAKEBOUND,HELP,PLUSMINUS,NETWORK,ALLSLACK,REVERSE,BARRIER,NETLIB_BARRIER,NETLIB_TUNE,
     REALLY_SCALE,BASISIN,BASISOUT,SOLVECONTINUOUS,CLEARCUTS,VERSION,STATISTICS,DEBUG,DUMMY,PRINTMASK,
-    OUTDUPROWS,USERCLP,MODELIN,CSVSTATISTICS,STOREDFILE,
+    OUTDUPROWS,USERCLP,MODELIN,CSVSTATISTICS,STOREDFILE,ENVIRONMENT,
 
     BAB=351,MIPLIB,STRENGTHEN,PRIORITYIN,USERCBC,DOHEURISTIC,
@@ -107 +111 @@
   CbcOrClpParam (  );
   CbcOrClpParam (std::string name, std::string help,
-           double lower, double upper, CbcOrClpParameterType type,bool display=true);
+           double lower, double upper, CbcOrClpParameterType type,int display=2);
   CbcOrClpParam (std::string name, std::string help,
-           int lower, int upper, CbcOrClpParameterType type,bool display=true);
+           int lower, int upper, CbcOrClpParameterType type,int display=2);
   // Other strings will be added by insert
   CbcOrClpParam (std::string name, std::string help, std::string firstValue,
-           CbcOrClpParameterType type,int whereUsed=7,bool display=true);
+           CbcOrClpParameterType type,int whereUsed=7,int display=2);
   // Action
   CbcOrClpParam (std::string name, std::string help,
-           CbcOrClpParameterType type,int whereUsed=7,bool display=true);
+           CbcOrClpParameterType type,int whereUsed=7,int display=2);
   /// Copy constructor. 
   CbcOrClpParam(const CbcOrClpParam &);
@@ -178 +182 @@
   /// Returns name which could match
   std::string matchName (  ) const;
+  /// Returns length of name for ptinting
+  int lengthMatchName (  ) const;
   /// Returns parameter option which matches (-1 if none)
   int parameterOption ( std::string check ) const;
@@ -212 +218 @@
   { return type_;}
   /// whether to display
-  inline bool displayThis() const
+  inline int displayThis() const
   { return display_;}
   /// Set Long help
@@ -265 +271 @@
   int currentKeyWord_;
   /// Display on ?
-  bool display_;
+  int display_;
   /// Integer parameter - current value
   int intValue_;

stable/1.11/Clp/src/ClpCholeskyBase.cpp

@@ +1 @@
+/* $Id$ */
 // Copyright (C) 2002, International Business Machines
 // Corporation and others.  All Rights Reserved.
+/*----------------------------------------------------------------------------*/
+/*      Ordering code - courtesy of Anshul Gupta                              */
+/*      (C) Copyright IBM Corporation 1997, 2009.  All Rights Reserved.       */
+/*----------------------------------------------------------------------------*/
+
+/*  A compact no-frills Approximate Minimum Local Fill ordering code.
+
+    References:
+
+[1] Ordering Sparse Matrices Using Approximate Minimum Local Fill.
+    Edward Rothberg, SGI Manuscript, April 1996.
+[2] An Approximate Minimum Degree Ordering Algorithm.
+    T. Davis, P. Amestoy, and I. Duff, TR-94-039, CIS Department,
+    University of Florida, December 1994. 
+*/
+/*----------------------------------------------------------------------------*/
+
 
 #include "CoinPragma.hpp"
 
-#include <iostream>
+#include <iostream> 
 
 #include "ClpCholeskyBase.hpp"
@@ -86 +104 @@
 #else
   // actually long double
-  workDouble_ = (double *) ClpCopyOfArray((longWork *) rhs.workDouble_,numberRows_);
+  workDouble_ = reinterpret_cast<double *> (ClpCopyOfArray(reinterpret_cast<CoinWorkDouble *> (rhs.workDouble_),numberRows_));
 #endif
   link_ = ClpCopyOfArray(rhs.link_,numberRows_);
@@ -171 +189 @@
 #else
     // actually long double
-    workDouble_ = (double *) ClpCopyOfArray((longWork *) rhs.workDouble_,numberRows_);
+    workDouble_ = reinterpret_cast<double *> (ClpCopyOfArray(reinterpret_cast<CoinWorkDouble *> (rhs.workDouble_),numberRows_));
 #endif
     link_ = ClpCopyOfArray(rhs.link_,numberRows_);
@@ -195 +213 @@
    region1 is rows+columns, region2 is rows */
 void 
-ClpCholeskyBase::solveKKT (double * region1, double * region2, const double * diagonal,
-                           double diagonalScaleFactor)
+ClpCholeskyBase::solveKKT (CoinWorkDouble * region1, CoinWorkDouble * region2, const CoinWorkDouble * diagonal,
+                           CoinWorkDouble diagonalScaleFactor)
 {
   if (!doKKT_) {
@@ -202 +220 @@
     int numberColumns = model_->numberColumns();
     int numberTotal = numberRows_+numberColumns;
-    double * region1Save = new double[numberTotal];
+    CoinWorkDouble * region1Save = new CoinWorkDouble[numberTotal];
     for (iColumn=0;iColumn<numberTotal;iColumn++) {
       region1[iColumn] *= diagonal[iColumn];
@@ -209 +227 @@
     multiplyAdd(region1+numberColumns,numberRows_,-1.0,region2,1.0);
     model_->clpMatrix()->times(1.0,region1,region2);
-    double maximumRHS = maximumAbsElement(region2,numberRows_);
-    double scale=1.0;
-    double unscale=1.0;
+    CoinWorkDouble maximumRHS = maximumAbsElement(region2,numberRows_);
+    CoinWorkDouble scale=1.0;
+    CoinWorkDouble unscale=1.0;
     if (maximumRHS>1.0e-30) {
       if (maximumRHS<=0.5) {
-        double factor=2.0;
+        CoinWorkDouble factor=2.0;
         while (maximumRHS<=0.5) {
           maximumRHS*=factor;
@@ -220 +238 @@
         } /* endwhile */
       } else if (maximumRHS>=2.0&&maximumRHS<=COIN_DBL_MAX) {
-        double factor=0.5;
+        CoinWorkDouble factor=0.5;
         while (maximumRHS>=2.0) {
           maximumRHS*=factor;
@@ -246 +264 @@
     int numberColumns = model_->numberColumns();
     int numberTotal = numberColumns + numberRowsModel;
-    double * array = new double [numberRows_];
+    CoinWorkDouble * array = new CoinWorkDouble [numberRows_];
     CoinMemcpyN(region1,numberTotal,array);
     CoinMemcpyN(region2,numberRowsModel,array+numberTotal);
@@ -253 +271 @@
     int iRow;
     for (iRow=0;iRow<numberTotal;iRow++) { 
-      if (rowsDropped_[iRow]&&fabs(array[iRow])>1.0e-8) {
+      if (rowsDropped_[iRow]&&CoinAbs(array[iRow])>1.0e-8) {
         printf("row region1 %d dropped %g\n",iRow,array[iRow]);
       }
     }
     for (;iRow<numberRows_;iRow++) {
-      if (rowsDropped_[iRow]&&fabs(array[iRow])>1.0e-8) {
+      if (rowsDropped_[iRow]&&CoinAbs(array[iRow])>1.0e-8) {
         printf("row region2 %d dropped %g\n",iRow,array[iRow]);
       }
@@ -621 +639 @@
 {
   model_=model;
+#define BASE_ORDER 2
+#if BASE_ORDER>0
+  if (!doKKT_&&model_->numberRows()>6) {
+    if (preOrder(false,true,false))
+      return -1;
+    //rowsDropped_ = new char [numberRows_];
+    numberRowsDropped_=0;
+    memset(rowsDropped_,0,numberRows_);
+    //rowCopy_ = model->clpMatrix()->reverseOrderedCopy();
+    // approximate minimum degree
+    return orderAMD();
+  }
+#endif
   int numberRowsModel = model_->numberRows();
   int numberColumns = model_->numberColumns();
@@ -636 +667 @@
   rowsDropped_ = new char [numberRows_];
   numberRowsDropped_=0;
+  memset(rowsDropped_,0,numberRows_);
   rowCopy_ = model->clpMatrix()->reverseOrderedCopy();
   const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
@@ -749 +781 @@
   delete [] count;
   permuteInverse_ = new int [numberRows_];
-  memset(rowsDropped_,0,numberRows_);
   for (iRow=0;iRow<numberRows_;iRow++) {
     //permute_[iRow]=iRow; // force no permute
@@ -757 +788 @@
   }
   return 0;
+}
+#if BASE_ORDER==1
+/* Orders rows and saves pointer to matrix.and model */
+int 
+ClpCholeskyBase::orderAMD()
+{
+  permuteInverse_ = new int [numberRows_];
+  permute_ = new int[numberRows_];
+  // Do ordering
+  int returnCode=0;
+  // get more space and full matrix
+  int space = 6*sizeFactor_+100000;
+  int * temp = new int [space];
+  int * which = new int[2*numberRows_];
+  CoinBigIndex * tempStart = new CoinBigIndex [numberRows_+1];
+  memset(which,0,numberRows_*sizeof(int));
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    which[iRow]+= choleskyStart_[iRow+1]-choleskyStart_[iRow]-1;
+    for (CoinBigIndex j=choleskyStart_[iRow]+1;j<choleskyStart_[iRow+1];j++) {
+      int jRow=choleskyRow_[j];
+      which[jRow]++;
+    }
+  }
+  CoinBigIndex sizeFactor =0;
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    int length = which[iRow];
+    permute_[iRow]=length;
+    tempStart[iRow]=sizeFactor;
+    which[iRow]=sizeFactor;
+    sizeFactor += length;
+  }
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    assert (choleskyRow_[choleskyStart_[iRow]]==iRow);
+    for (CoinBigIndex j=choleskyStart_[iRow]+1;j<choleskyStart_[iRow+1];j++) {
+      int jRow=choleskyRow_[j];
+      int put = which[iRow];
+      temp[put]=jRow;
+      which[iRow]++;
+      put = which[jRow];
+      temp[put]=iRow;
+      which[jRow]++;
+    }
+  }
+  for (int iRow=1;iRow<numberRows_;iRow++) 
+    assert (which[iRow-1]==tempStart[iRow]);
+  CoinBigIndex lastSpace=sizeFactor;
+  delete [] choleskyRow_;
+  choleskyRow_=temp;
+  delete [] choleskyStart_;
+  choleskyStart_=tempStart;
+  // linked lists of sizes and lengths
+  int * first = new int [numberRows_];
+  int * next = new int [numberRows_];
+  int * previous = new int [numberRows_];
+  char * mark = new char[numberRows_];
+  memset(mark,0,numberRows_);
+  CoinBigIndex * sort = new CoinBigIndex [numberRows_];
+  int * order = new int [numberRows_];
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    first[iRow]=-1;
+    next[iRow]=-1;
+    previous[iRow]=-1;
+    permuteInverse_[iRow]=-1;
+  }
+  int large = 1000+2*numberRows_;
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    int n = permute_[iRow];
+    if (first[n]<0) {
+      first[n]=iRow;
+      previous[iRow]=n+large;
+      next[iRow]=n+2*large;
+    } else {
+      int k=first[n];
+      assert (k<numberRows_);
+      first[n]=iRow;
+      previous[iRow]=n+large;
+      assert (previous[k]==n+large);
+      next[iRow]=k;
+      previous[k]=iRow;
+    }
+  }
+  int smallest=0;
+  int done=0;
+  int numberCompressions=0;
+  int numberExpansions=0;
+  while (smallest<numberRows_) {
+    if (first[smallest]<0||first[smallest]>numberRows_) {
+      smallest++;
+      continue;
+    }
+    int iRow=first[smallest];
+    if (false) {
+      int kRow=-1;
+      int ss=999999;
+      for (int jRow=numberRows_-1;jRow>=0;jRow--) {
+        if (permuteInverse_[jRow]<0) {
+          int length = permute_[jRow];
+          assert (length>0);
+          for (CoinBigIndex j=choleskyStart_[jRow];
+               j<choleskyStart_[jRow]+length;j++) {
+            int jjRow=choleskyRow_[j];
+            assert (permuteInverse_[jjRow]<0);
+          }
+          if (length<ss) {
+            ss=length;
+            kRow=jRow;
+          }
+        }
+      }
+      assert (smallest==ss);
+      printf("list chose %d - full chose %d - length %d\n",
+             iRow,kRow,ss);
+    }
+    int kNext = next[iRow];
+    first[smallest]=kNext;
+    if (kNext<numberRows_)
+      previous[kNext]=previous[iRow];
+    previous[iRow]=-1;
+    next[iRow]=-1;
+    permuteInverse_[iRow]=done;
+    done++;
+    // Now add edges
+    CoinBigIndex start=choleskyStart_[iRow];
+    CoinBigIndex end=choleskyStart_[iRow]+permute_[iRow];
+    int nSave=0;
+    for (CoinBigIndex k=start;k<end;k++) {
+      int kRow=choleskyRow_[k];
+      assert (permuteInverse_[kRow]<0);
+      //if (permuteInverse_[kRow]<0) 
+      which[nSave++]=kRow;
+    }
+    for (int i=0;i<nSave;i++) {
+      int kRow = which[i];
+      int length = permute_[kRow];
+      CoinBigIndex start=choleskyStart_[kRow];
+      CoinBigIndex end=choleskyStart_[kRow]+length;
+      for (CoinBigIndex j=start;j<end;j++) {
+        int jRow=choleskyRow_[j];
+        mark[jRow]=1;
+      }
+      mark[kRow]=1;
+      int n=nSave;
+      for (int j=0;j<nSave;j++) {
+        int jRow=which[j];
+        if (!mark[jRow]) {
+          which[n++]=jRow;
+        }
+      }
+      for (CoinBigIndex j=start;j<end;j++) {
+        int jRow=choleskyRow_[j];
+        mark[jRow]=0;
+      }
+      mark[kRow]=0;
+      if (n>nSave) {
+        bool inPlace = (n-nSave==1);
+        if (!inPlace) {
+          // extend
+          int length = n-nSave+end-start;
+          if (length+lastSpace>space) {
+            // need to compress
+            numberCompressions++;
+            int newN=0;
+            for (int iRow=0;iRow<numberRows_;iRow++) {
+              CoinBigIndex start=choleskyStart_[iRow];
+              if (permuteInverse_[iRow]<0) {
+                sort[newN]=start;
+                order[newN++]=iRow;
+              } else {
+                choleskyStart_[iRow]=-1;
+                permute_[iRow]=0;
+              }
+            }
+            CoinSort_2(sort,sort+newN,order);
+            sizeFactor=0;
+            for (int k=0;k<newN;k++) {
+              int iRow=order[k];
+              int length = permute_[iRow];
+              CoinBigIndex start=choleskyStart_[iRow];
+              choleskyStart_[iRow]=sizeFactor;
+              for (int j=0;j<length;j++) 
+                choleskyRow_[sizeFactor+j]=choleskyRow_[start+j];
+              sizeFactor += length;
+            }
+            lastSpace=sizeFactor;
+            if ((sizeFactor+numberRows_+1000)*4>3*space) {
+              // need to expand
+              numberExpansions++;
+              space = (3*space)/2;
+              int * temp = new int [space];
+              memcpy(temp,choleskyRow_,sizeFactor*sizeof(int));
+              delete [] choleskyRow_;
+              choleskyRow_=temp;
+            }
+          }
+        }
+        // Now add
+        start=choleskyStart_[kRow];
+        end=choleskyStart_[kRow]+permute_[kRow];
+        if (!inPlace)
+          choleskyStart_[kRow]=lastSpace;
+        CoinBigIndex put = choleskyStart_[kRow];
+        for (CoinBigIndex j=start;j<end;j++) {
+          int jRow=choleskyRow_[j];
+          if (permuteInverse_[jRow]<0) 
+            choleskyRow_[put++]=jRow;
+        }
+        for (int j=nSave;j<n;j++) {
+          int jRow=which[j];
+          choleskyRow_[put++]=jRow;
+        }
+        if (!inPlace) {
+          permute_[kRow]=put-lastSpace;
+          lastSpace=put;
+        } else {
+          permute_[kRow]=put-choleskyStart_[kRow];
+        }
+      } else {
+        // pack down for new counts
+        CoinBigIndex put=start;
+        for (CoinBigIndex j=start;j<end;j++) {
+          int jRow=choleskyRow_[j];
+          if (permuteInverse_[jRow]<0) 
+            choleskyRow_[put++]=jRow;
+        }
+        permute_[kRow]=put-start;
+      } 
+      // take out
+      int iNext = next[kRow];
+      int iPrevious = previous[kRow];
+      if (iPrevious<numberRows_) {
+        next[iPrevious]=iNext;
+      } else {
+        assert (iPrevious==length+large);
+        first[length]=iNext;
+      }
+      if (iNext<numberRows_) {
+        previous[iNext]=iPrevious;
+      } else {
+        assert (iNext==length+2*large);
+      }
+      // put in
+      length=permute_[kRow];
+      smallest = CoinMin(smallest,length);
+      if (first[length]<0||first[length]>numberRows_) {
+        first[length]=kRow;
+        previous[kRow]=length+large;
+        next[kRow]=length+2*large;
+      } else {
+        int k=first[length];
+        assert (k<numberRows_);
+        first[length]=kRow;
+        previous[kRow]=length+large;
+        assert (previous[k]==length+large);
+        next[kRow]=k;
+        previous[k]=kRow;
+      }
+    }
+  }
+  // do rest
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    if (permuteInverse_[iRow]<0) 
+      permuteInverse_[iRow]=done++;
+  }
+  printf("%d compressions, %d expansions\n",
+         numberCompressions,numberExpansions);
+  assert (done==numberRows_);
+  delete [] sort;
+  delete [] order;
+  delete [] which;
+  delete [] mark;
+  delete [] first;
+  delete [] next;
+  delete [] previous;
+  delete [] choleskyRow_;
+  choleskyRow_=NULL;
+  delete [] choleskyStart_;
+  choleskyStart_=NULL;
+#ifndef NDEBUG
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    permute_[iRow]=-1;
+  }
+#endif
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    permute_[permuteInverse_[iRow]]=iRow;
+  }
+#ifndef NDEBUG
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    assert(permute_[iRow]>=0&&permute_[iRow]<numberRows_);
+  }
+#endif
+  return returnCode;
+} 
+#elif BASE_ORDER==2
+/*----------------------------------------------------------------------------*/
+/*      (C) Copyright IBM Corporation 1997, 2009.  All Rights Reserved.       */
+/*----------------------------------------------------------------------------*/
+
+/*  A compact no-frills Approximate Minimum Local Fill ordering code.
+
+    References:
+
+[1] Ordering Sparse Matrices Using Approximate Minimum Local Fill.
+    Edward Rothberg, SGI Manuscript, April 1996.
+[2] An Approximate Minimum Degree Ordering Algorithm.
+    T. Davis, P. Amestoy, and I. Duff, TR-94-039, CIS Department,
+    University of Florida, December 1994. 
+*/
+
+#include <math.h>
+#include <stdlib.h>
+
+typedef int             WSI;
+
+#define NORDTHRESH      7
+#define MAXIW           2147000000
+
+//#define WSSMP_DBG
+#ifdef WSSMP_DBG
+static void chk (WSI ind, WSI i, WSI lim) {
+
+  if (i <= 0 || i > lim) {
+    printf("%d: chk: myamlf: WAR**: i, lim = %d, %d\n",ind,i,lim);
+  }
+}
+#endif
+
+static void 
+myamlf(WSI n, WSI xadj[], WSI adjncy[], WSI dgree[], WSI varbl[], 
+       WSI snxt[], WSI perm[], WSI invp[], WSI head[], WSI lsize[], 
+       WSI flag[], WSI erscore[], WSI locaux, WSI adjln, WSI speed)
+{
+WSI l, i, j, k;
+double x, y;
+WSI maxmum, fltag, nodeg, scln, nm1, deg, tn,
+    locatns, ipp, jpp, nnode, numpiv, node, 
+    nodeln, currloc, counter, numii, mindeg,
+    i0, i1, i2, i4, i5, i6, i7, i9,
+    j0, j1, j2, j3, j4, j5, j6, j7, j8, j9;
+/*                                             n cannot be less than NORDTHRESH
+ if (n < 3) {
+    if (n > 0) perm[0] = invp[0] = 1;
+    if (n > 1) perm[1] = invp[1] = 2; 
+    return;
+ }
+*/
+#ifdef WSSMP_DBG
+ printf("Myamlf: n, locaux, adjln, speed = %d,%d,%d,%d\n",n,locaux,adjln,speed);
+ for (i = 0; i < n; i++) flag[i] = 0;
+ k = xadj[0];
+ for (i = 1; i <= n; i++) {
+   j = k + dgree[i-1];
+   if (j < k || k < 1) printf("ERR**: myamlf: i, j, k = %d,%d,%d\n",i,j,k);
+   for (l = k; l < j; l++) {
+      if (adjncy[l - 1] < 1 || adjncy[l - 1] > n || adjncy[l - 1] == i)
+        printf("ERR**: myamlf: i, l, adjj[l] = %d,%d,%d\n",i,l,adjncy[l - 1]);
+      if (flag[adjncy[l - 1] - 1] == i)
+        printf("ERR**: myamlf: duplicate entry: %d - %d\n",i,adjncy[l - 1]);
+      flag[adjncy[l - 1] - 1] = i;
+      nm1 = adjncy[l - 1] - 1;
+      for (fltag = xadj[nm1]; fltag < xadj[nm1] + dgree[nm1]; fltag++) {
+        if (adjncy[fltag - 1] == i) goto L100;
+      }
+      printf("ERR**: Unsymmetric %d %d\n",i,fltag);
+L100:;
+   }
+   k = j;
+   if (k > locaux) printf("ERR**: i, j, k, locaux = %d, %d, %d, %d\n",
+                                  i, j, k, locaux);
+ }
+ if (n*(n-1) < locaux-1) printf("ERR**: myamlf: too many nnz, n, ne = %d, %d\n",
+                                n,adjln);
+ for (i = 0; i < n; i++) flag[i] = 1;
+ if (n > 10000) printf ("Finished error checking in AMF\n");
+ for (i = locaux; i <= adjln; i++) adjncy[i - 1] = -22;
+#endif
+
+ maxmum = 0;
+ mindeg = 1;
+ fltag = 2;
+ locatns = locaux - 1;
+ nm1 = n - 1;
+ counter = 1;
+ for (l = 0; l < n; l++) {
+     j = erscore[l];
+#ifdef WSSMP_DBG
+chk(1,j,n);
+#endif
+     if (j > 0) {
+         nnode = head[j - 1];
+         if (nnode) perm[nnode - 1] = l + 1;
+         snxt[l] = nnode;
+         head[j - 1] = l + 1;
+     } else {
+         invp[l] = -(counter++);
+         flag[l] = xadj[l] = 0;
+     }
+ }
+ while (counter <= n) {
+   for (deg = mindeg; head[deg - 1] < 1; deg++) {};
+     nodeg = 0;
+#ifdef WSSMP_DBG
+chk(2,deg,n-1);
+#endif
+     node = head[deg - 1];
+#ifdef WSSMP_DBG
+chk(3,node,n);
+#endif
+     mindeg = deg;
+     nnode = snxt[node - 1];
+     if (nnode) perm[nnode - 1] = 0;
+     head[deg - 1] = nnode;
+     nodeln = invp[node - 1];
+     numpiv = varbl[node - 1];
+     invp[node - 1] = -counter;
+     counter += numpiv;
+     varbl[node - 1] = -numpiv;
+     if (nodeln) {
+         j4 = locaux;
+         i5 = lsize[node - 1] - nodeln;
+         i2 = nodeln + 1;
+         l = xadj[node - 1];
+         for (i6 = 1; i6 <= i2; ++i6) {
+             if (i6 == i2) {
+                 tn = node, i0 = l, scln = i5;
+             } else {
+#ifdef WSSMP_DBG
+chk(4,l,adjln);
+#endif
+                 tn = adjncy[l-1];
+                 l++;
+#ifdef WSSMP_DBG
+chk(5,tn,n);
+#endif
+                 i0 = xadj[tn - 1];
+                 scln = lsize[tn - 1];
+             }
+             for (i7 = 1; i7 <= scln; ++i7) {
+#ifdef WSSMP_DBG
+chk(6,i0,adjln);
+#endif
+               i = adjncy[i0 - 1];
+               i0++;
+#ifdef WSSMP_DBG
+chk(7,i,n);
+#endif
+               numii = varbl[i - 1];
+               if (numii > 0) {
+                 if (locaux > adjln) {
+                   lsize[node - 1] -= i6;
+                   xadj[node - 1] = l;
+                   if (!lsize[node - 1]) xadj[node - 1] = 0;
+                   xadj[tn - 1] = i0;
+                   lsize[tn - 1] = scln - i7;
+                   if (!lsize[tn - 1]) xadj[tn - 1] = 0;
+                   for (j = 1; j <= n; j++) {
+                     i4 = xadj[j - 1];
+                     if (i4 > 0) {
+                       xadj[j - 1] = adjncy[i4 - 1];
+#ifdef WSSMP_DBG
+chk(8,i4,adjln);
+#endif
+                       adjncy[i4 - 1] = -j;
+                     }
+                   }
+                   i9 = j4 - 1;
+                   j6 = j7 = 1;
+                   while (j6 <= i9) {
+#ifdef WSSMP_DBG
+chk(9,j6,adjln);
+#endif
+                     j = -adjncy[j6 - 1];
+                     j6++;
+                     if (j > 0) {
+#ifdef WSSMP_DBG
+chk(10,j7,adjln);
+chk(11,j,n);
+#endif
+                       adjncy[j7 - 1] = xadj[j - 1];
+                       xadj[j - 1] = j7++;
+                       j8 = lsize[j - 1] - 1 + j7;
+                       for (; j7 < j8; j7++,j6++) adjncy[j7-1] = adjncy[j6-1];
+                     }
+                   }
+                   for (j0=j7; j4 < locaux; j4++,j7++) {
+#ifdef WSSMP_DBG
+chk(12,j4,adjln);
+#endif
+                     adjncy[j7 - 1] = adjncy[j4 - 1];
+                   }
+                   j4 = j0;
+                   locaux = j7;
+                   i0 = xadj[tn - 1];
+                   l = xadj[node - 1];
+                 }
+                 adjncy[locaux-1] = i;
+                 locaux++;
+                 varbl[i - 1] = -numii;
+                 nodeg += numii;
+                 ipp = perm[i - 1];
+                 nnode = snxt[i - 1];
+#ifdef WSSMP_DBG
+if (ipp) chk(13,ipp,n);
+if (nnode) chk(14,nnode,n);
+#endif
+                 if (ipp) snxt[ipp - 1] = nnode; 
+                 else head[erscore[i - 1] - 1] = nnode;
+                 if (nnode) perm[nnode - 1] = ipp;
+               }
+             }
+             if (tn != node) {
+                 flag[tn - 1] = 0, xadj[tn - 1] = -node;
+             }
+         }
+         currloc = (j5 = locaux) - j4;
+         locatns += currloc;
+     } else {
+         i1 = (j4 = xadj[node - 1]) + lsize[node - 1];
+         for (j = j5 = j4; j < i1; j++) {
+#ifdef WSSMP_DBG
+chk(15,j,adjln);
+#endif
+             i = adjncy[j - 1];
+#ifdef WSSMP_DBG
+chk(16,i,n);
+#endif
+             numii = varbl[i - 1];
+             if (numii > 0) {
+                 nodeg += numii;
+                 varbl[i - 1] = -numii;
+#ifdef WSSMP_DBG
+chk(17,j5,adjln);
+#endif
+                 adjncy[j5-1] = i;
+                 ipp = perm[i - 1];
+                 nnode = snxt[i - 1];
+                 j5++;
+#ifdef WSSMP_DBG
+if (ipp) chk(18,ipp,n);
+if (nnode) chk(19,nnode,n);
+#endif
+                 if (ipp) snxt[ipp - 1] = nnode; 
+                 else head[erscore[i - 1] - 1] = nnode;
+                 if (nnode) perm[nnode - 1] = ipp;
+             }
+         }
+         currloc = 0;
+     }
+#ifdef WSSMP_DBG
+chk(20,node,n);
+#endif
+     lsize[node - 1] = j5 - (xadj[node - 1] = j4);
+     dgree[node - 1] = nodeg;
+     if (fltag+n < 0 || fltag+n > MAXIW) {
+       for (i = 1; i <= n; i++) if (flag[i - 1]) flag[i - 1] = 1;
+       fltag = 2;
+     }
+     for (j3 = j4; j3 < j5; j3++) {
+#ifdef WSSMP_DBG
+chk(21,j3,adjln);
+#endif
+       i = adjncy[j3 - 1];
+#ifdef WSSMP_DBG
+chk(22,i,n);
+#endif
+       j = invp[i - 1];
+       if (j > 0) {
+         i4 = fltag - (numii = -varbl[i - 1]);
+         i2 = xadj[i - 1] + j;
+         for (l = xadj[i - 1]; l < i2; l++) {
+#ifdef WSSMP_DBG
+chk(23,l,adjln);
+#endif
+           tn = adjncy[l - 1];
+#ifdef WSSMP_DBG
+chk(24,tn,n);
+#endif
+           j9 = flag[tn - 1];
+           if (j9 >= fltag) j9 -= numii; else if (j9) j9 = dgree[tn - 1] + i4;
+           flag[tn - 1] = j9;
+         }
+       }
+     }
+     for (j3 = j4; j3 < j5; j3++) {
+#ifdef WSSMP_DBG
+chk(25,j3,adjln);
+#endif
+         i = adjncy[j3 - 1];
+         i5 = deg = 0;
+#ifdef WSSMP_DBG
+chk(26,i,n);
+#endif
+         j1 = (i4 = xadj[i - 1]) + invp[i - 1];
+         for (l = j0 = i4; l < j1; l++) {
+#ifdef WSSMP_DBG
+chk(27,l,adjln);
+#endif
+             tn = adjncy[l - 1];
+#ifdef WSSMP_DBG
+chk(70,tn,n);
+#endif
+             j8 = flag[tn - 1];
+             if (j8) {
+                 deg += (j8 - fltag);
+#ifdef WSSMP_DBG
+chk(28,i4,adjln);
+#endif
+                 adjncy[i4-1] = tn;
+                 i5 += tn;
+                 i4++;
+                 while (i5 >= nm1) i5 -= nm1;
+             }
+         }
+         invp[i - 1] = (j2 = i4) - j0 + 1;
+         i2 = j0 + lsize[i - 1];
+         for (l = j1; l < i2; l++) {
+#ifdef WSSMP_DBG
+chk(29,l,adjln);
+#endif
+             j = adjncy[l - 1];
+#ifdef WSSMP_DBG
+chk(30,j,n);
+#endif
+             numii = varbl[j - 1];
+             if (numii > 0) {
+                 deg += numii;
+#ifdef WSSMP_DBG
+chk(31,i4,adjln);
+#endif
+                 adjncy[i4-1] = j;
+                 i5 += j;
+                 i4++;
+                 while (i5 >= nm1) i5 -= nm1;
+             }
+         }
+         if (invp[i - 1] == 1 && j2 == i4) {
+             numii = -varbl[i - 1];
+             xadj[i - 1] = -node;
+             nodeg -= numii;
+             counter += numii;
+             numpiv += numii;
+             invp[i - 1] = varbl[i - 1] = 0;
+         } else {
+             if (dgree[i - 1] > deg) dgree[i - 1] = deg;
+#ifdef WSSMP_DBG
+chk(32,j2,adjln);
+chk(33,j0,adjln);
+#endif
+             adjncy[i4 - 1] = adjncy[j2 - 1];
+             adjncy[j2 - 1] = adjncy[j0 - 1];
+             adjncy[j0 - 1] = node;
+             lsize[i - 1] = i4 - j0 + 1;
+             i5++;
+#ifdef WSSMP_DBG
+chk(35,i5,n);
+#endif
+             j = head[i5 - 1];
+             if (j > 0) {
+                 snxt[i - 1] = perm[j - 1];
+                 perm[j - 1] = i;
+             } else {
+                 snxt[i - 1] = -j;
+                 head[i5 - 1] = -i;
+             }
+             perm[i - 1] = i5;
+         }
+     }
+#ifdef WSSMP_DBG
+chk(36,node,n);
+#endif
+     dgree[node - 1] = nodeg;
+     if (maxmum < nodeg) maxmum = nodeg;
+     fltag += maxmum;
+#ifdef WSSMP_DBG
+     if (fltag+n+1 < 0) printf("ERR**: fltag = %d (A)\n",fltag);
+#endif
+     for (j3 = j4; j3 < j5; ++j3) {
+#ifdef WSSMP_DBG
+chk(37,j3,adjln);
+#endif
+       i = adjncy[j3 - 1];
+#ifdef WSSMP_DBG
+chk(38,i,n);
+#endif
+       if (varbl[i - 1] < 0) {
+         i5 = perm[i - 1];
+#ifdef WSSMP_DBG
+chk(39,i5,n);
+#endif
+         j = head[i5 - 1];
+         if (j) {
+           if (j < 0) {
+                head[i5 - 1] = 0, i = -j;
+           } else {
+#ifdef WSSMP_DBG
+chk(40,j,n);
+#endif
+                i = perm[j - 1];
+                perm[j - 1] = 0;
+           }
+           while (i) {
+#ifdef WSSMP_DBG
+chk(41,i,n);
+#endif
+             if (!snxt[i - 1]) {
+                 i = 0;
+             } else {
+               k = invp[i - 1];
+               i2 = xadj[i - 1] + (scln = lsize[i - 1]);
+               for (l = xadj[i - 1] + 1; l < i2; l++) {
+#ifdef WSSMP_DBG
+chk(42,l,adjln);
+chk(43,adjncy[l - 1],n);
+#endif
+                 flag[adjncy[l - 1] - 1] = fltag;
+               }
+               jpp = i;
+               j = snxt[i - 1];
+               while (j) {
+#ifdef WSSMP_DBG
+chk(44,j,n);
+#endif
+                 if (lsize[j - 1] == scln && invp[j - 1] == k) {
+                   i2 = xadj[j - 1] + scln;
+                   j8 = 1;
+                   for (l = xadj[j - 1] + 1; l < i2; l++) {
+#ifdef WSSMP_DBG
+chk(45,l,adjln);
+chk(46,adjncy[l - 1],n);
+#endif
+                       if (flag[adjncy[l - 1] - 1] != fltag) {
+                         j8 = 0;
+                         break;
+                       }
+                   }
+                   if (j8) {
+                     xadj[j - 1] = -i;
+                     varbl[i - 1] += varbl[j - 1];
+                     varbl[j - 1] = invp[j - 1] = 0;
+#ifdef WSSMP_DBG
+chk(47,j,n);
+chk(48,jpp,n);
+#endif
+                     j = snxt[j - 1];
+                     snxt[jpp - 1] = j;
+                   } else {
+                     jpp = j;
+#ifdef WSSMP_DBG
+chk(49,j,n);
+#endif
+                     j = snxt[j - 1];
+                   }
+                 } else {
+                   jpp = j;
+#ifdef WSSMP_DBG
+chk(50,j,n);
+#endif
+                   j = snxt[j - 1];
+                 }
+               }
+               fltag++;
+#ifdef WSSMP_DBG
+               if (fltag+n+1 < 0) printf("ERR**: fltag = %d (B)\n",fltag);
+#endif
+#ifdef WSSMP_DBG
+chk(51,i,n);
+#endif
+               i = snxt[i - 1];
+             }
+           }
+         }
+       }
+     }
+     j8 = nm1 - counter;
+     switch (speed) {
+case 1:
+       for (j = j3 = j4; j3 < j5; j3++) {
+#ifdef WSSMP_DBG
+chk(52,j3,adjln);
+#endif
+         i = adjncy[j3 - 1];
+#ifdef WSSMP_DBG
+chk(53,i,n);
+#endif
+         numii = varbl[i - 1];
+         if (numii < 0) {
+           k = 0;
+           i4 = (l = xadj[i - 1]) + invp[i - 1];
+           for (; l < i4; l++) {
+#ifdef WSSMP_DBG
+chk(54,l,adjln);
+chk(55,adjncy[l - 1],n);
+#endif
+              i5 = dgree[adjncy[l - 1] - 1];
+              if (k < i5) k = i5;
+           }
+           x = static_cast<double> (k - 1);
+           varbl[i - 1] = abs(numii);
+           j9 = dgree[i - 1] + nodeg;
+           deg = (j8 > j9 ? j9 : j8) + numii;
+           if (deg < 1) deg = 1;
+           y = static_cast<double> (deg);
+           dgree[i - 1] = deg;
+/*
+           printf("%i %f should >= %i %f\n",deg,y,k-1,x);
+           if (y < x) printf("** \n"); else printf("\n");
+*/
+           y = y*y - y;
+           x = y - (x*x - x);
+           if (x < 1.1) x = 1.1;
+           deg = static_cast<WSI>(sqrt(x));
+/*         if (deg < 1) deg = 1; */
+           erscore[i - 1] = deg;
+#ifdef WSSMP_DBG
+chk(56,deg,n-1);
+#endif
+           nnode = head[deg - 1];
+           if (nnode) perm[nnode - 1] = i;
+           snxt[i - 1] = nnode;
+           perm[i - 1] = 0;
+#ifdef WSSMP_DBG
+chk(57,j,adjln);
+#endif
+           head[deg - 1] = adjncy[j-1] = i;
+           j++;
+           if (deg < mindeg) mindeg = deg;
+         }
+       }
+       break;
+case 2:
+       for (j = j3 = j4; j3 < j5; j3++) {
+#ifdef WSSMP_DBG
+chk(58,j3,adjln);
+#endif
+         i = adjncy[j3 - 1];
+#ifdef WSSMP_DBG
+chk(59,i,n);
+#endif
+         numii = varbl[i - 1];
+         if (numii < 0) {
+           x = static_cast<double> (dgree[adjncy[xadj[i - 1] - 1] - 1] - 1);
+           varbl[i - 1] = abs(numii);
+           j9 = dgree[i - 1] + nodeg;
+           deg = (j8 > j9 ? j9 : j8) + numii;
+           if (deg < 1) deg = 1;
+           y = static_cast<double> (deg);
+           dgree[i - 1] = deg;
+/*
+           printf("%i %f should >= %i %f",deg,y,dgree[adjncy[xadj[i - 1] - 1] - 1]-1,x);
+           if (y < x) printf("** \n"); else printf("\n");
+*/
+           y = y*y - y;
+           x = y - (x*x - x);
+           if (x < 1.1) x = 1.1;
+           deg = static_cast<WSI>(sqrt(x));
+/*         if (deg < 1) deg = 1; */
+           erscore[i - 1] = deg;
+#ifdef WSSMP_DBG
+chk(60,deg,n-1);
+#endif
+           nnode = head[deg - 1];
+           if (nnode) perm[nnode - 1] = i;
+           snxt[i - 1] = nnode;
+           perm[i - 1] = 0;
+#ifdef WSSMP_DBG
+chk(61,j,adjln);
+#endif
+           head[deg - 1] = adjncy[j-1] = i;
+           j++;
+           if (deg < mindeg) mindeg = deg;
+         }
+       }
+       break;
+default:
+       for (j = j3 = j4; j3 < j5; j3++) {
+#ifdef WSSMP_DBG
+chk(62,j3,adjln);
+#endif
+         i = adjncy[j3 - 1];
+#ifdef WSSMP_DBG
+chk(63,i,n);
+#endif
+         numii = varbl[i - 1];
+         if (numii < 0) {
+           varbl[i - 1] = abs(numii);
+           j9 = dgree[i - 1] + nodeg;
+           deg = (j8 > j9 ? j9 : j8) + numii;
+           if (deg < 1) deg = 1;
+           dgree[i - 1] = deg;
+#ifdef WSSMP_DBG
+chk(64,deg,n-1);
+#endif
+           nnode = head[deg - 1];
+           if (nnode) perm[nnode - 1] = i;
+           snxt[i - 1] = nnode;
+           perm[i - 1] = 0;
+#ifdef WSSMP_DBG
+chk(65,j,adjln);
+#endif
+           head[deg - 1] = adjncy[j-1] = i;
+           j++;
+           if (deg < mindeg) mindeg = deg;
+         }
+       }
+       break;
+     }
+     if (currloc) {
+#ifdef WSSMP_DBG
+chk(66,node,n);
+#endif
+       locatns += (lsize[node - 1] - currloc), locaux = j;
+     }
+     varbl[node - 1] = numpiv + nodeg;
+     lsize[node - 1] = j - j4;
+     if (!lsize[node - 1]) flag[node - 1] = xadj[node - 1] = 0;
+ }
+ for (l = 1; l <= n; l++) {
+   if (!invp[l - 1]) {
+     for (i = -xadj[l - 1]; invp[i - 1] >= 0; i = -xadj[i - 1]){};
+       tn = i;
+#ifdef WSSMP_DBG
+chk(67,tn,n);
+#endif
+       k = -invp[tn - 1];
+       i = l;
+#ifdef WSSMP_DBG
+chk(68,i,n);
+#endif
+       while (invp[i - 1] >= 0) {
+         nnode = -xadj[i - 1];
+         xadj[i - 1] = -tn;
+         if (!invp[i - 1]) invp[i - 1] = k++;
+         i = nnode;
+       }
+       invp[tn - 1] = -k;
+   }
+ }
+ for (l = 0; l < n; l++) {
+   i = abs(invp[l]);
+#ifdef WSSMP_DBG
+chk(69,i,n);
+#endif
+   invp[l] = i;
+   perm[i - 1] = l + 1;
+ }
+ return;
+}
+// This code is not needed, but left in in case needed sometime
+#if 0
+/*C--------------------------------------------------------------------------*/
+void amlfdr(WSI *n, WSI xadj[], WSI adjncy[], WSI dgree[], WSI *adjln,
+            WSI *locaux, WSI varbl[], WSI snxt[], WSI perm[],
+            WSI head[], WSI invp[], WSI lsize[], WSI flag[], WSI *ispeed)
+{
+WSI nn,nlocaux,nadjln,speed,i,j,mx,mxj,*erscore;
+
+#ifdef WSSMP_DBG
+  printf("Calling amlfdr for n, speed = %d, %d\n",*n,*ispeed);
+#endif
+
+  if ((nn = *n) == 0) return;
+
+#ifdef WSSMP_DBG
+  if (nn == 31) {
+    printf("n = %d; adjln = %d; locaux = %d; ispeed = %d\n",
+            *n,*adjln,*locaux,*ispeed);
+  }
+#endif
+
+  if (nn < NORDTHRESH) {
+    for (i = 0; i < nn; i++) lsize[i] = i;
+    for (i = nn; i > 0; i--) {
+      mx = dgree[0];
+      mxj = 0;
+      for (j = 1; j < i; j++)
+        if (dgree[j] > mx) {
+          mx = dgree[j];
+          mxj = j;
+        }
+      invp[lsize[mxj]] = i;
+      dgree[mxj] = dgree[i-1];
+      lsize[mxj] = lsize[i-1];
+    }
+    return;
+  }
+  speed = *ispeed;
+  if (speed < 3) {
+/*  
+    erscore = (WSI *)malloc(nn * sizeof(WSI)); 
+    if (erscore == NULL) speed = 3;
+*/
+    wscmal (&nn, &i, &erscore);
+    if (i != 0) speed = 3;
+  }
+  if (speed > 2) erscore = dgree;
+  if (speed < 3) {
+    for (i = 0; i < nn; i++) {
+      perm[i] = 0;
+      invp[i] = 0;
+      head[i] = 0;
+      flag[i] = 1;
+      varbl[i] = 1;
+      lsize[i] = dgree[i];
+      erscore[i] = dgree[i];
+    }
+  } else {
+    for (i = 0; i < nn; i++) {
+      perm[i] = 0;
+      invp[i] = 0;
+      head[i] = 0;
+      flag[i] = 1;
+      varbl[i] = 1;
+      lsize[i] = dgree[i];
+    }
+  }
+  nlocaux = *locaux;
+  nadjln = *adjln;
+
+  myamlf(nn, xadj, adjncy, dgree, varbl, snxt, perm, invp,
+         head, lsize, flag, erscore, nlocaux, nadjln, speed);
+/*
+  if (speed < 3) free(erscore);
+*/
+  if (speed < 3) wscfr(&erscore);
+  return;
+}
+#endif // end of taking out amlfdr
+/*C--------------------------------------------------------------------------*/
+#endif
+// Orders rows
+int 
+ClpCholeskyBase::orderAMD()
+{
+  permuteInverse_ = new int [numberRows_];
+  permute_ = new int[numberRows_];
+  // Do ordering
+  int returnCode=0;
+  // get full matrix
+  int space = 2*sizeFactor_+10000+4*numberRows_;
+  int * temp = new int [space];
+  CoinBigIndex * count = new CoinBigIndex [numberRows_];
+  CoinBigIndex * tempStart = new CoinBigIndex [numberRows_+1];
+  memset(count,0,numberRows_*sizeof(int));
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    count[iRow]+= choleskyStart_[iRow+1]-choleskyStart_[iRow]-1;
+    for (CoinBigIndex j=choleskyStart_[iRow]+1;j<choleskyStart_[iRow+1];j++) {
+      int jRow=choleskyRow_[j];
+      count[jRow]++;
+    }
+  }
+#define OFFSET 1
+  CoinBigIndex sizeFactor =0;
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    int length = count[iRow];
+    permute_[iRow]=length;
+    // add 1 to starts
+    tempStart[iRow]=sizeFactor+OFFSET;
+    count[iRow]=sizeFactor;
+    sizeFactor += length;
+  }
+  tempStart[numberRows_]=sizeFactor+OFFSET;
+  // add 1 to rows 
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    assert (choleskyRow_[choleskyStart_[iRow]]==iRow);
+    for (CoinBigIndex j=choleskyStart_[iRow]+1;j<choleskyStart_[iRow+1];j++) {
+      int jRow=choleskyRow_[j];
+      int put = count[iRow];
+      temp[put]=jRow+OFFSET;
+      count[iRow]++;
+      put = count[jRow];
+      temp[put]=iRow+OFFSET;
+      count[jRow]++;
+    }
+  }
+  for (int iRow=1;iRow<numberRows_;iRow++) 
+    assert (count[iRow-1]==tempStart[iRow]-OFFSET);
+  delete [] choleskyRow_;
+  choleskyRow_=temp;
+  delete [] choleskyStart_;
+  choleskyStart_=tempStart;
+  int locaux=sizeFactor+OFFSET;
+  delete [] count;
+  int speed=integerParameters_[0];
+  if (speed<1||speed>2)
+    speed=3;
+  int * use = new int [((speed<3) ? 7 : 6)*numberRows_];
+  int * dgree = use;
+  int * varbl = dgree+numberRows_;
+  int * snxt = varbl+numberRows_;
+  int * head = snxt+numberRows_;
+  int * lsize = head+numberRows_;
+  int * flag = lsize+numberRows_;
+  int * erscore;
+  for (int i=0;i<numberRows_;i++) {
+    dgree[i]=choleskyStart_[i+1]-choleskyStart_[i];
+    head[i]=dgree[i];
+    snxt[i]=0;
+    permute_[i]=0;
+    permuteInverse_[i]=0;
+    head[i]=0;
+    flag[i]=1;
+    varbl[i]=1;
+    lsize[i]=dgree[i];
+  }
+  if (speed<3) {
+    erscore = flag+numberRows_;
+    for (int i=0;i<numberRows_;i++) 
+      erscore[i]=dgree[i];
+  } else {
+    erscore = dgree;
+  }
+  myamlf(numberRows_, choleskyStart_, choleskyRow_, 
+         dgree, varbl, snxt, permute_, permuteInverse_,
+         head, lsize, flag, erscore, locaux, space, speed);
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    permute_[iRow]--;
+  }
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    permuteInverse_[permute_[iRow]]=iRow;
+  }
+  for (int iRow=0;iRow<numberRows_;iRow++) {
+    assert (permuteInverse_[iRow]>=0&&permuteInverse_[iRow]<numberRows_);
+  }
+  delete [] use;
+  delete [] choleskyRow_;
+  choleskyRow_=NULL;
+  delete [] choleskyStart_;
+  choleskyStart_=NULL;
+  return returnCode;
 }
 /* Does Symbolic factorization given permutation.
@@ -1237 +2396 @@
 #else
     // actually long double
-    workDouble_ = (double *) (new longWork[numberRows_]);
+    workDouble_ = reinterpret_cast<double *> (new CoinWorkDouble[numberRows_]);
 #endif
     diagonal_ = new longDouble[numberRows_];
@@ -1338 +2497 @@
       int k=iRow;
       int linked = link_[iRow];
+#ifndef NDEBUG
+      int count=0;
+#endif
       while (linked<=kRow) {
         k=linked;
         linked = link_[k];
+#ifndef NDEBUG
+        count++;
+        assert (count<numberRows_);
+#endif
       }
       nz++;
@@ -1521 +2687 @@
 /* Factorize - filling in rowsDropped and returning number dropped */
 int 
-ClpCholeskyBase::factorize(const double * diagonal, int * rowsDropped) 
+ClpCholeskyBase::factorize(const CoinWorkDouble * diagonal, int * rowsDropped) 
 {
   const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
@@ -1533 +2699 @@
   int numberColumns=model_->clpMatrix()->getNumCols();
   //perturbation
-  longDouble perturbation=model_->diagonalPerturbation()*model_->diagonalNorm();
+  CoinWorkDouble perturbation=model_->diagonalPerturbation()*model_->diagonalNorm();
   //perturbation=perturbation*perturbation*100000000.0;
   if (perturbation>1.0) {
@@ -1540 +2706 @@
       std::cout <<"large perturbation "<<perturbation<<std::endl;
 #endif
-    perturbation=sqrt(perturbation);;
+    perturbation=CoinSqrt(perturbation);
     perturbation=1.0;
   }
@@ -1548 +2714 @@
   CoinZeroN(work,numberRows_);
   int newDropped=0;
-  double largest=1.0;
-  double smallest=COIN_DBL_MAX;
+  CoinWorkDouble largest=1.0;
+  CoinWorkDouble smallest=COIN_DBL_MAX;
   int numberDense=0;
   if (!doKKT_) {
-    const double * diagonalSlack = diagonal + numberColumns;
+    const CoinWorkDouble * diagonalSlack = diagonal + numberColumns;
     if (dense_)
       numberDense=dense_->numberRows();
@@ -1577 +2743 @@
       }
     }
-    longDouble delta2 = model_->delta(); // add delta*delta to diagonal
+    CoinWorkDouble delta2 = model_->delta(); // add delta*delta to diagonal
     delta2 *= delta2;
     // largest in initial matrix
-    double largest2=1.0e-20;
+    CoinWorkDouble largest2=1.0e-20;
     for (iRow=0;iRow<numberRows_;iRow++) {
       longDouble * put = sparseFactor_+choleskyStart_[iRow];
@@ -1597 +2763 @@
             CoinBigIndex start=columnStart[iColumn];
             CoinBigIndex end=columnStart[iColumn]+columnLength[iColumn];
-            longDouble multiplier = diagonal[iColumn]*elementByRow[k];
+            CoinWorkDouble multiplier = diagonal[iColumn]*elementByRow[k];
             for (CoinBigIndex j=start;j<end;j++) {
               int jRow=row[j];
               int jNewRow = permuteInverse_[jRow];
               if (jNewRow>=iRow&&!rowsDropped_[jRow]) {
-                longDouble value=element[j]*multiplier;
+                CoinWorkDouble value=element[j]*multiplier;
                 work[jNewRow] += value;
               }
@@ -1609 +2775 @@
         }
         diagonal_[iRow]=work[iRow];
-        largest2 = CoinMax(largest2,fabs(work[iRow]));
+        largest2 = CoinMax(largest2,CoinAbs(work[iRow]));
         work[iRow]=0.0;
         int j;
@@ -1615 +2781 @@
           int jRow = which[j];
           put[j]=work[jRow];
-          largest2 = CoinMax(largest2,fabs(work[jRow]));
+          largest2 = CoinMax(largest2,CoinAbs(work[jRow]));
           work[jRow]=0.0;
         }
@@ -1629 +2795 @@
     //check sizes
     largest2*=1.0e-20;
-    largest = CoinMin(largest2,1.0e-11);
+    largest = CoinMin(largest2,CHOL_SMALL_VALUE);
     int numberDroppedBefore=0;
     for (iRow=0;iRow<numberRows_;iRow++) {
@@ -1636 +2802 @@
       rowsDropped[iRow]=dropped;
       if (!dropped) {
-        longDouble diagonal = diagonal_[iRow];
+        CoinWorkDouble diagonal = diagonal_[iRow];
         if (diagonal>largest2) {
           diagonal_[iRow]=diagonal+perturbation;
@@ -1663 +2829 @@
       for ( i=0;i<numberRows_;i++) {
         assert (diagonal_[i]>=0.0);
-        diagonal_[i]=sqrt(diagonal_[i]);
+        diagonal_[i]=CoinSqrt(diagonal_[i]);
       }
       // Update dense columns (just L)
@@ -1673 +2839 @@
             a[j]=0.0;
         }
-        solveLong(a,1);
+        for (i=0;i<numberRows_;i++) {
+          int iRow = permute_[i];
+          workDouble_[i] = a[iRow];
+        }
+        for (i=0;i<numberRows_;i++) {
+          CoinWorkDouble value=workDouble_[i];
+          CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
+          CoinBigIndex j;
+          for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
+            int iRow = choleskyRow_[j+offset];
+            workDouble_[iRow] -= sparseFactor_[j]*value;
+          }
+        }
+        for (i=0;i<numberRows_;i++) {
+          int iRow = permute_[i];
+          a[iRow]=workDouble_[i]*diagonal_[i];
+        }
       }
       dense_->resetRowsDropped();
@@ -1682 +2864 @@
         const longDouble * a = denseColumn_+i*numberRows_;
         // do diagonal
-        longDouble value = denseDiagonal[i];
+        CoinWorkDouble value = denseDiagonal[i];
         const longDouble * b = denseColumn_+i*numberRows_;
         for (int k=0;k<numberRows_;k++) 
@@ -1688 +2870 @@
         denseDiagonal[i]=value;
         for (int j=i+1;j<numberDense;j++) {
-          longDouble value = 0.0;
+          CoinWorkDouble value = 0.0;
           const longDouble * b = denseColumn_+j*numberRows_;
           for (int k=0;k<numberRows_;k++) 
@@ -1778 +2960 @@
     }
     if (permuted) {
-      longDouble delta2 = model_->delta(); // add delta*delta to bottom
+      CoinWorkDouble delta2 = model_->delta(); // add delta*delta to bottom
       delta2 *= delta2;
       // Need to permute - ugly
@@ -1788 +2970 @@
           if (iOriginalRow<numberColumns) {
             iColumn=iOriginalRow;
-            longDouble value = diagonal[iColumn];
-            if (fabs(value)>1.0e-100) {
+            CoinWorkDouble value = diagonal[iColumn];
+            if (CoinAbs(value)>1.0e-100) {
               value = 1.0/value;
-              largest = CoinMax(largest,fabs(value));
+              largest = CoinMax(largest,CoinAbs(value));
               diagonal_[iRow] = -value;
               CoinBigIndex start=columnStart[iColumn];
@@ -1800 +2982 @@
                 if (kRow>iRow) {
                   work[kRow]=element[j];
-                  largest = CoinMax(largest,fabs(element[j]));
+                  largest = CoinMax(largest,CoinAbs(element[j]));
                 }
               }
@@ -1807 +2989 @@
             }
           } else if (iOriginalRow<numberTotal) {
-            longDouble value = diagonal[iOriginalRow];
-            if (fabs(value)>1.0e-100) {
+            CoinWorkDouble value = diagonal[iOriginalRow];
+            if (CoinAbs(value)>1.0e-100) {
               value = 1.0/value;
-              largest = CoinMax(largest,fabs(value));
+              largest = CoinMax(largest,CoinAbs(value));
             } else {
               value = 1.0e100;
@@ -1828 +3010 @@
               if (jNewRow>iRow) {
                 work[jNewRow]=elementByRow[j];
-                largest = CoinMax(largest,fabs(elementByRow[j]));
+                largest = CoinMax(largest,CoinAbs(elementByRow[j]));
               }
             }
@@ -1857 +3039 @@
             CoinBigIndex j;
             iColumn=iOriginalRow;
-            longDouble value = diagonal[iColumn];
-            if (fabs(value)>1.0e-100) {
+            CoinWorkDouble value = diagonal[iColumn];
+            if (CoinAbs(value)>1.0e-100) {
               value = 1.0/value;
               for (j=columnQuadraticStart[iColumn];
@@ -1870 +3052 @@
                 }
               }
-              largest = CoinMax(largest,fabs(value));
+              largest = CoinMax(largest,CoinAbs(value));
               diagonal_[iRow] = -value;
               CoinBigIndex start=columnStart[iColumn];
@@ -1879 +3061 @@
                 if (kRow>iRow) {
                   work[kRow]=element[j];
-                  largest = CoinMax(largest,fabs(element[j]));
+                  largest = CoinMax(largest,CoinAbs(element[j]));
                 }
               }
@@ -1886 +3068 @@
             }
           } else if (iOriginalRow<numberTotal) {
-            longDouble value = diagonal[iOriginalRow];
-            if (fabs(value)>1.0e-100) {
+            CoinWorkDouble value = diagonal[iOriginalRow];
+            if (CoinAbs(value)>1.0e-100) {
               value = 1.0/value;
-              largest = CoinMax(largest,fabs(value));
+              largest = CoinMax(largest,CoinAbs(value));
             } else {
               value = 1.0e100;
@@ -1907 +3089 @@
               if (jNewRow>iRow) {
                 work[jNewRow]=elementByRow[j];
-                largest = CoinMax(largest,fabs(elementByRow[j]));
+                largest = CoinMax(largest,CoinAbs(elementByRow[j]));
               }
             }
@@ -1931 +3113 @@
           longDouble * put = sparseFactor_+choleskyStart_[iColumn];
           int * which = choleskyRow_+indexStart_[iColumn];
-          longDouble value = diagonal[iColumn];
-          if (fabs(value)>1.0e-100) {
+          CoinWorkDouble value = diagonal[iColumn];
+          if (CoinAbs(value)>1.0e-100) {
             value = 1.0/value;
-            largest = CoinMax(largest,fabs(value));
+            largest = CoinMax(largest,CoinAbs(value));
             diagonal_[iColumn] = -value;
             CoinBigIndex start=columnStart[iColumn];
@@ -1942 +3124 @@
               //sparseFactor_[numberElements++]=element[j];
               work[row[j]+numberTotal]=element[j];
-              largest = CoinMax(largest,fabs(element[j]));
+              largest = CoinMax(largest,CoinAbs(element[j]));
             }
           } else {
@@ -1965 +3147 @@
           int * which = choleskyRow_+indexStart_[iColumn];
           int number = choleskyStart_[iColumn+1]-choleskyStart_[iColumn];
-          longDouble value = diagonal[iColumn];
+          CoinWorkDouble value = diagonal[iColumn];
           CoinBigIndex j;
-          if (fabs(value)>1.0e-100) {
+          if (CoinAbs(value)>1.0e-100) {
             value = 1.0/value;
             for (j=columnQuadraticStart[iColumn];
@@ -1978 +3160 @@
               }
             }
-            largest = CoinMax(largest,fabs(value));
+            largest = CoinMax(largest,CoinAbs(value));
             diagonal_[iColumn] = -value;
             CoinBigIndex start=columnStart[iColumn];
@@ -1984 +3166 @@
             for (j=start;j<end;j++) {
               work[row[j]+numberTotal]=element[j];
-              largest = CoinMax(largest,fabs(element[j]));
+              largest = CoinMax(largest,CoinAbs(element[j]));
             }
             for (j=0;j<number;j++) {
@@ -2005 +3187 @@
         longDouble * put = sparseFactor_+choleskyStart_[iColumn];
         int * which = choleskyRow_+indexStart_[iColumn];
-        longDouble value = diagonal[iColumn];
-        if (fabs(value)>1.0e-100) {
+        CoinWorkDouble value = diagonal[iColumn];
+        if (CoinAbs(value)>1.0e-100) {
           value = 1.0/value;
-          largest = CoinMax(largest,fabs(value));
+          largest = CoinMax(largest,CoinAbs(value));
         } else {
           value = 1.0e100;
@@ -2023 +3205 @@
       }
       // Finish diagonal
-      longDouble delta2 = model_->delta(); // add delta*delta to bottom
+      CoinWorkDouble delta2 = model_->delta(); // add delta*delta to bottom
       delta2 *= delta2;
       for (iRow=0;iRow<numberRowsModel;iRow++) {
@@ -2037 +3219 @@
     //check sizes
     largest*=1.0e-20;
-    largest = CoinMin(largest,1.0e-11);
+    largest = CoinMin(largest,CHOL_SMALL_VALUE);
     doubleParameters_[10]=CoinMax(1.0e-20,largest);
     integerParameters_[20]=0;
@@ -2056 +3238 @@
     // Should save adjustments in ..R_
     int n1=0,n2=0;
-    double * primalR = model_->primalR();
-    double * dualR = model_->dualR();
+    CoinWorkDouble * primalR = model_->primalR();
+    CoinWorkDouble * dualR = model_->dualR();
     for (iRow=0;iRow<numberTotal;iRow++) { 
       if (rowsDropped2[iRow]) {
@@ -2093 +3275 @@
 ClpCholeskyBase::factorizePart2(int * rowsDropped) 
 {
-  longDouble largest=doubleParameters_[3];
-  longDouble smallest=doubleParameters_[4];
+  CoinWorkDouble largest=doubleParameters_[3];
+  CoinWorkDouble smallest=doubleParameters_[4];
   int numberDropped=integerParameters_[20];
   // probably done before
@@ -2159 +3341 @@
       for ( jRow=lastRow;jRow<iRow;jRow++) {
         int jCount = jRow-lastRow;
-        longDouble diagonalValue = diagonal_[jRow];
+        CoinWorkDouble diagonalValue = diagonal_[jRow];
         CoinBigIndex start=choleskyStart_[jRow];
         CoinBigIndex end=choleskyStart_[jRow+1];
@@ -2165 +3347 @@
           jCount--;
           CoinBigIndex get = choleskyStart_[kRow]+jCount;
-          longDouble a_jk = sparseFactor_[get];
-          longDouble value1 = d[kRow]*a_jk;
+          CoinWorkDouble a_jk = sparseFactor_[get];
+          CoinWorkDouble value1 = d[kRow]*a_jk;
           diagonalValue -= a_jk*value1;
           for (CoinBigIndex j=start;j<end;j++)
@@ -2222 +3404 @@
     }
     // for each column L[*,kRow] that affects L[*,iRow] 
-    longDouble diagonalValue=diagonal_[iRow];
+    CoinWorkDouble diagonalValue=diagonal_[iRow];
     int nextRow = link_[iRow];
     int kRow=0;
@@ -2234 +3416 @@
       CoinBigIndex end=choleskyStart_[kRow+1];
       assert(k<end);
-      longDouble a_ik=sparseFactor_[k++];
-      longDouble value1=d[kRow]*a_ik;
+      CoinWorkDouble a_ik=sparseFactor_[k++];
+      CoinWorkDouble value1=d[kRow]*a_ik;
       // update first
       first[kRow]=k;
@@ -2259 +3441 @@
             CoinBigIndex j=first[kkRow];
             //int iiRow = choleskyRow_[j+indexStart_[kkRow]-choleskyStart_[kkRow]];
-            longDouble a = sparseFactor_[j];
-            longDouble dValue = d[kkRow]*a;
+            CoinWorkDouble a = sparseFactor_[j];
+            CoinWorkDouble dValue = d[kkRow]*a;
             diagonalValue -= a*dValue;
             work[kkRow]=dValue;
@@ -2271 +3453 @@
           for (int i=0;i<length;i++) {
             int lRow = choleskyRow_[currentIndex++];
-            longDouble t0 = work[lRow];
+            CoinWorkDouble t0 = work[lRow];
             for (int kkRow=kRow;kkRow<last;kkRow++) {
               CoinBigIndex j = first[kkRow]+i;
@@ -2340 +3522 @@
         for (CoinBigIndex j=start;j<end;j++) {
           int jRow = choleskyRow_[j+offset];
-          longDouble value = sparseFactor_[j]-work[jRow];
+          CoinWorkDouble value = sparseFactor_[j]-work[jRow];
           work[jRow]=0.0;
           sparseFactor_[j]= diagonalValue*value;
@@ -2350 +3532 @@
     // do dense
     // update dense part
-    updateDense(d,work,first);
+    updateDense(d,/*work,*/first);
     ClpCholeskyDense dense;
     // just borrow space
@@ -2371 +3553 @@
     dense.setIntegerParameter(20,0);
     dense.setIntegerParameter(34,firstPositive);
+    dense.setModel(model_);
     dense.factorizePart2(dropped);
     largest=dense.getDoubleParameter(3);
@@ -2387 +3570 @@
 }
 // Updates dense part (broken out for profiling)
-void ClpCholeskyBase::updateDense(longDouble * d, longDouble * work, int * first)
+void ClpCholeskyBase::updateDense(longDouble * d, /*longDouble * work,*/ int * first)
 {
   for (int iRow=0;iRow<firstDense_;iRow++) {
@@ -2395 +3578 @@
       CoinBigIndex offset = indexStart_[iRow]-choleskyStart_[iRow];
       if (clique_[iRow]<2) {
-        longDouble dValue=d[iRow];
+        CoinWorkDouble dValue=d[iRow];
         for (CoinBigIndex k=start;k<end;k++) {
           int kRow = choleskyRow_[k+offset]; 
           assert(kRow>=firstDense_);
-          longDouble a_ik=sparseFactor_[k];
-          longDouble value1=dValue*a_ik;
+          CoinWorkDouble a_ik=sparseFactor_[k];
+          CoinWorkDouble value1=dValue*a_ik;
           diagonal_[kRow] -= value1*a_ik;
           CoinBigIndex base = choleskyStart_[kRow]-kRow-1;
           for (CoinBigIndex j=k+1;j<end;j++) {
             int jRow=choleskyRow_[j+offset];
-            longDouble a_jk = sparseFactor_[j];
+            CoinWorkDouble a_jk = sparseFactor_[j];
             sparseFactor_[base+jRow] -= a_jk*value1;
           }
@@ -2411 +3594 @@
       } else if (clique_[iRow]<3) {
         // do as pair
-        longDouble dValue0=d[iRow];
-        longDouble dValue1=d[iRow+1];
+        CoinWorkDouble dValue0=d[iRow];
+        CoinWorkDouble dValue1=d[iRow+1];
         int offset1 = first[iRow+1]-start;
         // skip row
@@ -2419 +3602 @@
           int kRow = choleskyRow_[k+offset]; 
           assert(kRow>=firstDense_);
-          longDouble a_ik0=sparseFactor_[k];
-          longDouble value0=dValue0*a_ik0;
-          longDouble a_ik1=sparseFactor_[k+offset1];
-          longDouble value1=dValue1*a_ik1;
+          CoinWorkDouble a_ik0=sparseFactor_[k];
+          CoinWorkDouble value0=dValue0*a_ik0;
+          CoinWorkDouble a_ik1=sparseFactor_[k+offset1];
+          CoinWorkDouble value1=dValue1*a_ik1;
           diagonal_[kRow] -= value0*a_ik0 + value1*a_ik1;
           CoinBigIndex base = choleskyStart_[kRow]-kRow-1;
           for (CoinBigIndex j=k+1;j<end;j++) {
             int jRow=choleskyRow_[j+offset];
-            longDouble a_jk0 = sparseFactor_[j];
-            longDouble a_jk1 = sparseFactor_[j+offset1];
+            CoinWorkDouble a_jk0 = sparseFactor_[j];
+            CoinWorkDouble a_jk1 = sparseFactor_[j+offset1];
             sparseFactor_[base+jRow] -= a_jk0*value0+a_jk1*value1;
           }
@@ -2441 +3624 @@
         // maybe later get fancy on big cliques and do transpose copy
         // seems only worth going to 3 on Intel
-        longDouble dValue0=d[iRow];
-        longDouble dValue1=d[iRow+1];
-        longDouble dValue2=d[iRow+2];
+        CoinWorkDouble dValue0=d[iRow];
+        CoinWorkDouble dValue1=d[iRow+1];
+        CoinWorkDouble dValue2=d[iRow+2];
         // get offsets and skip rows
         int offset1 = first[++iRow]-start;
@@ -2450 +3633 @@
           int kRow = choleskyRow_[k+offset]; 
           assert(kRow>=firstDense_);
-          double diagonalValue=diagonal_[kRow];
-          longDouble a_ik0=sparseFactor_[k];
-          longDouble value0=dValue0*a_ik0;
-          longDouble a_ik1=sparseFactor_[k+offset1];
-          longDouble value1=dValue1*a_ik1;
-          longDouble a_ik2=sparseFactor_[k+offset2];
-          longDouble value2=dValue2*a_ik2;
+          CoinWorkDouble diagonalValue=diagonal_[kRow];
+          CoinWorkDouble a_ik0=sparseFactor_[k];
+          CoinWorkDouble value0=dValue0*a_ik0;
+          CoinWorkDouble a_ik1=sparseFactor_[k+offset1];
+          CoinWorkDouble value1=dValue1*a_ik1;
+          CoinWorkDouble a_ik2=sparseFactor_[k+offset2];
+          CoinWorkDouble value2=dValue2*a_ik2;
           CoinBigIndex base = choleskyStart_[kRow]-kRow-1;
           diagonal_[kRow] = diagonalValue - value0*a_ik0 - value1*a_ik1 - value2*a_ik2;
           for (CoinBigIndex j=k+1;j<end;j++) {
             int jRow=choleskyRow_[j+offset];
-            longDouble a_jk0 = sparseFactor_[j];
-            longDouble a_jk1 = sparseFactor_[j+offset1];
-            longDouble a_jk2 = sparseFactor_[j+offset2];
+            CoinWorkDouble a_jk0 = sparseFactor_[j];
+            CoinWorkDouble a_jk1 = sparseFactor_[j+offset1];
+            CoinWorkDouble a_jk2 = sparseFactor_[j+offset2];
             sparseFactor_[base+jRow] -= a_jk0*value0+a_jk1*value1+a_jk2*value2;
           }
@@ -2472 +3655 @@
         // maybe later get fancy on big cliques and do transpose copy
         // maybe only worth going to 3 on Intel (but may have hidden registers)
-        longDouble dValue0=d[iRow];
-        longDouble dValue1=d[iRow+1];
-        longDouble dValue2=d[iRow+2];
-        longDouble dValue3=d[iRow+3];
+        CoinWorkDouble dValue0=d[iRow];
+        CoinWorkDouble dValue1=d[iRow+1];
+        CoinWorkDouble dValue2=d[iRow+2];
+        CoinWorkDouble dValue3=d[iRow+3];
         // get offsets and skip rows
         int offset1 = first[++iRow]-start;
@@ -2483 +3666 @@
           int kRow = choleskyRow_[k+offset]; 
           assert(kRow>=firstDense_);
-          double diagonalValue=diagonal_[kRow];
-          longDouble a_ik0=sparseFactor_[k];
-          longDouble value0=dValue0*a_ik0;
-          longDouble a_ik1=sparseFactor_[k+offset1];
-          longDouble value1=dValue1*a_ik1;
-          longDouble a_ik2=sparseFactor_[k+offset2];
-          longDouble value2=dValue2*a_ik2;
-          longDouble a_ik3=sparseFactor_[k+offset3];
-          longDouble value3=dValue3*a_ik3;
+          CoinWorkDouble diagonalValue=diagonal_[kRow];
+          CoinWorkDouble a_ik0=sparseFactor_[k];
+          CoinWorkDouble value0=dValue0*a_ik0;
+          CoinWorkDouble a_ik1=sparseFactor_[k+offset1];
+          CoinWorkDouble value1=dValue1*a_ik1;
+          CoinWorkDouble a_ik2=sparseFactor_[k+offset2];
+          CoinWorkDouble value2=dValue2*a_ik2;
+          CoinWorkDouble a_ik3=sparseFactor_[k+offset3];
+          CoinWorkDouble value3=dValue3*a_ik3;
           CoinBigIndex base = choleskyStart_[kRow]-kRow-1;
           diagonal_[kRow] = diagonalValue - (value0*a_ik0 + value1*a_ik1 + value2*a_ik2+value3*a_ik3);
           for (CoinBigIndex j=k+1;j<end;j++) {
             int jRow=choleskyRow_[j+offset];
-            longDouble a_jk0 = sparseFactor_[j];
-            longDouble a_jk1 = sparseFactor_[j+offset1];
-            longDouble a_jk2 = sparseFactor_[j+offset2];
-            longDouble a_jk3 = sparseFactor_[j+offset3];
+            CoinWorkDouble a_jk0 = sparseFactor_[j];
+            CoinWorkDouble a_jk1 = sparseFactor_[j+offset1];
+            CoinWorkDouble a_jk2 = sparseFactor_[j+offset2];
+            CoinWorkDouble a_jk3 = sparseFactor_[j+offset3];
             sparseFactor_[base+jRow] -= a_jk0*value0+a_jk1*value1+a_jk2*value2+a_jk3*value3;
           }
@@ -2510 +3693 @@
 /* Uses factorization to solve. */
 void 
-ClpCholeskyBase::solve (double * region) 
+ClpCholeskyBase::solve (CoinWorkDouble * region) 
 {
   if (!whichDense_) {
@@ -2520 +3703 @@
     // do change;
     int numberDense = dense_->numberRows();
-    double * change = new double[numberDense];
+    CoinWorkDouble * change = new CoinWorkDouble[numberDense];
     for (i=0;i<numberDense;i++) {
       const longDouble * a = denseColumn_+i*numberRows_;
-      longDouble value =0.0;
+      CoinWorkDouble value =0.0;
       for (int iRow=0;iRow<numberRows_;iRow++) 
         value += a[iRow]*region[iRow];
@@ -2532 +3715 @@
     for (i=0;i<numberDense;i++) {
       const longDouble * a = denseColumn_+i*numberRows_;
-      longDouble value = change[i];
+      CoinWorkDouble value = change[i];
       for (int iRow=0;iRow<numberRows_;iRow++) 
         region[iRow] -= value*a[iRow];
@@ -2545 +3728 @@
 */
 void 
-ClpCholeskyBase::solve(double * region, int type)
+ClpCholeskyBase::solve(CoinWorkDouble * region, int type)
 {
 #ifdef CLP_DEBUG
   double * regionX=NULL;
-  if (sizeof(longWork)!=sizeof(double)&&type==3) {
+  if (sizeof(CoinWorkDouble)!=sizeof(double)&&type==3) {
     regionX=ClpCopyOfArray(region,numberRows_);
   }
 #endif
-  longWork * work = reinterpret_cast<longWork *> (workDouble_);
+  CoinWorkDouble * work = reinterpret_cast<CoinWorkDouble *> (workDouble_);
   int i;
   CoinBigIndex j;
@@ -2563 +3746 @@
   case 1:
     for (i=0;i<numberRows_;i++) {
-      longDouble value=work[i];
+      CoinWorkDouble value=work[i];
       CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
       for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
@@ -2578 +3761 @@
     for (i=numberRows_-1;i>=0;i--) {
       CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      longDouble value=work[i]*diagonal_[i];
+      CoinWorkDouble value=work[i]*diagonal_[i];
       for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
         int iRow = choleskyRow_[j+offset];
@@ -2591 +3774 @@
     for (i=0;i<firstDense_;i++) {
       CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      longDouble value=work[i];
+      CoinWorkDouble value=work[i];
       for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
         int iRow = choleskyRow_[j+offset];
@@ -2603 +3786 @@
       int nDense = numberRows_-firstDense_;
       dense.reserveSpace(this,nDense);
-#if CLP_LONG_CHOLESKY!=1
-      dense.solveLong(work+firstDense_);
-#else
-      dense.solveLongWork(work+firstDense_);
-#endif
+      dense.solve(work+firstDense_);
       for (i=numberRows_-1;i>=firstDense_;i--) {
-        longDouble value=work[i];
+        CoinWorkDouble value=work[i];
         int iRow = permute_[i];
         region[iRow]=value;
@@ -2616 +3795 @@
     for (i=firstDense_-1;i>=0;i--) {
       CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      longDouble value=work[i]*diagonal_[i];
+      CoinWorkDouble value=work[i]*diagonal_[i];
       for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
         int iRow = choleskyRow_[j+offset];
@@ -2634 +3813 @@
     double largestO=0.0;
     for (i=0;i<numberRows_;i++) {
-      largestO = CoinMax(largestO,fabs(regionX[i]));
+      largestO = CoinMax(largestO,CoinAbs(regionX[i]));
     }
     for (i=0;i<numberRows_;i++) {
@@ -2642 +3821 @@
     for (i=0;i<firstDense_;i++) {
       CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      longDouble value=work[i];
+      CoinWorkDouble value=work[i];
       for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
         int iRow = choleskyRow_[j+offset];
@@ -2654 +3833 @@
       int nDense = numberRows_-firstDense_;
       dense.reserveSpace(this,nDense);
-      dense.solveLong(work+firstDense_);
+      dense.solve(work+firstDense_);
       for (i=numberRows_-1;i>=firstDense_;i--) {
-        longDouble value=work[i];
+        CoinWorkDouble value=work[i];
         int iRow = permute_[i];
         regionX[iRow]=value;
@@ -2663 +3842 @@
     for (i=firstDense_-1;i>=0;i--) {
       CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      longDouble value=work[i]*diagonal_[i];
+      CoinWorkDouble value=work[i]*diagonal_[i];
       for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
         int iRow = choleskyRow_[j+offset];
@@ -2675 +3854 @@
     double largestV=0.0;
     for (i=0;i<numberRows_;i++) {
-      largest = CoinMax(largest,fabs(region[i]-regionX[i]));
-      largestV = CoinMax(largestV,fabs(region[i]));
+      largest = CoinMax(largest,CoinAbs(region[i]-regionX[i]));
+      largestV = CoinMax(largestV,CoinAbs(region[i]));
     }
     printf("largest difference %g, largest %g, largest original %g\n",
@@ -2684 +3863 @@
 #endif
 }
-/* solve - 1 just first half, 2 just second half - 3 both.
-   If 1 and 2 then diagonal has sqrt of inverse otherwise inverse
-*/
+#if 0 //CLP_LONG_CHOLESKY
+/* Uses factorization to solve. */
 void 
-ClpCholeskyBase::solveLong(longDouble * region, int type)
+ClpCholeskyBase::solve (CoinWorkDouble * region) 
 {
+  assert (!whichDense_) ;
+  CoinWorkDouble * work = reinterpret_cast<CoinWorkDouble *> (workDouble_);
   int i;
   CoinBigIndex j;
   for (i=0;i<numberRows_;i++) {
     int iRow = permute_[i];
-    workDouble_[i] = region[iRow];
-  }
-  switch (type) {
-  case 1:
-    for (i=0;i<numberRows_;i++) {
-      longDouble value=workDouble_[i];
-      CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
-        int iRow = choleskyRow_[j+offset];
-        workDouble_[iRow] -= sparseFactor_[j]*value;
-      }
-    }
-    for (i=0;i<numberRows_;i++) {
-      int iRow = permute_[i];
-      region[iRow]=workDouble_[i]*diagonal_[i];
-    }
-    break;
-  case 2:
-    for (i=numberRows_-1;i>=0;i--) {
-      CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      longDouble value=workDouble_[i]*diagonal_[i];
-      for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
-        int iRow = choleskyRow_[j+offset];
-        value -= sparseFactor_[j]*workDouble_[iRow];
-      }
-      workDouble_[i]=value;
+    work[i] = region[iRow];
+  }
+  for (i=0;i<firstDense_;i++) {
+    CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
+    CoinWorkDouble value=work[i];
+    for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
+      int iRow = choleskyRow_[j+offset];
+      work[iRow] -= sparseFactor_[j]*value;
+    }
+  }
+  if (firstDense_<numberRows_) {
+    // do dense
+    ClpCholeskyDense dense;
+    // just borrow space
+    int nDense = numberRows_-firstDense_;
+    dense.reserveSpace(this,nDense);
+    dense.solve(work+firstDense_);
+    for (i=numberRows_-1;i>=firstDense_;i--) {
+      CoinWorkDouble value=work[i];
       int iRow = permute_[i];
       region[iRow]=value;
     }
-    break;
-  case 3:
-    for (i=0;i<firstDense_;i++) {
-      CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      longDouble value=workDouble_[i];
-      for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
-        int iRow = choleskyRow_[j+offset];
-        workDouble_[iRow] -= sparseFactor_[j]*value;
-      }
-    }
-    if (firstDense_<numberRows_) {
-      // do dense
-      ClpCholeskyDense dense;
-      // just borrow space
-      int nDense = numberRows_-firstDense_;
-      dense.reserveSpace(this,nDense);
-      dense.solveLong(workDouble_+firstDense_);
-      for (i=numberRows_-1;i>=firstDense_;i--) {
-        longDouble value=workDouble_[i];
-        int iRow = permute_[i];
-        region[iRow]=value;
-      }
-    }
-    for (i=firstDense_-1;i>=0;i--) {
-      CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
-      longDouble value=workDouble_[i]*diagonal_[i];
-      for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
-        int iRow = choleskyRow_[j+offset];
-        value -= sparseFactor_[j]*workDouble_[iRow];
-      }
-      workDouble_[i]=value;
-      int iRow = permute_[i];
-      region[iRow]=value;
-    }
-    break;
+  }
+  for (i=firstDense_-1;i>=0;i--) {
+    CoinBigIndex offset = indexStart_[i]-choleskyStart_[i];
+    CoinWorkDouble value=work[i]*diagonal_[i];
+    for (j=choleskyStart_[i];j<choleskyStart_[i+1];j++) {
+      int iRow = choleskyRow_[j+offset];
+      value -= sparseFactor_[j]*work[iRow];
+    }
+    work[i]=value;
+    int iRow = permute_[i];
+    region[iRow]=value;
   }
 }
-
+#endif

stable/1.11/Clp/src/ClpCholeskyBase.hpp

@@ +1 @@
+/* $Id$ */
 // Copyright (C) 2003, International Business Machines
 // Corporation and others.  All Rights Reserved.
@@ -6 +7 @@
 #include "CoinPragma.hpp"
 #include "CoinFinite.hpp"
+//#define CLP_LONG_CHOLESKY 0
+#ifndef CLP_LONG_CHOLESKY 
 #define CLP_LONG_CHOLESKY 0
+#endif
+/* valid combinations are 
+   CLP_LONG_CHOLESKY 0 and COIN_LONG_WORK 0
+   CLP_LONG_CHOLESKY 1 and COIN_LONG_WORK 1
+   CLP_LONG_CHOLESKY 2 and COIN_LONG_WORK 1
+*/
+#if COIN_LONG_WORK==0
+#if CLP_LONG_CHOLESKY>0
+#define CHOLESKY_BAD_COMBINATION
+#endif
+#else
+#if CLP_LONG_CHOLESKY==0
+#define CHOLESKY_BAD_COMBINATION
+#endif
+#endif
+#ifdef CHOLESKY_BAD_COMBINATION
+#  warning("Bad combination of CLP_LONG_CHOLESKY and COIN_BIG_DOUBLE/COIN_LONG_WORK");
+"Bad combination of CLP_LONG_CHOLESKY and COIN_LONG_WORK"
+#endif
 #if CLP_LONG_CHOLESKY>1
 typedef long double longDouble;
-typedef long double longWork;
+#define CHOL_SMALL_VALUE 1.0e-15 
 #elif CLP_LONG_CHOLESKY==1
 typedef double longDouble;
-typedef long double longWork;
+#define CHOL_SMALL_VALUE 1.0e-11
 #else
 typedef double longDouble;
-typedef double longWork;
+#define CHOL_SMALL_VALUE 1.0e-11
 #endif
 class ClpInterior;
@@ -46 +68 @@
   /** Factorize - filling in rowsDropped and returning number dropped.
       If return code negative then out of memory */
-  virtual int factorize(const double * diagonal, int * rowsDropped) ;
+  virtual int factorize(const CoinWorkDouble * diagonal, int * rowsDropped) ;
   /** Uses factorization to solve. */
-  virtual void solve (double * region) ;
+  virtual void solve (CoinWorkDouble * region) ;
   /** Uses factorization to solve. - given as if KKT.
    region1 is rows+columns, region2 is rows */
-  virtual void solveKKT (double * region1, double * region2, const double * diagonal,
-                         double diagonalScaleFactor);
+  virtual void solveKKT (CoinWorkDouble * region1, CoinWorkDouble * region2, const CoinWorkDouble * diagonal,
+                         CoinWorkDouble diagonalScaleFactor);
+private:
+  /// AMD ordering
+  int orderAMD();
+public:
   //@}
 
@@ -141 +167 @@
 protected:
   /// Sets type
-  void setType(int type) {type_=type;}
+  inline void setType(int type) {type_=type;}
+  /// model.
+  inline void setModel(ClpInterior * model)
+  { model_=model;}
    //@}
    
@@ -162 +191 @@
   If 1 and 2 then diagonal has sqrt of inverse otherwise inverse
   */
-  void solve(double * region, int type);
-  void solveLong(longDouble * region, int type);
+  void solve(CoinWorkDouble * region, int type);
   /// Forms ADAT - returns nonzero if not enough memory
   int preOrder(bool lowerTriangular, bool includeDiagonal, bool doKKT);
   /// Updates dense part (broken out for profiling)
-  void updateDense(longDouble * d, longDouble * work, int * first);
+  void updateDense(longDouble * d, /*longDouble * work,*/ int * first);
   //@}
     

stable/1.11/Clp/src/ClpCholeskyDense.cpp

@@ -1 @@
-// Copyright (C) 2003, International Business Machines
-// Corporation and others.  All Rights Reserved.
-
-
-
+/* $Id$ */
+/* Copyright (C) 2003, International Business Machines Corporation 
+   and others.  All Rights Reserved. */
 #include "CoinPragma.hpp"
 #include "CoinHelperFunctions.hpp"
+#include "ClpHelperFunctions.hpp"
 
 #include "ClpInterior.hpp"
@@ -12 +11 @@
 #include "ClpQuadraticObjective.hpp"
 
-//#############################################################################
-// Constructors / Destructor / Assignment
-//#############################################################################
-
-//-------------------------------------------------------------------
-// Default Constructor 
-//-------------------------------------------------------------------
+/*#############################################################################*/
+/* Constructors / Destructor / Assignment*/
+/*#############################################################################*/
+
+/*-------------------------------------------------------------------*/
+/* Default Constructor */
+/*-------------------------------------------------------------------*/
 ClpCholeskyDense::ClpCholeskyDense () 
   : ClpCholeskyBase(),
@@ -26 +25 @@
 }
 
-//-------------------------------------------------------------------
-// Copy constructor 
-//-------------------------------------------------------------------
+/*-------------------------------------------------------------------*/
+/* Copy constructor */
+/*-------------------------------------------------------------------*/
 ClpCholeskyDense::ClpCholeskyDense (const ClpCholeskyDense & rhs) 
   : ClpCholeskyBase(rhs),
     borrowSpace_(rhs.borrowSpace_)
 {
-  assert(!rhs.borrowSpace_||!rhs.sizeFactor_); // can't do if borrowing space
-}
-
-
-//-------------------------------------------------------------------
-// Destructor 
-//-------------------------------------------------------------------
+  assert(!rhs.borrowSpace_||!rhs.sizeFactor_); /* can't do if borrowing space*/
+}
+
+
+/*-------------------------------------------------------------------*/
+/* Destructor */
+/*-------------------------------------------------------------------*/
 ClpCholeskyDense::~ClpCholeskyDense ()
 {
   if (borrowSpace_) {
-    // set NULL
+    /* set NULL*/
     sparseFactor_=NULL;
     workDouble_=NULL;
@@ -50 +49 @@
 }
 
-//----------------------------------------------------------------
-// Assignment operator 
-//-------------------------------------------------------------------
+/*----------------------------------------------------------------*/
+/* Assignment operator */
+/*-------------------------------------------------------------------*/
 ClpCholeskyDense &
 ClpCholeskyDense::operator=(const ClpCholeskyDense& rhs)
 {
   if (this != &rhs) {
-    assert(!rhs.borrowSpace_||!rhs.sizeFactor_); // can't do if borrowing space
+    assert(!rhs.borrowSpace_||!rhs.sizeFactor_); /* can't do if borrowing space*/
     ClpCholeskyBase::operator=(rhs);
     borrowSpace_=rhs.borrowSpace_;
@@ -63 +62 @@
   return *this;
 }
-//-------------------------------------------------------------------
-// Clone
-//-------------------------------------------------------------------
+/*-------------------------------------------------------------------*/
+/* Clone*/
+/*-------------------------------------------------------------------*/
 ClpCholeskyBase * ClpCholeskyDense::clone() const
 {
   return new ClpCholeskyDense(*this);
 }
-// If not power of 2 then need to redo a bit
+/* If not power of 2 then need to redo a bit*/
 #define BLOCK 16
 #define BLOCKSHIFT 4
-// Block unroll if power of 2 and at least 8
+/* Block unroll if power of 2 and at least 8*/
 #define BLOCKUNROLL
 
@@ -87 +86 @@
   numberRows_ = numberRows;
   int numberBlocks = (numberRows_+BLOCK-1)>>BLOCKSHIFT;
-  // allow one stripe extra
+  /* allow one stripe extra*/
   numberBlocks = numberBlocks + ((numberBlocks*(numberBlocks+1))/2);
   sizeFactor_=numberBlocks*BLOCKSQ;
-  //#define CHOL_COMPARE
+  /*#define CHOL_COMPARE*/
 #ifdef CHOL_COMPARE  
   sizeFactor_ += 95000;
@@ -115 +114 @@
 {
  int numberBlocks = (numberRows+BLOCK-1)>>BLOCKSHIFT;
-  // allow one stripe extra
+ /* allow one stripe extra*/
   numberBlocks = numberBlocks + ((numberBlocks*(numberBlocks+1))/2);
   CoinBigIndex sizeFactor=numberBlocks*BLOCKSQ;
@@ -151 +150 @@
 /* Factorize - filling in rowsDropped and returning number dropped */
 int 
-ClpCholeskyDense::factorize(const double * diagonal, int * rowsDropped) 
+ClpCholeskyDense::factorize(const CoinWorkDouble * diagonal, int * rowsDropped) 
 {
   assert (!borrowSpace_);
@@ -164 +163 @@
   int numberColumns=model_->clpMatrix()->getNumCols();
   CoinZeroN(sparseFactor_,sizeFactor_);
-  //perturbation
-  longDouble perturbation=model_->diagonalPerturbation()*model_->diagonalNorm();
+  /*perturbation*/
+  CoinWorkDouble perturbation=model_->diagonalPerturbation()*model_->diagonalNorm();
   perturbation=perturbation*perturbation;
   if (perturbation>1.0) {
 #ifdef COIN_DEVELOP
-    //if (model_->model()->logLevel()&4) 
+    /*if (model_->model()->logLevel()&4) */
       std::cout <<"large perturbation "<<perturbation<<std::endl;
 #endif
-    perturbation=sqrt(perturbation);;
+    perturbation=CoinSqrt(perturbation);;
     perturbation=1.0;
   }
   int iRow;
   int newDropped=0;
-  double largest=1.0;
-  double smallest=COIN_DBL_MAX;
-  longDouble delta2 = model_->delta(); // add delta*delta to diagonal
+  CoinWorkDouble largest=1.0;
+  CoinWorkDouble smallest=COIN_DBL_MAX;
+  CoinWorkDouble delta2 = model_->delta(); /* add delta*delta to diagonal*/
   delta2 *= delta2;
   if (!doKKT_) {
     longDouble * work = sparseFactor_;
-    work--; // skip diagonal
+    work--; /* skip diagonal*/
     int addOffset=numberRows_-1;
-    const double * diagonalSlack = diagonal + numberColumns;
-    // largest in initial matrix
-    double largest2=1.0e-20;
+    const CoinWorkDouble * diagonalSlack = diagonal + numberColumns;
+    /* largest in initial matrix*/
+    CoinWorkDouble largest2=1.0e-20;
     for (iRow=0;iRow<numberRows_;iRow++) {
       if (!rowsDropped_[iRow]) {
         CoinBigIndex startRow=rowStart[iRow];
         CoinBigIndex endRow=rowStart[iRow]+rowLength[iRow];
-        longDouble diagonalValue = diagonalSlack[iRow]+delta2;
+        CoinWorkDouble diagonalValue = diagonalSlack[iRow]+delta2;
         for (CoinBigIndex k=startRow;k<endRow;k++) {
           int iColumn=column[k];
           CoinBigIndex start=columnStart[iColumn];
           CoinBigIndex end=columnStart[iColumn]+columnLength[iColumn];
-          longDouble multiplier = diagonal[iColumn]*elementByRow[k];
+          CoinWorkDouble multiplier = diagonal[iColumn]*elementByRow[k];
           for (CoinBigIndex j=start;j<end;j++) {
             int jRow=row[j];
             if (!rowsDropped_[jRow]) {
               if (jRow>iRow) {
-                longDouble value=element[j]*multiplier;
+                CoinWorkDouble value=element[j]*multiplier;
                 work[jRow] += value;
               } else if (jRow==iRow) {
-                longDouble value=element[j]*multiplier;
+                CoinWorkDouble value=element[j]*multiplier;
                 diagonalValue += value;
               }
@@ -212 +211 @@
         } 
         for (int j=iRow+1;j<numberRows_;j++) 
-          largest2 = CoinMax(largest2,fabs(work[j]));
+          largest2 = CoinMax(largest2,CoinAbs(work[j]));
         diagonal_[iRow]=diagonalValue;
-        largest2 = CoinMax(largest2,fabs(diagonalValue));
+        largest2 = CoinMax(largest2,CoinAbs(diagonalValue));
       } else {
-        // dropped
+        /* dropped*/
         diagonal_[iRow]=1.0;
       }
@@ -222 +221 @@
       work += addOffset;
     }
-    //check sizes
+    /*check sizes*/
     largest2*=1.0e-20;
-    largest = CoinMin(largest2,1.0e-11);
+    largest = CoinMin(largest2,CHOL_SMALL_VALUE);
     int numberDroppedBefore=0;
     for (iRow=0;iRow<numberRows_;iRow++) {
       int dropped=rowsDropped_[iRow];
-      // Move to int array
+      /* Move to int array*/
       rowsDropped[iRow]=dropped;
       if (!dropped) {
-        longDouble diagonal = diagonal_[iRow];
+        CoinWorkDouble diagonal = diagonal_[iRow];
         if (diagonal>largest2) {
           diagonal_[iRow]=diagonal+perturbation;
@@ -245 +244 @@
     doubleParameters_[3]=0.0;
     doubleParameters_[4]=COIN_DBL_MAX;
-    integerParameters_[34]=0; // say all must be positive
+    integerParameters_[34]=0; /* say all must be positive*/
 #ifdef CHOL_COMPARE  
     if (numberRows_<200)
@@ -257 +256 @@
       std::cout<<"Cholesky - largest "<<largest<<" smallest "<<smallest<<std::endl;
     choleskyCondition_=largest/smallest;
-    //drop fresh makes some formADAT easier
+    /*drop fresh makes some formADAT easier*/
     if (newDropped||numberRowsDropped_) {
       newDropped=0;
@@ -264 +263 @@
         rowsDropped_[i]=dropped;
         if (dropped==2) {
-          //dropped this time
+          /*dropped this time*/
           rowsDropped[newDropped++]=i;
           rowsDropped_[i]=0;
@@ -273 +272 @@
     } 
   } else {
-    // KKT
+    /* KKT*/
     CoinPackedMatrix * quadratic = NULL;
     ClpQuadraticObjective * quadraticObj = 
@@ -279 +278 @@
     if (quadraticObj) 
       quadratic = quadraticObj->quadraticObjective();
-    // matrix
+    /* matrix*/
     int numberRowsModel = model_->numberRows();
     int numberColumns = model_->numberColumns();
     int numberTotal = numberColumns + numberRowsModel;
     longDouble * work = sparseFactor_;
-    work--; // skip diagonal
+    work--; /* skip diagonal*/
     int addOffset=numberRows_-1;
     int iColumn;
     if (!quadratic) {
       for (iColumn=0;iColumn<numberColumns;iColumn++) {
-        longDouble value = diagonal[iColumn];
-        if (fabs(value)>1.0e-100) {
+        CoinWorkDouble value = diagonal[iColumn];
+        if (CoinAbs(value)>1.0e-100) {
           value = 1.0/value;
-          largest = CoinMax(largest,fabs(value));
+          largest = CoinMax(largest,CoinAbs(value));
           diagonal_[iColumn] = -value;
           CoinBigIndex start=columnStart[iColumn];
           CoinBigIndex end=columnStart[iColumn]+columnLength[iColumn];
           for (CoinBigIndex j=start;j<end;j++) {
-            //choleskyRow_[numberElements]=row[j]+numberTotal;
-            //sparseFactor_[numberElements++]=element[j];
+            /*choleskyRow_[numberElements]=row[j]+numberTotal;*/
+            /*sparseFactor_[numberElements++]=element[j];*/
             work[row[j]+numberTotal]=element[j];
-            largest = CoinMax(largest,fabs(element[j]));
+            largest = CoinMax(largest,CoinAbs(element[j]));
           }
         } else {
@@ -309 +308 @@
       }
     } else {
-      // Quadratic
+      /* Quadratic*/
       const int * columnQuadratic = quadratic->getIndices();
       const CoinBigIndex * columnQuadraticStart = quadratic->getVectorStarts();
@@ -315 +314 @@
       const double * quadraticElement = quadratic->getElements();
       for (iColumn=0;iColumn<numberColumns;iColumn++) {
-        longDouble value = diagonal[iColumn];
+        CoinWorkDouble value = diagonal[iColumn];
         CoinBigIndex j;
-        if (fabs(value)>1.0e-100) {
+        if (CoinAbs(value)>1.0e-100) {
           value = 1.0/value;
           for (j=columnQuadraticStart[iColumn];
@@ -328 +327 @@
             }
           }
-          largest = CoinMax(largest,fabs(value));
+          largest = CoinMax(largest,CoinAbs(value));
           diagonal_[iColumn] = -value;
           CoinBigIndex start=columnStart[iColumn];
@@ -334 +333 @@
           for (j=start;j<end;j++) {
             work[row[j]+numberTotal]=element[j];
-            largest = CoinMax(largest,fabs(element[j]));
+            largest = CoinMax(largest,CoinAbs(element[j]));
           }
         } else {
@@ -344 +343 @@
       }
     }
-    // slacks
+    /* slacks*/
     for (iColumn=numberColumns;iColumn<numberTotal;iColumn++) {
-      longDouble value = diagonal[iColumn];
-      if (fabs(value)>1.0e-100) {
+      CoinWorkDouble value = diagonal[iColumn];
+      if (CoinAbs(value)>1.0e-100) {
         value = 1.0/value;
-        largest = CoinMax(largest,fabs(value));
+        largest = CoinMax(largest,CoinAbs(value));
       } else {
         value = 1.0e100;
@@ -358 +357 @@
       work += addOffset;
     }
-    // Finish diagonal
+    /* Finish diagonal*/
     for (iRow=0;iRow<numberRowsModel;iRow++) {
       diagonal_[iRow+numberTotal]=delta2;
     }
-    //check sizes
+    /*check sizes*/
     largest*=1.0e-20;
-    largest = CoinMin(largest,1.0e-11);
+    largest = CoinMin(largest,CHOL_SMALL_VALUE);
     doubleParameters_[10]=CoinMax(1.0e-20,largest);
     integerParameters_[20]=0;
     doubleParameters_[3]=0.0;
     doubleParameters_[4]=COIN_DBL_MAX;
-    // Set up LDL cutoff
+    /* Set up LDL cutoff*/
     integerParameters_[34]=numberTotal;
-    // KKT
+    /* KKT*/
     int * rowsDropped2 = new int[numberRows_];
     CoinZeroN(rowsDropped2,numberRows_);
@@ -385 +384 @@
       std::cout<<"Cholesky - largest "<<largest<<" smallest "<<smallest<<std::endl;
     choleskyCondition_=largest/smallest;
-    // Should save adjustments in ..R_
+    /* Should save adjustments in ..R_*/
     int n1=0,n2=0;
-    double * primalR = model_->primalR();
-    double * dualR = model_->dualR();
+    CoinWorkDouble * primalR = model_->primalR();
+    CoinWorkDouble * dualR = model_->dualR();
     for (iRow=0;iRow<numberTotal;iRow++) { 
       if (rowsDropped2[iRow]) {
         n1++;
-        //printf("row region1 %d dropped\n",iRow);
-        //rowsDropped_[iRow]=1;
+        /*printf("row region1 %d dropped\n",iRow);*/
+        /*rowsDropped_[iRow]=1;*/
         rowsDropped_[iRow]=0;
         primalR[iRow]=doubleParameters_[20];
@@ -404 +403 @@
       if (rowsDropped2[iRow]) {
         n2++;
-        //printf("row region2 %d dropped\n",iRow);
-        //rowsDropped_[iRow]=1;
+        /*printf("row region2 %d dropped\n",iRow);*/
+        /*rowsDropped_[iRow]=1;*/
         rowsDropped_[iRow]=0;
         dualR[iRow-numberTotal]=doubleParameters_[34];
@@ -425 +424 @@
   diagonal_ = sparseFactor_ + 40000;
   sparseFactor_=diagonal_ + numberRows_;
-  //memcpy(sparseFactor_,xx,sizeFactor_*sizeof(double));
+  /*memcpy(sparseFactor_,xx,sizeFactor_*sizeof(double));*/
   CoinMemcpyN(xx,40000,sparseFactor_);
   CoinMemcpyN(yy,numberRows_,diagonal_);
   int numberDropped=0;
-  double largest=0.0;
-  double smallest=COIN_DBL_MAX;
+  CoinWorkDouble largest=0.0;
+  CoinWorkDouble smallest=COIN_DBL_MAX;
   double dropValue = doubleParameters_[10];
   int firstPositive=integerParameters_[34];
   longDouble * work = sparseFactor_;
-  // Allow for triangular
+  /* Allow for triangular*/
   int addOffset=numberRows_-1;
   work--;
@@ -441 +440 @@
     int addOffsetNow = numberRows_-1;;
     longDouble * workNow=sparseFactor_-1+iColumn;
-    double diagonalValue = diagonal_[iColumn];
+    CoinWorkDouble diagonalValue = diagonal_[iColumn];
     for (iRow=0;iRow<iColumn;iRow++) {
       double aj = *workNow;
       addOffsetNow--;
       workNow += addOffsetNow;
-      double multiplier = workDouble_[iRow];
-      diagonalValue -= aj*aj*multiplier;
+      diagonalValue -= aj*aj*workDouble_[iRow];
     }
     bool dropColumn=false;
     if (iColumn<firstPositive) {
-      // must be negative
+      /* must be negative*/
       if (diagonalValue<=-dropValue) {
         smallest = CoinMin(smallest,-diagonalValue);
@@ -464 +462 @@
       }
     } else {
-      // must be positive
+      /* must be positive*/
       if (diagonalValue>=dropValue) {
         smallest = CoinMin(smallest,diagonalValue);
@@ -494 +492 @@
       }
     } else {
-      // drop column
+      /* drop column*/
       rowsDropped[iColumn]=2;
       numberDropped++;
@@ -511 +509 @@
   diagonal_=yy;
 }
-//#define POS_DEBUG
+/*#define POS_DEBUG*/
 #ifdef POS_DEBUG
 static int counter=0;
@@ -522 +520 @@
   iCol=0;
   int kk=k>>BLOCKSQSHIFT;
-  //printf("%d %d %d %d\n",k,kk,BLOCKSQ,BLOCKSQSHIFT);
+  /*printf("%d %d %d %d\n",k,kk,BLOCKSQ,BLOCKSQSHIFT);*/
   k=kk;
   while (k>=numberBlocks) {
@@ -541 +539 @@
 {
   int iColumn;
-  //longDouble * xx = sparseFactor_;
-  //longDouble * yy = diagonal_;
-  //diagonal_ = sparseFactor_ + 40000;
-  //sparseFactor_=diagonal_ + numberRows_;
-  //memcpy(sparseFactor_,xx,sizeFactor_*sizeof(double));
-  //memcpy(sparseFactor_,xx,40000*sizeof(double));
-  //memcpy(diagonal_,yy,numberRows_*sizeof(double));
+  /*longDouble * xx = sparseFactor_;*/
+  /*longDouble * yy = diagonal_;*/
+  /*diagonal_ = sparseFactor_ + 40000;*/
+  /*sparseFactor_=diagonal_ + numberRows_;*/
+  /*memcpy(sparseFactor_,xx,sizeFactor_*sizeof(double));*/
+  /*memcpy(sparseFactor_,xx,40000*sizeof(double));*/
+  /*memcpy(diagonal_,yy,numberRows_*sizeof(double));*/
   int numberBlocks = (numberRows_+BLOCK-1)>>BLOCKSHIFT;
-  // later align on boundary
+  /* later align on boundary*/
   longDouble * a = sparseFactor_+BLOCKSQ*numberBlocks;
   int n=numberRows_;
   int nRound = numberRows_&(~(BLOCK-1));
-  // adjust if exact
+  /* adjust if exact*/
   if (nRound==n)
     nRound -= BLOCK;
   int sizeLastBlock=n-nRound;
-  int get = n*(n-1)/2; // ? as no diagonal
+  int get = n*(n-1)/2; /* ? as no diagonal*/
   int block = numberBlocks*(numberBlocks+1)/2;
   int ifOdd;
@@ -566 +564 @@
     ifOdd=1;
     int put = BLOCKSQ;
-    // do last separately
+    /* do last separately*/
     put -= (BLOCK-sizeLastBlock)*(BLOCK+1);
     for (iColumn=numberRows_-1;iColumn>=nRound;iColumn--) {
@@ -575 +573 @@
         assert (aa+put2>=sparseFactor_+get);
       }
-      // save diagonal as well
+      /* save diagonal as well*/
       aa[--put2]=diagonal_[iColumn];
     }
@@ -581 +579 @@
     block--;
   } else {
-    // exact fit
+    /* exact fit*/
     rowLast=numberRows_-1;
     ifOdd=0;
   }
-  // Now main loop
+  /* Now main loop*/
   int nBlock=0;
   for (;n>0;n-=BLOCK) {
@@ -592 +590 @@
     int put = BLOCKSQ;
     int putLast=0;
-    // see if we have small block
+    /* see if we have small block*/
     if (ifOdd) {
       aaLast = &a[(block-1)*BLOCKSQ];
@@ -600 +598 @@
     for (iColumn=n-1;iColumn>=n-BLOCK;iColumn--) {
       if (aaLast) {
-        // last bit
+        /* last bit*/
         for (int iRow=numberRows_-1;iRow>rowLast;iRow--) {
           aaLast[--putLast] = sparseFactor_[--get];
@@ -617 +615 @@
         }
         if (j-BLOCK<iColumn) {
-          // save diagonal as well
+          /* save diagonal as well*/
           aPut[--put2]=diagonal_[iColumn];
         }
@@ -628 +626 @@
     block -= nBlock+ifOdd;
   }
-  factor(a,numberRows_,numberBlocks,
+  ClpCholeskyDenseC  info;
+  info.diagonal_=diagonal_;
+  info.doubleParameters_[0]=doubleParameters_[10];
+  info.integerParameters_[0]=integerParameters_[34];
+#ifndef CLP_CILK
+  ClpCholeskyCfactor(&info,a,numberRows_,numberBlocks,
          diagonal_,workDouble_,rowsDropped);
-  //sparseFactor_=xx;
-  //diagonal_=yy;
-}
-// Non leaf recursive factor
-void 
-ClpCholeskyDense::factor(longDouble * a, int n, int numberBlocks,
+#else
+  info.a=a;
+  info.n=numberRows_;
+  info.numberBlocks=numberBlocks;
+  info.work=workDouble_;
+  info.rowsDropped=rowsDropped;
+  info.integerParameters_[1]=model_->numberThreads();
+  ClpCholeskySpawn(&info);
+#endif
+  double largest=0.0;
+  double smallest=COIN_DBL_MAX;
+  int numberDropped=0;
+  for (int i=0;i<numberRows_;i++) {
+    if (diagonal_[i]) {
+      largest = CoinMax(largest,CoinAbs(diagonal_[i]));
+      smallest = CoinMin(smallest,CoinAbs(diagonal_[i]));
+    } else {
+      numberDropped++;
+    }
+  } 
+  doubleParameters_[3]=CoinMax(doubleParameters_[3],1.0/smallest);
+  doubleParameters_[4]=CoinMin(doubleParameters_[4],1.0/largest);
+  integerParameters_[20]+= numberDropped;
+}
+  /* Non leaf recursive factor*/
+void  
+ClpCholeskyCfactor(ClpCholeskyDenseC * thisStruct, longDouble * a, int n, int numberBlocks,
             longDouble * diagonal, longDouble * work, int * rowsDropped)
 {
   if (n<=BLOCK) {
-    factorLeaf(a,n,diagonal,work,rowsDropped);
+    ClpCholeskyCfactorLeaf(thisStruct, a,n,diagonal,work,rowsDropped);
   } else {
     int nb=number_blocks((n+1)>>1);
@@ -647 +671 @@
     int nintri=(nb*(nb+1))>>1;
     int nbelow=(numberBlocks-nb)*nb;
-    factor(a,nThis,numberBlocks,diagonal,work,rowsDropped);
-    triRec(a,nThis,a+number_entries(nb),diagonal,work,nLeft,nb,0,numberBlocks);
+    ClpCholeskyCfactor(thisStruct, a,nThis,numberBlocks,diagonal,work,rowsDropped);
+    ClpCholeskyCtriRec(thisStruct, a,nThis,a+number_entries(nb),diagonal,work,nLeft,nb,0,numberBlocks);
     aother=a+number_entries(nintri+nbelow);
-    recTri(a+number_entries(nb),nLeft,nThis,nb,0,aother,diagonal,work,numberBlocks);
-    factor(aother,nLeft,
+    ClpCholeskyCrecTri(thisStruct, a+number_entries(nb),nLeft,nThis,nb,0,aother,diagonal,work,numberBlocks);
+    ClpCholeskyCfactor(thisStruct, aother,nLeft,
         numberBlocks-nb,diagonal+nThis,work+nThis,rowsDropped);
   }
 }
-// Non leaf recursive triangle rectangle update
+  /* Non leaf recursive triangle rectangle update*/
 void 
-ClpCholeskyDense::triRec(longDouble * aTri, int nThis, longDouble * aUnder,
+ClpCholeskyCtriRec(ClpCholeskyDenseC * thisStruct, longDouble * aTri, int nThis, longDouble * aUnder,
                          longDouble * diagonal, longDouble * work,
                          int nLeft, int iBlock, int jBlock,
@@ -663 +687 @@
 {
   if (nThis<=BLOCK&&nLeft<=BLOCK) {
-    triRecLeaf(aTri,aUnder,diagonal,work,nLeft);
+    ClpCholeskyCtriRecLeaf(/*thisStruct,*/ aTri,aUnder,diagonal,work,nLeft);
   } else if (nThis<nLeft) {
     int nb=number_blocks((nLeft+1)>>1);
     int nLeft2=number_rows(nb);
-    triRec(aTri,nThis,aUnder,diagonal,work,nLeft2,iBlock,jBlock,numberBlocks);
-    triRec(aTri,nThis,aUnder+number_entries(nb),diagonal,work,nLeft-nLeft2,
+    ClpCholeskyCtriRec(thisStruct, aTri,nThis,aUnder,diagonal,work,nLeft2,iBlock,jBlock,numberBlocks);
+    ClpCholeskyCtriRec(thisStruct, aTri,nThis,aUnder+number_entries(nb),diagonal,work,nLeft-nLeft2,
           iBlock+nb,jBlock,numberBlocks);
   } else {
@@ -678 +702 @@
     int nintri=(nb*(nb+1))>>1;
     int nbelow=(numberBlocks-nb)*nb;
-    triRec(aTri,nThis2,aUnder,diagonal,work,nLeft,iBlock,jBlock,numberBlocks);
+    ClpCholeskyCtriRec(thisStruct, aTri,nThis2,aUnder,diagonal,work,nLeft,iBlock,jBlock,numberBlocks);
     /* and rectangular update */
     i=((numberBlocks-jBlock)*(numberBlocks-jBlock-1)-
       (numberBlocks-jBlock-nb)*(numberBlocks-jBlock-nb-1))>>1;
     aother=aUnder+number_entries(i);
-    recRec(aTri+number_entries(nb),nThis-nThis2,nLeft,nThis2,aUnder,aother,
+    ClpCholeskyCrecRec(thisStruct, aTri+number_entries(nb),nThis-nThis2,nLeft,nThis2,aUnder,aother,
           work,kBlock,jBlock,numberBlocks);
-    triRec(aTri+number_entries(nintri+nbelow),nThis-nThis2,aother,diagonal+nThis2,
+    ClpCholeskyCtriRec(thisStruct, aTri+number_entries(nintri+nbelow),nThis-nThis2,aother,diagonal+nThis2,
            work+nThis2,nLeft,
       iBlock-nb,kBlock-nb,numberBlocks-nb);
   }
 }
-// Non leaf recursive rectangle triangle update
+  /* Non leaf recursive rectangle triangle update*/
 void 
-ClpCholeskyDense::recTri(longDouble * aUnder, int nTri, int nDo,
+ClpCholeskyCrecTri(ClpCholeskyDenseC * thisStruct, longDouble * aUnder, int nTri, int nDo,
                          int iBlock, int jBlock,longDouble * aTri,
                          longDouble * diagonal, longDouble * work,
@@ -698 +722 @@
 {
   if (nTri<=BLOCK&&nDo<=BLOCK) {
-    recTriLeaf(aUnder,aTri,diagonal,work,nTri);
+    ClpCholeskyCrecTriLeaf(/*thisStruct,*/ aUnder,aTri,/*diagonal,*/work,nTri);
   } else if (nTri<nDo) {
     int nb=number_blocks((nDo+1)>>1);
@@ -704 +728 @@
     longDouble * aother;
     int i;
-    recTri(aUnder,nTri,nDo2,iBlock,jBlock,aTri,diagonal,work,numberBlocks);
+    ClpCholeskyCrecTri(thisStruct, aUnder,nTri,nDo2,iBlock,jBlock,aTri,diagonal,work,numberBlocks);
     i=((numberBlocks-jBlock)*(numberBlocks-jBlock-1)-
       (numberBlocks-jBlock-nb)*(numberBlocks-jBlock-nb-1))>>1;
     aother=aUnder+number_entries(i);
-    recTri(aother,nTri,nDo-nDo2,iBlock-nb,jBlock,aTri,diagonal+nDo2,
+    ClpCholeskyCrecTri(thisStruct, aother,nTri,nDo-nDo2,iBlock-nb,jBlock,aTri,diagonal+nDo2,
            work+nDo2,numberBlocks-nb);
   } else {
@@ -715 +739 @@
     longDouble * aother;
     int i;
-    recTri(aUnder,nTri2,nDo,iBlock,jBlock,aTri,diagonal,work,numberBlocks);
+    ClpCholeskyCrecTri(thisStruct, aUnder,nTri2,nDo,iBlock,jBlock,aTri,diagonal,work,numberBlocks);
     /* and rectangular update */
     i=((numberBlocks-iBlock)*(numberBlocks-iBlock+1)-
       (numberBlocks-iBlock-nb)*(numberBlocks-iBlock-nb+1))>>1;
     aother=aTri+number_entries(nb);
-    recRec(aUnder,nTri2,nTri-nTri2,nDo,aUnder+number_entries(nb),aother,
+    ClpCholeskyCrecRec(thisStruct, aUnder,nTri2,nTri-nTri2,nDo,aUnder+number_entries(nb),aother,
            work,iBlock,jBlock,numberBlocks);
-    recTri(aUnder+number_entries(nb),nTri-nTri2,nDo,iBlock+nb,jBlock,
+    ClpCholeskyCrecTri(thisStruct, aUnder+number_entries(nb),nTri-nTri2,nDo,iBlock+nb,jBlock,
          aTri+number_entries(i),diagonal,work,numberBlocks);
   }
@@ -731 +755 @@
 */
 void 
-ClpCholeskyDense::recRec(longDouble * above, int nUnder, int nUnderK,
+ClpCholeskyCrecRec(ClpCholeskyDenseC * thisStruct, longDouble * above, int nUnder, int nUnderK,
                          int nDo, longDouble * aUnder, longDouble *aOther,
                          longDouble * work,
@@ -739 +763 @@
   if (nDo<=BLOCK&&nUnder<=BLOCK&&nUnderK<=BLOCK) {
     assert (nDo==BLOCK&&nUnder==BLOCK);
-    recRecLeaf(above , aUnder ,  aOther, work, nUnderK);
+    ClpCholeskyCrecRecLeaf(/*thisStruct,*/ above , aUnder ,  aOther, work, nUnderK);
   } else if (nDo<=nUnderK&&nUnder<=nUnderK) {
     int nb=number_blocks((nUnderK+1)>>1);
     int nUnder2=number_rows(nb);
-    recRec(above,nUnder,nUnder2,nDo,aUnder,aOther,work,
+    ClpCholeskyCrecRec(thisStruct, above,nUnder,nUnder2,nDo,aUnder,aOther,work,
                iBlock,jBlock,numberBlocks);
-    recRec(above,nUnder,nUnderK-nUnder2,nDo,aUnder+number_entries(nb),
+    ClpCholeskyCrecRec(thisStruct, above,nUnder,nUnderK-nUnder2,nDo,aUnder+number_entries(nb),
         aOther+number_entries(nb),work,iBlock,jBlock,numberBlocks);
   } else if (nUnderK<=nDo&&nUnder<=nDo) {
@@ -751 +775 @@
     int nDo2=number_rows(nb);
     int i;
-    recRec(above,nUnder,nUnderK,nDo2,aUnder,aOther,work,
+    ClpCholeskyCrecRec(thisStruct, above,nUnder,nUnderK,nDo2,aUnder,aOther,work,
          iBlock,jBlock,numberBlocks);
     i=((numberBlocks-jBlock)*(numberBlocks-jBlock-1)-
       (numberBlocks-jBlock-nb)*(numberBlocks-jBlock-nb-1))>>1;
-    recRec(above+number_entries(i),nUnder,nUnderK,nDo-nDo2,
+    ClpCholeskyCrecRec(thisStruct, above+number_entries(i),nUnder,nUnderK,nDo-nDo2,
            aUnder+number_entries(i),
            aOther,work+nDo2,
@@ -763 +787 @@
     int nUnder2=number_rows(nb);
     int i;
-    recRec(above,nUnder2,nUnderK,nDo,aUnder,aOther,work,
+    ClpCholeskyCrecRec(thisStruct, above,nUnder2,nUnderK,nDo,aUnder,aOther,work,
                iBlock,jBlock,numberBlocks);
     i=((numberBlocks-iBlock)*(numberBlocks-iBlock-1)-
       (numberBlocks-iBlock-nb)*(numberBlocks-iBlock-nb-1))>>1;
-    recRec(above+number_entries(nb),nUnder-nUnder2,nUnderK,nDo,aUnder,
+    ClpCholeskyCrecRec(thisStruct, above+number_entries(nb),nUnder-nUnder2,nUnderK,nDo,aUnder,
         aOther+number_entries(i),work,iBlock+nb,jBlock,numberBlocks);
   }
 }
-// Leaf recursive factor
+  /* Leaf recursive factor*/
 void 
-ClpCholeskyDense::factorLeaf(longDouble * a, int n, 
+ClpCholeskyCfactorLeaf(ClpCholeskyDenseC * thisStruct, longDouble * a, int n, 
                 longDouble * diagonal, longDouble * work, int * rowsDropped)
 {
-  longDouble largest=doubleParameters_[3];
-  longDouble smallest=doubleParameters_[4];
-  double dropValue = doubleParameters_[10];
-  int firstPositive=integerParameters_[34];
-  size_t rowOffset=diagonal-diagonal_;
-  int numberDropped=0;
+  double dropValue = thisStruct->doubleParameters_[0];
+  int firstPositive=thisStruct->integerParameters_[0];
+  int rowOffset=diagonal-thisStruct->diagonal_;
   int i, j, k;
-  longDouble t00,temp1;
+  CoinWorkDouble t00,temp1;
   longDouble * aa;
   aa = a-BLOCK;
   for (j = 0; j < n; j ++) {
+    bool dropColumn;
+    CoinWorkDouble useT00;
     aa+=BLOCK;
     t00 = aa[j];
     for (k = 0; k < j; ++k) {
-      longDouble multiplier = work[k];
+      CoinWorkDouble multiplier = work[k];
       t00 -= a[j + k * BLOCK] * a[j + k * BLOCK] * multiplier;
     }
-    bool dropColumn=false;
-    longDouble useT00=t00;
-    if ((int)(j+rowOffset)<firstPositive) {
-      // must be negative
+    dropColumn=false;
+    useT00=t00;
+    if (j+rowOffset<firstPositive) {
+      /* must be negative*/
       if (t00<=-dropValue) {
-        smallest = CoinMin(smallest,-t00);
-        largest = CoinMax(largest,-t00);
-        //aa[j]=t00;
+        /*aa[j]=t00;*/
         t00 = 1.0/t00;
       } else {
         dropColumn=true;
-        //aa[j]=-1.0e100;
+        /*aa[j]=-1.0e100;*/
         useT00=-1.0e-100;
         t00=0.0;
-        integerParameters_[20]++;
       }
     } else {
-      // must be positive
+      /* must be positive*/
       if (t00>=dropValue) {
-        smallest = CoinMin(smallest,t00);
-        largest = CoinMax(largest,t00);
-        //aa[j]=t00;
+        /*aa[j]=t00;*/
         t00 = 1.0/t00;
       } else {
         dropColumn=true;
-        //aa[j]=1.0e100;
+        /*aa[j]=1.0e100;*/
         useT00=1.0e-100;
         t00=0.0;
-        integerParameters_[20]++;
       }
     }
@@ -831 +848 @@
         t00=aa[i];
         for (k = 0; k < j; ++k) {
-          longDouble multiplier = work[k];
+          CoinWorkDouble multiplier = work[k];
           t00 -= a[i + k * BLOCK] * a[j + k * BLOCK] * multiplier;
         }
@@ -837 +854 @@
       }
     } else {
-      // drop column
+      /* drop column*/
       rowsDropped[j+rowOffset]=2;
-      numberDropped++;
       diagonal[j]=0.0;
-      //aa[j]=1.0e100;
+      /*aa[j]=1.0e100;*/
       work[j]=1.0e100;
       for (i=j+1;i<n;i++) {
@@ -848 +864 @@
     }
   }
-  doubleParameters_[3]=largest;
-  doubleParameters_[4]=smallest;
-  integerParameters_[20]+=numberDropped;
-}
-// Leaf recursive triangle rectangle update
+}
+  /* Leaf recursive triangle rectangle update*/
 void 
-ClpCholeskyDense::triRecLeaf(longDouble * aTri, longDouble * aUnder, longDouble * diagonal, longDouble * work,
+ClpCholeskyCtriRecLeaf(/*ClpCholeskyDenseC * thisStruct,*/ longDouble * aTri, longDouble * aUnder, longDouble * diagonal, longDouble * work,
                 int nUnder)
 {
@@ -862 +875 @@
   int irt,ict;
   int it=bNumber(aTri,irt,ict);
-  //printf("%d %d\n",iu,it);
+  /*printf("%d %d\n",iu,it);*/
   printf("trirecleaf  under (%d,%d), tri (%d,%d)\n",
          iru,icu,irt,ict);
-  assert (diagonal==diagonal_+ict*BLOCK);
+  assert (diagonal==thisStruct->diagonal_+ict*BLOCK);
 #endif
   int j;
@@ -873 +886 @@
     aa = aTri-2*BLOCK;
     for (j = 0; j < BLOCK; j +=2) {
+      int i;
+      CoinWorkDouble temp0 = diagonal[j];
+      CoinWorkDouble temp1 = diagonal[j+1];
       aa+=2*BLOCK;
-      longDouble temp0 = diagonal[j];
-      longDouble temp1 = diagonal[j+1];
-      for (int i=0;i<BLOCK;i+=2) {
-        longDouble t00=aUnder[i+j*BLOCK];
-        longDouble t10=aUnder[i+ BLOCK + j*BLOCK];
-        longDouble t01=aUnder[i+1+j*BLOCK];
-        longDouble t11=aUnder[i+1+ BLOCK + j*BLOCK];
-        for (int k = 0; k < j; ++k) {
-          longDouble multiplier=work[k];
-          longDouble au0 = aUnder[i + k * BLOCK]*multiplier;
-          longDouble au1 = aUnder[i + 1 + k * BLOCK]*multiplier;
-          longDouble at0 = aTri[j + k * BLOCK];
-          longDouble at1 = aTri[j + 1 + k * BLOCK];
+      for ( i=0;i<BLOCK;i+=2) {
+        CoinWorkDouble at1;
+        CoinWorkDouble t00=aUnder[i+j*BLOCK];
+        CoinWorkDouble t10=aUnder[i+ BLOCK + j*BLOCK];
+        CoinWorkDouble t01=aUnder[i+1+j*BLOCK];
+        CoinWorkDouble t11=aUnder[i+1+ BLOCK + j*BLOCK];
+        int k;
+        for (k = 0; k < j; ++k) {
+          CoinWorkDouble multiplier=work[k];
+          CoinWorkDouble au0 = aUnder[i + k * BLOCK]*multiplier;
+          CoinWorkDouble au1 = aUnder[i + 1 + k * BLOCK]*multiplier;
+          CoinWorkDouble at0 = aTri[j + k * BLOCK];
+          CoinWorkDouble at1 = aTri[j + 1 + k * BLOCK];
           t00 -= au0 * at0;
           t10 -= au0 * at1;
@@ -893 +909 @@
         }
         t00 *= temp0;
-        longDouble at1 = aTri[j + 1 + j*BLOCK]*work[j];
+        at1 = aTri[j + 1 + j*BLOCK]*work[j];
         t10 -= t00 * at1;
         t01 *= temp0;
@@ -907 +923 @@
     aa = aTri-BLOCK;
     for (j = 0; j < BLOCK; j ++) {
+      int i;
+      CoinWorkDouble temp1 = diagonal[j];
       aa+=BLOCK;
-      longDouble temp1 = diagonal[j];
-      for (int i=0;i<nUnder;i++) {
-        longDouble t00=aUnder[i+j*BLOCK];
-        for (int k = 0; k < j; ++k) {
-          longDouble multiplier=work[k];
+      for (i=0;i<nUnder;i++) {
+        int k;
+        CoinWorkDouble t00=aUnder[i+j*BLOCK];
+        for ( k = 0; k < j; ++k) {
+          CoinWorkDouble multiplier=work[k];
           t00 -= aUnder[i + k * BLOCK] * aTri[j + k * BLOCK] * multiplier;
         }
@@ -922 +940 @@
 #endif
 }
-// Leaf recursive rectangle triangle update
-void ClpCholeskyDense::recTriLeaf(longDouble * aUnder, longDouble * aTri, 
-                                  longDouble * diagonal, longDouble * work, int nUnder)
+  /* Leaf recursive rectangle triangle update*/
+void ClpCholeskyCrecTriLeaf(/*ClpCholeskyDenseC * thisStruct,*/ longDouble * aUnder, longDouble * aTri, 
+                            /*longDouble * diagonal,*/ longDouble * work, int nUnder)
 {
 #ifdef POS_DEBUG
@@ -931 +949 @@
   int irt,ict;
   int it=bNumber(aTri,irt,ict);
-  //printf("%d %d\n",iu,it);
+  /*printf("%d %d\n",iu,it);*/
   printf("rectrileaf  under (%d,%d), tri (%d,%d)\n",
          iru,icu,irt,ict);
-  assert (diagonal==diagonal_+icu*BLOCK);
+  assert (diagonal==thisStruct->diagonal_+icu*BLOCK);
 #endif
   int i, j, k;
-  longDouble t00;
+  CoinWorkDouble t00;
   longDouble * aa;
 #ifdef BLOCKUNROLL
@@ -944 +962 @@
     aa = aTri-2*BLOCK;
     for (j = 0; j < BLOCK; j +=2) {
-      longDouble t00,t01,t10,t11;
+      CoinWorkDouble t00,t01,t10,t11;
       aa+=2*BLOCK;
       aUnder2+=2;
@@ -951 +969 @@
       t10=aa[j+1+BLOCK];
       for (k = 0; k < BLOCK; ++k) {
-        longDouble multiplier = work[k];
-        longDouble a0 = aUnder2[k * BLOCK];
-        longDouble a1 = aUnder2[1 + k * BLOCK];
-        longDouble x0 = a0 * multiplier;
-        longDouble x1 = a1 * multiplier;
+        CoinWorkDouble multiplier = work[k];
+        CoinWorkDouble a0 = aUnder2[k * BLOCK];
+        CoinWorkDouble a1 = aUnder2[1 + k * BLOCK];
+        CoinWorkDouble x0 = a0 * multiplier;
+        CoinWorkDouble x1 = a1 * multiplier;
         t00 -= a0 * x0;
         t01 -= a1 * x0;
@@ -969 +987 @@
         t11=aa[i+1+BLOCK];
         for (k = 0; k < BLOCK; ++k) {
-          longDouble multiplier = work[k];
-          longDouble a0 = aUnder2[k * BLOCK]*multiplier;
-          longDouble a1 = aUnder2[1 + k * BLOCK]*multiplier;
+          CoinWorkDouble multiplier = work[k];
+          CoinWorkDouble a0 = aUnder2[k * BLOCK]*multiplier;
+          CoinWorkDouble a1 = aUnder2[1 + k * BLOCK]*multiplier;
           t00 -= aUnder[i + k * BLOCK] * a0;
           t01 -= aUnder[i + k * BLOCK] * a1;
@@ -991 +1009 @@
         t00=aa[i];
         for (k = 0; k < BLOCK; ++k) {
-          longDouble multiplier = work[k];
+          CoinWorkDouble multiplier = work[k];
           t00 -= aUnder[i + k * BLOCK] * aUnder[j + k * BLOCK]*multiplier;
         }
@@ -1006 +1024 @@
 */
 void 
-ClpCholeskyDense::recRecLeaf(const longDouble * COIN_RESTRICT above, 
+ClpCholeskyCrecRecLeaf(/*ClpCholeskyDenseC * thisStruct,*/
+                                         const longDouble * COIN_RESTRICT above, 
                              const longDouble * COIN_RESTRICT aUnder, 
                              longDouble * COIN_RESTRICT aOther, 
@@ -1019 +1038 @@
   int iro,ico;
   int io=bNumber(aOther,iro,ico);
-  //printf("%d %d %d\n",ia,iu,io);
+  /*printf("%d %d %d\n",ia,iu,io);*/
   printf("recrecleaf above (%d,%d), under (%d,%d), other (%d,%d)\n",
          ira,ica,iru,icu,iro,ico);
@@ -1028 +1047 @@
   aa = aOther-4*BLOCK;
   if (nUnder==BLOCK) {
-    //#define INTEL
+    /*#define INTEL*/
 #ifdef INTEL
     aa+=2*BLOCK;
@@ -1034 +1053 @@
       aa+=2*BLOCK;
       for (i=0;i< BLOCK;i+=2) {
-        longDouble t00=aa[i+0*BLOCK];
-        longDouble t10=aa[i+1*BLOCK];
-        longDouble t01=aa[i+1+0*BLOCK];
-        longDouble t11=aa[i+1+1*BLOCK];
+        CoinWorkDouble t00=aa[i+0*BLOCK];
+        CoinWorkDouble t10=aa[i+1*BLOCK];
+        CoinWorkDouble t01=aa[i+1+0*BLOCK];
+        CoinWorkDouble t11=aa[i+1+1*BLOCK];
         for (k=0;k<BLOCK;k++) {
-          longDouble multiplier = work[k];
-          longDouble a00=aUnder[i+k*BLOCK]*multiplier;
-          longDouble a01=aUnder[i+1+k*BLOCK]*multiplier;
+          CoinWorkDouble multiplier = work[k];
+          CoinWorkDouble a00=aUnder[i+k*BLOCK]*multiplier;
+          CoinWorkDouble a01=aUnder[i+1+k*BLOCK]*multiplier;
           t00 -= a00 * above[j + 0 + k * BLOCK];
           t10 -= a00 * above[j + 1 + k * BLOCK];
@@ -1057 +1076 @@
       aa+=4*BLOCK;
       for (i=0;i< BLOCK;i+=4) {
-        longDouble t00=aa[i+0+0*BLOCK];
-        longDouble t10=aa[i+0+1*BLOCK];
-        longDouble t20=aa[i+0+2*BLOCK];
-        longDouble t30=aa[i+0+3*BLOCK];
-        longDouble t01=aa[i+1+0*BLOCK];
-        longDouble t11=aa[i+1+1*BLOCK];
-        longDouble t21=aa[i+1+2*BLOCK];
-        longDouble t31=aa[i+1+3*BLOCK];
-        longDouble t02=aa[i+2+0*BLOCK];
-        longDouble t12=aa[i+2+1*BLOCK];
-        longDouble t22=aa[i+2+2*BLOCK];
-        longDouble t32=aa[i+2+3*BLOCK];
-        longDouble t03=aa[i+3+0*BLOCK];
-        longDouble t13=aa[i+3+1*BLOCK];
-        longDouble t23=aa[i+3+2*BLOCK];
-        longDouble t33=aa[i+3+3*BLOCK];
+        CoinWorkDouble t00=aa[i+0+0*BLOCK];
+        CoinWorkDouble t10=aa[i+0+1*BLOCK];
+        CoinWorkDouble t20=aa[i+0+2*BLOCK];
+        CoinWorkDouble t30=aa[i+0+3*BLOCK];
+        CoinWorkDouble t01=aa[i+1+0*BLOCK];
+        CoinWorkDouble t11=aa[i+1+1*BLOCK];
+        CoinWorkDouble t21=aa[i+1+2*BLOCK];
+        CoinWorkDouble t31=aa[i+1+3*BLOCK];
+        CoinWorkDouble t02=aa[i+2+0*BLOCK];
+        CoinWorkDouble t12=aa[i+2+1*BLOCK];
+        CoinWorkDouble t22=aa[i+2+2*BLOCK];
+        CoinWorkDouble t32=aa[i+2+3*BLOCK];
+        CoinWorkDouble t03=aa[i+3+0*BLOCK];
+        CoinWorkDouble t13=aa[i+3+1*BLOCK];
+        CoinWorkDouble t23=aa[i+3+2*BLOCK];
+        CoinWorkDouble t33=aa[i+3+3*BLOCK];
         const longDouble * COIN_RESTRICT aUnderNow = aUnder+i;
         const longDouble * COIN_RESTRICT aboveNow = above+j;
         for (k=0;k<BLOCK;k++) {
-          longDouble multiplier = work[k];
-          longDouble a00=aUnderNow[0]*multiplier;
-          longDouble a01=aUnderNow[1]*multiplier;
-          longDouble a02=aUnderNow[2]*multiplier;
-          longDouble a03=aUnderNow[3]*multiplier;
+          CoinWorkDouble multiplier = work[k];
+          CoinWorkDouble a00=aUnderNow[0]*multiplier;
+          CoinWorkDouble a01=aUnderNow[1]*multiplier;
+          CoinWorkDouble a02=aUnderNow[2]*multiplier;
+          CoinWorkDouble a03=aUnderNow[3]*multiplier;
           t00 -= a00 * aboveNow[0];
           t10 -= a00 * aboveNow[1];
@@ -1125 +1144 @@
       aa+=4*BLOCK;
       for (i=0;i< n;i+=2) {
-        longDouble t00=aa[i+0*BLOCK];
-        longDouble t10=aa[i+1*BLOCK];
-        longDouble t20=aa[i+2*BLOCK];
-        longDouble t30=aa[i+3*BLOCK];
-        longDouble t01=aa[i+1+0*BLOCK];
-        longDouble t11=aa[i+1+1*BLOCK];
-        longDouble t21=aa[i+1+2*BLOCK];
-        longDouble t31=aa[i+1+3*BLOCK];
+        CoinWorkDouble t00=aa[i+0*BLOCK];
+        CoinWorkDouble t10=aa[i+1*BLOCK];
+        CoinWorkDouble t20=aa[i+2*BLOCK];
+        CoinWorkDouble t30=aa[i+3*BLOCK];
+        CoinWorkDouble t01=aa[i+1+0*BLOCK];
+        CoinWorkDouble t11=aa[i+1+1*BLOCK];
+        CoinWorkDouble t21=aa[i+1+2*BLOCK];
+        CoinWorkDouble t31=aa[i+1+3*BLOCK];
         const longDouble * COIN_RESTRICT aUnderNow = aUnder+i;
         const longDouble * COIN_RESTRICT aboveNow = above+j;
         for (k=0;k<BLOCK;k++) {
-          longDouble multiplier = work[k];
-          longDouble a00=aUnderNow[0]*multiplier;
-          longDouble a01=aUnderNow[1]*multiplier;
+          CoinWorkDouble multiplier = work[k];
+          CoinWorkDouble a00=aUnderNow[0]*multiplier;
+          CoinWorkDouble a01=aUnderNow[1]*multiplier;
           t00 -= a00 * aboveNow[0];
           t10 -= a00 * aboveNow[1];
@@ -1160 +1179 @@
       }
       if (odd) {
-        longDouble t0=aa[n+0*BLOCK];
-        longDouble t1=aa[n+1*BLOCK];
-        longDouble t2=aa[n+2*BLOCK];
-        longDouble t3=aa[n+3*BLOCK];
-        longDouble a0;
+        CoinWorkDouble t0=aa[n+0*BLOCK];
+        CoinWorkDouble t1=aa[n+1*BLOCK];
+        CoinWorkDouble t2=aa[n+2*BLOCK];
+        CoinWorkDouble t3=aa[n+3*BLOCK];
+        CoinWorkDouble a0;
         for (k=0;k<BLOCK;k++) {
           a0=aUnder[n+k*BLOCK]*work[k];
@@ -1184 +1203 @@
     aa+=BLOCK;
     for (i=0;i< nUnder;i++) {
-      longDouble t00=aa[i+0*BLOCK];
+      CoinWorkDouble t00=aa[i+0*BLOCK];
       for (k=0;k<BLOCK;k++) {
-        longDouble a00=aUnder[i+k*BLOCK]*work[k];
+        CoinWorkDouble a00=aUnder[i+k*BLOCK]*work[k];
         t00 -= a00 * above[j + k * BLOCK];
       }
@@ -1196 +1215 @@
 /* Uses factorization to solve. */
 void 
-ClpCholeskyDense::solve (double * region) 
+ClpCholeskyDense::solve (CoinWorkDouble * region) 
 {
 #ifdef CHOL_COMPARE
@@ -1228 +1247 @@
   }
 #endif
-  //longDouble * xx = sparseFactor_;
-  //longDouble * yy = diagonal_;
-  //diagonal_ = sparseFactor_ + 40000;
-  //sparseFactor_=diagonal_ + numberRows_;
+  /*longDouble * xx = sparseFactor_;*/
+  /*longDouble * yy = diagonal_;*/
+  /*diagonal_ = sparseFactor_ + 40000;*/
+  /*sparseFactor_=diagonal_ + numberRows_;*/
   int numberBlocks = (numberRows_+BLOCK-1)>>BLOCKSHIFT;
-  // later align on boundary
+  /* later align on boundary*/
   longDouble * a = sparseFactor_+BLOCKSQ*numberBlocks;
   int iBlock;
@@ -1261 +1280 @@
     aa+=BLOCKSQ;
   }
-  // do diagonal outside
+  /* do diagonal outside*/
   for (iColumn=0;iColumn<numberRows_;iColumn++) 
     region[iColumn] *= diagonal_[iColumn];
@@ -1293 +1312 @@
   if (numberRows_<200) {
     for (int i=0;i<numberRows_;i++) {
-      assert(fabs(region[i]-region2[i])<1.0e-3);
+      assert(CoinAbs(region[i]-region2[i])<1.0e-3);
     }
     delete [] region2;
@@ -1299 +1318 @@
 #endif
 }
-// Forward part of solve 1
+/* Forward part of solve 1*/
 void 
-ClpCholeskyDense::solveF1(longDouble * a,int n,double * region)
+ClpCholeskyDense::solveF1(longDouble * a,int n,CoinWorkDouble * region)
 {
   int j, k;
-  longDouble t00;
+  CoinWorkDouble t00;
   for (j = 0; j < n; j ++) {
     t00 = region[j];
@@ -1310 +1329 @@
       t00 -= region[k] * a[j + k * BLOCK];
     }
-    //t00*=a[j + j * BLOCK];
+    /*t00*=a[j + j * BLOCK];*/
     region[j] = t00;
   }
 }
-// Forward part of solve 2
+/* Forward part of solve 2*/
 void 
-ClpCholeskyDense::solveF2(longDouble * a,int n,double * region, double * region2)
+ClpCholeskyDense::solveF2(longDouble * a,int n,CoinWorkDouble * region, CoinWorkDouble * region2)
 {
   int j, k;
@@ -1322 +1341 @@
   if (n==BLOCK) {
     for (k = 0; k < BLOCK; k+=4) {
-      longDouble t0 = region2[0];
-      longDouble t1 = region2[1];
-      longDouble t2 = region2[2];
-      longDouble t3 = region2[3];
+      CoinWorkDouble t0 = region2[0];
+      CoinWorkDouble t1 = region2[1];
+      CoinWorkDouble t2 = region2[2];
+      CoinWorkDouble t3 = region2[3];
       t0 -= region[0] * a[0 + 0 * BLOCK];
       t1 -= region[0] * a[1 + 0 * BLOCK];
@@ -1416 +1435 @@
 #endif
     for (k = 0; k < n; ++k) {
-      longDouble t00 = region2[k];
+      CoinWorkDouble t00 = region2[k];
       for (j = 0; j < BLOCK; j ++) {
         t00 -= region[j] * a[k + j * BLOCK];
@@ -1426 +1445 @@
 #endif
 }
-// Backward part of solve 1
+/* Backward part of solve 1*/
 void 
-ClpCholeskyDense::solveB1(longDouble * a,int n,double * region)
+ClpCholeskyDense::solveB1(longDouble * a,int n,CoinWorkDouble * region)
 {
   int j, k;
-  longDouble t00;
+  CoinWorkDouble t00;
   for (j = n-1; j >=0; j --) {
     t00 = region[j];
@@ -1437 +1456 @@
       t00 -= region[k] * a[k + j * BLOCK];
     }
-    //t00*=a[j + j * BLOCK];
+    /*t00*=a[j + j * BLOCK];*/
     region[j] = t00;
   }
 }
-// Backward part of solve 2
+/* Backward part of solve 2*/
 void 
-ClpCholeskyDense::solveB2(longDouble * a,int n,double * region, double * region2)
+ClpCholeskyDense::solveB2(longDouble * a,int n,CoinWorkDouble * region, CoinWorkDouble * region2)
 {
   int j, k;
@@ -1449 +1468 @@
   if (n==BLOCK) {
     for (j = 0; j < BLOCK; j +=4) {
-      longDouble t0 = region[0];
-      longDouble t1 = region[1];
-      longDouble t2 = region[2];
-      longDouble t3 = region[3];
+      CoinWorkDouble t0 = region[0];
+      CoinWorkDouble t1 = region[1];
+      CoinWorkDouble t2 = region[2];
+      CoinWorkDouble t3 = region[3];
       t0 -= region2[0] * a[0 + 0*BLOCK];
       t1 -= region2[0] * a[0 + 1*BLOCK];
@@ -1544 +1563 @@
 #endif
     for (j = 0; j < BLOCK; j ++) {
-      longDouble t00 = region[j];
+      CoinWorkDouble t00 = region[j];
       for (k = 0; k < n; ++k) {
         t00 -= region2[k] * a[k + j * BLOCK];
@@ -1554 +1573 @@
 #endif
 }
-/* Uses factorization to solve. */
-void 
-ClpCholeskyDense::solveLong (longDouble * region) 
-{
-  int numberBlocks = (numberRows_+BLOCK-1)>>BLOCKSHIFT;
-  // later align on boundary
-  longDouble * a = sparseFactor_+BLOCKSQ*numberBlocks;
-  int iBlock;
-  longDouble * aa = a;
-  int iColumn;
-  for (iBlock=0;iBlock<numberBlocks;iBlock++) {
-    int nChunk;
-    int jBlock;
-    int iDo = iBlock*BLOCK;
-    int base=iDo;
-    if (iDo+BLOCK>numberRows_) {
-      nChunk=numberRows_-iDo;
-    } else {
-      nChunk=BLOCK;
-    }
-    solveF1Long(aa,nChunk,region+iDo);
-    for (jBlock=iBlock+1;jBlock<numberBlocks;jBlock++) {
-      base+=BLOCK;
-      aa+=BLOCKSQ;
-      if (base+BLOCK>numberRows_) {
-        nChunk=numberRows_-base;
-      } else {
-        nChunk=BLOCK;
-      }
-      solveF2Long(aa,nChunk,region+iDo,region+base);
-    }
-    aa+=BLOCKSQ;
-  }
-  // do diagonal outside
-  for (iColumn=0;iColumn<numberRows_;iColumn++) 
-    region[iColumn] *= diagonal_[iColumn];
-  int offset=((numberBlocks*(numberBlocks+1))>>1);
-  aa = a+number_entries(offset-1);
-  int lBase=(numberBlocks-1)*BLOCK;
-  for (iBlock=numberBlocks-1;iBlock>=0;iBlock--) {
-    int nChunk;
-    int jBlock;
-    int triBase=iBlock*BLOCK;
-    int iBase=lBase;
-    for (jBlock=iBlock+1;jBlock<numberBlocks;jBlock++) {
-      if (iBase+BLOCK>numberRows_) {
-        nChunk=numberRows_-iBase;
-      } else {
-        nChunk=BLOCK;
-      }
-      solveB2Long(aa,nChunk,region+triBase,region+iBase);
-      iBase-=BLOCK;
-      aa-=BLOCKSQ;
-    }
-    if (triBase+BLOCK>numberRows_) {
-      nChunk=numberRows_-triBase;
-    } else {
-      nChunk=BLOCK;
-    }
-    solveB1Long(aa,nChunk,region+triBase);
-    aa-=BLOCKSQ;
-  }
-}
-// Forward part of solve 1
-void 
-ClpCholeskyDense::solveF1Long(longDouble * a,int n,longDouble * region)
-{
-  int j, k;
-  longDouble t00;
-  for (j = 0; j < n; j ++) {
-    t00 = region[j];
-    for (k = 0; k < j; ++k) {
-      t00 -= region[k] * a[j + k * BLOCK];
-    }
-    //t00*=a[j + j * BLOCK];
-    region[j] = t00;
-  }
-}
-// Forward part of solve 2
-void 
-ClpCholeskyDense::solveF2Long(longDouble * a,int n,longDouble * region, longDouble * region2)
-{
-  int j, k;
-#ifdef BLOCKUNROLL
-  if (n==BLOCK) {
-    for (k = 0; k < BLOCK; k+=4) {
-      longDouble t0 = region2[0];
-      longDouble t1 = region2[1];
-      longDouble t2 = region2[2];
-      longDouble t3 = region2[3];
-      t0 -= region[0] * a[0 + 0 * BLOCK];
-      t1 -= region[0] * a[1 + 0 * BLOCK];
-      t2 -= region[0] * a[2 + 0 * BLOCK];
-      t3 -= region[0] * a[3 + 0 * BLOCK];
-
-      t0 -= region[1] * a[0 + 1 * BLOCK];
-      t1 -= region[1] * a[1 + 1 * BLOCK];
-      t2 -= region[1] * a[2 + 1 * BLOCK];
-      t3 -= region[1] * a[3 + 1 * BLOCK];
-
-      t0 -= region[2] * a[0 + 2 * BLOCK];
-      t1 -= region[2] * a[1 + 2 * BLOCK];
-      t2 -= region[2] * a[2 + 2 * BLOCK];
-      t3 -= region[2] * a[3 + 2 * BLOCK];
-
-      t0 -= region[3] * a[0 + 3 * BLOCK];
-      t1 -= region[3] * a[1 + 3 * BLOCK];
-      t2 -= region[3] * a[2 + 3 * BLOCK];
-      t3 -= region[3] * a[3 + 3 * BLOCK];
-
-      t0 -= region[4] * a[0 + 4 * BLOCK];
-      t1 -= region[4] * a[1 + 4 * BLOCK];
-      t2 -= region[4] * a[2 + 4 * BLOCK];
-      t3 -= region[4] * a[3 + 4 * BLOCK];
-
-      t0 -= region[5] * a[0 + 5 * BLOCK];
-      t1 -= region[5] * a[1 + 5 * BLOCK];
-      t2 -= region[5] * a[2 + 5 * BLOCK];
-      t3 -= region[5] * a[3 + 5 * BLOCK];
-
-      t0 -= region[6] * a[0 + 6 * BLOCK];
-      t1 -= region[6] * a[1 + 6 * BLOCK];
-      t2 -= region[6] * a[2 + 6 * BLOCK];
-      t3 -= region[6] * a[3 + 6 * BLOCK];
-
-      t0 -= region[7] * a[0 + 7 * BLOCK];
-      t1 -= region[7] * a[1 + 7 * BLOCK];
-      t2 -= region[7] * a[2 + 7 * BLOCK];
-      t3 -= region[7] * a[3 + 7 * BLOCK];
-#if BLOCK>8
-      t0 -= region[8] * a[0 + 8 * BLOCK];
-      t1 -= region[8] * a[1 + 8 * BLOCK];
-      t2 -= region[8] * a[2 + 8 * BLOCK];
-      t3 -= region[8] * a[3 + 8 * BLOCK];
-
-      t0 -= region[9] * a[0 + 9 * BLOCK];
-      t1 -= region[9] * a[1 + 9 * BLOCK];
-      t2 -= region[9] * a[2 + 9 * BLOCK];
-      t3 -= region[9] * a[3 + 9 * BLOCK];
-
-      t0 -= region[10] * a[0 + 10 * BLOCK];
-      t1 -= region[10] * a[1 + 10 * BLOCK];
-      t2 -= region[10] * a[2 + 10 * BLOCK];
-      t3 -= region[10] * a[3 + 10 * BLOCK];
-
-      t0 -= region[11] * a[0 + 11 * BLOCK];
-      t1 -= region[11] * a[1 + 11 * BLOCK];
-      t2 -= region[11] * a[2 + 11 * BLOCK];
-      t3 -= region[11] * a[3 + 11 * BLOCK];
-
-      t0 -= region[12] * a[0 + 12 * BLOCK];
-      t1 -= region[12] * a[1 + 12 * BLOCK];
-      t2 -= region[12] * a[2 + 12 * BLOCK];
-      t3 -= region[12] * a[3 + 12 * BLOCK];
-
-      t0 -= region[13] * a[0 + 13 * BLOCK];
-      t1 -= region[13] * a[1 + 13 * BLOCK];
-      t2 -= region[13] * a[2 + 13 * BLOCK];
-      t3 -= region[13] * a[3 + 13 * BLOCK];
-
-      t0 -= region[14] * a[0 + 14 * BLOCK];
-      t1 -= region[14] * a[1 + 14 * BLOCK];
-      t2 -= region[14] * a[2 + 14 * BLOCK];
-      t3 -= region[14] * a[3 + 14 * BLOCK];
-
-      t0 -= region[15] * a[0 + 15 * BLOCK];
-      t1 -= region[15] * a[1 + 15 * BLOCK];
-      t2 -= region[15] * a[2 + 15 * BLOCK];
-      t3 -= region[15] * a[3 + 15 * BLOCK];
-#endif
-      region2[0] = t0;
-      region2[1] = t1;
-      region2[2] = t2;
-      region2[3] = t3;
-      region2+=4;
-      a+=4;
-    }
-  } else {
-#endif
-    for (k = 0; k < n; ++k) {
-      longDouble t00 = region2[k];
-      for (j = 0; j < BLOCK; j ++) {
-        t00 -= region[j] * a[k + j * BLOCK];
-      }
-      region2[k] = t00;
-    }
-#ifdef BLOCKUNROLL
-  }
-#endif
-}
-// Backward part of solve 1
-void 
-ClpCholeskyDense::solveB1Long(longDouble * a,int n,longDouble * region)
-{
-  int j, k;
-  longDouble t00;
-  for (j = n-1; j >=0; j --) {
-    t00 = region[j];
-    for (k = j+1; k < n; ++k) {
-      t00 -= region[k] * a[k + j * BLOCK];