scip_misc.c
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-2018 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 
33 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34 
35 #include "scip_misc.h"
36 #include "scip/scipdefplugins.h"
37 #include <string.h>
38 #include "scip/cons_indicator.h"
39 
41 SCIP_Bool GCGisVarRelevant(
42  SCIP_VAR* var
43  )
44 {
45  assert(var != NULL);
46  return (SCIPvarGetStatus(var) != SCIP_VARSTATUS_FIXED)
47  && (SCIPvarIsActive(var) || SCIPvarGetStatus(var) == SCIP_VARSTATUS_AGGREGATED || SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR || SCIPvarGetStatus(var) == SCIP_VARSTATUS_NEGATED);
48 }
49 
52  SCIP_CONS* cons
53  )
54 {
55  SCIP_CONSHDLR* conshdlr;
56  const char * conshdlrname;
57  assert(cons != NULL);
58  conshdlr = SCIPconsGetHdlr(cons);
59  assert(conshdlr != NULL);
60  conshdlrname = SCIPconshdlrGetName(conshdlr);
61 
62  if( strcmp(conshdlrname, "linear") == 0 )
63  {
64  return linear;
65  }
66  else if( strcmp(conshdlrname, "setppc") == 0 )
67  {
68  switch ( SCIPgetTypeSetppc(NULL, cons) ) {
69  case SCIP_SETPPCTYPE_COVERING:
70  return setcovering;
71  case SCIP_SETPPCTYPE_PACKING:
72  return setpacking;
73  case SCIP_SETPPCTYPE_PARTITIONING:
74  return setpartitioning;
75  default:
76  return unknown;
77  }
78  }
79  else if( strcmp(conshdlrname, "logicor") == 0 )
80  {
81  return logicor;
82  }
83  else if( strcmp(conshdlrname, "knapsack") == 0 )
84  {
85  return knapsack;
86  }
87  else if( strcmp(conshdlrname, "varbound") == 0 )
88  {
89  return varbound;
90  }
91  else if( strcmp(conshdlrname, "SOS1") == 0 )
92  {
93  return sos1;
94  }
95  else if( strcmp(conshdlrname, "SOS2") == 0 )
96  {
97  return sos2;
98  }
99  else if( strcmp(conshdlrname, "indicator") == 0 )
100  {
101  return sos2;
102  }
103  return unknown;
104 }
105 
107 SCIP_Real GCGconsGetRhs(
108  SCIP* scip,
109  SCIP_CONS* cons
110  )
111 {
112  int nconsvars;
113  SCIP_VAR** consvars;
114  SCIP_CONSHDLR* conshdlr;
115  const char * conshdlrname;
116  SCIP_Longint * w;
117  SCIP_Real rhs;
118  int i;
119 
120  assert(scip != NULL);
121  assert(cons != NULL);
122  conshdlr = SCIPconsGetHdlr(cons);
123  assert(conshdlr != NULL);
124  conshdlrname = SCIPconshdlrGetName(conshdlr);
125 
126  if( strcmp(conshdlrname, "linear") == 0 )
127  {
128  return SCIPgetRhsLinear(scip, cons);
129  }
130  else if( strcmp(conshdlrname, "setppc") == 0 )
131  {
132  switch ( SCIPgetTypeSetppc(scip, cons) ) {
133  case SCIP_SETPPCTYPE_PARTITIONING: /* fall through desired */
134  case SCIP_SETPPCTYPE_PACKING:
135  rhs = 1.0;
136 
137  nconsvars = SCIPgetNVarsSetppc(scip, cons);
138  consvars = SCIPgetVarsSetppc(scip, cons);
139 
140  for( i = 0; i < nconsvars; i++ )
141  {
142  if( SCIPvarIsNegated(consvars[i]) )
143  rhs -= 1.0;
144  }
145 
146  return rhs;
147 
148  case SCIP_SETPPCTYPE_COVERING:
149  return SCIPinfinity(scip);
150  }
151  }
152  else if( strcmp(conshdlrname, "logicor") == 0 )
153  {
154  return SCIPinfinity(scip);
155  }
156  else if( strcmp(conshdlrname, "knapsack") == 0 )
157  {
158  rhs = SCIPgetCapacityKnapsack(scip, cons);
159 
160  /* copy Longint array to SCIP_Real array */
161  w = SCIPgetWeightsKnapsack(scip, cons);
162  consvars = SCIPgetVarsKnapsack(scip, cons);
163  nconsvars = SCIPgetNVarsKnapsack(scip, cons);
164 
165  for( i = 0; i < nconsvars; i++ )
166  {
167  if( SCIPvarIsNegated(consvars[i]) )
168  rhs -= w[i];
169  }
170 
171  return rhs;
172  }
173  else if( strcmp(conshdlrname, "varbound") == 0 )
174  {
175  rhs = SCIPgetRhsVarbound(scip, cons);
176 
177  if( SCIPvarIsNegated(SCIPgetVarVarbound(scip, cons)) && !SCIPisInfinity(scip, rhs) )
178  rhs -= 1.0;
179 
180  if( SCIPvarIsNegated(SCIPgetVbdvarVarbound(scip, cons)) && !SCIPisInfinity(scip, rhs) )
181  rhs -= SCIPgetVbdcoefVarbound(scip, cons);
182 
183  return rhs;
184  }
185  else if( strcmp(conshdlrname, "SOS1") == 0 )
186  {
187  SCIPdebugMessage("WARNING: SOS1 NOT IMPLEMENTED\n");
188  }
189  else if( strcmp(conshdlrname, "SOS2") == 0 )
190  {
191  SCIPdebugMessage("WARNING: SOS2 NOT IMPLEMENTED\n");
192  }
193  else if( strcmp(conshdlrname, "indicator") == 0 )
194  {
195  return 0.;
196  }
197  else
198  {
199  SCIPdebugMessage("WARNING: NOT IMPLEMENTED");
200  }
201  return -SCIPinfinity(scip);
202 }
203 
205 SCIP_Real GCGconsGetLhs(
206  SCIP* scip,
207  SCIP_CONS* cons
208  )
209 {
210  SCIP_CONSHDLR* conshdlr;
211  const char * conshdlrname;
212  int nconsvars;
213  SCIP_VAR** consvars;
214  SCIP_Real lhs;
215  int i;
216 
217 
218  assert(scip != NULL);
219  assert(cons != NULL);
220  conshdlr = SCIPconsGetHdlr(cons);
221  assert(conshdlr != NULL);
222  conshdlrname = SCIPconshdlrGetName(conshdlr);
223 
224  if( strcmp(conshdlrname, "linear") == 0 )
225  {
226  return SCIPgetLhsLinear(scip, cons);
227  }
228  else if( strcmp(conshdlrname, "setppc") == 0 )
229  {
230  switch ( SCIPgetTypeSetppc(scip, cons) ) {
231  case SCIP_SETPPCTYPE_PARTITIONING: /* fall through desired */
232  case SCIP_SETPPCTYPE_COVERING:
233  lhs = 1.0;
234 
235  nconsvars = SCIPgetNVarsSetppc(scip, cons);
236  consvars = SCIPgetVarsSetppc(scip, cons);
237 
238  for( i = 0; i < nconsvars; i++ )
239  {
240  if( SCIPvarIsNegated(consvars[i]) )
241  lhs -= 1.0;
242  }
243 
244  return lhs;
245 
246  case SCIP_SETPPCTYPE_PACKING:
247  return -SCIPinfinity(scip);
248  }
249  }
250  else if( strcmp(conshdlrname, "logicor") == 0 )
251  {
252  lhs = 1.0;
253 
254  nconsvars = SCIPgetNVarsLogicor(scip, cons);
255  consvars = SCIPgetVarsLogicor(scip, cons);
256 
257  for( i = 0; i < nconsvars; i++ )
258  {
259  if( SCIPvarIsNegated(consvars[i]) )
260  lhs -= 1.0;
261  }
262 
263  return lhs;
264  }
265  else if( strcmp(conshdlrname, "knapsack") == 0 )
266  {
267  return -SCIPinfinity(scip);
268  }
269  else if( strcmp(conshdlrname, "varbound") == 0 )
270  {
271  lhs = SCIPgetLhsVarbound(scip, cons);
272 
273  if( SCIPvarIsNegated(SCIPgetVarVarbound(scip, cons)) && !SCIPisInfinity(scip, -lhs) )
274  lhs -= 1.0;
275 
276  if( SCIPvarIsNegated(SCIPgetVbdvarVarbound(scip, cons)) && !SCIPisInfinity(scip, -lhs) )
277  lhs -= SCIPgetVbdcoefVarbound(scip, cons);
278 
279  return lhs;
280  }
281  else if( strcmp(conshdlrname, "SOS1") == 0 )
282  {
283  SCIPdebugMessage("WARNING: SOS1 NOT IMPLEMENTED\n");
284  }
285  else if( strcmp(conshdlrname, "SOS2") == 0 )
286  {
287  SCIPdebugMessage("WARNING: SOS2 NOT IMPLEMENTED\n");
288  }
289  else if( strcmp(conshdlrname, "indicator") == 0 )
290  {
291  return -SCIPinfinity(scip);
292  }
293  else
294  {
295  SCIPdebugMessage("WARNING: NOT IMPLEMENTED");
296  }
297  return SCIPinfinity(scip);
298 }
299 
301 extern
303  SCIP* scip,
304  SCIP_CONS* cons
305  )
306 {
307  SCIP_CONSHDLR* conshdlr;
308  const char * conshdlrname;
309 
310  assert(scip != NULL);
311  assert(cons != NULL);
312  conshdlr = SCIPconsGetHdlr(cons);
313  assert(conshdlr != NULL);
314  conshdlrname = SCIPconshdlrGetName(conshdlr);
315 
316  if( strcmp(conshdlrname, "linear") == 0 )
317  {
318  return SCIPgetDualfarkasLinear(scip, cons);
319  }
320  else if( strcmp(conshdlrname, "setppc") == 0 )
321  {
322  return SCIPgetDualfarkasSetppc(scip, cons);
323  }
324  else if( strcmp(conshdlrname, "logicor") == 0 )
325  {
326  return SCIPgetDualfarkasLogicor(scip, cons);
327  }
328  else if( strcmp(conshdlrname, "knapsack") == 0 )
329  {
330  return SCIPgetDualfarkasKnapsack(scip, cons);
331  }
332  else if( strcmp(conshdlrname, "varbound") == 0 )
333  {
334  return SCIPgetDualfarkasVarbound(scip, cons);
335  }
336  else if( strcmp(conshdlrname, "SOS1") == 0 )
337  {
338  SCIPdebugMessage("WARNING: SOS1 NOT IMPLEMENTED\n");
339  }
340  else if( strcmp(conshdlrname, "SOS2") == 0 )
341  {
342  SCIPdebugMessage("WARNING: SOS2 NOT IMPLEMENTED\n");
343  }
344  else if( strcmp(conshdlrname, "origbranch") == 0 )
345  {
346  SCIPdebugMessage("origbranch: return dualfarkas 0\n");
347  return 0.0;
348  }
349  else if( strcmp(conshdlrname, "masterbranch") == 0 )
350  {
351  SCIPdebugMessage("masterbranch: return dualsol 0\n");
352  return 0.0;
353  }
354  else if( strcmp(conshdlrname, "indicator") == 0 )
355  {
356  SCIPdebugMessage("WARNING: indicator conss NOT IMPLEMENTED");
357  }
358  else
359  {
360  SCIPdebugMessage("WARNING: NOT IMPLEMENTED");
361  }
362  return SCIPinfinity(scip);
363 }
364 
366 extern
368  SCIP* scip,
369  SCIP_CONS* cons
370  )
371 {
372  SCIP_CONSHDLR* conshdlr;
373  const char * conshdlrname;
374 
375  assert(scip != NULL);
376  assert(cons != NULL);
377  conshdlr = SCIPconsGetHdlr(cons);
378  assert(conshdlr != NULL);
379  conshdlrname = SCIPconshdlrGetName(conshdlr);
380 
381  if( strcmp(conshdlrname, "linear") == 0 )
382  {
383  return SCIPgetDualsolLinear(scip, cons);
384  }
385  else if( strcmp(conshdlrname, "setppc") == 0 )
386  {
387  return SCIPgetDualsolSetppc(scip, cons);
388  }
389  else if( strcmp(conshdlrname, "logicor") == 0 )
390  {
391  return SCIPgetDualsolLogicor(scip, cons);
392  }
393  else if( strcmp(conshdlrname, "knapsack") == 0 )
394  {
395  return SCIPgetDualsolKnapsack(scip, cons);
396  }
397  else if( strcmp(conshdlrname, "varbound") == 0 )
398  {
399  return SCIPgetDualsolVarbound(scip, cons);
400  }
401  else if( strcmp(conshdlrname, "SOS1") == 0 )
402  {
403  SCIPdebugMessage("WARNING: SOS1 NOT IMPLEMENTED\n");
404  }
405  else if( strcmp(conshdlrname, "SOS2") == 0 )
406  {
407  SCIPdebugMessage("WARNING: SOS2 NOT IMPLEMENTED\n");
408  }
409  else if( strcmp(conshdlrname, "origbranch") == 0 )
410  {
411  SCIPdebugMessage("origbranch: return Dualsol 0\n");
412  return 0.0;
413  }
414  else if( strcmp(conshdlrname, "masterbranch") == 0 )
415  {
416  SCIPdebugMessage("masterbranch: return dualsol 0\n");
417  return 0.0;
418  }
419  else if( strcmp(conshdlrname, "indicator") == 0 )
420  {
421  SCIPdebugMessage("WARNING: indicator conss NOT IMPLEMENTED");
422  }
423  else
424  {
425  SCIPdebugMessage("WARNING: NOT IMPLEMENTED");
426  }
427  return SCIPinfinity(scip);
428 }
429 
430 
431 
434  SCIP* scip,
435  SCIP_CONS* cons
436  )
437 {
438  SCIP_CONSHDLR* conshdlr;
439  const char * conshdlrname;
440 
441  assert(scip != NULL);
442  assert(cons != NULL);
443  conshdlr = SCIPconsGetHdlr(cons);
444  assert(conshdlr != NULL);
445  conshdlrname = SCIPconshdlrGetName(conshdlr);
446 
447 
448 
449  if( strcmp(conshdlrname, "linear") == 0 )
450  {
451  return SCIPgetNVarsLinear(scip, cons);
452  }
453  else if( strcmp(conshdlrname, "setppc") == 0 )
454  {
455  return SCIPgetNVarsSetppc(scip, cons);
456  }
457  else if( strcmp(conshdlrname, "logicor") == 0 )
458  {
459  return SCIPgetNVarsLogicor(scip, cons);
460  }
461  else if( strcmp(conshdlrname, "knapsack") == 0 )
462  {
463  return SCIPgetNVarsKnapsack(scip, cons);
464  }
465  else if( strcmp(conshdlrname, "varbound") == 0 )
466  {
467  return 2;
468  }
469  else if( strcmp(conshdlrname, "indicator") == 0 )
470  {
471  return 2;
472  }
473  else if( strcmp(conshdlrname, "SOS1") == 0 )
474  {
475  return SCIPgetNVarsSOS1(scip, cons);
476  }
477  else if( strcmp(conshdlrname, "SOS2") == 0 )
478  {
479  return SCIPgetNVarsSOS2(scip, cons);
480  }
481  else
482  {
483  SCIPdebugMessage("WARNING: NOT IMPLEMENTED <%s>\n", conshdlrname);
484  return 0;
485  }
486 }
487 
489 SCIP_RETCODE GCGconsGetVars(
490  SCIP* scip,
491  SCIP_CONS* cons,
492  SCIP_VAR** vars,
493  int nvars
494  )
495 {
496 
497  SCIP_CONSHDLR* conshdlr;
498  const char * conshdlrname;
499  int i;
500 
501  assert(scip != NULL);
502  assert(cons != NULL);
503  assert(vars != NULL);
504  assert(nvars > 0);
505 
506  conshdlr = SCIPconsGetHdlr(cons);
507  assert(conshdlr != NULL);
508  conshdlrname = SCIPconshdlrGetName(conshdlr);
509 
510  if( strcmp(conshdlrname, "linear") == 0 )
511  {
512  if( nvars < SCIPgetNVarsLinear(scip, cons) )
513  return SCIP_INVALIDDATA;
514 
515  BMScopyMemoryArray(vars, SCIPgetVarsLinear(scip, cons), SCIPgetNVarsLinear(scip, cons));
516  }
517  else if( strcmp(conshdlrname, "setppc") == 0 )
518  {
519  SCIP_VAR** consvars;
520  int nconsvars;
521 
522  consvars = SCIPgetVarsSetppc(scip, cons);
523  nconsvars = SCIPgetNVarsSetppc(scip, cons);
524 
525  if( nvars < nconsvars )
526  return SCIP_INVALIDDATA;
527 
528  for( i = 0; i < nconsvars; i++ )
529  if( !SCIPvarIsNegated(consvars[i]) )
530  vars[i] = consvars[i];
531  else
532  vars[i] = SCIPvarGetNegatedVar(consvars[i]);
533  }
534  else if( strcmp(conshdlrname, "logicor") == 0 )
535  {
536  SCIP_VAR** consvars;
537  int nconsvars;
538 
539  consvars = SCIPgetVarsLogicor(scip, cons);
540  nconsvars = SCIPgetNVarsLogicor(scip, cons);
541 
542  if( nvars < nconsvars )
543  return SCIP_INVALIDDATA;
544 
545  for( i = 0; i < nconsvars; i++ )
546  if( !SCIPvarIsNegated(consvars[i]) )
547  vars[i] = consvars[i];
548  else
549  vars[i] = SCIPvarGetNegatedVar(consvars[i]);
550  }
551  else if( strcmp(conshdlrname, "knapsack") == 0 )
552  {
553  SCIP_VAR** consvars;
554  int nconsvars;
555 
556  consvars = SCIPgetVarsKnapsack(scip, cons);
557  nconsvars = SCIPgetNVarsKnapsack(scip, cons);
558 
559  if( nvars < nconsvars )
560  return SCIP_INVALIDDATA;
561 
562  for( i = 0; i < nconsvars; i++ )
563  if( !SCIPvarIsNegated(consvars[i]) )
564  vars[i] = consvars[i];
565  else
566  vars[i] = SCIPvarGetNegatedVar(consvars[i]);
567  }
568  else if( strcmp(conshdlrname, "varbound") == 0 )
569  {
570  if( nvars < 2 )
571  return SCIP_INVALIDDATA;
572 
573  if( !SCIPvarIsNegated(SCIPgetVarVarbound(scip, cons)) )
574  vars[0] = SCIPgetVarVarbound(scip, cons);
575  else
576  vars[0] = SCIPvarGetNegatedVar(SCIPgetVarVarbound(scip, cons));
577 
578  if( !SCIPvarIsNegated(SCIPgetVbdvarVarbound(scip, cons)) )
579  vars[1] = SCIPgetVbdvarVarbound(scip, cons);
580  else
581  vars[1] = SCIPvarGetNegatedVar(SCIPgetVbdvarVarbound(scip, cons));
582  }
583  else if( strcmp(conshdlrname, "SOS1") == 0 )
584  {
585  if( nvars < SCIPgetNVarsSOS1(scip, cons) )
586  return SCIP_INVALIDDATA;
587 
588  BMScopyMemoryArray(vars, SCIPgetVarsSOS1(scip, cons), nvars);
589  }
590  else if( strcmp(conshdlrname, "SOS2") == 0 )
591  {
592  if( nvars < SCIPgetNVarsSOS2(scip, cons) )
593  return SCIP_INVALIDDATA;
594 
595  BMScopyMemoryArray(vars, SCIPgetVarsSOS2(scip, cons), nvars);
596  }
597  else if( strcmp(conshdlrname, "indicator") == 0 )
598  {
599  if( nvars != 2 )
600  return SCIP_INVALIDDATA;
601 
605  vars[0] = SCIPgetSlackVarIndicator(cons);
606  vars[1] = SCIPgetBinaryVarIndicator(cons);
607  }
608  else
609  {
610  SCIPwarningMessage(scip, "WARNING: NOT IMPLEMENTED <%s>\n", conshdlrname);
611  }
612  return SCIP_OKAY;
613 }
614 
615 
620 SCIP_RETCODE GCGconsGetVals(
621  SCIP* scip,
622  SCIP_CONS* cons,
623  SCIP_Real* vals,
624  int nvals
625  )
626 {
627  SCIP_CONSHDLR* conshdlr;
628  const char* conshdlrname;
629  int i;
630  int nvars;
631 
632  assert(scip != NULL);
633  assert(cons != NULL);
634  assert(vals != NULL);
635  assert(nvals > 0);
636 
637  conshdlr = SCIPconsGetHdlr(cons);
638  assert(conshdlr != NULL);
639  conshdlrname = SCIPconshdlrGetName(conshdlr);
640 
641  if( strcmp(conshdlrname, "linear") == 0 )
642  {
643  nvars = SCIPgetNVarsLinear(scip, cons);
644  if( nvals < nvars )
645  return SCIP_INVALIDDATA;
646 
647  BMScopyMemoryArray(vals, SCIPgetValsLinear(scip, cons), nvars);
648  }
649  else if( strcmp(conshdlrname, "setppc") == 0 )
650  {
651  SCIP_VAR** vars;
652  vars = SCIPgetVarsSetppc(scip, cons);
653  nvars = SCIPgetNVarsSetppc(scip, cons);
654  if( nvals < nvars )
655  return SCIP_INVALIDDATA;
656 
657  for( i = 0; i < nvals; i++ )
658  if( !SCIPvarIsNegated(vars[i]) )
659  vals[i] = 1.0;
660  else
661  vals[i] = -1.0;
662  }
663  else if( strcmp(conshdlrname, "logicor") == 0 )
664  {
665  SCIP_VAR** vars;
666  vars = SCIPgetVarsLogicor(scip, cons);
667  nvars = SCIPgetNVarsLogicor(scip, cons);
668  if( nvals < nvars )
669  return SCIP_INVALIDDATA;
670 
671  for( i = 0; i < nvals; i++ )
672  {
673  if( !SCIPvarIsNegated(vars[i]) )
674  vals[i] = 1.0;
675  else
676  vals[i] = -1.0;
677  }
678  }
679  else if( strcmp(conshdlrname, "knapsack") == 0 )
680  {
681  SCIP_VAR** vars;
682 
683  /* copy Longint array to SCIP_Real array */
684  SCIP_Longint * w = SCIPgetWeightsKnapsack(scip, cons);
685  vars = SCIPgetVarsKnapsack(scip, cons);
686  nvars = SCIPgetNVarsKnapsack(scip, cons);
687  if( nvals < nvars )
688  return SCIP_INVALIDDATA;
689 
690  for( i = 0; i < nvars; i++ )
691  {
692  if( !SCIPvarIsNegated(vars[i]) )
693  vals[i] = w[i];
694  else
695  vals[i] = -w[i];
696  }
697  }
698  else if( strcmp(conshdlrname, "varbound") == 0 )
699  {
700  nvars = 2;
701  if( nvals < nvars )
702  return SCIP_INVALIDDATA;
703 
704  if( !SCIPvarIsNegated(SCIPgetVarVarbound(scip, cons)) )
705  vals[0] = 1.0;
706  else
707  vals[0] = -1.0;
708 
709  if( !SCIPvarIsNegated(SCIPgetVbdvarVarbound(scip, cons)) )
710  vals[1] = SCIPgetVbdcoefVarbound(scip, cons);
711  else
712  vals[1] = -SCIPgetVbdcoefVarbound(scip, cons);
713  }
714  else if( strcmp(conshdlrname, "SOS1") == 0 )
715  {
716  /* store constraint */
717  SCIPerrorMessage("WARNING: SOS1 NOT IMPLEMENTED\n");
718  }
719  else if( strcmp(conshdlrname, "SOS2") == 0 )
720  {
721  /* store constraint */
722  SCIPdebugMessage("WARNING: SOS2 NOT IMPLEMENTED\n");
723  }
724  else if( strcmp(conshdlrname, "indicator") == 0 )
725  {
726  if( nvals != 2 )
727  return SCIP_INVALIDDATA;
728 
732  vals[0] = 1.;
733  vals[1] = SCIPvarGetUbGlobal( SCIPgetSlackVarIndicator(cons) );
734  }
735  else
736  {
737  SCIPdebugMessage("WARNING: UNKNOWN NOT IMPLEMENTED: %s\n", conshdlrname);
738  }
739  return SCIP_OKAY;
740 }
741 
743 SCIP_Bool GCGconsIsRanged(
744  SCIP* scip,
745  SCIP_CONS* cons
746 ){
747 
748  SCIP_Real lhs;
749  SCIP_Real rhs;
750 
751  assert(scip != NULL);
752 
753  rhs = GCGconsGetRhs(scip, cons);
754  lhs = GCGconsGetLhs(scip, cons);
755 
756 
757  return !(SCIPisEQ(scip, lhs, rhs) || SCIPisInfinity(scip, -lhs) || SCIPisInfinity(scip, rhs) );
758 }
759 
760 
763  SCIP* scip,
764  SCIP_CONS* cons,
765  SCIP_SETPPCTYPE* setppctype
766  )
767 {
768  SCIP_VAR** vars;
769  SCIP_Real* vals;
770  int i;
771 
772  int nvars;
773  SCIP_Bool relevant = TRUE;
774  assert(scip != NULL);
775  assert(cons != NULL);
776  assert(setppctype != NULL);
777 
778  *setppctype = SCIP_SETPPCTYPE_PACKING;
779  SCIPdebugMessage("cons %s is ", SCIPconsGetName(cons));
780 
781  if( GCGconsGetType(cons) == setcovering || GCGconsGetType(cons) == setpartitioning || GCGconsGetType(cons) == logicor )
782  {
783  SCIPdebugPrintf("setcov, part or logicor.\n");
784  return TRUE;
785  }
786  nvars = GCGconsGetNVars(scip, cons);
787  vars = NULL;
788  vals = NULL;
789  if( nvars > 0 )
790  {
791  SCIP_CALL_ABORT( SCIPallocBufferArray(scip, &vars, nvars) );
792  SCIP_CALL_ABORT( SCIPallocBufferArray(scip, &vals, nvars) );
793  SCIP_CALL_ABORT( GCGconsGetVars(scip, cons, vars, nvars) );
794  SCIP_CALL_ABORT( GCGconsGetVals(scip, cons, vals, nvars) );
795  }
796 
797  /* check vars and vals for integrality */
798  for( i = 0; i < nvars && relevant; ++i )
799  {
800  assert(vars != NULL);
801  assert(vals != NULL);
802 
803  if( !SCIPvarIsBinary(vars[i]) )
804  {
805  SCIPdebugPrintf("(%s is not integral) ", SCIPvarGetName(vars[i]) );
806  relevant = FALSE;
807  }
808  if( !SCIPisEQ(scip, vals[i], 1.0) )
809  {
810  SCIPdebugPrintf("(coeff for var %s is %.2f != 1.0) ", SCIPvarGetName(vars[i]), vals[i] );
811  relevant = FALSE;
812  }
813  }
814 
815  if( relevant )
816  {
817  SCIP_Real rhs = GCGconsGetRhs(scip, cons);
818  SCIP_Real lhs = GCGconsGetLhs(scip, cons);
819  SCIPdebugPrintf("(lhs %.2f, rhs %.2f)", lhs, rhs);
820 
821  if( SCIPisEQ(scip, lhs, 1.0) && SCIPisEQ(scip, rhs, 1.0) )
822  {
823  *setppctype = SCIP_SETPPCTYPE_PARTITIONING;
824  }
825  else if( SCIPisEQ(scip, lhs, 1.0) && SCIPisGE(scip, rhs, nvars*1.0) )
826  {
827  *setppctype = SCIP_SETPPCTYPE_COVERING;
828  }
829  else if( SCIPisLE(scip, lhs, 0.0) && SCIPisEQ(scip, rhs, 1.0) )
830  {
831  *setppctype = SCIP_SETPPCTYPE_PACKING;
832  }
833  else
834  {
835  relevant = FALSE;
836  }
837  }
838 
839  /* free temporary data */
840  SCIPfreeBufferArrayNull(scip, &vals);
841  SCIPfreeBufferArrayNull(scip, &vars);
842 
843  SCIPdebugPrintf("%s master\n", relevant ? "in" : "not in");
844  return relevant;
845 }
846 
849  SCIP* scip,
850  SCIP_CONS* cons
851 )
852 {
853  SCIP_VAR** vars;
854  SCIP_Real* vals;
855  int i;
856 
857  int nvars;
858  SCIP_Bool relevant = TRUE;
859  assert(scip != NULL);
860  assert(cons != NULL);
861 
862  SCIPdebugMessage("cons %s is ", SCIPconsGetName(cons));
863 
864  if( GCGconsGetType(cons) == setpartitioning )
865  {
866  return TRUE;
867  }
868  nvars = GCGconsGetNVars(scip, cons);
869  vars = NULL;
870  vals = NULL;
871  if( nvars > 0 )
872  {
873  SCIP_CALL_ABORT( SCIPallocBufferArray(scip, &vars, nvars) );
874  SCIP_CALL_ABORT( SCIPallocBufferArray(scip, &vals, nvars) );
875  SCIP_CALL_ABORT( GCGconsGetVars(scip, cons, vars, nvars) );
876  SCIP_CALL_ABORT( GCGconsGetVals(scip, cons, vals, nvars) );
877  }
878 
879  /* check vars and vals for integrality */
880  for( i = 0; i < nvars && relevant; ++i )
881  {
882  assert(vars != NULL);
883  assert(vals != NULL);
884 
885 // if( !SCIPvarIsBinary(vars[i]) )
886 // {
887 // SCIPdebugPrintf("(%s is not integral) ", SCIPvarGetName(vars[i]) );
888 // relevant = FALSE;
889 // }
890  if( !SCIPisEQ(scip, vals[i], 1.0) )
891  {
892  SCIPdebugPrintf("(coeff for var %s is %.2f != 1.0) ", SCIPvarGetName(vars[i]), vals[i] );
893  relevant = FALSE;
894  }
895  }
896 
897  if( relevant )
898  {
899  SCIP_Real rhs = GCGconsGetRhs(scip, cons);
900  SCIP_Real lhs = GCGconsGetLhs(scip, cons);
901  SCIPdebugPrintf("(lhs %.2f, rhs %.2f)", lhs, rhs);
902 
903  if(! SCIPisFeasEQ(scip, lhs, rhs) )
904  {
905  relevant = FALSE;
906  }
907  }
908 
909  /* free temporary data */
910  SCIPfreeBufferArrayNull(scip, &vals);
911  SCIPfreeBufferArrayNull(scip, &vars);
912 
913  SCIPdebugPrintf("%s master\n", relevant ? "in" : "not in");
914  return relevant;
915 }
916 
917 
918 
920 SCIP_Bool GCGisRootNode(
921  SCIP* scip
922  )
923 {
924  assert(scip != NULL);
925  return (SCIPgetCurrentNode(scip) == SCIPgetRootNode(scip));
926 }
SCIP_Bool GCGisRootNode(SCIP *scip)
Definition: scip_misc.c:920
SCIP_Bool GCGgetConsIsCardinalityCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:848
int GCGconsGetNVars(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:433
Definition: scip_misc.h:49
Definition: scip_misc.h:49
consType GCGconsGetType(SCIP_CONS *cons)
Definition: scip_misc.c:51
consType
Definition: scip_misc.h:47
SCIP_RETCODE GCGconsGetVals(SCIP *scip, SCIP_CONS *cons, SCIP_Real *vals, int nvals)
Definition: scip_misc.c:620
various SCIP helper methods
SCIP_Real GCGconsGetDualfarkas(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:302
SCIP_RETCODE GCGconsGetVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int nvars)
Definition: scip_misc.c:489
SCIP_Bool GCGisVarRelevant(SCIP_VAR *var)
Definition: scip_misc.c:41
SCIP_Real GCGconsGetRhs(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:107
SCIP_Real GCGconsGetLhs(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:205
SCIP_Bool GCGconsIsRanged(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:743
SCIP_Real GCGconsGetDualsol(SCIP *scip, SCIP_CONS *cons)
Definition: scip_misc.c:367
SCIP_Bool GCGgetConsIsSetppc(SCIP *scip, SCIP_CONS *cons, SCIP_SETPPCTYPE *setppctype)
Definition: scip_misc.c:762