source: branches/sandbox/Cbc/src/CbcParam.cpp @ 1373

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

Renamed parameter constants in CbcParam?, CbcSolver?, and ClpAmplStuff? with same names as CbcOrClpParam? in CLP to make them more readable/search-able

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 15.3 KB
Line 
1/* $Id: CbcParam.cpp 1373 2009-12-06 21:21:35Z bjarni $ */
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_(CBC_PARAM_NOTUSED_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_(CBC_PARAM_NOTUSED_INVALID),
35        currentKeyWord_(-1)
36{
37}
38// Other constructors
39CbcParam::CbcParam (std::string name, std::string help,
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)
51{
52    lowerDoubleValue_ = lower;
53    upperDoubleValue_ = upper;
54    gutsOfConstructor();
55}
56CbcParam::CbcParam (std::string name, std::string help,
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)
68{
69    gutsOfConstructor();
70    lowerIntValue_ = lower;
71    upperIntValue_ = upper;
72}
73// Other strings will be added by append
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)
89{
90    gutsOfConstructor();
91    definedKeyWords_.push_back(firstValue);
92}
93// Action
94CbcParam::CbcParam (std::string name, std::string help,
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)
108{
109    gutsOfConstructor();
110}
111
112//-------------------------------------------------------------------
113// Copy constructor
114//-------------------------------------------------------------------
115CbcParam::CbcParam (const CbcParam & rhs)
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_;
130
131}
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
164CbcParam::gutsOfConstructor()
165{
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    }
176}
177// Insert string (only valid for keywords)
178void
179CbcParam::append(std::string keyWord)
180{
181    definedKeyWords_.push_back(keyWord);
182}
183
184int
185CbcParam::matches (std::string input) const
186{
187    // look up strings to do more elegantly
188    if (input.length() > lengthName_) {
189        return 0;
190    } else {
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        }
204    }
205}
206// Returns name which could match
207std::string
208CbcParam::matchName (  ) const
209{
210    if (lengthMatch_ == lengthName_)
211        return name_;
212    else
213        return name_.substr(0, lengthMatch_) + "(" + name_.substr(lengthMatch_) + ")";
214}
215
216// Returns parameter option which matches (-1 if none)
217int
218CbcParam::parameterOption ( std::string check ) const
219{
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;
257    }
258}
259// Prints parameter options
260void
261CbcParam::printOptions (  ) const
262{
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;
274    }
275}
276int
277CbcParam::setDoubleParameter (OsiSolverInterface * model, double value) const
278{
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_) {
287        case CLP_PARAM_DBL_DUALTOLERANCE:
288            model->getDblParam(OsiDualTolerance, oldValue);
289            model->setDblParam(OsiDualTolerance, value);
290            break;
291        case CLP_PARAM_DBL_PRIMALTOLERANCE:
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;
302    }
303}
304int
305CbcParam::checkDoubleParameter (double value) const
306{
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    }
315}
316double
317CbcParam::doubleParameter (OsiSolverInterface * model) const
318{
319    double value;
320    bool getDblParamRetValue;
321    switch (type_) {
322    case CLP_PARAM_DBL_DUALTOLERANCE:
323        getDblParamRetValue = model->getDblParam(OsiDualTolerance, value);
324        assert(getDblParamRetValue);
325        break;
326    case CLP_PARAM_DBL_PRIMALTOLERANCE:
327        getDblParamRetValue = model->getDblParam(OsiPrimalTolerance, value);
328        assert(getDblParamRetValue);
329        break;
330    default:
331        abort();
332    }
333    return value;
334}
335int
336CbcParam::setIntParameter (OsiSolverInterface * model, int value) const
337{
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_) {
346        case CLP_PARAM_INT_LOGLEVEL:
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;
357    }
358}
359int
360CbcParam::intParameter (OsiSolverInterface * model) const
361{
362    int value = 0;
363    switch (type_) {
364    case CLP_PARAM_INT_LOGLEVEL:
365        //value=model->logLevel();
366        break;
367    default:
368        abort();
369    }
370    return value;
371}
372int
373CbcParam::setDoubleParameter (CbcModel &model, double value) const
374{
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_) {
383        case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
384            oldValue = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
385            model.setDblParam(CbcModel::CbcInfeasibilityWeight, value);
386            break;
387        case CBC_PARAM_DBL_INTEGERTOLERANCE:
388            oldValue = model.getDblParam(CbcModel::CbcIntegerTolerance);
389            model.setDblParam(CbcModel::CbcIntegerTolerance, value);
390            break;
391        case CBC_PARAM_DBL_INCREMENT:
392            oldValue = model.getDblParam(CbcModel::CbcCutoffIncrement);
393            model.setDblParam(CbcModel::CbcCutoffIncrement, value);
394        case CBC_PARAM_DBL_ALLOWABLEGAP:
395            oldValue = model.getDblParam(CbcModel::CbcAllowableGap);
396            model.setDblParam(CbcModel::CbcAllowableGap, value);
397            break;
398        case CLP_PARAM_DBL_TIMELIMIT: {
399            oldValue = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
400            model.setDblParam(CbcModel::CbcMaximumSeconds, value) ;
401            break ;
402        }
403        case CLP_PARAM_DBL_DUALTOLERANCE:
404        case CLP_PARAM_DBL_PRIMALTOLERANCE:
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_) {
421    case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
422        value = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
423        break;
424    case CBC_PARAM_DBL_INTEGERTOLERANCE:
425        value = model.getDblParam(CbcModel::CbcIntegerTolerance);
426        break;
427    case CBC_PARAM_DBL_INCREMENT:
428        value = model.getDblParam(CbcModel::CbcCutoffIncrement);
429    case CBC_PARAM_DBL_ALLOWABLEGAP:
430        value = model.getDblParam(CbcModel::CbcAllowableGap);
431        break;
432    case CLP_PARAM_DBL_TIMELIMIT: {
433        value = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
434        break ;
435    }
436    case CLP_PARAM_DBL_DUALTOLERANCE:
437    case CLP_PARAM_DBL_PRIMALTOLERANCE:
438        value = doubleParameter(model.solver());
439        break;
440    default:
441        abort();
442    }
443    return value;
444}
445int
446CbcParam::setIntParameter (CbcModel &model, int value) const
447{
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_) {
456        case CLP_PARAM_INT_LOGLEVEL:
457            oldValue = model.messageHandler()->logLevel();
458            model.messageHandler()->setLogLevel(value);
459            break;
460        case CLP_PARAM_INT_SOLVERLOGLEVEL:
461            oldValue = model.solver()->messageHandler()->logLevel();
462            model.solver()->messageHandler()->setLogLevel(value);
463            break;
464        case CBC_PARAM_INT_MAXNODES:
465            oldValue = model.getIntParam(CbcModel::CbcMaxNumNode);
466            model.setIntParam(CbcModel::CbcMaxNumNode, value);
467            break;
468        case CBC_PARAM_INT_STRONGBRANCHING:
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    }
480}
481int
482CbcParam::intParameter (CbcModel &model) const
483{
484    int value;
485    switch (type_) {
486    case CLP_PARAM_INT_LOGLEVEL:
487        value = model.messageHandler()->logLevel();
488        break;
489    case CLP_PARAM_INT_SOLVERLOGLEVEL:
490        value = model.solver()->messageHandler()->logLevel();
491        break;
492    case CBC_PARAM_INT_MAXNODES:
493        value = model.getIntParam(CbcModel::CbcMaxNumNode);
494        break;
495    case CBC_PARAM_INT_STRONGBRANCHING:
496        value = model.numberStrong();
497        break;
498    default:
499        abort();
500    }
501    return value;
502}
Note: See TracBrowser for help on using the repository browser.