File: CbcSimpleIntegerPseudoCost.hpp

package info (click to toggle)
coinor-cbc 2.9.9+repack1-1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 7,848 kB
  • ctags: 5,787
  • sloc: cpp: 104,337; sh: 8,921; xml: 2,950; makefile: 520; ansic: 491; awk: 197
file content (114 lines) | stat: -rw-r--r-- 3,380 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
// $Id: CbcSimpleIntegerPseudoCost.hpp 1899 2013-04-09 18:12:08Z stefan $
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

// Edwin 11/10/2009-- carved out of CbcBranchActual

#ifndef CbcSimpleIntegerPseudoCost_H
#define CbcSimpleIntegerPseudoCost_H

#include "CbcSimpleInteger.hpp"
/// Define a single integer class but with pseudo costs

class CbcSimpleIntegerPseudoCost : public CbcSimpleInteger {

public:

    // Default Constructor
    CbcSimpleIntegerPseudoCost ();

    // Useful constructor - passed model index
    CbcSimpleIntegerPseudoCost (CbcModel * model, int iColumn, double breakEven = 0.5);

    // Useful constructor - passed and model index and pseudo costs
    CbcSimpleIntegerPseudoCost (CbcModel * model, int iColumn,
                                double downPseudoCost, double upPseudoCost);
    // Useful constructor - passed and model index and pseudo costs
    CbcSimpleIntegerPseudoCost (CbcModel * model, int dummy, int iColumn,
                                double downPseudoCost, double upPseudoCost);

    // Copy constructor
    CbcSimpleIntegerPseudoCost ( const CbcSimpleIntegerPseudoCost &);

    /// Clone
    virtual CbcObject * clone() const;

    // Assignment operator
    CbcSimpleIntegerPseudoCost & operator=( const CbcSimpleIntegerPseudoCost& rhs);

    // Destructor
    virtual ~CbcSimpleIntegerPseudoCost ();

    /// Infeasibility - large is 0.5
    virtual double infeasibility(const OsiBranchingInformation * info,
                                 int &preferredWay) const;

    /// Creates a branching object
    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;

    /// Down pseudo cost
    inline double downPseudoCost() const {
        return downPseudoCost_;
    }
    /// Set down pseudo cost
    inline void setDownPseudoCost(double value) {
        downPseudoCost_ = value;
    }

    /// Up pseudo cost
    inline double upPseudoCost() const {
        return upPseudoCost_;
    }
    /// Set up pseudo cost
    inline void setUpPseudoCost(double value) {
        upPseudoCost_ = value;
    }

    /// Up down separator
    inline double upDownSeparator() const {
        return upDownSeparator_;
    }
    /// Set up down separator
    inline void setUpDownSeparator(double value) {
        upDownSeparator_ = value;
    }

    /// Return "up" estimate
    virtual double upEstimate() const;
    /// Return "down" estimate (default 1.0e-5)
    virtual double downEstimate() const;

    /// method - see below for details
    inline int method() const {
        return method_;
    }
    /// Set method
    inline void setMethod(int value) {
        method_ = value;
    }

protected:
    /// data

    /// Down pseudo cost
    double downPseudoCost_;
    /// Up pseudo cost
    double upPseudoCost_;
    /** Up/down separator
        If >0.0 then do first branch up if value-floor(value)
        >= this value
    */
    double upDownSeparator_;
    /** Method -
        0 - normal - return min (up,down)
        1 - if before any solution return CoinMax(up,down)
        2 - if before branched solution return CoinMax(up,down)
        3 - always return CoinMax(up,down)
    */
    int method_;
};


#endif