source: branches/sandbox/Cbc/src/CbcParam_ban.cpp @ 1276

Last change on this file since 1276 was 1276, checked in by bjarni, 10 years ago

Add Astyle formatting options based on ansi (A1), k&r (A3), stroustrup (A4), and banner (A6)

File size: 15.9 KB
RevLine 
[1276]1/* $Id: CbcParam.cpp 1271 2009-11-05 15:57:25Z forrest $ */
2// Copyright (C) 2002, International Business Machines
3// Corporation and others.  All Rights Reserved.
4#if defined(_MSC_VER)
5// Turn off compiler warning about long names
6#  pragma warning(disable:4786)
7#endif
8
9#include <string>
10#include <iostream>
11#include <cassert>
12
13#include "CbcParam.hpp"
14
15//#############################################################################
16// Constructors / Destructor / Assignment
17//#############################################################################
18
19//-------------------------------------------------------------------
20// Default Constructor
21//-------------------------------------------------------------------
22CbcParam::CbcParam ()
23        : type_(INVALID),
24        lowerDoubleValue_(0.0),
25        upperDoubleValue_(0.0),
26        lowerIntValue_(0),
27        upperIntValue_(0),
28        lengthName_(0),
29        lengthMatch_(0),
30        definedKeyWords_(),
31        name_(),
32        shortHelp_(),
33        longHelp_(),
34        action_(INVALID),
35        currentKeyWord_(-1) {
36    }
37// Other constructors
38CbcParam::CbcParam (std::string name, std::string help,
39                    double lower, double upper, CbcParameterType type,
40                    bool display)
41        : type_(type),
42        lowerIntValue_(0),
43        upperIntValue_(0),
44        definedKeyWords_(),
45        name_(name),
46        shortHelp_(help),
47        longHelp_(),
48        action_(type),
49        currentKeyWord_(-1) {
50    lowerDoubleValue_ = lower;
51    upperDoubleValue_ = upper;
52    gutsOfConstructor();
53    }
54CbcParam::CbcParam (std::string name, std::string help,
55                    int lower, int upper, CbcParameterType type,
56                    bool display)
57        : type_(type),
58        lowerDoubleValue_(0.0),
59        upperDoubleValue_(0.0),
60        definedKeyWords_(),
61        name_(name),
62        shortHelp_(help),
63        longHelp_(),
64        action_(type),
65        currentKeyWord_(-1) {
66    gutsOfConstructor();
67    lowerIntValue_ = lower;
68    upperIntValue_ = upper;
69    }
70// Other strings will be added by append
71CbcParam::CbcParam (std::string name, std::string help,
72                    std::string firstValue,
73                    CbcParameterType type,int defaultIndex,
74                    bool display)
75        : type_(type),
76        lowerDoubleValue_(0.0),
77        upperDoubleValue_(0.0),
78        lowerIntValue_(0),
79        upperIntValue_(0),
80        definedKeyWords_(),
81        name_(name),
82        shortHelp_(help),
83        longHelp_(),
84        action_(type),
85        currentKeyWord_(0) {
86    gutsOfConstructor();
87    definedKeyWords_.push_back(firstValue);
88    }
89// Action
90CbcParam::CbcParam (std::string name, std::string help,
91                    CbcParameterType type,int indexNumber,
92                    bool display)
93        : type_(type),
94        lowerDoubleValue_(0.0),
95        upperDoubleValue_(0.0),
96        lowerIntValue_(0),
97        upperIntValue_(0),
98        definedKeyWords_(),
99        name_(name),
100        shortHelp_(help),
101        longHelp_(),
102        action_(type),
103        currentKeyWord_(-1) {
104    gutsOfConstructor();
105    }
106
107//-------------------------------------------------------------------
108// Copy constructor
109//-------------------------------------------------------------------
110CbcParam::CbcParam (const CbcParam & rhs) {
111    type_ = rhs.type_;
112    lowerDoubleValue_ = rhs.lowerDoubleValue_;
113    upperDoubleValue_ = rhs.upperDoubleValue_;
114    lowerIntValue_ = rhs.lowerIntValue_;
115    upperIntValue_ = rhs.upperIntValue_;
116    lengthName_ = rhs.lengthName_;
117    lengthMatch_ = rhs.lengthMatch_;
118    definedKeyWords_ = rhs.definedKeyWords_;
119    name_ = rhs.name_;
120    shortHelp_ = rhs.shortHelp_;
121    longHelp_ = rhs.longHelp_;
122    action_ = rhs.action_;
123    currentKeyWord_ = rhs.currentKeyWord_;
124
125    }
126
127//-------------------------------------------------------------------
128// Destructor
129//-------------------------------------------------------------------
130CbcParam::~CbcParam () {
131    }
132
133//----------------------------------------------------------------
134// Assignment operator
135//-------------------------------------------------------------------
136CbcParam &
137CbcParam::operator=(const CbcParam& rhs) {
138    if (this != &rhs) {
139        type_ = rhs.type_;
140        lowerDoubleValue_ = rhs.lowerDoubleValue_;
141        upperDoubleValue_ = rhs.upperDoubleValue_;
142        lowerIntValue_ = rhs.lowerIntValue_;
143        upperIntValue_ = rhs.upperIntValue_;
144        lengthName_ = rhs.lengthName_;
145        lengthMatch_ = rhs.lengthMatch_;
146        definedKeyWords_ = rhs.definedKeyWords_;
147        name_ = rhs.name_;
148        shortHelp_ = rhs.shortHelp_;
149        longHelp_ = rhs.longHelp_;
150        action_ = rhs.action_;
151        currentKeyWord_ = rhs.currentKeyWord_;
152        }
153    return *this;
154    }
155void
156CbcParam::gutsOfConstructor() {
157    std::string::size_type  shriekPos = name_.find('!');
158    lengthName_ = name_.length();
159    if ( shriekPos==std::string::npos ) {
160        //does not contain '!'
161        lengthMatch_= lengthName_;
162        }
163    else {
164        lengthMatch_=shriekPos;
165        name_ = name_.substr(0,shriekPos)+name_.substr(shriekPos+1);
166        lengthName_--;
167        }
168    }
169// Insert string (only valid for keywords)
170void
171CbcParam::append(std::string keyWord) {
172    definedKeyWords_.push_back(keyWord);
173    }
174
175int
176CbcParam::matches (std::string input) const {
177    // look up strings to do more elegantly
178    if (input.length()>lengthName_) {
179        return 0;
180        }
181    else {
182        unsigned int i;
183        for (i=0; i<input.length(); i++) {
184            if (tolower(name_[i])!=tolower(input[i]))
185                break;
186            }
187        if (i<input.length()) {
188            return 0;
189            }
190        else if (i>=lengthMatch_) {
191            return 1;
192            }
193        else {
194            // matched but too short
195            return 2;
196            }
197        }
198    }
199// Returns name which could match
200std::string
201CbcParam::matchName (  ) const {
202    if (lengthMatch_==lengthName_)
203        return name_;
204    else
205        return name_.substr(0,lengthMatch_)+"("+name_.substr(lengthMatch_)+")";
206    }
207
208// Returns parameter option which matches (-1 if none)
209int
210CbcParam::parameterOption ( std::string check ) const {
211    int numberItems = definedKeyWords_.size();
212    if (!numberItems) {
213        return -1;
214        }
215    else {
216        int whichItem=0;
217        unsigned int it;
218        for (it=0; it<definedKeyWords_.size(); it++) {
219            std::string thisOne = definedKeyWords_[it];
220            std::string::size_type  shriekPos = thisOne.find('!');
221            unsigned int length1 = thisOne.length();
222            unsigned int length2 = length1;
223            if ( shriekPos!=std::string::npos ) {
224                //contains '!'
225                length2 = shriekPos;
226                thisOne = thisOne.substr(0,shriekPos)+
227                          thisOne.substr(shriekPos+1);
228                length1 = thisOne.length();
229                }
230            if (check.length()<=length1) {
231                unsigned int i;
232                for (i=0; i<check.length(); i++) {
233                    if (tolower(thisOne[i])!=tolower(check[i]))
234                        break;
235                    }
236                if (i<check.length()) {
237                    whichItem++;
238                    }
239                else if (i>=length2) {
240                    break;
241                    }
242                }
243            else {
244                whichItem++;
245                }
246            }
247        if (whichItem<numberItems)
248            return whichItem;
249        else
250            return -1;
251        }
252    }
253// Prints parameter options
254void
255CbcParam::printOptions (  ) const {
256    std::cout<<"Possible options for "<<name_<<" are:"<<std::endl;
257    unsigned int it;
258    for (it=0; it<definedKeyWords_.size(); it++) {
259        std::string thisOne = definedKeyWords_[it];
260        std::string::size_type  shriekPos = thisOne.find('!');
261        if ( shriekPos!=std::string::npos ) {
262            //contains '!'
263            thisOne = thisOne.substr(0,shriekPos)+
264                      "("+thisOne.substr(shriekPos+1)+")";
265            }
266        std::cout<<thisOne<<std::endl;
267        }
268    }
269int
270CbcParam::setDoubleParameter (OsiSolverInterface * model,double value) const {
271    if (value<lowerDoubleValue_||value>upperDoubleValue_) {
272        std::cout<<value<<" was provided for "<<name_<<
273                 " - valid range is "<<lowerDoubleValue_<<" to "<<
274                 upperDoubleValue_<<std::endl;
275        return 1;
276        }
277    else {
278        double oldValue;
279        switch (type_) {
280            case DUALTOLERANCE:
281                model->getDblParam(OsiDualTolerance,oldValue);
282                model->setDblParam(OsiDualTolerance,value);
283                break;
284            case PRIMALTOLERANCE:
285                model->getDblParam(OsiPrimalTolerance,oldValue);
286                model->setDblParam(OsiPrimalTolerance,value);
287                break;
288            default:
289                oldValue=0.0; // to avoid compiler message
290                abort();
291            }
292        std::cout<<name_<<" was changed from "<<oldValue<<" to "
293                 <<value<<std::endl;
294        return 0;
295        }
296    }
297int
298CbcParam::checkDoubleParameter (double value) const {
299    if (value<lowerDoubleValue_||value>upperDoubleValue_) {
300        std::cout<<value<<" was provided for "<<name_<<
301                 " - valid range is "<<lowerDoubleValue_<<" to "<<
302                 upperDoubleValue_<<std::endl;
303        return 1;
304        }
305    else {
306        return 0;
307        }
308    }
309double
310CbcParam::doubleParameter (OsiSolverInterface * model) const {
311    double value;
312    bool getDblParamRetValue;
313    switch (type_) {
314        case DUALTOLERANCE:
315            getDblParamRetValue = model->getDblParam(OsiDualTolerance,value);
316            assert(getDblParamRetValue);
317            break;
318        case PRIMALTOLERANCE:
319            getDblParamRetValue = model->getDblParam(OsiPrimalTolerance,value);
320            assert(getDblParamRetValue);
321            break;
322        default:
323            abort();
324        }
325    return value;
326    }
327int
328CbcParam::setIntParameter (OsiSolverInterface * model,int value) const {
329    if (value<lowerIntValue_||value>upperIntValue_) {
330        std::cout<<value<<" was provided for "<<name_<<
331                 " - valid range is "<<lowerIntValue_<<" to "<<
332                 upperIntValue_<<std::endl;
333        return 1;
334        }
335    else {
336        int oldValue;
337        switch (type_) {
338            case LOGLEVEL:
339                oldValue=model->messageHandler()->logLevel();
340                model->messageHandler()->setLogLevel(value);
341                break;
342            default:
343                oldValue=0; // to avoid compiler message
344                abort();
345            }
346        std::cout<<name_<<" was changed from "<<oldValue<<" to "
347                 <<value<<std::endl;
348        return 0;
349        }
350    }
351int
352CbcParam::intParameter (OsiSolverInterface * model) const {
353    int value=0;
354    switch (type_) {
355        case LOGLEVEL:
356            //value=model->logLevel();
357            break;
358        default:
359            abort();
360        }
361    return value;
362    }
363int
364CbcParam::setDoubleParameter (CbcModel &model,double value) const {
365    if (value<lowerDoubleValue_||value>upperDoubleValue_) {
366        std::cout<<value<<" was provided for "<<name_<<
367                 " - valid range is "<<lowerDoubleValue_<<" to "<<
368                 upperDoubleValue_<<std::endl;
369        return 1;
370        }
371    else {
372        double oldValue;
373        switch (type_) {
374            case INFEASIBILITYWEIGHT:
375                oldValue=model.getDblParam(CbcModel::CbcInfeasibilityWeight);
376                model.setDblParam(CbcModel::CbcInfeasibilityWeight,value);
377                break;
378            case INTEGERTOLERANCE:
379                oldValue=model.getDblParam(CbcModel::CbcIntegerTolerance);
380                model.setDblParam(CbcModel::CbcIntegerTolerance,value);
381                break;
382            case INCREMENT:
383                oldValue=model.getDblParam(CbcModel::CbcCutoffIncrement);
384                model.setDblParam(CbcModel::CbcCutoffIncrement,value);
385            case ALLOWABLEGAP:
386                oldValue=model.getDblParam(CbcModel::CbcAllowableGap);
387                model.setDblParam(CbcModel::CbcAllowableGap,value);
388                break;
389            case TIMELIMIT: {
390                oldValue = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
391                model.setDblParam(CbcModel::CbcMaximumSeconds,value) ;
392                break ;
393                }
394            case DUALTOLERANCE:
395            case PRIMALTOLERANCE:
396                setDoubleParameter(model.solver(),value);
397                return 0; // to avoid message
398            default:
399                oldValue=0.0; // to avoid compiler message
400                abort();
401            }
402        std::cout<<name_<<" was changed from "<<oldValue<<" to "
403                 <<value<<std::endl;
404        return 0;
405        }
406    }
407double
408CbcParam::doubleParameter (CbcModel &model) const {
409    double value;
410    switch (type_) {
411        case INFEASIBILITYWEIGHT:
412            value=model.getDblParam(CbcModel::CbcInfeasibilityWeight);
413            break;
414        case INTEGERTOLERANCE:
415            value=model.getDblParam(CbcModel::CbcIntegerTolerance);
416            break;
417        case INCREMENT:
418            value=model.getDblParam(CbcModel::CbcCutoffIncrement);
419        case ALLOWABLEGAP:
420            value=model.getDblParam(CbcModel::CbcAllowableGap);
421            break;
422        case TIMELIMIT: {
423            value = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
424            break ;
425            }
426        case DUALTOLERANCE:
427        case PRIMALTOLERANCE:
428            value=doubleParameter(model.solver());
429            break;
430        default:
431            abort();
432        }
433    return value;
434    }
435int
436CbcParam::setIntParameter (CbcModel &model,int value) const {
437    if (value<lowerIntValue_||value>upperIntValue_) {
438        std::cout<<value<<" was provided for "<<name_<<
439                 " - valid range is "<<lowerIntValue_<<" to "<<
440                 upperIntValue_<<std::endl;
441        return 1;
442        }
443    else {
444        int oldValue;
445        switch (type_) {
446            case LOGLEVEL:
447                oldValue = model.messageHandler()->logLevel();
448                model.messageHandler()->setLogLevel(value);
449                break;
450            case SOLVERLOGLEVEL:
451                oldValue = model.solver()->messageHandler()->logLevel();
452                model.solver()->messageHandler()->setLogLevel(value);
453                break;
454            case MAXNODES:
455                oldValue=model.getIntParam(CbcModel::CbcMaxNumNode);
456                model.setIntParam(CbcModel::CbcMaxNumNode,value);
457                break;
458            case STRONGBRANCHING:
459                oldValue=model.numberStrong();
460                model.setNumberStrong(value);
461                break;
462            default:
463                oldValue=0; // to avoid compiler message
464                abort();
465            }
466        std::cout<<name_<<" was changed from "<<oldValue<<" to "
467                 <<value<<std::endl;
468        return 0;
469        }
470    }
471int
472CbcParam::intParameter (CbcModel &model) const {
473    int value;
474    switch (type_) {
475        case LOGLEVEL:
476            value = model.messageHandler()->logLevel();
477            break;
478        case SOLVERLOGLEVEL:
479            value = model.solver()->messageHandler()->logLevel();
480            break;
481        case MAXNODES:
482            value = model.getIntParam(CbcModel::CbcMaxNumNode);
483            break;
484        case STRONGBRANCHING:
485            value=model.numberStrong();
486            break;
487        default:
488            abort();
489        }
490    return value;
491    }
Note: See TracBrowser for help on using the repository browser.