Minotaur 0.4.1
Docs for developers
Loading...
Searching...
No Matches
LogHandler.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
14//y=log(x) and log constraint have same meaning
15#ifndef MINOTAURLOGHANDLER_H
16#define MINOTAURLOGHANDLER_H
17
18#include "Handler.h"
19#include "Types.h"
20namespace Minotaur {
21
22 class Engine;
23 class Function;
24 class LinearFunction;
25 class Objective;
26 class Problem;
27 typedef LinearFunction *LinearFunctionPtr;
28 typedef Objective *ObjectivePtr;
29
30
31 class LogHandler : public Handler {
32
33 public:
34 // Constructor
35 LogHandler(EnvPtr env, ProblemPtr problem);
36 LogHandler(EnvPtr env, ProblemPtr problem, ProblemPtr orig_);
37 // Destructor
39
47 ConstVariablePtr ovar, char sense = 'E');
48
49 // base class method—not used here
50 void addConstraint(ConstraintPtr) override { assert(0); }
51
52
53 // Full relaxation (unused)
54 void relaxInitFull(RelaxationPtr, SolutionPool *, bool *) override {}
55
56 // Create initial relaxation at root and then updation
57 void relaxInitInc(RelaxationPtr rel, SolutionPool *, bool *is_inf) override;
58
59 //Base Class method
60 bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation,
61 bool &should_prune, double &inf_meas) override;
62
63 // Separation (cuts) -cutmanager not implemented
65 CutManager *cutman, SolutionPoolPtr s_pool,
66 ModVector &p_mods, ModVector &r_mods, bool *sol_found,
67 SeparationStatus *status) override;
68
69 // Full relaxation at a node (unused for LogHandler)
70 void relaxNodeFull(NodePtr, RelaxationPtr, bool *) override {}
71
72 // Incremental relaxation at a node.
73 void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool *isInfeasible) override;
74
75 // Branching candidates.
76 void getBranchingCandidates(RelaxationPtr rel, const DoubleVector &x,
77 ModVector &mods, BrVarCandSet &cands,
78 BrCandVector &gencands, bool &is_inf) override;
79
80 // Branch modification for a variable.
81 ModificationPtr getBrMod(BrCandPtr cand, DoubleVector &x,
82 RelaxationPtr rel, BranchDirection dir) override;
83
84 // Generate branches.
85 Branches getBranches(BrCandPtr cand, DoubleVector &x, RelaxationPtr rel,
86 SolutionPoolPtr s_pool) override;
87
88 // Top-level presolve.
89 SolveStatus presolve(PreModQ *pre_mods, bool *changed, Solution **sol) override;
90
91 // Node-level presolve.
93 ModVector &p_mods, ModVector &r_mods) override;
94
95 // Name of the handler.
96 std::string getName() const override;
97
98 // Stats
99 void writeStats(std::ostream &out) const override;
100
101
102
103
104 private:
105
106 // Per-constraint data for log constraints
107 struct LogCons
108 {
109 ConstraintPtr con;
112 VariablePtr riv;
113 VariablePtr rov;
114 char sense;
115 ConstraintPtr secCon;
116 ConstraintVector linCons;
117
118 LogCons(ConstraintPtr newcon, ConstVariablePtr ivar,
119 ConstVariablePtr ovar, char s)
120 : con(newcon),
121 iv(ivar),
122 ov(ovar),
123 riv(0),
124 rov(0),
125 sense(s),
126 secCon(0),
127 linCons()
128 {
129 }
130 };
131
132 typedef LogCons *LogConsPtr;
133 typedef std::vector<LogConsPtr> LogConsVec;
134 typedef LogConsVec::iterator LogConsIter;
135
136 // All log constraints data
137 LogConsVec consd_;
138
139 // For printing
140 static const std::string me_;
141
142 //Stats to store separation data
143 struct SepaStats {
144 int iters;
145 int tangentcuts;
146 int optcuts;
147 int optrem;
148 double time;
149 };
150
151 // Presolve statistics container
152 struct LogPresolveStats
153 {
154 UInt iters;
155 double time;
156 UInt conDel;
157 UInt vBnd;
158 UInt nMods;
159
160 LogPresolveStats()
161 : iters(0),
162 time(0.0),
163 conDel(0),
164 vBnd(0),
165 nMods(0)
166 {
167 }
168 };
169
170 struct BoundTighteningStats
171 {
172 int niters;
173 int nLP;
174 int dlb;
175 int dub;
176 double timeLP;
177 };
178
179 BoundTighteningStats bStats_;
180 LogPresolveStats pStats_;
181 SepaStats sStats_;
182 // Default bounds for presolve
183 double LBd_;
184 double UBd_;
185
186 double bTol_;
187
188 // Environment
189 EnvPtr env_;
190
191 //Problem pointer to the original problem
192 ProblemPtr orig_;
193
194 // Optional cuts
195 ConstraintVector optCuts_;
196
197
198 // Absolute feasibility tolerance
199 double aTol_;
200
201 // Relative feasibility tolerance
202 double rTol_;
203
204 // Tolerances for log constraints
205 double eTol_;
206
207 // Tolerance for when lower and upper bounds are considered equal
208 double vTol_;
209 // Problem pointer to the transformed problem
210 ProblemPtr p_;
211
212 // Logger
213 LoggerPtr log_;
214
215 // Temporary vectors for evaluations
216 DoubleVector tmpX_;
217 DoubleVector grad_;
218
219
220 //separating
221 void addCut_(VariablePtr x, VariablePtr y, double xval, double yval,
222 RelaxationPtr rel, bool& ifcuts);
223
224
225 //add default bounds for x in y=log(x) if no finite bound was added by presolve
226 double addDefaultLogBounds_(VariablePtr x, BoundType lu);
227
231 ConstraintPtr addTangent_(VariablePtr, VariablePtr, double, RelaxationPtr);
232
233
234 //Points at which linearisation is done
235 void addLin_(LogCons &cd, RelaxationPtr rel);
236
241 void addSecant_(LogCons &cd, RelaxationPtr rel);
242
243
249 LinearFunctionPtr getLogSec_(VariablePtr x, VariablePtr y, double lb,
250 double ub, double &rhs);
251
252 //returns the violation for functon y=log(x) and takes input solution vector
253 double getViol_(const LogCons &cd, const DoubleVector &x) const;
254
255
256 // Check feasibility.
257 bool isFeasible_(ConstSolutionPtr sol, RelaxationPtr relaxation,
258 bool &should_prune, double &inf_meas);
259
260
261
262
267 void relaxLog_(LogCons &cd, RelaxationPtr rel, bool init);
268
269 // For a given y = log(x) constraint,
270 // derive bounds on y from bounds on x. Also derive bounds on x from bounds
271 // on y.
272 bool propLogBnds_(LogConsPtr lcd, bool *changed);
273
274
275
284 void updateRelax_(LogCons &cd, RelaxationPtr rel, DoubleVector &tmpX,
285 DoubleVector &grad, ModVector &mods);
286
288 int updatePBnds_(VariablePtr p, double newlb, double newub,
289 bool *changed);
290
291
292 bool varBndsFromCons_(bool *changed);
293
294
295 };
296
297} // namespace Minotaur
298
299#endif // MINOTAURLOGHANDLER_H
Define abstract base class for handlers of various kinds.
Declare important 'types' used in Minotaur.
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 LogHandler.h:31
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 LogHandler.cpp:294
Branches getBranches(BrCandPtr cand, DoubleVector &x, RelaxationPtr rel, SolutionPoolPtr s_pool) override
Return branches for branching.
Definition LogHandler.cpp:438
void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool *isInfeasible) override
Create an incremental relaxation for a node.
Definition LogHandler.cpp:103
bool presolveNode(RelaxationPtr p, NodePtr node, SolutionPoolPtr s_pool, ModVector &p_mods, ModVector &r_mods) override
Presolve the problem and its relaxation at a node.
Definition LogHandler.cpp:697
std::string getName() const override
Return the name of the handler.
Definition LogHandler.cpp:708
SolveStatus presolve(PreModQ *pre_mods, bool *changed, Solution **sol) override
Initial presolve.
Definition LogHandler.cpp:686
void relaxInitInc(RelaxationPtr rel, SolutionPool *, bool *is_inf) override
Create root relaxation if doing incremental node relaxations.
Definition LogHandler.cpp:85
void relaxNodeFull(NodePtr, RelaxationPtr, bool *) override
Create a relaxation for a node, building from scratch.
Definition LogHandler.h:70
bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation, bool &should_prune, double &inf_meas) override
Check if a solution is feasible.
Definition LogHandler.cpp:240
void getBranchingCandidates(RelaxationPtr rel, const DoubleVector &x, ModVector &mods, BrVarCandSet &cands, BrCandVector &gencands, bool &is_inf) override
find branching candidates.
Definition LogHandler.cpp:345
void writeStats(std::ostream &out) const override
Write statistics to ostream out.
Definition LogHandler.cpp:713
void addConstraint(ConstraintPtr) override
Add constraint to be handled by this handler.
Definition LogHandler.h:50
ModificationPtr getBrMod(BrCandPtr cand, DoubleVector &x, RelaxationPtr rel, BranchDirection dir) override
Get the modifcation that creates a given (up or down) branch.
Definition LogHandler.cpp:396
void relaxInitFull(RelaxationPtr, SolutionPool *, bool *) override
Create root relaxation if doing full node relaxations.
Definition LogHandler.h:54
void addConstraint(ConstraintPtr newcon, ConstVariablePtr ivar, ConstVariablePtr ovar, char sense='E')
Definition LogHandler.cpp:225
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
BoundType
Different types of variable-bounds.
Definition Types.h:131
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 Thu Nov 19 2026