File: CbcGeneralDepth.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 (279 lines) | stat: -rw-r--r-- 8,699 bytes parent folder | download | duplicates (2)
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
// $Id: CbcGeneralDepth.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 CbcGeneralDepth_H
#define CbcGeneralDepth_H

#include "CbcGeneral.hpp"
#include "CbcBranchBase.hpp"
#include "CbcSubProblem.hpp"

#ifdef COIN_HAS_CLP

/** Define a catch all class.
    This will create a list of subproblems using partial evaluation
*/
#include "ClpSimplex.hpp"
#include "ClpNode.hpp"


class CbcGeneralDepth : public CbcGeneral {

public:

    // Default Constructor
    CbcGeneralDepth ();

    /** Useful constructor
        Just needs to point to model.
        Initial version does evaluation to depth N
        This is stored in CbcModel but may be
        better here
    */
    CbcGeneralDepth (CbcModel * model, int maximumDepth);

    // Copy constructor
    CbcGeneralDepth ( const CbcGeneralDepth &);

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

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

    // Destructor
    ~CbcGeneralDepth ();

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

    using CbcObject::feasibleRegion ;
    /// This looks at solution and sets bounds to contain solution
    virtual void feasibleRegion();

    /// Creates a branching object
    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
    /// Return maximum number of nodes
    inline int maximumNodes() const {
        return maximumNodes_;
    }
    /// Get maximum depth
    inline int maximumDepth() const {
        return maximumDepth_;
    }
    /// Set maximum depth
    inline void setMaximumDepth(int value) {
        maximumDepth_ = value;
    }
    /// Return number of nodes
    inline int numberNodes() const {
        return numberNodes_;
    }
    /// Get which solution
    inline int whichSolution() const {
        return whichSolution_;
    }
    /// Get ClpNode info
    inline ClpNode * nodeInfo(int which) {
        return nodeInfo_->nodeInfo_[which];
    }

    /// Redoes data when sequence numbers change
    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);

protected:
    /// data
    /// Maximum depth
    int maximumDepth_;
    /// Maximum nodes
    int maximumNodes_;
    /// Which node has solution (or -1)
    mutable int whichSolution_;
    /// Number of valid nodes (including whichSolution_)
    mutable int numberNodes_;
    /// For solving nodes
    mutable ClpNodeStuff * nodeInfo_;
};
/** Branching object for general objects

 */
class CbcNode;
class CbcGeneralBranchingObject : public CbcBranchingObject {

public:

    // Default Constructor
    CbcGeneralBranchingObject ();

    // Useful constructor
    CbcGeneralBranchingObject (CbcModel * model);

    // Copy constructor
    CbcGeneralBranchingObject ( const CbcGeneralBranchingObject &);

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

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

    // Destructor
    virtual ~CbcGeneralBranchingObject ();

    using CbcBranchingObject::branch ;
    /// Does next branch and updates state
    virtual double branch();
    /** Double checks in case node can change its mind!
        Can change objective etc */
    virtual void checkIsCutoff(double cutoff);

    using CbcBranchingObject::print ;
    /** \brief Print something about branch - only if log level high
    */
    virtual void print();
    /// Fill in current objective etc
    void state(double & objectiveValue, double & sumInfeasibilities,
               int & numberUnsatisfied, int which) const;
    /// Set CbcNode
    inline void setNode(CbcNode * node) {
        node_ = node;
    }
    /** Return the type (an integer identifier) of \c this */
    virtual CbcBranchObjType type() const {
        return GeneralDepthBranchObj;
    }

    /** Compare the original object of \c this with the original object of \c
        brObj. Assumes that there is an ordering of the original objects.
        This method should be invoked only if \c this and brObj are of the same
        type.
        Return negative/0/positive depending on whether \c this is
        smaller/same/larger than the argument.
    */
    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

    /** Compare the \c this with \c brObj. \c this and \c brObj must be os the
        same type and must have the same original object, but they may have
        different feasible regions.
        Return the appropriate CbcRangeCompare value (first argument being the
        sub/superset if that's the case). In case of overlap (and if \c
        replaceIfOverlap is true) replace the current branching object with one
        whose feasible region is the overlap.
     */
    virtual CbcRangeCompare compareBranchingObject
    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
    /// Number of subproblems
    inline int numberSubProblems() const {
        return numberSubProblems_;
    }
    /// Decrement number left and return number
    inline int decrementNumberLeft() {
        numberSubLeft_--;
        return numberSubLeft_;
    }
    /// Which node we want to use
    inline int whichNode() const {
        return whichNode_;
    }
    /// Set which node we want to use
    inline void setWhichNode(int value) {
        whichNode_ = value;
    }
    // Sub problem
    const CbcSubProblem * subProblem(int which) const {
        return subProblems_ + which;
    }

public:
    /// data
    // Sub problems
    CbcSubProblem * subProblems_;
    /// Node
    CbcNode * node_;
    /// Number of subproblems
    int numberSubProblems_;
    /// Number of subproblems left
    int numberSubLeft_;
    /// Which node we want to use (-1 for default)
    int whichNode_;
    /// Number of rows
    int numberRows_;
};
/** Branching object for general objects - just one

 */
class CbcOneGeneralBranchingObject : public CbcBranchingObject {

public:

    // Default Constructor
    CbcOneGeneralBranchingObject ();

    // Useful constructor
    CbcOneGeneralBranchingObject (CbcModel * model,
                                  CbcGeneralBranchingObject * object,
                                  int whichOne);

    // Copy constructor
    CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject &);

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

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

    // Destructor
    virtual ~CbcOneGeneralBranchingObject ();

    using CbcBranchingObject::branch ;
    /// Does next branch and updates state
    virtual double branch();
    /** Double checks in case node can change its mind!
        Can change objective etc */
    virtual void checkIsCutoff(double cutoff);

    using CbcBranchingObject::print ;
    /** \brief Print something about branch - only if log level high
    */
    virtual void print();
    /** Return the type (an integer identifier) of \c this */
    virtual CbcBranchObjType type() const {
        return OneGeneralBranchingObj;
    }

    /** Compare the original object of \c this with the original object of \c
        brObj. Assumes that there is an ordering of the original objects.
        This method should be invoked only if \c this and brObj are of the same
        type.
        Return negative/0/positive depending on whether \c this is
        smaller/same/larger than the argument.
    */
    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

    /** Compare the \c this with \c brObj. \c this and \c brObj must be os the
        same type and must have the same original object, but they may have
        different feasible regions.
        Return the appropriate CbcRangeCompare value (first argument being the
        sub/superset if that's the case). In case of overlap (and if \c
        replaceIfOverlap is true) replace the current branching object with one
        whose feasible region is the overlap.
     */
    virtual CbcRangeCompare compareBranchingObject
    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);

public:
    /// data
    /// Object
    CbcGeneralBranchingObject * object_;
    /// Which one
    int whichOne_;
};
#endif //COIN_HAS_CLP
#endif