Minotaur 0.4.1
Docs for developers
Loading...
Searching...
No Matches
AbsHandler.h
Go to the documentation of this file.
1
2// Minotaur -- It's only 1/2 bull
3//
4// (C)opyright 2010 - 2025 The Minotaur Team.
5//
6
13#ifndef MINOTAURABSHANDLER_H
14#define MINOTAURABSHANDLER_H
15
16#include "Handler.h"
17#include "Types.h"
18
19namespace Minotaur {
20
21 class AbsHandler : public Handler {
22 public:
23 AbsHandler(EnvPtr env, ProblemPtr problem);
25
31 ConstVariablePtr ovar, char sense = 'E');
32
33 // base class method -- not used here
34 void addConstraint(ConstraintPtr) override { assert(0); }
35
36 void relaxInitFull(RelaxationPtr, SolutionPool *, bool *) override {}
37 void relaxInitInc(RelaxationPtr rel, SolutionPool *, bool *is_inf) override;
38 void relaxNodeFull(NodePtr, RelaxationPtr, bool *) override {}
39 void relaxNodeInc(NodePtr node, RelaxationPtr rel,
40 bool *is_infeasible) override;
41
43 bool &should_prune, double &inf_meas) override;
44
45 // No cuts: the relaxation is exact once x is on one side of 0
47 CutManager *cutman, SolutionPoolPtr s_pool,
48 ModVector &p_mods, ModVector &r_mods, bool *sol_found,
49 SeparationStatus *status) override;
50
51 void getBranchingCandidates(RelaxationPtr rel, const DoubleVector &x,
52 ModVector &mods, BrVarCandSet &cands,
53 BrCandVector &gencands, bool &is_inf) override;
54
55 ModificationPtr getBrMod(BrCandPtr cand, DoubleVector &x,
56 RelaxationPtr rel, BranchDirection dir) override;
57
58 Branches getBranches(BrCandPtr cand, DoubleVector &x, RelaxationPtr rel,
59 SolutionPoolPtr s_pool) override;
60
61 SolveStatus presolve(PreModQ *pre_mods, bool *changed,
62 Solution **sol) override;
63
65 ModVector &p_mods, ModVector &r_mods) override;
66
67 std::string getName() const override;
68 void writeStats(std::ostream &out) const override;
69
70 private:
71 struct AbsCons {
72 ConstraintPtr con;
73 VariablePtr iv;
74 VariablePtr ov;
75 VariablePtr riv;
76 VariablePtr rov;
77 char sense;
78 ConstraintPtr secCon;
79
80 AbsCons(ConstraintPtr c, VariablePtr i, VariablePtr o, char s)
81 : con(c), iv(i), ov(o), riv(0), rov(0), sense(s), secCon(0)
82 {
83 }
84 };
85
86 typedef AbsCons *AbsConsPtr;
87 typedef std::vector<AbsConsPtr> AbsConsVec;
88 typedef AbsConsVec::iterator AbsConsIter;
89
90 struct AbsPresolveStats {
91 UInt iters;
92 UInt vBnd;
93 AbsPresolveStats() : iters(0), vBnd(0) {}
94 };
95
96 AbsConsVec consd_;
97 static const std::string me_;
98 AbsPresolveStats pStats_;
99 double eTol_;
100 double vTol_;
101 ProblemPtr p_;
102 LoggerPtr log_;
103
104 // y >= x and y >= -x: global and exact, added once at the root
105 void addLin_(AbsCons &cd, RelaxationPtr rel);
106
107 // Row y - m*x <= c valid on the current bounds of x. Created at the root,
108 // overwritten at every node; a free row if no valid upper side exists.
109 void addSecant_(AbsCons &cd, RelaxationPtr rel);
110
111 // Violation of y = |x|; 0 if x is on one side of 0 (relaxation exact)
112 double getViol_(const AbsCons &cd, const DoubleVector &x) const;
113
114 // Bounds on y from bounds on x and vice versa. Returns true if infeasible.
115 bool propAbsBnds_(AbsConsPtr cd, bool *changed);
116
117 int updatePBnds_(VariablePtr p, double newlb, double newub,
118 bool *changed);
119 };
120
121 typedef AbsHandler *AbsHandlerPtr;
122
123} // namespace Minotaur
124
125#endif // MINOTAURABSHANDLER_H
Define abstract base class for handlers of various kinds.
Declare important 'types' used in Minotaur.
Definition AbsHandler.h:21
void writeStats(std::ostream &out) const override
Write statistics to ostream out.
Definition AbsHandler.cpp:342
SolveStatus presolve(PreModQ *pre_mods, bool *changed, Solution **sol) override
Initial presolve.
Definition AbsHandler.cpp:319
void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool *is_infeasible) override
Create an incremental relaxation for a node.
Definition AbsHandler.cpp:123
std::string getName() const override
Return the name of the handler.
Definition AbsHandler.cpp:337
void getBranchingCandidates(RelaxationPtr rel, const DoubleVector &x, ModVector &mods, BrVarCandSet &cands, BrCandVector &gencands, bool &is_inf) override
find branching candidates.
Definition AbsHandler.cpp:173
Branches getBranches(BrCandPtr cand, DoubleVector &x, RelaxationPtr rel, SolutionPoolPtr s_pool) override
Return branches for branching.
Definition AbsHandler.cpp:216
void addConstraint(ConstraintPtr newcon, ConstVariablePtr ivar, ConstVariablePtr ovar, char sense='E')
Definition AbsHandler.cpp:54
void addConstraint(ConstraintPtr) override
Add constraint to be handled by this handler.
Definition AbsHandler.h:34
bool isFeasible(ConstSolutionPtr sol, RelaxationPtr rel, bool &should_prune, double &inf_meas) override
Check if a solution is feasible.
Definition AbsHandler.cpp:148
void relaxInitFull(RelaxationPtr, SolutionPool *, bool *) override
Create root relaxation if doing full node relaxations.
Definition AbsHandler.h:36
bool presolveNode(RelaxationPtr rel, NodePtr node, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods) override
Presolve the problem and its relaxation at a node.
Definition AbsHandler.cpp:331
ModificationPtr getBrMod(BrCandPtr cand, DoubleVector &x, RelaxationPtr rel, BranchDirection dir) override
Get the modifcation that creates a given (up or down) branch.
Definition AbsHandler.cpp:204
void relaxNodeFull(NodePtr, RelaxationPtr, bool *) override
Create a relaxation for a node, building from scratch.
Definition AbsHandler.h:38
void relaxInitInc(RelaxationPtr rel, SolutionPool *, bool *is_inf) override
Create root relaxation if doing incremental node relaxations.
Definition AbsHandler.cpp:109
void separate(ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel, CutManager *cutman, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods, bool *sol_found, SeparationStatus *status) override
add cuts to separate a given point.
Definition AbsHandler.cpp:166
Base class for describing candidates for branching on a node in branch-and-bound.
Definition BrCand.h:32
The Constraint class is used to manage a constraint.
Definition Constraint.h:61
Abstract base class to manage cuts in the relaxation.
Definition CutManager.h:42
Definition Environment.h:28
Base class for handling specific types of constraints or objective.
Definition Handler.h:49
Definition Modification.h:29
Definition Node.h:54
Definition Problem.h:74
Definition Relaxation.h:53
Definition SolutionPool.h:28
Definition Solution.h:30
Definition Variable.h:31
Definition AbsHandler.h:19
BranchDirection
Two directions for branching.
Definition Types.h:201
unsigned int UInt
Unsigned integer.
Definition Types.h:30
SeparationStatus
Status from separation routine:
Definition Types.h:217
SolveStatus
Different states an algorithm like branch-and-bound can be in.
Definition Types.h:158

Minotaur source code documented by Doxygen 1.9.8 on Wed Nov 18 2026