Changeset 1055


Ignore:
Timestamp:
Jul 25, 2007 11:57:53 AM (12 years ago)
Author:
forrest
Message:

out };

Location:
trunk/Clp/src
Files:
31 edited

Legend:

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

    r1034 r1055  
    130130  inline std::string  name(  ) const {
    131131    return name_;
    132   };
     132  }
    133133  /// Returns short help
    134134  inline std::string  shortHelp(  ) const {
    135135    return shortHelp_;
    136   };
     136  }
    137137  /// Sets a double parameter (nonzero code if error)
    138138  int setDoubleParameter(CbcModel & model, double value) ;
     
    169169  /// Returns current parameter option
    170170  inline std::string currentOption (  ) const
    171   { return definedKeyWords_[currentKeyWord_]; };
     171  { return definedKeyWords_[currentKeyWord_]; }
    172172  /// Sets current parameter option
    173173  void setCurrentOption ( int value , bool printIt=false);
     
    177177  void setIntValue ( int value );
    178178    inline int intValue () const
    179   { return intValue_; };
     179  { return intValue_; }
    180180  /// Sets double value
    181181  void setDoubleValue ( double value );
    182182  inline double doubleValue () const
    183   { return doubleValue_; };
     183  { return doubleValue_; }
    184184  /// Sets string value
    185185  void setStringValue ( std::string value );
    186186  inline std::string stringValue () const
    187   { return stringValue_; };
     187  { return stringValue_; }
    188188  /// Returns 1 if matches minimum, 2 if matches less, 0 if not matched
    189189  int matches (std::string input) const;
    190190  /// type
    191191  inline CbcOrClpParameterType type() const
    192   { return type_;};
     192  { return type_;}
    193193  /// whether to display
    194194  inline bool displayThis() const
    195   { return display_;};
     195  { return display_;}
    196196  /// Set Long help
    197197  inline void setLonghelp(const std::string help)
    198   {longHelp_=help;};
     198  {longHelp_=help;}
    199199  /// Print Long help
    200200  void printLongHelp() const;
     
    207207  */
    208208  inline int whereUsed() const
    209   { return whereUsed_;};
     209  { return whereUsed_;}
    210210 
    211211private:
  • trunk/Clp/src/ClpCholeskyBase.hpp

    r754 r1055  
    5959  /// status.  Returns status
    6060  inline int status() const
    61   {return status_;};
     61  {return status_;}
    6262  /// numberRowsDropped.  Number of rows gone
    6363  inline int numberRowsDropped() const
    64   {return numberRowsDropped_;};
     64  {return numberRowsDropped_;}
    6565  /// reset numberRowsDropped and rowsDropped.
    6666  void resetRowsDropped();
    6767  /// rowsDropped - which rows are gone
    6868  inline char * rowsDropped() const
    69   {return rowsDropped_;};
     69  {return rowsDropped_;}
    7070  /// choleskyCondition.
    7171  inline double choleskyCondition() const
    72   {return choleskyCondition_;};
     72  {return choleskyCondition_;}
    7373  /// goDense i.e. use dense factoriaztion if > this (default 0.7).
    7474  inline double goDense() const
    75   {return goDense_;};
     75  {return goDense_;}
    7676  /// goDense i.e. use dense factoriaztion if > this (default 0.7).
    7777  inline void setGoDense(double value)
    78   {goDense_=value;};
     78  {goDense_=value;}
    7979  /// rank.  Returns rank
    8080  inline int rank() const
    81   {return numberRows_-numberRowsDropped_;};
     81  {return numberRows_-numberRowsDropped_;}
    8282  /// Return number of rows
    8383  inline int numberRows() const
    84   {return numberRows_;};
     84  {return numberRows_;}
    8585  /// Return size
    8686  inline CoinBigIndex size() const
    87   { return sizeFactor_;};
     87  { return sizeFactor_;}
    8888  /// Return sparseFactor
    8989  inline longDouble * sparseFactor() const
    90   { return sparseFactor_;};
     90  { return sparseFactor_;}
    9191  /// Return diagonal
    9292  inline longDouble * diagonal() const
    93   { return diagonal_;};
     93  { return diagonal_;}
    9494  /// Return workDouble
    9595  inline longDouble * workDouble() const
    96   { return workDouble_;};
     96  { return workDouble_;}
    9797  /// If KKT on
    9898  inline bool kkt() const
    99   { return doKKT_;};
     99  { return doKKT_;}
    100100  /// Set KKT
    101101  inline void setKKT(bool yesNo)
    102   { doKKT_ = yesNo;};
     102  { doKKT_ = yesNo;}
    103103  /// Set integer parameter
    104104  inline void setIntegerParameter(int i,int value)
    105   { integerParameters_[i]=value;};
     105  { integerParameters_[i]=value;}
    106106  /// get integer parameter
    107107  inline int getIntegerParameter(int i)
    108   { return integerParameters_[i];};
     108  { return integerParameters_[i];}
    109109  /// Set double parameter
    110110  inline void setDoubleParameter(int i,double value)
    111   { doubleParameters_[i]=value;};
     111  { doubleParameters_[i]=value;}
    112112  /// get double parameter
    113113  inline double getDoubleParameter(int i)
    114   { return doubleParameters_[i];};
     114  { return doubleParameters_[i];}
    115115   //@}
    116116 
     
    138138  /// Returns type
    139139  inline int type() const
    140   { if (doKKT_) return 100; else return type_;};
     140  { if (doKKT_) return 100; else return type_;}
    141141protected:
    142142  /// Sets type
    143   void setType(int type) {type_=type;};
     143  void setType(int type) {type_=type;}
    144144   //@}
    145145   
  • trunk/Clp/src/ClpConstraint.hpp

    r1035 r1055  
    7979  /// Returns type, 0 linear, 1 nonlinear
    8080  inline int type()
    81   { return type_;};
     81  { return type_;}
    8282  /// Row number (-1 is objective)
    8383  inline int rowNumber() const
    84   {return rowNumber_;};
     84  {return rowNumber_;}
    8585 
    8686  /// Number of possible coefficients in gradient
     
    8989  /// Stored constraint function value
    9090  inline double functionValue () const
    91   { return functionValue_;};
     91  { return functionValue_;}
    9292
    9393  /// Constraint offset
    9494  inline double offset () const
    95   { return offset_;};
     95  { return offset_;}
    9696  /// Say we have new primal solution - so may need to recompute
    97   virtual void newXValues() {};
     97  virtual void newXValues() {}
    9898  //@}
    9999
  • trunk/Clp/src/ClpConstraintLinear.hpp

    r1035 r1055  
    7878  /// Number of columns in linear constraint
    7979  inline int numberColumns() const
    80   {return numberColumns_;};
     80  {return numberColumns_;}
    8181  /// Columns
    8282  inline const int * column() const
    83   { return column_;};
     83  { return column_;}
    8484  /// Coefficients
    8585  inline const double * coefficient() const
    86   { return coefficient_;};
     86  { return coefficient_;}
    8787  //@}
    8888
  • trunk/Clp/src/ClpConstraintQuadratic.hpp

    r1035 r1055  
    7979  /// Number of columns in constraint
    8080  inline int numberColumns() const
    81   {return numberColumns_;};
     81  {return numberColumns_;}
    8282  /// Column starts
    8383  inline CoinBigIndex * start() const
     
    8585  /// Columns
    8686  inline const int * column() const
    87   { return column_;};
     87  { return column_;}
    8888  /// Coefficients
    8989  inline const double * coefficient() const
    90   { return coefficient_;};
     90  { return coefficient_;}
    9191  //@}
    9292
  • trunk/Clp/src/ClpDualRowPivot.hpp

    r754 r1055  
    6161  /// Returns true if would not find any row
    6262  virtual bool looksOptimal() const
    63   { return false;};
     63  { return false;}
    6464  /// Called when maximum pivots changes
    65   virtual void maximumPivotsChanged() {};
     65  virtual void maximumPivotsChanged() {}
    6666  //@}
    6767 
     
    9090  /// Returns model
    9191  inline ClpSimplex * model()
    92   { return model_;};
     92  { return model_;}
    9393 
    9494  /// Returns type (above 63 is extra information)
    9595  inline int type()
    96   { return type_;};
     96  { return type_;}
    9797 
    9898  //@}
  • trunk/Clp/src/ClpDualRowSteepest.hpp

    r754 r1055  
    9595  /// Mode
    9696  inline int mode() const
    97     { return mode_;};
     97    { return mode_;}
    9898  /// Set/ get persistence
    9999  inline void setPersistence(Persistence life)
    100   { persistence_ = life;};
     100  { persistence_ = life;}
    101101  inline Persistence persistence() const
    102   { return persistence_ ;};
     102  { return persistence_ ;}
    103103 //@}
    104104
  • trunk/Clp/src/ClpDummyMatrix.hpp

    r754 r1055  
    3030   virtual int getNumCols() const { return numberColumns_; }
    3131   /** Number of rows. */
    32   virtual int getNumRows() const { return numberRows_; };
     32  virtual int getNumRows() const { return numberRows_; }
    3333
    3434   /** A vector containing the elements in the packed matrix. Note that there
     
    8686   /// Allow any parts of a created CoinMatrix to be deleted
    8787  /// Allow any parts of a created CoinPackedMatrix to be deleted
    88    virtual void releasePackedMatrix() const {};
     88   virtual void releasePackedMatrix() const {}
    8989   //@}
    9090
  • trunk/Clp/src/ClpDynamicExampleMatrix.hpp

    r754 r1055  
    9696  /// Starts of each column
    9797  inline CoinBigIndex * startColumnGen() const
    98   { return startColumnGen_;};
     98  { return startColumnGen_;}
    9999  /// rows
    100100  inline int * rowGen() const
    101   { return rowGen_;};
     101  { return rowGen_;}
    102102  /// elements
    103103  inline float * elementGen() const
    104   { return elementGen_;};
     104  { return elementGen_;}
    105105  /// costs
    106106  inline float * costGen() const
    107   { return costGen_;};
     107  { return costGen_;}
    108108  /// full starts
    109109  inline int * fullStartGen() const
    110   { return fullStartGen_;};
     110  { return fullStartGen_;}
    111111  /// ids in next level matrix
    112112  inline int * idGen() const
    113   { return idGen_;};
     113  { return idGen_;}
    114114  /// Optional lower bounds on columns
    115115  inline float * columnLowerGen() const
    116   { return columnLowerGen_;};
     116  { return columnLowerGen_;}
    117117  /// Optional upper bounds on columns
    118118  inline float * columnUpperGen() const
    119   { return columnUpperGen_;};
     119  { return columnUpperGen_;}
    120120  /// size
    121121  inline int numberColumns() const
    122   { return numberColumns_;};
     122  { return numberColumns_;}
    123123  inline void setDynamicStatusGen(int sequence, DynamicStatus status)
    124124  {
     
    126126    st_byte &= ~7;
    127127    st_byte |= status;
    128   };
     128  }
    129129  inline DynamicStatus getDynamicStatusGen(int sequence) const
    130   {return static_cast<DynamicStatus> (dynamicStatusGen_[sequence]&7);};
     130  {return static_cast<DynamicStatus> (dynamicStatusGen_[sequence]&7);}
    131131  /// Whether flagged
    132132  inline bool flaggedGen(int i) const {
    133133    return (dynamicStatusGen_[i]&8)!=0;
    134   };
     134  }
    135135  inline void setFlaggedGen(int i) {
    136136    dynamicStatusGen_[i] |= 8;
    137   };
     137  }
    138138  inline void unsetFlagged(int i) {
    139139    dynamicStatusGen_[i]  &= ~8;;
    140   };
     140  }
    141141   //@}
    142142   
  • trunk/Clp/src/ClpDynamicMatrix.hpp

    r754 r1055  
    100100      Entries at upper bound (really nonzero) never go out (at present).
    101101  */
    102   virtual void packDown(const int * in, int numberToPack) {};
     102  virtual void packDown(const int * in, int numberToPack) {}
    103103  /// Gets lower bound (to simplify coding)
    104104  inline double columnLower(int sequence) const
    105   { if (columnLower_) return columnLower_[sequence]; else return 0.0;};
     105  { if (columnLower_) return columnLower_[sequence]; else return 0.0;}
    106106  /// Gets upper bound (to simplify coding)
    107107  inline double columnUpper(int sequence) const
    108   { if (columnUpper_) return columnUpper_[sequence]; else return COIN_DBL_MAX;};
     108  { if (columnUpper_) return columnUpper_[sequence]; else return COIN_DBL_MAX;}
    109109
    110110  //@}
     
    150150  /// Status of row slacks
    151151  inline ClpSimplex::Status getStatus(int sequence) const
    152   {return static_cast<ClpSimplex::Status> (status_[sequence]&7);};
     152  {return static_cast<ClpSimplex::Status> (status_[sequence]&7);}
    153153  inline void setStatus(int sequence, ClpSimplex::Status status)
    154154  {
     
    156156    st_byte &= ~7;
    157157    st_byte |= status;
    158   };
     158  }
    159159  /// Number of sets (dynamic rows)
    160160  inline int numberSets() const
    161   { return numberSets_;};
     161  { return numberSets_;}
    162162  /// Whether flagged
    163163  inline bool flagged(int i) const {
    164164    return (dynamicStatus_[i]&8)!=0;
    165   };
     165  }
    166166  inline void setFlagged(int i) {
    167167    dynamicStatus_[i] |= 8;
    168   };
     168  }
    169169  inline void unsetFlagged(int i) {
    170170    dynamicStatus_[i]  &= ~8;;
    171   };
     171  }
    172172  inline void setDynamicStatus(int sequence, DynamicStatus status)
    173173  {
     
    175175    st_byte &= ~7;
    176176    st_byte |= status;
    177   };
     177  }
    178178  inline DynamicStatus getDynamicStatus(int sequence) const
    179   {return static_cast<DynamicStatus> (dynamicStatus_[sequence]&7);};
     179  {return static_cast<DynamicStatus> (dynamicStatus_[sequence]&7);}
    180180  /// Saved value of objective offset
    181181  inline double objectiveOffset() const
    182   { return objectiveOffset_;};
     182  { return objectiveOffset_;}
    183183  /// Starts of each column
    184184  inline CoinBigIndex * startColumn() const
    185   { return startColumn_;};
     185  { return startColumn_;}
    186186  /// rows
    187187  inline int * row() const
    188   { return row_;};
     188  { return row_;}
    189189  /// elements
    190190  inline float * element() const
    191   { return element_;};
     191  { return element_;}
    192192  /// costs
    193193  inline float * cost() const
    194   { return cost_;};
     194  { return cost_;}
    195195  /// ids of active columns (just index here)
    196196  inline int * id() const
    197   { return id_;};
     197  { return id_;}
    198198  /// Optional lower bounds on columns
    199199  inline float * columnLower() const
    200   { return columnLower_;};
     200  { return columnLower_;}
    201201  /// Optional upper bounds on columns
    202202  inline float * columnUpper() const
    203   { return columnUpper_;};
     203  { return columnUpper_;}
    204204  /// Lower bounds on sets
    205205  inline float * lowerSet() const
    206   { return lowerSet_;};
     206  { return lowerSet_;}
    207207  /// Upper bounds on sets
    208208  inline float * upperSet() const
    209   { return upperSet_;};
     209  { return upperSet_;}
    210210  /// size
    211211  inline int numberGubColumns() const
    212   { return numberGubColumns_;};
     212  { return numberGubColumns_;}
    213213  /// first free
    214214  inline int firstAvailable() const
    215   { return firstAvailable_;};
     215  { return firstAvailable_;}
    216216  /// first dynamic
    217217  inline int firstDynamic() const
    218   { return firstDynamic_;};
     218  { return firstDynamic_;}
    219219  /// number of columns in dynamic model
    220220  inline int lastDynamic() const
    221   { return lastDynamic_;};
     221  { return lastDynamic_;}
    222222  /// number of rows in original model
    223223  inline int numberStaticRows() const
    224   { return numberStaticRows_;};
     224  { return numberStaticRows_;}
    225225  /// size of working matrix (max)
    226226  inline int numberElements() const
    227   { return numberElements_;};
     227  { return numberElements_;}
    228228  inline int * keyVariable() const
    229   { return keyVariable_;};
     229  { return keyVariable_;}
    230230  /// Switches off dj checking each factorization (for BIG models)
    231231  void switchOffCheck();
    232232  /// Status region for gub slacks
    233233  inline unsigned char * gubRowStatus() const
    234   { return status_;};
     234  { return status_;}
    235235  /// Status region for gub variables
    236236  inline unsigned char * dynamicStatus() const
    237   { return dynamicStatus_;};
     237  { return dynamicStatus_;}
    238238  /// Returns which set a variable is in
    239239  int whichSet (int sequence) const;
  • trunk/Clp/src/ClpEventHandler.hpp

    r1034 r1055  
    7474  /// Get model
    7575  inline ClpSimplex * simplex() const
    76   { return model_;};
     76  { return model_;}
    7777  //@}
    7878 
     
    131131  /// Get model
    132132  inline ClpSimplex * simplex() const
    133   { return model_;};
     133  { return model_;}
    134134  //@}
    135135 
  • trunk/Clp/src/ClpFactorization.hpp

    r754 r1055  
    105105  /// Says if a network basis
    106106  inline bool networkBasis() const
    107   { return (networkBasis_!=NULL);};
     107  { return (networkBasis_!=NULL);}
    108108#else
    109109  /// Says if a network basis
    110110  inline bool networkBasis() const
    111   { return false;};
     111  { return false;}
    112112#endif
    113113  /// Fills weighted row list
  • trunk/Clp/src/ClpGubDynamicMatrix.hpp

    r800 r1055  
    101101  inline bool flagged(int i) const {
    102102    return (dynamicStatus_[i]&8)!=0;
    103   };
     103  }
    104104  inline void setFlagged(int i) {
    105105    dynamicStatus_[i] |= 8;
    106   };
     106  }
    107107  inline void unsetFlagged(int i) {
    108108    dynamicStatus_[i]  &= ~8;;
    109   };
     109  }
    110110  inline void setDynamicStatus(int sequence, DynamicStatus status)
    111111  {
     
    113113    st_byte &= ~7;
    114114    st_byte |= status;
    115   };
     115  }
    116116  inline DynamicStatus getDynamicStatus(int sequence) const
    117   {return static_cast<DynamicStatus> (dynamicStatus_[sequence]&7);};
     117  {return static_cast<DynamicStatus> (dynamicStatus_[sequence]&7);}
    118118  /// Saved value of objective offset
    119119  inline double objectiveOffset() const
    120   { return objectiveOffset_;};
     120  { return objectiveOffset_;}
    121121  /// Starts of each column
    122122  inline CoinBigIndex * startColumn() const
    123   { return startColumn_;};
     123  { return startColumn_;}
    124124  /// rows
    125125  inline int * row() const
    126   { return row_;};
     126  { return row_;}
    127127  /// elements
    128128  inline float * element() const
    129   { return element_;};
     129  { return element_;}
    130130  /// costs
    131131  inline float * cost() const
    132   { return cost_;};
     132  { return cost_;}
    133133  /// full starts
    134134  inline int * fullStart() const
    135   { return fullStart_;};
     135  { return fullStart_;}
    136136  /// ids of active columns (just index here)
    137137  inline int * id() const
    138   { return id_;};
     138  { return id_;}
    139139  /// Optional lower bounds on columns
    140140  inline float * lowerColumn() const
    141   { return lowerColumn_;};
     141  { return lowerColumn_;}
    142142  /// Optional upper bounds on columns
    143143  inline float * upperColumn() const
    144   { return upperColumn_;};
     144  { return upperColumn_;}
    145145  /// Optional true lower bounds on sets
    146146  inline float * lowerSet() const
    147   { return lowerSet_;};
     147  { return lowerSet_;}
    148148  /// Optional true upper bounds on sets
    149149  inline float * upperSet() const
    150   { return upperSet_;};
     150  { return upperSet_;}
    151151  /// size
    152152  inline int numberGubColumns() const
    153   { return numberGubColumns_;};
     153  { return numberGubColumns_;}
    154154  /// first free
    155155  inline int firstAvailable() const
    156   { return firstAvailable_;};
     156  { return firstAvailable_;}
    157157  /// set first free
    158158  inline void setFirstAvailable(int value)
    159   { firstAvailable_ = value;};
     159  { firstAvailable_ = value;}
    160160  /// first dynamic
    161161  inline int firstDynamic() const
    162   { return firstDynamic_;};
     162  { return firstDynamic_;}
    163163  /// number of columns in dynamic model
    164164  inline int lastDynamic() const
    165   { return lastDynamic_;};
     165  { return lastDynamic_;}
    166166  /// size of working matrix (max)
    167167  inline int numberElements() const
    168   { return numberElements_;};
     168  { return numberElements_;}
    169169  /// Status region for gub slacks
    170170  inline unsigned char * gubRowStatus() const
    171   { return status_;};
     171  { return status_;}
    172172  /// Status region for gub variables
    173173  inline unsigned char * dynamicStatus() const
    174   { return dynamicStatus_;};
     174  { return dynamicStatus_;}
    175175  /// Returns which set a variable is in
    176176  int whichSet (int sequence) const;
  • trunk/Clp/src/ClpGubMatrix.hpp

    r1034 r1055  
    206206  /// Status
    207207  inline ClpSimplex::Status getStatus(int sequence) const
    208   {return static_cast<ClpSimplex::Status> (status_[sequence]&7);};
     208  {return static_cast<ClpSimplex::Status> (status_[sequence]&7);}
    209209  inline void setStatus(int sequence, ClpSimplex::Status status)
    210210  {
     
    212212    st_byte &= ~7;
    213213    st_byte |= status;
    214   };
     214  }
    215215  /// To flag a variable
    216216  inline void setFlagged( int sequence)
    217217  {
    218218    status_[sequence] |= 64;
    219   };
     219  }
    220220  inline void clearFlagged( int sequence)
    221221  {
    222222    status_[sequence] &= ~64;
    223   };
     223  }
    224224  inline bool flagged(int sequence) const
    225   {return ((status_[sequence]&64)!=0);};
     225  {return ((status_[sequence]&64)!=0);}
    226226  /// To say key is above ub
    227227  inline void setAbove( int sequence)
     
    230230    iStat &= ~24;
    231231    status_[sequence] = iStat|16;
    232   };
     232  }
    233233  /// To say key is feasible
    234234  inline void setFeasible( int sequence)
     
    237237    iStat &= ~24;
    238238    status_[sequence] = iStat|8;
    239   };
     239  }
    240240  /// To say key is below lb
    241241  inline void setBelow( int sequence)
     
    244244    iStat &= ~24;
    245245    status_[sequence] = iStat;
    246   };
     246  }
    247247  inline double weight( int sequence) const
    248248  {
     
    250250    iStat = iStat>>3;
    251251    return (double) (iStat-1);
    252   };
     252  }
    253253  /// Starts
    254254  inline int * start() const
    255   { return start_;};
     255  { return start_;}
    256256  /// End
    257257  inline int * end() const
    258   { return end_;};
     258  { return end_;}
    259259  /// Lower bounds on sets
    260260  inline double * lower() const
    261   { return lower_;};
     261  { return lower_;}
    262262  /// Upper bounds on sets
    263263  inline double * upper() const
    264   { return upper_;};
     264  { return upper_;}
    265265  /// Key variable of set
    266266  inline int * keyVariable() const
    267   { return keyVariable_;};
     267  { return keyVariable_;}
    268268  /// Backward pointer to set number
    269269  inline int * backward() const
    270   { return backward_;};
     270  { return backward_;}
    271271  /// Number of sets (gub rows)
    272272  inline int numberSets() const
    273   { return numberSets_;};
     273  { return numberSets_;}
    274274  /// Switches off dj checking each factorization (for BIG models)
    275275  void switchOffCheck();
  • trunk/Clp/src/ClpInterior.hpp

    r897 r1055  
    162162  /// If problem is primal feasible
    163163  inline bool primalFeasible() const
    164          { return (sumPrimalInfeasibilities_<=1.0e-5);};
     164         { return (sumPrimalInfeasibilities_<=1.0e-5);}
    165165  /// If problem is dual feasible
    166166  inline bool dualFeasible() const
    167          { return (sumDualInfeasibilities_<=1.0e-5);};
     167         { return (sumDualInfeasibilities_<=1.0e-5);}
    168168  /// Current (or last) algorithm
    169169  inline int algorithm() const
    170   {return algorithm_; } ;
     170  {return algorithm_; }
    171171  /// Set algorithm
    172172  inline void setAlgorithm(int value)
    173   {algorithm_=value; } ;
     173  {algorithm_=value; }
    174174  /// Sum of dual infeasibilities
    175175  inline double sumDualInfeasibilities() const
    176           { return sumDualInfeasibilities_;} ;
     176          { return sumDualInfeasibilities_;}
    177177  /// Sum of primal infeasibilities
    178178  inline double sumPrimalInfeasibilities() const
    179           { return sumPrimalInfeasibilities_;} ;
     179          { return sumPrimalInfeasibilities_;}
    180180  /// dualObjective.
    181181  inline double dualObjective() const
    182   { return dualObjective_;};
     182  { return dualObjective_;}
    183183  /// primalObjective.
    184184  inline double primalObjective() const
    185   { return primalObjective_;};
     185  { return primalObjective_;}
    186186  /// diagonalNorm
    187187  inline double diagonalNorm() const
    188   { return diagonalNorm_;};
     188  { return diagonalNorm_;}
    189189  /// linearPerturbation
    190190  inline double linearPerturbation() const
    191   { return linearPerturbation_;};
     191  { return linearPerturbation_;}
    192192  inline void setLinearPerturbation(double value)
    193   { linearPerturbation_=value;};
     193  { linearPerturbation_=value;}
    194194  /// diagonalPerturbation
    195195  inline double diagonalPerturbation() const
    196   { return diagonalPerturbation_;};
     196  { return diagonalPerturbation_;}
    197197  inline void setDiagonalPerturbation(double value)
    198   { diagonalPerturbation_=value;};
     198  { diagonalPerturbation_=value;}
    199199  /// gamma
    200200  inline double gamma() const
    201   { return gamma_;};
     201  { return gamma_;}
    202202  inline void setGamma(double value)
    203   { gamma_=value;};
     203  { gamma_=value;}
    204204  /// delta
    205205  inline double delta() const
    206   { return delta_;};
     206  { return delta_;}
    207207  inline void setDelta(double value)
    208   { delta_=value;};
     208  { delta_=value;}
    209209  /// ComplementarityGap
    210210  inline double complementarityGap() const
    211           { return complementarityGap_;} ;
     211          { return complementarityGap_;}
    212212  //@}
    213213
     
    216216  /// Largest error on Ax-b
    217217  inline double largestPrimalError() const
    218           { return largestPrimalError_;} ;
     218          { return largestPrimalError_;}
    219219  /// Largest error on basic duals
    220220  inline double largestDualError() const
    221           { return largestDualError_;} ;
     221          { return largestDualError_;}
    222222  /// Maximum iterations
    223223  inline int maximumBarrierIterations() const
    224   { return maximumBarrierIterations_;};
     224  { return maximumBarrierIterations_;}
    225225  inline void setMaximumBarrierIterations(int value)
    226   { maximumBarrierIterations_=value;};
     226  { maximumBarrierIterations_=value;}
    227227  /// Set cholesky (and delete present one)
    228228  void setCholesky(ClpCholeskyBase * cholesky);
     
    234234  /// Primal erturbation vector
    235235  inline double * primalR() const
    236   { return primalR_;};
     236  { return primalR_;}
    237237  /// Dual erturbation vector
    238238  inline double * dualR() const
    239   { return dualR_;};
     239  { return dualR_;}
    240240  //@}
    241241
     
    260260  /// Raw objective value (so always minimize)
    261261  inline double rawObjectiveValue() const
    262   { return objectiveValue_;};
     262  { return objectiveValue_;}
    263263  /// Returns 1 if sequence indicates column
    264264  inline int isColumn(int sequence) const
    265   { return sequence<numberColumns_ ? 1 : 0;};
     265  { return sequence<numberColumns_ ? 1 : 0;}
    266266  /// Returns sequence number within section
    267267  inline int sequenceWithin(int sequence) const
    268   { return sequence<numberColumns_ ? sequence : sequence-numberColumns_;};
     268  { return sequence<numberColumns_ ? sequence : sequence-numberColumns_;}
    269269  /// Checks solution
    270270  void checkSolution();
     
    278278  {
    279279    status_[sequence] |= 1;
    280   };
     280  }
    281281  inline void clearFixed( int sequence)
    282282  {
    283283    status_[sequence] &= ~1;
    284   };
     284  }
    285285  inline bool fixed(int sequence) const
    286   {return ((status_[sequence]&1)!=0);};
     286  {return ((status_[sequence]&1)!=0);}
    287287
    288288  /// To flag a variable
     
    290290  {
    291291    status_[sequence] |= 2;
    292   };
     292  }
    293293  inline void clearFlagged( int sequence)
    294294  {
    295295    status_[sequence] &= ~2;
    296   };
     296  }
    297297  inline bool flagged(int sequence) const
    298   {return ((status_[sequence]&2)!=0);};
     298  {return ((status_[sequence]&2)!=0);}
    299299
    300300  /// To say a variable is fixed OR free
     
    302302  {
    303303    status_[sequence] |= 4;
    304   };
     304  }
    305305  inline void clearFixedOrFree( int sequence)
    306306  {
    307307    status_[sequence] &= ~4;
    308   };
     308  }
    309309  inline bool fixedOrFree(int sequence) const
    310   {return ((status_[sequence]&4)!=0);};
     310  {return ((status_[sequence]&4)!=0);}
    311311
    312312  /// To say a variable has lower bound
     
    314314  {
    315315    status_[sequence] |= 8;
    316   };
     316  }
    317317  inline void clearLowerBound( int sequence)
    318318  {
    319319    status_[sequence] &= ~8;
    320   };
     320  }
    321321  inline bool lowerBound(int sequence) const
    322   {return ((status_[sequence]&8)!=0);};
     322  {return ((status_[sequence]&8)!=0);}
    323323
    324324  /// To say a variable has upper bound
     
    326326  {
    327327    status_[sequence] |= 16;
    328   };
     328  }
    329329  inline void clearUpperBound( int sequence)
    330330  {
    331331    status_[sequence] &= ~16;
    332   };
     332  }
    333333  inline bool upperBound(int sequence) const
    334   {return ((status_[sequence]&16)!=0);};
     334  {return ((status_[sequence]&16)!=0);}
    335335
    336336  /// To say a variable has fake lower bound
     
    338338  {
    339339    status_[sequence] |= 32;
    340   };
     340  }
    341341  inline void clearFakeLower( int sequence)
    342342  {
    343343    status_[sequence] &= ~32;
    344   };
     344  }
    345345  inline bool fakeLower(int sequence) const
    346   {return ((status_[sequence]&32)!=0);};
     346  {return ((status_[sequence]&32)!=0);}
    347347
    348348  /// To say a variable has fake upper bound
     
    350350  {
    351351    status_[sequence] |= 64;
    352   };
     352  }
    353353  inline void clearFakeUpper( int sequence)
    354354  {
    355355    status_[sequence] &= ~64;
    356   };
     356  }
    357357  inline bool fakeUpper(int sequence) const
    358   {return ((status_[sequence]&64)!=0);};
     358  {return ((status_[sequence]&64)!=0);}
    359359  //@}
    360360
  • trunk/Clp/src/ClpMatrixBase.hpp

    r1034 r1055  
    8282  /** Returns a new matrix in reverse order without gaps
    8383      Is allowed to return NULL if doesn't want to have row copy */
    84   virtual ClpMatrixBase * reverseOrderedCopy() const {return NULL;};
     84  virtual ClpMatrixBase * reverseOrderedCopy() const {return NULL;}
    8585 
    8686  /// Returns number of elements in column part of basis
     
    100100      returns non-zero if no scaling done */
    101101  virtual int scale(ClpModel * model) const
    102   { return 1;};
     102  { return 1;}
    103103  /** Scales rowCopy if column copy scaled
    104104      Only called if scales already exist */
    105105  virtual void scaleRowCopy(ClpModel * model) const
    106   { };
     106  { }
    107107  /// Returns true if can create row copy
    108108  virtual bool canGetRowCopy() const
    109   { return true;};
     109  { return true;}
    110110  /** Realy really scales column copy
    111111      Only called if scales already exist.
    112112      Up to user to delete */
    113113  inline virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const
    114   { return this->clone();};
     114  { return this->clone();}
    115115 
    116116  /** Checks if all elements are in valid range.  Can just
     
    127127                                  double smallest, double largest,
    128128                                  int check=15)
    129   { return true;};
     129  { return true;}
    130130  /** Set the dimensions of the matrix. In effect, append new empty
    131131      columns/rows to the matrix. A negative number for either dimension
     
    156156  */
    157157  virtual int refresh(ClpSimplex * model)
    158   { return 0;};
     158  { return 0;}
    159159 
    160160  // Really scale matrix
     
    296296      and if it would be faster */
    297297  virtual bool canCombine(const ClpSimplex * model,
    298                           const CoinIndexedVector * pi) const {return false;};
     298                          const CoinIndexedVector * pi) const {return false;}
    299299  /// Updates two arrays for steepest and does devex weights (need not be coded)
    300300  virtual void transposeTimes2(const ClpSimplex * model,
     
    343343  */
    344344  inline int type() const
    345   { return type_;};
     345  { return type_;}
    346346  /// Sets type
    347   void setType(int type) {type_=type;};
     347  void setType(int type) {type_=type;}
    348348  /// Sets up an effective RHS
    349349  void useEffectiveRhs(ClpSimplex * model);
     
    355355  /// If rhsOffset used this is iteration last refreshed
    356356  inline int lastRefresh() const
    357   { return lastRefresh_;};
     357  { return lastRefresh_;}
    358358  /// If rhsOffset used this is refresh frequency (0==off)
    359359  inline int refreshFrequency() const
    360   { return refreshFrequency_;};
     360  { return refreshFrequency_;}
    361361  inline void setRefreshFrequency(int value)
    362   { refreshFrequency_=value;};
     362  { refreshFrequency_=value;}
    363363  /// whether to skip dual checks most of time
    364364  inline bool skipDualCheck() const
    365   { return skipDualCheck_;};
     365  { return skipDualCheck_;}
    366366  inline void setSkipDualCheck(bool yes)
    367   { skipDualCheck_=yes;};
     367  { skipDualCheck_=yes;}
    368368  /** Partial pricing tuning parameter - minimum number of "objects" to scan.
    369369      e.g. number of Gub sets but could be number of variables */
    370370  inline int minimumObjectsScan() const
    371   { return minimumObjectsScan_;};
     371  { return minimumObjectsScan_;}
    372372  inline void setMinimumObjectsScan(int value)
    373   { minimumObjectsScan_=value;};
     373  { minimumObjectsScan_=value;}
    374374  /// Partial pricing tuning parameter - minimum number of negative reduced costs to get
    375375  inline int minimumGoodReducedCosts() const
    376   { return minimumGoodReducedCosts_;};
     376  { return minimumGoodReducedCosts_;}
    377377  inline void setMinimumGoodReducedCosts(int value)
    378   { minimumGoodReducedCosts_=value;};
     378  { minimumGoodReducedCosts_=value;}
    379379  /// Current start of search space in matrix (as fraction)
    380380  inline double startFraction() const
    381   { return startFraction_;};
     381  { return startFraction_;}
    382382  inline void setStartFraction(double value)
    383   { startFraction_ = value;};
     383  { startFraction_ = value;}
    384384  /// Current end of search space in matrix (as fraction)
    385385  inline double endFraction() const
    386   { return endFraction_;};
     386  { return endFraction_;}
    387387  inline void setEndFraction(double value)
    388   { endFraction_ = value;};
     388  { endFraction_ = value;}
    389389  /// Current best reduced cost
    390390  inline double savedBestDj() const
    391   { return savedBestDj_;};
     391  { return savedBestDj_;}
    392392  inline void setSavedBestDj(double value)
    393   { savedBestDj_ = value;};
     393  { savedBestDj_ = value;}
    394394  /// Initial number of negative reduced costs wanted
    395395  inline int originalWanted() const
    396   { return originalWanted_;};
     396  { return originalWanted_;}
    397397  inline void setOriginalWanted(int value)
    398   { originalWanted_ = value;};
     398  { originalWanted_ = value;}
    399399  /// Current number of negative reduced costs which we still need
    400400  inline int currentWanted() const
    401   { return currentWanted_;};
     401  { return currentWanted_;}
    402402  inline void setCurrentWanted(int value)
    403   { currentWanted_ = value;};
     403  { currentWanted_ = value;}
    404404  /// Current best sequence
    405405  inline int savedBestSequence() const
    406   { return savedBestSequence_;};
     406  { return savedBestSequence_;}
    407407  inline void setSavedBestSequence(int value)
    408   { savedBestSequence_ = value;};
     408  { savedBestSequence_ = value;}
    409409  //@}
    410410 
  • trunk/Clp/src/ClpModel.hpp

    r1034 r1055  
    330330  void setObjectiveOffset(double value);
    331331#ifndef CLP_NO_STD
    332   inline std::string problemName() const { return strParam_[ClpProbName]; };
     332  inline std::string problemName() const { return strParam_[ClpProbName]; }
    333333#endif
    334334   /// Number of iterations
     
    336336   inline int getIterationCount() const { return numberIterations_; }
    337337  inline void setNumberIterations(int numberIterations)
    338   { numberIterations_ = numberIterations;};
     338  { numberIterations_ = numberIterations;}
    339339  /** Solve type - 1 simplex, 2 simplex interface, 3 Interior.*/
    340340  inline int solveType() const
    341   { return solveType_;};
     341  { return solveType_;}
    342342  inline void setSolveType(int type)
    343   { solveType_=type;};
     343  { solveType_=type;}
    344344   /// Maximum number of iterations
    345345   inline int maximumIterations() const { return intParam_[ClpMaxNumIteration]; }
     
    363363  /// Set problem status
    364364  inline void setProblemStatus(int problemStatus)
    365   { problemStatus_ = problemStatus;};
     365  { problemStatus_ = problemStatus;}
    366366   /** Secondary status of problem - may get extended
    367367       0 - none
     
    379379   inline int secondaryStatus() const            { return secondaryStatus_; }
    380380  inline void setSecondaryStatus(int status)
    381   { secondaryStatus_ = status;};
     381  { secondaryStatus_ = status;}
    382382   /// Are there a numerical difficulties?
    383383   inline bool isAbandoned() const             { return problemStatus_==4; }
     
    407407   inline const double * getColSolution() const { return columnActivity_; }
    408408   inline void setColSolution(const double * input)
    409    { memcpy(columnActivity_,input,numberColumns_*sizeof(double));};
     409   { memcpy(columnActivity_,input,numberColumns_*sizeof(double));}
    410410   /// Dual row solution
    411411   inline double * dualRowSolution() const      { return dual_; }
     
    427427       /** Set an objective function coefficient */
    428428       inline void setObjCoeff( int elementIndex, double elementValue )
    429        { setObjectiveCoefficient( elementIndex, elementValue);};
     429       { setObjectiveCoefficient( elementIndex, elementValue);}
    430430
    431431      /** Set a single column lower bound<br>
     
    456456          Use -DBL_MAX for -infinity. */
    457457       inline void setColLower( int elementIndex, double elementValue )
    458        { setColumnLower(elementIndex, elementValue);};
     458       { setColumnLower(elementIndex, elementValue);}
    459459      /** Set a single column upper bound<br>
    460460          Use DBL_MAX for infinity. */
    461461       inline void setColUpper( int elementIndex, double elementValue )
    462        { setColumnUpper(elementIndex, elementValue);};
     462       { setColumnUpper(elementIndex, elementValue);}
    463463
    464464      /** Set a single column lower and upper bound */
    465465      inline void setColBounds( int elementIndex,
    466466        double lower, double upper )
    467        { setColumnBounds(elementIndex, lower, upper);};
     467       { setColumnBounds(elementIndex, lower, upper);}
    468468
    469469      /** Set the bounds on a number of columns simultaneously<br>
     
    476476                                   const int* indexLast,
    477477                                   const double* boundList)
    478       { setColumnSetBounds(indexFirst, indexLast, boundList);};
     478      { setColumnSetBounds(indexFirst, indexLast, boundList);}
    479479     
    480480      /** Set a single row lower bound<br>
     
    502502    //@}
    503503   /// Scaling
    504    inline const double * rowScale() const {return rowScale_;};
    505    inline const double * columnScale() const {return columnScale_;};
    506    inline void setRowScale(double * scale) { delete [] (double *) rowScale_; rowScale_ = scale;};
    507    inline void setColumnScale(double * scale) { delete [] (double *) columnScale_; columnScale_ = scale;};
     504   inline const double * rowScale() const {return rowScale_;}
     505   inline const double * columnScale() const {return columnScale_;}
     506   inline void setRowScale(double * scale) { delete [] (double *) rowScale_; rowScale_ = scale;}
     507   inline void setColumnScale(double * scale) { delete [] (double *) columnScale_; columnScale_ = scale;}
    508508  /// Scaling of objective
    509509  inline double objectiveScale() const
    510           { return objectiveScale_;} ;
     510          { return objectiveScale_;}
    511511  inline void setObjectiveScale(double value)
    512           { objectiveScale_ = value;} ;
     512          { objectiveScale_ = value;}
    513513  /// Scaling of rhs and bounds
    514514  inline double rhsScale() const
    515           { return rhsScale_;} ;
     515          { return rhsScale_;}
    516516  inline void setRhsScale(double value)
    517           { rhsScale_ = value;} ;
     517          { rhsScale_ = value;}
    518518   /// Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later)
    519519   void scaling(int mode=1);
     
    522522  void unscale();
    523523   /// Gets scalingFlag
    524    inline int scalingFlag() const {return scalingFlag_;};
     524   inline int scalingFlag() const {return scalingFlag_;}
    525525   /// Objective
    526526   inline double * objective() const           
     
    569569   /// Number of elements in matrix
    570570   inline int getNumElements() const
    571      { return matrix_->getNumElements();};
     571     { return matrix_->getNumElements();}
    572572   /** Small element value - elements less than this set to zero,
    573573      default is 1.0e-20 */
    574574   inline double getSmallElementValue() const
    575   { return smallElement_;};
     575  { return smallElement_;}
    576576  inline void setSmallElementValue(double value)
    577   { smallElement_=value;};
     577  { smallElement_=value;}
    578578   /// Row Matrix
    579579   inline ClpMatrixBase * rowCopy() const       { return rowCopy_; }
     
    593593   inline void replaceMatrix(CoinPackedMatrix * matrix,
    594594                             bool deleteCurrent=false)
    595   { replaceMatrix(new ClpPackedMatrix(matrix),deleteCurrent);};
     595  { replaceMatrix(new ClpPackedMatrix(matrix),deleteCurrent);}
    596596   /// Objective value
    597597   inline double objectiveValue() const {
     
    612612  /// See if status (i.e. basis) array exists (partly for OsiClp)
    613613  inline bool statusExists() const
    614   { return (status_!=NULL);};
     614  { return (status_!=NULL);}
    615615  /// Return address of status (i.e. basis) array (char[numberRows+numberColumns])
    616616  inline unsigned char *  statusArray() const
    617   { return status_;};
     617  { return status_;}
    618618  /** Return copy of status (i.e. basis) array (char[numberRows+numberColumns]),
    619619      use delete [] */
     
    624624  /// User pointer for whatever reason
    625625  inline void setUserPointer (void * pointer)
    626   { userPointer_=pointer;};
     626  { userPointer_=pointer;}
    627627  inline void * getUserPointer () const
    628   { return userPointer_;};
     628  { return userPointer_;}
    629629  /// What has changed in model (only for masochistic users)
    630630  inline int whatsChanged() const
    631           { return whatsChanged_;} ;
     631          { return whatsChanged_;}
    632632  inline void setWhatsChanged(int value)
    633           { whatsChanged_ = value;} ;
     633          { whatsChanged_ = value;}
    634634  /// Number of threads (not really being used)
    635635  inline int numberThreads() const
    636           { return numberThreads_;} ;
     636          { return numberThreads_;}
    637637  inline void setNumberThreads(int value)
    638           { numberThreads_ = value;} ;
     638          { numberThreads_ = value;}
    639639  //@}
    640640  /**@name Message handling */
     
    674674   /// Event handler
    675675   inline ClpEventHandler * eventHandler() const
    676   { return eventHandler_;};
     676  { return eventHandler_;}
    677677   /// length of names (0 means no names0
    678678   inline int lengthNames() const { return lengthNames_; }
     
    701701  /// Objective methods
    702702  inline ClpObjective * objectiveAsObject() const
    703   { return objective_;};
     703  { return objective_;}
    704704  void setObjective(ClpObjective * objective);
    705705  inline void setObjectivePointer(ClpObjective * objective)
    706   { objective_ = objective;};
     706  { objective_ = objective;}
    707707  /** Solve a problem with no elements - return status and
    708708      dual and primal infeasibilites */
     
    817817#define COIN_CBC_USING_CLP 0x01000000
    818818  inline unsigned int specialOptions() const
    819   { return specialOptions_;};
     819  { return specialOptions_;}
    820820  void setSpecialOptions(unsigned int value);
    821821  //@}
  • trunk/Clp/src/ClpNetworkMatrix.hpp

    r901 r1055  
    2929   virtual int getNumCols() const { return numberColumns_; }
    3030   /** Number of rows. */
    31   virtual int getNumRows() const { return numberRows_; };
     31  virtual int getNumRows() const { return numberRows_; }
    3232
    3333   /** A vector containing the elements in the packed matrix. Note that there
     
    4242        vectorLengths. */
    4343  virtual const int * getIndices() const
    44   { return indices_;};
     44  { return indices_;}
    4545
    4646  virtual const CoinBigIndex * getVectorStarts() const;
     
    146146  /// Return true if really network, false if has slacks
    147147  inline bool trueNetwork() const
    148   { return trueNetwork_;};
     148  { return trueNetwork_;}
    149149   //@}
    150150
  • trunk/Clp/src/ClpNonLinearCost.hpp

    r800 r1055  
    256256  /// Returns current lower bound
    257257  inline double lower(int sequence) const
    258   { return lower_[whichRange_[sequence]+offset_[sequence]];};
     258  { return lower_[whichRange_[sequence]+offset_[sequence]];}
    259259  /// Returns current upper bound
    260260  inline double upper(int sequence) const
    261   { return lower_[whichRange_[sequence]+offset_[sequence]+1];};
     261  { return lower_[whichRange_[sequence]+offset_[sequence]+1];}
    262262  /// Returns current cost
    263263  inline double cost(int sequence) const
    264   { return cost_[whichRange_[sequence]+offset_[sequence]];};
     264  { return cost_[whichRange_[sequence]+offset_[sequence]];}
    265265  //@}
    266266
     
    270270  /// Number of infeasibilities
    271271  inline int numberInfeasibilities() const
    272   {return numberInfeasibilities_;};
     272  {return numberInfeasibilities_;}
    273273  /// Change in cost
    274274  inline double changeInCost() const
    275   {return changeCost_;};
     275  {return changeCost_;}
    276276  /// Feasible cost
    277277  inline double feasibleCost() const
    278   {return feasibleCost_;};
     278  {return feasibleCost_;}
    279279  /// Feasible cost with offset and direction (i.e. for reporting)
    280280  double feasibleReportCost() const;
    281281  /// Sum of infeasibilities
    282282  inline double sumInfeasibilities() const
    283   {return sumInfeasibilities_;};
     283  {return sumInfeasibilities_;}
    284284  /// Largest infeasibility
    285285  inline double largestInfeasibility() const
    286   {return largestInfeasibility_;};
     286  {return largestInfeasibility_;}
    287287  /// Average theta
    288288  inline double averageTheta() const
    289   {return averageTheta_;};
     289  {return averageTheta_;}
    290290  inline void setAverageTheta(double value)
    291   {averageTheta_=value;};
     291  {averageTheta_=value;}
    292292  inline void setChangeInCost(double value)
    293   {changeCost_ = value;};
     293  {changeCost_ = value;}
    294294  inline void setMethod(int value)
    295   {method_ = value;};
     295  {method_ = value;}
    296296  /// See if may want to look both ways
    297297  inline bool lookBothWays() const
    298   { return bothWays_;};
     298  { return bothWays_;}
    299299  //@}
    300300  ///@name Private functions to deal with infeasible regions
     
    311311  }
    312312  inline unsigned char * statusArray() const
    313   { return status_;};
     313  { return status_;}
    314314  /// For debug
    315315  void validate();
  • trunk/Clp/src/ClpObjective.hpp

    r1034 r1055  
    6161  virtual int markNonlinear(char * which);
    6262  /// Say we have new primal solution - so may need to recompute
    63   virtual void newXValues() {};
     63  virtual void newXValues() {}
    6464  //@}
    6565 
     
    9494  /// Returns type (above 63 is extra information)
    9595  inline int type()
    96   { return type_;};
     96  { return type_;}
    9797  /// Whether activated
    9898  inline int activated() const
    99   {return activated_;};
     99  {return activated_;}
    100100  /// Set whether activated
    101101  inline void setActivated(int value)
    102   {activated_=value;};
     102  {activated_=value;}
    103103 
    104104  /// Objective offset
    105105  inline double nonlinearOffset () const
    106   { return offset_;};
     106  { return offset_;}
    107107  //@}
    108108
  • trunk/Clp/src/ClpPackedMatrix.hpp

    r1034 r1055  
    2222   //@{
    2323   /// Return a complete CoinPackedMatrix
    24   virtual CoinPackedMatrix * getPackedMatrix() const { return matrix_;};
     24  virtual CoinPackedMatrix * getPackedMatrix() const { return matrix_;}
    2525    /** Whether the packed matrix is column major ordered or not. */
    2626    virtual bool isColOrdered() const { return matrix_->isColOrdered(); }
     
    3131   virtual int getNumCols() const { return matrix_->getNumCols(); }
    3232   /** Number of rows. */
    33   virtual int getNumRows() const { return matrix_->getNumRows(); };
     33  virtual int getNumRows() const { return matrix_->getNumRows(); }
    3434
    3535   /** A vector containing the elements in the packed matrix. Note that there
     
    3838        this vector together with vectorStarts and vectorLengths. */
    3939   virtual const double * getElements() const
    40   { return matrix_->getElements();};
     40  { return matrix_->getElements();}
    4141   /** A vector containing the minor indices of the elements in the packed
    4242        matrix. Note that there might be gaps in this list, entries that do not
     
    4545        vectorLengths. */
    4646   virtual const int * getIndices() const
    47   { return matrix_->getIndices();};
     47  { return matrix_->getIndices();}
    4848
    4949   virtual const CoinBigIndex * getVectorStarts() const
    50   { return matrix_->getVectorStarts();};
     50  { return matrix_->getVectorStarts();}
    5151   /** The lengths of the major-dimension vectors. */
    5252   virtual const int * getVectorLengths() const
    53   { return matrix_->getVectorLengths();} ;
     53  { return matrix_->getVectorLengths();}
    5454  /** The length of a single major-dimension vector. */
    5555  virtual int getVectorLength(int index) const
    56   { return matrix_->getVectorSize(index);};
     56  { return matrix_->getVectorSize(index);}
    5757
    5858    /** Delete the columns whose indices are listed in <code>indDel</code>. */
     
    7979  virtual void replaceVector(const int index,
    8080                       const int numReplace, const double * newElements)
    81       {matrix_->replaceVector(index,numReplace,newElements);};
     81      {matrix_->replaceVector(index,numReplace,newElements);}
    8282  /** Modify one element of packed matrix.  An element may be added.
    8383      This works for either ordering If the new element is zero it will be
     
    148148                   int column, double multiplier) const;
    149149   /// Allow any parts of a created CoinPackedMatrix to be deleted
    150    virtual void releasePackedMatrix() const { };
     150   virtual void releasePackedMatrix() const { }
    151151  /** Given positive integer weights for each row fills in sum of weights
    152152      for each column (and slack).
     
    254254   //@{
    255255  /// Returns CoinPackedMatrix (non const)
    256   inline CoinPackedMatrix * matrix() const { return matrix_;};
     256  inline CoinPackedMatrix * matrix() const { return matrix_;}
    257257  /** Just sets matrix_ to NULL so it can be used elsewhere.
    258258      used in GUB
    259259  */
    260260  inline void setMatrixNull()
    261   { matrix_=NULL;};
     261  { matrix_=NULL;}
    262262  /// Say we want special column copy
    263263  inline void makeSpecialColumnCopy()
    264   { flags_ |= 8;};
     264  { flags_ |= 8;}
    265265  /// Say we don't want special column copy
    266266  void releaseSpecialColumnCopy();
    267267  /// Are there zeros?
    268268  inline bool zeros() const
    269   { return ((flags_&1)!=0);};
     269  { return ((flags_&1)!=0);}
    270270  /// Do we want special column copy
    271271  inline bool wantsSpecialColumnCopy() const
    272   { return ((flags_&8)!=0);};
     272  { return ((flags_&8)!=0);}
    273273   //@}
    274274
     
    396396  /// Returns true if copy has useful information
    397397  inline bool usefulInfo() const
    398   { return rowStart_!=NULL;};
     398  { return rowStart_!=NULL;}
    399399  //@}
    400400
  • trunk/Clp/src/ClpPlusMinusOneMatrix.hpp

    r901 r1055  
    2727   virtual int getNumCols() const { return numberColumns_; }
    2828   /** Number of rows. */
    29   virtual int getNumRows() const { return numberRows_; };
     29  virtual int getNumRows() const { return numberRows_; }
    3030
    3131   /** A vector containing the elements in the packed matrix. Note that there
     
    4040        vectorLengths. */
    4141  virtual const int * getIndices() const
    42   { return indices_;};
     42  { return indices_;}
    4343  // and for advanced use
    4444  int * getMutableIndices() const
    45   { return indices_;};
     45  { return indices_;}
    4646
    4747  virtual const CoinBigIndex * getVectorStarts() const;
     
    193193  /// Return starts of +1s
    194194  inline CoinBigIndex * startPositive() const
    195   { return startPositive_;};
     195  { return startPositive_;}
    196196  /// Return starts of -1s
    197197  inline CoinBigIndex * startNegative() const
    198   { return startNegative_;};
     198  { return startNegative_;}
    199199   //@}
    200200
  • trunk/Clp/src/ClpPresolve.hpp

    r1034 r1055  
    7070  */
    7171  inline void setNonLinearValue(double value)
    72   { nonLinearValue_ = value;};
     72  { nonLinearValue_ = value;}
    7373  inline double nonLinearValue() const
    74     { return nonLinearValue_;};
     74    { return nonLinearValue_;}
    7575  /// Whether we want to do dual part of presolve
    7676  inline bool doDual() const
    77   { return (presolveActions_&1)==0;};
     77  { return (presolveActions_&1)==0;}
    7878  inline void setDoDual(bool doDual)
    79   { if (doDual) presolveActions_  &= ~1; else presolveActions_ |= 1;};
     79  { if (doDual) presolveActions_  &= ~1; else presolveActions_ |= 1;}
    8080  /// Whether we want to do singleton part of presolve
    8181  inline bool doSingleton() const
    82   { return (presolveActions_&2)==0;};
     82  { return (presolveActions_&2)==0;}
    8383  inline void setDoSingleton(bool doSingleton)
    84   { if (doSingleton) presolveActions_  &= ~2; else presolveActions_ |= 2;};
     84  { if (doSingleton) presolveActions_  &= ~2; else presolveActions_ |= 2;}
    8585  /// Whether we want to do doubleton part of presolve
    8686  inline bool doDoubleton() const
    87   { return (presolveActions_&4)==0;};
     87  { return (presolveActions_&4)==0;}
    8888  inline void setDoDoubleton(bool doDoubleton)
    89   { if (doDoubleton) presolveActions_  &= ~4; else presolveActions_ |= 4;};
     89  { if (doDoubleton) presolveActions_  &= ~4; else presolveActions_ |= 4;}
    9090  /// Whether we want to do tripleton part of presolve
    9191  inline bool doTripleton() const
    92   { return (presolveActions_&8)==0;};
     92  { return (presolveActions_&8)==0;}
    9393  inline void setDoTripleton(bool doTripleton)
    94   { if (doTripleton) presolveActions_  &= ~8; else presolveActions_ |= 8;};
     94  { if (doTripleton) presolveActions_  &= ~8; else presolveActions_ |= 8;}
    9595  /// Whether we want to do tighten part of presolve
    9696  inline bool doTighten() const
    97   { return (presolveActions_&16)==0;};
     97  { return (presolveActions_&16)==0;}
    9898  inline void setDoTighten(bool doTighten)
    99   { if (doTighten) presolveActions_  &= ~16; else presolveActions_ |= 16;};
     99  { if (doTighten) presolveActions_  &= ~16; else presolveActions_ |= 16;}
    100100  /// Whether we want to do forcing part of presolve
    101101  inline bool doForcing() const
    102   { return (presolveActions_&32)==0;};
     102  { return (presolveActions_&32)==0;}
    103103  inline void setDoForcing(bool doForcing)
    104   { if (doForcing) presolveActions_  &= ~32; else presolveActions_ |= 32;};
     104  { if (doForcing) presolveActions_  &= ~32; else presolveActions_ |= 32;}
    105105  /// Whether we want to do impliedfree part of presolve
    106106  inline bool doImpliedFree() const
    107   { return (presolveActions_&64)==0;};
     107  { return (presolveActions_&64)==0;}
    108108  inline void setDoImpliedFree(bool doImpliedfree)
    109   { if (doImpliedfree) presolveActions_  &= ~64; else presolveActions_ |= 64;};
     109  { if (doImpliedfree) presolveActions_  &= ~64; else presolveActions_ |= 64;}
    110110  /// Whether we want to do dupcol part of presolve
    111111  inline bool doDupcol() const
    112   { return (presolveActions_&128)==0;};
     112  { return (presolveActions_&128)==0;}
    113113  inline void setDoDupcol(bool doDupcol)
    114   { if (doDupcol) presolveActions_  &= ~128; else presolveActions_ |= 128;};
     114  { if (doDupcol) presolveActions_  &= ~128; else presolveActions_ |= 128;}
    115115  /// Whether we want to do duprow part of presolve
    116116  inline bool doDuprow() const
    117   { return (presolveActions_&256)==0;};
     117  { return (presolveActions_&256)==0;}
    118118  inline void setDoDuprow(bool doDuprow)
    119   { if (doDuprow) presolveActions_  &= ~256; else presolveActions_ |= 256;};
     119  { if (doDuprow) presolveActions_  &= ~256; else presolveActions_ |= 256;}
    120120  /// Whether we want to do singleton column part of presolve
    121121  inline bool doSingletonColumn() const
    122   { return (presolveActions_&512)==0;};
     122  { return (presolveActions_&512)==0;}
    123123  inline void setDoSingletonColumn(bool doSingleton)
    124   { if (doSingleton) presolveActions_  &= ~512; else presolveActions_ |= 512;};
     124  { if (doSingleton) presolveActions_  &= ~512; else presolveActions_ |= 512;}
    125125  /// Set whole group
    126126  inline int presolveActions() const
    127   { return presolveActions_&0xffff;};
     127  { return presolveActions_&0xffff;}
    128128  inline void setPresolveActions(int action)
    129   { presolveActions_  = (presolveActions_&0xffff0000)|(action&0xffff);};
     129  { presolveActions_  = (presolveActions_&0xffff0000)|(action&0xffff);}
    130130  /// Substitution level
    131131  inline void setSubstitution(int value)
    132   { substitution_=value;};
     132  { substitution_=value;}
    133133  /// Asks for statistics
    134134  inline void statistics()
    135   { presolveActions_ |= 0x80000000;};
     135  { presolveActions_ |= 0x80000000;}
    136136
    137137  /**@name postsolve - postsolve the problem.  If the problem
  • trunk/Clp/src/ClpPrimalColumnDantzig.hpp

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

    r754 r1055  
    7272  */
    7373  virtual int pivotRow(double & way)
    74   {way=0;return -2;};
     74  {way=0;return -2;}
    7575  /// Gets rid of all arrays (may be empty)
    7676  virtual void clearArrays();
    7777  /// Returns true if would not find any column
    7878  virtual bool looksOptimal() const
    79   { return looksOptimal_;};
     79  { return looksOptimal_;}
    8080  /// Sets optimality flag (for advanced use)
    8181  virtual void setLooksOptimal(bool flag)
    82   { looksOptimal_ = flag;};
     82  { looksOptimal_ = flag;}
    8383  //@}
    8484 
     
    107107  /// Returns model
    108108  inline ClpSimplex * model()
    109   { return model_;};
     109  { return model_;}
    110110 
    111111  /// Returns type (above 63 is extra information)
    112112  inline int type()
    113   { return type_;};
     113  { return type_;}
    114114
    115115  /** Returns number of extra columns for sprint algorithm - 0 means off.
     
    120120  virtual void switchOffSprint();
    121121  /// Called when maximum pivots changes
    122   virtual void maximumPivotsChanged() {};
     122  virtual void maximumPivotsChanged() {}
    123123 
    124124  //@}
  • trunk/Clp/src/ClpPrimalColumnSteepest.hpp

    r754 r1055  
    122122  /// Mode
    123123  inline int mode() const
    124     { return mode_;};
     124    { return mode_;}
    125125  /** Returns number of extra columns for sprint algorithm - 0 means off.
    126126      Also number of iterations before recompute
     
    182182  /// Set/ get persistence
    183183  inline void setPersistence(Persistence life)
    184   { persistence_ = life;};
     184  { persistence_ = life;}
    185185  inline Persistence persistence() const
    186   { return persistence_ ;};
     186  { return persistence_ ;}
    187187 
    188188  //@}
  • trunk/Clp/src/ClpPrimalQuadraticDantzig.hpp

    r754 r1055  
    3535  /// Just sets model
    3636  virtual void saveWeights(ClpSimplex * model,int mode)
    37   {model_=model;};
     37  {model_=model;}
    3838  //@}
    3939 
  • trunk/Clp/src/ClpQuadraticObjective.hpp

    r1034 r1055  
    115115  /// Length of linear objective which could be bigger
    116116  inline int numberExtendedColumns() const
    117   {return numberExtendedColumns_;};
     117  {return numberExtendedColumns_;}
    118118  /// Number of columns in quadratic objective
    119119  inline int numberColumns() const
    120   {return numberColumns_;};
     120  {return numberColumns_;}
    121121  /// If a full or half matrix
    122122  inline bool fullMatrix() const
    123   { return fullMatrix_;};
     123  { return fullMatrix_;}
    124124  //@}
    125125
  • trunk/Clp/src/ClpSimplex.hpp

    r1034 r1055  
    132132  /// See if we have auxiliary model
    133133  inline bool usingAuxiliaryModel() const
    134   { return auxiliaryModel_!=NULL;};
     134  { return auxiliaryModel_!=NULL;}
    135135  /// Assignment operator. This copies the data
    136136    ClpSimplex & operator=(const ClpSimplex & rhs);
     
    449449  /// If problem is primal feasible
    450450  inline bool primalFeasible() const
    451          { return (numberPrimalInfeasibilities_==0);};
     451         { return (numberPrimalInfeasibilities_==0);}
    452452  /// If problem is dual feasible
    453453  inline bool dualFeasible() const
    454          { return (numberDualInfeasibilities_==0);};
     454         { return (numberDualInfeasibilities_==0);}
    455455  /// factorization
    456456  inline ClpFactorization * factorization() const
    457           { return factorization_;};
     457          { return factorization_;}
    458458  /// Sparsity on or off
    459459  bool sparseFactorization() const;
     
    464464  /// Dual bound
    465465  inline double dualBound() const
    466           { return dualBound_;};
     466          { return dualBound_;}
    467467  void setDualBound(double value);
    468468  /// Infeasibility cost
    469469  inline double infeasibilityCost() const
    470           { return infeasibilityCost_;};
     470          { return infeasibilityCost_;}
    471471  void setInfeasibilityCost(double value);
    472472  /** Amount of print out:
     
    487487  */
    488488  inline int perturbation() const
    489     { return perturbation_;};
     489    { return perturbation_;}
    490490  void setPerturbation(int value);
    491491  /// Current (or last) algorithm
    492492  inline int algorithm() const
    493   {return algorithm_; } ;
     493  {return algorithm_; }
    494494  /// Set algorithm
    495495  inline void setAlgorithm(int value)
    496   {algorithm_=value; } ;
     496  {algorithm_=value; }
    497497  /// Sum of dual infeasibilities
    498498  inline double sumDualInfeasibilities() const
    499           { return sumDualInfeasibilities_;} ;
     499          { return sumDualInfeasibilities_;}
    500500  inline void setSumDualInfeasibilities(double value)
    501           { sumDualInfeasibilities_=value;} ;
     501          { sumDualInfeasibilities_=value;}
    502502  /// Sum of relaxed dual infeasibilities
    503503  inline double sumOfRelaxedDualInfeasibilities() const
    504           { return sumOfRelaxedDualInfeasibilities_;} ;
     504          { return sumOfRelaxedDualInfeasibilities_;}
    505505  inline void setSumOfRelaxedDualInfeasibilities(double value)
    506           { sumOfRelaxedDualInfeasibilities_=value;} ;
     506          { sumOfRelaxedDualInfeasibilities_=value;}
    507507  /// Number of dual infeasibilities
    508508  inline int numberDualInfeasibilities() const
    509           { return numberDualInfeasibilities_;} ;
     509          { return numberDualInfeasibilities_;}
    510510  inline void setNumberDualInfeasibilities(int value)
    511           { numberDualInfeasibilities_=value;} ;
     511          { numberDualInfeasibilities_=value;}
    512512  /// Number of dual infeasibilities (without free)
    513513  inline int numberDualInfeasibilitiesWithoutFree() const
    514           { return numberDualInfeasibilitiesWithoutFree_;} ;
     514          { return numberDualInfeasibilitiesWithoutFree_;}
    515515  /// Sum of primal infeasibilities
    516516  inline double sumPrimalInfeasibilities() const
    517           { return sumPrimalInfeasibilities_;} ;
     517          { return sumPrimalInfeasibilities_;}
    518518  inline void setSumPrimalInfeasibilities(double value)
    519           { sumPrimalInfeasibilities_=value;} ;
     519          { sumPrimalInfeasibilities_=value;}
    520520  /// Sum of relaxed primal infeasibilities
    521521  inline double sumOfRelaxedPrimalInfeasibilities() const
    522           { return sumOfRelaxedPrimalInfeasibilities_;} ;
     522          { return sumOfRelaxedPrimalInfeasibilities_;}
    523523  inline void setSumOfRelaxedPrimalInfeasibilities(double value)
    524           { sumOfRelaxedPrimalInfeasibilities_=value;} ;
     524          { sumOfRelaxedPrimalInfeasibilities_=value;}
    525525  /// Number of primal infeasibilities
    526526  inline int numberPrimalInfeasibilities() const
    527           { return numberPrimalInfeasibilities_;} ;
     527          { return numberPrimalInfeasibilities_;}
    528528  inline void setNumberPrimalInfeasibilities(int value)
    529           { numberPrimalInfeasibilities_=value;} ;
     529          { numberPrimalInfeasibilities_=value;}
    530530  /** Save model to file, returns 0 if success.  This is designed for
    531531      use outside algorithms so does not save iterating arrays etc.
     
    552552  /// Useful row length arrays (0,1,2,3,4,5)
    553553  inline CoinIndexedVector * rowArray(int index) const
    554   { return rowArray_[index];};
     554  { return rowArray_[index];}
    555555  /// Useful column length arrays (0,1,2,3,4,5)
    556556  inline CoinIndexedVector * columnArray(int index) const
    557   { return columnArray_[index];};
     557  { return columnArray_[index];}
    558558  //@}
    559559
     
    665665  /// Initial value for alpha accuracy calculation (-1.0 off)
    666666  inline double alphaAccuracy() const
    667           { return alphaAccuracy_;} ;
     667          { return alphaAccuracy_;}
    668668  inline void setAlphaAccuracy(double value)
    669           { alphaAccuracy_ = value;} ;
     669          { alphaAccuracy_ = value;}
    670670public:
    671671  /// Disaster handler
    672672  inline void setDisasterHandler(ClpDisasterHandler * handler)
    673   { disasterArea_= handler;};
     673  { disasterArea_= handler;}
    674674  /// Large bound value (for complementarity etc)
    675675  inline double largeValue() const
    676           { return largeValue_;} ;
     676          { return largeValue_;}
    677677  void setLargeValue( double value) ;
    678678  /// Largest error on Ax-b
    679679  inline double largestPrimalError() const
    680           { return largestPrimalError_;} ;
     680          { return largestPrimalError_;}
    681681  /// Largest error on basic duals
    682682  inline double largestDualError() const
    683           { return largestDualError_;} ;
     683          { return largestDualError_;}
    684684  /// Largest error on Ax-b
    685685  inline void setLargestPrimalError(double value)
    686           { largestPrimalError_=value;} ;
     686          { largestPrimalError_=value;}
    687687  /// Largest error on basic duals
    688688  inline void setLargestDualError(double value)
    689           { largestDualError_=value;} ;
     689          { largestDualError_=value;}
    690690  /// Basic variables pivoting on which rows
    691691  inline int * pivotVariable() const
    692           { return pivotVariable_;};
     692          { return pivotVariable_;}
    693693  /// If automatic scaling on
    694694  inline bool automaticScaling() const
    695   { return automaticScale_!=0;};
     695  { return automaticScale_!=0;}
    696696  inline void setAutomaticScaling(bool onOff)
    697   { automaticScale_ = onOff ? 1: 0;};
     697  { automaticScale_ = onOff ? 1: 0;}
    698698  /// Current dual tolerance
    699699  inline double currentDualTolerance() const
    700           { return dualTolerance_;} ;
     700          { return dualTolerance_;}
    701701  inline void setCurrentDualTolerance(double value)
    702           { dualTolerance_ = value;} ;
     702          { dualTolerance_ = value;}
    703703  /// Current primal tolerance
    704704  inline double currentPrimalTolerance() const
    705           { return primalTolerance_;} ;
     705          { return primalTolerance_;}
    706706  inline void setCurrentPrimalTolerance(double value)
    707           { primalTolerance_ = value;} ;
     707          { primalTolerance_ = value;}
    708708  /// How many iterative refinements to do
    709709  inline int numberRefinements() const
    710           { return numberRefinements_;} ;
     710          { return numberRefinements_;}
    711711  void setNumberRefinements( int value) ;
    712712  /// Alpha (pivot element) for use by classes e.g. steepestedge
    713   inline double alpha() const { return alpha_;};
    714   inline void setAlpha(double value) { alpha_ = value;};
     713  inline double alpha() const { return alpha_;}
     714  inline void setAlpha(double value) { alpha_ = value;}
    715715  /// Reduced cost of last incoming for use by classes e.g. steepestedge
    716   inline double dualIn() const { return dualIn_;};
     716  inline double dualIn() const { return dualIn_;}
    717717  /// Pivot Row for use by classes e.g. steepestedge
    718   inline int pivotRow() const{ return pivotRow_;};
    719   inline void setPivotRow(int value) { pivotRow_=value;};
     718  inline int pivotRow() const{ return pivotRow_;}
     719  inline void setPivotRow(int value) { pivotRow_=value;}
    720720  /// value of incoming variable (in Dual)
    721721  double valueIncomingDual() const;
     
    761761      once was.  These just map into single arrays */
    762762  inline double * solutionRegion(int section) const
    763   { if (!section) return rowActivityWork_; else return columnActivityWork_;};
     763  { if (!section) return rowActivityWork_; else return columnActivityWork_;}
    764764  inline double * djRegion(int section) const
    765   { if (!section) return rowReducedCost_; else return reducedCostWork_;};
     765  { if (!section) return rowReducedCost_; else return reducedCostWork_;}
    766766  inline double * lowerRegion(int section) const
    767   { if (!section) return rowLowerWork_; else return columnLowerWork_;};
     767  { if (!section) return rowLowerWork_; else return columnLowerWork_;}
    768768  inline double * upperRegion(int section) const
    769   { if (!section) return rowUpperWork_; else return columnUpperWork_;};
     769  { if (!section) return rowUpperWork_; else return columnUpperWork_;}
    770770  inline double * costRegion(int section) const
    771   { if (!section) return rowObjectiveWork_; else return objectiveWork_;};
     771  { if (!section) return rowObjectiveWork_; else return objectiveWork_;}
    772772  /// Return region as single array
    773773  inline double * solutionRegion() const
    774   { return solution_;};
     774  { return solution_;}
    775775  inline double * djRegion() const
    776   { return dj_;};
     776  { return dj_;}
    777777  inline double * lowerRegion() const
    778   { return lower_;};
     778  { return lower_;}
    779779  inline double * upperRegion() const
    780   { return upper_;};
     780  { return upper_;}
    781781  inline double * costRegion() const
    782   { return cost_;};
     782  { return cost_;}
    783783  inline Status getStatus(int sequence) const
    784   {return static_cast<Status> (status_[sequence]&7);};
     784  {return static_cast<Status> (status_[sequence]&7);}
    785785  inline void setStatus(int sequence, Status status)
    786786  {
     
    788788    st_byte &= ~7;
    789789    st_byte |= status;
    790   };
     790  }
    791791  /** Normally the first factorization does sparse coding because
    792792      the factorization could be singular.  This allows initial dense
     
    797797  /** Return sequence In or Out */
    798798  inline int sequenceIn() const
    799   {return sequenceIn_;};
     799  {return sequenceIn_;}
    800800  inline int sequenceOut() const
    801   {return sequenceOut_;};
     801  {return sequenceOut_;}
    802802  /** Set sequenceIn or Out */
    803803  inline void  setSequenceIn(int sequence)
    804   { sequenceIn_=sequence;};
     804  { sequenceIn_=sequence;}
    805805  inline void  setSequenceOut(int sequence)
    806   { sequenceOut_=sequence;};
     806  { sequenceOut_=sequence;}
    807807  /** Return direction In or Out */
    808808  inline int directionIn() const
    809   {return directionIn_;};
     809  {return directionIn_;}
    810810  inline int directionOut() const
    811   {return directionOut_;};
     811  {return directionOut_;}
    812812  /** Set directionIn or Out */
    813813  inline void  setDirectionIn(int direction)
    814   { directionIn_=direction;};
     814  { directionIn_=direction;}
    815815  inline void  setDirectionOut(int direction)
    816   { directionOut_=direction;};
     816  { directionOut_=direction;}
    817817  /// Value of Out variable
    818818  inline double valueOut() const
    819   { return valueOut_;};
     819  { return valueOut_;}
    820820  /// Returns 1 if sequence indicates column
    821821  inline int isColumn(int sequence) const
    822   { return sequence<numberColumns_ ? 1 : 0;};
     822  { return sequence<numberColumns_ ? 1 : 0;}
    823823  /// Returns sequence number within section
    824824  inline int sequenceWithin(int sequence) const
    825   { return sequence<numberColumns_ ? sequence : sequence-numberColumns_;};
     825  { return sequence<numberColumns_ ? sequence : sequence-numberColumns_;}
    826826  /// Return row or column values
    827827  inline double solution(int sequence)
    828   { return solution_[sequence];};
     828  { return solution_[sequence];}
    829829  /// Return address of row or column values
    830830  inline double & solutionAddress(int sequence)
    831   { return solution_[sequence];};
     831  { return solution_[sequence];}
    832832  inline double reducedCost(int sequence)
    833    { return dj_[sequence];};
     833   { return dj_[sequence];}
    834834  inline double & reducedCostAddress(int sequence)
    835    { return dj_[sequence];};
     835   { return dj_[sequence];}
    836836  inline double lower(int sequence)
    837   { return lower_[sequence];};
     837  { return lower_[sequence];}
    838838  /// Return address of row or column lower bound
    839839  inline double & lowerAddress(int sequence)
    840   { return lower_[sequence];};
     840  { return lower_[sequence];}
    841841  inline double upper(int sequence)
    842   { return upper_[sequence];};
     842  { return upper_[sequence];}
    843843  /// Return address of row or column upper bound
    844844  inline double & upperAddress(int sequence)
    845   { return upper_[sequence];};
     845  { return upper_[sequence];}
    846846  inline double cost(int sequence)
    847   { return cost_[sequence];};
     847  { return cost_[sequence];}
    848848  /// Return address of row or column cost
    849849  inline double & costAddress(int sequence)
    850   { return cost_[sequence];};
     850  { return cost_[sequence];}
    851851  /// Return original lower bound
    852852  inline double originalLower(int iSequence) const
    853853  { if (iSequence<numberColumns_) return columnLower_[iSequence]; else
    854     return rowLower_[iSequence-numberColumns_];};
     854    return rowLower_[iSequence-numberColumns_];}
    855855  /// Return original lower bound
    856856  inline double originalUpper(int iSequence) const
    857857  { if (iSequence<numberColumns_) return columnUpper_[iSequence]; else
    858     return rowUpper_[iSequence-numberColumns_];};
     858    return rowUpper_[iSequence-numberColumns_];}
    859859  /// Theta (pivot change)
    860860  inline double theta() const
    861   { return theta_;};
     861  { return theta_;}
    862862  /// Return pointer to details of costs
    863863  inline ClpNonLinearCost * nonLinearCost() const
    864   { return nonLinearCost_;};
     864  { return nonLinearCost_;}
    865865  //@}
    866866  /**@name status methods */
     
    871871    st_byte &= ~24;
    872872    st_byte |= fakeBound<<3;
    873   };
     873  }
    874874  inline FakeBound getFakeBound(int sequence) const
    875   {return static_cast<FakeBound> ((status_[sequence]>>3)&3);};
     875  {return static_cast<FakeBound> ((status_[sequence]>>3)&3);}
    876876  inline void setRowStatus(int sequence, Status status)
    877877  {
     
    879879    st_byte &= ~7;
    880880    st_byte |= status;
    881   };
     881  }
    882882  inline Status getRowStatus(int sequence) const
    883   {return static_cast<Status> (status_[sequence+numberColumns_]&7);};
     883  {return static_cast<Status> (status_[sequence+numberColumns_]&7);}
    884884  inline void setColumnStatus(int sequence, Status status)
    885885  {
     
    887887    st_byte &= ~7;
    888888    st_byte |= status;
    889   };
     889  }
    890890  inline Status getColumnStatus(int sequence) const
    891   {return static_cast<Status> (status_[sequence]&7);};
     891  {return static_cast<Status> (status_[sequence]&7);}
    892892  inline void setPivoted( int sequence)
    893   { status_[sequence] |= 32;};
     893  { status_[sequence] |= 32;}
    894894  inline void clearPivoted( int sequence)
    895   { status_[sequence] &= ~32; };
     895  { status_[sequence] &= ~32; }
    896896  inline bool pivoted(int sequence) const
    897   {return (((status_[sequence]>>5)&1)!=0);};
     897  {return (((status_[sequence]>>5)&1)!=0);}
    898898  /// To flag a variable (not inline to allow for column generation)
    899899  void setFlagged( int sequence);
     
    901901  {
    902902    status_[sequence] &= ~64;
    903   };
     903  }
    904904  inline bool flagged(int sequence) const
    905   {return ((status_[sequence]&64)!=0);};
     905  {return ((status_[sequence]&64)!=0);}
    906906  /// To say row active in primal pivot row choice
    907907  inline void setActive( int iRow)
    908908  {
    909909    status_[iRow] |= 128;
    910   };
     910  }
    911911  inline void clearActive( int iRow)
    912912  {
    913913    status_[iRow] &= ~128;
    914   };
     914  }
    915915  inline bool active(int iRow) const
    916   {return ((status_[iRow]&128)!=0);};
     916  {return ((status_[iRow]&128)!=0);}
    917917  /** Set up status array (can be used by OsiClp).
    918918      Also can be used to set up all slack basis */
     
    924924  /// So we know when to be cautious
    925925  inline int lastBadIteration() const
    926   {return lastBadIteration_;};
     926  {return lastBadIteration_;}
    927927  /// Progress flag - at present 0 bit says artificials out
    928928  inline int progressFlag() const
    929   {return progressFlag_;};
     929  {return progressFlag_;}
    930930  /// Force re-factorization early
    931931  inline void forceFactorization(int value)
    932   { forceFactorization_ = value;};
     932  { forceFactorization_ = value;}
    933933  /// Raw objective value (so always minimize in primal)
    934934  inline double rawObjectiveValue() const
    935   { return objectiveValue_;};
     935  { return objectiveValue_;}
    936936   /// Compute objective value from solution and put in objectiveValue_
    937937  void computeObjectiveValue(bool useWorkingSolution=false);
     
    942942  */
    943943  inline int numberExtraRows() const
    944   { return numberExtraRows_;};
     944  { return numberExtraRows_;}
    945945  /** Maximum number of basic variables - can be more than number of rows if GUB
    946946  */
    947947  inline int maximumBasic() const
    948   { return maximumBasic_;};
     948  { return maximumBasic_;}
    949949  /// Create C++ lines to get to current state
    950950  void generateCpp( FILE * fp,bool defaultFactor=false);
     
    985985       /** Set an objective function coefficient */
    986986       inline void setObjCoeff( int elementIndex, double elementValue )
    987        { setObjectiveCoefficient( elementIndex, elementValue);};
     987       { setObjectiveCoefficient( elementIndex, elementValue);}
    988988
    989989      /** Set a single column lower bound<br>
     
    10141014          Use -DBL_MAX for -infinity. */
    10151015       inline void setColLower( int elementIndex, double elementValue )
    1016        { setColumnLower(elementIndex, elementValue);};
     1016       { setColumnLower(elementIndex, elementValue);}
    10171017      /** Set a single column upper bound<br>
    10181018          Use DBL_MAX for infinity. */
    10191019       inline void setColUpper( int elementIndex, double elementValue )
    1020        { setColumnUpper(elementIndex, elementValue);};
     1020       { setColumnUpper(elementIndex, elementValue);}
    10211021
    10221022      /** Set a single column lower and upper bound */
    10231023      inline void setColBounds( int elementIndex,
    10241024        double lower, double upper )
    1025        { setColumnBounds(elementIndex, lower, upper);};
     1025       { setColumnBounds(elementIndex, lower, upper);}
    10261026
    10271027      /** Set the bounds on a number of columns simultaneously<br>
     
    10341034                                   const int* indexLast,
    10351035                                   const double* boundList)
    1036       { setColumnSetBounds(indexFirst, indexLast, boundList);};
     1036      { setColumnSetBounds(indexFirst, indexLast, boundList);}
    10371037     
    10381038      /** Set a single row lower bound<br>
     
    13351335  /// Odd state
    13361336  inline void newOddState()
    1337   { oddState_= - oddState_-1;};
     1337  { oddState_= - oddState_-1;}
    13381338  inline void endOddState()
    1339   { oddState_=abs(oddState_);};
     1339  { oddState_=abs(oddState_);}
    13401340  inline void clearOddState()
    1341   { oddState_=0;};
     1341  { oddState_=0;}
    13421342  inline int oddState() const
    1343   { return oddState_;};
     1343  { return oddState_;}
    13441344  /// number of bad times
    13451345  inline int badTimes() const
    1346   { return numberBadTimes_;};
     1346  { return numberBadTimes_;}
    13471347  inline void clearBadTimes()
    1348   { numberBadTimes_=0;};
     1348  { numberBadTimes_=0;}
    13491349
    13501350  //@}
  • trunk/Clp/src/ClpSolve.hpp

    r1034 r1055  
    117117  void setInfeasibleReturn(bool trueFalse);
    118118  inline bool infeasibleReturn() const
    119   { return independentOptions_[0]!=0;};
     119  { return independentOptions_[0]!=0;}
    120120  /// Whether we want to do dual part of presolve
    121121  inline bool doDual() const
    122   { return (independentOptions_[1]&1)==0;};
     122  { return (independentOptions_[1]&1)==0;}
    123123  inline void setDoDual(bool doDual)
    124   { if (doDual) independentOptions_[1]  &= ~1; else independentOptions_[1] |= 1;};
     124  { if (doDual) independentOptions_[1]  &= ~1; else independentOptions_[1] |= 1;}
    125125  /// Whether we want to do singleton part of presolve
    126126  inline bool doSingleton() const
    127   { return (independentOptions_[1]&2)==0;};
     127  { return (independentOptions_[1]&2)==0;}
    128128  inline void setDoSingleton(bool doSingleton)
    129   { if (doSingleton) independentOptions_[1]  &= ~2; else independentOptions_[1] |= 2;};
     129  { if (doSingleton) independentOptions_[1]  &= ~2; else independentOptions_[1] |= 2;}
    130130  /// Whether we want to do doubleton part of presolve
    131131  inline bool doDoubleton() const
    132   { return (independentOptions_[1]&4)==0;};
     132  { return (independentOptions_[1]&4)==0;}
    133133  inline void setDoDoubleton(bool doDoubleton)
    134   { if (doDoubleton) independentOptions_[1]  &= ~4; else independentOptions_[1] |= 4;};
     134  { if (doDoubleton) independentOptions_[1]  &= ~4; else independentOptions_[1] |= 4;}
    135135  /// Whether we want to do tripleton part of presolve
    136136  inline bool doTripleton() const
    137   { return (independentOptions_[1]&8)==0;};
     137  { return (independentOptions_[1]&8)==0;}
    138138  inline void setDoTripleton(bool doTripleton)
    139   { if (doTripleton) independentOptions_[1]  &= ~8; else independentOptions_[1] |= 8;};
     139  { if (doTripleton) independentOptions_[1]  &= ~8; else independentOptions_[1] |= 8;}
    140140  /// Whether we want to do tighten part of presolve
    141141  inline bool doTighten() const
    142   { return (independentOptions_[1]&16)==0;};
     142  { return (independentOptions_[1]&16)==0;}
    143143  inline void setDoTighten(bool doTighten)
    144   { if (doTighten) independentOptions_[1]  &= ~16; else independentOptions_[1] |= 16;};
     144  { if (doTighten) independentOptions_[1]  &= ~16; else independentOptions_[1] |= 16;}
    145145  /// Whether we want to do forcing part of presolve
    146146  inline bool doForcing() const
    147   { return (independentOptions_[1]&32)==0;};
     147  { return (independentOptions_[1]&32)==0;}
    148148  inline void setDoForcing(bool doForcing)
    149   { if (doForcing) independentOptions_[1]  &= ~32; else independentOptions_[1] |= 32;};
     149  { if (doForcing) independentOptions_[1]  &= ~32; else independentOptions_[1] |= 32;}
    150150  /// Whether we want to do impliedfree part of presolve
    151151  inline bool doImpliedFree() const
    152   { return (independentOptions_[1]&64)==0;};
     152  { return (independentOptions_[1]&64)==0;}
    153153  inline void setDoImpliedFree(bool doImpliedfree)
    154   { if (doImpliedfree) independentOptions_[1]  &= ~64; else independentOptions_[1] |= 64;};
     154  { if (doImpliedfree) independentOptions_[1]  &= ~64; else independentOptions_[1] |= 64;}
    155155  /// Whether we want to do dupcol part of presolve
    156156  inline bool doDupcol() const
    157   { return (independentOptions_[1]&128)==0;};
     157  { return (independentOptions_[1]&128)==0;}
    158158  inline void setDoDupcol(bool doDupcol)
    159   { if (doDupcol) independentOptions_[1]  &= ~128; else independentOptions_[1] |= 128;};
     159  { if (doDupcol) independentOptions_[1]  &= ~128; else independentOptions_[1] |= 128;}
    160160  /// Whether we want to do duprow part of presolve
    161161  inline bool doDuprow() const
    162   { return (independentOptions_[1]&256)==0;};
     162  { return (independentOptions_[1]&256)==0;}
    163163  inline void setDoDuprow(bool doDuprow)
    164   { if (doDuprow) independentOptions_[1]  &= ~256; else independentOptions_[1] |= 256;};
     164  { if (doDuprow) independentOptions_[1]  &= ~256; else independentOptions_[1] |= 256;}
    165165  /// Whether we want to do singleton column part of presolve
    166166  inline bool doSingletonColumn() const
    167   { return (independentOptions_[1]&512)==0;};
     167  { return (independentOptions_[1]&512)==0;}
    168168  inline void setDoSingletonColumn(bool doSingleton)
    169   { if (doSingleton) independentOptions_[1]  &= ~512; else independentOptions_[1] |= 512;};
     169  { if (doSingleton) independentOptions_[1]  &= ~512; else independentOptions_[1] |= 512;}
    170170  /// Set whole group
    171171  inline int presolveActions() const
    172   { return independentOptions_[1]&0xffff;};
     172  { return independentOptions_[1]&0xffff;}
    173173  inline void setPresolveActions(int action)
    174   { independentOptions_[1]  = (independentOptions_[1]&0xffff0000)|(action&0xffff);};
     174  { independentOptions_[1]  = (independentOptions_[1]&0xffff0000)|(action&0xffff);}
    175175  /// Largest column for substitution (normally 3)
    176176  inline int substitution() const
    177   { return independentOptions_[2];};
     177  { return independentOptions_[2];}
    178178  inline void setSubstitution(int value)
    179   { independentOptions_[2] = value;};
     179  { independentOptions_[2] = value;}
    180180  //@}
    181181
  • trunk/Clp/src/Idiot.hpp

    r1034 r1055  
    9191      default 1.0e-4 */
    9292  inline double getStartingWeight() const
    93   { return mu_;};
     93  { return mu_;}
    9494  inline void setStartingWeight(double value)
    95   { mu_ = value;};
     95  { mu_ = value;}
    9696  /** Weight factor - weight multiplied by this when changes,
    9797      default 0.333 */
    9898  inline double getWeightFactor() const
    99   { return muFactor_;};
     99  { return muFactor_;}
    100100  inline void setWeightFactor(double value)
    101   { muFactor_ = value;};
     101  { muFactor_ = value;}
    102102  /** Feasibility tolerance - problem essentially feasible if
    103103      individual infeasibilities less than this.
    104104      default 0.1 */
    105105  inline double getFeasibilityTolerance() const
    106   { return smallInfeas_;};
     106  { return smallInfeas_;}
    107107  inline void setFeasibilityTolerance(double value)
    108   { smallInfeas_ = value;};
     108  { smallInfeas_ = value;}
    109109  /** Reasonably feasible.  Dubious method concentrates more on
    110110      objective when sum of infeasibilities less than this.
    111111      Very dubious default value of (Number of rows)/20 */
    112112  inline double getReasonablyFeasible() const
    113   { return reasonableInfeas_;};
     113  { return reasonableInfeas_;}
    114114  inline void setReasonablyFeasible(double value)
    115   { reasonableInfeas_ = value;};
     115  { reasonableInfeas_ = value;}
    116116  /** Exit infeasibility - exit if sum of infeasibilities less than this.
    117117      Default -1.0 (i.e. switched off) */
    118118  inline double getExitInfeasibility() const
    119   { return exitFeasibility_;};
     119  { return exitFeasibility_;}
    120120  inline void setExitInfeasibility(double value)
    121   { exitFeasibility_ = value;};
     121  { exitFeasibility_ = value;}
    122122  /** Major iterations.  stop after this number.
    123123      Default 30.  Use 2-5 for "crash" 50-100 for serious crunching */
    124124  inline int getMajorIterations() const
    125   { return majorIterations_;};
     125  { return majorIterations_;}
    126126  inline void setMajorIterations(int value)
    127   { majorIterations_ = value;};
     127  { majorIterations_ = value;}
    128128  /** Minor iterations.  Do this number of tiny steps before
    129129      deciding whether to change weights etc.
     
    133133      iterations) */
    134134  inline int getMinorIterations() const
    135   { return maxIts2_;};
     135  { return maxIts2_;}
    136136  inline void setMinorIterations(int value)
    137   { maxIts2_ = value;};
     137  { maxIts2_ = value;}
    138138  // minor iterations for first time
    139139  inline int getMinorIterations0() const
    140   { return maxIts_;};
     140  { return maxIts_;}
    141141  inline void setMinorIterations0(int value)
    142   { maxIts_ = value;};
     142  { maxIts_ = value;}
    143143  /** Reduce weight after this many major iterations.  It may
    144144      get reduced before this but this is a maximum.
    145145      Default 3.  3-10 plausible. */
    146146  inline int getReduceIterations() const
    147   { return maxBigIts_;};
     147  { return maxBigIts_;}
    148148  inline void setReduceIterations(int value)
    149   { maxBigIts_ = value;};
     149  { maxBigIts_ = value;}
    150150  /// Amount of information - default of 1 should be okay
    151151  inline int getLogLevel() const
    152   { return logLevel_;};
     152  { return logLevel_;}
    153153  inline void setLogLevel(int value)
    154   { logLevel_ = value;};
     154  { logLevel_ = value;}
    155155  /// How lightweight - 0 not, 1 yes, 2 very lightweight
    156156  inline int getLightweight() const
    157   { return lightWeight_;};
     157  { return lightWeight_;}
    158158  inline void setLightweight(int value)
    159   { lightWeight_ = value;};
     159  { lightWeight_ = value;}
    160160  /// strategy
    161161  inline int getStrategy() const
    162   { return strategy_;};
     162  { return strategy_;}
    163163  inline void setStrategy(int value)
    164   { strategy_ = value;};
     164  { strategy_ = value;}
    165165  /// Fine tuning - okay if feasibility drop this factor
    166166  inline double getDropEnoughFeasibility() const
    167   { return dropEnoughFeasibility_;};
     167  { return dropEnoughFeasibility_;}
    168168  inline void setDropEnoughFeasibility(double value)
    169   { dropEnoughFeasibility_=value;};
     169  { dropEnoughFeasibility_=value;}
    170170  /// Fine tuning - okay if weighted obj drop this factor
    171171  inline double getDropEnoughWeighted() const
    172   { return dropEnoughWeighted_;};
     172  { return dropEnoughWeighted_;}
    173173  inline void setDropEnoughWeighted(double value)
    174   { dropEnoughWeighted_=value;};
     174  { dropEnoughWeighted_=value;}
    175175  //@}
    176176
Note: See TracChangeset for help on using the changeset viewer.