Scippy

GCG

Branch-and-Price & Column Generation for Everyone

clscons_miplibconstypes.cpp
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program */
4 /* GCG --- Generic Column Generation */
5 /* a Dantzig-Wolfe decomposition based extension */
6 /* of the branch-cut-and-price framework */
7 /* SCIP --- Solving Constraint Integer Programs */
8 /* */
9 /* Copyright (C) 2010-2021 Operations Research, RWTH Aachen University */
10 /* Zuse Institute Berlin (ZIB) */
11 /* */
12 /* This program is free software; you can redistribute it and/or */
13 /* modify it under the terms of the GNU Lesser General Public License */
14 /* as published by the Free Software Foundation; either version 3 */
15 /* of the License, or (at your option) any later version. */
16 /* */
17 /* This program is distributed in the hope that it will be useful, */
18 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
19 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
20 /* GNU Lesser General Public License for more details. */
21 /* */
22 /* You should have received a copy of the GNU Lesser General Public License */
23 /* along with this program; if not, write to the Free Software */
24 /* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.*/
25 /* */
26 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
27 
28 /**@file clscons_miplibconstypes.cpp
29  * @ingroup CLASSIFIERS
30  * @brief classifies constraints according to their miplib constypes
31  */
32 
33 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34 
35 #include "clscons_miplibconstypes.h"
36 #include "cons_decomp.h"
37 #include "cons_decomp.hpp"
38 #include <vector>
39 #include <stdio.h>
40 #include <sstream>
41 
42 #include "class_detprobdata.h"
43 
44 #include "class_conspartition.h"
45 #include "scip_misc.h"
46 
47 /* classifier properties */
48 #define DEC_CLASSIFIERNAME "miplibconstype" /**< name of classifier */
49 #define DEC_DESC "miplib constypes" /**< short description of classification*/
50 #define DEC_PRIORITY 0
51 
52 #define DEC_ENABLED TRUE
53 
54 
55 /*
56  * Data structures
57  */
58 
59 /** classifier handler data */
60 struct DEC_ClassifierData
61 {
62 };
63 
64 
65 /*
66  * Local methods
67  */
68 
69 /* put your local methods here, and declare them static */
70 
71 
72 /*
73  * classifier callback methods
74  */
75 
76 /** destructor of classifier to free user data (called when GCG is exiting) */
77 #define classifierFree NULL
78 
79 static
80 DEC_DECL_CONSCLASSIFY(classifierClassify)
81 {
82  gcg::DETPROBDATA* detprobdata;
83  if( transformed )
84  {
85  detprobdata = GCGconshdlrDecompGetDetprobdataPresolved(scip);
86  }
87  else
88  {
89  detprobdata = GCGconshdlrDecompGetDetprobdataOrig(scip);
90  }
91 
92  std::vector<int> nfoundconstypesrangedsinglecount( (int) SCIP_CONSTYPE_GENERAL + 1, 0 );
93  std::vector<int> nfoundconstypesrangeddoublecount( (int) SCIP_CONSTYPE_GENERAL + 1, 0 );
94 
95  std::vector<int> classforcons = std::vector<int>( detprobdata->getNConss(), -1 );
96  gcg::ConsPartition* classifier;
97 
98  /* firstly, assign all constraints to classindices */
99  for( int c = 0; c < detprobdata->getNConss(); ++ c )
100  {
101  SCIP_CONS* cons;
102  SCIP_Real lhs;
103  SCIP_Real rhs;
104  SCIP_Real* vals;
105  SCIP_VAR** vars;
106  int nvars;
107  int i;
108 
109  cons = detprobdata->getCons(c);
110 
111  nvars = GCGconsGetNVars(scip, cons );
112 
113  lhs = GCGconsGetLhs(scip, cons);
114  rhs = GCGconsGetRhs(scip, cons);
115  if( nvars != 0 )
116  {
117  SCIP_CALL_ABORT( SCIPallocBufferArray(scip, &vals, nvars));
118  SCIP_CALL_ABORT( SCIPallocBufferArray(scip, &vars, nvars));
119  SCIP_CALL_ABORT( GCGconsGetVals(scip, cons, vals, nvars ) );
120  SCIP_CALL_ABORT( GCGconsGetVars(scip, cons, vars, nvars ) );
121  }
122 
123  for( i = 0; i < nvars; i++ )
124  {
125  assert(!SCIPisZero(scip, vals[i]) );
126  }
127 
128 
129  /* is constraint of type SCIP_CONSTYPE_EMPTY? */
130  if( nvars == 0 )
131  {
132  SCIPdebugMsg(scip, "classified as EMPTY: ");
133  SCIPdebugPrintCons(scip, cons, NULL);
134  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_EMPTY]++;
135  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_EMPTY]++;
136  classforcons[c] = SCIP_CONSTYPE_EMPTY;
137  continue;
138  }
139 
140  /* is constraint of type SCIP_CONSTYPE_FREE? */
141  if( SCIPisInfinity(scip, rhs) && SCIPisInfinity(scip, -lhs) )
142  {
143  SCIPdebugMsg(scip, "classified as FREE: ");
144  SCIPdebugPrintCons(scip, cons, NULL);
145  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_FREE]++;
146  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_FREE]++;
147  classforcons[c] = SCIP_CONSTYPE_FREE;
148  SCIPfreeBufferArray(scip, &vars);
149  SCIPfreeBufferArray(scip, &vals);
150  continue;
151  }
152 
153  /* is constraint of type SCIP_CONSTYPE_SINGLETON? */
154  if( nvars == 1 )
155  {
156  SCIPdebugMsg(scip, "classified as SINGLETON: ");
157  SCIPdebugPrintCons(scip, cons, NULL);
158  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_SINGLETON] += 2 ;
159  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_SINGLETON]++;
160  classforcons[c] = SCIP_CONSTYPE_SINGLETON;
161  SCIPfreeBufferArray(scip, &vars) ;
162  SCIPfreeBufferArray(scip, &vals) ;
163  continue;
164  }
165 
166  /* is constraint of type SCIP_CONSTYPE_AGGREGATION? */
167  if( nvars == 2 && SCIPisEQ(scip, lhs, rhs) )
168  {
169  SCIPdebugMsg(scip, "classified as AGGREGATION: ");
170  SCIPdebugPrintCons(scip, cons, NULL);
171  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_AGGREGATION]++;
172  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_AGGREGATION]++;
173  classforcons[c] = SCIP_CONSTYPE_AGGREGATION;
174  SCIPfreeBufferArray(scip, &vars) ;
175  SCIPfreeBufferArray(scip, &vals) ;
176  continue;
177  }
178 
179  /* is constraint of type SCIP_CONSTYPE_{VARBOUND}? */
180  if( nvars == 2 )
181  {
182  SCIPdebugMsg(scip, "classified as VARBOUND: ");
183  SCIPdebugPrintCons(scip, cons, NULL);
184  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_VARBOUND] += 2 ;
185  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_VARBOUND]++;
186  classforcons[c] = SCIP_CONSTYPE_VARBOUND;
187  SCIPfreeBufferArray(scip, &vars) ;
188  SCIPfreeBufferArray(scip, &vals) ;
189  continue;
190  }
191 
192  /* is constraint of type SCIP_CONSTYPE_{SETPARTITION, SETPACKING, SETCOVERING, CARDINALITY, INVKNAPSACK}? */
193  {
194  SCIP_Real scale;
195  SCIP_Real b;
196  SCIP_Bool unmatched;
197  int nnegbinvars;
198 
199  unmatched = FALSE;
200  nnegbinvars = 0;
201 
202  scale = REALABS(vals[0]);
203  for( i = 0; i < nvars && !unmatched; i++ )
204  {
205  unmatched = unmatched || SCIPvarGetType(vars[i]) == SCIP_VARTYPE_CONTINUOUS;
206  unmatched = unmatched || SCIPisLE(scip, SCIPvarGetLbGlobal(vars[i]), -1.0);
207  unmatched = unmatched || SCIPisGE(scip, SCIPvarGetUbGlobal(vars[i]), 2.0);
208  unmatched = unmatched || !SCIPisEQ(scip, REALABS(vals[i]), scale);
209 
210  if( vals[i] < 0.0 )
211  nnegbinvars++;
212  }
213 
214  if( !unmatched )
215  {
216  if( SCIPisEQ(scip, lhs, rhs) )
217  {
218  b = rhs/scale + nnegbinvars;
219  if( SCIPisEQ(scip, 1.0, b) )
220  {
221  SCIPdebugMsg(scip, "classified as SETPARTITION: ");
222  SCIPdebugPrintCons(scip, cons, NULL);
223  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_SETPARTITION] += 1 ;
224  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_SETPARTITION]++;
225  classforcons[c] = SCIP_CONSTYPE_SETPARTITION;
226  SCIPfreeBufferArray(scip, &vars) ;
227  SCIPfreeBufferArray(scip, &vals) ;
228  continue;
229  }
230  else if( SCIPisIntegral(scip, b) && !SCIPisNegative(scip, b) )
231  {
232  SCIPdebugMsg(scip, "classified as CARDINALITY: ");
233  SCIPdebugPrintCons(scip, cons, NULL);
234  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_CARDINALITY] += 1 ;
235  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_CARDINALITY]++;
236  classforcons[c] = SCIP_CONSTYPE_CARDINALITY;
237  SCIPfreeBufferArray(scip, &vars);
238  SCIPfreeBufferArray(scip, &vals);
239  continue;
240  }
241  }
242 
243  b = rhs/scale + nnegbinvars;
244  if( SCIPisEQ(scip, 1.0, b) )
245  {
246  SCIPdebugMsg(scip, "classified as SETPACKING: ");
247  SCIPdebugPrintCons(scip, cons, NULL);
248  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_SETPACKING] += 1 ;
249  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_SETPACKING]++;
250  classforcons[c] = SCIP_CONSTYPE_SETPACKING;
251  rhs = SCIPinfinity(scip);
252  }
253  else if( SCIPisIntegral(scip, b) && !SCIPisNegative(scip, b) )
254  {
255  SCIPdebugMsg(scip, "classified as INVKNAPSACK: ");
256  SCIPdebugPrintCons(scip, cons, NULL);
257  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_INVKNAPSACK] += 1 ;
258  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_INVKNAPSACK]++;
259  classforcons[c] = SCIP_CONSTYPE_INVKNAPSACK;
260  rhs = SCIPinfinity(scip);
261  }
262 
263  b = lhs/scale + nnegbinvars;
264  if( SCIPisEQ(scip, 1.0, b) )
265  {
266  SCIPdebugMsg(scip, "classified as SETCOVERING: ");
267  SCIPdebugPrintCons(scip, cons, NULL);
268  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_SETCOVERING] += 1 ;
269  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_SETCOVERING]++;
270  classforcons[c] = SCIP_CONSTYPE_SETCOVERING;
271  lhs = -SCIPinfinity(scip);
272  }
273 
274  if( SCIPisInfinity(scip, -lhs) && SCIPisInfinity(scip, rhs) )
275  {
276  SCIPfreeBufferArray(scip, &vars);
277  SCIPfreeBufferArray(scip, &vals);
278  continue;
279  }
280  }
281  }
282 
283  /* is constraint of type SCIP_CONSTYPE_{EQKNAPSACK, BINPACKING, KNAPSACK}? */
284  /* @todo If coefficients or rhs are not integral, we currently do not check
285  * if the constraint could be scaled (finitely), such that they are.
286  */
287  {
288  SCIP_Real b;
289  SCIP_Bool unmatched;
290 
291  b = rhs;
292  unmatched = FALSE;
293  for( i = 0; i < nvars && !unmatched; i++ )
294  {
295  unmatched = unmatched || SCIPvarGetType(vars[i]) == SCIP_VARTYPE_CONTINUOUS;
296  unmatched = unmatched || SCIPisLE(scip, SCIPvarGetLbGlobal(vars[i]), -1.0);
297  unmatched = unmatched || SCIPisGE(scip, SCIPvarGetUbGlobal(vars[i]), 2.0);
298  unmatched = unmatched || !SCIPisIntegral(scip, vals[i]);
299 
300  if( SCIPisNegative(scip, vals[i]) )
301  b -= vals[i];
302  }
303  unmatched = unmatched || !detprobdata->isFiniteNonnegativeIntegral(scip, b);
304 
305  if( !unmatched )
306  {
307  if( SCIPisEQ(scip, lhs, rhs) )
308  {
309  SCIPdebugMsg(scip, "classified as EQKNAPSACK: ");
310  SCIPdebugPrintCons(scip, cons, NULL);
311  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_EQKNAPSACK] += 1 ;
312  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_EQKNAPSACK]++;
313  classforcons[c] = SCIP_CONSTYPE_EQKNAPSACK;
314  SCIPfreeBufferArray(scip, &vars);
315  SCIPfreeBufferArray(scip, &vals);
316  continue;
317  }
318  else
319  {
320  SCIP_Bool matched;
321 
322  matched = FALSE;
323  for( i = 0; i < nvars && !matched; i++ )
324  {
325  matched = matched || SCIPisEQ(scip, b, REALABS(vals[i]));
326  }
327 
328  SCIPdebugMsg(scip, "classified as %s: ", matched ? "BINPACKING" : "KNAPSACK");
329  SCIPdebugPrintCons(scip, cons, NULL);
330  nfoundconstypesrangeddoublecount[matched ? SCIP_CONSTYPE_BINPACKING : SCIP_CONSTYPE_KNAPSACK] += 1 ;
331  nfoundconstypesrangedsinglecount[matched ? SCIP_CONSTYPE_BINPACKING : SCIP_CONSTYPE_KNAPSACK]++;
332  classforcons[c] = matched ? SCIP_CONSTYPE_BINPACKING : SCIP_CONSTYPE_KNAPSACK;
333 
334  }
335 
336  if( SCIPisInfinity(scip, -lhs) )
337  {
338  SCIPfreeBufferArray(scip, &vars);
339  SCIPfreeBufferArray(scip, &vals);
340  continue;
341  }
342  else
343  rhs = SCIPinfinity(scip);
344  }
345  }
346 
347  /* is constraint of type SCIP_CONSTYPE_{INTKNAPSACK}? */
348  {
349  SCIP_Real b;
350  SCIP_Bool unmatched;
351 
352  unmatched = FALSE;
353 
354  b = rhs;
355  unmatched = unmatched || !detprobdata->isFiniteNonnegativeIntegral(scip, b);
356 
357  for( i = 0; i < nvars && !unmatched; i++ )
358  {
359  unmatched = unmatched || SCIPvarGetType(vars[i]) == SCIP_VARTYPE_CONTINUOUS;
360  unmatched = unmatched || SCIPisNegative(scip, SCIPvarGetLbGlobal(vars[i]));
361  unmatched = unmatched || !SCIPisIntegral(scip, vals[i]);
362  unmatched = unmatched || SCIPisNegative(scip, vals[i]);
363  }
364 
365  if( !unmatched )
366  {
367  SCIPdebugMsg(scip, "classified as INTKNAPSACK: ");
368  SCIPdebugPrintCons(scip, cons, NULL);
369  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_INTKNAPSACK] += 1 ;
370  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_INTKNAPSACK]++;
371  classforcons[c] = SCIP_CONSTYPE_INTKNAPSACK;
372 
373  if( SCIPisInfinity(scip, -lhs) )
374  {
375  SCIPfreeBufferArray(scip, &vars);
376  SCIPfreeBufferArray(scip, &vals);
377  continue;
378  }
379  else
380  rhs = SCIPinfinity(scip);
381  }
382  }
383 
384  /* is constraint of type SCIP_CONSTYPE_{MIXEDBINARY}? */
385  {
386  SCIP_Bool unmatched;
387 
388  unmatched = FALSE;
389  for( i = 0; i < nvars && !unmatched; i++ )
390  {
391  if( SCIPvarGetType(vars[i]) != SCIP_VARTYPE_CONTINUOUS
392  && (SCIPisLE(scip, SCIPvarGetLbGlobal(vars[i]), -1.0)
393  || SCIPisGE(scip, SCIPvarGetUbGlobal(vars[i]), 2.0)) )
394  unmatched = TRUE;
395  }
396 
397  if( !unmatched )
398  {
399  SCIPdebugMsg(scip, "classified as MIXEDBINARY (%d): ", detprobdata->isRangedRow(scip, lhs, rhs) ? 2 : 1);
400  SCIPdebugPrintCons(scip, cons, NULL);
401  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_MIXEDBINARY] += 1 ;
402  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_MIXEDBINARY]++;
403  classforcons[c] = SCIP_CONSTYPE_MIXEDBINARY;
404  SCIPfreeBufferArray(scip, &vars) ;
405  SCIPfreeBufferArray(scip, &vals) ;
406  continue;
407 
408  }
409  }
410 
411  /* no special structure detected */
412  SCIPdebugMsg(scip, "classified as GENERAL: ");
413  SCIPdebugPrintCons(scip, cons, NULL);
414  nfoundconstypesrangeddoublecount[SCIP_CONSTYPE_GENERAL] += 1 ;
415  nfoundconstypesrangedsinglecount[SCIP_CONSTYPE_GENERAL]++;
416  classforcons[c] = SCIP_CONSTYPE_GENERAL;
417  SCIPfreeBufferArray(scip, &vars);
418  SCIPfreeBufferArray(scip, &vals);
419  }
420 
421  classifier = new gcg::ConsPartition(scip, "constypes according to miplib", (int) SCIP_CONSTYPE_GENERAL + 1, detprobdata->getNConss() );
422 
423  /* set class names and descriptions of every class */
424  for( int c = 0; c < classifier->getNClasses(); ++ c )
425  {
426  std::string name;
427  std::stringstream text;
428  switch( c )
429  {
430  case (int) SCIP_CONSTYPE_EMPTY:
431  name = "empty";
432  break;
433  case SCIP_CONSTYPE_FREE:
434  name = "free";
435  break;
436  case SCIP_CONSTYPE_SINGLETON:
437  name = "singleton";
438  break;
439  case SCIP_CONSTYPE_AGGREGATION:
440  name = "aggregation";
441  break;
442  case SCIP_CONSTYPE_VARBOUND:
443  name = "varbound";
444  break;
445  case SCIP_CONSTYPE_SETPARTITION:
446  name = "setpartition";
447  break;
448  case SCIP_CONSTYPE_SETPACKING:
449  name = "setpacking";
450  break;
451  case SCIP_CONSTYPE_SETCOVERING:
452  name = "setcovering";
453  break;
454  case SCIP_CONSTYPE_CARDINALITY:
455  name = "cardinality";
456  break;
457  case SCIP_CONSTYPE_INVKNAPSACK:
458  name = "invknapsack";
459  break;
460  case SCIP_CONSTYPE_EQKNAPSACK:
461  name = "eqknapsack";
462  break;
463  case SCIP_CONSTYPE_BINPACKING:
464  name = "binpacking";
465  break;
466  case SCIP_CONSTYPE_KNAPSACK:
467  name = "knapsack";
468  break;
469  case SCIP_CONSTYPE_INTKNAPSACK:
470  name = "intknapsack";
471  break;
472  case SCIP_CONSTYPE_MIXEDBINARY:
473  name = "mixed binary";
474  break;
475  case SCIP_CONSTYPE_GENERAL:
476  name = "general";
477  break;
478  default:
479  name = "unknown";
480  break;
481  }
482 
483 
484 #ifdef WRITE_ORIG_CONSTYPES
485  myfile << " " << nfoundconstypesrangeddoublecount[c] << ",";
486 #endif
487 
488  classifier->setClassName( c, name.c_str() );
489  text << "This class contains all constraints that are of (miplib) constype \"" << name << "\".";
490  classifier->setClassDescription( c, text.str().c_str() );
491  }
492 
493 #ifdef WRITE_ORIG_CONSTYPES
494  myfile << std::endl;
495  myfile.close();
496 #endif
497 
498 
499 
500  for( int i = 0; i < classifier->getNConss(); ++ i )
501  {
502  classifier->assignConsToClass( i, classforcons[i] );
503  }
504 
505 
506 
507  classifier->removeEmptyClasses();
508  SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL, " Consclassifier \"%s\" yields a classification with %d different constraint classes \n", classifier->getName(), classifier->getNClasses() );
509 
510  detprobdata->addConsPartition(classifier);
511  return SCIP_OKAY;
512 }
513 
514 /*
515  * classifier specific interface methods
516  */
517 
518 SCIP_RETCODE SCIPincludeConsClassifierMiplibConstypes(
519  SCIP* scip /**< SCIP data structure */
520 ) {
521  DEC_CLASSIFIERDATA* classifierdata = NULL;
522 
523  SCIP_CALL(
524  DECincludeConsClassifier(scip, DEC_CLASSIFIERNAME, DEC_DESC, DEC_PRIORITY, DEC_ENABLED, classifierdata,
525  classifierFree, classifierClassify));
526 
527  return SCIP_OKAY;
528 }
DEC_PRIORITY
#define DEC_PRIORITY
Definition: clscons_miplibconstypes.cpp:50
gcg::DETPROBDATA::getNConss
int getNConss()
returns the number of variables considered in the detprobdata
Definition: class_detprobdata.cpp:796
GCGconsGetRhs
SCIP_Real GCGconsGetRhs(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:108
clscons_miplibconstypes.h
classifies constraints according to their miplib constypes
gcg::IndexPartition::setClassDescription
void setClassDescription(int classindex, const char *desc)
Definition: class_indexpartition.cpp:365
SCIP_CONSTYPE_SETCOVERING
@ SCIP_CONSTYPE_SETCOVERING
Definition: class_detprobdata.h:71
GCGconsGetLhs
SCIP_Real GCGconsGetLhs(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:206
SCIP_CONSTYPE_BINPACKING
@ SCIP_CONSTYPE_BINPACKING
Definition: class_detprobdata.h:75
SCIP_CONSTYPE_VARBOUND
@ SCIP_CONSTYPE_VARBOUND
Definition: class_detprobdata.h:68
cons_decomp.h
constraint handler for structure detection
gcg::ConsPartition::assignConsToClass
void assignConsToClass(int consindex, int classindex)
Definition: class_conspartition.cpp:80
DEC_DECL_CONSCLASSIFY
static DEC_DECL_CONSCLASSIFY(classifierClassify)
Definition: clscons_miplibconstypes.cpp:80
class_conspartition.h
class representing a partition of a set of constraints
GCGconsGetVars
SCIP_RETCODE GCGconsGetVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int nvars)
Definition: scip_misc.c:490
SCIP_CONSTYPE_SINGLETON
@ SCIP_CONSTYPE_SINGLETON
Definition: class_detprobdata.h:66
GCGconshdlrDecompGetDetprobdataOrig
DETPROBDATA * GCGconshdlrDecompGetDetprobdataOrig(SCIP *scip)
help method to access detprobdata for unpresolved problem
Definition: cons_decomp.cpp:5249
SCIP_CONSTYPE_INVKNAPSACK
@ SCIP_CONSTYPE_INVKNAPSACK
Definition: class_detprobdata.h:73
SCIP_CONSTYPE_MIXEDBINARY
@ SCIP_CONSTYPE_MIXEDBINARY
Definition: class_detprobdata.h:78
scip_misc.h
various SCIP helper methods
DEC_ClassifierData
Definition: clscons_consnamelevenshtein.cpp:62
SCIP_CONSTYPE_AGGREGATION
@ SCIP_CONSTYPE_AGGREGATION
Definition: class_detprobdata.h:67
SCIPincludeConsClassifierMiplibConstypes
SCIP_RETCODE SCIPincludeConsClassifierMiplibConstypes(SCIP *scip)
Definition: clscons_miplibconstypes.cpp:518
DEC_ENABLED
#define DEC_ENABLED
Definition: clscons_miplibconstypes.cpp:52
gcg::DETPROBDATA::getCons
SCIP_CONS * getCons(int consIndex)
returns the SCIP constraint related to a constraint index
Definition: class_detprobdata.cpp:698
gcg::IndexPartition::setClassName
void setClassName(int classindex, const char *name)
Definition: class_indexpartition.cpp:373
DEC_DESC
#define DEC_DESC
Definition: clscons_miplibconstypes.cpp:49
SCIP_CONSTYPE_INTKNAPSACK
@ SCIP_CONSTYPE_INTKNAPSACK
Definition: class_detprobdata.h:77
cons_decomp.hpp
C++ interface of cons_decomp.
SCIP_CONSTYPE_EQKNAPSACK
@ SCIP_CONSTYPE_EQKNAPSACK
Definition: class_detprobdata.h:74
SCIP_CONSTYPE_EMPTY
@ SCIP_CONSTYPE_EMPTY
Definition: class_detprobdata.h:64
SCIP_CONSTYPE_SETPARTITION
@ SCIP_CONSTYPE_SETPARTITION
Definition: class_detprobdata.h:69
GCGconsGetVals
SCIP_RETCODE GCGconsGetVals(SCIP *scip, SCIP_CONS *cons, SCIP_Real *vals, int nvals)
Definition: scip_misc.c:621
SCIP_CONSTYPE_KNAPSACK
@ SCIP_CONSTYPE_KNAPSACK
Definition: class_detprobdata.h:76
GCGconsGetNVars
int GCGconsGetNVars(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:434
SCIP_CONSTYPE_GENERAL
@ SCIP_CONSTYPE_GENERAL
Definition: class_detprobdata.h:79
gcg::DETPROBDATA::isFiniteNonnegativeIntegral
SCIP_Bool isFiniteNonnegativeIntegral(SCIP *scip, SCIP_Real x)
is constraint ranged row, i.e., -inf < lhs < rhs < inf?
Definition: class_detprobdata.cpp:1079
classifierFree
#define classifierFree
Definition: clscons_miplibconstypes.cpp:77
gcg::DETPROBDATA::isRangedRow
SCIP_Bool isRangedRow(SCIP *scip, SCIP_Real lhs, SCIP_Real rhs)
is constraint ranged row, i.e., -inf < lhs < rhs < inf?
Definition: class_detprobdata.cpp:1104
SCIP_CONSTYPE_SETPACKING
@ SCIP_CONSTYPE_SETPACKING
Definition: class_detprobdata.h:70
DEC_CLASSIFIERNAME
#define DEC_CLASSIFIERNAME
Definition: clscons_miplibconstypes.cpp:48
GCGconshdlrDecompGetDetprobdataPresolved
DETPROBDATA * GCGconshdlrDecompGetDetprobdataPresolved(SCIP *scip)
help method to access detprobdata for transformed problem
Definition: cons_decomp.cpp:5263
SCIP_CONSTYPE_FREE
@ SCIP_CONSTYPE_FREE
Definition: class_detprobdata.h:65
SCIP_CONSTYPE_CARDINALITY
@ SCIP_CONSTYPE_CARDINALITY
Definition: class_detprobdata.h:72
gcg::DETPROBDATA::addConsPartition
void addConsPartition(ConsPartition *partition)
adds a constraint partition if it is no duplicate of an existing constraint partition
Definition: class_detprobdata.cpp:505
DECincludeConsClassifier
SCIP_RETCODE DECincludeConsClassifier(SCIP *scip, const char *name, const char *description, int priority, SCIP_Bool enabled, DEC_CLASSIFIERDATA *classifierdata, DEC_DECL_FREECONSCLASSIFIER((*freeClassifier)),)
Definition: cons_decomp.cpp:2992
class_detprobdata.h
class storing partialdecs and the problem matrix