Changeset 1200 for trunk


Ignore:
Timestamp:
Jul 25, 2009 4:44:13 AM (11 years ago)
Author:
forrest
Message:

get rid of compiler warnings

Location:
trunk/Cbc/src
Files:
38 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcBranchActual.cpp

    r1173 r1200  
    11541154
    11551155double
    1156 CbcSimpleInteger::infeasibility(const OsiSolverInterface * solver, const OsiBranchingInformation * info,
     1156CbcSimpleInteger::infeasibility(const OsiSolverInterface * /*solver*/,
     1157                                const OsiBranchingInformation * info,
    11571158                         int & preferredWay) const
    11581159{
     
    12001201*/
    12011202OsiSolverBranch *
    1202 CbcSimpleInteger::solverBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info) const
     1203CbcSimpleInteger::solverBranch(OsiSolverInterface * /*solver*/,
     1204                               const OsiBranchingInformation * info) const
    12031205{
    12041206  double value = info->solution_[columnNumber_];
     
    12161218// Creates a branching object
    12171219CbcBranchingObject *
    1218 CbcSimpleInteger::createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way)
     1220CbcSimpleInteger::createBranch(OsiSolverInterface * /*solver*/,
     1221                               const OsiBranchingInformation * info, int way)
    12191222{
    12201223  CbcIntegerBranchingObject * branch = new CbcIntegerBranchingObject(model_,0,-1,0.5);
     
    12751278 */
    12761279void
    1277 CbcSimpleInteger::resetSequenceEtc(int numberColumns, const int * originalColumns)
    1278 {
    1279   assert (numberColumns>0);
     1280CbcSimpleInteger::resetSequenceEtc(int /*numberColumns*/,
     1281                                   const int * originalColumns)
     1282{
     1283  //assert (numberColumns>0);
    12801284  int iColumn;
    12811285#if 0
     
    13111315}
    13121316CbcBranchingObject *
    1313 CbcSimpleInteger::createBranch( int way)
     1317CbcSimpleInteger::createBranch( int /*way*/)
    13141318{
    13151319  abort();
     
    16051609   branchState is -1 for 'down' +1 for 'up' */
    16061610void
    1607 CbcIntegerBranchingObject::fix(OsiSolverInterface * solver,
     1611CbcIntegerBranchingObject::fix(OsiSolverInterface * /*solver*/,
    16081612                               double * lower, double * upper,
    16091613                               int branchState) const
     
    18021806}
    18031807// Useful constructor - passed and model index and pseudo costs
    1804 CbcSimpleIntegerPseudoCost::CbcSimpleIntegerPseudoCost (CbcModel * model, int dummy,int iColumn,
     1808CbcSimpleIntegerPseudoCost::CbcSimpleIntegerPseudoCost (CbcModel * model,
     1809                                                        int /*dummy*/,
     1810                                                        int iColumn,
    18051811                                                        double downPseudoCost, double upPseudoCost)
    18061812{
     
    20102016                                                      int variable, int way,
    20112017                                                      double lowerValue,
    2012                                                       double upperValue)
     2018                                                                          double /*upperValue*/)
    20132019  :CbcIntegerBranchingObject(model,variable,way,lowerValue)
    20142020{
     
    23072313CbcRangeCompare
    23082314CbcCliqueBranchingObject::compareBranchingObject
    2309 (const CbcBranchingObject* brObj, const bool replaceIfOverlap)
     2315(const CbcBranchingObject* brObj, const bool /*replaceIfOverlap*/)
    23102316{
    23112317  const CbcCliqueBranchingObject* br =
     
    25582564CbcRangeCompare
    25592565CbcLongCliqueBranchingObject::compareBranchingObject
    2560 (const CbcBranchingObject* brObj, const bool replaceIfOverlap)
     2566(const CbcBranchingObject* brObj, const bool /*replaceIfOverlap*/)
    25612567{
    25622568  const CbcLongCliqueBranchingObject* br =
     
    27242730void
    27252731CbcSOSBranchingObject::fix(OsiSolverInterface * solver,
    2726                                double * lower, double * upper,
     2732                           double * /*lower*/, double * upper,
    27272733                               int branchState) const
    27282734{
     
    29562962int
    29572963CbcBranchDefaultDecision::betterBranch(CbcBranchingObject * thisOne,
    2958                             CbcBranchingObject * bestSoFar,
     2964                                       CbcBranchingObject * /*bestSoFar*/,
    29592965                            double changeUp, int numInfUp,
    29602966                            double changeDn, int numInfDn)
     
    37793785int
    37803786CbcFixingBranchingObject::compareOriginalObject
    3781 (const CbcBranchingObject* brObj) const
     3787(const CbcBranchingObject* /*brObj*/) const
    37823788{
    37833789  throw("must implement");
     
    37943800CbcRangeCompare
    37953801CbcFixingBranchingObject::compareBranchingObject
    3796 (const CbcBranchingObject* brObj, const bool replaceIfOverlap)
    3797 {
    3798 #ifndef NDEBUG
     3802(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
     3803{
     3804#if 0 //ndef NDEBUG
    37993805  const CbcFixingBranchingObject* br =
    38003806    dynamic_cast<const CbcFixingBranchingObject*>(brObj);
     
    40224028// Creates a branching object
    40234029CbcBranchingObject *
    4024 CbcNWay::createBranch(int way)
     4030CbcNWay::createBranch(int /*way*/)
    40254031{
    40264032  int numberFree=0;
     
    41904196int
    41914197CbcNWayBranchingObject::compareOriginalObject
    4192 (const CbcBranchingObject* brObj) const
     4198(const CbcBranchingObject* /*brObj*/) const
    41934199{
    41944200  throw("must implement");
     
    42054211CbcRangeCompare
    42064212CbcNWayBranchingObject::compareBranchingObject
    4207 (const CbcBranchingObject* brObj, const bool replaceIfOverlap)
     4213(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
    42084214{
    42094215  throw("must implement");
     
    45844590// Infeasibility - large is 0.5
    45854591double
    4586 CbcGeneralDepth::infeasibility(int & preferredWay) const
     4592CbcGeneralDepth::infeasibility(int & /*preferredWay*/) const
    45874593{
    45884594  whichSolution_ = -1;
     
    46944700// Redoes data when sequence numbers change
    46954701void
    4696 CbcGeneralDepth::redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns)
     4702CbcGeneralDepth::redoSequenceEtc(CbcModel * /*model*/,
     4703                                 int /*numberColumns*/,
     4704                                 const int * /*originalColumns*/)
    46974705{
    46984706}
     
    47074715// Creates a branching object
    47084716CbcBranchingObject *
    4709 CbcGeneralDepth::createBranch(int way)
     4717CbcGeneralDepth::createBranch(int /*way*/)
    47104718{
    47114719  int numberDo = numberNodes_;
     
    49925000int
    49935001CbcGeneralBranchingObject::compareOriginalObject
    4994 (const CbcBranchingObject* brObj) const
     5002(const CbcBranchingObject* /*brObj*/) const
    49955003{
    49965004  throw("must implement");
     
    50075015CbcRangeCompare
    50085016CbcGeneralBranchingObject::compareBranchingObject
    5009 (const CbcBranchingObject* brObj, const bool replaceIfOverlap)
     5017(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
    50105018{
    50115019  throw("must implement");
     
    50855093   Can change objective etc */
    50865094void
    5087 CbcOneGeneralBranchingObject::checkIsCutoff(double cutoff)
     5095CbcOneGeneralBranchingObject::checkIsCutoff(double /*cutoff*/)
    50885096{
    50895097  assert (numberBranchesLeft());
     
    51045112int
    51055113CbcOneGeneralBranchingObject::compareOriginalObject
    5106 (const CbcBranchingObject* brObj) const
     5114(const CbcBranchingObject* /*brObj*/) const
    51075115{
    51085116  throw("must implement");
     
    51195127CbcRangeCompare
    51205128CbcOneGeneralBranchingObject::compareBranchingObject
    5121 (const CbcBranchingObject* brObj, const bool replaceIfOverlap)
     5129(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
    51225130{
    51235131  throw("must implement");
     
    53635371int
    53645372CbcDummyBranchingObject::compareOriginalObject
    5365 (const CbcBranchingObject* brObj) const
     5373(const CbcBranchingObject* /*brObj*/) const
    53665374{
    53675375  throw("must implement");
     
    53785386CbcRangeCompare
    53795387CbcDummyBranchingObject::compareBranchingObject
    5380 (const CbcBranchingObject* brObj, const bool replaceIfOverlap)
     5388(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
    53815389{
    53825390  throw("must implement");
  • trunk/Cbc/src/CbcBranchBase.cpp

    r1173 r1200  
    9999*/
    100100double
    101 CbcObject::infeasibility(const OsiSolverInterface * solver,int &preferredWay) const
    102 {
    103   assert (solver==model_->solver());
     101CbcObject::infeasibility(const OsiSolverInterface * /*solver*/,
     102                         int &preferredWay) const
     103{
     104  //assert (solver==model_->solver());
    104105  return infeasibility(preferredWay);
    105106}
     
    110111*/
    111112double
    112 CbcObject::feasibleRegion(OsiSolverInterface * solver) const
    113 {
    114   assert (solver==model_->solver());
     113CbcObject::feasibleRegion(OsiSolverInterface * /*solver*/) const
     114{
     115  //assert (solver==model_->solver());
    115116  CbcObject * fudge = const_cast<CbcObject *>(this);
    116117  fudge->feasibleRegion();
     
    134135*/
    135136double
    136 CbcObject::infeasibility(const OsiBranchingInformation * info,
     137CbcObject::infeasibility(const OsiBranchingInformation * /*info*/,
    137138                         int &preferredWay) const
    138139{
     
    145146*/
    146147double
    147 CbcObject::feasibleRegion(OsiSolverInterface * solver,const OsiBranchingInformation * info) const
    148 {
    149   assert (solver==model_->solver());
     148CbcObject::feasibleRegion(OsiSolverInterface * /*solver*/,
     149                          const OsiBranchingInformation * /*info*/) const
     150{
     151  //assert (solver==model_->solver());
    150152  CbcObject * fudge = const_cast<CbcObject *>(this);
    151153  fudge->feasibleRegion();
     
    159161*/
    160162OsiBranchingObject *
    161 CbcObject::createBranch(OsiSolverInterface * solver, int way) const
    162 {
    163   assert (solver==model_->solver());
     163CbcObject::createBranch(OsiSolverInterface * /*solver*/, int way) const
     164{
     165  //assert (solver==model_->solver());
    164166  CbcObject * fudge = const_cast<CbcObject *>(this);
    165167  return fudge->createBranch(way);
     
    171173*/
    172174OsiBranchingObject *
    173 CbcObject::createBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) const
    174 {
    175   assert (solver==model_->solver());
     175CbcObject::createBranch(OsiSolverInterface * /*solver*/,
     176                        const OsiBranchingInformation * /*info*/,
     177                        int way) const
     178{
     179  //assert (solver==model_->solver());
    176180  CbcObject * fudge = const_cast<CbcObject *>(this);
    177181  return fudge->createBranch(way);
     
    190194   Assumes can get information from solver */
    191195CbcObjectUpdateData
    192 CbcObject::createUpdateInformation(const OsiSolverInterface * solver,
    193                                                         const CbcNode * node,
    194                                                         const CbcBranchingObject * branchingObject)
     196CbcObject::createUpdateInformation(const OsiSolverInterface * /*solver*/,
     197                                   const CbcNode * /*node*/,
     198                                   const CbcBranchingObject * /*branchingObject*/)
    195199{
    196200  return CbcObjectUpdateData();
     
    274278int
    275279CbcBranchDecision::bestBranch (CbcBranchingObject ** objects, int numberObjects,
    276                                int numberUnsatisfied,
     280                               int /*numberUnsatisfied*/,
    277281                               double * changeUp, int * numberInfeasibilitiesUp,
    278282                               double * changeDown, int * numberInfeasibilitiesDown,
    279                                double objectiveValue)
     283                               double /*objectiveValue*/)
    280284{
    281285  int bestWay=0;
     
    322326
    323327// Copy constructor
    324 CbcConsequence::CbcConsequence ( const CbcConsequence & rhs)
     328CbcConsequence::CbcConsequence ( const CbcConsequence & /*rhs*/)
    325329{
    326330}
  • trunk/Cbc/src/CbcBranchBase.hpp

    r1173 r1200  
    195195    Bounds may be tightened, so it may be good to be able to set this info in object.
    196196   */
    197   virtual void resetBounds(const OsiSolverInterface * solver) {}
     197  virtual void resetBounds(const OsiSolverInterface * ) {}
    198198 
    199199  /** Returns floor and ceiling i.e. closest valid points
     
    210210
    211211  /// Update object by CbcObjectUpdateData
    212   virtual void updateInformation(const CbcObjectUpdateData & data) {}
     212  virtual void updateInformation(const CbcObjectUpdateData & ) {}
    213213
    214214  /// Identifier (normally column number in matrix)
     
    250250  { preferredWay_=value;}
    251251  /// Redoes data when sequence numbers change
    252   virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns) {}
     252  virtual void redoSequenceEtc(CbcModel * , int , const int * ) {}
    253253 
    254254protected:
     
    310310      The object mention in incoming CbcStrongInfo must match.
    311311      Returns nonzero if skip is wanted */
    312   virtual int fillStrongInfo( CbcStrongInfo & info) {return 0;}
     312  virtual int fillStrongInfo( CbcStrongInfo & ) {return 0;}
    313313  /// Reset number of branches left to original
    314314  inline void resetNumberBranchesLeft()
     
    331331             Returns change in guessed objective on next branch
    332332  */
    333   virtual double branch(OsiSolverInterface * solver)
     333  virtual double branch(OsiSolverInterface * )
    334334  { return branch();}
    335335  /** Update bounds in solver as in 'branch' and update given bounds.
    336336      branchState is -1 for 'down' +1 for 'up' */
    337   virtual void fix(OsiSolverInterface * solver,
    338                    double * lower, double * upper,
    339                    int branchState) const {}
     337  virtual void fix(OsiSolverInterface * ,
     338                   double * , double * ,
     339                   int ) const {}
    340340
    341341  /** Reset every information so that the branching object appears to point to
     
    512512  /** Saves a clone of current branching object.  Can be used to update
    513513      information on object causing branch - after branch */
    514   virtual void saveBranchingObject(OsiBranchingObject * object) {}
     514  virtual void saveBranchingObject(OsiBranchingObject * ) {}
    515515  /** Pass in information on branch just done.
    516516      assumes object can get information from solver */
    517   virtual void updateInformation(OsiSolverInterface * solver,
    518                                  const CbcNode * node) {}
     517  virtual void updateInformation(OsiSolverInterface * ,
     518                                 const CbcNode * ) {}
    519519  /** Sets or gets best criterion so far */
    520   virtual void setBestCriterion(double value) {}
     520  virtual void setBestCriterion(double ) {}
    521521  virtual double getBestCriterion() const {return 0.0;}
    522522  /// Create C++ lines to get to current state
    523   virtual void generateCpp( FILE * fp) {}
     523  virtual void generateCpp( FILE * ) {}
    524524  /// Model
    525525  inline CbcModel * cbcModel() const
  • trunk/Cbc/src/CbcBranchCut.cpp

    r1173 r1200  
    5050// Assignment operator
    5151CbcBranchCut &
    52 CbcBranchCut::operator=( const CbcBranchCut& rhs)
     52CbcBranchCut::operator=( const CbcBranchCut& /*rhs*/)
    5353{
    5454  return *this;
     
    8686// Creates a branching object
    8787CbcBranchingObject *
    88 CbcBranchCut::createBranch(int way)
     88CbcBranchCut::createBranch(int /*way*/)
    8989{
    9090  throw CoinError("Use of base class","createBranch","CbcBranchCut");
     
    436436// Creates a branching object
    437437CbcBranchingObject *
    438 CbcBranchToFixLots::createBranch(int way)
     438CbcBranchToFixLots::createBranch(int /*way*/)
    439439{
    440440  // by default way must be -1
    441   assert (way==-1);
     441  //assert (way==-1);
    442442  OsiSolverInterface * solver = model_->solver();
    443443  const double * solution = model_->testSolution();
     
    946946// Creates a branching object
    947947CbcBranchingObject *
    948 CbcBranchAllDifferent::createBranch(int way)
     948CbcBranchAllDifferent::createBranch(int /*way*/)
    949949{
    950950  // by default way must be -1
    951   assert (way==-1);
     951  //assert (way==-1);
    952952  const double * solution = model_->testSolution();
    953953  double * values = new double[numberInSet_];
  • trunk/Cbc/src/CbcBranchDynamic.cpp

    r1199 r1200  
    2121#ifdef COIN_DEVELOP
    2222typedef struct {
     23  double sumUp_;
     24  double upEst_; // or change in obj in update
     25  double sumDown_;
     26  double downEst_; // or movement in value in update
     27  int sequence_;
     28  int numberUp_;
     29  int numberUpInf_;
     30  int numberDown_;
     31  int numberDownInf_;
    2332  char where_;
    2433  char status_;
    25   unsigned short sequence_;
    26   int numberUp_;
    27   int numberUpInf_;
    28   float sumUp_;
    29   float upEst_; // or change in obj in update
    30   int numberDown_;
    31   int numberDownInf_;
    32   float sumDown_;
    33   float downEst_; // or movement in value in update
    3434} History;
    3535History * history=NULL;
     
    267267*/
    268268CbcSimpleIntegerDynamicPseudoCost::CbcSimpleIntegerDynamicPseudoCost (CbcModel * model,
    269                                     int dummy, int iColumn, double downDynamicPseudoCost,
     269                                                                      int /*dummy*/,
     270                                                                      int iColumn, double downDynamicPseudoCost,
    270271                                                        double upDynamicPseudoCost)
    271272{
     
    808809
    809810double
    810 CbcSimpleIntegerDynamicPseudoCost::infeasibility(const OsiSolverInterface * solver, const OsiBranchingInformation * info,
     811CbcSimpleIntegerDynamicPseudoCost::infeasibility(const OsiSolverInterface * /*solver*/,
     812                                                 const OsiBranchingInformation * info,
    811813                         int & preferredWay) const
    812814{
     
    919921// Creates a branching object
    920922CbcBranchingObject *
    921 CbcSimpleIntegerDynamicPseudoCost::createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way)
     923CbcSimpleIntegerDynamicPseudoCost::createBranch(OsiSolverInterface * /*solver*/,
     924                                                const OsiBranchingInformation * info, int way)
    922925{
    923926  double value = info->solution_[columnNumber_];
     
    14041407                                                      int variable, int way,
    14051408                                                      double lowerValue,
    1406                                                       double upperValue)
     1409                                                                          double /*upperValue*/)
    14071410  :CbcIntegerBranchingObject(model,variable,way,lowerValue)
    14081411{
     
    15311534// Initialize i.e. before start of choosing at a node
    15321535void
    1533 CbcBranchDynamicDecision::initialize(CbcModel * model)
     1536CbcBranchDynamicDecision::initialize(CbcModel * /*model*/)
    15341537{
    15351538  bestCriterion_ = 0.0;
     
    17411744int
    17421745CbcBranchDynamicDecision::betterBranch(CbcBranchingObject * thisOne,
    1743                             CbcBranchingObject * bestSoFar,
     1746                                       CbcBranchingObject * /*bestSoFar*/,
    17441747                            double changeUp, int numInfUp,
    17451748                            double changeDown, int numInfDown)
     
    19601963  FILE * fp = fopen(file,"w");
    19611964  assert(fp);
    1962   unsigned short numberIntegers=0;
     1965  int numberIntegers=0;
    19631966  int i;
    19641967  for (i=0;i<numberHistory;i++) {
  • trunk/Cbc/src/CbcBranchDynamic.hpp

    r1173 r1200  
    3333 
    3434  // Useful constructor - passed  model index and pseudo costs
    35   CbcSimpleIntegerDynamicPseudoCost (CbcModel * model, int dummy, int iColumn,
     35  CbcSimpleIntegerDynamicPseudoCost (CbcModel * model,int dummy, int iColumn,
    3636                              double downDynamicPseudoCost, double upDynamicPseudoCost);
    3737 
  • trunk/Cbc/src/CbcBranchLotsize.cpp

    r1173 r1200  
    3131// Just for debug (CBC_PRINT defined in CbcBranchLotsize.cpp)
    3232void
     33#if CBC_PRINT
    3334CbcLotsize::printLotsize(double value,bool condition,int type) const
     35#else
     36CbcLotsize::printLotsize(double ,bool ,int ) const
     37#endif
    3438{
    3539#if CBC_PRINT
     
    399403void
    400404CbcLotsize::floorCeiling(double & floorLotsize, double & ceilingLotsize, double value,
    401                          double tolerance) const
     405                         double /*tolerance*/) const
    402406{
    403407  bool feasible=findRange(value);
     
    644648 */
    645649void
    646 CbcLotsize::resetBounds(const OsiSolverInterface * solver)
     650CbcLotsize::resetBounds(const OsiSolverInterface * /*solver*/)
    647651{
    648652}
  • trunk/Cbc/src/CbcCompareBase.hpp

    r1173 r1200  
    3030  // This allows any method to change behavior as it is called
    3131  // after each solution
    32   virtual void newSolution(CbcModel * model) {}
     32  virtual void newSolution(CbcModel * ) {}
    3333
    3434  // This Also allows any method to change behavior as it is called
    3535  // after each solution
    36   virtual void newSolution(CbcModel * model,
    37                            double objectiveAtContinuous,
    38                            int numberInfeasibilitiesAtContinuous) {}
     36  virtual void newSolution(CbcModel * ,
     37                           double ,
     38                           int ) {}
    3939
    4040  // This allows any method to change behavior as it is called
    4141  // after every 1000 nodes.
    4242  // Return true if want tree re-sorted
    43   virtual bool every1000Nodes(CbcModel * model,int numberNodes) {return false;}
     43  virtual bool every1000Nodes(CbcModel * ,int ) {return false;}
    4444
    4545  /** Returns true if wants code to do scan with alternate criterion
     
    5050  virtual ~CbcCompareBase() {}
    5151  /// Create C++ lines to get to current state
    52   virtual void generateCpp( FILE * fp) {}
     52  virtual void generateCpp( FILE * ) {}
    5353
    5454  // Copy constructor
     
    6767
    6868  /// This is test function
    69   virtual bool test (CbcNode * x, CbcNode * y) {return true;}
     69  virtual bool test (CbcNode * , CbcNode * ) {return true;}
    7070
    7171  /// This is alternate test function
  • trunk/Cbc/src/CbcCutGenerator.cpp

    r1199 r1200  
    102102  switches_ = rhs.switches_;
    103103  timeInCutGenerator_ = rhs.timeInCutGenerator_;
     104  savedCuts_ = rhs.savedCuts_;
    104105  inaccuracy_ = rhs.inaccuracy_;
    105106  numberTimes_ = rhs.numberTimes_;
     
    129130    switches_ = rhs.switches_;
    130131    timeInCutGenerator_ = rhs.timeInCutGenerator_;
     132    savedCuts_ = rhs.savedCuts_;
    131133    inaccuracy_ = rhs.inaccuracy_;
    132134    numberTimes_ = rhs.numberTimes_;
     
    186188  //OsiSolverInterface * solver = model_->solver();
    187189  int pass=model_->getCurrentPassNumber()-1;
     190  // Reset cuts on first pass
     191  if (!pass)
     192    savedCuts_ = OsiCuts();
    188193  bool doThis=(model_->getNodeCount()%howOften)==0;
    189194  if (depthCutGenerator_>0) {
     
    498503      }
    499504    }
     505    // Add in saved cuts if violated
     506    if (false&&!depth) {
     507      const double * solution = solver->getColSolution();
     508      double primalTolerance = 1.0e-7;
     509      int numberCuts = savedCuts_.sizeRowCuts() ;
     510      for (int k = numberCuts-1;k>=0;k--) {
     511        const OsiRowCut * thisCut = savedCuts_.rowCutPtr(k) ;
     512        double sum=0.0;
     513        int n=thisCut->row().getNumElements();
     514        const int * column = thisCut->row().getIndices();
     515        const double * element = thisCut->row().getElements();
     516        assert (n);
     517        for (int i=0;i<n;i++) {
     518          double value = element[i];
     519          sum += value*solution[column[i]];
     520        }
     521        if (sum>thisCut->ub()+primalTolerance) {
     522          sum= sum-thisCut->ub();
     523        } else if (sum<thisCut->lb()-primalTolerance) {
     524          sum= thisCut->lb()-sum;
     525        } else {
     526          sum=0.0;
     527        }
     528        if (sum) {
     529          // add to candidates and take out here
     530          cs.insert(*thisCut);
     531          savedCuts_.eraseRowCut(k);
     532        }
     533      }
     534    }
    500535    {
    501536      int numberRowCutsAfter = cs.sizeRowCuts() ;
     
    768803          const OsiRowCut * thisCut = cs.rowCutPtr(iCut) ;
    769804          int n=thisCut->row().getNumElements();
     805          if (n&&sort[k]) {
     806            // add to saved cuts
     807            savedCuts_.insert(*thisCut);
     808          }
    770809          nDelete-=n;
    771810          k++;
     
    870909
    871910// Copy constructor
    872 CbcCutModifier::CbcCutModifier ( const CbcCutModifier & rhs)
     911CbcCutModifier::CbcCutModifier ( const CbcCutModifier & /*rhs*/)
    873912{
    874913}
     
    933972*/
    934973int
    935 CbcCutSubsetModifier::modify(const OsiSolverInterface * solver, OsiRowCut & cut)
     974CbcCutSubsetModifier::modify(const OsiSolverInterface * /*solver*/,
     975                             OsiRowCut & cut)
    936976{
    937977  int n=cut.row().getNumElements();
  • trunk/Cbc/src/CbcCutGenerator.hpp

    r1180 r1200  
    271271  { switches_&=~256;switches_ |= yesNo ? 256 : 0;}
    272272  //@}
     273  /// Saved cuts
     274  OsiCuts savedCuts_;
    273275  /// Time in cut generator
    274276  double timeInCutGenerator_;
    275277  /// The client model
    276   CbcModel *model_;
     278  CbcModel *model_; 
    277279
    278280  // The CglCutGenerator object
     
    355357  virtual int modify(const OsiSolverInterface * solver, OsiRowCut & cut) =0;
    356358  /// Create C++ lines to get to current state
    357   virtual void generateCpp( FILE * fp) {}
     359  virtual void generateCpp( FILE * ) {}
    358360protected:
    359361 
     
    399401  virtual int modify(const OsiSolverInterface * solver, OsiRowCut & cut) ;
    400402  /// Create C++ lines to get to current state
    401   virtual void generateCpp( FILE * fp) {}
     403  virtual void generateCpp( FILE * ) {}
    402404protected:
    403405  /// data
  • trunk/Cbc/src/CbcFathom.cpp

    r1173 r1200  
    6767//-------------------------------------------------------------------
    6868OsiSolverInterface *
    69 CbcOsiSolver::clone(bool copyData) const
     69CbcOsiSolver::clone(bool /*copyData*/) const
    7070{
    71   assert (copyData);
     71  //assert (copyData);
    7272  return new CbcOsiSolver(*this);
    7373}
     
    7979CbcOsiSolver::CbcOsiSolver (
    8080                  const CbcOsiSolver & rhs)
    81   : OsiClpSolverInterface(rhs)
     81  : OsiSolverInterface(), // Should not be needed but get warning
     82  OsiClpSolverInterface(rhs)
    8283{
    8384  cbcModel_ = rhs.cbcModel_;
  • trunk/Cbc/src/CbcFeasibilityBase.hpp

    r1173 r1200  
    3232     1 pretend integer solution
    3333  */
    34   virtual int feasible(CbcModel * model, int mode) {return 0;}
     34  virtual int feasible(CbcModel * , int ) {return 0;}
    3535
    3636  virtual ~CbcFeasibilityBase() {}
    3737
    3838  // Copy constructor
    39   CbcFeasibilityBase ( const CbcFeasibilityBase & rhs)
     39  CbcFeasibilityBase ( const CbcFeasibilityBase & )
    4040  {}
    4141   
    4242  // Assignment operator
    43   CbcFeasibilityBase & operator=( const CbcFeasibilityBase& rhs)
     43  CbcFeasibilityBase & operator=( const CbcFeasibilityBase& )
    4444  { 
    4545    return *this;
  • trunk/Cbc/src/CbcHeuristic.hpp

    r1173 r1200  
    113113      Default is do nothing
    114114  */
    115   virtual int solution(double & objectiveValue,
    116                        double * newSolution,
    117                        OsiCuts & cs) {return 0;}
     115  virtual int solution(double & /*objectiveValue*/,
     116                       double * /*newSolution*/,
     117                       OsiCuts & /*cs*/) {return 0;}
    118118
    119119  /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
     
    197197                          double cutoff , std::string name) const;
    198198  /// Create C++ lines to get to current state
    199   virtual void generateCpp( FILE * fp) {}
     199  virtual void generateCpp( FILE * ) {}
    200200  /// Create C++ lines to get to current state - does work for base class
    201201  void generateCpp( FILE * fp,const char * heuristic) ;
     
    542542      This is dummy as never called
    543543  */
    544   virtual bool selectVariableToBranch(OsiSolverInterface* solver,
    545                                       const double* newSolution,
    546                                       int& bestColumn,
    547                                       int& bestRound)
     544  virtual bool selectVariableToBranch(OsiSolverInterface* /*solver*/,
     545                                      const double* /*newSolution*/,
     546                                      int& /*bestColumn*/,
     547                                      int& /*bestRound*/)
    548548  { return true;}
    549549  /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
  • trunk/Cbc/src/CbcHeuristicDive.hpp

    r1173 r1200  
    3232
    3333  /// Create C++ lines to get to current state
    34   virtual void generateCpp( FILE * fp) {}
     34  virtual void generateCpp( FILE * ) {}
    3535
    3636  /// Create C++ lines to get to current state - does work for base class
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r1199 r1200  
    189189// Resets stuff if model changes
    190190void
    191 CbcHeuristicFPump::resetModel(CbcModel * model)
     191CbcHeuristicFPump::resetModel(CbcModel * )
    192192{
    193193}
     
    632632        randomNumberGenerator_.setSeed(987654321);
    633633      }
    634       returnCode = rounds(solver, newSolution,saveObjective,numberIntegers,integerVariable,
    635                           pumpPrint,numberPasses,roundExpensive_,defaultRounding_,&flip);
     634      returnCode = rounds(solver, newSolution,/*saveObjective,*/
     635                          numberIntegers,integerVariable,
     636                          /*pumpPrint,*/numberPasses,
     637                          /*roundExpensive_,*/defaultRounding_,&flip);
    636638      if (numberPasses==0&&false) {
    637639        // Make sure random will be different
     
    920922          memcpy(newSolution,solution,numberColumns*sizeof(double));
    921923          int flip;
    922           returnCode = rounds(solver, newSolution,saveObjective,numberIntegers,integerVariable,
    923                               pumpPrint,numberPasses,roundExpensive_,defaultRounding_,&flip);
     924          returnCode = rounds(solver, newSolution,/*saveObjective,*/
     925                              numberIntegers,integerVariable,
     926                              /*pumpPrint,*/numberPasses,
     927                              /*roundExpensive_,*/defaultRounding_,&flip);
    924928          numberPasses++;
    925929          if (returnCode) {
     
    19311935int
    19321936CbcHeuristicFPump::rounds(OsiSolverInterface * solver,double * solution,
    1933                           const double * objective,
     1937                          //const double * objective,
    19341938                          int numberIntegers, const int * integerVariable,
    1935                           char * pumpPrint, int iter,
    1936                           bool roundExpensive, double downValue, int *flip)
     1939                          /*char * pumpPrint,*/ int iter,
     1940                          /*bool roundExpensive,*/ double downValue, int *flip)
    19371941{
    19381942  double integerTolerance = model_->getDblParam(CbcModel::CbcIntegerTolerance);
  • trunk/Cbc/src/CbcHeuristicFPump.hpp

    r1173 r1200  
    215215      returns 0 if current is solution
    216216  */
    217   int rounds(OsiSolverInterface * solver,double * solution, const double * objective,
     217  int rounds(OsiSolverInterface * solver,double * solution,
     218             /*const double * objective, */
    218219             int numberIntegers, const int * integerVariable,
    219              char * pumpPrint,int passNumber,
    220              bool roundExpensive=false,
     220             /*char * pumpPrint,*/int passNumber,
     221             /*bool roundExpensive=false,*/
    221222             double downValue=0.5, int *flip=0);
    222223  /* note for eagle eyed readers.
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r1173 r1200  
    110110// Resets stuff if model changes
    111111void
    112 CbcHeuristicLocal::resetModel(CbcModel * model)
     112CbcHeuristicLocal::resetModel(CbcModel * /*model*/)
    113113{
    114114  //CbcHeuristic::resetModel(model);
     
    126126CbcHeuristicLocal::solutionFix(double & objectiveValue,
    127127                            double * newSolution,
    128                             const int * keep)
     128                               const int * /*keep*/)
    129129{
    130130  numCouldRun_++;
  • trunk/Cbc/src/CbcHeuristicPivotAndFix.cpp

    r1173 r1200  
    7575// Resets stuff if model changes
    7676void
    77 CbcHeuristicPivotAndFix::resetModel(CbcModel * model)
     77CbcHeuristicPivotAndFix::resetModel(CbcModel * /*model*/)
    7878{
    7979  //CbcHeuristic::resetModel(model);
     
    8383  Returns 1 if solution, 0 if not */
    8484int
    85 CbcHeuristicPivotAndFix::solution(double & solutionValue,
    86                          double * betterSolution)
     85CbcHeuristicPivotAndFix::solution(double & /*solutionValue*/,
     86                                  double * /*betterSolution*/)
    8787{
    8888
     
    559559
    560560// update model
    561 void CbcHeuristicPivotAndFix::setModel(CbcModel * model)
     561void CbcHeuristicPivotAndFix::setModel(CbcModel * )
    562562{
    563563  // probably same as resetModel
  • trunk/Cbc/src/CbcHeuristicRINS.cpp

    r1173 r1200  
    2626  numberSuccesses_=0;
    2727  numberTries_=0;
     28  lastNode_=-999999;
    2829  howOften_=100;
    2930  decayFactor_ = 0.5;
     
    3940  numberSuccesses_=0;
    4041  numberTries_=0;
     42  lastNode_=-999999;
    4143  howOften_=100;
    4244  decayFactor_ = 0.5;
     
    7173    numberSuccesses_ = rhs.numberSuccesses_;
    7274    numberTries_ = rhs.numberTries_;
     75    lastNode_=rhs.lastNode_;
    7376    delete [] used_;
    7477    if (model_&&rhs.used_) {
     
    106109  decayFactor_(rhs.decayFactor_),
    107110  numberSuccesses_(rhs.numberSuccesses_),
    108   numberTries_(rhs.numberTries_)
     111  numberTries_(rhs.numberTries_),
     112  lastNode_(rhs.lastNode_)
    109113{
    110114  if (model_&&rhs.used_) {
     
    118122// Resets stuff if model changes
    119123void
    120 CbcHeuristicRINS::resetModel(CbcModel * model)
     124CbcHeuristicRINS::resetModel(CbcModel * /*model*/)
    121125{
    122126  //CbcHeuristic::resetModel(model);
     
    171175    }
    172176  }
    173   if ((model_->getNodeCount()%howOften_)==0&&(model_->getCurrentPassNumber()==1||model_->getCurrentPassNumber()==999999)) {
     177  int numberNodes=model_->getNodeCount();
     178  if (howOften_==100) {
     179    if (numberNodes<lastNode_+12)
     180      return 0;
     181    // Do at 50 and 100
     182    if ((numberNodes>40&&numberNodes<=50)||(numberNodes>90&&numberNodes<100))
     183      numberNodes=howOften_;
     184  }
     185  if ((numberNodes%howOften_)==0&&(model_->getCurrentPassNumber()==1||
     186                                   model_->getCurrentPassNumber()==999999)) {
     187    lastNode_=model_->getNodeCount();
    174188    OsiSolverInterface * solver = model_->solver();
    175189
     
    292306// Resets stuff if model changes
    293307void
    294 CbcHeuristicRENS::resetModel(CbcModel * model)
     308CbcHeuristicRENS::resetModel(CbcModel * )
    295309{
    296310}
     
    490504// Resets stuff if model changes
    491505void
    492 CbcHeuristicDINS::resetModel(CbcModel * model)
     506CbcHeuristicDINS::resetModel(CbcModel * )
    493507{
    494508  //CbcHeuristic::resetModel(model);
  • trunk/Cbc/src/CbcHeuristicRINS.hpp

    r1173 r1200  
    7777  /// Number of tries
    7878  int numberTries_;
     79  /// Node when last done
     80  int lastNode_;
    7981  /// Whether a variable has been in a solution
    8082  char * used_;
  • trunk/Cbc/src/CbcHeuristicRandRound.cpp

    r1173 r1200  
    126126
    127127  OsiSolverInterface * solver= model_->solver()->clone();
     128  double primalTolerance ;
     129  solver->getDblParam(OsiPrimalTolerance,primalTolerance) ;
    128130  OsiClpSolverInterface * clpSolver = dynamic_cast<OsiClpSolverInterface *> (solver);
    129131  assert (clpSolver);
     
    254256            // if the element is zero, then set the new obj
    255257            // coefficient to 0.1 (i.e., round up)
    256             if(fabs(matrix[index[i]][j]) < 1e-6)
     258            if(fabs(matrix[index[i]][j]) < primalTolerance)
    257259              newObj[j] = 0.1;
    258260            else
     
    264266            // if the element is zero, then set the new obj coeffient
    265267            // to NEGATIVE 0.1 (i.e., round down)
    266             if(fabs(matrix[index[i]][j]) < 1e-6)
     268            if(fabs(matrix[index[i]][j]) < primalTolerance)
    267269              newObj[j] = -0.1;
    268270            else
     
    337339                {
    338340                  double closest=floor(cornerPoints[i][j]+0.5);
    339                   if(fabs(cornerPoints[i][j] - closest)>1e-6)
     341                  if(fabs(cornerPoints[i][j] - closest)>primalTolerance)
    340342                    {
    341343                      feasibility = 0;
     
    354356                        lhs += matrix[irow][j] * cornerPoints[i][j];
    355357                      }
    356                     if(rowSense[irow] == 'L' && lhs > rhs[irow] + 1e-6)
     358                    if(rowSense[irow] == 'L' && lhs > rhs[irow] + primalTolerance)
    357359                      {
    358360                        feasibility = 0;
    359361                        break;
    360362                      }
    361                     if(rowSense[irow] == 'G' && lhs < rhs[irow] - 1e-6)
     363                    if(rowSense[irow] == 'G' && lhs < rhs[irow] - primalTolerance)
    362364                      {
    363365                        feasibility = 0;
    364366                        break;
    365367                      }
    366                     if(rowSense[irow] == 'E' && (lhs - rhs[irow] > 1e-6 || lhs - rhs[irow] < -1e-6))
     368                    if(rowSense[irow] == 'E' && (lhs - rhs[irow] > primalTolerance || lhs - rhs[irow] < -primalTolerance))
    367369                      {
    368370                        feasibility = 0;
     
    470472                  lhs += matrix[i][j] * roundRp[j];
    471473                }
    472               if(rowSense[i] == 'L' && lhs > rhs[i] + 1e-6)
     474              if(rowSense[i] == 'L' && lhs > rhs[i] + primalTolerance)
    473475                {
    474476                  feasibility = 0;
    475477                  break;
    476478                }
    477               if(rowSense[i] == 'G' && lhs < rhs[i] - 1e-6)
     479              if(rowSense[i] == 'G' && lhs < rhs[i] - primalTolerance)
    478480                {
    479481                  feasibility = 0;
    480482                  break;
    481483                }
    482               if(rowSense[i] == 'E' && (lhs - rhs[i] > 1e-6 || lhs - rhs[i] < -1e-6))
     484              if(rowSense[i] == 'E' && (lhs - rhs[i] > primalTolerance || lhs - rhs[i] < -primalTolerance))
    483485                {
    484486                  feasibility = 0;
  • trunk/Cbc/src/CbcLinked.cpp

    r1180 r1200  
    30843084//-------------------------------------------------------------------
    30853085OsiSolverInterface *
    3086 OsiSolverLink::clone(bool copyData) const
    3087 {
    3088   assert (copyData);
     3086OsiSolverLink::clone(bool /*copyData*/) const
     3087{
     3088  //assert (copyData);
    30893089  OsiSolverLink * newModel = new OsiSolverLink(*this);
    30903090  return newModel;
     
    30973097OsiSolverLink::OsiSolverLink (
    30983098                  const OsiSolverLink & rhs)
    3099   : CbcOsiSolver(rhs)
     3099  : OsiSolverInterface(rhs),
     3100  CbcOsiSolver(rhs)
    31003101{
    31013102  gutsOfDestructor(true);
     
    38303831  }
    38313832  boundElementAction action;
    3832   action.affect=upperBoundAffected ? 1 : 0;
    3833   action.ubUsed=useUpperBound ? 1 : 0;
     3833  action.affect=static_cast<unsigned char>(upperBoundAffected ? 1 : 0);
     3834  action.ubUsed=static_cast<unsigned char>(useUpperBound ? 1 : 0);
    38343835  action.type=2;
    3835   action.affected=whichVariable;
     3836  action.affected=static_cast<short int>(whichVariable);
    38363837  action.multiplier=multiplier;
    38373838  affected_[numberAffected_++]=action;
     
    39923993
    39933994// Useful constructor (which are indices)
    3994 OsiOldLink::OsiOldLink (const OsiSolverInterface * solver,  int numberMembers,
    3995            int numberLinks, int first , const double * weights, int identifier)
     3995OsiOldLink::OsiOldLink (const OsiSolverInterface * /*solver*/,  int numberMembers,
     3996                        int numberLinks, int first , const double * weights, int /*identifier*/)
    39963997  : OsiSOS(),
    39973998    numberLinks_(numberLinks)
     
    40254026
    40264027// Useful constructor (which are indices)
    4027 OsiOldLink::OsiOldLink (const OsiSolverInterface * solver,  int numberMembers,
    4028            int numberLinks, int sosType, const int * which , const double * weights, int identifier)
     4028OsiOldLink::OsiOldLink (const OsiSolverInterface * /*solver*/,  int numberMembers,
     4029                        int numberLinks, int /*sosType*/, const int * which ,
     4030                        const double * weights, int /*identifier*/)
    40294031  : OsiSOS(),
    40304032    numberLinks_(numberLinks)
     
    61036105// Creates a branching object
    61046106OsiBranchingObject *
    6105 OsiBiLinear::createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const
     6107OsiBiLinear::createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * /*info*/, int way) const
    61066108{
    61076109  // create object
     
    65906592  int way;
    65916593  double saveInfeasibility = infeasibility_;
    6592   int saveWhichWay = whichWay_;
     6594  short int saveWhichWay = whichWay_;
    65936595  double saveXyBranchValue = xyBranchValue_;
    65946596  short saveChosen = chosen_;
     
    66136615                                                        int chosen)
    66146616  :OsiTwoWayBranchingObject(solver,set,way,separator),
    6615    chosen_(chosen)
     6617   chosen_(static_cast<short int>(chosen))
    66166618{
    66176619  assert (chosen_>=0&&chosen_<2);
     
    66696671// Print what would happen 
    66706672void
    6671 OsiBiLinearBranchingObject::print(const OsiSolverInterface * solver)
     6673OsiBiLinearBranchingObject::print(const OsiSolverInterface * /*solver*/)
    66726674{
    66736675  const OsiBiLinear * set =
     
    71177119  if (preferredWay_>=0&&!satisfied)
    71187120    whichWay = preferredWay_;
    7119   whichWay_=whichWay;
     7121  whichWay_=static_cast<short int>(whichWay);
    71207122  return infeasibility_;
    71217123}
     
    71607162void
    71617163CglTemporary::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
    7162                              const CglTreeInfo info) const
     7164                           const CglTreeInfo /*info*/) const
    71637165{
    71647166  // Get basic problem information
     
    72197221  return *this;
    72207222}
    7221 void checkQP(ClpSimplex * model)
     7223void checkQP(ClpSimplex * /*model*/)
    72227224{
    72237225#if 0
     
    73367338//-------------------------------------------------------------------
    73377339OsiSolverInterface *
    7338 OsiSolverLinearizedQuadratic::clone(bool copyData) const
    7339 {
    7340   assert (copyData);
     7340OsiSolverLinearizedQuadratic::clone(bool /*copyData*/) const
     7341{
     7342  //assert (copyData);
    73417343  return new OsiSolverLinearizedQuadratic(*this);
    73427344}
     
    73487350OsiSolverLinearizedQuadratic::OsiSolverLinearizedQuadratic (
    73497351                  const OsiSolverLinearizedQuadratic & rhs)
    7350   : OsiClpSolverInterface(rhs)
     7352  : OsiSolverInterface(rhs)
     7353  , OsiClpSolverInterface(rhs)
    73517354{
    73527355  bestObjectiveValue_=rhs.bestObjectiveValue_;
     
    77067709approximateSolution(CoinModel & coinModel,
    77077710                    int numberPasses, double deltaTolerance,
    7708                     int mode)
     7711                    int /*mode*/)
    77097712{
    77107713#if 1
     
    82268229  if (preferredWay_>=0&&!satisfied)
    82278230    whichWay = preferredWay_;
    8228   whichWay_=whichWay;
     8231  whichWay_=static_cast<short int>(whichWay);
    82298232  return infeasibility_;
    82308233}
  • trunk/Cbc/src/CbcLinked.hpp

    r1173 r1200  
    321321private:
    322322  typedef struct {
     323    double multiplier; // to use in computation
     324    int affected; // variable or element affected
    323325    /*
    324326      0 - LB of variable affected
     
    326328      2 - element in position (affected) affected
    327329    */
    328     unsigned int affect:2;
    329     unsigned int ubUsed:1; // nonzero if UB of this variable is used
     330    unsigned char affect;
     331    unsigned char ubUsed; // nonzero if UB of this variable is used
    330332    /*
    331333       0 - use x*multiplier
     
    333335       2 - if UB use min of current upper and x*multiplier, if LB use max of current lower and x*multiplier
    334336    */
    335     unsigned int type:4; // type of computation
    336     unsigned int affected:25; // variable or element affected
    337     double multiplier; // to use in computation
     337    unsigned char type; // type of computation
    338338  } boundElementAction;
    339339 
  • trunk/Cbc/src/CbcMessage.cpp

    r1173 r1200  
    6666  {CBC_RESTART,44,1,"Reduced cost fixing - %d rows, %d columns - restarting search"},
    6767  {CBC_GENERAL,45,1,"%s"},
     68  {CBC_ROOT_DETAIL,46,2,"Root node pass %d, %d rows, %d total tight cuts  -  objective %g"},
    6869  {CBC_DUMMY_END,999999,0,""}
    6970};
  • trunk/Cbc/src/CbcMessage.hpp

    r1173 r1200  
    7070  CBC_RESTART,
    7171  CBC_GENERAL,
     72  CBC_ROOT_DETAIL,
    7273  CBC_DUMMY_END
    7374};
  • trunk/Cbc/src/CbcModel.cpp

    r1199 r1200  
     1
    12/* $Id$ */
    23// Copyright (C) 2002, International Business Machines
     
    1819//#define NODE_LOG
    1920//#define GLOBAL_CUTS_JUST_POINTERS
     21#ifdef CGL_DEBUG_GOMORY
     22extern int gomory_try;
     23#endif
    2024#include <cassert>
    2125#include <cmath>
     
    6064// include Probing
    6165#include "CglProbing.hpp"
     66#include "CglGomory.hpp"
     67#include "CglTwomir.hpp"
    6268// include preprocessing
    6369#include "CglPreProcess.hpp"
     
    58505856*/
    58515857void
    5852 CbcModel::synchronizeHandlers(int makeDefault)
     5858CbcModel::synchronizeHandlers(int /*makeDefault*/)
    58535859{
    58545860  if (!defaultHandler_) {
     
    63756381        !solver_->optimalBasisIsAvailable()) {
    63766382      //printf("XXXXYY no opt basis\n");
     6383#if 0//def COIN_HAS_CLP
     6384      //OsiClpSolverInterface * clpSolver
     6385      //= dynamic_cast<OsiClpSolverInterface *> (solver_);
     6386      int save=0;
     6387      if (clpSolver) {
     6388        save=clpSolver->specialOptions();
     6389        clpSolver->setSpecialOptions(save|2048/*4096*/);
     6390      }
     6391#endif
    63776392      resolve(node ? node->nodeInfo() : NULL,3);
     6393#if 0//def COIN_HAS_CLP
     6394      if (clpSolver)
     6395        clpSolver->setSpecialOptions(save);
     6396#ifdef CLP_INVESTIGATE
     6397      if(clpSolver->getModelPtr()->numberIterations())
     6398        printf("ITS %d pass %d\n",
     6399               clpSolver->getModelPtr()->numberIterations(),
     6400               currentPassNumber_);
     6401#endif
     6402#endif
    63786403    }
    63796404    if (nextRowCut_) {
     
    65116536        numberRowCutsAfter = theseCuts.sizeRowCuts() ;
    65126537        numberColumnCutsAfter = theseCuts.sizeColCuts() ;
    6513        
    65146538        if ((specialOptions_&1)!=0) {
    65156539          if (onOptimalPath) {
     
    65296553                    printf("%d bounds %g,%g\n",i,lower[i],upper[i]);
    65306554                }
     6555#ifdef CGL_DEBUG_GOMORY
     6556                printf("Value of gomory_try is %d, recompile with -%d\n",
     6557                       gomory_try,gomory_try);
     6558#endif
    65316559                abort();
    65326560              }
     
    66016629          }
    66026630        }
     6631      }
     6632      if (!node) {
     6633        handler_->message(CBC_ROOT_DETAIL,messages_)
     6634          <<currentPassNumber_
     6635          <<solver_->getNumRows()
     6636          <<solver_->getNumRows()-numberRowsAtContinuous_
     6637          <<solver_->getObjValue()
     6638          <<CoinMessageEol ;
    66036639      }
    66046640      if (violated >=0&&feasible) {
     
    71977233        delete basis;
    71987234      }
     7235      //solver_->setHintParam(OsiDoDualInResolve,false,OsiHintTry);
    71997236      feasible = ( resolve(node ? node->nodeInfo() : NULL,2) != 0) ;
     7237      //solver_->setHintParam(OsiDoDualInResolve,true,OsiHintTry);
    72007238      if ( getCurrentSeconds() > dblParam_[CbcMaximumSeconds] )
    72017239        numberTries=0; // exit
     
    72117249*/
    72127250    else
    7213     { numberTries = 0 ; }
     7251      { numberTries = 0 ;}
    72147252/*
    72157253  If the problem is still feasible, first, call takeOffCuts() to remove cuts
     
    85068544CbcModel *
    85078545CbcModel::findCliques(bool makeEquality,
    8508                       int atLeastThisMany, int lessThanThis, int defaultValue)
     8546                      int atLeastThisMany, int lessThanThis,
     8547                      int /*defaultValue*/)
    85098548{
    85108549  // No objects are allowed to exist
     
    1100211041    }
    1100311042    clpSolver->resolve();
     11043    if (!numberNodes_) {
     11044      double error = CoinMax(clpSimplex->largestDualError(),
     11045                             clpSimplex->largestPrimalError());
     11046      if (error>1.0e-2||!clpSolver->isProvenOptimal()) {
     11047#ifdef CLP_INVESTIGATE
     11048        printf("Problem was %s largest dual error %g largest primal %g - safer cuts\n",
     11049               clpSolver->isProvenOptimal() ? "optimal" : "!infeasible",
     11050               clpSimplex->largestDualError(),
     11051               clpSimplex->largestPrimalError());
     11052#endif
     11053        if (!clpSolver->isProvenOptimal()) {
     11054          clpSolver->setSpecialOptions(save2|2048);
     11055          clpSimplex->allSlackBasis(true);
     11056          clpSolver->resolve();
     11057        }
     11058        // make cuts safer
     11059        for (int iCutGenerator = 0;iCutGenerator<numberCutGenerators_;iCutGenerator++) {
     11060          CglCutGenerator * generator = generator_[iCutGenerator]->generator();
     11061          CglGomory * cgl1 = dynamic_cast<CglGomory *>(generator);
     11062          if (cgl1) {
     11063            cgl1->setLimitAtRoot(cgl1->getLimit());
     11064          }
     11065          CglTwomir * cgl2 = dynamic_cast<CglTwomir *>(generator);
     11066          if (cgl2) {
     11067            generator_[iCutGenerator]->setHowOften(-100);
     11068          }
     11069        }
     11070      }
     11071    }
    1100411072    clpSolver->setSpecialOptions(save2);
    1100511073#ifdef CLP_INVESTIGATE
     
    1141411482          lockThread();
    1141511483        newNode->nodeInfo()->addCuts(cuts,newNode->numberBranches(),
    11416                                      whichGenerator_,
     11484                                     //whichGenerator_,
    1141711485                                     initialNumber) ;
    1141811486        if (parallelMode()>0)
     
    1178211850// Create C++ lines to get to current state
    1178311851void
    11784 CbcModel::generateCpp( FILE * fp,int options)
     11852CbcModel::generateCpp( FILE * fp,int /*options*/)
    1178511853{
    1178611854  // Do cut generators
     
    1313513203// Start threads
    1313613204void
    13137 CbcModel::startSplitModel(int numberIterations)
     13205CbcModel::startSplitModel(int /*numberIterations*/)
    1313813206{
    1313913207  abort();
     
    1314113209// Merge models
    1314213210void
    13143 CbcModel::mergeModels(int numberModel, CbcModel ** model,
    13144                       int numberNodes)
     13211CbcModel::mergeModels(int /*numberModel*/, CbcModel ** /*model*/,
     13212                      int /*numberNodes*/)
    1314513213{
    1314613214  abort();
  • trunk/Cbc/src/CbcNode.cpp

    r1199 r1200  
    330330void
    331331CbcNodeInfo::addCuts (OsiCuts & cuts, int numberToBranchOn,
    332                       int * whichGenerator,int numberPointingToThis)
     332                      /*int * whichGenerator,*/int numberPointingToThis)
    333333{
    334334  int numberCuts = cuts.sizeRowCuts();
     
    23902390
    23912391int CbcNode::chooseDynamicBranch (CbcModel *model, CbcNode *lastNode,
    2392                                   OsiSolverBranch * & branches,int numberPassesLeft)
     2392                                  OsiSolverBranch * & /*branches*/,
     2393                                  int numberPassesLeft)
    23932394 
    23942395{ if (lastNode)
     
    26892690      int bestPriority=COIN_INT_MAX;
    26902691      int number01 = 0;
    2691       const fixEntry * entry = NULL;
     2692      const cliqueEntry * entry = NULL;
    26922693      const int * toZero = NULL;
    26932694      const int * toOne = NULL;
     
    43744375
    43754376
    4376 CbcNode::CbcNode(const CbcNode & rhs)
     4377CbcNode::CbcNode(const CbcNode & rhs)
     4378  : CoinTreeNode(rhs)
    43774379
    43784380#ifdef CHECK_NODE
  • trunk/Cbc/src/CbcNode.hpp

    r1173 r1200  
    178178  { parent_=NULL;}
    179179
    180   void addCuts(OsiCuts & cuts,int numberToBranch, int * whichGenerator
    181                ,int numberPointingToThis);
     180  void addCuts(OsiCuts & cuts,int numberToBranch, //int * whichGenerator,
     181               int numberPointingToThis);
    182182  void addCuts(int numberCuts, CbcCountRowCut ** cuts,int numberToBranch);
    183183  /** Delete cuts (decrements counts)
  • trunk/Cbc/src/CbcSolver.cpp

    r1199 r1200  
    113113}
    114114#else
    115 void stolen_from_ekk_memory(void * dummy,int type)
    116 {
    117 }
    118 bool malloc_counts_on=false;
     115//void stolen_from_ekk_memory(void * dummy,int type)
     116//{
     117//}
     118//bool malloc_counts_on=false;
    119119#endif
    120120//#define DMALLOC
     
    505505  parameters_[whichParam(PROBINGCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
    506506  parameters_[whichParam(KNAPSACKCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
     507#ifdef ZERO_HALF_CUTS
    507508  parameters_[whichParam(ZEROHALFCUTS,numberParameters_,parameters_)].setCurrentOption("off");
     509#endif
    508510  parameters_[whichParam(REDSPLITCUTS,numberParameters_,parameters_)].setCurrentOption("off");
    509511  parameters_[whichParam(CLIQUECUTS,numberParameters_,parameters_)].setCurrentOption("ifmove");
     
    764766}
    765767// Copy constructor
    766 CbcStopNow::CbcStopNow ( const CbcStopNow & rhs)
     768CbcStopNow::CbcStopNow ( const CbcStopNow & )
    767769{
    768770}
     
    828830
    829831extern "C" {
    830    static void signal_handler(int whichSignal)
     832  static void signal_handler(int /*whichSignal*/)
    831833   {
    832834     if (currentBranchModel!=NULL) {
     
    12301232  On output - number fixed
    12311233*/
    1232 static OsiClpSolverInterface * fixVubs(CbcModel & model, int skipZero2,
    1233                                        int & doAction, CoinMessageHandler * generalMessageHandler,
    1234                                        const double * lastSolution, double dextra[6],
    1235                                        int extra[5])
     1234static OsiClpSolverInterface *
     1235fixVubs(CbcModel & model, int skipZero2,
     1236        int & doAction,
     1237        CoinMessageHandler * /*generalMessageHandler*/,
     1238        const double * lastSolution, double dextra[6],
     1239        int extra[5])
    12361240{
    12371241  if (doAction==11&&!lastSolution)
     
    28912895}
    28922896#endif
     2897#ifdef COIN_DEVELOP
    28932898void checkSOS(CbcModel * babModel, const OsiSolverInterface * solver)
     2899#else
     2900void checkSOS(CbcModel * /*babModel*/, const OsiSolverInterface * /*solver*/)
     2901#endif
    28942902{
    28952903#ifdef COIN_DEVELOP
     
    30873095  return returnCode;
    30883096}
    3089 static int dummyCallBack(CbcModel * model, int whereFrom)
     3097static int dummyCallBack(CbcModel * /*model*/, int /*whereFrom*/)
    30903098{
    30913099  return 0;
     
    32363244  parameters[whichParam(PROBINGCUTS,numberParameters,parameters)].setCurrentOption("ifmove");
    32373245  parameters[whichParam(KNAPSACKCUTS,numberParameters,parameters)].setCurrentOption("ifmove");
     3246#ifdef ZERO_HALF_CUTS
    32383247  parameters[whichParam(ZEROHALFCUTS,numberParameters,parameters)].setCurrentOption("off");
     3248#endif
    32393249  parameters[whichParam(REDSPLITCUTS,numberParameters,parameters)].setCurrentOption("off");
    32403250  parameters[whichParam(CLIQUECUTS,numberParameters,parameters)].setCurrentOption("ifmove");
     
    42004210    CglZeroHalf zerohalfGen;
    42014211    //zerohalfGen.switchOnExpensive();
    4202 #endif
    42034212    // set default action (0=off,1=on,2=root)
    42044213    int zerohalfAction=0;
     4214#endif
    42054215
    42064216    // Stored cuts
     
    43684378        if (type==GENERALQUERY) {
    43694379          bool evenHidden=false;
     4380          int printLevel =
     4381            parameters_[whichParam(ALLCOMMANDS,
     4382                                   numberParameters_,parameters_)].currentOptionAsInteger();
     4383          int convertP[]={2,1,0};
     4384          printLevel=convertP[printLevel];
    43704385          if ((verbose&8)!=0) {
    43714386            // even hidden
     
    43914406            std::cout<<"only maximize, dual, primal, help and quit are recognized without ="<<std::endl;
    43924407          }
    4393           int maxAcross=5;
     4408          int maxAcross=10;
    43944409          if ((verbose%4)!=0)
    43954410            maxAcross=1;
     
    44074422          for (iType=0;iType<8;iType++) {
    44084423            int across=0;
     4424            int lengthLine=0;
    44094425            if ((verbose%4)!=0)
    44104426              std::cout<<std::endl;
     
    44144430            for ( iParam=0; iParam<numberParameters_; iParam++ ) {
    44154431              int type = parameters_[iParam].type();
    4416               if ((parameters_[iParam].displayThis()||evenHidden)&&
     4432              //printf("%d type %d limits %d %d display %d\n",iParam,
     4433              //     type,limits[iType],limits[iType+1],parameters_[iParam].displayThis());
     4434              if ((parameters_[iParam].displayThis()>=printLevel||evenHidden)&&
    44174435                  type>=limits[iType]
    44184436                  &&type<limits[iType+1]) {
     
    44214439                  continue;
    44224440                if (!across) {
    4423                   if ((verbose&2)==0)
    4424                     std::cout<<"  ";
    4425                   else
     4441                  if ((verbose&2)!=0)
    44264442                    std::cout<<"Command ";
    44274443                }
    4428                 std::cout<<parameters_[iParam].matchName()<<"  ";
     4444                int length = parameters_[iParam].lengthMatchName()+1;
     4445                if (lengthLine+length>80) {
     4446                  std::cout<<std::endl;
     4447                  across=0;
     4448                  lengthLine=0;
     4449                }
     4450                std::cout<<" "<<parameters_[iParam].matchName();
     4451                lengthLine += length;
    44294452                across++;
    44304453                if (across==maxAcross) {
     
    48874910              residualCapacityAction = action;
    48884911              break;
     4912#ifdef ZERO_HALF_CUTS
    48894913            case ZEROHALFCUTS:
    48904914              defaultSettings=false; // user knows what she is doing
    48914915              zerohalfAction = action;
    48924916              break;
     4917#endif
    48934918            case ROUNDING:
    48944919              defaultSettings=false; // user knows what she is doing
     
    49074932              probingAction = action;
    49084933              knapsackAction = action;
     4934#ifdef ZERO_HALF_CUTS
    49094935              zerohalfAction = action;
     4936#endif
    49104937              cliqueAction = action;
    49114938              flowAction = action;
     
    49204947              parameters_[whichParam(MIXEDCUTS,numberParameters_,parameters_)].setCurrentOption(action);
    49214948              parameters_[whichParam(TWOMIRCUTS,numberParameters_,parameters_)].setCurrentOption(action);
     4949#ifdef ZERO_HALF_CUTS
    49224950              parameters_[whichParam(ZEROHALFCUTS,numberParameters_,parameters_)].setCurrentOption(action);
     4951#endif
    49234952              if (!action) {
    49244953                redsplitAction = action;
     
    49644993              preProcess = action;
    49654994              break;
     4995            default:
     4996              //abort();
    49664997              break;
    4967             default:
    4968               abort();
    49694998            }
    49704999          }
     
    58425871                }
    58435872                double time1a = CoinCpuTime();
    5844                 model_.initialSolve();
    58455873                OsiSolverInterface * solver = model_.solver();
    58465874#ifndef CBC_OTHER_SOLVER
    58475875                OsiClpSolverInterface * si =
    58485876                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     5877                if (si)
     5878                  si->setSpecialOptions(si->specialOptions()|1024);
     5879#endif
     5880                model_.initialSolve();
     5881#ifndef CBC_OTHER_SOLVER
    58495882                ClpSimplex * clpSolver = si->getModelPtr();
    58505883                int iStatus = clpSolver->status();
     
    61396172                    int type = setInfo[i].setType();
    61406173                    int n=setInfo[i].numberEntries();
    6141                     sosType[i]=type;
     6174                    sosType[i]=static_cast<char>(type);
    61426175                    nTotal += n;
    61436176                    sosStart[i+1] = nTotal;
     
    62806313                  {
    62816314                    OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (saveSolver);
     6315                    osiclp->setSpecialOptions(osiclp->specialOptions()|1024);
    62826316                    int savePerturbation = osiclp->getModelPtr()->perturbation();
    62836317                    //#define CBC_TEMP1
     
    91459179                  while (*pos>=' '&&*pos!='\n') {
    91469180                    if (*pos!=' '&&*pos!='\t') {
    9147                       *put=tolower(*pos);
     9181                      *put=static_cast<char>(tolower(*pos));
    91489182                      put++;
    91499183                    }
     
    94389472                int numRows;
    94399473                double obj;
    9440                 fread(&numRows,sizeof(int),1,fp);
    9441                 fread(&numberDebugValues,sizeof(int),1,fp);
    9442                 fread(&obj,sizeof(double),1,fp);
     9474                int nRead;
     9475                nRead=fread(&numRows,sizeof(int),1,fp);
     9476                if (nRead!=1)
     9477                  throw("Error in fread");
     9478                nRead=fread(&numberDebugValues,sizeof(int),1,fp);
     9479                if (nRead!=1)
     9480                  throw("Error in fread");
     9481                nRead=fread(&obj,sizeof(double),1,fp);
     9482                if (nRead!=1)
     9483                  throw("Error in fread");
    94439484                debugValues = new double[numberDebugValues+numRows];
    9444                 fread(debugValues,sizeof(double),numRows,fp);
    9445                 fread(debugValues,sizeof(double),numRows,fp);
    9446                 fread(debugValues,sizeof(double),numberDebugValues,fp);
     9485                nRead=fread(debugValues,sizeof(double),numRows,fp);
     9486                if (nRead!=numRows)
     9487                  throw("Error in fread");
     9488                nRead=fread(debugValues,sizeof(double),numRows,fp);
     9489                if (nRead!=numRows)
     9490                  throw("Error in fread");
     9491                nRead=fread(debugValues,sizeof(double),numberDebugValues,fp);
     9492                if (nRead!=numberDebugValues)
     9493                  throw("Error in fread");
    94479494                printf("%d doubles read into debugValues\n",numberDebugValues);
    94489495                if (numberDebugValues<200) {
     
    1080410851  *put='\0';
    1080510852}
    10806 static void generateCode(CbcModel * model, const char * fileName,int type,int preProcess)
     10853static void generateCode(CbcModel * /*model*/, const char * fileName,int type,int preProcess)
    1080710854{
    1080810855  // options on code generation
  • trunk/Cbc/src/CbcSolver.hpp

    r1173 r1200  
    224224               1 - errors
    225225  */
    226   virtual int importData(CbcSolver * model, int & argc, char * argv[]) {return -1;}
     226  virtual int importData(CbcSolver * /*model*/, int & /*argc*/, char * /*argv[]*/) {return -1;}
    227227  /// Export 1 OsiClpSolver, 2 CbcModel - add 10 if infeasible from odd situation
    228   virtual void exportSolution(CbcSolver * model, int mode,const char * message=NULL) {}
     228  virtual void exportSolution(CbcSolver * /*model*/,
     229                              int /*mode*/,const char * /*message*/=NULL) {}
    229230  /// Export Data (i.e. at very end)
    230   virtual void exportData(CbcSolver * model) {}
     231  virtual void exportData(CbcSolver * /*model*/) {}
    231232  /// Get useful stuff
    232   virtual void fillInformation(CbcSolver * model,
    233                                CbcSolverUsefulData & info) {}
     233  virtual void fillInformation(CbcSolver * /*model*/,
     234                               CbcSolverUsefulData & /*info*/) {}
    234235
    235236  //@}
     
    300301     nonzero return code to stop
    301302  */
    302   virtual int callBack(CbcModel * currentSolver, int whereFrom) {return 0;}
     303  virtual int callBack(CbcModel * /*currentSolver*/,
     304                       int /*whereFrom*/) {return 0;}
    303305  //@}
    304306  ///@name Constructors and destructors etc
  • trunk/Cbc/src/CbcStrategy.cpp

    r1173 r1200  
    6969// Return a new Partial node information pointer (descendant of CbcPartialNodeInfo)
    7070CbcNodeInfo *
    71 CbcStrategy::partialNodeInfo(CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
     71CbcStrategy::partialNodeInfo(CbcModel * /*model*/,
     72                             CbcNodeInfo * parent, CbcNode * owner,
    7273                             int numberChangedBounds,const int * variables,
    7374                             const double * boundChanges,
     
    8485*/
    8586int
    86 CbcStrategy::status(CbcModel * model, CbcNodeInfo * parent,int whereFrom)
     87CbcStrategy::status(CbcModel * /*model*/, CbcNodeInfo * /*parent*/,
     88                    int /*whereFrom*/)
    8789{
    8890  return -1;
  • trunk/Cbc/src/CbcStrategy.hpp

    r1173 r1200  
    5757                                        const CoinWarmStartDiff *basisDiff) const;
    5858  /// Create C++ lines to get to current state
    59   virtual void generateCpp( FILE * fp) {}
     59  virtual void generateCpp( FILE * ) {}
    6060  /** After a CbcModel::resolve this can return a status
    6161      -1 no effect
     
    102102
    103103  /// Setup cut generators
    104   virtual void setupCutGenerators(CbcModel & model) {}
    105   /// Setup heuristics
    106   virtual void setupHeuristics(CbcModel & model) {}
    107   /// Do printing stuff
    108   virtual void setupPrinting(CbcModel & model,int modelLogLevel) {}
     104  virtual void setupCutGenerators(CbcModel & ) {}
     105  /// Setup heuristics
     106  virtual void setupHeuristics(CbcModel & ) {}
     107  /// Do printing stuff
     108  virtual void setupPrinting(CbcModel & ,int ) {}
    109109  /// Other stuff e.g. strong branching
    110   virtual void setupOther(CbcModel & model) {}
     110  virtual void setupOther(CbcModel & ) {}
    111111
    112112protected:
  • trunk/Cbc/src/CbcTree.hpp

    r1173 r1200  
    3939  virtual CbcTree * clone() const;
    4040  /// Create C++ lines to get to current state
    41   virtual void generateCpp( FILE * fp) {}
     41  virtual void generateCpp( FILE * ) {}
    4242
    4343/*! \name Heap access and maintenance methods */
     
    168168  virtual CbcTree * clone() const;
    169169  /// Create C++ lines to get to current state
    170   virtual void generateCpp( FILE * fp) {}
     170  virtual void generateCpp( FILE * ) {}
    171171
    172172/*! \name Heap access and maintenance methods */
     
    242242  virtual CbcNewTree * clone() const;
    243243  /// Create C++ lines to get to current state
    244   virtual void generateCpp( FILE * fp) {}
     244  virtual void generateCpp( FILE * ) {}
    245245
    246246/*! \name Heap access and maintenance methods */
  • trunk/Cbc/src/Cbc_C_Interface.cpp

    r1193 r1200  
    104104
    105105Cbc_MessageHandler::Cbc_MessageHandler (const CoinMessageHandler & rhs)
    106   : CoinMessageHandler(),
     106  : CoinMessageHandler(rhs),
    107107    model_(NULL),
    108108    callback_(NULL)
     
    112112// Constructor with pointer to model
    113113Cbc_MessageHandler::Cbc_MessageHandler(Cbc_Model * model,
    114                FILE * userPointer)
     114                                       FILE * /*userPointer*/)
    115115  : CoinMessageHandler(),
    116116    model_(model),
     
    394394/* Drop integer informations */
    395395COINLIBAPI void COINLINKAGE
    396 Cbc_deleteIntegerInformation(Cbc_Model * model)
     396Cbc_deleteIntegerInformation(Cbc_Model * /*model*/)
    397397{
    398398  const char prefix[] = "Cbc_C_Interface::Cbc_deleteIntegerInformation(): ";
     
    409409/* Resizes rim part of model  */
    410410COINLIBAPI void COINLINKAGE
    411 Cbc_resize (Cbc_Model * model, int newNumberRows, int newNumberColumns)
     411Cbc_resize (Cbc_Model * /*model*/, int /*newNumberRows*/,
     412            int /*newNumberColumns*/)
    412413{
    413414  const char prefix[] = "Cbc_C_Interface::Cbc_resize(): ";
     
    436437/* Add rows */
    437438COINLIBAPI void COINLINKAGE
    438 Cbc_addRows(Cbc_Model * model, const int number, const double * rowLower,
    439          const double * rowUpper,
    440          const int * rowStarts, const int * columns,
    441          const double * elements)
     439Cbc_addRows(Cbc_Model * /*model*/, const int /*number*/,
     440            const double * /*rowLower*/,
     441            const double * /*rowUpper*/,
     442            const int * /*rowStarts*/, const int * /*columns*/,
     443            const double * /*elements*/)
    442444{
    443445  const char prefix[] = "Cbc_C_Interface::Cbc_addRows(): ";
     
    467469/* Add columns */
    468470COINLIBAPI void COINLINKAGE
    469 Cbc_addColumns(Cbc_Model * model, int number, const double * columnLower,
    470       const double * columnUpper,
    471       const double * objective,
    472       const int * columnStarts, const int * rows,
    473       const double * elements)
     471Cbc_addColumns(Cbc_Model * /*model*/, int /*number*/,
     472               const double * /*columnLower*/,
     473               const double * /*columnUpper*/,
     474               const double * /*objective*/,
     475               const int * /*columnStarts*/, const int * /*rows*/,
     476               const double * /*elements*/)
    474477{
    475478  const char prefix[] = "Cbc_C_Interface::Cbc_addColumns(): ";
     
    486489/* Drops names - makes lengthnames 0 and names empty */
    487490COINLIBAPI void COINLINKAGE
    488 Cbc_dropNames(Cbc_Model * model)
     491Cbc_dropNames(Cbc_Model * /*model*/)
    489492{
    490493  const char prefix[] = "Cbc_C_Interface::Cbc_dropNames(): ";
     
    500503/* Copies in names */
    501504COINLIBAPI void COINLINKAGE
    502 Cbc_copyNames(Cbc_Model * model, const char * const * rowNamesIn,
    503         const char * const * columnNamesIn)
     505Cbc_copyNames(Cbc_Model * /*model*/, const char * const * /*rowNamesIn*/,
     506              const char * const * /*columnNamesIn*/)
    504507{
    505508  const char prefix[] = "Cbc_C_Interface::Cbc_copyNames(): ";
     
    660663/* Objective offset */
    661664COINLIBAPI double COINLINKAGE
    662 Cbc_objectiveOffset(Cbc_Model * model)
     665Cbc_objectiveOffset(Cbc_Model * /*model*/)
    663666{
    664667  const char prefix[] = "Cbc_C_Interface::Cbc_objectiveOffset(): ";
     
    675678}
    676679COINLIBAPI void COINLINKAGE
    677 Cbc_setObjectiveOffset(Cbc_Model * model, double value)
     680Cbc_setObjectiveOffset(Cbc_Model * /*model*/, double /*value*/)
    678681{
    679682  const char prefix[] = "Cbc_C_Interface::Cbc_setObjectiveOffset(): ";
     
    705708/* Sets problem name.  Must have \0 at end.  */
    706709COINLIBAPI int COINLINKAGE
    707 Cbc_setProblemName(Cbc_Model * model, int maxNumberCharacters, char * array)
     710Cbc_setProblemName(Cbc_Model * model, int /*maxNumberCharacters*/, char * array)
    708711{
    709712  const char prefix[] = "Cbc_C_Interface::Cbc_setProblemName(): ";
     
    732735}
    733736COINLIBAPI void COINLINKAGE
    734 Cbc_setNumberIterations(Cbc_Model * model, int numberIterations)
     737Cbc_setNumberIterations(Cbc_Model * /*model*/, int /*numberIterations*/)
    735738{
    736739  const char prefix[] = "Cbc_C_Interface::Cbc_setNumberIterations(): ";
     
    747750/* Maximum number of iterations */
    748751COINLIBAPI int COINLINKAGE
    749 Cbc_maximumIterations(Cbc_Model * model)
     752Cbc_maximumIterations(Cbc_Model * /*model*/)
    750753{
    751754  const char prefix[] = "Cbc_C_Interface::Cbc_maximumIterations(): ";
     
    762765}
    763766COINLIBAPI void COINLINKAGE
    764 Cbc_setMaximumIterations(Cbc_Model * model, int value)
     767Cbc_setMaximumIterations(Cbc_Model * /*model*/, int /*value*/)
    765768{
    766769  const char prefix[] = "Cbc_C_Interface::Cbc_setMaximumIterations(): ";
     
    851854/* Returns true if hit maximum iteratio`ns (or time) */
    852855COINLIBAPI int COINLINKAGE
    853 Cbc_hitMaximumIterations(Cbc_Model * model)
     856Cbc_hitMaximumIterations(Cbc_Model * /*model*/)
    854857{
    855858  const char prefix[] = "Cbc_C_Interface::Cbc_hitMaximumIterations(): ";
     
    887890/* Set problem status */
    888891COINLIBAPI void COINLINKAGE
    889 Cbc_setProblemStatus(Cbc_Model * model, int problemStatus)
     892Cbc_setProblemStatus(Cbc_Model * /*model*/, int /*problemStatus*/)
    890893{
    891894  const char prefix[] = "Cbc_C_Interface::Cbc_setProblemStatus(): ";
     
    922925}
    923926COINLIBAPI void COINLINKAGE
    924 Cbc_setSecondaryStatus(Cbc_Model * model, int status)
     927Cbc_setSecondaryStatus(Cbc_Model * /*model*/, int /*status*/)
    925928{
    926929  const char prefix[] = "Cbc_C_Interface::Cbc_setSecondaryStatus(): ";
     
    962965/* Primal row solution */
    963966COINLIBAPI double * COINLINKAGE
    964 Cbc_primalRowSolution(Cbc_Model * model)
     967Cbc_primalRowSolution(Cbc_Model * /*model*/)
    965968{
    966969  const char prefix[] = "Cbc_C_Interface::Cbc_primalRowSolution(): ";
     
    980983/* Primal column solution */
    981984COINLIBAPI double * COINLINKAGE
    982 Cbc_primalColumnSolution(Cbc_Model * model)
     985Cbc_primalColumnSolution(Cbc_Model * /*model*/)
    983986{
    984987  const char prefix[] = "Cbc_C_Interface::Cbc_primalColumnSolution(): ";
     
    9971000/* Dual row solution */
    9981001COINLIBAPI double * COINLINKAGE
    999 Cbc_dualRowSolution(Cbc_Model * model)
     1002Cbc_dualRowSolution(Cbc_Model * /*model*/)
    10001003{
    10011004  const char prefix[] = "Cbc_C_Interface::Cbc_dualRowSolution(): ";
     
    10141017/* Reduced costs */
    10151018COINLIBAPI double * COINLINKAGE
    1016 Cbc_dualColumnSolution(Cbc_Model * model)
     1019Cbc_dualColumnSolution(Cbc_Model * /*model*/)
    10171020{
    10181021  const char prefix[] = "Cbc_C_Interface::Cbc_dualColumnSolution(): ";
     
    10311034/* Row lower */
    10321035COINLIBAPI double * COINLINKAGE
    1033 Cbc_rowLower(Cbc_Model * model)
     1036Cbc_rowLower(Cbc_Model * /*model*/)
    10341037{
    10351038  const char prefix[] = "Cbc_C_Interface::Cbc_rowLower(): ";
     
    10481051/* Row upper  */
    10491052COINLIBAPI double * COINLINKAGE
    1050 Cbc_rowUpper(Cbc_Model * model)
     1053Cbc_rowUpper(Cbc_Model * /*model*/)
    10511054{
    10521055  const char prefix[] = "Cbc_C_Interface::Cbc_rowUpper(): ";
     
    10651068/* Objective Coefficients */
    10661069COINLIBAPI double * COINLINKAGE
    1067 Cbc_objective(Cbc_Model * model)
     1070Cbc_objective(Cbc_Model * /*model*/)
    10681071{
    10691072  const char prefix[] = "Cbc_C_Interface::Cbc_objective(): ";
     
    10821085/* Column Lower */
    10831086COINLIBAPI double * COINLINKAGE
    1084 Cbc_columnLower(Cbc_Model * model)
     1087Cbc_columnLower(Cbc_Model * /*model*/)
    10851088{
    10861089  const char prefix[] = "Cbc_C_Interface::Cbc_columnLower(): ";
     
    10991102/* Column Upper */
    11001103COINLIBAPI double * COINLINKAGE
    1101 Cbc_columnUpper(Cbc_Model * model)
     1104Cbc_columnUpper(Cbc_Model * /*model*/)
    11021105{
    11031106  const char prefix[] = "Cbc_C_Interface::Cbc_columnUpper(): ";
     
    12091212   Up to user to use delete [] on these arrays.  */
    12101213COINLIBAPI double * COINLINKAGE
    1211 Cbc_infeasibilityRay(Cbc_Model * model)
     1214Cbc_infeasibilityRay(Cbc_Model * /*model*/)
    12121215{
    12131216  const char prefix[] = "Cbc_C_Interface::Cbc_infeasibilityRay(): ";
     
    12261229}
    12271230COINLIBAPI double * COINLINKAGE
    1228 Cbc_unboundedRay(Cbc_Model * model)
     1231Cbc_unboundedRay(Cbc_Model * /*model*/)
    12291232{
    12301233  const char prefix[] = "Cbc_C_Interface::Cbc_unboundedRay(): ";
     
    12441247/* See if status array exists (partly for OsiClp) */
    12451248COINLIBAPI int COINLINKAGE
    1246 Cbc_statusExists(Cbc_Model * model)
     1249Cbc_statusExists(Cbc_Model * /*model*/)
    12471250{
    12481251  const char prefix[] = "Cbc_C_Interface::Cbc_statusExists(): ";
     
    12591262/* Return address of status array (char[numberRows+numberColumns]) */
    12601263COINLIBAPI void  COINLINKAGE
    1261 Cbc_getBasisStatus(Cbc_Model * model, int * cstat, int * rstat)
     1264Cbc_getBasisStatus(Cbc_Model * /*model*/, int * /*cstat*/, int * /*rstat*/)
    12621265{
    12631266  const char prefix[] = "Cbc_C_Interface::Cbc_getBasisStatus(): ";
     
    12741277/* Copy in status vector */
    12751278COINLIBAPI void COINLINKAGE
    1276 Cbc_setBasisStatus(Cbc_Model * model,  int * cstat, int * rstat)
     1279Cbc_setBasisStatus(Cbc_Model * /*model*/,  int * /*cstat*/, int * /*rstat*/)
    12771280{
    12781281  const char prefix[] = "Cbc_C_Interface::Cbc_setBasisStatus(): ";
     
    12881291/* User pointer for whatever reason */
    12891292COINLIBAPI void COINLINKAGE
    1290 Cbc_setUserPointer (Cbc_Model * model, void * pointer)
     1293Cbc_setUserPointer (Cbc_Model * /*model*/, void * /*pointer*/)
    12911294{
    12921295  const char prefix[] = "Cbc_C_Interface::Cbc_setUserPointer(): ";
     
    13021305}
    13031306COINLIBAPI void * COINLINKAGE
    1304 Cbc_getUserPointer (Cbc_Model * model)
     1307Cbc_getUserPointer (Cbc_Model * /*model*/)
    13051308{
    13061309  const char prefix[] = "Cbc_C_Interface::Cbc_getUserPointer(): ";
     
    13861389/* length of names (0 means no names0 */
    13871390COINLIBAPI int COINLINKAGE
    1388 Cbc_lengthNames(Cbc_Model * model)
     1391Cbc_lengthNames(Cbc_Model * /*model*/)
    13891392{
    13901393  const char prefix[] = "Cbc_C_Interface::Cbc_lengthNames(): ";
     
    14021405/* Fill in array (at least lengthNames+1 long) with a row name */
    14031406COINLIBAPI void COINLINKAGE
    1404 Cbc_rowName(Cbc_Model * model, int iRow, char * name)
     1407Cbc_rowName(Cbc_Model * /*model*/, int iRow, char * name)
    14051408{
    14061409  const char prefix[] = "Cbc_C_Interface::Cbc_rowName(): ";
     
    14181421// cannot find names in Cbc, Osi, or OsiClp
    14191422COINLIBAPI void COINLINKAGE
    1420 Cbc_columnName(Cbc_Model * model, int iColumn, char * name)
     1423Cbc_columnName(Cbc_Model * /*model*/, int iColumn, char * name)
    14211424{
    14221425  const char prefix[] = "Cbc_C_Interface::Cbc_columnName(): ";
     
    14881491/* Gets scalingFlag */
    14891492COINLIBAPI int COINLINKAGE
    1490 Cbc_scalingFlag(Cbc_Model * model)
     1493Cbc_scalingFlag(Cbc_Model * /*model*/)
    14911494{
    14921495  const char prefix[] = "Cbc_C_Interface::Cbc_scalingFlag(): ";
     
    15171520*/
    15181521COINLIBAPI int COINLINKAGE
    1519 Cbc_crash(Cbc_Model * model, double gap,int pivot)
     1522Cbc_crash(Cbc_Model * /*model*/, double /*gap*/,int /*pivot*/)
    15201523{
    15211524  const char prefix[] = "Cbc_C_Interface::Cbc_crash(): ";
     
    15631566/* Dual bound */
    15641567COINLIBAPI double COINLINKAGE
    1565 Cbc_dualBound(Cbc_Model * model)
     1568Cbc_dualBound(Cbc_Model * /*model*/)
    15661569{
    15671570  const char prefix[] = "Cbc_C_Interface::Cbc_dualBound(): ";
     
    15781581}
    15791582COINLIBAPI void COINLINKAGE
    1580 Cbc_setDualBound(Cbc_Model * model, double value)
     1583Cbc_setDualBound(Cbc_Model * /*model*/, double /*value*/)
    15811584{
    15821585  const char prefix[] = "Cbc_C_Interface::Cbc_setDualBound(): ";
     
    15921595/* Infeasibility cost */
    15931596COINLIBAPI double COINLINKAGE
    1594 Cbc_infeasibilityCost(Cbc_Model * model)
     1597Cbc_infeasibilityCost(Cbc_Model * /*model*/)
    15951598{
    15961599  const char prefix[] = "Cbc_C_Interface::Cbc_infeasibilityCost(): ";
     
    16071610}
    16081611COINLIBAPI void COINLINKAGE
    1609 Cbc_setInfeasibilityCost(Cbc_Model * model, double value)
     1612Cbc_setInfeasibilityCost(Cbc_Model * /*model*/, double /*value*/)
    16101613{
    16111614  const char prefix[] = "Cbc_C_Interface::Cbc_setInfeasibilityCost(): ";
     
    16281631*/
    16291632COINLIBAPI int COINLINKAGE
    1630 Cbc_perturbation(Cbc_Model * model)
     1633Cbc_perturbation(Cbc_Model * /*model*/)
    16311634{
    16321635  const char prefix[] = "Cbc_C_Interface::Cbc_perturbation(): ";
     
    16431646}
    16441647COINLIBAPI void COINLINKAGE
    1645 Cbc_setPerturbation(Cbc_Model * model, int value)
     1648Cbc_setPerturbation(Cbc_Model * /*model*/, int /*value*/)
    16461649{
    16471650  const char prefix[] = "Cbc_C_Interface::Cbc_setPerturbation(): ";
     
    16571660/* Current (or last) algorithm */
    16581661COINLIBAPI int COINLINKAGE
    1659 Cbc_algorithm(Cbc_Model * model)
     1662Cbc_algorithm(Cbc_Model * /*model*/)
    16601663{
    16611664  const char prefix[] = "Cbc_C_Interface::Cbc_setPerturbation(): ";
     
    16731676/* Set algorithm */
    16741677COINLIBAPI void COINLINKAGE
    1675 Cbc_setAlgorithm(Cbc_Model * model, int value)
     1678Cbc_setAlgorithm(Cbc_Model * /*model*/, int /*value*/)
    16761679{
    16771680  const char prefix[] = "Cbc_C_Interface::Cbc_setAlgorithm(): ";
     
    16871690/* Sum of dual infeasibilities */
    16881691COINLIBAPI double COINLINKAGE
    1689 Cbc_sumDualInfeasibilities(Cbc_Model * model)
     1692Cbc_sumDualInfeasibilities(Cbc_Model * /*model*/)
    16901693{
    16911694  const char prefix[] = "Cbc_C_Interface::Cbc_sumDualInfeasibilities(): ";
     
    17031706/* Number of dual infeasibilities */
    17041707COINLIBAPI int COINLINKAGE
    1705 Cbc_numberDualInfeasibilities(Cbc_Model * model)
     1708Cbc_numberDualInfeasibilities(Cbc_Model * /*model*/)
    17061709{
    17071710  const char prefix[] = "Cbc_C_Interface::Cbc_numberDualInfeasibilities(): ";
     
    17191722/* Sum of primal infeasibilities */
    17201723COINLIBAPI double COINLINKAGE
    1721 Cbc_sumPrimalInfeasibilities(Cbc_Model * model)
     1724Cbc_sumPrimalInfeasibilities(Cbc_Model * /*model*/)
    17221725{
    17231726  const char prefix[] = "Cbc_C_Interface::Cbc_sumPrimalInfeasibilities(): ";
     
    17351738/* Number of primal infeasibilities */
    17361739COINLIBAPI int COINLINKAGE
    1737 Cbc_numberPrimalInfeasibilities(Cbc_Model * model)
     1740Cbc_numberPrimalInfeasibilities(Cbc_Model * /*model*/)
    17381741{
    17391742  const char prefix[] = "Cbc_C_Interface::Cbc_numberPrimalInfeasibilities(): ";
     
    17551758*/
    17561759COINLIBAPI int COINLINKAGE
    1757 Cbc_saveModel(Cbc_Model * model, const char * fileName)
     1760Cbc_saveModel(Cbc_Model * /*model*/, const char * /*fileName*/)
    17581761{
    17591762  const char prefix[] = "Cbc_C_Interface::Cbc_saveModel(): ";
     
    17721775   deletes current model */
    17731776COINLIBAPI int COINLINKAGE
    1774 Cbc_restoreModel(Cbc_Model * model, const char * fileName)
     1777Cbc_restoreModel(Cbc_Model * /*model*/, const char * /*fileName*/)
    17751778{
    17761779  const char prefix[] = "Cbc_C_Interface::Cbc_restoreModel(): ";
     
    17931796*/
    17941797COINLIBAPI void COINLINKAGE
    1795 Cbc_checkSolution(Cbc_Model * model)
     1798Cbc_checkSolution(Cbc_Model * /*model*/)
    17961799{
    17971800  const char prefix[] = "Cbc_C_Interface::Cbc_checkSolution(): ";
     
    21992202
    22002203COINLIBAPI double COINLINKAGE
    2201 Cbc_cpuTime(Cbc_Model * model)
     2204Cbc_cpuTime(Cbc_Model * /*model*/)
    22022205{
    22032206  const char prefix[] = "Cbc_C_Interface::Cbc_cpuTime(): ";
     
    25182521  /** Dual initial solve */
    25192522  COINLIBAPI int COINLINKAGE
    2520   Cbc_initialDualSolve(Cbc_Model * model)
     2523  Cbc_initialDualSolve(Cbc_Model * /*model*/)
    25212524  {
    25222525    return 0;
     
    25242527  /** Primal initial solve */
    25252528  COINLIBAPI int COINLINKAGE
    2526   Cbc_initialPrimalSolve(Cbc_Model * model)
     2529  Cbc_initialPrimalSolve(Cbc_Model * /*model*/)
    25272530  {
    25282531    return 0;
     
    25302533  /** Dual algorithm - see ClpSimplexDual.hpp for method */
    25312534  COINLIBAPI int COINLINKAGE
    2532   Cbc_dual(Cbc_Model * model, int ifValuesPass)
     2535  Cbc_dual(Cbc_Model * /*model*/, int /*ifValuesPass*/)
    25332536  {
    25342537    return 0;
     
    25362539  /** Primal algorithm - see ClpSimplexPrimal.hpp for method */
    25372540  COINLIBAPI int COINLINKAGE
    2538   Cbc_primal(Cbc_Model * model, int ifValuesPass)
     2541  Cbc_primal(Cbc_Model * /*model*/, int /*ifValuesPass*/)
    25392542  {
    25402543    return 0;
  • trunk/Cbc/src/Cbc_ampl.cpp

    r1173 r1200  
    14771477#include "Cbc_ampl.h"
    14781478int
    1479 readAmpl(ampl_info * info, int argc, char **argv, void ** coinModel)
     1479readAmpl(ampl_info * , int , char **, void ** )
    14801480{
    14811481  return 0;
    14821482}
    1483 void freeArrays1(ampl_info * info)
    1484 {
    1485 }
    1486 void freeArrays2(ampl_info * info)
    1487 {
    1488 }
    1489 void freeArgs(ampl_info * info)
     1483void freeArrays1(ampl_info *)
     1484{
     1485}
     1486void freeArrays2(ampl_info *)
     1487{
     1488}
     1489void freeArgs(ampl_info * )
    14901490{
    14911491}
     
    14941494  return 0;
    14951495}
    1496 void writeAmpl(ampl_info * info)
     1496void writeAmpl(ampl_info * )
    14971497{
    14981498}
  • trunk/Cbc/src/ClpAmplStuff.cpp

    r1193 r1200  
    13641364#include "ClpConstraint.hpp"
    13651365int
    1366 ClpSimplex::loadNonLinear(void * amplInfo, int & numberConstraints,
    1367                           ClpConstraint ** & constraints)
     1366ClpSimplex::loadNonLinear(void * , int & ,
     1367                          ClpConstraint ** & )
    13681368{
    13691369  abort();
  • trunk/Cbc/src/CoinSolve.cpp

    r1199 r1200  
    206206#ifdef USER_HAS_FAKE_CBC
    207207#endif
    208 void fakeMain (ClpSimplex & model,OsiSolverInterface & osiSolver, CbcModel & babSolver)
     208void fakeMain (ClpSimplex & model,OsiSolverInterface & /*osiSolver*/, CbcModel & babSolver)
    209209{
    210210#ifdef USER_HAS_FAKE_CBC
     
    221221#ifdef USER_HAS_FAKE_CLP
    222222#endif
    223 void fakeMain2 (ClpSimplex & model,OsiClpSolverInterface & osiSolver,int options) {
     223void fakeMain2 (ClpSimplex & /*model*/,
     224                OsiClpSolverInterface & osiSolver,
     225                int /*options*/) {
    224226#ifdef USER_HAS_FAKE_CLP
    225227#else
  • trunk/Cbc/src/unitTestClp.cpp

    r1180 r1200  
    533533        if (modelC->numberColumns()+modelC->numberRows()<=100000&&
    534534            model->fastNodeDepth()==-1)
    535           model->setFastNodeDepth(-7);
     535          model->setFastNodeDepth(-9);
    536536      }
    537537    }
Note: See TracChangeset for help on using the changeset viewer.