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

Last change on this file since 2081 was 1573, checked in by lou, 9 years ago

Change to EPL license notice.

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