Ignore:
Timestamp:
Jan 3, 2019 2:03:23 PM (19 months ago)
Author:
unxusr
Message:

.clang-format with proposal for formatting code

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcGenOsiParam.hpp

    r1899 r2464  
    3232
    3333public:
    34 
    35     /*! \name Subtypes */
    36 //@{
    37 
    38     /*! \enum CbcOsiParamCode
     34  /*! \name Subtypes */
     35  //@{
     36
     37  /*! \enum CbcOsiParamCode
    3938        \brief Enumeration for parameters that control an OsiSolverInterface
    4039           object
     
    4443      convenient separation of parameter groups.
    4544    */
    46     typedef enum { CBCOSI_FIRSTPARAM = CbcCbcParam::CBCCBC_LASTPARAM + 1,
    47 
    48                    ALGORITHM, ALLSLACK, AUTOSCALE, BARRIER, BARRIERSCALE,
    49                    BASISIN, BASISOUT, BIASLU, CHOLESKY, CRASH, CROSSOVER,
    50                    DUALBOUND, DUALPIVOT, DUALSIMPLEX, DUALTOLERANCE, FAKEBOUND,
    51                    GAMMA, IDIOT, KEEPNAMES, KKT, MAXITERATION, MAXHOTITS, NETLIB_BARRIER,
    52                    NETLIB_DUAL, NETLIB_PRIMAL, NETWORK, OBJSCALE, PERTURBATION,
    53                    PERTVALUE, PFI, PLUSMINUS, PRESOLVE, PRESOLVEOPTIONS, PRESOLVEPASS,
    54                    PRIMALPIVOT, PRIMALSIMPLEX, PRIMALTOLERANCE, REALLY_SCALE,
    55                    RESTORE, REVERSE, RHSSCALE, SAVE, SCALING, SLPVALUE, SOLVERLOGLEVEL,
    56                    SPARSEFACTOR, SPECIALOPTIONS, SPRINT, TIGHTEN,
    57 
    58                    CBCOSI_LASTPARAM
    59 
    60                  } CbcOsiParamCode ;
    61 
    62 //@}
    63 
    64     /*! \name Constructors and Destructors
     45  typedef enum { CBCOSI_FIRSTPARAM = CbcCbcParam::CBCCBC_LASTPARAM + 1,
     46
     47    ALGORITHM,
     48    ALLSLACK,
     49    AUTOSCALE,
     50    BARRIER,
     51    BARRIERSCALE,
     52    BASISIN,
     53    BASISOUT,
     54    BIASLU,
     55    CHOLESKY,
     56    CRASH,
     57    CROSSOVER,
     58    DUALBOUND,
     59    DUALPIVOT,
     60    DUALSIMPLEX,
     61    DUALTOLERANCE,
     62    FAKEBOUND,
     63    GAMMA,
     64    IDIOT,
     65    KEEPNAMES,
     66    KKT,
     67    MAXITERATION,
     68    MAXHOTITS,
     69    NETLIB_BARRIER,
     70    NETLIB_DUAL,
     71    NETLIB_PRIMAL,
     72    NETWORK,
     73    OBJSCALE,
     74    PERTURBATION,
     75    PERTVALUE,
     76    PFI,
     77    PLUSMINUS,
     78    PRESOLVE,
     79    PRESOLVEOPTIONS,
     80    PRESOLVEPASS,
     81    PRIMALPIVOT,
     82    PRIMALSIMPLEX,
     83    PRIMALTOLERANCE,
     84    REALLY_SCALE,
     85    RESTORE,
     86    REVERSE,
     87    RHSSCALE,
     88    SAVE,
     89    SCALING,
     90    SLPVALUE,
     91    SOLVERLOGLEVEL,
     92    SPARSEFACTOR,
     93    SPECIALOPTIONS,
     94    SPRINT,
     95    TIGHTEN,
     96
     97    CBCOSI_LASTPARAM
     98
     99  } CbcOsiParamCode;
     100
     101  //@}
     102
     103  /*! \name Constructors and Destructors
    65104
    66105      Be careful how you specify parameters for the constructors! There's great
    67106      potential for confusion.
    68107    */
    69 //@{
    70     /*! \brief Default constructor */
    71 
    72     CbcOsiParam() ;
    73 
    74     /*! \brief Constructor for a parameter with a double value
     108  //@{
     109  /*! \brief Default constructor */
     110
     111  CbcOsiParam();
     112
     113  /*! \brief Constructor for a parameter with a double value
    75114
    76115      The default value is 0.0. Be careful to clearly indicate that \p lower and
     
    78117      constructor for an integer parameter.
    79118    */
    80     CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
    81                 double lower, double upper, double dflt = 0.0,
    82                 bool display = true) ;
    83 
    84     /*! \brief Constructor for a parameter with an integer value
     119  CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
     120    double lower, double upper, double dflt = 0.0,
     121    bool display = true);
     122
     123  /*! \brief Constructor for a parameter with an integer value
    85124
    86125      The default value is 0.
    87126    */
    88     CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
    89                 int lower, int upper, int dflt = 0,
    90                 bool display = true) ;
    91 
    92     /*! \brief Constructor for a parameter with keyword values
     127  CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
     128    int lower, int upper, int dflt = 0,
     129    bool display = true);
     130
     131  /*! \brief Constructor for a parameter with keyword values
    93132
    94133      The string supplied as \p firstValue becomes the first keyword.
     
    99138      constructors.
    100139    */
    101     CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
    102                 std::string firstValue, int dflt, bool display = true) ;
    103 
    104     /*! \brief Constructor for a string parameter
     140  CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
     141    std::string firstValue, int dflt, bool display = true);
     142
     143  /*! \brief Constructor for a string parameter
    105144
    106145      The default string value must be specified explicitly to distinguish
     
    108147    */
    109148
    110     CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
    111                 std::string dflt, bool display = true) ;
    112 
    113     /*! \brief Constructor for an action parameter */
    114 
    115     CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
    116                 bool display = true) ;
    117 
    118     /*! \brief Copy constructor */
    119 
    120     CbcOsiParam(const CbcOsiParam &orig) ;
    121 
    122     /*! \brief Clone */
    123 
    124     CbcOsiParam *clone() ;
    125 
    126     /*! \brief Assignment */
    127 
    128     CbcOsiParam &operator=(const CbcOsiParam &rhs) ;
    129 
    130     /*! \brief  Destructor */
    131 
    132     ~CbcOsiParam() ;
    133 
    134 //@}
    135 
    136     /*! \name Methods to query and manipulate a parameter object */
    137 //@{
    138 
    139     /*! \brief Get the parameter code  */
    140 
    141     inline CbcOsiParamCode paramCode() const {
    142         return (paramCode_) ;
    143     }
    144 
    145     /*! \brief Set the parameter code */
    146 
    147     inline void setParamCode(CbcOsiParamCode code) {
    148         paramCode_ = code ;
    149     }
    150 
    151     /*! \brief Get the underlying OsiSolverInterface object */
    152 
    153     inline OsiSolverInterface *obj() const {
    154         return (obj_) ;
    155     }
    156 
    157     /*! \brief Set the underlying OsiSolverInterace object */
    158 
    159     inline void setObj(OsiSolverInterface *obj) {
    160         obj_ = obj ;
    161     }
    162 
    163 //@}
    164 
     149  CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
     150    std::string dflt, bool display = true);
     151
     152  /*! \brief Constructor for an action parameter */
     153
     154  CbcOsiParam(CbcOsiParamCode code, std::string name, std::string help,
     155    bool display = true);
     156
     157  /*! \brief Copy constructor */
     158
     159  CbcOsiParam(const CbcOsiParam &orig);
     160
     161  /*! \brief Clone */
     162
     163  CbcOsiParam *clone();
     164
     165  /*! \brief Assignment */
     166
     167  CbcOsiParam &operator=(const CbcOsiParam &rhs);
     168
     169  /*! \brief  Destructor */
     170
     171  ~CbcOsiParam();
     172
     173  //@}
     174
     175  /*! \name Methods to query and manipulate a parameter object */
     176  //@{
     177
     178  /*! \brief Get the parameter code  */
     179
     180  inline CbcOsiParamCode paramCode() const
     181  {
     182    return (paramCode_);
     183  }
     184
     185  /*! \brief Set the parameter code */
     186
     187  inline void setParamCode(CbcOsiParamCode code)
     188  {
     189    paramCode_ = code;
     190  }
     191
     192  /*! \brief Get the underlying OsiSolverInterface object */
     193
     194  inline OsiSolverInterface *obj() const
     195  {
     196    return (obj_);
     197  }
     198
     199  /*! \brief Set the underlying OsiSolverInterace object */
     200
     201  inline void setObj(OsiSolverInterface *obj)
     202  {
     203    obj_ = obj;
     204  }
     205
     206  //@}
    165207
    166208private:
    167 
    168     /*! \name Data */
    169 //@{
    170 
    171     /// Parameter code
    172     CbcOsiParamCode paramCode_ ;
    173 
    174     /// OsiSolverInterface object
    175     OsiSolverInterface *obj_ ;
    176 
    177 //@}
    178 
    179 } ;
    180 
    181 
     209  /*! \name Data */
     210  //@{
     211
     212  /// Parameter code
     213  CbcOsiParamCode paramCode_;
     214
     215  /// OsiSolverInterface object
     216  OsiSolverInterface *obj_;
     217
     218  //@}
     219};
    182220
    183221/*
     
    187225namespace CbcOsiParamUtils {
    188226void addCbcOsiParams(int &numParams, CoinParamVec &paramVec,
    189                      OsiSolverInterface *osi) ;
     227  OsiSolverInterface *osi);
    190228void loadOsiParamObj(const CoinParamVec paramVec,
    191                      CbcGenCtlBlk *ctlBlk) ;
    192 void setOsiSolverInterfaceDefaults(OsiSolverInterface *osi) ;
    193 
    194 int pushCbcOsiLogLevel(CoinParam *param) ;
    195 int pushCbcOsiInt(CoinParam *param) ;
    196 int pushCbcOsiDbl(CoinParam *param) ;
    197 int pushCbcOsiKwd(CoinParam *param) ;
    198 int pushCbcOsiHint(CoinParam *param) ;
     229  CbcGenCtlBlk *ctlBlk);
     230void setOsiSolverInterfaceDefaults(OsiSolverInterface *osi);
     231
     232int pushCbcOsiLogLevel(CoinParam *param);
     233int pushCbcOsiInt(CoinParam *param);
     234int pushCbcOsiDbl(CoinParam *param);
     235int pushCbcOsiKwd(CoinParam *param);
     236int pushCbcOsiHint(CoinParam *param);
    199237}
    200238
    201 
    202239#endif
    203 
Note: See TracChangeset for help on using the changeset viewer.