Scippy

SCIP

Solving Constraint Integer Programs

sepa_oddcycle.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2022 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file sepa_oddcycle.c
17  * @ingroup DEFPLUGINS_SEPA
18  * @brief oddcycle separator
19  * @author Robert Waniek
20  * @author Marc Pfetsch
21  *
22  * We separate odd cycle inequalities in the implication graph. Implemented are the classic method
23  * by Groetschel, Lovasz, and Schrijver (GLS) and the levelgraph method by Hoffman and Padberg (HP)
24  *
25  * Odd cycle inequalities are lifted by a heuristic method based on an idea from Alvarez-Valdes,
26  * Parreno, and Tamarit.
27  *
28  * Some part of this code is based on the odd cycle separator of the program colorbitopt by Marc
29  * Pfetsch.
30  */
31 
32 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
33 
34 #include <assert.h>
35 #include <string.h>
36 
37 #include "blockmemshell/memory.h"
38 #include "dijkstra/dijkstra.h"
39 #include "scip/pub_implics.h"
40 #include "scip/pub_lp.h"
41 #include "scip/pub_message.h"
42 #include "scip/pub_misc.h"
43 #include "scip/pub_misc_sort.h"
44 #include "scip/pub_sepa.h"
45 #include "scip/pub_tree.h"
46 #include "scip/pub_var.h"
47 #include "scip/scip_branch.h"
48 #include "scip/scip_cut.h"
49 #include "scip/scip_general.h"
50 #include "scip/scip_lp.h"
51 #include "scip/scip_mem.h"
52 #include "scip/scip_message.h"
53 #include "scip/scip_numerics.h"
54 #include "scip/scip_param.h"
55 #include "scip/scip_prob.h"
56 #include "scip/scip_sepa.h"
57 #include "scip/scip_sol.h"
58 #include "scip/scip_solvingstats.h"
59 #include "scip/scip_tree.h"
60 #include "scip/scip_var.h"
61 #include "scip/sepa_oddcycle.h"
62 #include <string.h>
63 
64 #define SEPA_NAME "oddcycle"
65 #define SEPA_DESC "odd cycle separator"
66 #define SEPA_PRIORITY -15000
67 #define SEPA_FREQ -1
68 #define SEPA_MAXBOUNDDIST 1.0
69 #define SEPA_USESSUBSCIP FALSE /**< does the separator use a secondary SCIP instance? */
70 #define SEPA_DELAY FALSE /**< should separation method be delayed, if other separators found cuts? */
71 
72 
73 /* default values for separator settings */
74 #define DEFAULT_SCALEFACTOR 1000 /**< factor for scaling of the arc-weights in the Dijkstra algorithm */
75 #define DEFAULT_USEGLS TRUE /**< use GLS method, otherwise HP method */
76 #define DEFAULT_LIFTODDCYCLES FALSE /**< lift odd cycle cuts */
77 #define DEFAULT_REPAIRCYCLES TRUE /**< try to repair violated cycles in which a variable and its negated appear */
78 #define DEFAULT_ADDSELFARCS TRUE /**< add links between a variable and its negated */
79 #define DEFAULT_INCLUDETRIANGLES TRUE /**< separate triangles (3-cliques) found as 3-cycles or repaired larger cycles */
80 #define DEFAULT_MULTIPLECUTS FALSE /**< still try variable as start, even if it is already covered by a cut */
81 #define DEFAULT_ALLOWMULTIPLECUTS TRUE /**< allow another inequality to use variable, even if it is already covered */
82 #define DEFAULT_LPLIFTCOEF FALSE /**< TRUE: choose lifting candidate with highest value of coefficient*lpvalue
83  * FALSE: choose lifting candidate with highest coefficient */
84 #define DEFAULT_RECALCLIFTCOEF TRUE /**< whether lifting coefficients should be recomputed */
85 #define DEFAULT_MAXSEPACUTS 5000 /**< maximal number of oddcycle cuts separated per separation round */
86 #define DEFAULT_MAXSEPACUTSROOT 5000 /**< maximal number of oddcycle cuts separated per separation round in root node */
87 #define DEFAULT_PERCENTTESTVARS 0 /**< percent of variables to try the chosen method on [0-100] */
88 #define DEFAULT_OFFSETTESTVARS 100 /**< offset of variables to try the chosen method on */
89 #define DEFAULT_MAXCUTSROOT 1 /**< maximal number of oddcycle cuts generated per root of the levelgraph */
90 #define DEFAULT_SORTSWITCH 3 /**< unsorted (0), maxlp (1), minlp (2), maxfrac (3), minfrac (4) */
91 #define DEFAULT_MAXREFERENCE 0 /**< minimal weight on an edge (in level graph or Dijkstra graph) */
92 #define DEFAULT_MAXROUNDS 10 /**< maximal number of rounds pre node */
93 #define DEFAULT_MAXROUNDSROOT 10 /**< maximal number of rounds in the root node */
94 #define DEFAULT_MAXNLEVELS 20 /**< maximal number of levels in level graph */
95 #define DEFAULT_MAXPERNODESLEVEL 100 /**< maximal percentage of nodes allowed in one level of the levelgraph [0-100] */
96 #define DEFAULT_OFFSETNODESLEVEL 10 /**< additional offset of nodes allowed in one level of the levelgraph */
97 #define DEFAULT_SORTROOTNEIGHBORS TRUE /**< sort neighbors of the root in the level graph */
98 #define DEFAULT_MAXCUTSLEVEL 50 /**< maximal number of cuts produced per level */
99 #define DEFAULT_MAXUNSUCESSFULL 3 /**< maximal number of unsuccessful calls at each node */
100 #define DEFAULT_CUTTHRESHOLD -1 /**< maximal number of other cuts s.t. separation is applied (-1 for direct call) */
101 
102 
103 /*
104  * Data structures
105  */
106 
107 /** Graph structure for level graph
108  *
109  * This graph is tailored to the heuristic search for odd holes, @see separateHeur().
110  *
111  * This undirected graph is represented by a directed graph with forward and backward arcs. Arcs are
112  * forward if they lead from a level l to level l+1, i.e., away from the root; backward arcs
113  * lead from a level l+1 to level l. This distinction enables a fast construction and search
114  * process. In the latter only forward or backward arcs have to be searched.
115  *
116  * Target nodes and weights of the arcs incident to each node (adjacency lists) are stored
117  * consecutively in the arrays targetForward, targetBackward, weightForward, and weightBackward.
118  * The end of each list is marked by a -1 in targetForward and targetBackward.
119  */
120 struct levelGraph
121 {
122  unsigned int nnodes; /**< number of nodes */
123  unsigned int narcs; /**< number of arcs */
124  unsigned int maxnodes; /**< maximal number of nodes of the level graph */
125  unsigned int maxarcs; /**< maximal number of arcs of the level graph */
126  unsigned int nlevels; /**< number of levels completely inserted so far */
127  unsigned int* level; /**< level number for each node */
128  unsigned int lastF; /**< last storage element index in targetForward, weightForward - forward direction */
129  unsigned int lastB; /**< last storage element index in targetBackward, weightBackward - backward direction */
130  int* beginForward; /**< forward adjacency list index in targetForward, weightForward for each node */
131  int* beginBackward; /**< backward adjacency list index in targetBackward, weightBackward for each node */
132  int* targetForward; /**< target nodes of forward arcs */
133  int* targetBackward; /**< target nodes of backward arcs */
134  unsigned int* weightForward; /**< weights of forward arcs */
135  unsigned int* weightBackward; /**< weights of backwards arcs */
136  unsigned int sizeForward; /**< size of targetForward and weightForward */
137  unsigned int sizeBackward; /**< size of targetBackward and weightBackward */
138  int* beginAdj; /**< index of list of arcs inside a level (in sourceAdj) for each node
139  * (the index points at the first arc starting from this node) */
140  unsigned int* sourceAdj; /**< source nodes of arcs inside a level */
141  unsigned int* targetAdj; /**< target nodes of arcs inside a level */
142  unsigned int* weightAdj; /**< weights of arcs inside a level */
143  unsigned int* levelAdj; /**< index of the first arc inside a given level */
144  unsigned int sizeAdj; /**< size of sourceAdj, targetAdj and weightAdj */
145 };
146 
147 typedef struct levelGraph LEVELGRAPH;
148 
149 
150 /** sorting type for starting node or root node iteration order
151  *
152  * If the array should be sorted (1-4), the variable array is sorted every round by the chosen
153  * sorttype and the search method tries the nodes in order of the array. If the array is used
154  * unsorted (0), the search methods tries the nodes in order of the array and stores the last
155  * processed start node or root node and continues from this position in the next separation round.
156  */
157 enum sorttype
158 {
159  UNSORTED = 0, /**< variable array is unsorted */
160  MAXIMAL_LPVALUE = 1, /**< variable array is sorted by maximal lp-value */
161  MINIMAL_LPVALUE = 2, /**< variable array is sorted by minimal fractionality */
162  MAXIMAL_FRACTIONALITY = 3, /**< variable array is sorted by maximal lp-value */
163  MINIMAL_FRACTIONALITY = 4 /**< variable array is sorted by minimal fractionality */
164 };
165 typedef enum sorttype SORTTYPE;
166 
167 /** auxiliary data structure for passing graphs */
168 struct GraphData
169 {
170  SCIP_Bool usegls; /**< Use GLS algorithm? If true, dijstragraph != NULL should hold, otherwise levelgraph != NULL */
171  LEVELGRAPH* levelgraph; /**< level graph when using HP method, NULL otherwise */
172  DIJKSTRA_GRAPH* dijkstragraph; /**< Dijkstra graph if using method by GLS, NULL otherwise */
173 };
174 typedef struct GraphData GRAPHDATA;
175 
176 /** separator data */
177 struct SCIP_SepaData
178 {
179  int scale; /**< factor for scaling of the arc-weights */
180  unsigned int ncuts; /**< number of cuts, added by the separator so far (in current and past calls) */
181  unsigned int oldncuts; /**< number of cuts at the start the current separation round */
182  int nliftedcuts; /**< number of lifted cuts, added by the separator so far (in current and past calls) */
183  SCIP_Bool usegls; /**< use GLS method, otherwise HP method */
184  SCIP_Bool multiplecuts; /**< an odd cycle cut of length L can be generated L times; forbidding multiple cuts
185  * per node might be faster but might miss some cuts in the current round */
186  SCIP_Bool allowmultiplecuts; /**< allow multiple cuts covering one node */
187  SCIP_Bool liftoddcycles; /**< TRUE, iff we try to lift odd cycle inequalities */
188  SCIP_Bool addselfarcs; /**< add arcs between the nodes of a variable and its negated; since not all implications
189  * are in the graph, this often finds more cycles */
190  SCIP_Bool repaircycles; /**< if a variable and its negated appear in a cycle, we can repair the cycle
191  * by removing both and reconnecting the remaining nodes of the cycle */
192  SCIP_Bool includetriangles; /**< handle triangles found as 3-cycles or repaired larger cycles */
193  unsigned int* mapping; /**< mapping for getting the index of a variable in the sorted variable array */
194  SCIP_Bool lpliftcoef; /**< TRUE: choose lifting candidate with highest value of coefficient*lpvalue
195  * FALSE: choose lifting candidate with highest coefficient */
196  SCIP_Bool recalcliftcoef; /**< whether lifting coefficients should be recomputed */
197  int maxsepacuts; /**< max. number of oddcycle cuts separated per separation round */
198  int maxsepacutsroot; /**< max. number of oddcycle cuts separated per separation round in the root node */
199  int maxsepacutsround; /**< max. number of oddcycle cuts separated per separation round in the current node */
200  SORTTYPE sortswitch; /**< sorted type: unsorted (0), maxlp (1), minlp (2), maxfrac (3), minfrac (4) */
201  int lastroot; /**< save root of last GLS-method run */
202  SCIP_Bool sortrootneighbors; /**< sort neighbors of the root in the level graph */
203  int percenttestvars; /**< percentage of variables to try the chosen method on [0-100] */
204  int offsettestvars; /**< offset of variables to try the chosen method on */
205  int maxpernodeslevel; /**< percentage of nodes allowed in the same level of the level graph [0-100] */
206  int offsetnodeslevel; /**< additional offset of nodes allowed in one level of the levelgraph */
207  unsigned int maxlevelsize; /**< maximal number of nodes allowed in the same level of the level graph */
208  int maxcutsroot; /**< maximal number of oddcycle cuts generated per root of the levelgraph */
209  int maxcutslevel; /**< maximal number of oddcycle cuts generated per level of the level graph */
210  int maxrounds; /**< maximal number of oddcycle separation rounds per node (-1: unlimited) */
211  int maxroundsroot; /**< maximal number of oddcycle separation rounds in the root node (-1: unlimited) */
212  int maxreference; /**< minimal weight on an edge (in level graph or Dijkstra graph) */
213  int maxnlevels; /**< maximal number of levels in level graph */
214  int maxunsucessfull; /**< maximal number of unsuccessful calls at each node */
215  int nunsucessfull; /**< number of unsuccessful calls at current node */
216  int cutthreshold; /**< maximal number of other cuts s.t. separation is applied (-1 for direct call) */
217  SCIP_Longint lastnode; /**< number of last node */
218 };
219 
220 
221 /*
222  * debugging methods
223  */
224 
225 #ifdef SCIP_OUTPUT
226 
227 /** displays cycle of pred data structure w.r.t. variable names of the original problem (including
228  * status: original or negated node in graph)
229  */
230 static
231 void printCycle(
232  SCIP_VAR** vars, /**< problem variables */
233  unsigned int* pred, /**< cycle stored as predecessor list */
234  unsigned int nbinvars, /**< number of binary problem variables */
235  unsigned int startnode /**< a node of the cycle */
236  )
237 {
238  unsigned int varsindex;
239  unsigned int counter;
240 
241  assert(vars != NULL);
242  assert(pred != NULL);
243  assert(nbinvars > 0);
244  assert(startnode < 4*nbinvars);
245 
246  counter = 0;
247  varsindex = startnode;
248 
249  /* print start/end node */
250  if( varsindex < nbinvars || ( varsindex >= 2*nbinvars && varsindex < 3*nbinvars ) )
251  {
252  SCIPdebugMsg(scip, "+ %s\n",SCIPvarGetName(vars[varsindex%nbinvars]));
253  }
254  else
255  {
256  SCIPdebugMsg(scip, "- %s\n",SCIPvarGetName(vars[varsindex%nbinvars]));
257  }
258 
259  /* print inner nodes */
260  for( varsindex = pred[startnode]; varsindex != startnode; varsindex = pred[varsindex] )
261  {
262  if( varsindex < nbinvars || ( varsindex >= 2*nbinvars && varsindex < 3*nbinvars ) )
263  {
264  SCIPdebugMsg(scip, "+ %s\n",SCIPvarGetName(vars[varsindex%nbinvars]));
265  }
266  else
267  {
268  SCIPdebugMsg(scip, "- %s\n",SCIPvarGetName(vars[varsindex%nbinvars]));
269  }
270  ++counter;
271  }
272 
273  /* print start/end node */
274  if( varsindex < nbinvars || ( varsindex >= 2*nbinvars && varsindex < 3*nbinvars ) )
275  {
276  SCIPdebugMsg(scip, "+ %s\n",SCIPvarGetName(vars[varsindex%nbinvars]));
277  }
278  else
279  {
280  SCIPdebugMsg(scip, "- %s\n",SCIPvarGetName(vars[varsindex%nbinvars]));
281  }
282 
283  ++counter;
284  SCIPdebugMsg(scip, "original cycle has %u variables.\n", counter);
285 }
286 #endif
287 
288 
289 /*
290  * lifting methods
291  */
292 
293 /** using the level graph (if possible) or Dijkstra graph data structure (depending on the used
294  * method) we determine whether two nodes are adjacent
295  */
296 static
297 SCIP_Bool isNeighbor(
298  SCIP_VAR** vars, /**< problem variables */
299  unsigned int nbinvars, /**< number of binary problem variables */
300  GRAPHDATA* graphdata, /**< graph */
301  unsigned int a, /**< node index of first variable */
302  unsigned int b /**< node index of second variable */
303  )
304 {
305  unsigned int i;
306 
307  assert(vars != NULL);
308  assert(nbinvars > 2);
309  assert(graphdata != NULL);
310  assert(graphdata->levelgraph != NULL || graphdata->usegls);
311  assert(graphdata->dijkstragraph != NULL || ! graphdata->usegls);
312  assert(a < 2*nbinvars);
313  assert(b < 2*nbinvars);
314  assert(a != b);
315 
316  /* determine adjacency using the Dijkstra graph */
317  if( graphdata->usegls )
318  {
319  DIJKSTRA_GRAPH* dijkstragraph = graphdata->dijkstragraph;
320  if( dijkstragraph->outcnt[a] == 0 || dijkstragraph->outcnt[b] == 0 )
321  return FALSE;
322 
323  /* @todo later: if helpful: sort head and weight list once */
324  for( i = dijkstragraph->outbeg[a]; i < dijkstragraph->outbeg[a] + dijkstragraph->outcnt[a]; ++i )
325  {
326  if( dijkstragraph->head[i] == b + 2*nbinvars )
327  return TRUE;
328  }
329  }
330  else /* determine adjacency using the level graph */
331  {
332  LEVELGRAPH* levelgraph = graphdata->levelgraph;
333 
334  /* if a and b are contained in the level graph (with their arcs), we can check inside the level graph structure */
335  if( (levelgraph->beginForward[a] != -1 || levelgraph->beginBackward[a] != -1)
336  && (levelgraph->beginForward[b] != -1 || levelgraph->beginBackward[b] != -1) )
337  {
338  assert(levelgraph->level[a] <= levelgraph->nlevels);
339  assert(levelgraph->level[b] <= levelgraph->nlevels);
340 
341  /* if a and b are not in neighbored levels or the same level, they cannot be adjacent */
342  if( levelgraph->level[a] > levelgraph->level[b] + 1
343  || levelgraph->level[b] > levelgraph->level[a] + 1 )
344  return FALSE;
345 
346  assert(levelgraph->level[a] == levelgraph->level[b]
347  || levelgraph->level[a]+1 == levelgraph->level[b]
348  || levelgraph->level[a] == levelgraph->level[b]+1);
349 
350  /* first case of adjacent level */
351  if( levelgraph->level[a] == levelgraph->level[b]+1 )
352  {
353  if( levelgraph->beginBackward[a] >= 0 )
354  {
355  i = (unsigned int) levelgraph->beginBackward[a];
356  while( levelgraph->targetBackward[i] != -1 )
357  {
358  if( levelgraph->targetBackward[i] == (int)b )
359  return TRUE;
360  ++i;
361  }
362  }
363  }
364  else if( levelgraph->level[a] == levelgraph->level[b]-1 ) /* second case of adjacent level */
365  {
366  if( levelgraph->beginForward[a] >= 0 )
367  {
368  i = (unsigned int) levelgraph->beginForward[a];
369  while( levelgraph->targetForward[i] != -1 )
370  {
371  if( levelgraph->targetForward[i] == (int)b )
372  return TRUE;
373  ++i;
374  }
375  }
376  }
377  else /* same level (note that an edge between a and b is stored for a if a < b, otherwise it is stored for b) */
378  {
379  assert(levelgraph->level[a] == levelgraph->level[b]);
380  assert(levelgraph->level[a] > 0); /* root has no neighbor in the same level */
381 
382  if( a < b && levelgraph->beginAdj[a] >= 0 )
383  {
384  i = (unsigned int) levelgraph->beginAdj[a];
385  assert(i >= levelgraph->levelAdj[levelgraph->level[a]]);
386 
387  while( i < levelgraph->levelAdj[levelgraph->level[a]+1] && levelgraph->sourceAdj[i] == a )
388  {
389  if( levelgraph->targetAdj[i] == b )
390  return TRUE;
391 
392  /* if adjacency list ends we are done and a and b are not adjacent */
393  if( levelgraph->sourceAdj[i] == 0 && levelgraph->targetAdj[i] == 0 )
394  return FALSE;
395 
396  assert(levelgraph->sourceAdj[i] < levelgraph->targetAdj[i]);
397  ++i;
398  }
399  }
400  if( b < a && levelgraph->beginAdj[b] >= 0 )
401  {
402  i = (unsigned int) levelgraph->beginAdj[b];
403  assert(i >= levelgraph->levelAdj[levelgraph->level[b]]);
404 
405  while( i < levelgraph->levelAdj[levelgraph->level[b]+1] && levelgraph->sourceAdj[i] == b )
406  {
407  if( levelgraph->targetAdj[i] == a )
408  return TRUE;
409 
410  /* if adjacency list ends we are done and a and b are not adjacent */
411  if( levelgraph->sourceAdj[i] == 0 && levelgraph->targetAdj[i] == 0 )
412  return FALSE;
413 
414  assert(levelgraph->sourceAdj[i] < levelgraph->targetAdj[i]);
415  ++i;
416  }
417  }
418  }
419  }
420  /* if a or b is not in the levels already completely inserted in the levelgraph, we check
421  * their adjacency by the SCIP data structures
422  */
423  else
424  {
425  SCIP_CLIQUE** cliques;
426  SCIP_VAR** cliquevars;
427  SCIP_Bool* cliquevals;
428  SCIP_Bool originala;
429  SCIP_Bool originalb;
430  unsigned int ncliques;
431  unsigned int ncliquevars;
432  unsigned int j;
433 
434  /* get original variables */
435  originala = TRUE;
436  if( a >= nbinvars )
437  {
438  a = a - nbinvars;
439  originala = FALSE;
440  }
441  assert(a < nbinvars);
442 
443  originalb = TRUE;
444  if( b >= nbinvars )
445  {
446  b = b - nbinvars;
447  originalb = FALSE;
448  }
449  assert(b < nbinvars);
450 
451  /* nodes cannot be connected by trivial observations */
452  if( SCIPvarGetNCliques(vars[a], originala) == 0 || SCIPvarGetNCliques(vars[b], originalb) == 0 )
453  return FALSE;
454 
455  /* @todo later: possible improvement: do this test for implications and cliques separately if this here is time consuming */
456  /* one of the nodes seems to have more arcs than the other, we swap them (since adjacency is symmetric) */
457  if( SCIPvarGetNCliques(vars[a], originala) > SCIPvarGetNCliques(vars[b], originalb) )
458  {
459  unsigned int temp;
460  SCIP_Bool varfixingtemp;
461 
462  temp = b;
463  varfixingtemp = originalb;
464  b = a;
465  originalb = originala;
466  a = temp;
467  originala = varfixingtemp;
468  }
469 
470  /* check whether a and b are contained in a clique */
471  ncliques = (unsigned int) SCIPvarGetNCliques(vars[a], originala);
472  cliques = SCIPvarGetCliques(vars[a], originala);
473 
474  assert(cliques != NULL || ncliques == 0);
475 
476  for( i = 0; i < ncliques; ++i )
477  {
478  assert( cliques != NULL ); /* for lint */
479  ncliquevars = (unsigned int) SCIPcliqueGetNVars(cliques[i]);
480  cliquevars = SCIPcliqueGetVars(cliques[i]);
481  cliquevals = SCIPcliqueGetValues(cliques[i]);
482 
483  assert(cliquevars != NULL || ncliquevars == 0);
484  assert(cliquevals != NULL || ncliquevars == 0);
485 
486  for( j = 0; j < ncliquevars; ++j )
487  {
488  assert( cliquevals != NULL && cliquevars != NULL ); /* for lint */
489  if( SCIPvarGetProbindex(vars[b]) == SCIPvarGetProbindex(cliquevars[j]) )
490  {
491  if( (cliquevals[j] == FALSE && originalb == TRUE) || ( cliquevals[j] == TRUE && originalb == FALSE ) )
492  return TRUE;
493  }
494  }
495  }
496  }
497  }
498 
499  return FALSE;
500 }
501 
502 /** inside the lifting heuristic we determine the lifting coefficient by counting the length of
503  * chains adjacent to the lifting candidate.
504  *
505  * since we have to exclude all chains adjacent to an already lifted node which is not adjacent to
506  * the current lifting candidate we check all chains of the cycle of length three and block them if
507  * they are adjacent.
508  */
509 static
510 void checkBlocking(
511  unsigned int a, /**< first node of the checked cycle chain of length 3 */
512  unsigned int b, /**< second node of the checked cycle chain of length 3 */
513  unsigned int c, /**< third node of the checked cycle chain of length 3 */
514  unsigned int i, /**< current lifting candidate */
515  unsigned int* cycle, /**< list of cycle nodes in order of the cycle */
516  unsigned int ncyclevars, /**< number of variables in the odd cycle */
517  SCIP_VAR** vars, /**< problem variables */
518  unsigned int nbinvars, /**< number of binary problem variables */
519  unsigned int* lifted, /**< list of lifted nodes */
520  unsigned int* nlifted, /**< number of lifted nodes */
521  GRAPHDATA* graphdata, /**< graph */
522  SCIP_Bool* myi /**< flag array, if cycle node is inner point of a counted chain */
523  )
524 {
525  unsigned int k;
526 
527  assert(a < ncyclevars);
528  assert(b < ncyclevars);
529  assert(c < ncyclevars);
530  assert(cycle != NULL);
531  assert(ncyclevars % 2 == 1);
532  assert(ncyclevars > 2);
533  assert(ncyclevars <= nbinvars);
534  assert(vars != NULL);
535  assert(nbinvars > 2);
536  assert(lifted != NULL);
537  assert(nlifted != NULL);
538  assert(myi != NULL);
539 
540  k = 0;
541  while( (myi[a] || myi[b] || myi[c]) && k < *nlifted )
542  {
543  /* if all three nodes are adjacent to a node which is already lifted and not adjacent with the
544  * current lifting candidate, they cannot be regarded */
545  if( !isNeighbor(vars, nbinvars, graphdata, i, lifted[k])
546  && isNeighbor(vars, nbinvars, graphdata, cycle[a], lifted[k])
547  && isNeighbor(vars, nbinvars, graphdata, cycle[b], lifted[k])
548  && isNeighbor(vars, nbinvars, graphdata, cycle[c], lifted[k]) )
549  {
550  myi[a] = FALSE;
551  myi[b] = FALSE;
552  myi[c] = FALSE;
553  }
554  ++k;
555  }
556 }
557 
558 /** determine the heuristic lifting coefficient by counting the length of the adjacent chains of the
559  * candidate (we have to exclude all chains that are adjacent to an already lifted node which is
560  * not adjacent to the current candidate)
561  */
562 static
563 unsigned int getCoef(
564  SCIP* scip, /**< SCIP data structure */
565  unsigned int i, /**< current lifting candidate */
566  unsigned int* cycle, /**< list of cycle nodes in order of the cycle */
567  unsigned int ncyclevars, /**< number of variables in the odd cycle */
568  SCIP_VAR** vars, /**< problem variables */
569  unsigned int nbinvars, /**< number of binary problem variables */
570  unsigned int* lifted, /**< list of lifted nodes */
571  unsigned int* nlifted, /**< number of lifted nodes */
572  GRAPHDATA* graphdata, /**< graph data structure */
573  SCIP_Bool* myi /**< flag array, if cycle node is inner point of a counted chain */
574  )
575 {
576  int j;
577  unsigned int k;
578  unsigned int coef; /* coefficient of lifting candidate of the current step */
579  unsigned int end;
580 
581  assert(scip != NULL);
582  assert(i < 2*nbinvars);
583  assert(cycle != NULL);
584  assert(ncyclevars % 2 == 1);
585  assert(ncyclevars > 2);
586  assert(ncyclevars <= 2*nbinvars);
587  assert(vars != NULL);
588  assert(nbinvars > 2);
589  assert(nlifted != NULL);
590  assert(lifted != NULL);
591 
592  coef = 0;
593 
594  /* get inner nodes of adjacent chains in cycle */
595  for( j = 1; j < (int)ncyclevars-1; ++j )
596  {
597  myi[j] = isNeighbor(vars, nbinvars, graphdata, i, cycle[j-1]) && isNeighbor(vars, nbinvars, graphdata, i, cycle[j])
598  && isNeighbor(vars, nbinvars, graphdata, i, cycle[j+1]);
599  }
600 
601  /* the first and last node of the cycle are treated separately */
602  myi[0] = isNeighbor(vars, nbinvars, graphdata, i, cycle[ncyclevars-1])
603  && isNeighbor(vars, nbinvars, graphdata, i, cycle[0])
604  && isNeighbor(vars, nbinvars, graphdata, i, cycle[1]);
605  myi[ncyclevars-1] = isNeighbor(vars, nbinvars, graphdata, i, cycle[ncyclevars-2])
606  && isNeighbor(vars, nbinvars, graphdata, i, cycle[ncyclevars-1])
607  && isNeighbor(vars, nbinvars, graphdata, i, cycle[0]);
608 
609  /* consider already lifted nodes that are not adjacent to current lifting candidate and
610  * remove all inner cycle nodes that are adjacent to them
611  */
612  for( j = 1; j < (int)ncyclevars-1; ++j )
613  {
614  checkBlocking((unsigned int) (j-1), (unsigned int) j, (unsigned int) (j+1), i, cycle, ncyclevars, vars, nbinvars, lifted, nlifted, graphdata, myi);
615  }
616  checkBlocking(ncyclevars-2, ncyclevars-1, 0, i, cycle, ncyclevars, vars, nbinvars, lifted, nlifted, graphdata, myi);
617  checkBlocking(ncyclevars-1, 0, 1, i, cycle, ncyclevars, vars, nbinvars, lifted, nlifted, graphdata, myi);
618 
619  /* calculate lifting coefficient */
620  k = 0;
621 
622  /* first, handle the special case, that the first node of the cycle list is part of a chain */
623  if( myi[0] )
624  {
625  ++k;
626  end = ncyclevars-1;
627  while( myi[end] && end > 0 )
628  {
629  ++k;
630  --end;
631  }
632  assert(k == ncyclevars || end > 0);
633 
634  /* all cycle nodes build a relevant chain (maximal chain s.t. all inner nodes are in myi) */
635  if( end == 0 )
636  {
637  assert(ncyclevars % 2 == 1);
638  coef = (ncyclevars-1)/2;
639  return coef;
640  }
641  assert(!myi[end]);
642 
643  /* current nonempty relevant chain cannot be extended */
644  if( !myi[1] )
645  {
646  coef = (unsigned int) SCIPfloor(scip,(k+1.0)/2.0);
647  assert(coef <= (ncyclevars-1)/2);
648  k = 0;
649  }
650  }
651  else
652  end = ncyclevars;
653 
654  /* find remaining relevant chains */
655  j = 1;
656  while( j < (int)end )
657  {
658  /* skip all nodes that are not inner node */
659  while( j<(int)end && ! myi[j] )
660  ++j;
661 
662  /* collect all inner nodes (chain is extended) */
663  while( j<(int)end && myi[j] )
664  {
665  ++k;
666  ++j;
667  }
668 
669  if( k > 0 )
670  {
671  assert(myi[j-1]);
672  coef += (unsigned int) SCIPfloor(scip,(k+1.0)/2.0);
673  assert(coef <= (ncyclevars-1)/2);
674  k = 0;
675  }
676  }
677 
678  return coef;
679 }
680 
681 /** Lifting Heuristic based on an idea by Alvarez-Valdes, Parreno, Tamarit
682  *
683  * This method is based on the observation, that a non-cycle node can be lifted into the inequality
684  * with coefficient \f$1\f$ if the node is adjacent to the nodes of a 3-chain on the cycle.
685  *
686  * The coefficient can be calculated as
687  * \f$\left\lfloor{\frac{|C|-1}{2}}\right\rfloor\f$
688  * where \f$C\f$ is the chain on the cycle.
689  *
690  * If the node is connected to several chains, the coefficients of the chains can be summed up, resulting
691  * in a feasible lifting coefficient.
692  *
693  * Additionally further variables can be lifted by considering chains connected to the additional lifting node
694  * which are not connected to already lifted nodes.
695  *
696  * This method is a feasible heuristic which gives a valid lifted inequality.
697  * (Furthermore the first lifting coefficient is always smaller or equal to the largest possible lifting coefficient.)
698  */
699 static
700 SCIP_RETCODE liftOddCycleCut(
701  SCIP* scip, /**< SCIP data structure */
702  unsigned int* nlifted, /**< number of lifted variables */
703  unsigned int* lifted, /**< indices of the lifted variables */
704  unsigned int* liftcoef, /**< lifting coefficients */
705  SCIP_SEPADATA* sepadata, /**< separator data structure */
706  GRAPHDATA* graphdata, /**< graph */
707  SCIP_VAR** vars, /**< problem variables */
708  unsigned int nbinvars, /**< number of binary problem variables */
709  unsigned int startnode, /**< a node of the cycle */
710  unsigned int* pred, /**< predecessor of each node (original and negated) in odd cycle */
711  unsigned int ncyclevars, /**< number of variables in the odd cycle */
712  SCIP_Real* vals, /**< values of the variables in the given solution */
713  SCIP_RESULT* result /**< pointer to store the result of the separation call */
714  )
715 {
716  unsigned int* cycle; /* storage for cycle and lifted nodes (and their coefficients) */
717  unsigned int* coef;
718  SCIP_Bool* candList; /* lifting candidate list */
719  unsigned int i;
720  unsigned int j;
721  unsigned int negated;
722  int bestcand;
723  unsigned int liftround;
724  SCIP_Bool* myi;
725 
726  assert(scip != NULL);
727  assert(graphdata != NULL);
728  assert(graphdata->levelgraph != NULL || graphdata->usegls);
729  assert(graphdata->dijkstragraph != NULL || ! graphdata->usegls);
730  assert(vars != NULL);
731  assert(nbinvars > 2);
732  assert(startnode < 2*nbinvars);
733  assert(pred != NULL);
734  assert(ncyclevars % 2 == 1);
735  assert(ncyclevars > 2);
736  assert(ncyclevars <= nbinvars);
737  assert(result != NULL);
738  assert(nlifted != NULL);
739  assert(lifted != NULL);
740  assert(liftcoef != NULL);
741 
742  /* allocate memory for cycle list */
743  SCIP_CALL( SCIPallocBufferArray(scip, &cycle, (int) ncyclevars) );
744 
745  /* transform cycle from predecessor list to array in order of appearance in cycle */
746  cycle[0] = startnode;
747  j = 1;
748  i = pred[startnode];
749  while( i != startnode )
750  {
751  cycle[j] = i;
752  i = pred[i];
753  ++j;
754  }
755  assert(j == ncyclevars);
756 
757  /* allocate memory for coefficients of the lifting candidates (used in every step) */
758  SCIP_CALL( SCIPallocBufferArray(scip, &coef, (int) (2*nbinvars)) );
759 
760  /* allocate memory candidate list and list of lifted nodes */
761  SCIP_CALL( SCIPallocBufferArray(scip, &candList, (int) (2*nbinvars)) );
762 
763  /* allocate memory for counting of chains in getCoef() */
764  SCIP_CALL( SCIPallocBufferArray(scip, &myi, (int) ncyclevars) );
765 
766  if( SCIPisStopped(scip) )
767  goto TERMINATE;
768 
769  /* initialize candidate list */
770  for( i = 0; i < 2*nbinvars; ++i )
771  candList[i] = TRUE;
772 
773  /* remove cycle variables and their negated from candidate list */
774  for( i = 0; i < ncyclevars; ++i )
775  {
776  candList[cycle[i]] = FALSE;
777  if( cycle[i] >= nbinvars )
778  negated = cycle[i] - nbinvars;
779  else
780  negated = cycle[i] + nbinvars;
781  assert(negated < 2*nbinvars);
782  candList[negated] = FALSE;
783  }
784 
785  /* no candidates lifted so far */
786  *nlifted = 0;
787  bestcand = 0;
788  liftround = 0;
789 
790  /* try lifting as long as we have lifting candidates */
791  while( bestcand >= 0 )
792  {
793  /* in case we use a lifting rule, which does not require the first lifting coefficient of all variables: REMOVE this */
794  if( sepadata->recalcliftcoef || liftround == 0 )
795  {
796  for( i = 0; i < 2*nbinvars; ++i )
797  {
798  if( candList[i] )
799  {
800  coef[i] = getCoef(scip, i, cycle, ncyclevars, vars, nbinvars, lifted, nlifted, graphdata, myi);
801  assert(coef[i] <= (ncyclevars-1)/2);
802  if( coef[i] < 1 )
803  candList[i] = FALSE;
804  }
805  }
806  }
807  ++liftround;
808  bestcand = -1;
809  for( i = 0; i < 2*nbinvars; ++i )
810  {
811  if( candList[i] )
812  {
813  /* we want to weight our choice of the lifting node by the value of the current lp solution */
814  if( sepadata->lpliftcoef )
815  {
816  if( bestcand < 0 || coef[i]*vals[i] > coef[bestcand]*vals[bestcand] )
817  bestcand = (int) i;
818  }
819  /* we only regard the coefficient */
820  else
821  {
822  if( bestcand < 0 || coef[i] > coef[bestcand] )
823  bestcand = (int) i;
824  }
825  }
826  }
827 
828  /* there is at least one lifting variable */
829  if( bestcand >= 0 )
830  {
831  if( !(sepadata->recalcliftcoef) )
832  coef[i] = getCoef(scip, (unsigned int) bestcand, cycle, ncyclevars, vars, nbinvars, lifted, nlifted, graphdata, myi);
833  assert(coef[bestcand] <= (ncyclevars-1)/2);
834  candList[bestcand] = FALSE;
835  if( coef[bestcand] > 0 )
836  {
837  if( bestcand >= (int)nbinvars )
838  negated = (unsigned int) bestcand - nbinvars;
839  else
840  negated = (unsigned int) bestcand + nbinvars;
841  assert(negated < 2*nbinvars);
842 
843  candList[negated] = FALSE;
844 
845  assert(*nlifted < nbinvars-ncyclevars);
846  lifted[*nlifted] = (unsigned int) bestcand;
847  liftcoef[*nlifted] = coef[bestcand];
848  ++(*nlifted);
849  }
850  }
851  }
852 
853  TERMINATE:
854  /* free temporary memory */
855  SCIPfreeBufferArray(scip, &myi);
856  SCIPfreeBufferArray(scip, &candList);
857  SCIPfreeBufferArray(scip, &coef);
858  SCIPfreeBufferArray(scip, &cycle);
859 
860  return SCIP_OKAY;
861 }
862 
863 
864 /*
865  * methods for both techniques
866  */
867 
868 /** add the inequality corresponding to the given odd cycle to the LP (if violated)
869  * after lifting it (if requested by user flag)
870  */
871 static
872 SCIP_RETCODE generateOddCycleCut(
873  SCIP* scip, /**< SCIP data structure */
874  SCIP_SEPA* sepa, /**< separator */
875  SCIP_SOL* sol, /**< given primal solution */
876  SCIP_VAR** vars, /**< problem variables */
877  unsigned int nbinvars, /**< number of binary problem variables */
878  unsigned int startnode, /**< a node of the cycle */
879  unsigned int* pred, /**< predecessor of each node (original and negated) in odd cycle */
880  unsigned int ncyclevars, /**< number of variables in the odd cycle */
881  unsigned int* incut, /**< TRUE iff node is covered already by a cut */
882  SCIP_Real* vals, /**< values of the variables in the given solution */
883  SCIP_SEPADATA* sepadata, /**< separator data structure */
884  GRAPHDATA* graphdata, /**< graph data structure */
885  SCIP_RESULT* result /**< pointer to store the result of the separation call */
886  )
887 {
888  unsigned int i;
889  unsigned int negatedcount;
890  unsigned int negated;
891 
892  /* memory for lifting */
893  unsigned int nlifted; /* number of lifted variables */
894  unsigned int* lifted; /* index of the lifted variables */
895  unsigned int* liftcoef; /* lifting coefficient */
896 
897  /* memory for cut generation */
898  SCIP_ROW* cut;
899  char cutname[SCIP_MAXSTRLEN];
900 
901  assert(scip != NULL);
902  assert(vars != NULL);
903  assert(startnode < 2*nbinvars);
904  assert(pred != NULL);
905  assert(ncyclevars % 2 == 1);
906  assert(ncyclevars <= nbinvars);
907  assert(incut != NULL);
908  assert(graphdata != NULL);
909  assert(graphdata->levelgraph != NULL || graphdata->usegls);
910  assert(graphdata->dijkstragraph != NULL || ! graphdata->usegls);
911  assert(result != NULL);
912 
913 #ifdef SCIP_OUTPUT
914  /* debug method that prints out all found cycles */
915  printCycle(vars, pred, nbinvars, startnode);
916 #endif
917 
918  /* cycle contains only one node */
919  if( ncyclevars < 3 )
920  {
921  SCIPdebugMsg(scip, "fixing variable\n");
922  /* strengthening variable bounds due to single-variable-cycle */
923  if( startnode < nbinvars )
924  {
925  SCIP_CALL( SCIPchgVarUb(scip, vars[startnode], 0.0) );
926  }
927  else
928  {
929  negated = startnode - nbinvars;
930  assert(negated < nbinvars);
931  SCIP_CALL( SCIPchgVarLb(scip, vars[negated], 1.0) );
932  }
933  *result = SCIP_REDUCEDDOM;
934  return SCIP_OKAY;
935  }
936 
937  /* cycle is a triangle (can be excluded by user) */
938  if( ncyclevars < 5 && ! sepadata->includetriangles )
939  return SCIP_OKAY;
940 
941  if( SCIPisStopped(scip) )
942  return SCIP_OKAY;
943 
944  /* lift the cycle inequality */
945  nlifted = 0;
946  lifted = NULL;
947  liftcoef = NULL;
948  if( sepadata->liftoddcycles )
949  {
950  SCIP_CALL( SCIPallocBufferArray(scip, &lifted, (int) (nbinvars - ncyclevars)) );
951  SCIP_CALL( SCIPallocBufferArray(scip, &liftcoef, (int) (nbinvars - ncyclevars)) );
952  SCIP_CALL( liftOddCycleCut(scip, &nlifted, lifted, liftcoef, sepadata, graphdata, vars, nbinvars, startnode, pred, ncyclevars, vals, result) );
953  }
954  /* if we don't try to lift, we generate and add the cut as is */
955 
956  /* create cut */
957  (void) SCIPsnprintf(cutname, SCIP_MAXSTRLEN, "oddcycle_%d", sepadata->ncuts);
958  SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &cut, sepa, cutname, -SCIPinfinity(scip), (ncyclevars-1)/2.0, FALSE, FALSE, TRUE) );
959  SCIP_CALL( SCIPcacheRowExtensions(scip, cut) );
960  negatedcount = 0;
961 
962  /* add variables of odd cycle to cut inequality */
963  i = pred[startnode];
964  while( i != startnode )
965  {
966  assert(i < 2*nbinvars);
967  if( i < nbinvars )
968  {
969  /* inserting original variable */
970  SCIP_CALL( SCIPaddVarToRow(scip, cut, vars[i], 1.0) );
971  incut[i] = TRUE;
972  }
973  else
974  {
975  negated = i - nbinvars;
976  assert(negated < nbinvars);
977 
978  /* inserting negated variable */
979  SCIP_CALL( SCIPaddVarToRow(scip, cut, vars[negated], -1.0) );
980  ++negatedcount;
981  incut[negated] = TRUE;
982  }
983  i = pred[i];
984  }
985  assert(startnode == i);
986 
987  /* insert startnode */
988  if( startnode < nbinvars )
989  {
990  /* inserting original variable */
991  SCIP_CALL( SCIPaddVarToRow(scip, cut, vars[startnode], 1.0) );
992  incut[startnode] = TRUE;
993  }
994  else
995  {
996  negated = startnode - nbinvars;
997  assert(negated < nbinvars);
998 
999  /* inserting negated variable */
1000  SCIP_CALL( SCIPaddVarToRow(scip, cut, vars[negated], -1.0) );
1001  ++negatedcount;
1002  incut[negated] = TRUE;
1003  }
1004 
1005  /* add lifted variables to cut inequality (if existing) */
1006  for( i = 0; i < nlifted; ++i)
1007  {
1008  assert(lifted != NULL);
1009  assert(liftcoef != NULL);
1010  if( lifted[i] < nbinvars )
1011  {
1012  assert(vars[lifted[i]] != NULL);
1013  SCIP_CALL( SCIPaddVarToRow(scip, cut, vars[lifted[i]], (SCIP_Real) liftcoef[i]) );
1014  }
1015  else
1016  {
1017  negated = lifted[i] - nbinvars;
1018  assert(negated < nbinvars);
1019  assert(vars[negated] != NULL);
1020  SCIP_CALL( SCIPaddVarToRow(scip, cut, vars[negated], -1.0*liftcoef[i]) );
1021  negatedcount += liftcoef[i];
1022  }
1023  }
1024 
1025  /* modify right hand side corresponding to number of added negated variables */
1026  SCIP_CALL( SCIPchgRowRhs(scip, cut, SCIProwGetRhs(cut) - negatedcount) );
1027  SCIP_CALL( SCIPflushRowExtensions(scip, cut) );
1028 
1029  /* set cut rank: for oddcycle cuts we always set to 1 */
1030  SCIProwChgRank(cut, 1);
1031 
1032  /* not every odd cycle has to be violated due to incompleteness of the implication graph */
1033  if( SCIPisCutEfficacious(scip, sol, cut) )
1034  {
1035  SCIP_Bool infeasible;
1036 
1037  SCIP_CALL( SCIPaddRow(scip, cut, FALSE, &infeasible) );
1038  ++sepadata->ncuts;
1039  if ( nlifted > 0 )
1040  ++sepadata->nliftedcuts;
1041  if ( infeasible )
1042  *result = SCIP_CUTOFF;
1043  else
1044  {
1045  SCIP_CALL( SCIPaddPoolCut(scip, cut) );
1046 
1047  if( *result == SCIP_DIDNOTFIND )
1048  *result = SCIP_SEPARATED;
1049  }
1050 
1051 #ifdef SCIP_OUTPUT
1052  SCIP_CALL( SCIPprintRow(scip, cut, NULL) );
1053 #endif
1054 
1055  assert(*result == SCIP_CUTOFF || *result == SCIP_SEPARATED || *result == SCIP_REDUCEDDOM);
1056  }
1057 
1058  SCIP_CALL( SCIPreleaseRow(scip, &cut) );
1059 
1060  if( sepadata->liftoddcycles )
1061  {
1062  SCIPfreeBufferArray(scip, &liftcoef);
1063  SCIPfreeBufferArray(scip, &lifted);
1064  }
1065  return SCIP_OKAY;
1066 }
1067 
1068 /** check whether the given object is really a cycle without sub-cycles (sub-cycles may be
1069  * calculated by the GLS algorithm in case there is no violated odd cycle inequality) and removes
1070  * pairs of original and negated variables from the cycle
1071  */
1072 static
1073 SCIP_RETCODE cleanCycle(
1074  SCIP* scip, /**< SCIP data structure */
1075  unsigned int* pred, /**< predecessor list of current cycle segment */
1076  SCIP_Bool* incycle, /**< flag array iff node is in cycle segment */
1077  unsigned int* incut, /**< flag array iff node is already covered by a cut */
1078  unsigned int x, /**< index of current variable */
1079  unsigned int startnode, /**< index of first variable of cycle segment */
1080  unsigned int nbinvars, /**< number of binary problem variables */
1081  unsigned int* ncyclevars, /**< number of nodes in current cycle segment */
1082  SCIP_Bool repaircycles, /**< user flag if we should try to repair damaged cycles */
1083  SCIP_Bool allowmultiplecuts, /**< user flag if we allow multiple cuts per node */
1084  SCIP_Bool* success /**< FALSE iff an irreparable cycle appears */
1085  )
1086 {
1087  unsigned int negx;
1088 
1089  assert(scip != NULL);
1090  assert(pred != NULL);
1091  assert(incycle != NULL);
1092  assert(incut != NULL);
1093  assert(ncyclevars != NULL);
1094  assert(*ncyclevars <= nbinvars);
1095  assert(success != NULL);
1096  assert(*success);
1097 
1098  assert(x < 2*nbinvars);
1099 
1100  /* skip variable if it is already covered by a cut and we do not allow multiple cuts per node */
1101  if( incut[x] && !allowmultiplecuts )
1102  {
1103  *success = FALSE;
1104  return SCIP_OKAY;
1105  }
1106 
1107  /* get index of negated variable of current variable */
1108  if( x < nbinvars )
1109  negx = x + nbinvars;
1110  else
1111  negx = x - nbinvars;
1112  assert(negx < 2*nbinvars);
1113 
1114  /* given object is not an odd cycle (contains sub-cycle) or contains original and negated
1115  * variable pair but we should not repair this
1116  */
1117  if( incycle[x] || (incycle[negx] && !repaircycles) )
1118  {
1119  *success = FALSE;
1120  return SCIP_OKAY;
1121  }
1122 
1123  /* cycle does not contain original and negated variable pair */
1124  if( !incycle[negx] )
1125  {
1126  assert(!incycle[x]);
1127  incycle[x] = TRUE;
1128  ++(*ncyclevars);
1129  return SCIP_OKAY;
1130  }
1131 
1132  /* delete original and negated variable and cross-link their neighbors the following way, if possible:
1133  * suppose the cycle contains segments:
1134  * startnode - ... - a - neg(x) - c1 - c2 - ... - cn-1 - cn - x - z=pred(x)
1135  *
1136  * because of the chain a - neg(x) - x - cn it holds that
1137  * a=1 => x=0 => neg(x)=1 => cn=0 and
1138  * cn=1 => x=0 => neg(x)=1 => a=0
1139  * because of the chain z - x - neg(x) - b it holds that
1140  * z=1 => x=0 => neg(x)=1 => c1=0 and
1141  * c1=1 => x=0 => neg(x)=1 => z=0
1142  *
1143  * in addition to that, in our linked list structure we need to relink the chain c1-...-cn in reverse order.
1144  * so we gain the order: a - cn - cn-1 - ... - c2 - c1 - z
1145  */
1146 
1147  /* if negated variable is first node in cycle,
1148  * cross-linking not possible because there is no successor z of neg(x) contained in cycle yet
1149  */
1150  if( negx == startnode )
1151  {
1152  *success = FALSE;
1153  return SCIP_OKAY;
1154  }
1155 
1156  /* if original and negated variable are neighbors, cross linking is not possible,
1157  * but x and neg(x) can simply be removed
1158  * a - neg(x)=pred[a] - x=pred[neg(x)] - z=pred[x] --> a - z=pred[x]=:pred[a]
1159  */
1160  if( pred[negx] == x )
1161  {
1162  unsigned int a;
1163 
1164  /* find a */
1165  a = startnode;
1166  while( pred[a] != negx )
1167  a = pred[a];
1168 
1169  /* link a and z */
1170  pred[a] = pred[x];
1171  }
1172  /* cross linking as mentioned above */
1173  else
1174  {
1175  unsigned int a;
1176  unsigned int z;
1177 
1178  /* memory for chain reverse */
1179  unsigned int* chain;
1180  unsigned int nchain;
1181 
1182  unsigned int i;
1183 
1184  /* allocate temporary memory */
1185  SCIP_CALL( SCIPallocBufferArray(scip, &chain, (int) *ncyclevars) );
1186 
1187  /* find and store a */
1188  a = startnode;
1189  while( pred[a] != negx )
1190  a = pred[a];
1191 
1192  /* store chain */
1193  i = pred[negx];
1194  nchain = 0;
1195  while( i != x )
1196  {
1197  chain[nchain] = i;
1198  ++nchain;
1199  i = pred[i];
1200  }
1201  assert(nchain > 0);
1202 
1203  /* store z */
1204  z = pred[x];
1205 
1206  /* link a and c1 */
1207  pred[a] = chain[nchain-1];
1208 
1209  /* link cn and z */
1210  pred[chain[0]] = z;
1211 
1212  /* reverse the chain */
1213  for( i = nchain-1; i > 0; --i )
1214  pred[chain[i]] = chain[i-1];
1215 
1216  /* free temporary memory */
1217  SCIPfreeBufferArray(scip, &chain);
1218  }
1219 
1220  /* remove negated variable from cycle */
1221  assert(!incycle[x] && incycle[negx]);
1222  incycle[negx] = FALSE;
1223  --(*ncyclevars);
1224 
1225  return SCIP_OKAY;
1226 }
1227 
1228 
1229 /*
1230  * methods for separateHeur()
1231  */
1232 
1233 /** memory reallocation method (the graph is normally very dense, so we dynamically allocate only the memory we need)
1234  *
1235  * Since the array sizes differ the method can be called for each of the three data structure types:
1236  * - Forward: sizeForward, targetForward, weightForward
1237  * - Backward: sizeBackward, targetBackward, weightBackward
1238  * - Adj (inner level edges): sizeAdj, sourceAdj, targetAdj, weightAdj
1239  */
1240 static
1241 SCIP_RETCODE checkArraySizesHeur(
1242  SCIP* scip, /**< SCIP data structure */
1243  LEVELGRAPH* graph, /**< LEVELGRAPH data structure */
1244  unsigned int* size, /**< given size */
1245  int** targetArray, /**< given target array (or NULL if sourceAdjArray and targetAdjArray given) */
1246  unsigned int** weightArray, /**< given weight array */
1247  unsigned int** sourceAdjArray, /**< given sourceAdj array (or NULL if targetArray given) */
1248  unsigned int** targetAdjArray, /**< given targetAdj array (or NULL if targetArray given) */
1249  SCIP_Bool* success /**< FALSE, iff memory reallocation fails */
1250  )
1251 {
1252  SCIP_Real memorylimit;
1253  unsigned int additional;
1254  SCIP_Bool avoidmemout;
1255 
1256  assert(scip != NULL);
1257  assert(graph != NULL);
1258  assert(size != NULL);
1259  assert(targetArray != NULL || (sourceAdjArray != NULL && targetAdjArray != NULL));
1260  assert(weightArray != NULL);
1261  assert(success != NULL);
1262 
1263  SCIPdebugMsg(scip, "reallocating...\n");
1264 
1265  additional = MIN(graph->maxarcs + graph->maxnodes - *size, *size) * ((int) sizeof(**weightArray));
1266  if( targetArray != NULL )
1267  {
1268  additional += MIN(graph->maxarcs + graph->maxnodes - *size, *size) * ((int) sizeof(**targetArray));
1269  }
1270  else
1271  {
1272  additional += MIN(graph->maxarcs + graph->maxnodes - *size, *size) * ((int) sizeof(**sourceAdjArray));
1273  additional += MIN(graph->maxarcs + graph->maxnodes - *size, *size) * ((int) sizeof(**targetAdjArray));
1274  }
1275 
1276  SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
1277  if( !SCIPisInfinity(scip, memorylimit) )
1278  {
1279  memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
1280  memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
1281  }
1282 
1283  SCIP_CALL( SCIPgetBoolParam(scip, "misc/avoidmemout", &avoidmemout) );
1284  /* if memorylimit would be exceeded or any other limit is reached free all data and exit */
1285  if( (avoidmemout && memorylimit <= additional/1048576.0) || SCIPisStopped(scip) )
1286  {
1287  *success = FALSE;
1288  SCIPdebugMsg(scip, "...memory limit exceeded\n");
1289  return SCIP_OKAY;
1290  }
1291 
1292  *size = 2 * (*size);
1293 
1294  SCIP_CALL( SCIPreallocBufferArray(scip, weightArray, (int) MIN(graph->maxarcs + graph->maxnodes, *size)) );
1295  if( targetArray != NULL )
1296  {
1297  SCIP_CALL( SCIPreallocBufferArray(scip, targetArray, (int) MIN(graph->maxarcs + graph->maxnodes, *size)) );
1298  }
1299  else
1300  {
1301  assert(sourceAdjArray != NULL);
1302  assert(targetAdjArray != NULL);
1303  SCIP_CALL( SCIPreallocBufferArray(scip, sourceAdjArray, (int) MIN(graph->maxarcs, *size)) );
1304  SCIP_CALL( SCIPreallocBufferArray(scip, targetAdjArray, (int) MIN(graph->maxarcs, *size)) );
1305  }
1306 
1307  /* if memorylimit is exceeded free all data and exit */
1308  SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
1309  if( !SCIPisInfinity(scip, memorylimit) )
1310  {
1311  memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
1312  memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
1313  }
1314 
1315  if( avoidmemout && memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
1316  {
1317  *success = FALSE;
1318  SCIPdebugMsg(scip, "...memory limit exceeded\n");
1319  return SCIP_OKAY;
1320  }
1321 
1322  SCIPdebugMsg(scip, "...with success\n");
1323 
1324  return SCIP_OKAY;
1325 }
1326 
1327 /** Add arc to level graph */
1328 static
1329 SCIP_RETCODE addArc(
1330  SCIP* scip, /**< SCIP data structure */
1331  LEVELGRAPH* graph, /**< LEVELGRAPH data structure */
1332  unsigned int u, /**< source node */
1333  unsigned int v, /**< target node */
1334  unsigned int level, /**< number of current level */
1335  unsigned int weight, /**< weight of the arc */
1336  unsigned int* nAdj, /**< array of numbers of arcs inside levels */
1337  SCIP_Bool* success /**< FALSE, iff memory reallocation fails */
1338  )
1339 {
1340  /* arc is a forward arc */
1341  if( graph->level[v] == level+1 )
1342  {
1343  graph->targetForward[graph->lastF] = (int) v;
1344  graph->weightForward[graph->lastF] = weight;
1345  ++(graph->lastF);
1346  ++(graph->narcs);
1347  if( graph->lastF == graph->sizeForward )
1348  {
1349  SCIP_CALL( checkArraySizesHeur(scip, graph, &(graph->sizeForward), &(graph->targetForward),
1350  &(graph->weightForward), NULL, NULL, success) );
1351  if( !(*success) )
1352  return SCIP_OKAY;
1353  }
1354  }
1355  else
1356  {
1357  assert(graph->level[v] == level || graph->level[v] == level-1);
1358 
1359  /* arc is a backward arc */
1360  if( graph->level[v] == level-1 )
1361  {
1362  graph->targetBackward[graph->lastB] = (int) v;
1363  graph->weightBackward[graph->lastB] = weight;
1364  ++(graph->lastB);
1365  ++(graph->narcs);
1366 
1367  if( graph->lastB == graph->sizeBackward )
1368  {
1369  SCIP_CALL( checkArraySizesHeur(scip, graph, &(graph->sizeBackward), &(graph->targetBackward),
1370  &(graph->weightBackward), NULL, NULL, success) );
1371  if( !(*success) )
1372  return SCIP_OKAY;
1373  }
1374  }
1375  else /* arc is in the same level */
1376  {
1377  assert(graph->level[v] == level);
1378 
1379  /* add arc only once, i.e., if u < v */
1380  if( u < v )
1381  {
1382  graph->sourceAdj[graph->levelAdj[level+1]+*nAdj] = u;
1383  graph->targetAdj[graph->levelAdj[level+1]+*nAdj] = v;
1384  graph->weightAdj[graph->levelAdj[level+1]+*nAdj] = weight;
1385  ++(*nAdj);
1386  ++(graph->narcs);
1387 
1388  if( graph->levelAdj[level+1]+*nAdj == graph->sizeAdj )
1389  {
1390  SCIP_CALL( checkArraySizesHeur(scip, graph, &(graph->sizeAdj), NULL, &(graph->weightAdj),
1391  &(graph->sourceAdj), &(graph->targetAdj), success) );
1392  if( !(*success) )
1393  return SCIP_OKAY;
1394  }
1395  }
1396  }
1397  }
1398  return SCIP_OKAY;
1399 }
1400 
1401 /** add implications from cliques of the given node u
1402  *
1403  * @see createNextLevel()
1404  */
1405 static
1406 SCIP_RETCODE addNextLevelCliques(
1407  SCIP* scip, /**< SCIP data structure */
1408  SCIP_SEPADATA* sepadata, /**< separator data structure */
1409  SCIP_VAR** vars, /**< problem variables */
1410  SCIP_Real* vals, /**< values of the binary variables in the current LP relaxation */
1411  unsigned int u, /**< current node */
1412  LEVELGRAPH* graph, /**< LEVELGRAPH data structure */
1413  unsigned int level, /**< number of current level */
1414  SCIP_Bool* inlevelgraph, /**< flag array if node is already inserted in level graph */
1415  unsigned int* newlevel, /**< array of nodes of the next level */
1416  unsigned int* nnewlevel, /**< number of nodes of the next level */
1417  unsigned int* nAdj, /**< array of numbers of arcs inside levels */
1418  SCIP_Bool* success /**< FALSE, iff memory reallocation fails */
1419  )
1420 {
1421  SCIP_Bool varfixing;
1422  unsigned int ncliques;
1423  unsigned int nbinvars;
1424  unsigned int varsidx;
1425  SCIP_CLIQUE** cliques;
1426  unsigned int ncliquevars;
1427  SCIP_VAR** cliquevars;
1428  SCIP_Bool* cliquevals;
1429  unsigned int j;
1430  unsigned int k;
1431 
1432  assert(scip != NULL);
1433  assert(vars != NULL);
1434  assert(vals != NULL);
1435  assert(graph != NULL);
1436  assert(graph->targetForward != NULL);
1437  assert(graph->weightForward != NULL);
1438  assert(graph->targetBackward != NULL);
1439  assert(graph->weightBackward != NULL);
1440  assert(graph->sourceAdj != NULL);
1441  assert(graph->targetAdj != NULL);
1442  assert(graph->weightAdj != NULL);
1443  assert(inlevelgraph != NULL);
1444  assert(newlevel != NULL);
1445  assert(nnewlevel != NULL);
1446  assert(nAdj != NULL);
1447  assert(success != NULL);
1448 
1449  assert(u < graph->maxnodes);
1450 
1451  nbinvars = (graph->maxnodes)/2;
1452 
1453  /* current node signifies a problem variable */
1454  if( u < nbinvars )
1455  {
1456  varfixing = TRUE;
1457  varsidx = u;
1458  }
1459  /* current node signifies a negated variable */
1460  else
1461  {
1462  varfixing = FALSE;
1463  varsidx = u - nbinvars;
1464  }
1465  assert(varsidx < nbinvars);
1466  assert(!SCIPisFeasIntegral(scip, vals[varsidx]));
1467 
1468  /* get cliques of the current variable */
1469  ncliques = (unsigned int) SCIPvarGetNCliques(vars[varsidx], varfixing);
1470  if( ncliques == 0 )
1471  return SCIP_OKAY;
1472 
1473  cliques = SCIPvarGetCliques(vars[varsidx], varfixing);
1474  assert(cliques != NULL);
1475 
1476  for( j = 0; j < ncliques; ++j )
1477  {
1478  ncliquevars = (unsigned int) SCIPcliqueGetNVars(cliques[j]);
1479  cliquevars = SCIPcliqueGetVars(cliques[j]);
1480  cliquevals = SCIPcliqueGetValues(cliques[j]);
1481 
1482  assert(cliquevars != NULL || ncliquevars == 0);
1483  assert(cliquevals != NULL || ncliquevars == 0);
1484 
1485  for( k = 0; k < ncliquevars; ++k )
1486  {
1487  unsigned int l;
1488  unsigned int v;
1489  unsigned int weight;
1490 
1491  assert( cliquevars != NULL && cliquevals != NULL ); /* for lint */
1492 
1493  l = sepadata->mapping[SCIPvarGetProbindex(cliquevars[k])];
1494  assert(l < nbinvars);
1495 
1496  /* skip integral neighbors */
1497  if( SCIPisFeasIntegral(scip, vals[l]) )
1498  continue;
1499 
1500  /* consider clique with negated variable (x = 1 -> y >= 1 <=> x = 1 -> neg(y) <= 0) */
1501  if( cliquevals[k] == FALSE )
1502  v = l + nbinvars;
1503  /* x = 1 -> y <= 0 */
1504  else
1505  v = l;
1506  assert(v < graph->maxnodes);
1507 
1508  /* if variable is a new node, it will be assigned to the next level,
1509  * but if the level contains more nodes than allowed
1510  * (defined by percent per level plus offset),
1511  * we skip the rest of the nodes
1512  */
1513  if( !inlevelgraph[v] && (*nnewlevel) <= sepadata->maxlevelsize )
1514  {
1515  ++(graph->nnodes);
1516  graph->level[v] = level+1;
1517  inlevelgraph[v] = TRUE;
1518  newlevel[*nnewlevel] = v;
1519  ++(*nnewlevel);
1520  }
1521  assert(*nnewlevel > sepadata->maxlevelsize || inlevelgraph[v]);
1522 
1523  /* calculate arc weight and add arc, if the neighbor node is on the same or a neighbor level */
1524  if( inlevelgraph[v] && (graph->level[v] == level+1 || graph->level[v] == level || graph->level[v] == level-1))
1525  {
1526  int tmp;
1527 
1528  /* the computation of 1.0 - vals[v] if v is negated is ensured by the fact that v > nbinvars in this case */
1529  /* set weight of arc (x,y) to 1 - x* -y* */
1530  if( varfixing )
1531  {
1532  /* x = 1 -> y <= 0 or y >= 1 */
1533  tmp = (int) SCIPfeasCeil(scip, sepadata->scale * (1 - vals[varsidx] - vals[v]));
1534  weight = (unsigned int) MAX(tmp, sepadata->maxreference);
1535  }
1536  else
1537  {
1538  /* x = 0 <-> neg(x) = 1 -> y <= 0 or y >= 1 */
1539  tmp = (int) SCIPfeasCeil(scip, sepadata->scale * (1.0 - (1.0 - vals[varsidx]) - vals[v]));
1540  weight = (unsigned int) MAX(tmp, sepadata->maxreference);
1541  }
1542 
1543  /* add arc from current to neighbor node */
1544  SCIP_CALL( addArc(scip, graph, u, v, level, weight, nAdj, success) );
1545  if( !(*success) )
1546  return SCIP_OKAY;
1547  }
1548  }
1549  }
1550  return SCIP_OKAY;
1551 }
1552 
1553 
1554 /** sort level of root neighbors
1555  *
1556  * If we limit the size of nodes of a level, we want to add the best neighbors to the next level.
1557  * Since sorting every level is too expensive, we sort the neighbors of the root (if requested).
1558  *
1559  * Create the first level as follows:
1560  * - create flag array for binary variables and their negated and set their values FALSE
1561  * - iterate over the implication and clique neighbors of the root and set their flag array values to TRUE
1562  * - create variable array and insert all variables with flag value TRUE
1563  * - sort variable array by maximal fractionality
1564  * - add variables from sorted array to levelgraph until first level is full (or all variables are inserted)
1565  *
1566  * Even inserting all variables might help for the following creation of further levels since the neighbors
1567  * of nodes with high fractionality often have high fractionalities themselves and would be inserted first
1568  * when further levels would have been sorted (which actually is not the case).
1569  */
1570 static
1571 SCIP_RETCODE insertSortedRootNeighbors(
1572  SCIP* scip, /**< SCIP data structure */
1573  LEVELGRAPH* graph, /**< LEVELGRAPH data structure */
1574  unsigned int nbinvars, /**< number of binary problem variables */
1575  unsigned int ncurlevel, /**< number of nodes of the current level */
1576  unsigned int u, /**< source node */
1577  SCIP_Real* vals, /**< values of the binary variables in the current LP relaxation */
1578  SCIP_VAR** vars, /**< problem variables */
1579  SCIP_SEPADATA* sepadata, /**< separator data structure */
1580  unsigned int* nnewlevel, /**< number of nodes of the next level */
1581  SCIP_Bool* inlevelgraph, /**< nodes in new graph corr. to old graph (-1 if unassigned) */
1582  unsigned int level, /**< number of current level */
1583  unsigned int* newlevel, /**< array of nodes of the next level */
1584  SCIP_Bool* success /**< FALSE, iff memory reallocation fails */
1585  )
1586 {
1587  /* storage for the neighbors of the root */
1588  unsigned int root;
1589  unsigned int nneighbors;
1590  SCIP_Bool* isneighbor;
1591  int* neighbors;
1592  SCIP_Real* sortvals;
1593 
1594  SCIP_Bool varfixing;
1595  unsigned int varsidx;
1596 
1597  /* storage for cliques to the neighbors of the root node */
1598  unsigned int ncliques;
1599  SCIP_CLIQUE** cliques;
1600  unsigned int ncliquevars;
1601  SCIP_VAR** cliquevars;
1602  SCIP_Bool* cliquevals;
1603 
1604  unsigned int j;
1605  unsigned int k;
1606  unsigned int v;
1607 
1608  /* allocate flag array for neighbor detection */
1609  SCIP_CALL( SCIPallocBufferArray(scip, &isneighbor, (int) graph->maxnodes) );
1610  BMSclearMemoryArray(isneighbor, graph->maxnodes);
1611 
1612  nbinvars = (graph->maxnodes)/2;
1613 
1614  assert(ncurlevel == 1);
1615  root = u;
1616 
1617  /* current node signifies a problem variable */
1618  if( root < nbinvars )
1619  {
1620  varfixing = TRUE;
1621  varsidx = root;
1622  }
1623  /* current node signifies a negated variable */
1624  else
1625  {
1626  varfixing = FALSE;
1627  varsidx = root - nbinvars;
1628  }
1629  assert(varsidx < nbinvars);
1630  assert(! SCIPisFeasIntegral(scip, vals[varsidx]));
1631  nneighbors = 0;
1632 
1633  /* count cliques of the root */
1634  ncliques = (unsigned int) SCIPvarGetNCliques(vars[varsidx], varfixing);
1635  if( ncliques > 0 )
1636  {
1637  cliques = SCIPvarGetCliques(vars[varsidx], varfixing);
1638  assert(cliques != NULL);
1639 
1640  for( j = 0; j < ncliques; ++j )
1641  {
1642  ncliquevars = (unsigned int) SCIPcliqueGetNVars(cliques[j]);
1643  cliquevars = SCIPcliqueGetVars(cliques[j]);
1644  cliquevals = SCIPcliqueGetValues(cliques[j]);
1645 
1646  assert(cliquevars != NULL || ncliquevars == 0);
1647  assert(cliquevals != NULL || ncliquevars == 0);
1648 
1649  for( k = 0; k < ncliquevars; ++k )
1650  {
1651  unsigned int kidx;
1652 
1653  assert( cliquevars != NULL && cliquevals != NULL ); /* for lint */
1654 
1655  kidx = sepadata->mapping[SCIPvarGetProbindex(cliquevars[k])];
1656  assert(kidx < nbinvars);
1657 
1658  /* skip root */
1659  if( kidx == varsidx )
1660  continue;
1661 
1662  /* skip integral neighbors */
1663  if( SCIPisFeasIntegral(scip, vals[kidx]))
1664  continue;
1665 
1666  if( cliquevals[k] == TRUE )
1667  {
1668  if ( ! isneighbor[kidx] )
1669  {
1670  ++nneighbors;
1671  isneighbor[kidx] = TRUE;
1672  }
1673  }
1674  else
1675  {
1676  assert(cliquevals[k] == FALSE);
1677  if ( ! isneighbor[kidx + nbinvars] )
1678  {
1679  ++nneighbors;
1680  isneighbor[kidx+nbinvars] = TRUE;
1681  }
1682  }
1683  }
1684  }
1685  }
1686 
1687  /* root cannot be part of the next level */
1688  assert(! isneighbor[root]);
1689 
1690  /* allocate memory for sorting of root neighbors */
1691  SCIP_CALL( SCIPallocBufferArray(scip, &neighbors, (int) nneighbors) );
1692  SCIP_CALL( SCIPallocBufferArray(scip, &sortvals, (int) nneighbors) );
1693 
1694  k = 0;
1695  for( j = 0; j < graph->maxnodes; ++j )
1696  {
1697  if( isneighbor[j] )
1698  {
1699  assert(j != root);
1700  assert(!SCIPisFeasIntegral(scip, vals[j]));
1701 
1702  neighbors[k] = (int) j;
1703  sortvals[k] = MIN(1.0 - vals[j], vals[j]);
1704  ++k;
1705  }
1706  }
1707  assert(k == nneighbors);
1708 
1709  /* sort neighbors by fractionality */
1710  SCIPsortDownRealInt(sortvals, neighbors, (int) nneighbors);
1711 
1712  /* free temporary memory */
1713  SCIPfreeBufferArray(scip, &sortvals);
1714 
1715  /* insert sorted neighbors until level size limit is reached (or all neighbors are inserted) */
1716  for( j = 0; j < nneighbors && (*nnewlevel) <= sepadata->maxlevelsize; ++j )
1717  {
1718  int tmp;
1719 
1720  v = (unsigned int) neighbors[j];
1721  assert( v < 2 * nbinvars );
1722 
1723  /* only the root is contained in the levelgraph */
1724  assert(! inlevelgraph[v] || v == root+nbinvars || v == root-nbinvars);
1725 
1726  /* insert neighbor into levelgraph */
1727  ++(graph->nnodes);
1728  graph->level[v] = level + 1;
1729  inlevelgraph[v] = TRUE;
1730  newlevel[*nnewlevel] = v;
1731  ++(*nnewlevel);
1732 
1733  assert(! SCIPisFeasIntegral(scip, vals[varsidx]));
1734  assert(! SCIPisFeasIntegral(scip, vals[v]));
1735 
1736  graph->targetForward[graph->lastF] = (int) v;
1737  /* the computation of 1.0 - vals[v] if v is negated is ensured by the fact that v > nbinvars in this case */
1738  if( varfixing )
1739  {
1740  tmp = (int) SCIPfeasCeil(scip, sepadata->scale * (1.0 - vals[varsidx] - vals[v]));
1741  graph->weightForward[graph->lastF] = (unsigned int) MAX(tmp, sepadata->maxreference);
1742  }
1743  else
1744  {
1745  assert( ! varfixing );
1746  tmp = (int) SCIPfeasCeil(scip, sepadata->scale * (1.0 - (1.0 - vals[varsidx]) - vals[v]));
1747  graph->weightForward[graph->lastF] = (unsigned int) MAX(tmp, sepadata->maxreference);
1748  }
1749  ++(graph->lastF);
1750  ++(graph->narcs);
1751  if( graph->lastF == graph->sizeForward )
1752  {
1753  SCIP_CALL( checkArraySizesHeur(scip, graph, &(graph->sizeForward), &(graph->targetForward),
1754  &(graph->weightForward), NULL, NULL, success) );
1755 
1756  if( !(*success) )
1757  break;
1758  }
1759  }
1760 
1761  /* free temporary memory */
1762  SCIPfreeBufferArray(scip, &neighbors);
1763  SCIPfreeBufferArray(scip, &isneighbor);
1764 
1765  return SCIP_OKAY;
1766 }
1767 
1768 /** Find shortest path from start node to root
1769  *
1770  * We perform a BFS to find the shortest path to the root. D stores the distance to the start
1771  * node, P stores the partent nodes in the shortest path tree (-1 if node has not been reached).
1772  */
1773 static
1774 SCIP_RETCODE findShortestPathToRoot(
1775  SCIP* scip, /**< SCIP data structure */
1776  int scale, /**< scaling factor for edge weights */
1777  LEVELGRAPH* graph, /**< LEVELGRAPH data structure */
1778  unsigned int startnode, /**< start node for path search */
1779  unsigned int* distance, /**< distances of searched nodes from root */
1780  unsigned int* queue, /**< node queue for path search */
1781  SCIP_Bool* inQueue, /**< whether node is in the queue */
1782  int* parentTree /**< parent tree (-1 if no parent) */
1783  )
1784 {
1785  unsigned int i;
1786  int startQueue;
1787  int endQueue;
1788  unsigned int u;
1789  int v;
1790  unsigned int d;
1791 
1792  assert(scip != NULL);
1793  assert(graph != NULL);
1794  assert(graph->beginBackward != NULL);
1795  assert(graph->targetBackward != NULL);
1796  assert(graph->weightBackward != NULL);
1797  assert(distance != NULL);
1798  assert(queue != NULL);
1799  assert(inQueue != NULL);
1800  assert(parentTree != NULL);
1801  assert(scale >= 0);
1802 
1803  /* initialize distances */
1804  for( i = 0; i < graph->maxnodes; ++i )
1805  {
1806  distance[i] = 2 * (graph->nnodes) * (unsigned) scale;
1807  parentTree[i] = -1;
1808  inQueue[i] = FALSE;
1809  }
1810  distance[startnode] = 0;
1811 
1812  /* initialize queue */
1813  startQueue = 0;
1814  endQueue = 0;
1815  queue[0] = startnode;
1816 
1817  /* as long as queue is not empty */
1818  while( startQueue <= endQueue )
1819  {
1820  /* pop first node from queue */
1821  u = queue[startQueue];
1822  ++startQueue;
1823 
1824  /* check adjacent nodes */
1825  assert(graph->beginBackward[u] >= 0);
1826  i = (unsigned int) graph->beginBackward[u];
1827  for( v = graph->targetBackward[i]; v >= 0; v = graph->targetBackward[++i] )
1828  {
1829  /* distance to u via current arc: */
1830  d = distance[u] + graph->weightBackward[i];
1831 
1832  /* if we found a shorter connection */
1833  if( d < distance[v] )
1834  {
1835  distance[v] = d;
1836  parentTree[v] = (int) u;
1837 
1838  /* insert in queue if not already present */
1839  if( !inQueue[v] )
1840  {
1841  ++endQueue;
1842  queue[endQueue] = (unsigned int) v;
1843  inQueue[v] = TRUE;
1844  }
1845  }
1846  }
1847  /* it is not necessary to stop if we found the root (in this case there are no arcs left) and we stop anyway */
1848  }
1849  assert(parentTree[u] != -1);
1850 
1851  return SCIP_OKAY;
1852 }
1853 
1854 
1855 /** Block shortest path
1856  *
1857  * We traverse the shortest path found by findShortestPathToRoot() and block all neighbors (in the
1858  * original graph) of nodes in the path, i.e., we set blocked to TRUE. We do not block neighbors of
1859  * the root node, since they have to be used. For the start node we only block nodes on the
1860  * previous layers,
1861  *
1862  * @see findShortestPathToRoot()
1863  */
1864 static
1865 SCIP_RETCODE blockRootPath(
1866  SCIP* scip, /**< SCIP data structure */
1867  LEVELGRAPH* graph, /**< LEVELGRAPH data structure */
1868  unsigned int startnode, /**< start node */
1869  SCIP_Bool* inlevelgraph, /**< nodes in new graph corr. to old graph (-1 if unassigned) */
1870  SCIP_Bool* blocked, /**< whether node is blocked */
1871  int* parentTree, /**< parent tree */
1872  unsigned int root /**< root of the current level graph */
1873  )
1874 {
1875  unsigned int u;
1876  unsigned int i;
1877  int v;
1878 
1879  assert(scip != NULL);
1880  assert(graph != NULL);
1881  assert(graph->level != NULL);
1882  assert(graph->beginForward != NULL);
1883  assert(graph->targetForward != NULL);
1884  assert(graph->beginBackward != NULL);
1885  assert(graph->targetBackward != NULL);
1886  assert(graph->sourceAdj != NULL);
1887  assert(graph->targetAdj != NULL);
1888  assert(inlevelgraph != NULL);
1889  assert(blocked != NULL);
1890  assert(parentTree != NULL);
1891 
1892  assert(parentTree[root] >= 0);
1893 
1894  /* follow the path from the predecessor of root to the start node and block all neighbors */
1895  u = (unsigned int) parentTree[root];
1896  while( u != startnode )
1897  {
1898  /* block neighbors of u in higher level */
1899  i = (unsigned int) graph->beginForward[u];
1900  for( v = graph->targetForward[i]; v >= 0; v = graph->targetForward[++i] )
1901  {
1902  assert(inlevelgraph[v]);
1903  blocked[v] = TRUE;
1904  }
1905 
1906  /* block neighbors of u in lower level */
1907  i = (unsigned int) graph->beginBackward[u];
1908  for( v = graph->targetBackward[i]; v >= 0; v = graph->targetBackward[++i] )
1909  {
1910  assert(inlevelgraph[v]);
1911  blocked[v] = TRUE;
1912  }
1913 
1914  /* block neighbors of u in same level */
1915  assert(graph->level[u] > 0);
1916  for( i = graph->levelAdj[graph->level[u]]; i < graph->levelAdj[graph->level[u]+1]; ++i )
1917  {
1918  assert(graph->sourceAdj[i] < graph->targetAdj[i]);
1919  assert(graph->level[graph->sourceAdj[i]] == graph->level[graph->targetAdj[i]]);
1920 
1921  /* remember that these arcs are only stored for one direction */
1922  if( graph->sourceAdj[i] == u )
1923  {
1924  blocked[graph->targetAdj[i]] = TRUE;
1925  }
1926  if( graph->targetAdj[i] == u )
1927  {
1928  blocked[graph->sourceAdj[i]] = TRUE;
1929  }
1930  }
1931 
1932  /* get next node on the path */
1933  u = (unsigned int) parentTree[u];
1934  }
1935  assert(u == startnode);
1936 
1937  /* block nodes adjacent to start node on previous level */
1938  assert(graph->beginBackward[u] > 0);
1939  i = (unsigned int) graph->beginBackward[u];
1940  for( v = graph->targetBackward[i]; v >= 0; v = graph->targetBackward[++i] )
1941  blocked[v] = TRUE;
1942 
1943  return SCIP_OKAY;
1944 }
1945 
1946 
1947 /** Find shortest path from root to target node
1948  *
1949  * We perform a BFS to find the shortest path from the root. The only difference to
1950  * findShortestPathToRoot() is that we avoid nodes that are blocked.
1951  */
1952 static
1953 SCIP_RETCODE
1954 findUnblockedShortestPathToRoot(
1955  SCIP* scip, /**< SCIP data structure */
1956  int scale, /**< scaling factor for edge weights */
1957  LEVELGRAPH* graph, /**< LEVELGRAPH data structure */
1958  unsigned int startnode, /**< start node for path search */
1959  unsigned int* distance, /**< distances of searched nodes from root */
1960  unsigned int* queue, /**< node queue for path search */
1961  SCIP_Bool* inQueue, /**< whether node is in the queue */
1962  int* parentTreeBackward, /**< parent tree (-1 if no parent) */
1963  unsigned int root, /**< root of the current level graph */
1964  SCIP_Bool* blocked /**< whether nodes can be used */
1965  )
1966 {
1967  unsigned int i;
1968  int startQueue;
1969  int endQueue;
1970  unsigned int u;
1971  int v;
1972  unsigned int d;
1973  int* parentTree;
1974  int* transform;
1975 
1976  assert(scip != NULL);
1977  assert(graph != NULL);
1978  assert(graph->beginBackward != NULL);
1979  assert(graph->targetBackward != NULL);
1980  assert(graph->weightBackward != NULL);
1981  assert(distance != NULL);
1982  assert(queue != NULL);
1983  assert(inQueue != NULL);
1984  assert(scale >= 0);
1985 
1986  /* allocate temporary memory */
1987  SCIP_CALL( SCIPallocBufferArray(scip, &parentTree, (int) graph->maxnodes) );
1988  SCIP_CALL( SCIPallocBufferArray(scip, &transform, (int) graph->maxnodes) );
1989 
1990  assert(parentTree != NULL);
1991  assert(transform != NULL);
1992 
1993  /* initialize distances */
1994  for( i = 0; i < graph->maxnodes; ++i )
1995  {
1996  distance[i] = 2 * (graph->nnodes) * (unsigned)scale;
1997  parentTree[i] = -1;
1998  parentTreeBackward[i] = -1;
1999  transform[i] = -1;
2000  inQueue[i] = FALSE;
2001  }
2002  distance[startnode] = 0;
2003 
2004  /* initialize queue */
2005  startQueue = 0;
2006  endQueue = 0;
2007  queue[0] = startnode;
2008 
2009  /* as long as queue is not empty */
2010  while( startQueue <= endQueue )
2011  {
2012  /* pop first node from queue */
2013  u = queue[startQueue];
2014  ++startQueue;
2015 
2016  /* check adjacent nodes */
2017  assert(graph->beginBackward[u] >= 0);
2018  i = (unsigned int) graph->beginBackward[u];
2019  for( v = graph->targetBackward[i]; v >= 0; v = graph->targetBackward[++i] )
2020  {
2021  if( blocked[v] && v != (int) root)
2022  continue;
2023 
2024  /* distance to u via current arc: */
2025  d = distance[u] + graph->weightBackward[i];
2026 
2027  /* if we found a shorter connection */
2028  if( d < distance[v] )
2029  {
2030  distance[v] = d;
2031  parentTree[v] = (int) u;
2032 
2033  /* insert in queue if not already present */
2034  if( !inQueue[v] )
2035  {
2036  ++endQueue;
2037  queue[endQueue] = (unsigned int) v;
2038  inQueue[v] = TRUE;
2039  }
2040  }
2041  }
2042  /* it is not necessary to stop if we found the root (in this case there are no arcs left) and we stop anyway */
2043  }
2044 
2045  /* reverse order such that it is a path from the root */
2046  v = (int) root;
2047  transform[0] = (int) root;
2048  i = 1;
2049  while(parentTree[v] >= 0)
2050  {
2051  transform[i] = parentTree[v];
2052  ++i;
2053  v = parentTree[v];
2054  }
2055  --i;
2056  while(i > 0)
2057  {
2058  parentTreeBackward[transform[i]] = transform[i-1];
2059  --i;
2060  }
2061 
2062  /* free temporary memory */
2063  SCIPfreeBufferArray(scip, &transform);
2064  SCIPfreeBufferArray(scip, &parentTree);
2065 
2066  return SCIP_OKAY;
2067 }
2068 
2069 /** create next level of level graph for odd cycle separation
2070  *
2071  * @see separateHeur()
2072  */
2073 static
2074 SCIP_RETCODE createNextLevel(
2075  SCIP* scip, /**< SCIP data structure */
2076  SCIP_SEPADATA* sepadata, /**< separator data structure */
2077  SCIP_VAR** vars, /**< problem variables */
2078  SCIP_Real* vals, /**< values of the binary variables in the current LP relaxation */
2079  LEVELGRAPH* graph, /**< LEVELGRAPH data structure */
2080  unsigned int level, /**< number of current level */
2081  SCIP_Bool* inlevelgraph, /**< flag array if node is already inserted in level graph */
2082  unsigned int* curlevel, /**< array of nodes of the current level */
2083  unsigned int ncurlevel, /**< number of nodes of the current level */
2084  unsigned int* newlevel, /**< array of nodes of the next level */
2085  unsigned int* nnewlevel, /**< number of nodes of the next level */
2086  SCIP_Bool* success /**< FALSE, iff memory reallocation fails */
2087  )
2088 {
2089  unsigned int i;
2090  unsigned int nbinvars;
2091  unsigned int nAdj;
2092 
2093  assert(scip != NULL);
2094  assert(vars != NULL);
2095  assert(vals != NULL);
2096  assert(graph != NULL);
2097  assert(graph->level != NULL);
2098  assert(graph->beginForward != NULL);
2099  assert(graph->targetForward != NULL);
2100  assert(graph->weightForward != NULL);
2101  assert(graph->beginBackward != NULL);
2102  assert(graph->targetBackward != NULL);
2103  assert(graph->weightBackward != NULL);
2104  assert(graph->beginAdj != NULL);
2105  assert(graph->levelAdj != NULL);
2106  assert(graph->sourceAdj != NULL);
2107  assert(graph->targetAdj != NULL);
2108  assert(graph->weightAdj != NULL);
2109  assert(inlevelgraph != NULL);
2110  assert(curlevel != NULL);
2111  assert(newlevel != NULL);
2112  assert(success != NULL);
2113 
2114  *nnewlevel = 0;
2115  nAdj = 0;
2116  assert(graph->maxnodes % 2 == 0);
2117  nbinvars = (graph->maxnodes)/2;
2118 
2119  /* for every node in current level add its implications and assign its neighbors to the next
2120  * level, if neighbor is not already existing in the level graph
2121  */
2122  for( i = 0; i < ncurlevel; ++i )
2123  {
2124  unsigned int negated;
2125  unsigned int u;
2126 
2127  /* get node */
2128  u = curlevel[i];
2129  assert(u < graph->maxnodes);
2130  assert(graph->level[u] == level);
2131  assert(graph->beginForward[u] < 0);
2132  assert(graph->beginBackward[u] < 0);
2133  assert(graph->beginAdj[u] < 0);
2134  assert(inlevelgraph[u]);
2135 
2136  /* get negated */
2137  if( u < nbinvars )
2138  negated = u + nbinvars;
2139  else
2140  negated = u - nbinvars;
2141  assert(negated < graph->maxnodes);
2142  assert(negated < nbinvars || u < nbinvars);
2143  assert(negated >= nbinvars || u >= nbinvars);
2144 
2145  /* initialize adjacency lists for node u */
2146  graph->beginForward[u] = (int) graph->lastF;
2147  graph->beginBackward[u] = (int) graph->lastB;
2148  graph->beginAdj[u] = (int) (graph->levelAdj[level+1] + nAdj);
2149 
2150  /* if we want to add arcs between a variable and its negated */
2151  if( sepadata->addselfarcs )
2152  {
2153  /* add negated variable, if not existing in the levelgraph,
2154  * but if the level contains more nodes than allowed
2155  * (defined by percent per level plus offset),
2156  * we skip the rest of the nodes
2157  */
2158  if( !inlevelgraph[negated] && (*nnewlevel) <= sepadata->maxlevelsize )
2159  {
2160  ++(graph->nnodes);
2161  graph->level[negated] = level+1;
2162  inlevelgraph[negated] = TRUE;
2163  newlevel[*nnewlevel] = negated;
2164  ++(*nnewlevel);
2165  }
2166  assert( *nnewlevel > sepadata->maxlevelsize || inlevelgraph[negated] );
2167 
2168  /* add self-arc if negated variable is on a neighbored level */
2169  if( inlevelgraph[negated] && ((graph->level[negated] == level - 1)
2170  || (graph->level[negated] == level) || (graph->level[negated] == level + 1)) )
2171  {
2172  /* add arc from u to its negated variable */
2173  SCIP_CALL( addArc(scip, graph, u, negated, level, 0, &nAdj, success) );
2174  if( !(*success) )
2175  return SCIP_OKAY;
2176  }
2177  }
2178 
2179  /* insert level of sorted root neighbors (if requested) */
2180  if( graph->nlevels == 0 && sepadata->sortrootneighbors )
2181  {
2182  SCIP_CALL( insertSortedRootNeighbors(scip, graph, nbinvars, ncurlevel, u, vals, vars,
2183  sepadata, nnewlevel, inlevelgraph, level, newlevel, success) );
2184  }
2185  else
2186  {
2187  SCIP_CALL( addNextLevelCliques(scip, sepadata, vars, vals, u, graph, level, inlevelgraph,
2188  newlevel, nnewlevel, &nAdj, success) );
2189  }
2190  if( !(*success) )
2191  return SCIP_OKAY;
2192 
2193  /* every node has a backward arc */
2194  assert(graph->lastB > (unsigned int) graph->beginBackward[u] || graph->nlevels == 0 );
2195 
2196  /* root has outgoing arcs otherwise we would have skipped it */
2197  assert(graph->lastF > 0);
2198 
2199  /* close adjacency lists */
2200  graph->targetForward[graph->lastF] = -1;
2201  ++(graph->lastF);
2202  if( graph->lastF == graph->sizeForward )
2203  {
2204  SCIP_CALL( checkArraySizesHeur(scip, graph, &(graph->sizeForward), &(graph->targetForward),
2205  &(graph->weightForward), NULL, NULL, success) );
2206 
2207  if( !(*success) )
2208  return SCIP_OKAY;
2209  }
2210  graph->targetBackward[graph->lastB] = -1;
2211  ++(graph->lastB);
2212  if( graph->lastB == graph->sizeBackward )
2213  {
2214  SCIP_CALL( checkArraySizesHeur(scip, graph, &(graph->sizeBackward), &(graph->targetBackward),
2215  &(graph->weightBackward), NULL, NULL, success) );
2216 
2217  if( !(*success) )
2218  return SCIP_OKAY;
2219  }
2220 
2221  /* terminate adjacency list with 0 for current level lifting */
2222  graph->sourceAdj[graph->levelAdj[level+1]+nAdj] = 0;
2223  graph->targetAdj[graph->levelAdj[level+1]+nAdj] = 0;
2224  }
2225  graph->levelAdj[level+2] = graph->levelAdj[level+1]+nAdj;
2226 
2227  return SCIP_OKAY;
2228 }
2229 
2230 /** The heuristic method for finding odd cycles by Hoffman, Padberg uses a level graph
2231  * which is constructed as follows:
2232  * First we choose a node (i.e. a variable of the problem or its negated) as root
2233  * and assign it to level 0 (and no other node is assigned to level 0).
2234  * All neighbors of the root are assigned to level 1 and the arcs between are added.
2235  *
2236  * In general:
2237  * All neighbors of nodes in level i that are assigned to level i+1, if they do not already appear in levels <= i.
2238  * All arcs between nodes in level i and their neighbors are added.
2239  *
2240  * In the construction we only take nodes that are contained in the fractional graph,
2241  * i.e., their current LP values are not integral.
2242  *
2243  * Since SCIP stores implications between original and negated variables,
2244  * the level graph has at most twice the number of fractional binary variables of the problem.
2245  *
2246  * Since the implication graph of SCIP is (normally) incomplete,
2247  * it is possible to use arcs between an original variable and its negated
2248  * to obtain more cycles which are valid but not found due to missing links.
2249  */
2250 static
2251 SCIP_RETCODE separateHeur(
2252  SCIP* scip, /**< SCIP data structure */
2253  SCIP_SEPA* sepa, /**< separator */
2254  SCIP_SEPADATA* sepadata, /**< separator data structure */
2255  SCIP_SOL* sol, /**< given primal solution */
2256  SCIP_RESULT* result /**< pointer to store the result of the separation call */
2257  )
2258 {
2259  /* memory for variable data */
2260  SCIP_VAR** scipvars; /* variables of the current SCIP (unsorted) */
2261  SCIP_VAR** vars; /* variables of the current SCIP (sorted if requested) */
2262  SCIP_Real* vals; /* LP-values of the variables (and negated variables) */
2263  unsigned int nbinvars; /* number of nodecandidates for implicationgraph */
2264  unsigned int* incut; /* flag array for check if a variable is already covered by a cut */
2265 
2266  /* storage for levelgraph */
2267  LEVELGRAPH graph;
2268  unsigned int* curlevel;
2269  unsigned int* newlevel;
2270  unsigned int ncurlevel;
2271  unsigned int nnewlevel;
2272  SCIP_Bool* inlevelgraph;
2273 
2274  /* storage for path finding */
2275  unsigned int* queue;
2276  SCIP_Bool* inQueue;
2277  int* parentTree;
2278  int* parentTreeBackward;
2279  unsigned int* distance;
2280  SCIP_Bool* blocked;
2281 
2282  /* counter and limits */
2283  unsigned int maxroots; /* maximum of level graph roots */
2284  unsigned int rootcounter; /* counter of tried roots */
2285  unsigned int ncutsroot; /* counter of cuts per root */
2286  unsigned int ncutslevel; /* counter of cuts per level */
2287 
2288  unsigned int i;
2289  unsigned int j;
2290  unsigned int k;
2291 
2292  int nscipbinvars;
2293  int nscipintvars;
2294  int nscipimplvars;
2295  int nintegral;
2296  int l;
2297 
2298  assert(scip != NULL);
2299  assert(sepadata != NULL);
2300  assert(result != NULL);
2301 
2302  SCIP_CALL( SCIPgetVarsData(scip, &scipvars, NULL, &nscipbinvars, &nscipintvars, &nscipimplvars, NULL) );
2303  assert(nscipbinvars >= 0);
2304  assert(nscipintvars >= 0);
2305  assert(nscipimplvars >= 0);
2306 
2307  nintegral = nscipbinvars + nscipintvars + nscipimplvars;
2308  assert(scipvars != NULL || ((nscipbinvars == 0) && (nscipintvars == 0) && (nscipimplvars == 0) && (nintegral == 0)));
2309 
2310  /* collect binary variables, including implicit binary */
2311  SCIP_CALL( SCIPallocBufferArray(scip, &vars, nintegral) );
2312  for (l = 0; l < nscipbinvars; ++l)
2313  vars[l] = scipvars[l]; /*lint !e613*/
2314 
2315  nbinvars = (unsigned int) nscipbinvars;
2316  for (l = nscipbinvars; l < nintegral; ++l)
2317  {
2318  assert( SCIPvarGetType(scipvars[l]) != SCIP_VARTYPE_CONTINUOUS ); /*lint !e613*/
2319  if ( SCIPvarIsBinary(scipvars[l]) ) /*lint !e613*/
2320  vars[nbinvars++] = scipvars[l]; /*lint !e613*/
2321  }
2322 
2323  if( nbinvars == 0 )
2324  {
2325  SCIPfreeBufferArray(scip, &vars);
2326  return SCIP_OKAY;
2327  }
2328 
2329  /* initialize flag array to avoid multiple cuts per variable, if requested by user-flag */
2330  SCIP_CALL( SCIPallocBufferArray(scip, &vals, (int) (2 * nbinvars)) );
2331 
2332  /* prepare values */
2333  assert( vars != NULL );
2334  switch( sepadata->sortswitch )
2335  {
2336  case UNSORTED :
2337  /* if no sorting is requested, we use the normal variable array */
2338  break;
2339 
2340  case MAXIMAL_LPVALUE :
2341  /* store lp-values */
2342  for( i = 0; i < nbinvars; ++i )
2343  vals[i] = SCIPgetSolVal(scip, sol, vars[i]);
2344 
2345  /* sort by lp-value, maximal first */
2346  SCIPsortDownRealPtr(vals, (void**)vars, (int) nbinvars);
2347  break;
2348 
2349  case MINIMAL_LPVALUE :
2350  /* store lp-values */
2351  for( i = 0; i < nbinvars; ++i )
2352  vals[i] = SCIPgetSolVal(scip, sol, vars[i]);
2353 
2354  /* sort by lp-value, minimal first */
2355  SCIPsortRealPtr(vals, (void**)vars, (int) nbinvars);
2356  break;
2357 
2358  case MAXIMAL_FRACTIONALITY :
2359  /* store lp-values and determine fractionality */
2360  for( i = 0; i < nbinvars; ++i )
2361  {
2362  vals[i] = SCIPgetSolVal(scip, sol, vars[i]);
2363  vals[i] = MIN(1.0 - vals[i], vals[i]);
2364  }
2365 
2366  /* sort by fractionality, maximal first */
2367  SCIPsortDownRealPtr(vals, (void**)vars, (int) nbinvars);
2368  break;
2369 
2370  case MINIMAL_FRACTIONALITY :
2371  /* store lp-values and determine fractionality */
2372  for( i = 0; i < nbinvars; ++i )
2373  {
2374  vals[i] = SCIPgetSolVal(scip, sol, vars[i]);
2375  vals[i] = MIN(1.0 - vals[i], vals[i]);
2376  }
2377 
2378  /* sort by fractionality, minimal first */
2379  SCIPsortRealPtr(vals, (void**)vars, (int) nbinvars);
2380  break;
2381 
2382  default :
2383  SCIPerrorMessage("invalid sortswitch value\n");
2384  SCIPABORT();
2385  return SCIP_INVALIDDATA; /*lint !e527*/
2386  }
2387  assert(vars != NULL);
2388 
2389  /* create mapping for getting the index of a variable via its probindex to the index in the sorted variable array */
2390  SCIP_CALL( SCIPallocBufferArray(scip, &(sepadata->mapping), nintegral) );
2391 
2392  /* initialize LP value and cut flag for all variables */
2393  for( i = 0; i < nbinvars; ++i )
2394  {
2395  assert( 0 <= SCIPvarGetProbindex(vars[i]) && SCIPvarGetProbindex(vars[i]) < nintegral); /* since binary, integer, and implicit variables are first */
2396  sepadata->mapping[SCIPvarGetProbindex(vars[i])] = i;
2397  vals[i] = SCIPgetSolVal(scip, sol, vars[i]); /* need to get new values, since they might be corrupted */
2398  }
2399 
2400  for( i = nbinvars; i < 2*nbinvars; ++i )
2401  vals[i] = 1.0 - vals[i - nbinvars];
2402 
2403  /* determine size of level graph */
2404  graph.maxnodes = 2 * nbinvars;
2405 
2406  /* the implication graph is redundant and therefore more implications and clique arcs may occur than should be possible
2407  * @todo later: filtering of edges which were already added
2408  */
2409  /* graph.maxarcs = nbinvars*(2*nbinvars-1); */ /* = 2*nbinvars*(2*nbinvars-1)/2 */
2410  graph.maxarcs = UINT_MAX;
2411 
2412  /* set sizes for graph memory storage */
2413  graph.sizeForward = 100 * graph.maxnodes;
2414  graph.sizeBackward = 100 * graph.maxnodes;
2415  graph.sizeAdj = 100 * graph.maxnodes;
2416 
2417  /* allocate memory for level graph structure */
2418  SCIP_CALL( SCIPallocBufferArray(scip, &graph.level, (int) graph.maxnodes) );
2419  SCIP_CALL( SCIPallocBufferArray(scip, &graph.beginForward, (int) graph.maxnodes) );
2420  SCIP_CALL( SCIPallocBufferArray(scip, &graph.beginBackward, (int) graph.maxnodes) );
2421  SCIP_CALL( SCIPallocBufferArray(scip, &graph.targetForward, (int) MIN(graph.sizeForward, graph.maxarcs)) );
2422  SCIP_CALL( SCIPallocBufferArray(scip, &graph.targetBackward, (int) MIN(graph.sizeBackward, graph.maxarcs)) );
2423  SCIP_CALL( SCIPallocBufferArray(scip, &graph.weightForward, (int) MIN(graph.sizeForward, graph.maxarcs)) );
2424  SCIP_CALL( SCIPallocBufferArray(scip, &graph.weightBackward, (int) MIN(graph.sizeBackward, graph.maxarcs)) );
2425 
2426  SCIP_CALL( SCIPallocBufferArray(scip, &curlevel, (int) graph.maxnodes) );
2427  SCIP_CALL( SCIPallocBufferArray(scip, &newlevel, (int) graph.maxnodes) );
2428  SCIP_CALL( SCIPallocBufferArray(scip, &graph.beginAdj, (int) graph.maxnodes) );
2429  SCIP_CALL( SCIPallocBufferArray(scip, &graph.sourceAdj, (int) MIN(graph.sizeAdj, graph.maxarcs)) );
2430  SCIP_CALL( SCIPallocBufferArray(scip, &graph.targetAdj, (int) MIN(graph.sizeAdj, graph.maxarcs)) );
2431  SCIP_CALL( SCIPallocBufferArray(scip, &graph.weightAdj, (int) MIN(graph.sizeAdj, graph.maxarcs)) );
2432  SCIP_CALL( SCIPallocBufferArray(scip, &graph.levelAdj, (int) graph.maxnodes) );
2433  SCIP_CALL( SCIPallocBufferArray(scip, &inlevelgraph, (int) graph.maxnodes) );
2434 
2435  SCIP_CALL( SCIPallocBufferArray(scip, &queue, (int) graph.maxnodes) );
2436  SCIP_CALL( SCIPallocBufferArray(scip, &inQueue, (int) graph.maxnodes) );
2437  SCIP_CALL( SCIPallocBufferArray(scip, &parentTree, (int) graph.maxnodes) );
2438  SCIP_CALL( SCIPallocBufferArray(scip, &parentTreeBackward, (int) graph.maxnodes) );
2439  SCIP_CALL( SCIPallocBufferArray(scip, &distance, (int) graph.maxnodes) );
2440  SCIP_CALL( SCIPallocBufferArray(scip, &blocked, (int) graph.maxnodes) );
2441 
2442  SCIP_CALL( SCIPallocBufferArray(scip, &incut, (int) (2 * nbinvars)) );
2443 
2444  /* initialize cut flag for all variables */
2445  BMSclearMemoryArray(incut, 2*nbinvars);
2446 
2447  /* determine the number of level graph roots */
2448  maxroots = (unsigned int) SCIPceil(scip, sepadata->offsettestvars + (0.02 * nbinvars * sepadata->percenttestvars));
2449  sepadata->maxlevelsize = (unsigned int) SCIPceil(scip, sepadata->offsetnodeslevel + 0.01 * sepadata->maxpernodeslevel * graph.maxnodes);
2450  rootcounter = 0;
2451 
2452  /* check each node as root */
2453  for( i = (unsigned int) sepadata->lastroot; i < graph.maxnodes && rootcounter < maxroots
2454  && sepadata->ncuts - sepadata->oldncuts < (unsigned int) sepadata->maxsepacutsround
2455  && !SCIPisStopped(scip) ; ++i )
2456  {
2457  /* skip node if it is already covered by a cut and if we do not want to search cycles starting
2458  * with a node already covered by a cut */
2459  if( incut[i] && ! sepadata->multiplecuts )
2460  continue;
2461 
2462  /* skip variable if its LP-value is not fractional */
2463  if( SCIPisFeasIntegral(scip, vals[i]) )
2464  continue;
2465 
2466  /* consider original and negated variable pair and skip variable if there is only one edge leaving the pair */
2467  if( SCIPvarGetNCliques(vars[i % nbinvars], TRUE) + SCIPvarGetNCliques(vars[i % nbinvars], FALSE) == 0 )
2468  continue;
2469 
2470  /* skip variable having too less implics and cliques itself */
2471  if( i < nbinvars )
2472  {
2473  if( SCIPvarGetNCliques(vars[i % nbinvars], TRUE ) == 0 )
2474  continue;
2475  if( !(sepadata->addselfarcs) && SCIPvarGetNCliques(vars[i % nbinvars], TRUE ) == 0 )
2476  continue;
2477  }
2478  else
2479  {
2480  if( SCIPvarGetNCliques(vars[i % nbinvars], FALSE) == 0 )
2481  continue;
2482 
2483  if( !(sepadata->addselfarcs) && SCIPvarGetNCliques(vars[i % nbinvars], FALSE) == 0 )
2484  continue;
2485  }
2486 
2487  /* node is actually considered as root node for the level graph */
2488  ++rootcounter;
2489  ncutsroot = 0;
2490 
2491  /* initialize graph */
2492  for( j = 0; j < graph.maxnodes; ++j)
2493  {
2494  graph.beginForward[j] = -1;
2495  graph.beginBackward[j] = -1;
2496  graph.beginAdj[j] = -1;
2497  inlevelgraph[j] = FALSE;
2498  blocked[j] = FALSE;
2499  }
2500  graph.lastF = 0;
2501  graph.lastB = 0;
2502  graph.nlevels = 0;
2503  graph.narcs = 0;
2504 
2505  /* insert root (first level contains root only) */
2506  inlevelgraph[i] = TRUE;
2507  graph.level[i] = 0;
2508  graph.levelAdj[0] = 0;
2509  graph.nnodes = 1;
2510  curlevel[0] = i;
2511  ncurlevel = 1;
2512 
2513  /* there are no arcs inside the root level */
2514  graph.levelAdj[graph.nlevels+1] = 0;
2515 
2516  /* create new levels until there are not more nodes for a new level */
2517  do
2518  {
2519  SCIP_Bool success;
2520  success = TRUE;
2521 
2522  /* all neighbors of nodes in level i that are assigned to level i+1,
2523  if they do not already appear in levels <= i. */
2524  SCIP_CALL( createNextLevel(scip, sepadata, vars, vals, &graph, graph.nlevels, inlevelgraph,
2525  curlevel, ncurlevel, newlevel, &nnewlevel, &success) );
2526 
2527  if( !success )
2528  goto TERMINATE;
2529 
2530  /* search for odd holes */
2531  if( graph.nlevels > 0 && (sepadata->includetriangles || graph.nlevels > 1) )
2532  {
2533  unsigned int maxcutslevel;
2534 
2535  ncutslevel = 0;
2536 
2537  /* calculate maximal cuts in this level due to cut limitations (per level, per root, per separation round) */
2538  maxcutslevel = (unsigned int) sepadata->maxcutslevel;
2539  maxcutslevel = (unsigned int) MIN((int) maxcutslevel, (int) ncutsroot - sepadata->maxcutsroot);
2540  maxcutslevel = (unsigned int) MIN((int) maxcutslevel, sepadata->maxsepacutsround + (int) sepadata->oldncuts - (int) sepadata->ncuts);
2541 
2542  /* for each cross edge in this level find both shortest paths to root (as long as no limits are reached) */
2543  for( j = graph.levelAdj[graph.nlevels+1]; j < graph.levelAdj[graph.nlevels+2]
2544  && ncutslevel < maxcutslevel && !SCIPisStopped(scip); ++j )
2545  {
2546  unsigned int ncyclevars;
2547  unsigned int u;
2548 
2549  /* storage for cut generation */
2550  unsigned int* pred; /* predecessor list */
2551  SCIP_Bool* incycle; /* flag array for check of double variables in found cycle */
2552 
2553  assert(graph.sourceAdj[j] < graph.targetAdj[j]);
2554 
2555  /* find shortest path from source to root and update weight of cycle */
2556  SCIP_CALL( findShortestPathToRoot(scip, sepadata->scale, &graph, graph.sourceAdj[j], distance, queue, inQueue, parentTree) );
2557 
2558 #ifndef NDEBUG
2559  /* check that this path ends in the root node */
2560  u = i;
2561  k = 1;
2562  while( u != graph.sourceAdj[j] )
2563  {
2564  assert(parentTree[u] != -1 && k <= graph.maxnodes);
2565  u = (unsigned int) parentTree[u];
2566  ++k;
2567  }
2568 #endif
2569 
2570  /* block all nodes that are adjacent to nodes of the first path */
2571  for( k = 0; k < graph.nnodes; ++k )
2572  blocked[k] = FALSE;
2573  SCIP_CALL( blockRootPath(scip, &graph, graph.sourceAdj[j], inlevelgraph, blocked, parentTree, i) );
2574 
2575  /* if the target is block, no violated odd hole can be found */
2576  if( blocked[graph.targetAdj[j]] )
2577  continue;
2578 
2579  /* find shortest path from root to target node avoiding blocked nodes */
2580  SCIP_CALL( findUnblockedShortestPathToRoot(scip, sepadata->scale, &graph,
2581  graph.targetAdj[j], distance, queue, inQueue, parentTreeBackward, i, blocked) );
2582 
2583  /* no odd cycle cut found */
2584  if( parentTreeBackward[graph.targetAdj[j]] < 0 )
2585  continue;
2586 
2587  /* allocate and initialize predecessor list and flag array representing odd cycle */
2588  SCIP_CALL( SCIPallocBufferArray(scip, &pred, (int) (2 * nbinvars)) );
2589  SCIP_CALL( SCIPallocBufferArray(scip, &incycle, (int) (2 * nbinvars)) );
2590  for( k = 0; k < 2 * nbinvars; ++k )
2591  {
2592  pred[k] = DIJKSTRA_UNUSED;
2593  incycle[k] = FALSE;
2594  }
2595  ncyclevars = 0;
2596  success = TRUE;
2597 
2598  /* check cycle for x-neg(x)-sub-cycles and clean them
2599  * (note that a variable cannot appear twice in a cycle since it is only once in the graph)
2600  * convert parentTreeBackward and parentTree to pred&incycle structure for generateOddCycleCut
2601  */
2602  u = graph.targetAdj[j];
2603 
2604  /* add path to root to cycle */
2605  while( success && u != i )
2606  {
2607  /* insert u in predecessor list */
2608  pred[u] = (unsigned int) parentTreeBackward[u];
2609 
2610  /* remove pairs of original and negated variable from cycle */
2611  SCIP_CALL( cleanCycle(scip, pred, incycle, incut, u, graph.targetAdj[j], nbinvars, &ncyclevars,
2612  sepadata->repaircycles, sepadata->allowmultiplecuts, &success) );
2613 
2614  assert(parentTreeBackward[u] >= 0 || u == i);
2615 
2616  /* select next node on path */
2617  u = (unsigned int) parentTreeBackward[u];
2618  }
2619 
2620  /* add path from root to cycle */
2621  while( success && u != graph.sourceAdj[j] )
2622  {
2623  /* insert u in predecessor list */
2624  pred[u] = (unsigned int) parentTree[u];
2625 
2626  /* remove pairs of original and negated variable from cycle */
2627  SCIP_CALL( cleanCycle(scip, pred, incycle, incut, u, graph.targetAdj[j], nbinvars, &ncyclevars,
2628  sepadata->repaircycles, sepadata->allowmultiplecuts, &success) );
2629 
2630  /* select next node on path */
2631  u = (unsigned int) parentTree[u];
2632  }
2633  assert(!success || u == graph.sourceAdj[j]);
2634 
2635  /* close the cycle */
2636  if( success )
2637  {
2638  pred[u] = graph.targetAdj[j];
2639 
2640  /* remove pairs of original and negated variable from cycle */
2641  SCIP_CALL( cleanCycle(scip, pred, incycle, incut, u, graph.targetAdj[j], nbinvars, &ncyclevars,
2642  sepadata->repaircycles, sepadata->allowmultiplecuts, &success) );
2643  }
2644 
2645  /* generate cut (if cycle is valid) */
2646  if(success)
2647  {
2648  GRAPHDATA graphdata;
2649  unsigned int oldncuts;
2650 
2651  graphdata.usegls = FALSE;
2652  graphdata.levelgraph = &graph;
2653  graphdata.dijkstragraph = NULL;
2654 
2655  oldncuts = sepadata->ncuts;
2656 
2657  SCIP_CALL( generateOddCycleCut(scip, sepa, sol, vars, nbinvars, graph.targetAdj[j], pred, ncyclevars,
2658  incut, vals, sepadata, &graphdata, result) );
2659 
2660  if(oldncuts < sepadata->ncuts)
2661  {
2662  ++ncutsroot;
2663  ++ncutslevel;
2664  }
2665  }
2666 
2667  /* free temporary memory */
2668  SCIPfreeBufferArray(scip, &incycle);
2669  SCIPfreeBufferArray(scip, &pred);
2670 
2671  if ( *result == SCIP_CUTOFF || *result == SCIP_REDUCEDDOM )
2672  break;
2673  }
2674  }
2675 
2676  if ( *result == SCIP_CUTOFF || *result == SCIP_REDUCEDDOM )
2677  break;
2678 
2679  /* copy new level to current one */
2680  ++(graph.nlevels);
2681  for( j = 0; j < nnewlevel; ++j )
2682  curlevel[j] = newlevel[j];
2683  ncurlevel = nnewlevel;
2684  }
2685  /* stop level creation loop if new level is empty or any limit is reached */
2686  while( nnewlevel > 0 && !SCIPisStopped(scip)
2687  && graph.nlevels < (unsigned int) sepadata->maxnlevels
2688  && ncutsroot < (unsigned int) sepadata->maxcutsroot
2689  && sepadata->ncuts - sepadata->oldncuts < (unsigned int) sepadata->maxsepacutsround);
2690  }
2691 
2692  /* store the last tried root (when running without sorting the variable array, we don't want
2693  * to always check the same variables and therefore start next time where we stopped last time)
2694  */
2695  if( sepadata->sortswitch == UNSORTED )
2696  {
2697  if( i == graph.maxnodes )
2698  sepadata->lastroot = 0;
2699  else
2700  sepadata->lastroot = (int) i;
2701  }
2702 
2703  TERMINATE:
2704  /* free memory */
2705  SCIPfreeBufferArray(scip, &incut);
2706 
2707  SCIPfreeBufferArray(scip, &blocked);
2708  SCIPfreeBufferArray(scip, &distance);
2709  SCIPfreeBufferArray(scip, &parentTreeBackward);
2710  SCIPfreeBufferArray(scip, &parentTree);
2711  SCIPfreeBufferArray(scip, &inQueue);
2712  SCIPfreeBufferArray(scip, &queue);
2713 
2714  SCIPfreeBufferArray(scip, &inlevelgraph);
2715  SCIPfreeBufferArray(scip, &graph.levelAdj);
2716  SCIPfreeBufferArray(scip, &graph.weightAdj);
2717  SCIPfreeBufferArray(scip, &graph.targetAdj);
2718  SCIPfreeBufferArray(scip, &graph.sourceAdj);
2719  SCIPfreeBufferArray(scip, &graph.beginAdj);
2720  SCIPfreeBufferArray(scip, &newlevel);
2721  SCIPfreeBufferArray(scip, &curlevel);
2722 
2723  SCIPfreeBufferArray(scip, &graph.weightBackward);
2724  SCIPfreeBufferArray(scip, &graph.weightForward);
2725  SCIPfreeBufferArray(scip, &graph.targetBackward);
2726  SCIPfreeBufferArray(scip, &graph.targetForward);
2727  SCIPfreeBufferArray(scip, &graph.beginBackward);
2728  SCIPfreeBufferArray(scip, &graph.beginForward);
2729  SCIPfreeBufferArray(scip, &graph.level);
2730 
2731  SCIPfreeBufferArray(scip, &(sepadata->mapping));
2732  SCIPfreeBufferArray(scip, &vars);
2733  SCIPfreeBufferArray(scip, &vals);
2734 
2735  return SCIP_OKAY;
2736 }
2737 
2738 
2739 /* methods for separateGLS() */
2740 
2741 /** memory reallocation method (the graph is normally very dense, so we dynamically allocate only the memory we need) */
2742 static
2743 SCIP_RETCODE checkArraySizesGLS(
2744  SCIP* scip, /**< SCIP data structure */
2745  unsigned int maxarcs, /**< maximal size of graph->head and graph->weight */
2746  unsigned int* arraysize, /**< current size of graph->head and graph->weight */
2747  DIJKSTRA_GRAPH* graph, /**< Dijkstra Graph data structure */
2748  SCIP_Bool* success /**< FALSE, iff memory reallocation fails */
2749  )
2750 {
2751  SCIP_Real memorylimit;
2752  unsigned int additional;
2753  unsigned int j;
2754  unsigned int oldarraysize;
2755 
2756  assert(scip != NULL);
2757  assert(arraysize != NULL);
2758  assert(graph != NULL);
2759  assert(graph->head != NULL);
2760  assert(graph->weight != NULL);
2761  assert(success != NULL);
2762 
2763  SCIPdebugMsg(scip, "reallocating graph->head and graph->weight...\n");
2764 
2765  additional = (MIN(maxarcs, 2 * (*arraysize)) - (*arraysize)) * ((int) sizeof(*(graph->head)));
2766  additional += (MIN(maxarcs, 2 * (*arraysize)) - (*arraysize)) * ((int) sizeof(*(graph->weight)));
2767 
2768  SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
2769  if( !SCIPisInfinity(scip, memorylimit) )
2770  {
2771  memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
2772  memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
2773  }
2774 
2775  /* if memorylimit would be exceeded or any other limit is reached free all data and exit */
2776  if( memorylimit <= additional/1048576.0 || SCIPisStopped(scip) )
2777  {
2778  *success = FALSE;
2779  SCIPdebugMsg(scip, "...memory limit exceeded\n");
2780  return SCIP_OKAY;
2781  }
2782 
2783  oldarraysize = *arraysize;
2784  *arraysize = 2*(*arraysize);
2785 
2786  SCIP_CALL( SCIPreallocBufferArray(scip, &(graph->head), (int) MIN(maxarcs, (*arraysize))) );
2787  SCIP_CALL( SCIPreallocBufferArray(scip, &(graph->weight), (int) MIN(maxarcs, (*arraysize))) );
2788 
2789  /* if memorylimit exceeded, leave the separator */
2790  SCIP_CALL( SCIPgetRealParam(scip, "limits/memory", &memorylimit) );
2791 
2792  if( !SCIPisInfinity(scip, memorylimit) )
2793  {
2794  memorylimit -= SCIPgetMemUsed(scip)/1048576.0;
2795  memorylimit -= SCIPgetMemExternEstim(scip)/1048576.0;
2796  }
2797 
2798  if( memorylimit <= 2.0*SCIPgetMemExternEstim(scip)/1048576.0 )
2799  {
2800  SCIPdebugMsg(scip, "...memory limit exceeded - freeing all arrays\n");
2801  *success = FALSE;
2802  return SCIP_OKAY;
2803  }
2804 
2805  /* initialize new segments of graph as empty graph */
2806  for( j = oldarraysize; j < MIN(maxarcs,(*arraysize)); ++j )
2807  {
2808  (graph->head)[j] = DIJKSTRA_UNUSED;
2809  (graph->weight)[j] = DIJKSTRA_UNUSED;
2810  }
2811 
2812  SCIPdebugMsg(scip, "...with success\n");
2813 
2814  return SCIP_OKAY;
2815 }
2816 
2817 /** add implications from cliques of the given node */
2818 static
2819 SCIP_RETCODE addGLSCliques(
2820  SCIP* scip, /**< SCIP data structure */
2821  SCIP_SEPADATA* sepadata, /**< separator data structure */
2822  SCIP_VAR** vars, /**< problem variables */
2823  unsigned int varsidx, /**< index of current variable inside the problem variables */
2824  unsigned int dijkindex, /**< index of current variable inside the Dijkstra Graph */
2825  SCIP_Real* vals, /**< value of the variables in the given solution */
2826  unsigned int nbinvars, /**< number of binary problem variables */
2827  unsigned int ncliques, /**< number of cliques of the current node */
2828  DIJKSTRA_GRAPH* graph, /**< Dijkstra Graph data structure */
2829  unsigned int* narcs, /**< current number of arcs inside the Dijkstra Graph */
2830  unsigned int maxarcs, /**< maximal number of arcs inside the Dijkstra Graph */
2831  SCIP_Bool original, /**< TRUE, iff variable is a problem variable */
2832  SCIP_Bool* emptygraph, /**< TRUE, iff there is no arc in the implication graph of the binary variables of SCIP */
2833  unsigned int* arraysize, /**< current size of graph->head and graph->weight */
2834  SCIP_Bool* success /**< FALSE, iff memory reallocation fails */
2835  )
2836 {
2837  SCIP_VAR* neighbor; /* current neighbor of the current variable */
2838  unsigned int neighindex;
2839  SCIP_CLIQUE** cliques; /* cliques of the current variable (with x==0/1) */
2840  unsigned int ncliquevars; /* number of variables of a clique */
2841  SCIP_VAR** cliquevars; /* variables of a clique */
2842  SCIP_Bool* cliquevals; /* is the cliquevariable fixed to TRUE or to FALSE */
2843  unsigned int k;
2844  unsigned int m;
2845 
2846  assert(scip != NULL);
2847  assert(sepadata != NULL);
2848  assert(vars != NULL);
2849  assert(graph != NULL);
2850  assert(graph->head != NULL);
2851  assert(graph->weight != NULL);
2852  assert(narcs != NULL);
2853  assert(emptygraph != NULL);
2854  assert(arraysize != NULL);
2855  assert(success != NULL);
2856 
2857  /* if current variable has cliques of current clique-type */
2858  cliques = SCIPvarGetCliques(vars[varsidx], original);
2859  assert(cliques != NULL || ncliques == 0);
2860 
2861  for( k = 0; k < ncliques; ++k )
2862  {
2863  assert( cliques != NULL ); /* for lint */
2864 
2865  /* get clique data */
2866  cliquevars = SCIPcliqueGetVars(cliques[k]);
2867  ncliquevars = (unsigned int) SCIPcliqueGetNVars(cliques[k]);
2868  cliquevals = SCIPcliqueGetValues(cliques[k]);
2869 
2870  assert(cliquevars != NULL || ncliquevars == 0);
2871  assert(cliquevals != NULL || ncliquevars == 0);
2872 
2873  /* add arcs for all fractional variables in clique */
2874  for( m = 0; m < ncliquevars; ++m )
2875  {
2876  int tmp;
2877 
2878  assert( cliquevars != NULL && cliquevals != NULL ); /* for lint */
2879  neighbor = cliquevars[m];
2880 
2881  neighindex = sepadata->mapping[SCIPvarGetProbindex(neighbor)];
2882  assert(neighindex < nbinvars);
2883 
2884  /* ignore current variable */
2885  if( neighindex == varsidx )
2886  continue;
2887 
2888  /* we use only variables with fractional LP-solution values */
2889  if( SCIPisFeasIntegral(scip, vals[neighindex]) )
2890  continue;
2891 
2892  /* forward direction (the backward is created at the occurrence of the current variable in the cliquevars of the neighbor) */
2893  /* x==1 */
2894  if( original )
2895  {
2896  /* implication to y=0 (I->III) */
2897  if( cliquevals[m] )
2898  {
2899  tmp = (int) SCIPfeasCeil(scip, sepadata->scale * (1 - vals[varsidx] - vals[neighindex] ));
2900  graph->weight[*narcs] = (unsigned int) MAX(0, tmp);
2901  graph->head[*narcs] = neighindex + 2 * nbinvars;
2902  }
2903  /* implication to y=1 (I->IV) (cliquevals[m] == FALSE) */
2904  else
2905  {
2906  tmp = (int) SCIPfeasCeil(scip, sepadata->scale * (1 - vals[varsidx] - (1 - vals[neighindex]) ));
2907  graph->weight[*narcs] = (unsigned int) MAX(0, tmp);
2908  graph->head[*narcs] = neighindex + 3 * nbinvars;
2909  }
2910  }
2911  /* x==0 */
2912  else
2913  {
2914  /* implication to y=0 (II->III) */
2915  if( cliquevals[m] )
2916  {
2917  tmp = (int) SCIPfeasCeil(scip, sepadata->scale * (1 - (1 - vals[varsidx]) - vals[neighindex] ));
2918  graph->weight[*narcs] = (unsigned int) MAX(0, tmp);
2919  graph->head[*narcs] = neighindex + 2 * nbinvars;
2920  }
2921  /* implication to y=1 (II->IV) (cliquevals[m] == FALSE) */
2922  else
2923  {
2924  tmp = (int) SCIPfeasCeil(scip, sepadata->scale * (1 - (1 - vals[varsidx]) - (1-vals[neighindex]) )) ;
2925  graph->weight[*narcs] = (unsigned int) MAX(0, tmp);
2926  graph->head[*narcs] = neighindex + 3 * nbinvars;
2927  }
2928  }
2929 
2930  /* update minimum and maximum weight values */
2931  if( graph->weight[*narcs] < graph->minweight )
2932  graph->minweight = graph->weight[*narcs];
2933 
2934  if( graph->weight[*narcs] > graph->maxweight )
2935  graph->maxweight = graph->weight[*narcs];
2936 
2937  ++(*narcs);
2938  if( *arraysize == *narcs )
2939  {
2940  SCIP_CALL( checkArraySizesGLS(scip, maxarcs, arraysize, graph, success) );
2941 
2942  if( !(*success) )
2943  return SCIP_OKAY;
2944  }
2945  assert((*narcs) < maxarcs);
2946  ++(graph->outcnt[dijkindex]);
2947 
2948  *emptygraph = FALSE;
2949  }
2950  }
2951 
2952  return SCIP_OKAY;
2953 }
2954 
2955 /** The classical method for finding odd cycles by Groetschel, Lovasz, Schrijver uses a bipartite graph
2956  * which contains in each partition a node for every node in the original graph.
2957  * All arcs uv of the original graph are copied to arcs from u of the first partition to v' of the second partition
2958  * and from u' of the second partition to v of the first partition.
2959  * A Dijkstra algorithm is used to find a path from a node x to its copy x', if existing.
2960  * The nodes in the original graph corresponding to the nodes on the path form an odd cycle.
2961  *
2962  * Since SCIP stores implications between original and negated variables,
2963  * our original graph has at most twice the number of binary variables of the problem.
2964  * By creating the bipartite graph we gain 4 segments of the graph:
2965  *
2966  * I - nodes of the original variables in the first bipartition \n
2967  * II - nodes of the negated variables in the first bipartition \n
2968  * III - nodes of the original variables in the second bipartition \n
2969  * IV - nodes of the negated variables in the second bipartition
2970  *
2971  * The length of every segment if the number of binary variables in the original problem.
2972  *
2973  * Since the implication graph of SCIP is (normally) incomplete,
2974  * it is possible to use arcs between an original variable and its negated
2975  * to obtain more cycles which are valid but not found due to missing links.
2976  */
2977 static
2978 SCIP_RETCODE separateGLS(
2979  SCIP* scip, /**< SCIP data structure */
2980  SCIP_SEPA* sepa, /**< separator */
2981  SCIP_SEPADATA* sepadata, /**< separator data structure */
2982  SCIP_SOL* sol, /**< given primal solution */
2983  SCIP_RESULT* result /**< pointer to store the result of the separation call */
2984  )
2985 {
2986  SCIP_Bool emptygraph; /* flag if graph contains an arc */
2987 
2988  SCIP_Real* vals; /* values of the variables in the given solution */
2989  unsigned int* incut;
2990 
2991  unsigned int i;
2992  unsigned int j;
2993 
2994  SCIP_VAR** scipvars; /* variables of the current SCIP (unsorted) */
2995  SCIP_VAR** vars; /* variables of the current SCIP (sorted if requested) */
2996  unsigned int nbinvars; /* number of binary problem variables */
2997  SCIP_Bool original; /* flag if the current variable is original or negated */
2998 
2999  unsigned int ncliques; /* number of cliques of the current variable */
3000 
3001  DIJKSTRA_GRAPH graph; /* Dijkstra graph data structure */
3002  unsigned int arraysize; /* current size of graph->head and graph->weight */
3003  unsigned int narcs; /* number of arcs in the Dijkstra graph */
3004  unsigned int maxarcs; /* maximum number of arcs in the Dijkstra graph */
3005  unsigned int maxstarts; /* maximum number of start nodes */
3006  unsigned int startcounter; /* counter of tried start nodes */
3007  unsigned long long cutoff; /* cutoff value for Dijkstra algorithm */
3008 
3009  unsigned int startnode; /* start node for Dijkstra algorithm */
3010  unsigned int endnode; /* target node for Dijkstra algorithm */
3011  unsigned long long* dist; /* distance matrix for Dijkstra algorithm */
3012  unsigned int* pred; /* predecessor list for found cycle */
3013  unsigned int* entry; /* storage for Dijkstra algorithm */
3014  unsigned int* order; /* storage for Dijkstra algorithm */
3015  unsigned int dijkindex;
3016  SCIP_Bool success; /* flag for check for several errors */
3017 
3018  SCIP_Bool* incycle; /* flag array if variable is contained in the found cycle */
3019  unsigned int* pred2; /* temporary predecessor list for backprojection of found cycle */
3020 
3021  int nscipbinvars;
3022  int nscipintvars;
3023  int nscipimplvars;
3024  int nintegral;
3025  int k;
3026 
3027  assert(scip != NULL);
3028  assert(sepadata != NULL);
3029  assert(result != NULL);
3030 
3031  success = TRUE;
3032  emptygraph = TRUE;
3033 
3034  SCIP_CALL( SCIPgetVarsData(scip, &scipvars, NULL, &nscipbinvars, &nscipintvars, &nscipimplvars, NULL) );
3035  assert(nscipbinvars >= 0);
3036  assert(nscipintvars >= 0);
3037  assert(nscipimplvars >= 0);
3038 
3039  nintegral = nscipbinvars + nscipintvars + nscipimplvars;
3040  assert(scipvars != NULL || ((nscipbinvars == 0) && (nscipintvars == 0) && (nscipimplvars == 0) && (nintegral == 0)));
3041 
3042  /* collect binary variables, including implicit binary */
3043  SCIP_CALL( SCIPallocBufferArray(scip, &vars, nintegral) );
3044  for (k = 0; k < nscipbinvars; ++k)
3045  vars[k] = scipvars[k]; /*lint !e613*/
3046 
3047  nbinvars = (unsigned int) nscipbinvars;
3048  for (k = nscipbinvars; k < nintegral; ++k)
3049  {
3050  assert( SCIPvarGetType(scipvars[k]) != SCIP_VARTYPE_CONTINUOUS ); /*lint !e613*/
3051  if ( SCIPvarIsBinary(scipvars[k]) ) /*lint !e613*/
3052  vars[nbinvars++] = scipvars[k]; /*lint !e613*/
3053  }
3054 
3055  if( nbinvars == 0 )
3056  {
3057  SCIPfreeBufferArray(scip, &vars);
3058  return SCIP_OKAY;
3059  }
3060 
3061  /* initialize flag array to avoid multiple cuts per variable, if requested by user-flag */
3062  SCIP_CALL( SCIPallocBufferArray(scip, &vals, (int) (2 * nbinvars)) );
3063 
3064  /* prepare values */
3065  assert( vars != NULL );
3066  switch( sepadata->sortswitch )
3067  {
3068  case UNSORTED :
3069  /* if no sorting is requested, we use the normal variable array */
3070  break;
3071 
3072  case MAXIMAL_LPVALUE :
3073  /* store lp-values */
3074  for( i = 0; i < nbinvars; ++i )
3075  vals[i] = SCIPgetSolVal(scip, sol, vars[i]);
3076 
3077  /* sort by lp-value, maximal first */
3078  SCIPsortDownRealPtr(vals, (void**)vars, (int) nbinvars);
3079  break;
3080 
3081  case MINIMAL_LPVALUE :
3082  /* store lp-values */
3083  for( i = 0; i < nbinvars; ++i )
3084  vals[i] = SCIPgetSolVal(scip, sol, vars[i]);
3085 
3086  /* sort by lp-value, minimal first */
3087  SCIPsortRealPtr(vals, (void**)vars, (int) nbinvars);
3088  break;
3089 
3090  case MAXIMAL_FRACTIONALITY :
3091  /* store lp-values and determine fractionality */
3092  for( i = 0; i < nbinvars; ++i )
3093  {
3094  vals[i] = SCIPgetSolVal(scip, sol, vars[i]);
3095  vals[i] = MIN(1.0 - vals[i], vals[i]);
3096  }
3097 
3098  /* sort by fractionality, maximal first */
3099  SCIPsortDownRealPtr(vals, (void**)vars, (int) nbinvars);
3100  break;
3101 
3102  case MINIMAL_FRACTIONALITY :
3103  /* store lp-values and determine fractionality */
3104  for( i = 0; i < nbinvars; ++i )
3105  {
3106  vals[i] = SCIPgetSolVal(scip, sol, vars[i]);
3107  vals[i] = MIN(1.0 - vals[i], vals[i]);
3108  }
3109 
3110  /* sort by fractionality, minimal first */
3111  SCIPsortRealPtr(vals, (void**)vars, (int) nbinvars);
3112  break;
3113 
3114  default :
3115  SCIPerrorMessage("invalid sortswitch value\n");
3116  SCIPABORT();
3117  return SCIP_INVALIDDATA; /*lint !e527*/
3118  }
3119  assert(vars != NULL);
3120 
3121  /* create mapping for getting the index of a variable via its probindex to the index in the sorted variable array */
3122  SCIP_CALL( SCIPallocBufferArray(scip, &(sepadata->mapping), nintegral) );
3123  SCIP_CALL( SCIPallocBufferArray(scip, &incut, (int) (4 * nbinvars)) );
3124  BMSclearMemoryArray(incut, 4 * nbinvars);
3125 
3126  /* initialize LP value and cut flag for all variables */
3127  for( i = 0; i < nbinvars; ++i )
3128  {
3129  assert( 0 <= SCIPvarGetProbindex(vars[i]) && SCIPvarGetProbindex(vars[i]) < nintegral); /* since binary, integer, and implicit variables are first */
3130  sepadata->mapping[SCIPvarGetProbindex(vars[i])] = i;
3131  vals[i] = SCIPgetSolVal(scip, sol, vars[i]); /* need to get new values, since they might be corrupted */
3132  }
3133 
3134  for( i = nbinvars; i < 2*nbinvars; ++i )
3135  vals[i] = 1 - vals[i - nbinvars];
3136 
3137  /* initialize number of nodes in Dijkstra graph (2*2*n nodes in a mirrored bipartite graph with negated variables) */
3138  graph.nodes = 4 * nbinvars;
3139 
3140  /* Initialize number of arcs in Dijkstra graph, should be (nbinvars+1) * graph.nodes, but might deviate, because
3141  * there might be parallel arcs:
3142  * nbinvars-1 possible arcs per node (it is not possible to be linked to variable and negated)
3143  * + 1 self-arc (arc to negated variable)
3144  * + 1 dummy arc for Dijkstra data structure
3145  * = nbinvars+1 arcs per node
3146  * * graph.nodes
3147  * = (nbinvars+1)*graph.nodes
3148  * + graph.nodes => separating entries for arclist)
3149  *
3150  * Number is corrected below.
3151  */
3152  graph.arcs = 0;
3153 
3154  /* the implication graph is redundant and therefore more implications and clique arcs may occur than should be possible
3155  * @todo later: filtering of edges which were already added, maxarcs should be graph.arcs rather than INT_MAX;
3156  */
3157  maxarcs = UINT_MAX;
3158 
3159  /* allocate memory for Dijkstra graph arrays */
3160  arraysize = 100 * graph.nodes;
3161  SCIP_CALL( SCIPallocBufferArray(scip, &graph.outbeg, (int) graph.nodes) );
3162  SCIP_CALL( SCIPallocBufferArray(scip, &graph.outcnt, (int) graph.nodes) );
3163  SCIP_CALL( SCIPallocBufferArray(scip, &graph.head, (int) MIN(maxarcs, arraysize)) );
3164  SCIP_CALL( SCIPallocBufferArray(scip, &graph.weight, (int) MIN(maxarcs, arraysize)) );
3165  SCIP_CALL( SCIPallocBufferArray(scip, &dist, (int) graph.nodes) );
3166  SCIP_CALL( SCIPallocBufferArray(scip, &pred, (int) graph.nodes) );
3167  SCIP_CALL( SCIPallocBufferArray(scip, &entry, (int) graph.nodes) );
3168  SCIP_CALL( SCIPallocBufferArray(scip, &order, (int) graph.nodes) );
3169 
3170  /* initialize Dijkstra graph as empty graph */
3171  for( i = 0; i < MIN(arraysize, maxarcs); ++i )
3172  {
3173  graph.head[i] = DIJKSTRA_UNUSED;
3174  graph.weight[i] = DIJKSTRA_UNUSED;
3175  }
3176  graph.minweight = DIJKSTRA_FARAWAY;
3177  graph.maxweight = 0;
3178  narcs = 0;
3179 
3180 #ifndef NDEBUG
3181  for( i = 0; i < graph.nodes; ++i )
3182  {
3183  graph.outbeg[i] = 0;
3184  graph.outcnt[i] = 0;
3185  }
3186 #endif
3187 
3188  /* add arcs from first to second partition to Dijkstra graph (based on the original fractional implication graph) */
3189  for( dijkindex = 0; dijkindex < 2 * nbinvars; ++dijkindex )
3190  {
3191  graph.outbeg[dijkindex] = narcs;
3192  graph.outcnt[dijkindex] = 0;
3193 
3194  /* decide if we have original or negated variable */
3195  if( dijkindex < nbinvars )
3196  {
3197  i = dijkindex;
3198  original = TRUE;
3199  }
3200  else
3201  {
3202  i = dijkindex - nbinvars;
3203  original = FALSE;
3204  }
3205  assert(i < nbinvars);
3206 
3207  /* if the variable has a fractional value we add it to the graph */
3208  if( ! SCIPisFeasIntegral(scip, vals[i]) )
3209  {
3210  ncliques = (unsigned int) SCIPvarGetNCliques(vars[i], original);
3211 
3212  /* insert arcs for cliques (take var => getCliques => take cliquevar => add forward-arc) */
3213  /* add clique arcs of clique-type "original" if current variable has them */
3214  if( ncliques >= 1 )
3215  {
3216  /* x==1/0 -> y==0/1 (I/II -> III/IV) */
3217  SCIP_CALL( addGLSCliques(scip, sepadata, vars, i, dijkindex, vals, nbinvars, ncliques, &graph,
3218  &narcs, maxarcs, original, &emptygraph, &arraysize, &success) );
3219 
3220  if( !success )
3221  goto TERMINATE;
3222  }
3223  }
3224 
3225  /* add link to copy of negated variable (useful if/because the implication graph is incomplete) */
3226  if( sepadata->addselfarcs && graph.outcnt[dijkindex] > 0 )
3227  {
3228  /* I -> IV */
3229  if( original )
3230  {
3231  assert(dijkindex < nbinvars);
3232  graph.head[narcs] = dijkindex + 3*nbinvars;
3233  }
3234  /* II -> III */
3235  else
3236  {
3237  assert(dijkindex >= nbinvars && dijkindex < 2*nbinvars);
3238  graph.head[narcs] = dijkindex + nbinvars;
3239  }
3240  graph.weight[narcs] = 0;
3241 
3242  /* update minimum and maximum weight values */
3243  if( graph.weight[narcs] < graph.minweight )
3244  graph.minweight = graph.weight[narcs];
3245 
3246  if( graph.weight[narcs] > graph.maxweight )
3247  graph.maxweight = graph.weight[narcs];
3248 
3249  ++narcs;
3250  if( arraysize == narcs )
3251  {
3252  SCIP_CALL( checkArraySizesGLS(scip, maxarcs, &arraysize, &graph, &success) );
3253  if( !success )
3254  goto TERMINATE;
3255  }
3256  assert(narcs < maxarcs);
3257  ++(graph.outcnt[dijkindex]);
3258  }
3259 
3260  /* add separating arc */
3261  graph.head[narcs] = DIJKSTRA_UNUSED;
3262  graph.weight[narcs] = DIJKSTRA_UNUSED;
3263  ++narcs;
3264  if( arraysize == narcs )
3265  {
3266  SCIP_CALL( checkArraySizesGLS(scip, maxarcs, &arraysize, &graph, &success) );
3267  if( !success )
3268  goto TERMINATE;
3269  }
3270  assert(narcs < maxarcs);
3271  }
3272 
3273  /* if the graph is empty, there is nothing to do */
3274  if( emptygraph )
3275  goto TERMINATE;
3276 
3277  /* add arcs from second to first partition to Dijkstra graph */
3278  for( i = 0; i < 2*nbinvars; ++i )
3279  {
3280  graph.outbeg[2 * nbinvars + i] = narcs;
3281  graph.outcnt[2 * nbinvars + i] = 0;
3282 
3283  /* copy all arcs to head from the second to the first bipartition */
3284  for( j = graph.outbeg[i]; j < graph.outbeg[i] + graph.outcnt[i]; ++j )
3285  {
3286  /* there are only arcs from first bipartition to the second */
3287  assert(graph.head[j] >= 2*nbinvars && graph.head[j] < 4*nbinvars);
3288 
3289  /* the backward arcs head from III->I or IV->II */
3290  graph.head[narcs] = graph.head[j] - 2 * nbinvars;
3291  graph.weight[narcs] = graph.weight[j];
3292  ++narcs;
3293  if( arraysize == narcs )
3294  {
3295  SCIP_CALL( checkArraySizesGLS(scip, maxarcs, &arraysize, &graph, &success) );
3296 
3297  if( !success )
3298  goto TERMINATE;
3299  }
3300  assert(narcs < maxarcs);
3301  ++(graph.outcnt[2*nbinvars+i]);
3302  }
3303 
3304  /* add separating arc */
3305  graph.head[narcs] = DIJKSTRA_UNUSED;
3306  graph.weight[narcs] = DIJKSTRA_UNUSED;
3307  ++narcs;
3308 
3309  if( arraysize == narcs )
3310  {
3311  SCIP_CALL( checkArraySizesGLS(scip, maxarcs, &arraysize, &graph, &success) );
3312 
3313  if( !success )
3314  goto TERMINATE;
3315  }
3316  assert(narcs < maxarcs);
3317  }
3318 
3319  /* correct number of arcs */
3320  graph.arcs = narcs;
3321 
3322  SCIPdebugMsg(scip, "--- graph successfully created (%u nodes, %u arcs) ---\n", graph.nodes, narcs);
3323 
3324  /* graph is now prepared for Dijkstra methods */
3325  assert( dijkstraGraphIsValid(&graph) );
3326 
3327 #ifdef SCIP_ODDCYCLE_WRITEGRAPH
3328  {
3329  char probname [SCIP_MAXSTRLEN];
3330  char filename [SCIP_MAXSTRLEN];
3331  char* name;
3332 
3333  (void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s", SCIPgetProbName(scip));
3334  SCIPsplitFilename(probname, NULL, &name, NULL, NULL);
3335  (void) SCIPsnprintf(filename, SCIP_MAXSTRLEN, "%s_%d.gml", name, SCIPgetNLPs(scip));
3336  SCIP_CALL( SCIPwriteCliqueGraph(scip, filename, TRUE, TRUE) );
3337  SCIPverbMessage(scip, SCIP_VERBLEVEL_HIGH, NULL, "Wrote clique/implication graph to <%s>.\n", filename);
3338  }
3339 #endif
3340 
3341  /* determine the number of start nodes */
3342  maxstarts = (unsigned int) SCIPceil(scip, sepadata->offsettestvars + (0.02 * nbinvars * sepadata->percenttestvars));
3343  startcounter = 0;
3344 
3345  /* allocate and initialize predecessor list and flag array representing odd cycle */
3346  SCIP_CALL( SCIPallocBufferArray(scip, &pred2, (int) (2 * nbinvars)) );
3347  SCIP_CALL( SCIPallocBufferArray(scip, &incycle, (int) (2 * nbinvars)) );
3348 
3349  /* separate odd cycle inequalities by GLS method */
3350  cutoff = (unsigned long long) (0.5 * sepadata->scale);
3351  for( i = (unsigned int) sepadata->lastroot; i < 2 * nbinvars
3352  && startcounter < maxstarts
3353  && sepadata->ncuts - sepadata->oldncuts < (unsigned int) sepadata->maxsepacutsround
3354  && !SCIPisStopped(scip); ++i )
3355  {
3356  unsigned int ncyclevars; /* cycle length */
3357  SCIP_Bool edgedirection; /* partitionindicator for backprojection from bipartite graph to original graph:
3358  * is the current edge a backwards edge, i.e., from second to first partition? */
3359 
3360  /* skip isolated node */
3361  if( graph.head[graph.outbeg[i]] == DIJKSTRA_UNUSED )
3362  continue;
3363 
3364  /* if node has only one arc, there is no odd cycle containing this node
3365  * (but there are invalid odd circuits containing the only neighbor twice)
3366  */
3367  if( graph.head[graph.outbeg[i]+1] == DIJKSTRA_UNUSED )
3368  continue;
3369 
3370  /* search shortest path from node to its counter part in the other partition */
3371  startnode = i;
3372  endnode = i + 2 * nbinvars;
3373 
3374  /* skip node if it is already covered by a cut and
3375  * we do not want to search cycles starting with a node already covered by a cut
3376  */
3377  if( incut[startnode] && ! sepadata->multiplecuts )
3378  continue;
3379 
3380  ++startcounter;
3381 
3382  if ( sepadata->allowmultiplecuts )
3383  (void) dijkstraPairCutoffIgnore(&graph, startnode, endnode, incut, cutoff, dist, pred, entry, order);
3384  else
3385  (void) dijkstraPairCutoff(&graph, startnode, endnode, cutoff, dist, pred, entry, order);
3386 
3387  /* no odd cycle cut found */
3388  if( dist[endnode] == DIJKSTRA_FARAWAY )
3389  continue;
3390 
3391  /* skip check if cutoff has been exceeded */
3392  if ( dist[endnode] >= cutoff )
3393  continue;
3394 
3395  /* detect cycle including:
3396  * project bipartitioned graph to original graph of variables and their negated
3397  * (pred&incycle-structure for generateOddCycleCut)
3398  * check cycles for double variables and try to clean variable-negated-sub-cycles if existing
3399  */
3400  for( j = 0; j < 2 * nbinvars; ++j )
3401  {
3402  pred2[j] = DIJKSTRA_UNUSED;
3403  incycle[j] = FALSE;
3404  }
3405 
3406  ncyclevars = 0;
3407  edgedirection = TRUE;
3408  success = TRUE;
3409 
3410  /* construct odd cycle in implication graph from shortest path on bipartite graph */
3411  for( dijkindex = endnode; dijkindex != startnode && success; dijkindex = pred[dijkindex], edgedirection = !edgedirection )
3412  {
3413  if( edgedirection )
3414  {
3415  /* check that current node is in second partition and next node is in first partition */
3416  assert(dijkindex >= 2 * nbinvars && dijkindex < 4 * nbinvars);
3417  assert(pred[dijkindex] < 2*nbinvars);
3418 
3419  pred2[dijkindex - 2 * nbinvars] = pred[dijkindex];
3420 
3421  /* check whether the object found is really a cycle without sub-cycles
3422  * (sub-cycles may occur in case there is not violated odd cycle inequality)
3423  * and remove pairs of original and negated variable from cycle
3424  */
3425  SCIP_CALL( cleanCycle(scip, pred2, incycle, incut, dijkindex-2*nbinvars, endnode-2*nbinvars, nbinvars,
3426  &ncyclevars, sepadata->repaircycles, sepadata->allowmultiplecuts, &success) );
3427  }
3428  else
3429  {
3430  /* check that current node is in first partition and next node is in second partition */
3431  assert(dijkindex < 2 * nbinvars);
3432  assert(pred[dijkindex] >= 2 * nbinvars && pred[dijkindex] < 4 * nbinvars);
3433 
3434  pred2[dijkindex] = pred[dijkindex] - 2 * nbinvars;
3435 
3436  /* check whether the object found is really a cycle without sub-cycles
3437  * (sub-cycles may occur in case there is not violated odd cycle inequality)
3438  * and remove pairs of original and negated variable from cycle
3439  */
3440  SCIP_CALL( cleanCycle(scip, pred2, incycle, incut, dijkindex, endnode-2*nbinvars, nbinvars, &ncyclevars,
3441  sepadata->repaircycles, sepadata->allowmultiplecuts, &success) );
3442  }
3443  }
3444 
3445  if( success )
3446  {
3447  GRAPHDATA graphdata;
3448 
3449  /* generate cut */
3450  graphdata.usegls = TRUE;
3451  graphdata.dijkstragraph = &graph;
3452  graphdata.levelgraph = NULL;
3453 
3454  SCIP_CALL( generateOddCycleCut(scip, sepa, sol, vars, nbinvars, startnode, pred2, ncyclevars, incut, vals, sepadata, &graphdata, result) );
3455  }
3456  }
3457 
3458  /* free temporary memory */
3459  SCIPfreeBufferArray(scip, &incycle);
3460  SCIPfreeBufferArray(scip, &pred2);
3461 
3462  /* store the last tried root (when running without sorting the variable array, we don't want
3463  * to always check the same variables and therefore start next time where we stopped last time)
3464  */
3465  if( sepadata->sortswitch == UNSORTED )
3466  {
3467  if( i == 2 * nbinvars )
3468  sepadata->lastroot = 0;
3469  else
3470  sepadata->lastroot = (int) i;
3471  }
3472 
3473  TERMINATE:
3474  /* free temporary memory */
3475  SCIPfreeBufferArray(scip, &order);
3476  SCIPfreeBufferArray(scip, &entry);
3477  SCIPfreeBufferArray(scip, &pred);
3478  SCIPfreeBufferArray(scip, &dist);
3479  SCIPfreeBufferArray(scip, &graph.weight);
3480  SCIPfreeBufferArray(scip, &graph.head);
3481  SCIPfreeBufferArray(scip, &graph.outcnt);
3482  SCIPfreeBufferArray(scip, &graph.outbeg);
3483  SCIPfreeBufferArray(scip, &incut);
3484  SCIPfreeBufferArray(scip, &(sepadata->mapping));
3485  SCIPfreeBufferArray(scip, &vars);
3486  SCIPfreeBufferArray(scip, &vals);
3487 
3488  return SCIP_OKAY;
3489 }
3490 
3491 
3492 /** separation method */
3493 static
3494 SCIP_RETCODE separateOddCycles(
3495  SCIP* scip, /**< SCIP data structure */
3496  SCIP_SEPA* sepa, /**< separator */
3497  SCIP_SOL* sol, /**< given primal solution */
3498  int depth, /**< current depth */
3499  SCIP_RESULT* result /**< pointer to store the result of the separation call */
3500  )
3501 {
3502  SCIP_SEPADATA* sepadata;
3503  int ncalls;
3504  SCIPdebug( int oldnliftedcuts; )
3505  int nfrac = 0;
3506 
3507  *result = SCIP_DIDNOTRUN;
3508 
3509  /* get separator data */
3510  sepadata = SCIPsepaGetData(sepa);
3511  assert(sepadata != NULL);
3512 
3513  ncalls = SCIPsepaGetNCallsAtNode(sepa);
3514 
3515  /* only call separator a given number of rounds at each b&b node */
3516  if( (depth == 0 && sepadata->maxroundsroot >= 0 && ncalls >= sepadata->maxroundsroot)
3517  || (depth > 0 && sepadata->maxrounds >= 0 && ncalls >= sepadata->maxrounds) )
3518  return SCIP_OKAY;
3519 
3520  /* only call separator if enough binary variables are present */
3521  if( SCIPgetNBinVars(scip) < 3 || (! sepadata->includetriangles && SCIPgetNBinVars(scip) < 5) )
3522  {
3523  SCIPdebugMsg(scip, "skipping separator: not enough binary variables\n");
3524  return SCIP_OKAY;
3525  }
3526 
3527  /* only call separator if enough fractional variables are present */
3528  if ( sol != NULL )
3529  {
3530  SCIP_VAR** vars;
3531  SCIP_Real solval;
3532  int nvars;
3533  int v;
3534 
3535  SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
3536 
3537  /* first compute fractional variables */
3538  for( v = 0; v < nvars; ++v )
3539  {
3540  solval = SCIPgetSolVal(scip, sol, vars[v]);
3541 
3542  if ( ! SCIPisFeasIntegral(scip, solval) )
3543  ++nfrac;
3544  }
3545  }
3546  else
3547  nfrac = SCIPgetNLPBranchCands(scip);
3548 
3549  if( nfrac < 3 || (! sepadata->includetriangles && nfrac < 5) )
3550  {
3551  SCIPdebugMsg(scip, "skipping separator: not enough fractional variables\n");
3552  return SCIP_OKAY;
3553  }
3554 
3555  /* only call separator if enough implications and cliques are present */
3556  if( SCIPgetNImplications(scip) + SCIPgetNCliques(scip) < 3 )
3557  {
3558  SCIPdebugMsg(scip, "skipping separator: not enough implications present\n");
3559  return SCIP_OKAY;
3560  }
3561 
3562  /* only run if number of cuts already found is small enough */
3563  if ( sepadata->cutthreshold >= 0 && SCIPgetNCutsFoundRound(scip) >= sepadata->cutthreshold )
3564  return SCIP_OKAY;
3565 
3566  /* store node number and reset number of unsuccessful calls */
3567  if ( sepadata->lastnode != SCIPnodeGetNumber(SCIPgetCurrentNode(scip)) )
3568  {
3569  sepadata->nunsucessfull = 0;
3570  sepadata->lastnode = SCIPnodeGetNumber(SCIPgetCurrentNode(scip));
3571  }
3572  else
3573  {
3574  if ( sepadata->nunsucessfull > sepadata->maxunsucessfull )
3575  {
3576  SCIPdebugMsg(scip, "skipping separator: number of unsucessfull calls = %d.\n", sepadata->nunsucessfull);
3577  return SCIP_OKAY;
3578  }
3579  }
3580 
3581  *result = SCIP_DIDNOTFIND;
3582  sepadata->oldncuts = sepadata->ncuts;
3583  SCIPdebug( oldnliftedcuts = sepadata->nliftedcuts; )
3584 
3585  if( depth == 0 )
3586  sepadata->maxsepacutsround = sepadata->maxsepacutsroot;
3587  else
3588  sepadata->maxsepacutsround = sepadata->maxsepacuts;
3589 
3590  /* perform the actual separation routines */
3591  if( sepadata->usegls )
3592  {
3593  SCIPdebugMsg(scip, "using GLS method for finding odd cycles\n");
3594  SCIP_CALL( separateGLS(scip, sepa, sepadata, sol, result) );
3595  }
3596  else
3597  {
3598  SCIPdebugMsg(scip, "using level graph heuristic for finding odd cycles\n");
3599  SCIP_CALL( separateHeur(scip, sepa, sepadata, sol, result) );
3600  }
3601 
3602  if( sepadata->ncuts - sepadata->oldncuts > 0 )
3603  {
3604  SCIPdebug( SCIPdebugMsg(scip, "added %u cuts (%d allowed), %d lifted.\n", sepadata->ncuts - sepadata->oldncuts,
3605  sepadata->maxsepacutsround, sepadata->nliftedcuts - oldnliftedcuts); )
3606  sepadata->nunsucessfull = 0;
3607  }
3608  else
3609  {
3610  SCIPdebugMsg(scip, "no cuts added (%d allowed)\n", sepadata->maxsepacutsround);
3611  ++sepadata->nunsucessfull;
3612  }
3613  SCIPdebugMsg(scip, "total sepatime: %.2f - total number of added cuts: %u\n", SCIPsepaGetTime(sepa), sepadata->ncuts);
3614 
3615  return SCIP_OKAY;
3616 }
3617 
3618 
3619 /*
3620  * Callback methods of separator
3621  */
3622 
3623 /** copy method for separator plugins (called when SCIP copies plugins) */
3624 static
3625 SCIP_DECL_SEPACOPY(sepaCopyOddcycle)
3626 { /*lint --e{715}*/
3627  assert(scip != NULL);
3628  assert(sepa != NULL);
3629  assert(strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0);
3630 
3631  /* call inclusion method of constraint handler */
3632  SCIP_CALL( SCIPincludeSepaOddcycle(scip) );
3633 
3634  return SCIP_OKAY;
3635 }
3636 
3637 
3638 /** destructor of separator to free user data (called when SCIP is exiting) */
3639 static
3640 SCIP_DECL_SEPAFREE(sepaFreeOddcycle)
3641 {
3642  SCIP_SEPADATA* sepadata;
3643 
3644  sepadata = SCIPsepaGetData(sepa);
3645  assert(sepadata != NULL);
3646 
3647  SCIPfreeBlockMemory(scip, &sepadata);
3648  SCIPsepaSetData(sepa, NULL);
3649 
3650  return SCIP_OKAY;
3651 }
3652 
3653 
3654 /** initialization method of separator (called after problem was transformed) */
3655 static
3656 SCIP_DECL_SEPAINIT(sepaInitOddcycle)
3657 {
3658  SCIP_SEPADATA* sepadata;
3659 
3660  sepadata = SCIPsepaGetData(sepa);
3661  assert(sepadata != NULL);
3662 
3663  sepadata->ncuts = 0;
3664  sepadata->oldncuts = 0;
3665  sepadata->nliftedcuts = 0;
3666  sepadata->lastroot = 0;
3667 
3668  return SCIP_OKAY;
3669 }
3670 
3671 
3672 /** solving process initialization method of separator (called when branch and bound process is about to begin) */
3673 static
3674 SCIP_DECL_SEPAINITSOL(sepaInitsolOddcycle)
3675 {
3676  SCIP_SEPADATA* sepadata;
3677 
3678  assert(sepa != NULL);
3679 
3680  sepadata = SCIPsepaGetData(sepa);
3681  assert(sepadata != NULL);
3682 
3683  sepadata->nunsucessfull = 0;
3684  sepadata->lastnode = -1;
3685 
3686  return SCIP_OKAY;
3687 }
3688 
3689 
3690 /** LP solution separation method of separator */
3691 static
3692 SCIP_DECL_SEPAEXECLP(sepaExeclpOddcycle)
3693 { /*lint --e{715}*/
3694  assert(sepa != NULL);
3695  assert(strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0);
3696  assert(scip != NULL);
3697  assert(result != NULL);
3698 
3699  SCIP_CALL( separateOddCycles(scip, sepa, NULL, depth, result) );
3700 
3701  return SCIP_OKAY;
3702 }
3703 
3704 /** arbitrary primal solution separation method of separator */
3705 static
3706 SCIP_DECL_SEPAEXECSOL(sepaExecsolOddcycle)
3707 { /*lint --e{715}*/
3708  assert(sepa != NULL);
3709  assert(strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0);
3710  assert(scip != NULL);
3711  assert(result != NULL);
3712 
3713  SCIP_CALL( separateOddCycles(scip, sepa, sol, depth, result) );
3714 
3715  return SCIP_OKAY;
3716 }
3717 
3718 
3719 /*
3720  * separator specific interface methods
3721  */
3722 
3723 /** creates the oddcycle separator and includes it in SCIP */
3724 SCIP_RETCODE SCIPincludeSepaOddcycle(
3725  SCIP* scip /**< SCIP data structure */
3726  )
3727 {
3728  SCIP_SEPADATA* sepadata;
3729  SCIP_SEPA* sepa;
3730 
3731  /* create oddcycle separator data */
3732  SCIP_CALL( SCIPallocBlockMemory(scip, &sepadata) );
3733  sepadata->nunsucessfull = 0;
3734  sepadata->lastnode = -1;
3735 
3736  /* include separator */
3737  SCIP_CALL( SCIPincludeSepaBasic(scip, &sepa, SEPA_NAME, SEPA_DESC, SEPA_PRIORITY, SEPA_FREQ, SEPA_MAXBOUNDDIST,
3738  SEPA_USESSUBSCIP, SEPA_DELAY,
3739  sepaExeclpOddcycle, sepaExecsolOddcycle,
3740  sepadata) );
3741 
3742  assert(sepa != NULL);
3743 
3744  /* set non-NULL pointers to callback methods */
3745  SCIP_CALL( SCIPsetSepaCopy(scip, sepa, sepaCopyOddcycle) );
3746  SCIP_CALL( SCIPsetSepaFree(scip, sepa, sepaFreeOddcycle) );
3747  SCIP_CALL( SCIPsetSepaInit(scip, sepa, sepaInitOddcycle) );
3748  SCIP_CALL( SCIPsetSepaInitsol(scip, sepa, sepaInitsolOddcycle) );
3749 
3750  /* add oddcycle separator parameters */
3751  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/usegls",
3752  "Should the search method by Groetschel, Lovasz, Schrijver be used? Otherwise use levelgraph method by Hoffman, Padberg.",
3753  &sepadata->usegls, FALSE, DEFAULT_USEGLS, NULL, NULL) );
3754 
3755  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/liftoddcycles",
3756  "Should odd cycle cuts be lifted?",
3757  &sepadata->liftoddcycles, FALSE, DEFAULT_LIFTODDCYCLES, NULL, NULL) );
3758 
3759  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxsepacuts",
3760  "maximal number of oddcycle cuts separated per separation round",
3761  &sepadata->maxsepacuts, FALSE, DEFAULT_MAXSEPACUTS, 0, INT_MAX, NULL, NULL) );
3762 
3763  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxsepacutsroot",
3764  "maximal number of oddcycle cuts separated per separation round in the root node",
3765  &sepadata->maxsepacutsroot, FALSE, DEFAULT_MAXSEPACUTSROOT, 0, INT_MAX, NULL, NULL) );
3766 
3767  /* add advanced parameters */
3768  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxrounds",
3769  "maximal number of oddcycle separation rounds per node (-1: unlimited)",
3770  &sepadata->maxrounds, FALSE, DEFAULT_MAXROUNDS, -1, INT_MAX, NULL, NULL) );
3771 
3772  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxroundsroot",
3773  "maximal number of oddcycle separation rounds in the root node (-1: unlimited)",
3774  &sepadata->maxroundsroot, FALSE, DEFAULT_MAXROUNDSROOT, -1, INT_MAX, NULL, NULL) );
3775 
3776  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/scalingfactor",
3777  "factor for scaling of the arc-weights",
3778  &sepadata->scale, TRUE, DEFAULT_SCALEFACTOR, 1, INT_MAX, NULL, NULL) );
3779 
3780  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/addselfarcs",
3781  "add links between a variable and its negated",
3782  &sepadata->addselfarcs, TRUE, DEFAULT_ADDSELFARCS, NULL, NULL) );
3783 
3784  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/repaircycles",
3785  "try to repair violated cycles with double appearance of a variable",
3786  &sepadata->repaircycles, TRUE, DEFAULT_REPAIRCYCLES, NULL, NULL) );
3787 
3788  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/includetriangles",
3789  "separate triangles found as 3-cycles or repaired larger cycles",
3790  &sepadata->includetriangles, TRUE, DEFAULT_INCLUDETRIANGLES, NULL, NULL) );
3791 
3792  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/multiplecuts",
3793  "Even if a variable is already covered by a cut, still try it as start node for a cycle search?",
3794  &sepadata->multiplecuts, TRUE, DEFAULT_MULTIPLECUTS, NULL, NULL) );
3795 
3796  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/allowmultiplecuts",
3797  "Even if a variable is already covered by a cut, still allow another cut to cover it too?",
3798  &sepadata->allowmultiplecuts, TRUE, DEFAULT_ALLOWMULTIPLECUTS, NULL, NULL) );
3799 
3800  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/lpliftcoef",
3801  "Choose lifting candidate by coef*lpvalue or only by coef?",
3802  &sepadata->lpliftcoef, TRUE, DEFAULT_LPLIFTCOEF, NULL, NULL) );
3803 
3804  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/recalcliftcoef",
3805  "Calculate lifting coefficient of every candidate in every step (or only if its chosen)?",
3806  &sepadata->recalcliftcoef, TRUE, DEFAULT_RECALCLIFTCOEF, NULL, NULL) );
3807 
3808  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/sortswitch",
3809  "use sorted variable array (unsorted(0), maxlp(1), minlp(2), maxfrac(3), minfrac(4))",
3810  (int*) &sepadata->sortswitch, TRUE, DEFAULT_SORTSWITCH, 0, 4, NULL, NULL) );
3811 
3812  SCIP_CALL( SCIPaddBoolParam(scip, "separating/" SEPA_NAME "/sortrootneighbors",
3813  "sort level of the root neighbors by fractionality (maxfrac)",
3814  &sepadata->sortrootneighbors, TRUE, DEFAULT_SORTROOTNEIGHBORS, NULL, NULL) );
3815 
3816  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/percenttestvars",
3817  "percentage of variables to try the chosen method on [0-100]",
3818  &sepadata->percenttestvars, TRUE, DEFAULT_PERCENTTESTVARS, 0, 100, NULL, NULL) );
3819 
3820  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/offsettestvars",
3821  "offset of variables to try the chosen method on (additional to the percentage of testvars)",
3822  &sepadata->offsettestvars, TRUE, DEFAULT_OFFSETTESTVARS, 0, INT_MAX, NULL, NULL) );
3823 
3824  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxpernodeslevel",
3825  "percentage of nodes allowed in the same level of the level graph [0-100]",
3826  &sepadata->maxpernodeslevel, TRUE, DEFAULT_MAXPERNODESLEVEL, 0, 100, NULL, NULL) );
3827 
3828  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/offsetnodeslevel",
3829  "offset of nodes allowed in the same level of the level graph (additional to the percentage of levelnodes)",
3830  &sepadata->offsetnodeslevel, TRUE, DEFAULT_OFFSETNODESLEVEL, 0, INT_MAX, NULL, NULL) );
3831 
3832  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxnlevels",
3833  "maximal number of levels in level graph",
3834  &sepadata->maxnlevels, TRUE, DEFAULT_MAXNLEVELS, 0, INT_MAX, NULL, NULL) );
3835 
3836  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxcutsroot",
3837  "maximal number of oddcycle cuts generated per chosen variable as root of the level graph",
3838  &sepadata->maxcutsroot, TRUE, DEFAULT_MAXCUTSROOT, 0, INT_MAX, NULL, NULL) );
3839 
3840  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxcutslevel",
3841  "maximal number of oddcycle cuts generated in every level of the level graph",
3842  &sepadata->maxcutslevel, TRUE, DEFAULT_MAXCUTSLEVEL, 0, INT_MAX, NULL, NULL) );
3843 
3844  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxreference",
3845  "minimal weight on an edge (in level graph or bipartite graph)",
3846  &sepadata->maxreference, TRUE, DEFAULT_MAXREFERENCE, 0, INT_MAX, NULL, NULL) );
3847 
3848  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxunsucessfull",
3849  "number of unsuccessful calls at current node",
3850  &sepadata->maxunsucessfull, TRUE, DEFAULT_MAXUNSUCESSFULL, 0, INT_MAX, NULL, NULL) );
3851 
3852  SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/cutthreshold",
3853  "maximal number of other cuts s.t. separation is applied (-1 for direct call)",
3854  &sepadata->cutthreshold, TRUE, DEFAULT_CUTTHRESHOLD, -1, INT_MAX, NULL, NULL) );
3855 
3856  return SCIP_OKAY;
3857 }
SCIP_RESULT
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
checkBlocking
static void checkBlocking(unsigned int a, unsigned int b, unsigned int c, unsigned int i, unsigned int *cycle, unsigned int ncyclevars, SCIP_VAR **vars, unsigned int nbinvars, unsigned int *lifted, unsigned int *nlifted, GRAPHDATA *graphdata, SCIP_Bool *myi)
Definition: sepa_oddcycle.c:511
SCIP_DECL_SEPAEXECLP
static SCIP_DECL_SEPAEXECLP(sepaExeclpOddcycle)
Definition: sepa_oddcycle.c:3693
SCIP_DIDNOTRUN
Definition: type_result.h:33
separateHeur
static SCIP_RETCODE separateHeur(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: sepa_oddcycle.c:2252
narcs
#define narcs
Definition: gastrans.c:68
SCIPcliqueGetVars
SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)
Definition: implics.c:3368
MAXIMAL_LPVALUE
Definition: sepa_oddcycle.c:161
SCIPcacheRowExtensions
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1626
scip_param.h
public methods for SCIP parameter handling
SCIPgetCurrentNode
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition: scip_tree.c:82
generateOddCycleCut
static SCIP_RETCODE generateOddCycleCut(SCIP *scip, SCIP_SEPA *sepa, SCIP_SOL *sol, SCIP_VAR **vars, unsigned int nbinvars, unsigned int startnode, unsigned int *pred, unsigned int ncyclevars, unsigned int *incut, SCIP_Real *vals, SCIP_SEPADATA *sepadata, GRAPHDATA *graphdata, SCIP_RESULT *result)
Definition: sepa_oddcycle.c:873
pub_tree.h
public methods for branch and bound tree
scip_mem.h
public methods for memory management
dijkstra.h
Definitions for Disjkstra&#39;s shortest path algorithm.
SEPA_DELAY
#define SEPA_DELAY
Definition: sepa_oddcycle.c:70
SCIPflushRowExtensions
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1649
GraphData::dijkstragraph
DIJKSTRA_GRAPH * dijkstragraph
Definition: sepa_oddcycle.c:173
pub_implics.h
public methods for implications, variable bounds, and cliques
SCIPgetRealParam
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip_param.c:298
SCIP_MAXSTRLEN
#define SCIP_MAXSTRLEN
Definition: def.h:293
DIJKSTRA_FARAWAY
#define DIJKSTRA_FARAWAY
Definition: dijkstra.h:38
DEFAULT_MAXROUNDSROOT
#define DEFAULT_MAXROUNDSROOT
Definition: sepa_oddcycle.c:94
SCIPaddVarToRow
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
Definition: scip_lp.c:1686
SEPA_USESSUBSCIP
#define SEPA_USESSUBSCIP
Definition: sepa_oddcycle.c:69
SCIPvarGetCliques
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18273
DEFAULT_LPLIFTCOEF
#define DEFAULT_LPLIFTCOEF
Definition: sepa_oddcycle.c:82
addArc
static SCIP_RETCODE addArc(SCIP *scip, LEVELGRAPH *graph, unsigned int u, unsigned int v, unsigned int level, unsigned int weight, unsigned int *nAdj, SCIP_Bool *success)
Definition: sepa_oddcycle.c:1330
SCIPsortDownRealPtr
void SCIPsortDownRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
SCIP_Var
Definition: struct_var.h:198
SCIPsplitFilename
void SCIPsplitFilename(char *filename, char **path, char **name, char **extension, char **compression)
Definition: misc.c:10974
SCIPvarIsBinary
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
Definition: var.c:17431
DEFAULT_MAXSEPACUTSROOT
#define DEFAULT_MAXSEPACUTSROOT
Definition: sepa_oddcycle.c:87
SCIPgetVarsData
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip_prob.c:1864
SCIP_VERBLEVEL_HIGH
Definition: type_message.h:45
FALSE
#define FALSE
Definition: def.h:87
DEFAULT_MULTIPLECUTS
#define DEFAULT_MULTIPLECUTS
Definition: sepa_oddcycle.c:80
DIJKSTRA_Graph::outcnt
unsigned int * outcnt
Definition: dijkstra.h:47
SCIPinfinity
SCIP_Real SCIPinfinity(SCIP *scip)
Definition: scip_numerics.c:503
SCIPsnprintf
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10755
DEFAULT_OFFSETNODESLEVEL
#define DEFAULT_OFFSETNODESLEVEL
Definition: sepa_oddcycle.c:97
DIJKSTRA_Graph::maxweight
unsigned int maxweight
Definition: dijkstra.h:52
TRUE
#define TRUE
Definition: def.h:86
SCIPdebug
#define SCIPdebug(x)
Definition: pub_message.h:84
SCIPsepaGetName
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:720
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIPsepaGetTime
SCIP_Real SCIPsepaGetTime(SCIP_SEPA *sepa)
Definition: sepa.c:827
SCIPvarGetProbindex
int SCIPvarGetProbindex(SCIP_VAR *var)
Definition: var.c:17600
pub_var.h
public methods for problem variables
dijkstraPairCutoff
unsigned int dijkstraPairCutoff(const DIJKSTRA_GRAPH *G, unsigned int source, unsigned int target, unsigned long long cutoff, unsigned long long *dist, unsigned int *pred, unsigned int *entry, unsigned int *order)
Definition: dijkstra.c:387
SCIPfreeBlockMemory
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:99
MINIMAL_FRACTIONALITY
Definition: sepa_oddcycle.c:164
SCIP_SEPARATED
Definition: type_result.h:40
DEFAULT_MAXPERNODESLEVEL
#define DEFAULT_MAXPERNODESLEVEL
Definition: sepa_oddcycle.c:96
liftOddCycleCut
static SCIP_RETCODE liftOddCycleCut(SCIP *scip, unsigned int *nlifted, unsigned int *lifted, unsigned int *liftcoef, SCIP_SEPADATA *sepadata, GRAPHDATA *graphdata, SCIP_VAR **vars, unsigned int nbinvars, unsigned int startnode, unsigned int *pred, unsigned int ncyclevars, SCIP_Real *vals, SCIP_RESULT *result)
Definition: sepa_oddcycle.c:701
SCIPgetNCutsFoundRound
int SCIPgetNCutsFoundRound(SCIP *scip)
Definition: scip_solvingstats.c:1043
DEFAULT_SORTSWITCH
#define DEFAULT_SORTSWITCH
Definition: sepa_oddcycle.c:91
SCIPchgVarLb
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4673
SCIPsortDownRealInt
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
SCIP_Sepa
Definition: struct_sepa.h:37
SCIPfreeBufferArray
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:127
SCIPgetNLPBranchCands
int SCIPgetNLPBranchCands(SCIP *scip)
Definition: scip_branch.c:419
scip_var.h
public methods for SCIP variables
SCIPsetSepaCopy
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
Definition: scip_sepa.c:142
SEPA_PRIORITY
#define SEPA_PRIORITY
Definition: sepa_oddcycle.c:66
DIJKSTRA_Graph::nodes
unsigned int nodes
Definition: dijkstra.h:45
DEFAULT_MAXSEPACUTS
#define DEFAULT_MAXSEPACUTS
Definition: sepa_oddcycle.c:86
SCIPdebugMsg
#define SCIPdebugMsg
Definition: scip_message.h:69
SCIPaddIntParam
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:74
scip_sepa.h
public methods for separator plugins
SEPA_MAXBOUNDDIST
#define SEPA_MAXBOUNDDIST
Definition: sepa_oddcycle.c:68
x
SCIP_VAR ** x
Definition: circlepacking.c:54
SCIPvarGetNCliques
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
Definition: var.c:18262
SCIP_DECL_SEPAINIT
static SCIP_DECL_SEPAINIT(sepaInitOddcycle)
Definition: sepa_oddcycle.c:3657
SCIPfeasCeil
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:910
scip_numerics.h
public methods for numerical tolerances
SCIPsepaGetData
SCIP_SEPADATA * SCIPsepaGetData(SCIP_SEPA *sepa)
Definition: sepa.c:610
separateOddCycles
static SCIP_RETCODE separateOddCycles(SCIP *scip, SCIP_SEPA *sepa, SCIP_SOL *sol, int depth, SCIP_RESULT *result)
Definition: sepa_oddcycle.c:3495
DEFAULT_ADDSELFARCS
#define DEFAULT_ADDSELFARCS
Definition: sepa_oddcycle.c:78
cleanCycle
static SCIP_RETCODE cleanCycle(SCIP *scip, unsigned int *pred, SCIP_Bool *incycle, unsigned int *incut, unsigned int x, unsigned int startnode, unsigned int nbinvars, unsigned int *ncyclevars, SCIP_Bool repaircycles, SCIP_Bool allowmultiplecuts, SCIP_Bool *success)
Definition: sepa_oddcycle.c:1074
scip_solvingstats.h
public methods for querying solving statistics
SCIP_Sol
Definition: struct_sol.h:64
SCIPgetProbName
const char * SCIPgetProbName(SCIP *scip)
Definition: scip_prob.c:1065
DEFAULT_ALLOWMULTIPLECUTS
#define DEFAULT_ALLOWMULTIPLECUTS
Definition: sepa_oddcycle.c:81
MAXIMAL_FRACTIONALITY
Definition: sepa_oddcycle.c:163
scip_tree.h
public methods for the branch-and-bound tree
SCIPnodeGetNumber
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
Definition: tree.c:7432
DEFAULT_INCLUDETRIANGLES
#define DEFAULT_INCLUDETRIANGLES
Definition: sepa_oddcycle.c:79
SCIPisCutEfficacious
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip_cut.c:108
SCIP_DECL_SEPACOPY
static SCIP_DECL_SEPACOPY(sepaCopyOddcycle)
Definition: sepa_oddcycle.c:3626
GraphData::usegls
SCIP_Bool usegls
Definition: sepa_oddcycle.c:171
separateGLS
static SCIP_RETCODE separateGLS(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: sepa_oddcycle.c:2979
SCIP_DIDNOTFIND
Definition: type_result.h:35
DEFAULT_SORTROOTNEIGHBORS
#define DEFAULT_SORTROOTNEIGHBORS
Definition: sepa_oddcycle.c:98
SCIPerrorMessage
#define SCIPerrorMessage
Definition: pub_message.h:55
findUnblockedShortestPathToRoot
static SCIP_RETCODE findUnblockedShortestPathToRoot(SCIP *scip, int scale, LEVELGRAPH *graph, unsigned int startnode, unsigned int *distance, unsigned int *queue, SCIP_Bool *inQueue, int *parentTreeBackward, unsigned int root, SCIP_Bool *blocked)
Definition: sepa_oddcycle.c:1955
DIJKSTRA_Graph::minweight
unsigned int minweight
Definition: dijkstra.h:51
addGLSCliques
static SCIP_RETCODE addGLSCliques(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_VAR **vars, unsigned int varsidx, unsigned int dijkindex, SCIP_Real *vals, unsigned int nbinvars, unsigned int ncliques, DIJKSTRA_GRAPH *graph, unsigned int *narcs, unsigned int maxarcs, SCIP_Bool original, SCIP_Bool *emptygraph, unsigned int *arraysize, SCIP_Bool *success)
Definition: sepa_oddcycle.c:2820
SCIPsepaGetNCallsAtNode
int SCIPsepaGetNCallsAtNode(SCIP_SEPA *sepa)
Definition: sepa.c:847
DIJKSTRA_Graph::head
unsigned int * head
Definition: dijkstra.h:50
SCIPchgVarUb
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4763
SCIPvarGetName
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17251
DEFAULT_MAXREFERENCE
#define DEFAULT_MAXREFERENCE
Definition: sepa_oddcycle.c:92
SCIPsepaSetData
void SCIPsepaSetData(SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata)
Definition: sepa.c:620
SCIPgetBoolParam
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip_param.c:241
DEFAULT_REPAIRCYCLES
#define DEFAULT_REPAIRCYCLES
Definition: sepa_oddcycle.c:77
MINIMAL_LPVALUE
Definition: sepa_oddcycle.c:162
NULL
#define NULL
Definition: lpi_spx1.cpp:155
dijkstraGraphIsValid
DIJKSTRA_Bool dijkstraGraphIsValid(const DIJKSTRA_GRAPH *G)
Definition: dijkstra.c:33
SCIP_OKAY
Definition: type_retcode.h:33
SCIPsetSepaInitsol
SCIP_RETCODE SCIPsetSepaInitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
Definition: scip_sepa.c:206
SCIP_DECL_SEPAINITSOL
static SCIP_DECL_SEPAINITSOL(sepaInitsolOddcycle)
Definition: sepa_oddcycle.c:3675
SCIP_CALL
#define SCIP_CALL(x)
Definition: def.h:384
SCIP_REDUCEDDOM
Definition: type_result.h:42
SCIProwGetRhs
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
Definition: lp.c:17235
SCIPverbMessage
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
Definition: scip_message.c:216
SCIPaddRow
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip_cut.c:241
DIJKSTRA_UNUSED
#define DIJKSTRA_UNUSED
Definition: dijkstra.h:39
DEFAULT_MAXCUTSROOT
#define DEFAULT_MAXCUTSROOT
Definition: sepa_oddcycle.c:90
SCIPincludeSepaBasic
SCIP_RETCODE SCIPincludeSepaBasic(SCIP *scip, SCIP_SEPA **sepa, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
Definition: scip_sepa.c:100
dijkstraPairCutoffIgnore
unsigned int dijkstraPairCutoffIgnore(const DIJKSTRA_GRAPH *G, unsigned int source, unsigned int target, unsigned int *ignore, unsigned long long cutoff, unsigned long long *dist, unsigned int *pred, unsigned int *entry, unsigned int *order)
Definition: dijkstra.c:498
SCIPallocBufferArray
#define SCIPallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:115
DEFAULT_PERCENTTESTVARS
#define DEFAULT_PERCENTTESTVARS
Definition: sepa_oddcycle.c:88
pub_misc.h
public data structures and miscellaneous methods
SCIP_Bool
#define SCIP_Bool
Definition: def.h:84
SCIPchgRowRhs
SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
Definition: scip_lp.c:1598
DIJKSTRA_Graph
Definition: dijkstra.h:43
DEFAULT_MAXUNSUCESSFULL
#define DEFAULT_MAXUNSUCESSFULL
Definition: sepa_oddcycle.c:100
GraphData::levelgraph
LEVELGRAPH * levelgraph
Definition: sepa_oddcycle.c:172
MAX
#define MAX(x, y)
Definition: tclique_def.h:83
SCIP_Row
Definition: struct_lp.h:192
SCIPaddPoolCut
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip_cut.c:352
SCIPcliqueGetValues
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
Definition: implics.c:3380
pub_lp.h
public methods for LP management
SCIPcreateEmptyRowSepa
SCIP_RETCODE SCIPcreateEmptyRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1444
getCoef
static unsigned int getCoef(SCIP *scip, unsigned int i, unsigned int *cycle, unsigned int ncyclevars, SCIP_VAR **vars, unsigned int nbinvars, unsigned int *lifted, unsigned int *nlifted, GRAPHDATA *graphdata, SCIP_Bool *myi)
Definition: sepa_oddcycle.c:564
DEFAULT_USEGLS
#define DEFAULT_USEGLS
Definition: sepa_oddcycle.c:75
SCIPwriteCliqueGraph
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip_var.c:7707
scip_cut.h
public methods for cuts and aggregation rows
SEPA_DESC
#define SEPA_DESC
Definition: sepa_oddcycle.c:65
DEFAULT_SCALEFACTOR
#define DEFAULT_SCALEFACTOR
Definition: sepa_oddcycle.c:74
SCIPisInfinity
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:514
SEPA_NAME
#define SEPA_NAME
Definition: sepa_oddcycle.c:64
SCIPgetNBinVars
int SCIPgetNBinVars(SCIP *scip)
Definition: scip_prob.c:2035
scip_lp.h
public methods for the LP relaxation, rows and columns
DEFAULT_MAXNLEVELS
#define DEFAULT_MAXNLEVELS
Definition: sepa_oddcycle.c:95
DIJKSTRA_Graph::weight
unsigned int * weight
Definition: dijkstra.h:49
pub_misc_sort.h
methods for sorting joint arrays of various types
isNeighbor
static SCIP_Bool isNeighbor(SCIP_VAR **vars, unsigned int nbinvars, GRAPHDATA *graphdata, unsigned int a, unsigned int b)
Definition: sepa_oddcycle.c:298
insertSortedRootNeighbors
static SCIP_RETCODE insertSortedRootNeighbors(SCIP *scip, LEVELGRAPH *graph, unsigned int nbinvars, unsigned int ncurlevel, unsigned int u, SCIP_Real *vals, SCIP_VAR **vars, SCIP_SEPADATA *sepadata, unsigned int *nnewlevel, SCIP_Bool *inlevelgraph, unsigned int level, unsigned int *newlevel, SCIP_Bool *success)
Definition: sepa_oddcycle.c:1572
scip_branch.h
public methods for branching rule plugins and branching
SCIP_DECL_SEPAFREE
static SCIP_DECL_SEPAFREE(sepaFreeOddcycle)
Definition: sepa_oddcycle.c:3641
b
SCIP_VAR ** b
Definition: circlepacking.c:56
SCIPreleaseRow
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
Definition: scip_lp.c:1553
checkArraySizesHeur
static SCIP_RETCODE checkArraySizesHeur(SCIP *scip, LEVELGRAPH *graph, unsigned int *size, int **targetArray, unsigned int **weightArray, unsigned int **sourceAdjArray, unsigned int **targetAdjArray, SCIP_Bool *success)
Definition: sepa_oddcycle.c:1242
checkArraySizesGLS
static SCIP_RETCODE checkArraySizesGLS(SCIP *scip, unsigned int maxarcs, unsigned int *arraysize, DIJKSTRA_GRAPH *graph, SCIP_Bool *success)
Definition: sepa_oddcycle.c:2744
scip_general.h
general public methods
UNSORTED
Definition: sepa_oddcycle.c:160
SCIPsetSepaFree
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
Definition: scip_sepa.c:158
SCIPsetSepaInit
SCIP_RETCODE SCIPsetSepaInit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
Definition: scip_sepa.c:174
scip_sol.h
public methods for solutions
SCIPgetMemUsed
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
Definition: scip_mem.c:91
SCIProwChgRank
void SCIProwChgRank(SCIP_ROW *row, int rank)
Definition: lp.c:17467
DEFAULT_RECALCLIFTCOEF
#define DEFAULT_RECALCLIFTCOEF
Definition: sepa_oddcycle.c:85
pub_message.h
public methods for message output
SCIPgetNCliques
int SCIPgetNCliques(SCIP *scip)
Definition: scip_var.c:7572
a
SCIP_VAR * a
Definition: circlepacking.c:57
SCIPgetNImplications
int SCIPgetNImplications(SCIP *scip)
Definition: scip_solvingstats.c:4388
SCIPgetMemExternEstim
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
Definition: scip_mem.c:117
SCIP_Real
#define SCIP_Real
Definition: def.h:177
SORTTYPE
enum sorttype SORTTYPE
Definition: sepa_oddcycle.c:166
SCIPisStopped
SCIP_Bool SCIPisStopped(SCIP *scip)
Definition: scip_general.c:694
DEFAULT_OFFSETTESTVARS
#define DEFAULT_OFFSETTESTVARS
Definition: sepa_oddcycle.c:89
SCIP_Clique
Definition: struct_implics.h:66
scip_message.h
public methods for message handling
SCIPprintRow
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
Definition: scip_lp.c:2197
DIJKSTRA_Graph::arcs
unsigned int arcs
Definition: dijkstra.h:48
DEFAULT_CUTTHRESHOLD
#define DEFAULT_CUTTHRESHOLD
Definition: sepa_oddcycle.c:101
SCIP_Longint
#define SCIP_Longint
Definition: def.h:162
SCIPsortRealPtr
void SCIPsortRealPtr(SCIP_Real *realarray, void **ptrarray, int len)
SEPA_FREQ
#define SEPA_FREQ
Definition: sepa_oddcycle.c:67
SCIPvarGetType
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:17416
blockRootPath
static SCIP_RETCODE blockRootPath(SCIP *scip, LEVELGRAPH *graph, unsigned int startnode, SCIP_Bool *inlevelgraph, SCIP_Bool *blocked, int *parentTree, unsigned int root)
Definition: sepa_oddcycle.c:1866
nnodes
#define nnodes
Definition: gastrans.c:65
SCIPcliqueGetNVars
int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)
Definition: implics.c:3358
SCIPisFeasIntegral
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:874
pub_sepa.h
public methods for separators
BMSclearMemoryArray
#define BMSclearMemoryArray(ptr, num)
Definition: memory.h:123
addNextLevelCliques
static SCIP_RETCODE addNextLevelCliques(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_VAR **vars, SCIP_Real *vals, unsigned int u, LEVELGRAPH *graph, unsigned int level, SCIP_Bool *inlevelgraph, unsigned int *newlevel, unsigned int *nnewlevel, unsigned int *nAdj, SCIP_Bool *success)
Definition: sepa_oddcycle.c:1407
sorttype
sorttype
Definition: sepa_oddcycle.c:158
SCIPallocBlockMemory
SCIPallocBlockMemory(scip, subsol))
SCIPincludeSepaOddcycle
SCIP_RETCODE SCIPincludeSepaOddcycle(SCIP *scip)
Definition: sepa_oddcycle.c:3725
SCIP_INVALIDDATA
Definition: type_retcode.h:43
SCIPceil
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:636
createNextLevel
static SCIP_RETCODE createNextLevel(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_VAR **vars, SCIP_Real *vals, LEVELGRAPH *graph, unsigned int level, SCIP_Bool *inlevelgraph, unsigned int *curlevel, unsigned int ncurlevel, unsigned int *newlevel, unsigned int *nnewlevel, SCIP_Bool *success)
Definition: sepa_oddcycle.c:2075
DIJKSTRA_Graph::outbeg
unsigned int * outbeg
Definition: dijkstra.h:46
DEFAULT_LIFTODDCYCLES
#define DEFAULT_LIFTODDCYCLES
Definition: sepa_oddcycle.c:76
SCIPgetNLPs
SCIP_Longint SCIPgetNLPs(SCIP *scip)
Definition: scip_solvingstats.c:419
SCIPABORT
#define SCIPABORT()
Definition: def.h:356
scip_prob.h
public methods for global and local (sub)problems
DEFAULT_MAXCUTSLEVEL
#define DEFAULT_MAXCUTSLEVEL
Definition: sepa_oddcycle.c:99
sepa_oddcycle.h
oddcycle separator
SCIP_DECL_SEPAEXECSOL
static SCIP_DECL_SEPAEXECSOL(sepaExecsolOddcycle)
Definition: sepa_oddcycle.c:3707
SCIPgetSolVal
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition: scip_sol.c:1352
findShortestPathToRoot
static SCIP_RETCODE findShortestPathToRoot(SCIP *scip, int scale, LEVELGRAPH *graph, unsigned int startnode, unsigned int *distance, unsigned int *queue, SCIP_Bool *inQueue, int *parentTree)
Definition: sepa_oddcycle.c:1775
SCIPfloor
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:624
DEFAULT_MAXROUNDS
#define DEFAULT_MAXROUNDS
Definition: sepa_oddcycle.c:93
SCIP_CUTOFF
Definition: type_result.h:39
SCIP_SEPADATA
struct SCIP_SepaData SCIP_SEPADATA
Definition: type_sepa.h:43
SCIPaddBoolParam
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:48
SCIPreallocBufferArray
#define SCIPreallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:119
memory.h
memory allocation routines
SCIP_VARTYPE_CONTINUOUS
Definition: type_var.h:58