Minotaur 0.4.1
Docs for developers
Loading...
Searching...
No Matches
SimpleTransformer.h
Go to the documentation of this file.
1//
2// Minotaur -- It's only 1/2 bull
3//
4// (C)opyright 2008 - 2025 The Minotaur Team.
5//
6
13#ifndef MINOTAURSIMPLETRANSFORMER_H
14#define MINOTAURSIMPLETRANSFORMER_H
15
16#include "Transformer.h"
17#include "Types.h"
18
19namespace Minotaur
20{
21class CGraph;
22class CNode;
23class Environment;
24class Engine;
25class LinearHandler;
26class LPEngine;
27class Problem;
28class QuadHandler;
29class Solution;
30class YEqCGs;
31class YEqLFs;
32class YEqVars;
33class YEqQfBil;
34typedef CGraph* CGraphPtr;
35typedef LinearHandler* LinearHandlerPtr;
36typedef QuadHandler* QuadHandlerPtr;
37typedef Solution* SolutionPtr;
38typedef const Solution* ConstSolutionPtr;
39typedef LPEngine* LPEnginePtr;
40typedef Engine* EnginePtr;
41
53{
54public:
57
60 EnginePtr nlpe);
61
64
65 // base class method.
66 std::string getName() const;
67
68 // base class method.
70
71 // base class method.
73
74 // base class method.
75 void reformulate(ProblemPtr& newp, HandlerVector& handlers, int& status);
76
77 void writeStats(std::ostream& out) const;
78
79private:
80 // Store statistics of reformulation
81 struct RefStats {
82 double time;
83 UInt nvars;
84 UInt ncons;
85 UInt nconv;
86 UInt objConv;
89 };
90
91 static const std::string me_;
92
93 LPEnginePtr bte_;
94
95 LPEnginePtr cute_;
96
97 EnginePtr nlpe_;
98
99 RefStats stats_;
100
101 YEqCGs* yBiVars_;
102 YEqQfBil* yQfBil_;
103
104 void absRef_(LinearFunctionPtr lfl, VariablePtr vl, double dl, VariablePtr& v,
105 double& d);
106
107 void bilRef_(LinearFunctionPtr lfl, VariablePtr vl, double dl,
108 LinearFunctionPtr lfr, VariablePtr vr, double dr,
109 LinearFunctionPtr& lf, VariablePtr& v, double& d);
110
111 VariablePtr newBilVar_(VariablePtr vl, VariablePtr vr);
112
116 bool checkNonLinConvexity_();
117
118 void powKRef_(LinearFunctionPtr lfl, VariablePtr vl, double dl, double k,
119 LinearFunctionPtr& lf, VariablePtr& v, double& d);
120
127 void refBinxBin_(VariablePtr bin1, VariablePtr bin2, VariablePtr aux);
128
135 void refBinxCont_(VariablePtr bin, VariablePtr cont, VariablePtr aux);
136
142 void refNonlinCons_(ConstProblemPtr oldp);
143
149 void refNonlinObj_(ConstProblemPtr oldp);
150
151 void refQuadCons_(QuadraticFunctionPtr qf, LinearFunctionPtr& lf);
152
156 void recursRef_(const CNode* node, LinearFunctionPtr& lf, VariablePtr& v,
157 double& d);
158
159 // Reset the statistics for transformer
160 void resetStats_();
161
162 void trigRef_(OpCode op, LinearFunctionPtr lfl, VariablePtr vl, double dl,
163 VariablePtr& v, double& d);
164
165 void uniVarRef_(const CNode* n0, LinearFunctionPtr lfl, VariablePtr vl,
166 double dl, LinearFunctionPtr& lf, VariablePtr& v, double& d);
167};
170
171} // namespace Minotaur
172
173#endif
174
Declare base class for transforming problems.
Declare important 'types' used in Minotaur.
CNode denotes a node in the computational graph. It stores the op-code, children, parents and other a...
Definition CNode.h:48
Definition Engine.h:34
Definition Environment.h:28
Definition LPEngine.h:29
The base class linear function is of the form c'x.
Definition LinearFunction.h:31
Definition Problem.h:74
Definition QuadraticFunction.h:38
Class for reformulating a problem using simple rules so that handlers can be applied to it.
Definition SimpleTransformer.h:53
void reformulate(ProblemPtr &newp, HandlerVector &handlers, int &status)
Perform the reformulation, and assign handlers.
Definition SimpleTransformer.cpp:1128
SimpleTransformer()
Default Constructor.
Definition SimpleTransformer.cpp:58
SolutionPtr getSolOrig(ConstSolutionPtr sol, int &err)
Translate the solution of reformulated problem into that of original problem.
Definition SimpleTransformer.cpp:186
~SimpleTransformer()
Destroy.
Definition SimpleTransformer.cpp:76
SolutionPtr getSolTrans(ConstSolutionPtr sol, int &err)
Translate the solution of originial problem into that of reformulated problem.
Definition SimpleTransformer.cpp:192
std::string getName() const
Get the name of this Transformer.
Definition SimpleTransformer.cpp:181
Definition Solution.h:30
Abstract base class for reformulating a problem so that handlers can be applied to it.
Definition Transformer.h:61
Definition Variable.h:31
Definition YEqCGs.h:24
Definition YEqQfBil.h:21
Definition AbsHandler.h:19
QuadHandler * QuadHandlerPtr
Shared pointer to QuadHandler.
Definition QuadHandler.h:770
unsigned int UInt
Unsigned integer.
Definition Types.h:30

Minotaur source code documented by Doxygen 1.9.8 on Fri Nov 20 2026