source: trunk/Cbc/src/CbcParam.cpp @ 1514

Last change on this file since 1514 was 1432, checked in by bjarni, 9 years ago

Added extra return at end of each source file where needed, to remove possible linefeed conflicts (NightlyBuild? errors)

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