MAiNGO
constraint.h
Go to the documentation of this file.
1 /**********************************************************************************
2  * Copyright (c) 2019 Process Systems Engineering (AVT.SVT), RWTH Aachen University
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License 2.0 which is available at
6  * http://www.eclipse.org/legal/epl-2.0.
7  *
8  * SPDX-License-Identifier: EPL-2.0
9  *
10  * @file constraint.h
11  *
12  * @brief File containing declaration of constraint used for storing properties,
13  * indices, constness and name of a constraint
14  *
15  **********************************************************************************/
16 
17 #pragma once
18 
19 #include <string>
20 #include <vector>
21 
22 
23 namespace maingo {
24 
25 
31  LP = 0,
32  MIP,
33  QP,
34  MIQP,
35  NLP,
36  DNLP,
38 };
39 
45  OBJ = 0,
46  INEQ,
47  EQ,
54 };
55 
61  CONV_NONE = 0,
64 };
65 
71  MON_NONE = 0,
72  INCR,
74 };
75 
89 };
90 
101 struct Constraint {
102 
103  public:
112 
116  Constraint(const CONSTRAINT_TYPE typeIn, const unsigned indexOriginalIn, const unsigned indexTypeIn, const unsigned indexNonconstantIn,
117  const unsigned indexTypeNonconstantIn, const std::string& nameIn = ""):
118  name(nameIn),
121  isFeasible(true), indexOriginal(indexOriginalIn), indexNonconstant(indexNonconstantIn), indexNonconstantUBP(0), indexConstant(0),
122  indexLinear(0), indexNonlinear(0), indexType(indexTypeIn), indexTypeNonconstant(indexTypeNonconstantIn), indexTypeConstant(0), nparticipatingVariables(0)
123  {
124  if (name == "") {
125  std::string str;
126  switch (typeIn) {
127  case OBJ:
128  str = "obj" + std::to_string(indexTypeIn + 1);
129  break;
130  case INEQ:
131  str = "ineq" + std::to_string(indexTypeIn + 1);
132  break;
133  case EQ:
134  str = "eq" + std::to_string(indexTypeIn + 1);
135  break;
136  case INEQ_REL_ONLY:
137  str = "relOnlyIneq" + std::to_string(indexTypeIn + 1);
138  break;
139  case EQ_REL_ONLY:
140  str = "relOnlyEq" + std::to_string(indexTypeIn + 1);
141  break;
142  case INEQ_SQUASH:
143  str = "squashIneq" + std::to_string(indexTypeIn + 1);
144  break;
145  case AUX_EQ_REL_ONLY:
146  str = "auxRelOnlyEq" + std::to_string(indexTypeIn + 1);
147  break;
148  case OUTPUT:
149  str = "output" + std::to_string(indexTypeIn + 1);
150  break;
151  default:
152  str = "constraint" + std::to_string(indexTypeIn + 1);
153  break;
154  }
155  name = str;
156  }
157  }
158 
162  Constraint(const CONSTRAINT_TYPE typeIn, const unsigned indexOriginalIn, const unsigned indexTypeIn,
163  const unsigned indexConstantIn, const unsigned indexTypeConstantIn, const bool isConstantIn,
164  const bool isFeasibleIn, const double valueIn, const std::string& nameIn = ""):
165  name(nameIn),
168  isFeasible(isFeasibleIn), indexOriginal(indexOriginalIn), indexNonconstant(0), indexNonconstantUBP(0), indexConstant(indexConstantIn),
169  indexLinear(0), indexNonlinear(0), indexType(indexTypeIn), indexTypeNonconstant(0), indexTypeConstant(indexTypeConstantIn), nparticipatingVariables(0)
170  {
171  if (name == "") {
172  std::string str;
173  switch (typeIn) {
174  case OBJ:
175  str = "obj" + std::to_string(indexTypeIn + 1);
176  break;
177  case INEQ:
178  str = "ineq" + std::to_string(indexTypeIn + 1);
179  break;
180  case EQ:
181  str = "eq" + std::to_string(indexTypeIn + 1);
182  break;
183  case INEQ_REL_ONLY:
184  str = "relOnlyIneq" + std::to_string(indexTypeIn + 1);
185  break;
186  case EQ_REL_ONLY:
187  str = "relOnlyEq" + std::to_string(indexTypeIn + 1);
188  break;
189  case INEQ_SQUASH:
190  str = "squashIneq" + std::to_string(indexTypeIn + 1);
191  break;
192  case AUX_EQ_REL_ONLY:
193  str = "auxRelOnlyEq" + std::to_string(indexTypeIn + 1);
194  break;
195  case OUTPUT:
196  str = "output" + std::to_string(indexTypeIn + 1);
197  break;
198  default:
199  str = "constraint" + std::to_string(indexTypeIn + 1);
200  break;
201  }
202  name = str;
203  }
204  }
205 
206  Constraint(const Constraint&) = default;
207  Constraint& operator=(const Constraint& constraintIn) = default;
209  std::string name;
210  double constantValue;
212  std::vector<unsigned> participatingVariables;
221  bool isConstant;
222  bool isFeasible;
228  unsigned int indexOriginal;
229  unsigned int indexNonconstant;
230  unsigned int indexNonconstantUBP;
231  unsigned int indexConstant;
232  unsigned int indexLinear;
233  unsigned int indexNonlinear;
234  unsigned int indexType;
235  unsigned int indexTypeNonconstant;
236  unsigned int indexTypeConstant;
238 };
239 
240 
241 } // end namespace maingo
Definition: constraint.h:45
unsigned int indexTypeConstant
Definition: constraint.h:236
Definition: constraint.h:53
Definition: constraint.h:82
Definition: constraint.h:61
unsigned int indexOriginal
Definition: constraint.h:228
Definition: constraint.h:46
Definition: constraint.h:35
Definition: constraint.h:84
Definition: constraint.h:72
CONSTRAINT_CONVEXITY
Enum for representing the constraint convexity.
Definition: constraint.h:60
CONSTRAINT_TYPE
Enum for representing the constraint type.
Definition: constraint.h:44
Definition: constraint.h:36
CONSTRAINT_DEPENDENCY dependency
Definition: constraint.h:220
unsigned int indexType
Definition: constraint.h:234
unsigned int indexLinear
Definition: constraint.h:232
bool isConstant
Definition: constraint.h:221
Struct for storing information about constraints.
Definition: constraint.h:101
unsigned int indexConstant
Definition: constraint.h:231
unsigned int indexTypeNonconstant
Definition: constraint.h:235
Definition: constraint.h:87
Constraint()
Default conststructor.
Definition: constraint.h:107
bool isFeasible
Definition: constraint.h:222
Definition: constraint.h:51
CONSTRAINT_DEPENDENCY
Enum for representing the constraint dependency. Note that the dependency is increasing meaning that ...
Definition: constraint.h:81
Definition: constraint.h:63
Definition: constraint.h:34
Definition: constraint.h:47
unsigned int indexNonconstantUBP
Definition: constraint.h:230
std::vector< unsigned > participatingVariables
Definition: constraint.h:212
Definition: constraint.h:33
Definition: constraint.h:86
Definition: constraint.h:37
double constantValue
Definition: constraint.h:210
Definition: constraint.h:88
Definition: constraint.h:48
PROBLEM_STRUCTURE
Enum for representing the problem structure.
Definition: constraint.h:30
Constraint & operator=(const Constraint &constraintIn)=default
Definition: constraint.h:73
Constraint(const CONSTRAINT_TYPE typeIn, const unsigned indexOriginalIn, const unsigned indexTypeIn, const unsigned indexConstantIn, const unsigned indexTypeConstantIn, const bool isConstantIn, const bool isFeasibleIn, const double valueIn, const std::string &nameIn="")
Conststructor for constant constraints with a possible name.
Definition: constraint.h:162
Definition: constraint.h:49
Definition: constraint.h:31
namespace holding all essentials of MAiNGO
Definition: aleModel.h:31
CONSTRAINT_MONOTONICITY monotonicity
Definition: constraint.h:219
Definition: constraint.h:32
unsigned nparticipatingVariables
Definition: constraint.h:211
CONSTRAINT_CONVEXITY convexity
Definition: constraint.h:218
Definition: constraint.h:50
std::string name
Definition: constraint.h:209
Definition: constraint.h:83
Definition: constraint.h:71
CONSTRAINT_MONOTONICITY
Enum for representing the constraint monotonicity.
Definition: constraint.h:70
Definition: constraint.h:52
unsigned int indexNonconstant
Definition: constraint.h:229
Definition: constraint.h:62
unsigned int indexNonlinear
Definition: constraint.h:233
CONSTRAINT_TYPE type
Definition: constraint.h:217
Definition: constraint.h:85
Constraint(const CONSTRAINT_TYPE typeIn, const unsigned indexOriginalIn, const unsigned indexTypeIn, const unsigned indexNonconstantIn, const unsigned indexTypeNonconstantIn, const std::string &nameIn="")
Conststructor for non-constant constraints with a possible name.
Definition: constraint.h:116