Changeset 1402


Ignore:
Timestamp:
Jul 25, 2009 4:39:55 AM (10 years ago)
Author:
forrest
Message:

get rid of compiler warnings

Location:
trunk/Clp/src
Files:
48 edited

Legend:

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

    r1401 r1402  
    7373    action_(INVALID),
    7474    currentKeyWord_(-1),
    75     display_(false),
     75    display_(0),
    7676    intValue_(-1),
    7777    doubleValue_(-1.0),
     
    8383CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
    8484           double lower, double upper, CbcOrClpParameterType type,
    85                     bool display)
     85                    int display)
    8686  : type_(type),
    8787    lowerIntValue_(0),
     
    105105CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
    106106           int lower, int upper, CbcOrClpParameterType type,
    107                     bool display)
     107                    int display)
    108108  : type_(type),
    109109    lowerDoubleValue_(0.0),
     
    129129                    std::string firstValue,
    130130                    CbcOrClpParameterType type,int whereUsed,
    131                     bool display)
     131                    int display)
    132132  : type_(type),
    133133    lowerDoubleValue_(0.0),
     
    153153CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
    154154                    CbcOrClpParameterType type,int whereUsed,
    155                     bool display)
     155                    int display)
    156156  : type_(type),
    157157    lowerDoubleValue_(0.0),
     
    247247    lengthName_--;
    248248  }
     249}
     250// Returns length of name for printing
     251int
     252CbcOrClpParam::lengthMatchName (  ) const
     253{
     254  if (lengthName_==lengthMatch_)
     255    return lengthName_;
     256  else
     257    return lengthName_+2;
    249258}
    250259// Insert string (only valid for keywords)
     
    650659#ifdef COIN_HAS_CBC
    651660double
    652 CbcOrClpParam::doubleParameter (OsiSolverInterface * model) const
     661CbcOrClpParam::doubleParameter (OsiSolverInterface *
     662#ifndef NDEBUG
     663model
     664#endif
     665) const
    653666{
    654667  double value=0.0;
     
    12171230  numberParameters=0;
    12181231  parameters[numberParameters++]=
    1219     CbcOrClpParam("?","For help",GENERALQUERY,7,false);
    1220   parameters[numberParameters++]=
    1221     CbcOrClpParam("???","For help",FULLGENERALQUERY,7,false);
     1232    CbcOrClpParam("?","For help",GENERALQUERY,7,0);
     1233  parameters[numberParameters++]=
     1234    CbcOrClpParam("???","For help",FULLGENERALQUERY,7,0);
    12221235  parameters[numberParameters++]=
    12231236    CbcOrClpParam("-","From stdin",
    1224                   STDIN,3,false);
     1237                  STDIN,3,0);
     1238  parameters[numberParameters++]=
     1239    CbcOrClpParam("allC!ommands","Whether to print less used commands",
     1240                  "no",ALLCOMMANDS);
     1241  parameters[numberParameters-1].append("more");
     1242  parameters[numberParameters-1].append("all");
     1243  parameters[numberParameters-1].setLonghelp
     1244    (
     1245     "For the sake of your sanity, only the more useful and simple commands \
     1246are printed out on ?."
     1247     );
    12251248#ifdef COIN_HAS_CBC
    12261249    parameters[numberParameters++]=
     
    12481271  parameters[numberParameters++]=
    12491272    CbcOrClpParam("artif!icialCost","Costs >= this treated as artificials in feasibility pump",
    1250                   0.0,COIN_DBL_MAX,ARTIFICIALCOST,false);
     1273                  0.0,COIN_DBL_MAX,ARTIFICIALCOST,1);
    12511274  parameters[numberParameters-1].setDoubleValue(0.0);
    12521275    parameters[numberParameters-1].setLonghelp
     
    12581281  parameters[numberParameters++]=
    12591282    CbcOrClpParam("auto!Scale","Whether to scale objective, rhs and bounds of problem if they look odd",
    1260                   "off",AUTOSCALE,7,false);
     1283                  "off",AUTOSCALE,7,0);
    12611284  parameters[numberParameters-1].append("on");
    12621285  parameters[numberParameters-1].setLonghelp
     
    12641287     "If you think you may get odd objective values or large equality rows etc then\
    12651288 it may be worth setting this true.  It is still experimental and you may prefer\
    1266  to use objective!Scale and rhs!Scale"
     1289 to use objective!Scale and rhs!Scale."
    12671290     );
    12681291  parameters[numberParameters++]=
     
    12721295    (
    12731296     "This command solves the current model using the  primal dual predictor \
    1274 corrector algorithm.  You will probably want to link in and choose a better \
    1275 ordering and factorization than the default ones provided.  It will also solve models \
     1297corrector algorithm.  You may want to link in an alternative \
     1298ordering and factorization.  It will also solve models \
    12761299with quadratic objectives."
    12771300     
     
    12851308 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    12861309 is initialized to '', i.e. it must be set.  If you have libz then it can read compressed\
    1287  files 'xxxxxxxx.gz'.."
     1310 files 'xxxxxxxx.gz' or xxxxxxxx.bz2."
    12881311     );
    12891312  parameters[numberParameters++]=
     
    12981321  parameters[numberParameters++]=
    12991322    CbcOrClpParam("biasLU","Whether factorization biased towards U",
    1300                   "UU",BIASLU,2,false);
     1323                  "UU",BIASLU,2,0);
    13011324  parameters[numberParameters-1].append("UX");
    13021325  parameters[numberParameters-1].append("LX");
     
    13231346were obtained fairly early in the search so the important point is to select the best variable to branch on.  \
    13241347See whether strong branching did a good job - or did it just take a lot of iterations.  Adjust the strongBranching \
    1325 and trustPseudoCosts parameters."
     1348and trustPseudoCosts parameters.  If cuts did a good job, then you may wish to \
     1349have more rounds of cuts - see passC!uts and passT!ree."
    13261350     );
    13271351#endif
    13281352  parameters[numberParameters++]=
    13291353    CbcOrClpParam("bscale","Whether to scale in barrier (and ordering speed)",
    1330                   "off",BARRIERSCALE,7,false);
     1354                  "off",BARRIERSCALE,7,0);
    13311355  parameters[numberParameters-1].append("on");
    13321356  parameters[numberParameters-1].append("off1");
     
    13421366  parameters[numberParameters-1].append("fudge!Long");
    13431367  parameters[numberParameters-1].append("wssmp");
    1344 #define REAL_BARRIER
    13451368#else
    13461369  parameters[numberParameters-1].append("fudge!Long_dummy");
     
    13491372#ifdef UFL_BARRIER
    13501373  parameters[numberParameters-1].append("Uni!versityOfFlorida");
    1351 #define REAL_BARRIER
    13521374#else
    13531375  parameters[numberParameters-1].append("Uni!versityOfFlorida_dummy");   
     
    13551377#ifdef TAUCS_BARRIER
    13561378  parameters[numberParameters-1].append("Taucs");
    1357 #define REAL_BARRIER
    13581379#else
    13591380  parameters[numberParameters-1].append("Taucs_dummy");
     
    13611382#ifdef MUMPS_BARRIER
    13621383  parameters[numberParameters-1].append("Mumps");
    1363 #define REAL_BARRIER
    13641384#else
    13651385  parameters[numberParameters-1].append("Mumps_dummy");   
     
    13681388    (
    13691389     "For a barrier code to be effective it needs a good Cholesky ordering and factorization.  \
    1370 You will need to link in one from another source.  See Makefile.locations for some \
     1390The native ordering and factorization is not state of the art, although acceptable.  \
     1391You may want to link in one from another source.  See Makefile.locations for some \
    13711392possibilities."
    13721393     );
     
    14311452  parameters[numberParameters++]=
    14321453    CbcOrClpParam("cpp!Generate","Generates C++ code",
    1433                   -1,50000,CPP);
     1454                  -1,50000,CPP,1);
    14341455  parameters[numberParameters-1].setLonghelp
    14351456    (
     
    143814590 gives simplest driver, 1 generates saves and restores, 2 \
    14391460generates saves and restores even for variables at default value. \
    1440 4 bit in cbc generates size dependent code rather than computed values."
     14614 bit in cbc generates size dependent code rather than computed values.  \
     1462This is now deprecated as you can call stand-alone solver - see \
     1463Cbc/examples/driver4.cpp."
    14411464     );
    14421465#ifdef COIN_HAS_CLP
     
    14531476     "If crash is set on and there is an all slack basis then Clp will flip or put structural\
    14541477 variables into basis with the aim of getting dual feasible.  On the whole dual seems to be\
    1455  better without it and there alernative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \
     1478 better without it and there are alternative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \
    14561479I have also added a variant due to Solow and Halim which is as on but just flip.");
    14571480  parameters[numberParameters++]=
     
    14731496  parameters[numberParameters++]=
    14741497    CbcOrClpParam("csv!Statistics","Create one line of statistics",
    1475                   CSVSTATISTICS,2,false);
     1498                  CSVSTATISTICS,2,1);
    14761499  parameters[numberParameters-1].setLonghelp
    14771500    (
     
    14891512every so often.  The original method was every so many nodes but it is more logical \
    14901513to do it whenever depth in tree is a multiple of K.  This option does that and defaults \
    1491 to -1 (off)."
     1514to -1 (off -> code decides)."
    14921515     );
    14931516  parameters[numberParameters-1].setIntValue(-1);
     
    15171540  parameters[numberParameters++]=
    15181541    CbcOrClpParam("debug!In","read valid solution from file",
    1519                   DEBUG,7,false);
     1542                  DEBUG,7,1);
    15201543  parameters[numberParameters-1].setLonghelp
    15211544    (
     
    15331556  parameters[numberParameters++]=
    15341557    CbcOrClpParam("dense!Threshold","Whether to use dense factorization",
    1535                   -1,10000,DENSE,false);
     1558                  -1,10000,DENSE,1);
    15361559  parameters[numberParameters-1].setLonghelp
    15371560    (
     
    15531576  parameters[numberParameters++]=
    15541577    CbcOrClpParam("dextra3","Extra double parameter 3",
    1555                   -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA3,false);
     1578                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA3,0);
    15561579  parameters[numberParameters-1].setDoubleValue(0.0);
    15571580  parameters[numberParameters++]=
    15581581    CbcOrClpParam("dextra4","Extra double parameter 4",
    1559                   -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA4,false);
     1582                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA4,0);
    15601583  parameters[numberParameters-1].setDoubleValue(0.0);
    15611584  parameters[numberParameters++]=
    15621585    CbcOrClpParam("dextra5","Extra double parameter 5",
    1563                   -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA5,false);
     1586                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA5,0);
    15641587  parameters[numberParameters-1].setDoubleValue(0.0);
    15651588  parameters[numberParameters++]=
     
    15961619  parameters[numberParameters++]=
    15971620    CbcOrClpParam("dirSample","Set directory where the COIN-OR sample problems are.",
    1598                   DIRSAMPLE);
     1621                  DIRSAMPLE,7,1);
    15991622  parameters[numberParameters-1].setLonghelp
    16001623    (
     
    16061629  parameters[numberParameters++]=
    16071630    CbcOrClpParam("dirNetlib","Set directory where the netlib problems are.",
    1608                   DIRNETLIB);
     1631                  DIRNETLIB,7,1);
    16091632  parameters[numberParameters-1].setLonghelp
    16101633    (
     
    16181641  parameters[numberParameters++]=
    16191642    CbcOrClpParam("dirMiplib","Set directory where the miplib 2003 problems are.",
    1620                   DIRMIPLIB);
     1643                  DIRMIPLIB,7,1);
    16211644  parameters[numberParameters-1].setLonghelp
    16221645    (
     
    16311654  parameters[numberParameters++]=
    16321655    CbcOrClpParam("diveO!pt","Diving options",
    1633                   -1,200,DIVEOPT,false);
    1634   parameters[numberParameters-1].setLonghelp
    1635     (
    1636      "If >2 && <7 then modify diving options"
     1656                  -1,200,DIVEOPT,1);
     1657  parameters[numberParameters-1].setLonghelp
     1658    (
     1659     "If >2 && <8 then modify diving options - \
     1660         \t3 only at root and if no solution,  \
     1661         \t4 only at root and if this heuristic has not got solution, \
     1662         \t5 only at depth <4, \
     1663         \t6 decay, \
     1664         \t7 run up to 2 times if solution found 4 otherwise."
    16371665     );
    16381666  parameters[numberParameters-1].setIntValue(-1);
     
    16921720    (
    16931721     "Normally heuristics are done in branch and bound.  It may be useful to do them outside. \
    1694 Doing this may also set cutoff."
     1722Only those heuristics with 'both' or 'before' set will run.  \
     1723Doing this may also set cutoff, which can help with preprocessing."
    16951724     );
    16961725#endif
     
    17141743  parameters[numberParameters++]=
    17151744    CbcOrClpParam("dualize","Solves dual reformulation",
    1716                   0,3,DUALIZE,false);
     1745                  0,3,DUALIZE,1);
    17171746  parameters[numberParameters-1].setLonghelp
    17181747    (
     
    17211750  parameters[numberParameters++]=
    17221751    CbcOrClpParam("dualP!ivot","Dual pivot choice algorithm",
    1723                   "auto!matic",DUALPIVOT);
     1752                  "auto!matic",DUALPIVOT,7,1);
    17241753  parameters[numberParameters-1].append("dant!zig");
    17251754  parameters[numberParameters-1].append("partial");
     
    17931822  parameters[numberParameters++]=
    17941823    CbcOrClpParam("exp!eriment","Whether to use testing features",
    1795                   -1,200,EXPERIMENT,false);
     1824                  -1,200,EXPERIMENT,0);
    17961825  parameters[numberParameters-1].setLonghelp
    17971826    (
     
    18081837     "This will write an MPS format file to the given file name.  It will use the default\
    18091838 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    1810  is initialized to 'default.mps'."
     1839 is initialized to 'default.mps'.  \
     1840It 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."
    18111841     );
    18121842#ifdef COIN_HAS_CBC
    18131843  parameters[numberParameters++]=
    18141844    CbcOrClpParam("extra1","Extra integer parameter 1",
    1815                   -COIN_INT_MAX,COIN_INT_MAX,EXTRA1,false);
     1845                  -COIN_INT_MAX,COIN_INT_MAX,EXTRA1,0);
    18161846  parameters[numberParameters-1].setIntValue(-1);
    18171847  parameters[numberParameters++]=
    18181848    CbcOrClpParam("extra2","Extra integer parameter 2",
    1819                   -100,COIN_INT_MAX,EXTRA2,false);
     1849                  -100,COIN_INT_MAX,EXTRA2,0);
    18201850  parameters[numberParameters-1].setIntValue(-1);
    18211851  parameters[numberParameters++]=
    18221852    CbcOrClpParam("extra3","Extra integer parameter 3",
    1823                   -1,COIN_INT_MAX,EXTRA3,false);
    1824   parameters[numberParameters-1].setIntValue(-1);
    1825   parameters[numberParameters++]=
    1826     CbcOrClpParam("depthminibab","Extra integer parameter 4",
    1827                   -COIN_INT_MAX,COIN_INT_MAX,DEPTHMINIBAB,false);
     1853                  -1,COIN_INT_MAX,EXTRA3,0);
    18281854  parameters[numberParameters-1].setIntValue(-1);
    18291855#endif
     
    18421868  parameters[numberParameters++]=
    18431869    CbcOrClpParam("fakeB!ound","All bounds <= this value - DEBUG",
    1844                   1.0,1.0e15,FAKEBOUND,false);
    1845 #ifdef COIN_HAS_CBC
    1846   parameters[numberParameters++]=
    1847     CbcOrClpParam("fakeC!utoff","Fake cutoff for use in feasibility pump",
    1848                   -COIN_DBL_MAX,COIN_DBL_MAX,FAKECUTOFF);
    1849   parameters[numberParameters-1].setDoubleValue(0.0);
    1850   parameters[numberParameters-1].setLonghelp
    1851     (
    1852      "0.0 off - otherwise add a constraint forcing objective below this value\
    1853  in feasibility pump"
    1854      );
    1855   parameters[numberParameters++]=
    1856     CbcOrClpParam("fakeI!ncrement","Fake increment for use in feasibility pump",
    1857                   -COIN_DBL_MAX,COIN_DBL_MAX,FAKEINCREMENT,false);
    1858   parameters[numberParameters-1].setDoubleValue(0.0);
    1859   parameters[numberParameters-1].setLonghelp
    1860     (
    1861      "0.0 off - otherwise use as absolute increment to cutoff \
    1862 when solution found in feasibility pump"
    1863      );
     1870                  1.0,1.0e15,FAKEBOUND,0);
     1871#ifdef COIN_HAS_CBC
    18641872  parameters[numberParameters++]=
    18651873    CbcOrClpParam("feas!ibilityPump","Whether to try Feasibility Pump",
     
    18781886    CbcOrClpParam("fix!OnDj","Try heuristic based on fixing variables with \
    18791887reduced costs greater than this",
    1880                   -1.0e20,1.0e20,DJFIX,false);
     1888                  -1.0e20,1.0e20,DJFIX,1);
    18811889  parameters[numberParameters-1].setLonghelp
    18821890    (
     
    19061914     "-1 off.  If 1 then tries to branch to solution given by AMPL or priorities file. \
    19071915If 0 then just tries to set as best solution \
    1908 If 1 then also does that many nodes on fixed problem."
     1916If >1 then also does that many nodes on fixed problem."
    19091917     );
    19101918  parameters[numberParameters++]=
    19111919    CbcOrClpParam("fraction!forBAB","Fraction in feasibility pump",
    1912                   1.0e-5,1.1,SMALLBAB,false);
     1920                  1.0e-5,1.1,SMALLBAB,1);
    19131921  parameters[numberParameters-1].setDoubleValue(0.5);
    19141922  parameters[numberParameters-1].setLonghelp
     
    19211929  parameters[numberParameters++]=
    19221930    CbcOrClpParam("gamma!(Delta)","Whether to regularize barrier",
    1923                   "off",GAMMA,7,false);
     1931                  "off",GAMMA,7,1);
    19241932  parameters[numberParameters-1].append("on");
    19251933  parameters[numberParameters-1].append("gamma");
     
    19841992  parameters[numberParameters++]=
    19851993    CbcOrClpParam("hOp!tions","Heuristic options",
    1986                   -9999999,9999999,HOPTIONS);
     1994                  -9999999,9999999,HOPTIONS,1);
    19871995  parameters[numberParameters-1].setLonghelp
    19881996    (
     
    19962004  parameters[numberParameters++]=
    19972005    CbcOrClpParam("hot!StartMaxIts","Maximum iterations on hot start",
    1998                   0,COIN_INT_MAX,MAXHOTITS,false);
     2006                  0,COIN_INT_MAX,MAXHOTITS);
    19992007#endif
    20002008#ifdef COIN_HAS_CLP
     
    20182026 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    20192027 is initialized to '', i.e. it must be set.  If you have libgz then it can read compressed\
    2020  files 'xxxxxxxx.gz'.."
     2028 files 'xxxxxxxx.gz' or 'xxxxxxxx.bz2'.  \
     2029If 'keepnames' is off, then names are dropped -> Rnnnnnnn and Cnnnnnnn."
    20212030     );
    20222031#ifdef COIN_HAS_CBC
     
    20352044    CbcOrClpParam("inf!easibilityWeight","Each integer infeasibility is expected \
    20362045to cost this much",
    2037                   0.0,1.0e20,INFEASIBILITYWEIGHT);
     2046                  0.0,1.0e20,INFEASIBILITYWEIGHT,1);
    20382047  parameters[numberParameters-1].setLonghelp
    20392048    (
     
    20692078  parameters[numberParameters++]=
    20702079    CbcOrClpParam("KKT","Whether to use KKT factorization",
    2071                   "off",KKT,7,false);
     2080                  "off",KKT,7,1);
    20722081  parameters[numberParameters-1].append("on");
    20732082#endif
     
    21532162     "This can be used for testing purposes.  The corresponding library call\n\
    21542163      \tsetMaximumIterations(value)\n can be useful.  If the code stops on\
    2155  seconds or by an interrupt this will be treated as stopping on maximum iterations"
     2164 seconds or by an interrupt this will be treated as stopping on maximum iterations.  This is ignored in branchAndCut - use maxN!odes."
    21562165     );
    21572166#endif
     
    21702179  parameters[numberParameters-1].setLonghelp
    21712180    (
    2172      "You may want to stop after (say) two solutions or an hour."
     2181     "You may want to stop after (say) two solutions or an hour.  \
     2182This is checked every node in tree, so it is possible to get more solutions from heuristics."
    21732183     );
    21742184#endif
     
    21852195  parameters[numberParameters++]=
    21862196    CbcOrClpParam("mipO!ptions","Dubious options for mip",
    2187                   0,COIN_INT_MAX,MIPOPTIONS,false);
     2197                  0,COIN_INT_MAX,MIPOPTIONS,0);
    21882198  parameters[numberParameters++]=
    21892199    CbcOrClpParam("more!MipOptions","More dubious options for mip",
    2190                   -1,COIN_INT_MAX,MOREMIPOPTIONS,false);
     2200                  -1,COIN_INT_MAX,MOREMIPOPTIONS,0);
    21912201  parameters[numberParameters++]=
    21922202    CbcOrClpParam("mixed!IntegerRoundingCuts","Whether to use Mixed Integer Rounding cuts",
     
    22132223but this program turns this off to make it look more friendly.  It can be useful\
    22142224 to turn them back on if you want to be able to 'grep' for particular messages or if\
    2215  you intend to override the behavior of a particular message."
     2225 you intend to override the behavior of a particular message.  This only affects Clp not Cbc."
    22162226     );
    22172227#ifdef COIN_HAS_CBC
    22182228  parameters[numberParameters++]=
    22192229    CbcOrClpParam("miplib","Do some of miplib test set",
    2220                   MIPLIB,3);
     2230                  MIPLIB,3,1);
    22212231  parameters[numberParameters++]=
    22222232      CbcOrClpParam("naive!Heuristics","Whether to try some stupid heuristic",
    2223                     "off",NAIVE);
     2233                    "off",NAIVE,7,1);
    22242234  parameters[numberParameters-1].append("on");
    22252235  parameters[numberParameters-1].append("both");
     
    22282238    (
    22292239     "Really silly stuff e.g. fix all integers with costs to zero!. \
    2230 Do options does heuristic before preprocessing"     );
     2240Doh option does heuristic before preprocessing"     );
    22312241#endif
    22322242#ifdef COIN_HAS_CLP
    22332243  parameters[numberParameters++]=
    22342244    CbcOrClpParam("netlib","Solve entire netlib test set",
    2235                   NETLIB_EITHER,3);
     2245                  NETLIB_EITHER,3,1);
    22362246  parameters[numberParameters-1].setLonghelp
    22372247    (
     
    22392249The user can set options before e.g. clp -presolve off -netlib"
    22402250     );
    2241 #ifdef REAL_BARRIER
    22422251  parameters[numberParameters++]=
    22432252    CbcOrClpParam("netlibB!arrier","Solve entire netlib test set with barrier",
    2244                   NETLIB_BARRIER,3);
     2253                  NETLIB_BARRIER,3,1);
    22452254  parameters[numberParameters-1].setLonghelp
    22462255    (
     
    22482257The user can set options before e.g. clp -kkt on -netlib"
    22492258     );
    2250 #endif
    22512259  parameters[numberParameters++]=
    22522260    CbcOrClpParam("netlibD!ual","Solve entire netlib test set (dual)",
    2253                   NETLIB_DUAL,3);
     2261                  NETLIB_DUAL,3,1);
    22542262  parameters[numberParameters-1].setLonghelp
    22552263    (
     
    22592267  parameters[numberParameters++]=
    22602268    CbcOrClpParam("netlibP!rimal","Solve entire netlib test set (primal)",
    2261                   NETLIB_PRIMAL,3);
     2269                  NETLIB_PRIMAL,3,1);
    22622270  parameters[numberParameters-1].setLonghelp
    22632271    (
     
    22672275  parameters[numberParameters++]=
    22682276    CbcOrClpParam("netlibT!une","Solve entire netlib test set with 'best' algorithm",
    2269                   NETLIB_TUNE,3);
     2277                  NETLIB_TUNE,3,1);
    22702278  parameters[numberParameters-1].setLonghelp
    22712279    (
     
    22772285  parameters[numberParameters++]=
    22782286    CbcOrClpParam("network","Tries to make network matrix",
    2279                   NETWORK,7,false);
     2287                  NETWORK,7,0);
    22802288  parameters[numberParameters-1].setLonghelp
    22812289    (
     
    23042312  parameters[numberParameters++]=
    23052313    CbcOrClpParam("numberA!nalyze","Number of analysis iterations",
    2306                   -COIN_INT_MAX,COIN_INT_MAX,NUMBERANALYZE,false);
     2314                  -COIN_INT_MAX,COIN_INT_MAX,NUMBERANALYZE,0);
    23072315  parameters[numberParameters-1].setLonghelp
    23082316    (
     
    23132321  parameters[numberParameters++]=
    23142322    CbcOrClpParam("objective!Scale","Scale factor to apply to objective",
    2315                   -1.0e20,1.0e20,OBJSCALE,false);
     2323                  -1.0e20,1.0e20,OBJSCALE,1);
    23162324  parameters[numberParameters-1].setLonghelp
    23172325    (
    23182326     "If the objective function has some very large values, you may wish to scale them\
    2319  internally by this amount.  It can also be set by autoscale.  It is applied after scaling"
     2327 internally by this amount.  It can also be set by autoscale.  It is applied after scaling.  You are unlikely to need this."
    23202328     );
    23212329  parameters[numberParameters-1].setDoubleValue(1.0);
     
    23242332  parameters[numberParameters++]=
    23252333    CbcOrClpParam("outDup!licates","takes duplicate rows etc out of integer model",
    2326                   OUTDUPROWS,7,false);
     2334                  OUTDUPROWS,7,0);
    23272335#endif
    23282336  parameters[numberParameters++]=
     
    23592367  parameters[numberParameters++]=
    23602368    CbcOrClpParam("passP!resolve","How many passes in presolve",
    2361                   -200,100,PRESOLVEPASS,false);
     2369                  -200,100,PRESOLVEPASS,1);
    23622370  parameters[numberParameters-1].setLonghelp
    23632371    (
     
    23792387  parameters[numberParameters++]=
    23802388    CbcOrClpParam("pertV!alue","Method of perturbation",
    2381                   -5000,102,PERTVALUE,false);
     2389                  -5000,102,PERTVALUE,1);
    23822390  parameters[numberParameters++]=
    23832391    CbcOrClpParam("perturb!ation","Whether to perturb problem",
     
    23932401  parameters[numberParameters++]=
    23942402    CbcOrClpParam("PFI","Whether to use Product Form of Inverse in simplex",
    2395                   "off",PFI,7,false);
     2403                  "off",PFI,7,0);
    23962404  parameters[numberParameters-1].append("on");
    23972405  parameters[numberParameters-1].setLonghelp
     
    24102418    (
    24112419     "stuff needed. \
    2412 Do options does heuristic before preprocessing"     );
     2420Doh option does heuristic before preprocessing"     );
    24132421#endif
    24142422#ifdef COIN_HAS_CLP
    24152423  parameters[numberParameters++]=
    24162424    CbcOrClpParam("plus!Minus","Tries to make +- 1 matrix",
    2417                   PLUSMINUS,7,false);
     2425                  PLUSMINUS,7,0);
    24182426  parameters[numberParameters-1].setLonghelp
    24192427    (
     
    24242432  parameters[numberParameters++]=
    24252433    CbcOrClpParam("pO!ptions","Dubious print options",
    2426                   0,COIN_INT_MAX,PRINTOPTIONS,false);
     2434                  0,COIN_INT_MAX,PRINTOPTIONS,1);
    24272435  parameters[numberParameters-1].setIntValue(0);
    24282436  parameters[numberParameters-1].setLonghelp
     
    24322440  parameters[numberParameters++]=
    24332441    CbcOrClpParam("preO!pt","Presolve options",
    2434                   0,COIN_INT_MAX,PRESOLVEOPTIONS,false);
     2442                  0,COIN_INT_MAX,PRESOLVEOPTIONS,0);
    24352443#endif
    24362444  parameters[numberParameters++]=
     
    24832491  parameters[numberParameters++]=
    24842492    CbcOrClpParam("primalP!ivot","Primal pivot choice algorithm",
    2485                   "auto!matic",PRIMALPIVOT);
     2493                  "auto!matic",PRIMALPIVOT,7,1);
    24862494  parameters[numberParameters-1].append("exa!ct");
    24872495  parameters[numberParameters-1].append("dant!zig");
     
    25952603     );
    25962604  parameters[numberParameters++]=
     2605    CbcOrClpParam("pumpC!utoff","Fake cutoff for use in feasibility pump",
     2606                  -COIN_DBL_MAX,COIN_DBL_MAX,FAKECUTOFF);
     2607  parameters[numberParameters-1].setDoubleValue(0.0);
     2608  parameters[numberParameters-1].setLonghelp
     2609    (
     2610     "0.0 off - otherwise add a constraint forcing objective below this value\
     2611 in feasibility pump"
     2612     );
     2613  parameters[numberParameters++]=
     2614    CbcOrClpParam("pumpI!ncrement","Fake increment for use in feasibility pump",
     2615                  -COIN_DBL_MAX,COIN_DBL_MAX,FAKEINCREMENT,1);
     2616  parameters[numberParameters-1].setDoubleValue(0.0);
     2617  parameters[numberParameters-1].setLonghelp
     2618    (
     2619     "0.0 off - otherwise use as absolute increment to cutoff \
     2620when solution found in feasibility pump"
     2621     );
     2622  parameters[numberParameters++]=
    25972623    CbcOrClpParam("pumpT!une","Dubious ideas for feasibility pump",
    25982624                  0,100000000,FPUMPTUNE);
     
    26022628\t>=1000000 use as accumulate switch\n\
    26032629\t>=1000 use index+1 as number of large loops\n\
    2604 \t==100 use objvalue +0.05*fabs(objvalue) as cutoff OR dextra1 if set\n\
     2630\t==100 use objvalue +0.05*fabs(objvalue) as cutoff OR fakeCutoff if set\n\
    26052631\t%100 == 10,20 etc for experimentation\n\
    26062632\t1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds"
     
    26252651    (
    26262652     "stuff needed. \
    2627 Do options does heuristic before preprocessing"     );
     2653Doh option does heuristic before preprocessing"     );
    26282654  parameters[numberParameters++]=
    26292655    CbcOrClpParam("ratio!Gap","Stop when gap between best possible and \
     
    26392665  parameters[numberParameters++]=
    26402666    CbcOrClpParam("readS!tored","Import stored cuts from file",
    2641                   STOREDFILE,3,false);
     2667                  STOREDFILE,3,0);
    26422668#endif
    26432669#ifdef COIN_HAS_CLP
    26442670  parameters[numberParameters++]=
    26452671    CbcOrClpParam("reallyO!bjectiveScale","Scale factor to apply to objective in place",
    2646                   -1.0e20,1.0e20,OBJSCALE2,false);
     2672                  -1.0e20,1.0e20,OBJSCALE2,0);
    26472673  parameters[numberParameters-1].setLonghelp
    26482674    (
     
    26522678  parameters[numberParameters++]=
    26532679    CbcOrClpParam("reallyS!cale","Scales model in place",
    2654                   REALLY_SCALE,7,false);
     2680                  REALLY_SCALE,7,0);
    26552681#endif
    26562682#ifdef COIN_HAS_CBC
     
    26832709  parameters[numberParameters++]=
    26842710    CbcOrClpParam("restore!Model","Restore model from binary file",
    2685                   RESTORE);
     2711                  RESTORE,7,1);
    26862712  parameters[numberParameters-1].setLonghelp
    26872713    (
     
    26922718  parameters[numberParameters++]=
    26932719    CbcOrClpParam("reverse","Reverses sign of objective",
    2694                   REVERSE,7,false);
     2720                  REVERSE,7,0);
    26952721  parameters[numberParameters-1].setLonghelp
    26962722    (
     
    26992725  parameters[numberParameters++]=
    27002726    CbcOrClpParam("rhs!Scale","Scale factor to apply to rhs and bounds",
    2701                   -1.0e20,1.0e20,RHSSCALE,false);
     2727                  -1.0e20,1.0e20,RHSSCALE,0);
    27022728  parameters[numberParameters-1].setLonghelp
    27032729    (
    27042730     "If the rhs or bounds have some very large meaningful values, you may wish to scale them\
    2705  internally by this amount.  It can also be set by autoscale"
     2731 internally by this amount.  It can also be set by autoscale.  This should not be needed."
    27062732     );
    27072733  parameters[numberParameters-1].setDoubleValue(1.0);
     
    27202746    (
    27212747     "This switches on Relaxation enforced neighborhood Search. \
    2722 on just does feasibility pump \
     2748on just does 50 nodes \
    27232749200 or 1000 does that many nodes. \
    2724 Do options does heuristic before preprocessing"     );
     2750Doh option does heuristic before preprocessing"     );
    27252751  parameters[numberParameters++]=
    27262752      CbcOrClpParam("Rins","Whether to try Relaxed Induced Neighborhood Search",
     
    27332759    (
    27342760     "This switches on Relaxed induced neighborhood Search. \
    2735 Do options does heuristic before preprocessing"     );
     2761Doh option does heuristic before preprocessing"     );
    27362762  parameters[numberParameters++]=
    27372763    CbcOrClpParam("round!ingHeuristic","Whether to use Rounding heuristic",
     
    27512777  parameters[numberParameters++]=
    27522778    CbcOrClpParam("saveM!odel","Save model to binary file",
    2753                   SAVE);
     2779                  SAVE,7,1);
    27542780  parameters[numberParameters-1].setLonghelp
    27552781    (
     
    27922818    (
    27932819     "After this many seconds clp will act as if maximum iterations had been reached \
    2794 (if value >=0).  \
    2795 In this program it is really only useful for testing but the library function\n\
    2796       \tsetMaximumSeconds(value)\n can be useful."
     2820(if value >=0)."
    27972821     );
    27982822#else
     
    28072831  parameters[numberParameters++]=
    28082832    CbcOrClpParam("sleep","for debug",
    2809                   DUMMY,7,false);
     2833                  DUMMY,7,0);
    28102834  parameters[numberParameters-1].setLonghelp
    28112835    (
     
    28152839  parameters[numberParameters++]=
    28162840    CbcOrClpParam("slp!Value","Number of slp passes before primal",
    2817                   -1,50000,SLPVALUE,false);
     2841                  -1,50000,SLPVALUE,1);
    28182842  parameters[numberParameters-1].setLonghelp
    28192843    (
     
    28242848  parameters[numberParameters++]=
    28252849    CbcOrClpParam("small!Factorization","Whether to use small factorization",
    2826                   -1,10000,SMALLFACT,false);
     2850                  -1,10000,SMALLFACT,1);
    28272851  parameters[numberParameters-1].setLonghelp
    28282852    (
     
    28832907  parameters[numberParameters++]=
    28842908    CbcOrClpParam("spars!eFactor","Whether factorization treated as sparse",
    2885                   "on",SPARSEFACTOR,7,false);
     2909                  "on",SPARSEFACTOR,7,0);
    28862910  parameters[numberParameters-1].append("off");
    28872911  parameters[numberParameters++]=
    28882912    CbcOrClpParam("special!Options","Dubious options for Simplex - see ClpSimplex.hpp",
    2889                   0,COIN_INT_MAX,SPECIALOPTIONS,false);
     2913                  0,COIN_INT_MAX,SPECIALOPTIONS,0);
    28902914  parameters[numberParameters++]=
    28912915    CbcOrClpParam("sprint!Crash","Whether to try sprint crash",
     
    29542978  parameters[numberParameters++]=
    29552979    CbcOrClpParam("subs!titution","How long a column to substitute for in presolve",
    2956                   0,10000,SUBSTITUTION,false);
     2980                  0,10000,SUBSTITUTION,0);
    29572981  parameters[numberParameters-1].setLonghelp
    29582982    (
     
    29652989  parameters[numberParameters++]=
    29662990    CbcOrClpParam("testO!si","Test OsiObject stuff",
    2967                   -1,COIN_INT_MAX,TESTOSI,false);
     2991                  -1,COIN_INT_MAX,TESTOSI,0);
    29682992#endif
    29692993#ifdef CBC_THREAD
    29702994  parameters[numberParameters++]=
    29712995    CbcOrClpParam("thread!s","Number of threads to try and use",
    2972                   -100,100000,THREADS,false);
     2996                  -100,100000,THREADS,1);
    29732997  parameters[numberParameters-1].setLonghelp
    29742998    (
     
    29833007    CbcOrClpParam("tighten!Factor","Tighten bounds using this times largest \
    29843008activity at continuous solution",
    2985                   1.0e-3,1.0e20,TIGHTENFACTOR,false);
     3009                  1.0e-3,1.0e20,TIGHTENFACTOR,0);
    29863010  parameters[numberParameters-1].setLonghelp
    29873011    (
     
    29923016  parameters[numberParameters++]=
    29933017    CbcOrClpParam("tightLP","Poor person's preSolve for now",
    2994                   TIGHTEN,7,false);
     3018                  TIGHTEN,7,0);
    29953019#endif
    29963020#ifdef COIN_HAS_CBC
     
    30073031  parameters[numberParameters++]=
    30083032    CbcOrClpParam("tune!PreProcess","Dubious tuning parameters",
    3009                   0,20000000,PROCESSTUNE,false);
     3033                  0,20000000,PROCESSTUNE,1);
    30103034  parameters[numberParameters-1].setLonghelp
    30113035    (
     
    30363060  parameters[numberParameters++]=
    30373061    CbcOrClpParam("unitTest","Do unit test",
    3038                   UNITTEST,3);
     3062                  UNITTEST,3,1);
    30393063  parameters[numberParameters-1].setLonghelp
    30403064    (
     
    30433067  parameters[numberParameters++]=
    30443068    CbcOrClpParam("userClp","Hand coded Clp stuff",
    3045                   USERCLP);
     3069                  USERCLP,0,0);
    30463070  parameters[numberParameters-1].setLonghelp
    30473071    (
     
    30523076  parameters[numberParameters++]=
    30533077    CbcOrClpParam("userCbc","Hand coded Cbc stuff",
    3054                   USERCBC);
     3078                  USERCBC,0,0);
    30553079  parameters[numberParameters-1].setLonghelp
    30563080    (
    30573081     "There are times e.g. when using AMPL interface when you may wish to do something unusual.  \
    3058 Look for USERCBC in main driver and modify sample code."
     3082Look for USERCBC in main driver and modify sample code. \
     3083It is possible you can get same effect by using example driver4.cpp."
    30593084     );
    30603085#endif
    30613086  parameters[numberParameters++]=
    30623087    CbcOrClpParam("vector","Whether to use vector? Form of matrix in simplex",
    3063                   "off",VECTOR,7,false);
    3064   parameters[numberParameters-1].append("on");
    3065   parameters[numberParameters-1].setLonghelp
    3066     (
    3067      "If this is on and ClpPackedMatrix uses extra column copy in odd format."
     3088                  "off",VECTOR,7,0);
     3089  parameters[numberParameters-1].append("on");
     3090  parameters[numberParameters-1].setLonghelp
     3091    (
     3092     "If this is on ClpPackedMatrix uses extra column copy in odd format."
    30683093     );
    30693094  parameters[numberParameters++]=
    30703095    CbcOrClpParam("verbose","Switches on longer help on single ?",
    3071                   0,15,VERBOSE,false);
     3096                  0,31,VERBOSE,0);
    30723097  parameters[numberParameters-1].setLonghelp
    30733098    (
     
    30783103  parameters[numberParameters++]=
    30793104    CbcOrClpParam("vub!heuristic","Type of vub heuristic",
    3080                   -2,20,VUBTRY,false);
     3105                  -2,20,VUBTRY,0);
    30813106  parameters[numberParameters-1].setLonghelp
    30823107    (
     
    30843109     );
    30853110  parameters[numberParameters-1].setIntValue(-1);
     3111#if 0
    30863112  parameters[numberParameters++]=
    30873113    CbcOrClpParam("zero!HalfCuts","Whether to use zero half cuts",
     
    30953121  parameters[numberParameters-1].setLonghelp
    30963122    (
    3097      "This switches on knapsack cuts (either at root or in entire tree) \
     3123     "This switches on zero-half cuts (either at root or in entire tree) \
    30983124See branchAndCut for information on options."
    3099      );
     3125     );
     3126#endif
    31003127#endif
    31013128  assert(numberParameters<CBCMAXPARAMETERS);
     
    31273154    int numberColumnsFile;
    31283155    double objectiveValue;
    3129     fread(&numberRowsFile,sizeof(int),1,fp);
    3130     fread(&numberColumnsFile,sizeof(int),1,fp);
    3131     fread(&objectiveValue,sizeof(double),1,fp);
     3156    int nRead;
     3157    nRead=fread(&numberRowsFile,sizeof(int),1,fp);
     3158    if (nRead!=1)
     3159      throw("Error in fread");
     3160    nRead=fread(&numberColumnsFile,sizeof(int),1,fp);
     3161    if (nRead!=1)
     3162      throw("Error in fread");
     3163    nRead=fread(&objectiveValue,sizeof(double),1,fp);
     3164    if (nRead!=1)
     3165      throw("Error in fread");
    31323166    double * dualRowSolution = lpSolver->dualRowSolution();
    31333167    double * primalRowSolution = lpSolver->primalRowSolution();
     
    31523186      lpSolver->setObjectiveValue(objectiveValue);
    31533187      if (numberRows==numberRowsFile&&numberColumns==numberColumnsFile) {
    3154         fread(primalRowSolution,sizeof(double),numberRows,fp);
    3155         fread(dualRowSolution,sizeof(double),numberRows,fp);
    3156         fread(primalColumnSolution,sizeof(double),numberColumns,fp);
    3157         fread(dualColumnSolution,sizeof(double),numberColumns,fp);
     3188        nRead=fread(primalRowSolution,sizeof(double),numberRows,fp);
     3189        if (nRead!=numberRows)
     3190          throw("Error in fread");
     3191        nRead=fread(dualRowSolution,sizeof(double),numberRows,fp);
     3192        if (nRead!=numberRows)
     3193          throw("Error in fread");
     3194        nRead=fread(primalColumnSolution,sizeof(double),numberColumns,fp);
     3195        if (nRead!=numberColumns)
     3196          throw("Error in fread");
     3197        nRead=fread(dualColumnSolution,sizeof(double),numberColumns,fp);
     3198        if (nRead!=numberColumns)
     3199          throw("Error in fread");
    31583200      } else {
    31593201        std::cout<<"Mismatch on rows and/or columns - truncating"<<std::endl;
    31603202        double * temp = new double [CoinMax(numberRowsFile,numberColumnsFile)];
    3161         fread(temp,sizeof(double),numberRowsFile,fp);
    3162  CoinMemcpyN(temp,numberRows,primalRowSolution);
    3163         fread(temp,sizeof(double),numberRowsFile,fp);
    3164  CoinMemcpyN(temp,numberRows,dualRowSolution);
    3165         fread(temp,sizeof(double),numberColumnsFile,fp);
    3166  CoinMemcpyN(temp,numberColumns,primalColumnSolution);
    3167         fread(temp,sizeof(double),numberColumnsFile,fp);
    3168  CoinMemcpyN(temp,numberColumns,dualColumnSolution);
     3203        nRead=fread(temp,sizeof(double),numberRowsFile,fp);
     3204        if (nRead!=numberRowsFile)
     3205          throw("Error in fread");
     3206        CoinMemcpyN(temp,numberRows,primalRowSolution);
     3207        nRead=fread(temp,sizeof(double),numberRowsFile,fp);
     3208        if (nRead!=numberRowsFile)
     3209          throw("Error in fread");
     3210        CoinMemcpyN(temp,numberRows,dualRowSolution);
     3211        nRead=fread(temp,sizeof(double),numberColumnsFile,fp);
     3212        if (nRead!=numberColumnsFile)
     3213          throw("Error in fread");
     3214        CoinMemcpyN(temp,numberColumns,primalColumnSolution);
     3215        nRead=fread(temp,sizeof(double),numberColumnsFile,fp);
     3216        if (nRead!=numberColumnsFile)
     3217          throw("Error in fread");
     3218        CoinMemcpyN(temp,numberColumns,dualColumnSolution);
    31693219        delete [] temp;
    31703220      }
     
    32263276    int numberColumns=lpSolver->numberColumns();
    32273277    double objectiveValue = lpSolver->objectiveValue();
    3228     fwrite(&numberRows,sizeof(int),1,fp);
    3229     fwrite(&numberColumns,sizeof(int),1,fp);
    3230     fwrite(&objectiveValue,sizeof(double),1,fp);
     3278    int nWrite;
     3279    nWrite=fwrite(&numberRows,sizeof(int),1,fp);
     3280    if (nWrite!=1)
     3281      throw("Error in fwrite");
     3282    nWrite=fwrite(&numberColumns,sizeof(int),1,fp);
     3283    if (nWrite!=1)
     3284      throw("Error in fwrite");
     3285    nWrite=fwrite(&objectiveValue,sizeof(double),1,fp);
     3286    if (nWrite!=1)
     3287      throw("Error in fwrite");
    32313288    double * dualRowSolution = lpSolver->dualRowSolution();
    32323289    double * primalRowSolution = lpSolver->primalRowSolution();
    3233     fwrite(primalRowSolution,sizeof(double),numberRows,fp);
    3234     fwrite(dualRowSolution,sizeof(double),numberRows,fp);
     3290    nWrite=fwrite(primalRowSolution,sizeof(double),numberRows,fp);
     3291    if (nWrite!=numberRows)
     3292      throw("Error in fwrite");
     3293    nWrite=fwrite(dualRowSolution,sizeof(double),numberRows,fp);
     3294    if (nWrite!=numberRows)
     3295      throw("Error in fwrite");
    32353296    double * dualColumnSolution = lpSolver->dualColumnSolution();
    32363297    double * primalColumnSolution = lpSolver->primalColumnSolution();
    3237     fwrite(primalColumnSolution,sizeof(double),numberColumns,fp);
    3238     fwrite(dualColumnSolution,sizeof(double),numberColumns,fp);
     3298    nWrite=fwrite(primalColumnSolution,sizeof(double),numberColumns,fp);
     3299    if (nWrite!=numberColumns)
     3300      throw("Error in fwrite");
     3301    nWrite=fwrite(dualColumnSolution,sizeof(double),numberColumns,fp);
     3302    if (nWrite!=numberColumns)
     3303      throw("Error in fwrite");
    32393304    fclose(fp);
    32403305  } else {
  • trunk/Clp/src/CbcOrClpParam.hpp

    r1401 r1402  
    7676    PRIMALPIVOT,PRESOLVE,CRASH,BIASLU,PERTURBATION,MESSAGES,AUTOSCALE,
    7777    CHOLESKY,KKT,BARRIERSCALE,GAMMA,CROSSOVER,PFI,INTPRINT,VECTOR,
    78     FACTORIZATION,
     78    FACTORIZATION,ALLCOMMANDS,
    7979   
    8080    NODESTRATEGY = 251,BRANCHSTRATEGY,CUTSSTRATEGY,HEURISTICSTRATEGY,
     
    109109  CbcOrClpParam (  );
    110110  CbcOrClpParam (std::string name, std::string help,
    111            double lower, double upper, CbcOrClpParameterType type,bool display=true);
     111           double lower, double upper, CbcOrClpParameterType type,int display=2);
    112112  CbcOrClpParam (std::string name, std::string help,
    113            int lower, int upper, CbcOrClpParameterType type,bool display=true);
     113           int lower, int upper, CbcOrClpParameterType type,int display=2);
    114114  // Other strings will be added by insert
    115115  CbcOrClpParam (std::string name, std::string help, std::string firstValue,
    116            CbcOrClpParameterType type,int whereUsed=7,bool display=true);
     116           CbcOrClpParameterType type,int whereUsed=7,int display=2);
    117117  // Action
    118118  CbcOrClpParam (std::string name, std::string help,
    119            CbcOrClpParameterType type,int whereUsed=7,bool display=true);
     119           CbcOrClpParameterType type,int whereUsed=7,int display=2);
    120120  /// Copy constructor.
    121121  CbcOrClpParam(const CbcOrClpParam &);
     
    180180  /// Returns name which could match
    181181  std::string matchName (  ) const;
     182  /// Returns length of name for ptinting
     183  int lengthMatchName (  ) const;
    182184  /// Returns parameter option which matches (-1 if none)
    183185  int parameterOption ( std::string check ) const;
     
    214216  { return type_;}
    215217  /// whether to display
    216   inline bool displayThis() const
     218  inline int displayThis() const
    217219  { return display_;}
    218220  /// Set Long help
     
    267269  int currentKeyWord_;
    268270  /// Display on ?
    269   bool display_;
     271  int display_;
    270272  /// Integer parameter - current value
    271273  int intValue_;
  • trunk/Clp/src/ClpCholeskyBase.cpp

    r1371 r1402  
    11861186 }
    11871187 while (counter <= n) {
    1188      for (deg = mindeg; head[deg - 1] < 1; deg++);
     1188   for (deg = mindeg; head[deg - 1] < 1; deg++) {};
    11891189     nodeg = 0;
    11901190#ifdef WSSMP_DBG
     
    17051705 for (l = 1; l <= n; l++) {
    17061706   if (!invp[l - 1]) {
    1707      for (i = -xadj[l - 1]; invp[i - 1] >= 0; i = -xadj[i - 1]);
     1707     for (i = -xadj[l - 1]; invp[i - 1] >= 0; i = -xadj[i - 1]){};
    17081708       tn = i;
    17091709#ifdef WSSMP_DBG
     
    35323532    // do dense
    35333533    // update dense part
    3534     updateDense(d,work,first);
     3534    updateDense(d,/*work,*/first);
    35353535    ClpCholeskyDense dense;
    35363536    // just borrow space
     
    35703570}
    35713571// Updates dense part (broken out for profiling)
    3572 void ClpCholeskyBase::updateDense(longDouble * d, longDouble * work, int * first)
     3572void ClpCholeskyBase::updateDense(longDouble * d, /*longDouble * work,*/ int * first)
    35733573{
    35743574  for (int iRow=0;iRow<firstDense_;iRow++) {
  • trunk/Clp/src/ClpCholeskyBase.hpp

    r1371 r1402  
    195195  int preOrder(bool lowerTriangular, bool includeDiagonal, bool doKKT);
    196196  /// Updates dense part (broken out for profiling)
    197   void updateDense(longDouble * d, longDouble * work, int * first);
     197  void updateDense(longDouble * d, /*longDouble * work,*/ int * first);
    198198  //@}
    199199   
  • trunk/Clp/src/ClpCholeskyDense.cpp

    r1371 r1402  
    687687{
    688688  if (nThis<=BLOCK&&nLeft<=BLOCK) {
    689     ClpCholeskyCtriRecLeaf(thisStruct, aTri,aUnder,diagonal,work,nLeft);
     689    ClpCholeskyCtriRecLeaf(/*thisStruct,*/ aTri,aUnder,diagonal,work,nLeft);
    690690  } else if (nThis<nLeft) {
    691691    int nb=number_blocks((nLeft+1)>>1);
     
    722722{
    723723  if (nTri<=BLOCK&&nDo<=BLOCK) {
    724     ClpCholeskyCrecTriLeaf(thisStruct, aUnder,aTri,diagonal,work,nTri);
     724    ClpCholeskyCrecTriLeaf(/*thisStruct,*/ aUnder,aTri,/*diagonal,*/work,nTri);
    725725  } else if (nTri<nDo) {
    726726    int nb=number_blocks((nDo+1)>>1);
     
    763763  if (nDo<=BLOCK&&nUnder<=BLOCK&&nUnderK<=BLOCK) {
    764764    assert (nDo==BLOCK&&nUnder==BLOCK);
    765     ClpCholeskyCrecRecLeaf(thisStruct, above , aUnder ,  aOther, work, nUnderK);
     765    ClpCholeskyCrecRecLeaf(/*thisStruct,*/ above , aUnder ,  aOther, work, nUnderK);
    766766  } else if (nDo<=nUnderK&&nUnder<=nUnderK) {
    767767    int nb=number_blocks((nUnderK+1)>>1);
     
    867867  /* Leaf recursive triangle rectangle update*/
    868868void
    869 ClpCholeskyCtriRecLeaf(ClpCholeskyDenseC * thisStruct, longDouble * aTri, longDouble * aUnder, longDouble * diagonal, longDouble * work,
     869ClpCholeskyCtriRecLeaf(/*ClpCholeskyDenseC * thisStruct,*/ longDouble * aTri, longDouble * aUnder, longDouble * diagonal, longDouble * work,
    870870                int nUnder)
    871871{
     
    941941}
    942942  /* Leaf recursive rectangle triangle update*/
    943 void ClpCholeskyCrecTriLeaf(ClpCholeskyDenseC * thisStruct, longDouble * aUnder, longDouble * aTri,
    944                                   longDouble * diagonal, longDouble * work, int nUnder)
     943void ClpCholeskyCrecTriLeaf(/*ClpCholeskyDenseC * thisStruct,*/ longDouble * aUnder, longDouble * aTri,
     944                            /*longDouble * diagonal,*/ longDouble * work, int nUnder)
    945945{
    946946#ifdef POS_DEBUG
     
    10241024*/
    10251025void
    1026 ClpCholeskyCrecRecLeaf(ClpCholeskyDenseC * thisStruct,
     1026ClpCholeskyCrecRecLeaf(/*ClpCholeskyDenseC * thisStruct,*/
    10271027                                         const longDouble * COIN_RESTRICT above,
    10281028                             const longDouble * COIN_RESTRICT aUnder,
  • trunk/Clp/src/ClpCholeskyDense.hpp

    r1371 r1402  
    134134  /**Leaf recursive triangle rectangle update */
    135135  void
    136   ClpCholeskyCtriRecLeaf(ClpCholeskyDenseC * thisStruct,
     136  ClpCholeskyCtriRecLeaf(/*ClpCholeskyDenseC * thisStruct,*/
    137137                         longDouble * aTri, longDouble * aUnder,
    138138                         longDouble * diagonal, longDouble * work,
     
    140140  /**Leaf recursive rectangle triangle update */
    141141  void
    142   ClpCholeskyCrecTriLeaf(ClpCholeskyDenseC * thisStruct,
     142  ClpCholeskyCrecTriLeaf(/*ClpCholeskyDenseC * thisStruct, */
    143143                         longDouble * aUnder, longDouble * aTri,
    144                          longDouble * diagonal, longDouble * work, int nUnder);
     144                         /*longDouble * diagonal,*/ longDouble * work, int nUnder);
    145145  /** Leaf recursive rectangle rectangle update,
    146146      nUnder is number of rows in iBlock,
     
    148148  */
    149149  void
    150   ClpCholeskyCrecRecLeaf(ClpCholeskyDenseC * thisStruct,
     150  ClpCholeskyCrecRecLeaf(/*ClpCholeskyDenseC * thisStruct, */
    151151                         const longDouble * COIN_RESTRICT above,
    152152                         const longDouble * COIN_RESTRICT aUnder,
  • trunk/Clp/src/ClpConstraintLinear.cpp

    r1370 r1402  
    182182*/
    183183int
    184 ClpConstraintLinear::markNonlinear(char * which) const
     184ClpConstraintLinear::markNonlinear(char *) const
    185185{
    186186  return 0;
  • trunk/Clp/src/ClpConstraintQuadratic.cpp

    r1370 r1402  
    227227// Scale constraint
    228228void
    229 ClpConstraintQuadratic::reallyScale(const double * columnScale)
     229ClpConstraintQuadratic::reallyScale(const double * )
    230230{
    231231  abort();
  • trunk/Clp/src/ClpDualRowDantzig.cpp

    r1370 r1402  
    8181// FT update and returns pivot alpha
    8282double
    83 ClpDualRowDantzig::updateWeights(CoinIndexedVector * input,
     83ClpDualRowDantzig::updateWeights(CoinIndexedVector * /*input*/,
    8484                                  CoinIndexedVector * spare,
    85                                  CoinIndexedVector * spare2,
     85                                 CoinIndexedVector * /*spare2*/,
    8686                                  CoinIndexedVector * updatedColumn)
    8787{
  • trunk/Clp/src/ClpDualRowPivot.cpp

    r1370 r1402  
    5252}
    5353void
    54 ClpDualRowPivot::saveWeights(ClpSimplex * model,int mode)
     54ClpDualRowPivot::saveWeights(ClpSimplex * model,int /*mode*/)
    5555{
    5656  model_=model;
  • trunk/Clp/src/ClpDummyMatrix.cpp

    r1370 r1402  
    5050}
    5151
    52 ClpDummyMatrix::ClpDummyMatrix (const CoinPackedMatrix & rhs)
     52ClpDummyMatrix::ClpDummyMatrix (const CoinPackedMatrix & )
    5353  : ClpMatrixBase()
    5454
     
    9696//unscaled versions
    9797void
    98 ClpDummyMatrix::times(double scalar,
    99                    const double * x, double * y) const
     98ClpDummyMatrix::times(double ,
     99                   const double * , double * ) const
    100100{
    101101  std::cerr<<"times not supported - ClpDummyMatrix"<<std::endl;
     
    103103}
    104104void
    105 ClpDummyMatrix::transposeTimes(double scalar,
    106                                 const double * x, double * y) const
     105ClpDummyMatrix::transposeTimes(double ,
     106                                const double * , double * ) const
    107107{
    108108  std::cerr<<"transposeTimes not supported - ClpDummyMatrix"<<std::endl;
     
    110110}
    111111void
    112 ClpDummyMatrix::times(double scalar,
    113                        const double * x, double * y,
    114                        const double * rowScale,
    115                        const double * columnScale) const
     112ClpDummyMatrix::times(double ,
     113                       const double * , double * ,
     114                       const double * ,
     115                       const double * ) const
    116116{
    117117  std::cerr<<"timesnot supported - ClpDummyMatrix"<<std::endl;
     
    119119}
    120120void
    121 ClpDummyMatrix::transposeTimes( double scalar,
    122                                  const double * x, double * y,
    123                                  const double * rowScale,
    124                                  const double * columnScale) const
     121ClpDummyMatrix::transposeTimes( double,
     122                                 const double * , double * ,
     123                                 const double * ,
     124                                 const double * ) const
    125125{
    126126  std::cerr<<"transposeTimesnot supported - ClpDummyMatrix"<<std::endl;
     
    130130        Squashes small elements and knows about ClpSimplex */
    131131void
    132 ClpDummyMatrix::transposeTimes(const ClpSimplex * model, double scalar,
    133                               const CoinIndexedVector * rowArray,
    134                               CoinIndexedVector * y,
    135                               CoinIndexedVector * columnArray) const
     132ClpDummyMatrix::transposeTimes(const ClpSimplex * , double ,
     133                              const CoinIndexedVector * ,
     134                              CoinIndexedVector * ,
     135                              CoinIndexedVector * ) const
    136136{
    137137  std::cerr<<"transposeTimes not supported - ClpDummyMatrix"<<std::endl;
     
    141141   just for indices in y */
    142142void
    143 ClpDummyMatrix::subsetTransposeTimes(const ClpSimplex * model,
    144                               const CoinIndexedVector * rowArray,
    145                               const CoinIndexedVector * y,
    146                               CoinIndexedVector * columnArray) const
     143ClpDummyMatrix::subsetTransposeTimes(const ClpSimplex * ,
     144                              const CoinIndexedVector * ,
     145                              const CoinIndexedVector * ,
     146                              CoinIndexedVector * ) const
    147147{
    148148  std::cerr<<"subsetTransposeTimes not supported - ClpDummyMatrix"<<std::endl;
     
    151151/// returns number of elements in column part of basis,
    152152CoinBigIndex
    153 ClpDummyMatrix::countBasis(ClpSimplex * model,
    154                                  const int * whichColumn,
    155                                  int numberBasic,
    156                            int & numberColumnBasic)
     153ClpDummyMatrix::countBasis(const int * ,
     154                           int & )
    157155{
    158156  std::cerr<<"countBasis not supported - ClpDummyMatrix"<<std::endl;
     
    161159}
    162160void
    163 ClpDummyMatrix::fillBasis(ClpSimplex * model,
    164                          const int * whichColumn,
    165                          int & numberColumnBasic,
    166                          int * row, int * start,
    167                          int * rowCount, int * columnCount,
    168                          CoinFactorizationDouble * element)
     161ClpDummyMatrix::fillBasis(ClpSimplex * ,
     162                         const int * ,
     163                         int & ,
     164                         int * , int * ,
     165                         int * , int * ,
     166                         CoinFactorizationDouble * )
    169167{
    170168  std::cerr<<"fillBasis not supported - ClpDummyMatrix"<<std::endl;
     
    174172 */
    175173void
    176 ClpDummyMatrix::unpack(const ClpSimplex * model,CoinIndexedVector * rowArray,
    177                    int iColumn) const
     174ClpDummyMatrix::unpack(const ClpSimplex * ,CoinIndexedVector * ,
     175                   int ) const
    178176{
    179177  std::cerr<<"unpack not supported - ClpDummyMatrix"<<std::endl;
     
    185183be modified if doing column generation (just for this variable) */
    186184void
    187 ClpDummyMatrix::unpackPacked(ClpSimplex * model,
    188                             CoinIndexedVector * rowArray,
    189                             int iColumn) const
     185ClpDummyMatrix::unpackPacked(ClpSimplex * ,
     186                            CoinIndexedVector * ,
     187                            int ) const
    190188{
    191189  std::cerr<<"unpackPacked not supported - ClpDummyMatrix"<<std::endl;
     
    195193      You can use quickAdd to add to vector */
    196194void
    197 ClpDummyMatrix::add(const ClpSimplex * model,CoinIndexedVector * rowArray,
    198                    int iColumn, double multiplier) const
     195ClpDummyMatrix::add(const ClpSimplex * ,CoinIndexedVector * ,
     196                   int , double ) const
    199197{
    200198  std::cerr<<"add not supported - ClpDummyMatrix"<<std::endl;
     
    203201/* Adds multiple of a column into an array */
    204202void
    205 ClpDummyMatrix::add(const ClpSimplex * model,double * array,
    206                     int column, double multiplier) const
     203ClpDummyMatrix::add(const ClpSimplex * ,double * ,
     204                    int , double ) const
    207205{
    208206  std::cerr<<"add not supported - ClpDummyMatrix"<<std::endl;
     
    246244}
    247245/* Delete the columns whose indices are listed in <code>indDel</code>. */
    248 void ClpDummyMatrix::deleteCols(const int numDel, const int * indDel)
     246void ClpDummyMatrix::deleteCols(const int , const int * )
    249247{
    250248  std::cerr<<"deleteCols not supported - ClpDummyMatrix"<<std::endl;
     
    252250}
    253251/* Delete the rows whose indices are listed in <code>indDel</code>. */
    254 void ClpDummyMatrix::deleteRows(const int numDel, const int * indDel)
     252void ClpDummyMatrix::deleteRows(const int , const int * )
    255253{
    256254  std::cerr<<"deleteRows not supported - ClpDummyMatrix"<<std::endl;
  • trunk/Clp/src/ClpDummyMatrix.hpp

    r1370 r1402  
    5656  virtual ClpMatrixBase * reverseOrderedCopy() const;
    5757  /// Returns number of elements in column part of basis
    58   virtual CoinBigIndex countBasis(ClpSimplex * model,
    59                                  const int * whichColumn,
    60                                  int numberRowBasic,
     58  virtual CoinBigIndex countBasis(const int * whichColumn,
    6159                                  int & numberColumnBasic);
    6260  /// Fills in column part of basis
  • trunk/Clp/src/ClpDynamicMatrix.cpp

    r1370 r1402  
    569569double *
    570570ClpDynamicMatrix::rhsOffset(ClpSimplex * model,bool forceRefresh,
    571                       bool check)
     571                      bool
     572#ifdef CLP_DEBUG
     573 check
     574#endif
     575)
    572576{
    573577  //forceRefresh=true;
     
    892896void
    893897ClpDynamicMatrix::dualExpanded(ClpSimplex * model,
    894                             CoinIndexedVector * array,
    895                             double * other,int mode)
     898                               CoinIndexedVector * /*array*/,
     899                               double * /*other*/,int mode)
    896900{
    897901  switch (mode) {
  • trunk/Clp/src/ClpDynamicMatrix.hpp

    r1370 r1402  
    103103      Entries at upper bound (really nonzero) never go out (at present).
    104104  */
    105   virtual void packDown(const int * in, int numberToPack) {}
     105  virtual void packDown(const int * , int ) {}
    106106  /// Gets lower bound (to simplify coding)
    107107  inline double columnLower(int sequence) const
  • trunk/Clp/src/ClpFactorization.cpp

    r1401 r1402  
    15091509      int numberColumnBasic = numberBasic-numberRowBasic;
    15101510     
    1511       numberElements +=matrix->countBasis(model,
    1512                                           pivotTemp+numberRowBasic,
    1513                                           numberRowBasic,
     1511      numberElements +=matrix->countBasis(pivotTemp+numberRowBasic,
    15141512                                          numberColumnBasic);
    15151513      // Not needed for dense
     
    19021900        int numberColumnBasic = numberBasic-numberRowBasic;
    19031901
    1904         numberElements +=matrix->countBasis(model,
    1905                                            pivotTemp+numberRowBasic,
    1906                                            numberRowBasic,
     1902        numberElements +=matrix->countBasis( pivotTemp+numberRowBasic,
    19071903                                            numberColumnBasic);
    19081904        // and recompute as network side say different
  • trunk/Clp/src/ClpGubDynamicMatrix.cpp

    r1370 r1402  
    15401540double *
    15411541ClpGubDynamicMatrix::rhsOffset(ClpSimplex * model,bool forceRefresh,
    1542                       bool check)
     1542                      bool
     1543#ifdef CLP_DEBUG
     1544check
     1545#endif
     1546)
    15431547{
    15441548  //forceRefresh=true;
     
    19941998*/
    19951999int
    1996 ClpGubDynamicMatrix::checkFeasible(ClpSimplex * model,double & sum) const
     2000ClpGubDynamicMatrix::checkFeasible(ClpSimplex * /*model*/,double & sum) const
    19972001{
    19982002  int numberRows = model_->numberRows();
  • trunk/Clp/src/ClpGubMatrix.cpp

    r1370 r1402  
    893893/// returns number of elements in column part of basis,
    894894CoinBigIndex
    895 ClpGubMatrix::countBasis(ClpSimplex * model,
     895ClpGubMatrix::countBasis(ClpSimplex * /*model*/,
    896896                           const int * whichColumn,
    897897                           int numberBasic,
     
    22142214ClpGubMatrix::dualExpanded(ClpSimplex * model,
    22152215                            CoinIndexedVector * array,
    2216                             double * other,int mode)
     2216                           double * /*other*/,int mode)
    22172217{
    22182218  switch (mode) {
     
    22242224      ClpSimplex::Status iStatus;
    22252225      // not dual values yet
    2226       assert (!other);
     2226      //assert (!other);
    22272227      //double * work = array->denseVector();
    22282228      double infeasibilityCost = model->infeasibilityCost();
     
    25942594// This is local to Gub to allow synchronization when status is good
    25952595int
    2596 ClpGubMatrix::synchronize(ClpSimplex * model, int mode)
     2596ClpGubMatrix::synchronize(ClpSimplex *, int)
    25972597{
    25982598  return 0;
     
    35123512   expensive.  This may re-compute */
    35133513double *
    3514 ClpGubMatrix::rhsOffset(ClpSimplex * model,bool forceRefresh,bool check)
     3514ClpGubMatrix::rhsOffset(ClpSimplex * model,bool forceRefresh,bool
     3515#ifdef CLP_DEBUG
     3516check
     3517#endif
     3518)
    35153519{
    35163520  //forceRefresh=true;
     
    36393643*/
    36403644int
    3641 ClpGubMatrix::updatePivot(ClpSimplex * model,double oldInValue, double oldOutValue)
     3645ClpGubMatrix::updatePivot(ClpSimplex * model,double oldInValue, double /*oldOutValue*/)
    36423646{
    36433647  int sequenceIn = model->sequenceIn();
     
    40774081// Correct sequence in and out to give true value
    40784082void
    4079 ClpGubMatrix::correctSequence(const ClpSimplex * model,int & sequenceIn, int & sequenceOut)
     4083ClpGubMatrix::correctSequence(const ClpSimplex * /*model*/,int & sequenceIn, int & sequenceOut)
    40804084{
    40814085  if (sequenceIn!=-999) {
  • trunk/Clp/src/ClpLinearObjective.cpp

    r1370 r1402  
    9999// Returns gradient
    100100double * 
    101 ClpLinearObjective::gradient(const ClpSimplex * model,
    102                              const double * solution, double & offset,bool refresh,
    103                              int includeLinear)
     101ClpLinearObjective::gradient(const ClpSimplex * /*model*/,
     102                             const double * /*solution*/, double & offset,
     103                             bool /*refresh*/,
     104                             int /*includeLinear*/)
    104105{
    105106  // not sure what to do about scaling
    106107  //assert (!model);
    107   assert (includeLinear==2); //otherwise need to return all zeros
     108  //assert (includeLinear==2); //otherwise need to return all zeros
    108109  offset=0.0;
    109110  return objective_;
     
    114115double
    115116ClpLinearObjective::reducedGradient(ClpSimplex * model, double * region,
    116                                  bool useFeasibleCosts)
     117                                    bool /*useFeasibleCosts*/)
    117118{
    118119  int numberRows = model->numberRows();
     
    131132  int number=0;
    132133  const double * cost = model->costRegion();
    133   assert (!useFeasibleCosts);
     134  //assert (!useFeasibleCosts);
    134135  const int * pivotVariable = model->pivotVariable();
    135136  for (iRow=0;iRow<numberRows;iRow++) {
  • trunk/Clp/src/ClpMain.cpp

    r1379 r1402  
    6868   __cdecl
    6969#endif // _MSC_VER
    70    signal_handler(int whichSignal)
     70   signal_handler(int /*whichSignal*/)
    7171   {
    7272      if (currentModel!=NULL)
     
    282282          std::cout<<"abcd value sets value"<<std::endl;
    283283          std::cout<<"Commands are:"<<std::endl;
    284           int maxAcross=5;
     284          int maxAcross=10;
    285285          bool evenHidden=false;
     286          int printLevel =
     287            parameters[whichParam(ALLCOMMANDS,
     288                                   numberParameters,parameters)].currentOptionAsInteger();
     289          int convertP[]={2,1,0};
     290          printLevel=convertP[printLevel];
    286291          if ((verbose&8)!=0) {
    287292            // even hidden
     
    300305          for (iType=0;iType<4;iType++) {
    301306            int across=0;
     307            int lengthLine=0;
    302308            if ((verbose%4)!=0)
    303309              std::cout<<std::endl;
     
    307313            for ( iParam=0; iParam<numberParameters; iParam++ ) {
    308314              int type = parameters[iParam].type();
    309               if ((parameters[iParam].displayThis()||evenHidden)&&
     315              //printf("%d type %d limits %d %d display %d\n",iParam,
     316              //   type,limits[iType],limits[iType+1],parameters[iParam].displayThis());
     317              if ((parameters[iParam].displayThis()>=printLevel||evenHidden)&&
    310318                  type>=limits[iType]
    311319                  &&type<limits[iType+1]) {
    312320                if (!across) {
    313                   if ((verbose&2)==0)
    314                     std::cout<<"  ";
    315                   else
     321                  if ((verbose&2)!=0)
    316322                    std::cout<<"Command ";
    317323                }
    318                 std::cout<<parameters[iParam].matchName()<<"  ";
     324                int length = parameters[iParam].lengthMatchName()+1;
     325                if (lengthLine+length>80) {
     326                  std::cout<<std::endl;
     327                  across=0;
     328                  lengthLine=0;
     329                }
     330                std::cout<<" "<<parameters[iParam].matchName();
     331                lengthLine += length ;
    319332                across++;
    320333                if (across==maxAcross) {
     
    549562              break;
    550563            default:
    551               abort();
     564              //abort();
     565              break;
    552566            }
    553567          }
  • trunk/Clp/src/ClpMatrixBase.cpp

    r1370 r1402  
    111111                     const double * x, double * y,
    112112                     const double * rowScale,
    113                      const double * columnScale) const
     113                     const double * /*columnScale*/) const
    114114{
    115115  if (rowScale) {
     
    125125                              const double * x, double * y,
    126126                              const double * rowScale,
    127                               const double * columnScale,
    128                               double * spare) const
     127                              const double * /*columnScale*/,
     128                              double * /*spare*/) const
    129129{
    130130  if (rowScale) {
     
    141141ClpMatrixBase *
    142142ClpMatrixBase::subsetClone (
    143                             int numberRows, const int * whichRows,
    144                             int numberColumns, const int * whichColumns) const
     143                            int /*numberRows*/, const int * /*whichRows*/,
     144                            int /*numberColumns*/, const int * /*whichColumns*/) const
    145145 
    146146
     
    156156*/
    157157CoinBigIndex *
    158 ClpMatrixBase::dubiousWeights(const ClpSimplex * model,int * inputWeights) const
     158ClpMatrixBase::dubiousWeights(const ClpSimplex * model,int * /*inputWeights*/) const
    159159{
    160160  int number = model->numberRows()+model->numberColumns();
     
    168168// Append Columns
    169169void
    170 ClpMatrixBase::appendCols(int number, const CoinPackedVectorBase * const * columns)
     170ClpMatrixBase::appendCols(int /*number*/,
     171                          const CoinPackedVectorBase * const * /*columns*/)
    171172{
    172173  std::cerr<<"appendCols not supported - ClpMatrixBase"<<std::endl;
     
    175176// Append Rows
    176177void
    177 ClpMatrixBase::appendRows(int number, const CoinPackedVectorBase * const * rows)
     178ClpMatrixBase::appendRows(int /*number*/,
     179                          const CoinPackedVectorBase * const * /*rows*/)
    178180{
    179181  std::cerr<<"appendRows not supported - ClpMatrixBase"<<std::endl;
     
    235237// Partial pricing
    236238void
    237 ClpMatrixBase::partialPricing(ClpSimplex * model, double start, double end,
    238                               int & bestSequence, int & numberWanted)
     239ClpMatrixBase::partialPricing(ClpSimplex * , double , double ,
     240                              int & , int & )
    239241{
    240242  std::cerr<<"partialPricing not supported - ClpMatrixBase"<<std::endl;
     
    248250*/
    249251int
    250 ClpMatrixBase::extendUpdated(ClpSimplex * model,CoinIndexedVector * update,int mode)
     252ClpMatrixBase::extendUpdated(ClpSimplex * ,CoinIndexedVector * ,int )
    251253{
    252254  return 0;
     
    258260*/
    259261void
    260 ClpMatrixBase::primalExpanded(ClpSimplex * model,int mode)
     262ClpMatrixBase::primalExpanded(ClpSimplex * ,int )
    261263{
    262264}
     
    267269*/
    268270void
    269 ClpMatrixBase::dualExpanded(ClpSimplex * model,
    270                             CoinIndexedVector * array,
    271                             double * other,int mode)
     271ClpMatrixBase::dualExpanded(ClpSimplex * ,
     272                            CoinIndexedVector * ,
     273                            double * ,int )
    272274{
    273275}
     
    317319// Sets up an effective RHS
    318320void
    319 ClpMatrixBase::useEffectiveRhs(ClpSimplex * model)
     321ClpMatrixBase::useEffectiveRhs(ClpSimplex * )
    320322{
    321323  std::cerr<<"useEffectiveRhs not supported - ClpMatrixBase"<<std::endl;
     
    326328   expensive.  This may re-compute */
    327329double *
    328 ClpMatrixBase::rhsOffset(ClpSimplex * model,bool forceRefresh,bool check)
     330ClpMatrixBase::rhsOffset(ClpSimplex * model,bool forceRefresh,bool
     331#ifdef CLP_DEBUG
     332check
     333#endif
     334)
    329335{
    330336  if (rhsOffset_) {
     
    387393*/
    388394int
    389 ClpMatrixBase::updatePivot(ClpSimplex * model,double oldInValue, double oldOutValue)
     395ClpMatrixBase::updatePivot(ClpSimplex * model,double oldInValue, double )
    390396{
    391397  if (rhsOffset_) {
     
    416422*/
    417423void
    418 ClpMatrixBase::createVariable(ClpSimplex * model, int & bestSequence)
     424ClpMatrixBase::createVariable(ClpSimplex *, int &)
    419425{
    420426}
     
    549555// Correct sequence in and out to give true value
    550556void
    551 ClpMatrixBase::correctSequence(const ClpSimplex * model,int & sequenceIn, int & sequenceOut)
     557ClpMatrixBase::correctSequence(const ClpSimplex * ,int & , int & )
    552558{
    553559}
    554560// Really scale matrix
    555561void
    556 ClpMatrixBase::reallyScale(const double * rowScale, const double * columnScale)
     562ClpMatrixBase::reallyScale(const double * , const double * )
    557563{
    558564  std::cerr<<"reallyScale not supported - ClpMatrixBase"<<std::endl;
     
    561567// Updates two arrays for steepest
    562568void
    563 ClpMatrixBase::transposeTimes2(const ClpSimplex * model,
    564                                const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
    565                                const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
    566                                CoinIndexedVector * spare,
    567                                double referenceIn, double devex,
     569ClpMatrixBase::transposeTimes2(const ClpSimplex * ,
     570                               const CoinIndexedVector * , CoinIndexedVector *,
     571                               const CoinIndexedVector * ,
     572                               CoinIndexedVector * ,
     573                               double , double ,
    568574                               // Array for exact devex to say what is in reference framework
    569                                unsigned int * reference,
    570                                double * weights, double scaleFactor)
     575                               unsigned int * ,
     576                               double * , double )
    571577{
    572578  std::cerr<<"transposeTimes2 not supported - ClpMatrixBase"<<std::endl;
     
    579585   is thrown. */
    580586void
    581 ClpMatrixBase::setDimensions(int numrows, int numcols){
     587ClpMatrixBase::setDimensions(int , int ){
    582588  // If odd matrix assume user knows what they are doing
    583589}
     
    587593   If 0 then rows, 1 if columns */
    588594int
    589 ClpMatrixBase::appendMatrix(int number, int type,
    590                             const CoinBigIndex * starts, const int * index,
    591                             const double * element, int numberOther)
     595ClpMatrixBase::appendMatrix(int , int ,
     596                            const CoinBigIndex * , const int * ,
     597                            const double * , int )
    592598{
    593599  std::cerr<<"appendMatrix not supported - ClpMatrixBase"<<std::endl;
     
    600606   deleted unless keepZero true */
    601607void
    602 ClpMatrixBase::modifyCoefficient(int row, int column, double newElement,
    603                         bool keepZero)
     608ClpMatrixBase::modifyCoefficient(int , int , double ,
     609                        bool )
    604610{
    605611  std::cerr<<"modifyCoefficient not supported - ClpMatrixBase"<<std::endl;
  • trunk/Clp/src/ClpMatrixBase.hpp

    r1390 r1402  
    8787 
    8888  /// Returns number of elements in column part of basis
    89   virtual CoinBigIndex countBasis(ClpSimplex * model,
    90                                  const int * whichColumn,
    91                                  int numberRowBasic,
     89  virtual CoinBigIndex countBasis(const int * whichColumn,
    9290                                  int & numberColumnBasic)=0;
    9391  /// Fills in column part of basis
     
    309307  virtual void transposeTimes2(const ClpSimplex * model,
    310308                               const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
    311                                const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     309                               const CoinIndexedVector * pi2,
    312310                               CoinIndexedVector * spare,
    313311                               double referenceIn, double devex,
  • trunk/Clp/src/ClpNetworkBasis.cpp

    r1370 r1402  
    4545                                 const CoinBigIndex * startColumn,
    4646                                 const int * numberInColumn,
    47                                  const int * indexRow, const CoinFactorizationDouble * element)
     47                                 const int * indexRow, const CoinFactorizationDouble * /*element*/)
    4848{
    4949#ifndef COIN_FAST_CODE
  • trunk/Clp/src/ClpNetworkMatrix.cpp

    r1370 r1402  
    337337ClpNetworkMatrix::times(double scalar,
    338338                       const double * x, double * y,
    339                        const double * rowScale,
    340                        const double * columnScale) const
     339                        const double * /*rowScale*/,
     340                        const double * /*columnScale*/) const
    341341{
    342342  // we know it is not scaled
     
    346346ClpNetworkMatrix::transposeTimes( double scalar,
    347347                                 const double * x, double * y,
    348                                  const double * rowScale,
    349                                  const double * columnScale, double * spare) const
     348                                  const double * /*rowScale*/,
     349                                  const double * /*columnScale*/,
     350                                  double * /*spare*/) const
    350351{
    351352  // we know it is not scaled
     
    481482   just for indices in y. */
    482483void
    483 ClpNetworkMatrix::subsetTransposeTimes(const ClpSimplex * model,
     484ClpNetworkMatrix::subsetTransposeTimes(const ClpSimplex * /*model*/,
    484485                              const CoinIndexedVector * rowArray,
    485486                              const CoinIndexedVector * y,
     
    523524/// returns number of elements in column part of basis,
    524525CoinBigIndex
    525 ClpNetworkMatrix::countBasis(ClpSimplex * model,
    526                                  const int * whichColumn,
    527                                  int numberBasic,
     526ClpNetworkMatrix::countBasis( const int * whichColumn,
    528527                             int & numberColumnBasic)
    529528{
     
    547546}
    548547void
    549 ClpNetworkMatrix::fillBasis(ClpSimplex * model,
     548ClpNetworkMatrix::fillBasis(ClpSimplex * /*model*/,
    550549                         const int * whichColumn,
    551550                         int & numberColumnBasic,
     
    596595 */
    597596void
    598 ClpNetworkMatrix::unpack(const ClpSimplex * model,CoinIndexedVector * rowArray,
     597ClpNetworkMatrix::unpack(const ClpSimplex * /*model*/,CoinIndexedVector * rowArray,
    599598                   int iColumn) const
    600599{
     
    612611be modified if doing column generation (just for this variable) */
    613612void
    614 ClpNetworkMatrix::unpackPacked(ClpSimplex * model,
     613ClpNetworkMatrix::unpackPacked(ClpSimplex * /*model*/,
    615614                            CoinIndexedVector * rowArray,
    616615                            int iColumn) const
     
    636635      You can use quickAdd to add to vector */
    637636void
    638 ClpNetworkMatrix::add(const ClpSimplex * model,CoinIndexedVector * rowArray,
     637ClpNetworkMatrix::add(const ClpSimplex * /*model*/,CoinIndexedVector * rowArray,
    639638                   int iColumn, double multiplier) const
    640639{
     
    649648/* Adds multiple of a column into an array */
    650649void
    651 ClpNetworkMatrix::add(const ClpSimplex * model,double * array,
     650ClpNetworkMatrix::add(const ClpSimplex * /*model*/,double * array,
    652651                    int iColumn, double multiplier) const
    653652{
     
    11801179ClpNetworkMatrix::appendMatrix(int number, int type,
    11811180                                    const CoinBigIndex * starts, const int * index,
    1182                                     const double * element, int numberOther)
     1181                               const double * element, int /*numberOther*/)
    11831182{
    11841183  int numberErrors=0;
  • trunk/Clp/src/ClpNetworkMatrix.hpp

    r1370 r1402  
    6969  virtual ClpMatrixBase * reverseOrderedCopy() const;
    7070  /// Returns number of elements in column part of basis
    71   virtual CoinBigIndex countBasis(ClpSimplex * model,
     71  virtual CoinBigIndex countBasis(
    7272                                 const int * whichColumn,
    73                                  int numberRowBasic,
    7473                                  int & numberColumnBasic);
    7574  /// Fills in column part of basis
  • trunk/Clp/src/ClpNode.cpp

    r1371 r1402  
    448448// Copy constructor
    449449//-------------------------------------------------------------------
    450 ClpNode::ClpNode (const ClpNode & source)
     450ClpNode::ClpNode (const ClpNode & )
    451451
    452452  printf("ClpNode copy not implemented\n");
     
    592592// Choose a new variable
    593593void
    594 ClpNode::chooseVariable(ClpSimplex * model, ClpNodeStuff * info)
     594ClpNode::chooseVariable(ClpSimplex * , ClpNodeStuff * /*info*/)
    595595{
    596596#if 0
     
    605605// Fix on reduced costs
    606606int
    607 ClpNode::fixOnReducedCosts(ClpSimplex * model)
     607ClpNode::fixOnReducedCosts(ClpSimplex * )
    608608{
    609609 
  • trunk/Clp/src/ClpObjective.cpp

    r1370 r1402  
    5858*/
    5959ClpObjective *
    60 ClpObjective::subsetClone (int numberColumns,
    61                            const int * whichColumns) const
     60ClpObjective::subsetClone (int,
     61                           const int * ) const
    6262{
    6363  std::cerr<<"subsetClone not supported - ClpObjective"<<std::endl;
     
    6969*/
    7070int
    71 ClpObjective::markNonlinear(char * which)
     71ClpObjective::markNonlinear(char *)
    7272{
    7373  return 0;
  • trunk/Clp/src/ClpPackedMatrix.cpp

    r1401 r1402  
    18831883ClpPackedMatrix::transposeTimes2(const ClpSimplex * model,
    18841884                                 const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
    1885                                  const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     1885                                 const CoinIndexedVector * pi2,
    18861886                                 CoinIndexedVector * spare,
    18871887                                 double referenceIn, double devex,
     
    21782178ClpPackedMatrix::subsetTimes2(const ClpSimplex * model,
    21792179                              CoinIndexedVector * dj1,
    2180                             const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     2180                            const CoinIndexedVector * pi2, CoinIndexedVector *,
    21812181                            double referenceIn, double devex,
    21822182                            // Array for exact devex to say what is in reference framework
     
    22712271/// returns number of elements in column part of basis,
    22722272CoinBigIndex
    2273 ClpPackedMatrix::countBasis(ClpSimplex * model,
    2274                            const int * whichColumn,
    2275                            int numberBasic,
     2273ClpPackedMatrix::countBasis( const int * whichColumn,
    22762274                            int & numberColumnBasic)
    22772275{
     
    30793077// Creates scales for column copy (rowCopy in model may be modified)
    30803078int
    3081 ClpPackedMatrix::scale(ClpModel * model,const ClpSimplex * baseModel) const
     3079ClpPackedMatrix::scale(ClpModel * model,const ClpSimplex * /*baseModel*/) const
    30823080{
    30833081  //const ClpSimplex * baseModel=NULL;
     
    44324430// makes sure active columns correct
    44334431int
    4434 ClpPackedMatrix::refresh(ClpSimplex * model)
     4432ClpPackedMatrix::refresh(ClpSimplex * )
    44354433{
    44364434  numberActiveColumns_ = matrix_->getNumCols();
     
    47564754// Useful Constructor
    47574755//-------------------------------------------------------------------
    4758 ClpPackedMatrix2::ClpPackedMatrix2 (ClpSimplex * model,const CoinPackedMatrix * rowCopy)
     4756ClpPackedMatrix2::ClpPackedMatrix2 (ClpSimplex * ,const CoinPackedMatrix * rowCopy)
    47594757  : numberBlocks_(0),
    47604758    numberRows_(0),
  • trunk/Clp/src/ClpPackedMatrix.hpp

    r1376 r1402  
    9393  virtual ClpMatrixBase * reverseOrderedCopy() const;
    9494  /// Returns number of elements in column part of basis
    95   virtual CoinBigIndex countBasis(ClpSimplex * model,
    96                                  const int * whichColumn,
    97                                  int numberRowBasic,
     95  virtual CoinBigIndex countBasis(const int * whichColumn,
    9896                                  int & numberColumnBasic);
    9997  /// Fills in column part of basis
     
    249247  virtual void transposeTimes2(const ClpSimplex * model,
    250248                               const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
    251                                const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     249                               const CoinIndexedVector * pi2,
    252250                               CoinIndexedVector * spare,
    253251                               double referenceIn, double devex,
     
    258256  virtual void subsetTimes2(const ClpSimplex * model,
    259257                                CoinIndexedVector * dj1,
    260                                const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     258                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2, 
    261259                               double referenceIn, double devex,
    262260                               // Array for exact devex to say what is in reference framework
  • trunk/Clp/src/ClpPlusMinusOneMatrix.cpp

    r1370 r1402  
    473473ClpPlusMinusOneMatrix::times(double scalar,
    474474                       const double * x, double * y,
    475                        const double * rowScale,
    476                        const double * columnScale) const
     475                             const double * /*rowScale*/,
     476                             const double * /*columnScale*/) const
    477477{
    478478  // we know it is not scaled
     
    482482ClpPlusMinusOneMatrix::transposeTimes( double scalar,
    483483                                 const double * x, double * y,
    484                                  const double * rowScale,
    485                                  const double * columnScale, double * spare) const
     484                                       const double * /*rowScale*/,
     485                                       const double * /*columnScale*/,
     486                                       double * /*spare*/) const
    486487{
    487488  // we know it is not scaled
     
    891892   just for indices in y. */
    892893void
    893 ClpPlusMinusOneMatrix::subsetTransposeTimes(const ClpSimplex * model,
     894ClpPlusMinusOneMatrix::subsetTransposeTimes(const ClpSimplex * ,
    894895                              const CoinIndexedVector * rowArray,
    895896                              const CoinIndexedVector * y,
     
    921922/// returns number of elements in column part of basis,
    922923CoinBigIndex
    923 ClpPlusMinusOneMatrix::countBasis(ClpSimplex * model,
    924                                  const int * whichColumn,
    925                                  int numberBasic,
     924ClpPlusMinusOneMatrix::countBasis(const int * whichColumn,
    926925                                  int & numberColumnBasic)
    927926{
     
    935934}
    936935void
    937 ClpPlusMinusOneMatrix::fillBasis(ClpSimplex * model,
     936ClpPlusMinusOneMatrix::fillBasis(ClpSimplex * ,
    938937                         const int * whichColumn,
    939938                         int & numberColumnBasic,
     
    967966 */
    968967void
    969 ClpPlusMinusOneMatrix::unpack(const ClpSimplex * model,
     968ClpPlusMinusOneMatrix::unpack(const ClpSimplex * ,
    970969                              CoinIndexedVector * rowArray,
    971970                              int iColumn) const
     
    986985be modified if doing column generation (just for this variable) */
    987986void
    988 ClpPlusMinusOneMatrix::unpackPacked(ClpSimplex * model,
     987ClpPlusMinusOneMatrix::unpackPacked(ClpSimplex * ,
    989988                            CoinIndexedVector * rowArray,
    990989                            int iColumn) const
     
    10101009      You can use quickAdd to add to vector */
    10111010void
    1012 ClpPlusMinusOneMatrix::add(const ClpSimplex * model,CoinIndexedVector * rowArray,
     1011ClpPlusMinusOneMatrix::add(const ClpSimplex * ,CoinIndexedVector * rowArray,
    10131012                   int iColumn, double multiplier) const
    10141013{
     
    10251024/* Adds multiple of a column into an array */
    10261025void
    1027 ClpPlusMinusOneMatrix::add(const ClpSimplex * model,double * array,
     1026ClpPlusMinusOneMatrix::add(const ClpSimplex * ,double * array,
    10281027                    int iColumn, double multiplier) const
    10291028{
     
    16771676ClpPlusMinusOneMatrix::transposeTimes2(const ClpSimplex * model,
    16781677                                 const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
    1679                                  const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     1678                                 const CoinIndexedVector * pi2, CoinIndexedVector * ,
    16801679                                 CoinIndexedVector * spare,
    16811680                                 double referenceIn, double devex,
     
    18211820// Updates second array for steepest and does devex weights
    18221821void
    1823 ClpPlusMinusOneMatrix::subsetTimes2(const ClpSimplex * model,
     1822ClpPlusMinusOneMatrix::subsetTimes2(const ClpSimplex * ,
    18241823                              CoinIndexedVector * dj1,
    1825                             const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
     1824                            const CoinIndexedVector * pi2, CoinIndexedVector *,
    18261825                            double referenceIn, double devex,
    18271826                            // Array for exact devex to say what is in reference framework
     
    19301929ClpPlusMinusOneMatrix::appendMatrix(int number, int type,
    19311930                                    const CoinBigIndex * starts, const int * index,
    1932                                     const double * element, int numberOther)
     1931                                    const double * element, int /*numberOther*/)
    19331932{
    19341933  int numberErrors=0;
  • trunk/Clp/src/ClpPlusMinusOneMatrix.hpp

    r1370 r1402  
    7070  virtual ClpMatrixBase * reverseOrderedCopy() const;
    7171  /// Returns number of elements in column part of basis
    72   virtual CoinBigIndex countBasis(ClpSimplex * model,
     72  virtual CoinBigIndex countBasis(
    7373                                 const int * whichColumn,
    74                                  int numberRowBasic,
    7574                                  int & numberColumnBasic);
    7675  /// Fills in column part of basis
  • trunk/Clp/src/ClpPredictorCorrector.cpp

    r1394 r1402  
    30513051// updateSolution.  Updates solution at end of iteration
    30523052//returns number fixed
    3053 int ClpPredictorCorrector::updateSolution(CoinWorkDouble nextGap)
     3053int ClpPredictorCorrector::updateSolution(CoinWorkDouble /*nextGap*/)
    30543054{
    30553055  CoinWorkDouble * dualArray = reinterpret_cast<CoinWorkDouble *>(dual_);
     
    37573757//See exactly what would happen given current deltas
    37583758void
    3759 ClpPredictorCorrector::debugMove(int phase,CoinWorkDouble primalStep, CoinWorkDouble dualStep)
     3759ClpPredictorCorrector::debugMove(int /*phase*/,
     3760                                 CoinWorkDouble primalStep, CoinWorkDouble dualStep)
    37603761{
    37613762#ifndef SOME_DEBUG
  • trunk/Clp/src/ClpPresolve.cpp

    r1370 r1402  
    10731073#endif
    10741074CoinPresolveMatrix::CoinPresolveMatrix(int ncols0_in,
    1075                                      double maxmin,
     1075                                       double /*maxmin*/,
    10761076                                     // end prepost members
    10771077
     
    12721272#endif
    12731273
    1274   presolve_make_memlists(mcstrt_, hincol_, clink_, ncols_);
    1275   presolve_make_memlists(mrstrt_, hinrow_, rlink_, nrows_);
     1274  presolve_make_memlists(/*mcstrt_,*/ hincol_, clink_, ncols_);
     1275  presolve_make_memlists(/*mrstrt_,*/ hinrow_, rlink_, nrows_);
    12761276
    12771277  // this allows last col/row to expand up to bufsize-1 (22);
     
    12891289
    12901290void CoinPresolveMatrix::update_model(ClpSimplex * si,
    1291                                      int nrows0,
    1292                                      int ncols0,
    1293                                      CoinBigIndex nelems0)
     1291                                      int /*nrows0*/,
     1292                                      int /*ncols0*/,
     1293                                      CoinBigIndex /*nelems0*/)
    12941294{
    12951295  si->loadProblem(ncols_, nrows_, mcstrt_, hrow_, colels_, hincol_,
  • trunk/Clp/src/ClpPrimalColumnDantzig.cpp

    r1370 r1402  
    5959int
    6060ClpPrimalColumnDantzig::pivotColumn(CoinIndexedVector * updates,
    61                                     CoinIndexedVector * spareRow1,
     61                                    CoinIndexedVector * /*spareRow1*/,
    6262                                    CoinIndexedVector * spareRow2,
    6363                                    CoinIndexedVector * spareColumn1,
  • trunk/Clp/src/ClpPrimalColumnDantzig.hpp

    r1370 r1402  
    3636
    3737  /// Just sets model
    38   virtual void saveWeights(ClpSimplex * model,int mode)
     38  virtual void saveWeights(ClpSimplex * model,int)
    3939  {model_=model;}
    4040  //@}
  • trunk/Clp/src/ClpPrimalColumnPivot.cpp

    r1370 r1402  
    5656}
    5757void
    58 ClpPrimalColumnPivot::saveWeights(ClpSimplex * model,int mode)
     58ClpPrimalColumnPivot::saveWeights(ClpSimplex * model,int )
    5959{
    6060  model_=model;
     
    6363
    6464void
    65 ClpPrimalColumnPivot::updateWeights(CoinIndexedVector * input)
     65ClpPrimalColumnPivot::updateWeights(CoinIndexedVector *)
    6666{
    6767}
     
    7676*/
    7777int
    78 ClpPrimalColumnPivot::numberSprintColumns(int & numberIterations) const
     78ClpPrimalColumnPivot::numberSprintColumns(int & ) const
    7979{
    8080  return 0;
  • trunk/Clp/src/ClpPrimalColumnSteepest.cpp

    r1371 r1402  
    287287  if (switchType==5) {
    288288    if (anyUpdates>0) {
    289       justDjs(updates,spareRow1,spareRow2,
     289      justDjs(updates,spareRow2,
    290290        spareColumn1,spareColumn2);
    291291    }
     
    293293    if (switchType<4) {
    294294      // exact etc when can use dj
    295       djsAndSteepest(updates,spareRow1,spareRow2,
     295      djsAndSteepest(updates,spareRow2,
    296296        spareColumn1,spareColumn2);
    297297    } else {
    298298      // devex etc when can use dj
    299       djsAndDevex(updates,spareRow1,spareRow2,
     299      djsAndDevex(updates,spareRow2,
    300300        spareColumn1,spareColumn2);
    301301    }
     
    303303    if (switchType<4) {
    304304      // exact etc when djs okay
    305       justSteepest(updates,spareRow1,spareRow2,
     305      justSteepest(updates,spareRow2,
    306306        spareColumn1,spareColumn2);
    307307    } else {
    308308      // devex etc when djs okay
    309       justDevex(updates,spareRow1,spareRow2,
     309      justDevex(updates,spareRow2,
    310310        spareColumn1,spareColumn2);
    311311    }
     
    313313    if (switchType<4) {
    314314      // exact etc when have to use pivot
    315       djsAndSteepest2(updates,spareRow1,spareRow2,
     315      djsAndSteepest2(updates,spareRow2,
    316316        spareColumn1,spareColumn2);
    317317    } else {
    318318      // devex etc when have to use pivot
    319       djsAndDevex2(updates,spareRow1,spareRow2,
     319      djsAndDevex2(updates,spareRow2,
    320320        spareColumn1,spareColumn2);
    321321    }
     
    595595void
    596596ClpPrimalColumnSteepest::justDjs(CoinIndexedVector * updates,
    597                CoinIndexedVector * spareRow1,
    598597               CoinIndexedVector * spareRow2,
    599598               CoinIndexedVector * spareColumn1,
     
    700699void
    701700ClpPrimalColumnSteepest::djsAndDevex(CoinIndexedVector * updates,
    702                CoinIndexedVector * spareRow1,
    703701               CoinIndexedVector * spareRow2,
    704702               CoinIndexedVector * spareColumn1,
     
    940938void
    941939ClpPrimalColumnSteepest::djsAndSteepest(CoinIndexedVector * updates,
    942                CoinIndexedVector * spareRow1,
    943940               CoinIndexedVector * spareRow2,
    944941               CoinIndexedVector * spareColumn1,
     
    12091206void
    12101207ClpPrimalColumnSteepest::djsAndDevex2(CoinIndexedVector * updates,
    1211                CoinIndexedVector * spareRow1,
    12121208               CoinIndexedVector * spareRow2,
    12131209               CoinIndexedVector * spareColumn1,
     
    14011397void
    14021398ClpPrimalColumnSteepest::djsAndSteepest2(CoinIndexedVector * updates,
    1403                CoinIndexedVector * spareRow1,
    14041399               CoinIndexedVector * spareRow2,
    14051400               CoinIndexedVector * spareColumn1,
     
    16661661  if (model_->clpMatrix()->canCombine(model_,pi1)) {
    16671662    // put row of tableau in rowArray and columnArray
    1668     model_->clpMatrix()->transposeTimes2(model_,pi1,dj1,pi2,dj2,spare,referenceIn, devex_,
     1663    model_->clpMatrix()->transposeTimes2(model_,pi1,dj1,pi2,spare,referenceIn, devex_,
    16691664                                         reference_,
    16701665                                         weights_,scaleFactor);
     
    17251720void
    17261721ClpPrimalColumnSteepest::justDevex(CoinIndexedVector * updates,
    1727                CoinIndexedVector * spareRow1,
    17281722               CoinIndexedVector * spareRow2,
    17291723               CoinIndexedVector * spareColumn1,
     
    18331827void
    18341828ClpPrimalColumnSteepest::justSteepest(CoinIndexedVector * updates,
    1835                CoinIndexedVector * spareRow1,
    18361829               CoinIndexedVector * spareRow2,
    18371830               CoinIndexedVector * spareColumn1,
     
    19801973int
    19811974ClpPrimalColumnSteepest::pivotColumnOldMethod(CoinIndexedVector * updates,
    1982                                     CoinIndexedVector * spareRow1,
     1975                                    CoinIndexedVector * ,
    19831976                                    CoinIndexedVector * spareRow2,
    19841977                                    CoinIndexedVector * spareColumn1,
     
    28002793        alternateWeights_->capacity()==numberRows+
    28012794          model_->factorization()->maximumPivots()) {
    2802         alternateWeights_->clear();
     2795        //alternateWeights_->clear();
    28032796        if (pivotSequence_>=0&&pivotSequence_<numberRows) {
    28042797          // save pivot order
  • trunk/Clp/src/ClpPrimalColumnSteepest.hpp

    r1370 r1402  
    4646  /// Just update djs
    4747  void justDjs(CoinIndexedVector * updates,
    48                CoinIndexedVector * spareRow1,
    4948               CoinIndexedVector * spareRow2,
    5049               CoinIndexedVector * spareColumn1,
     
    5756  /// Update djs, weights for Devex using djs
    5857  void djsAndDevex(CoinIndexedVector * updates,
    59                CoinIndexedVector * spareRow1,
    6058               CoinIndexedVector * spareRow2,
    6159               CoinIndexedVector * spareColumn1,
     
    6361  /// Update djs, weights for Steepest using djs
    6462  void djsAndSteepest(CoinIndexedVector * updates,
    65                CoinIndexedVector * spareRow1,
    6663               CoinIndexedVector * spareRow2,
    6764               CoinIndexedVector * spareColumn1,
     
    6966  /// Update djs, weights for Devex using pivot row
    7067  void djsAndDevex2(CoinIndexedVector * updates,
    71                CoinIndexedVector * spareRow1,
    7268               CoinIndexedVector * spareRow2,
    7369               CoinIndexedVector * spareColumn1,
     
    7571  /// Update djs, weights for Steepest using pivot row
    7672  void djsAndSteepest2(CoinIndexedVector * updates,
    77                CoinIndexedVector * spareRow1,
    7873               CoinIndexedVector * spareRow2,
    7974               CoinIndexedVector * spareColumn1,
     
    8176  /// Update weights for Devex
    8277  void justDevex(CoinIndexedVector * updates,
    83                CoinIndexedVector * spareRow1,
    8478               CoinIndexedVector * spareRow2,
    8579               CoinIndexedVector * spareColumn1,
     
    8781  /// Update weights for Steepest
    8882  void justSteepest(CoinIndexedVector * updates,
    89                CoinIndexedVector * spareRow1,
    9083               CoinIndexedVector * spareRow2,
    9184               CoinIndexedVector * spareColumn1,
  • trunk/Clp/src/ClpSimplex.cpp

    r1397 r1402  
    11531153   primal and dual solutions.  Uses input arrays for variables at
    11541154   bounds.  Returns feasibility states */
    1155 int ClpSimplex::getSolution ( const double * rowActivities,
    1156                                const double * columnActivities)
     1155int ClpSimplex::getSolution ( const double * /*rowActivities*/,
     1156                              const double * /*columnActivities*/)
    11571157{
    11581158  if (!factorization_->status()) {
     
    43944394  }
    43954395}
    4396 void checkCorrect(ClpSimplex * model,int iRow,
     4396void checkCorrect(ClpSimplex * /*model*/,int iRow,
    43974397                  const double * element,const int * rowStart,const int * rowLength,
    43984398                  const int * column,
    43994399                  const double * columnLower_, const double * columnUpper_,
    4400                   int infiniteUpperC,
    4401                   int infiniteLowerC,
     4400                  int /*infiniteUpperC*/,
     4401                  int /*infiniteLowerC*/,
    44024402                  double &maximumUpC,
    44034403                  double &maximumDownC)
     
    44414441    }
    44424442  }
    4443   assert (infiniteLowerC==infiniteLower);
    4444   assert (infiniteUpperC==infiniteUpper);
     4443  //assert (infiniteLowerC==infiniteLower);
     4444  //assert (infiniteUpperC==infiniteUpper);
    44454445  if (fabs(maximumUp-maximumUpC)>1.0e-12*CoinMax(fabs(maximumUp),fabs(maximumUpC)))
    44464446    printf("row %d comp up %g, true up %g\n",iRow,
     
    67346734// This loads a model from a coinModel object - returns number of errors
    67356735int
    6736 ClpSimplex::loadProblem (  CoinModel & modelObject, bool keepSolution)
     6736ClpSimplex::loadProblem (  CoinModel & modelObject, bool /*keepSolution*/)
    67376737{
    67386738  unsigned char * status = NULL;
  • trunk/Clp/src/ClpSimplexDual.cpp

    r1394 r1402  
    399399  int nPivots=9999;
    400400#endif
     401  double largestPrimalError=0.0;
     402  double largestDualError=0.0;
    401403  // Start can skip some things in transposeTimes
    402404  specialOptions_ |= 131072;
     
    484486    statusOfProblemInDual(lastCleaned,factorType,saveDuals,data,
    485487                          ifValuesPass);
     488    largestPrimalError=CoinMax(largestPrimalError,largestPrimalError_);
     489    largestDualError=CoinMax(largestDualError,largestDualError_);
    486490    if (disaster)
    487491      problemStatus_=3;
     
    555559  // Stop can skip some things in transposeTimes
    556560  specialOptions_ &= ~131072;
     561  largestPrimalError_=largestPrimalError;
     562  largestDualError_=largestDualError;
    557563}
    558564int
     
    15081514        }
    15091515        // do actual flips
    1510         flipBounds(rowArray_[0],columnArray_[0],theta_);
     1516        flipBounds(rowArray_[0],columnArray_[0]);
    15111517        //rowArray_[1]->expand();
    15121518        dualRowPivot_->updatePrimalSolution(rowArray_[1],
     
    24132419  if (fullRecompute) {
    24142420    // do actual flips
    2415     flipBounds(rowArray,columnArray,0.0);
     2421    flipBounds(rowArray,columnArray);
    24162422  }
    24172423  objectiveChange += changeObj;
     
    31633169                           CoinIndexedVector * spareArray2,
    31643170                           double acceptablePivot,
    3165                            CoinBigIndex * dubiousWeights)
     3171                           CoinBigIndex * /*dubiousWeights*/)
    31663172{
    31673173  int numberPossiblySwapped=0;
     
    51325138void
    51335139ClpSimplexDual::flipBounds(CoinIndexedVector * rowArray,
    5134                   CoinIndexedVector * columnArray,
    5135                   double change)
     5140                  CoinIndexedVector * columnArray)
    51365141{
    51375142  int number;
  • trunk/Clp/src/ClpSimplexDual.hpp

    r1370 r1402  
    175175                  double theta);
    176176  /** While updateDualsInDual sees what effect is of flip
    177       this does actuall flipping.
    178       If change >0.0 then value in array >0.0 => from lower to upper
     177      this does actual flipping.
    179178  */
    180179  void flipBounds(CoinIndexedVector * rowArray,
    181                   CoinIndexedVector * columnArray,
    182                   double change);
     180                  CoinIndexedVector * columnArray);
    183181  /**
    184182      Row array has row part of pivot row
  • trunk/Clp/src/ClpSimplexOther.cpp

    r1376 r1402  
    22822282*/
    22832283int
    2284 ClpSimplexOther::whileIterating(double startingTheta, double & endingTheta,double reportIncrement,
     2284ClpSimplexOther::whileIterating(double startingTheta, double & endingTheta,double /*reportIncrement*/,
    22852285                                const double * changeLower, const double * changeUpper,
    22862286                                const double * changeObjective)
     
    25452545        }
    25462546        // do actual flips
    2547         reinterpret_cast<ClpSimplexDual *> ( this)->flipBounds(rowArray_[0],columnArray_[0],theta_);
     2547        reinterpret_cast<ClpSimplexDual *> ( this)->flipBounds(rowArray_[0],columnArray_[0]);
    25482548        //rowArray_[1]->expand();
    25492549        dualRowPivot_->updatePrimalSolution(rowArray_[1],
     
    27792779// Computes next theta and says if objective or bounds (0= bounds, 1 objective, -1 none)
    27802780int
    2781 ClpSimplexOther::nextTheta(int type, double maxTheta, double * primalChange, double * dualChange,
     2781ClpSimplexOther::nextTheta(int type, double maxTheta, double * primalChange, double * /*dualChange*/,
    27822782                           const double * changeLower, const double * changeUpper,
    2783                            const double * changeObjective)
     2783                           const double * /*changeObjective*/)
    27842784{
    27852785  int numberTotal = numberColumns_+numberRows_;
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r1394 r1402  
    14851485                            CoinIndexedVector * rhsArray,
    14861486                            CoinIndexedVector * spareArray,
    1487                             CoinIndexedVector * spareArray2,
    14881487                            int valuesPass)
    14891488{
     
    27462745    matrix_->extendUpdated(this,rowArray_[1],0);
    27472746    // do ratio test and re-compute dj
    2748     primalRow(rowArray_[1],rowArray_[3],rowArray_[2],rowArray_[0],
     2747    primalRow(rowArray_[1],rowArray_[3],rowArray_[2],
    27492748              ifValuesPass);
    27502749    if (ifValuesPass) {
     
    27552754          // try other way
    27562755          directionIn_=-directionIn_;
    2757           primalRow(rowArray_[1],rowArray_[3],rowArray_[2],rowArray_[0],
     2756          primalRow(rowArray_[1],rowArray_[3],rowArray_[2],
    27582757                    0);
    27592758        }
  • trunk/Clp/src/ClpSimplexPrimal.hpp

    r1370 r1402  
    185185                 CoinIndexedVector * rhsArray,
    186186                 CoinIndexedVector * spareArray,
    187                  CoinIndexedVector * spareArray2,
    188187                 int valuesPass);
    189188  /**
  • trunk/Clp/src/ClpSolve.cpp

    r1370 r1402  
    343343   __cdecl
    344344#endif // _MSC_VER
    345    signal_handler(int whichSignal)
     345   signal_handler(int /*whichSignal*/)
    346346   {
    347347      if (currentModel!=NULL)
     
    26702670// Solve types
    26712671void
    2672 ClpSolve::setSolveType(SolveType method, int extraInfo)
     2672ClpSolve::setSolveType(SolveType method, int /*extraInfo*/)
    26732673{
    26742674  method_=method;
     
    32703270      CoinModelBlockInfo info = CoinModelBlockInfo();
    32713271      int whatsSet = thisBlock->whatIsSet();
    3272       info.matrix = ((whatsSet&1)!=0) ? 1 : 0;
    3273       info.rhs = ((whatsSet&2)!=0) ? 1 : 0;
    3274       info.rowName = ((whatsSet&4)!=0) ? 1 : 0;
    3275       info.integer = ((whatsSet&32)!=0) ? 1 : 0;
    3276       info.bounds = ((whatsSet&8)!=0) ? 1 : 0;
    3277       info.columnName = ((whatsSet&16)!=0) ? 1 : 0;
     3272      info.matrix = static_cast<char>(((whatsSet&1)!=0) ? 1 : 0);
     3273      info.rhs = static_cast<char>(((whatsSet&2)!=0) ? 1 : 0);
     3274      info.rowName = static_cast<char>(((whatsSet&4)!=0) ? 1 : 0);
     3275      info.integer = static_cast<char>(((whatsSet&32)!=0) ? 1 : 0);
     3276      info.bounds = static_cast<char>(((whatsSet&8)!=0) ? 1 : 0);
     3277      info.columnName = static_cast<char>(((whatsSet&16)!=0) ? 1 : 0);
    32783278      // Which block
    32793279      int iRowBlock=model->rowBlock(thisBlock->getRowBlock());
     
    36623662    CoinModelBlockInfo info = CoinModelBlockInfo();
    36633663    int whatsSet = thisBlock->whatIsSet();
    3664     info.matrix = ((whatsSet&1)!=0) ? 1 : 0;
    3665     info.rhs = ((whatsSet&2)!=0) ? 1 : 0;
    3666     info.rowName = ((whatsSet&4)!=0) ? 1 : 0;
    3667     info.integer = ((whatsSet&32)!=0) ? 1 : 0;
    3668     info.bounds = ((whatsSet&8)!=0) ? 1 : 0;
    3669     info.columnName = ((whatsSet&16)!=0) ? 1 : 0;
     3664    info.matrix = static_cast<char>(((whatsSet&1)!=0) ? 1 : 0);
     3665    info.rhs = static_cast<char>(((whatsSet&2)!=0) ? 1 : 0);
     3666    info.rowName = static_cast<char>(((whatsSet&4)!=0) ? 1 : 0);
     3667    info.integer = static_cast<char>(((whatsSet&32)!=0) ? 1 : 0);
     3668    info.bounds = static_cast<char>(((whatsSet&8)!=0) ? 1 : 0);
     3669    info.columnName = static_cast<char>(((whatsSet&16)!=0) ? 1 : 0);
    36703670    // Which block
    36713671    int iRowBlock=model->rowBlock(thisBlock->getRowBlock());
     
    43134313    CoinModelBlockInfo info = CoinModelBlockInfo();
    43144314    int whatsSet = thisBlock->whatIsSet();
    4315     info.matrix = ((whatsSet&1)!=0) ? 1 : 0;
    4316     info.rhs = ((whatsSet&2)!=0) ? 1 : 0;
    4317     info.rowName = ((whatsSet&4)!=0) ? 1 : 0;
    4318     info.integer = ((whatsSet&32)!=0) ? 1 : 0;
    4319     info.bounds = ((whatsSet&8)!=0) ? 1 : 0;
    4320     info.columnName = ((whatsSet&16)!=0) ? 1 : 0;
     4315    info.matrix = static_cast<char>(((whatsSet&1)!=0) ? 1 : 0);
     4316    info.rhs = static_cast<char>(((whatsSet&2)!=0) ? 1 : 0);
     4317    info.rowName = static_cast<char>(((whatsSet&4)!=0) ? 1 : 0);
     4318    info.integer = static_cast<char>(((whatsSet&32)!=0) ? 1 : 0);
     4319    info.bounds = static_cast<char>(((whatsSet&8)!=0) ? 1 : 0);
     4320    info.columnName = static_cast<char>(((whatsSet&16)!=0) ? 1 : 0);
    43214321    // Which block
    43224322    int iRowBlock=model->rowBlock(thisBlock->getRowBlock());
  • trunk/Clp/src/Clp_C_Interface.cpp

    r1390 r1402  
    9292
    9393CMessageHandler::CMessageHandler (const CoinMessageHandler & rhs)
    94   : CoinMessageHandler(),
     94  : CoinMessageHandler(rhs),
    9595    model_(NULL),
    9696    callback_(NULL)
     
    100100// Constructor with pointer to model
    101101CMessageHandler::CMessageHandler(Clp_Simplex * model,
    102                FILE * userPointer)
     102               FILE * )
    103103  : CoinMessageHandler(),
    104104    model_(model),
     
    445445/* Sets problem name.  Must have \0 at end.  */
    446446COINLIBAPI int COINLINKAGE
    447 Clp_setProblemName(Clp_Simplex * model, int maxNumberCharacters, char * array)
     447Clp_setProblemName(Clp_Simplex * model, int /*maxNumberCharacters*/, char * array)
    448448{
    449449  return model->model_->setStrParam(ClpProbName, array);
  • trunk/Clp/src/IdiSolve.cpp

    r1370 r1402  
    7070IdiotResult
    7171Idiot::objval(int nrows, int ncols, double * rowsol , double * colsol,
    72               double * pi, double * djs, const double * cost ,
    73               const double * rowlower,
    74               const double * rowupper, const double * lower,
    75               const double * upper, const double * elemnt,
     72              double * pi, double * /*djs*/, const double * cost ,
     73              const double * /*rowlower*/,
     74              const double * rowupper, const double * /*lower*/,
     75              const double * /*upper*/, const double * elemnt,
    7676              const int * row, const CoinBigIndex * columnStart,
    7777              const int * length, int extraBlock, int * rowExtra,
    78               double * solExtra, double * elemExtra, double * upperExtra,
     78              double * solExtra, double * elemExtra, double * /*upperExtra*/,
    7979              double * costExtra,double weight)
    8080{
  • trunk/Clp/src/MyMessageHandler.cpp

    r1370 r1402  
    4343
    4444MyMessageHandler::MyMessageHandler (const CoinMessageHandler & rhs)
    45   : CoinMessageHandler(),
     45  : CoinMessageHandler(rhs),
    4646    model_(NULL),
    4747    feasibleExtremePoints_(),
     
    5252// Constructor with pointer to model
    5353MyMessageHandler::MyMessageHandler(ClpSimplex * model,
    54                FILE * userPointer)
     54                                   FILE * /*userPointer*/)
    5555  : CoinMessageHandler(),
    5656    model_(model),
  • trunk/Clp/src/unitTest.cpp

    r1370 r1402  
    15871587      char temp[100];
    15881588      // read and skip
    1589       fscanf(fp,"%s",temp);
     1589      int x=fscanf(fp,"%s",temp);
     1590      if (x<0)
     1591        throw("bad fscanf");
    15901592      assert (!strcmp(temp,"BEGIN"));
    1591       fscanf(fp,"%*s %*s %d %d %*s %*s %d %*s",&problem, &numberRows,
     1593      x=fscanf(fp,"%*s %*s %d %d %*s %*s %d %*s",&problem, &numberRows,
    15921594             &numberColumns);
     1595      if (x<0)
     1596        throw("bad fscanf");
    15931597      // scan down to SUPPLY
    15941598      while (fgets(temp,100,fp)) {
     
    19731977      std::string topName="row_master";
    19741978      std::string blockName="block_";
    1975       char bName = 'a'+static_cast<char>(i);
     1979      char bName = static_cast<char>('a'+static_cast<char>(i));
    19761980      blockName.append(1,bName);
    19771981      structured.addBlock(topName,blockName,top);
     
    19992003    for (int i=0;i<numberBlocks;i++) {
    20002004      std::string blockName="block_";
    2001       char bName = 'a'+static_cast<char>(i);
     2005      char bName = static_cast<char>('a'+static_cast<char>(i));
    20022006      blockName.append(1,bName);
    20032007      structured2.addBlock(blockName,blockName,structured);
Note: See TracChangeset for help on using the changeset viewer.