SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
compr_weakcompr.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-2025 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file compr_weakcompr.c
26 * @ingroup OTHER_CFILES
27 * @brief weakcompr tree compression
28 * @author Jakob Witzig
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
35#include "scip/pub_compr.h"
36#include "scip/pub_message.h"
37#include "scip/pub_misc_sort.h"
38#include "scip/pub_reopt.h"
39#include "scip/pub_tree.h"
40#include "scip/scip_compr.h"
41#include "scip/scip_general.h"
42#include "scip/scip_mem.h"
43#include "scip/scip_message.h"
44#include "scip/scip_numerics.h"
45#include "scip/scip_param.h"
46#include "scip/scip_prob.h"
47#include "scip/scip_reopt.h"
48#include "scip/scip_tree.h"
49#include <string.h>
50
51#define COMPR_NAME "weakcompr"
52#define COMPR_DESC "reduce the search frontier to k+1 or max{2, |C|+1} nodes."
53#define COMPR_PRIORITY 1000
54#define COMPR_MINNNODES 50
55
56#define DEFAULT_MEM_REPR 2 /* since we cannot convert the added constraints into node currently, we choose 2 as default value */
57/*
58 * Data structures
59 */
60
61/** tree compression data */
62struct SCIP_ComprData
63{
64 /* representative data */
65 SCIP_REOPTNODE** representatives; /**< list of representatives */
66 int nrepresentatives; /**< number of representatives */
67 int representativessize;/**< size of array representatives */
68 SCIP_Bool initialized; /**< was compressor data initialized? */
69
70 /* parameter */
71 SCIP_Bool convertconss; /**< convert added logic-or constraints of size k into k nodes */
72};
73
74
75/*
76 * Local methods
77 */
78
79/** sort the ids of child nodes by their dual bound of the last iteration */
80static
82 SCIP* scip, /**< SCIP data structure */
83 unsigned int* childids, /**< array of child ids */
84 int nchildids /**< first position */
85 )
86{
87 SCIP_Real* lowerbounds;
88 int i;
89
90 SCIP_CALL( SCIPallocBufferArray(scip, &lowerbounds, nchildids) );
91
92 for( i = 0; i < nchildids; i++ )
93 {
94 lowerbounds[i] = SCIPreoptnodeGetLowerbound(SCIPgetReoptnode(scip, childids[i]));
95 }
96
97 /* sort the ids in decreasing order */
98 SCIPsortDownRealInt(lowerbounds, (signed int*)childids, nchildids);
99
100 /* free buffer memory */
101 SCIPfreeBufferArray(scip, &lowerbounds);
102
103 return SCIP_OKAY;
104}
105
106/** check of enough memory is allocated and reallocate of necessary. */
107static
109 SCIP* scip, /**< SCIP data structure */
110 SCIP_COMPRDATA* comprdata, /**< compression data */
111 int nrepresentatives /**< number of representatives */
112 )
113{
114 assert(scip != NULL);
115 assert(comprdata != NULL);
116
117 if( comprdata->representativessize < nrepresentatives )
118 {
119 SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &comprdata->representatives, comprdata->representativessize, nrepresentatives) );
120 comprdata->representativessize = nrepresentatives;
121 }
122
123 return SCIP_OKAY;
124}
125
126/** try to find a good representation
127 *
128 * @todo implement:
129 * 1) using k nodes without added constraint;
130 * 2) resolve the added nods via some kind of interdiction branching
131 */
132static
134 SCIP* scip, /**< SCIP data structure */
135 SCIP_COMPR* compr, /**< compression method */
136 SCIP_COMPRDATA* comprdata, /**< compression data */
137 SCIP_RESULT* result /**< result pointer */
138 )
139{
140 SCIP_NODE* currentnode;
141 SCIP_VAR**** conss_var;
142 SCIP_VAR*** vars;
143 SCIP_Real*** conss_val;
144 SCIP_Real** vals;
145 SCIP_BOUNDTYPE** boundtypes;
146 SCIP_BOUNDTYPE*** conss_boundtypes;
147 int** conss_nvars;
148 unsigned int* leaveids;
149 int* nconss;
150 int* nvars;
151 int mem_vars;
152 int nids;
153 int nleaveids;
154 int pos_repr_fix;
155 int size;
156 int k;
157 int r;
158
159 assert(scip != NULL);
160 assert(comprdata != NULL);
161
163
164 size = 1;
166
168 nleaveids = SCIPgetNReoptLeaves(scip, currentnode);
169 else
170 {
171 assert(currentnode != NULL);
172 nleaveids = SCIPgetNReoptLeaves(scip, currentnode);
173 }
174
175 SCIPdebugMsg(scip, ">> start <%s> at node %" SCIP_LONGINT_FORMAT " (nleaves: %d, depth: %d)\n", COMPR_NAME,
177 nleaveids, SCIPgetStage(scip) <= SCIP_STAGE_PRESOLVED ? 0 : SCIPnodeGetDepth(currentnode));
178
179 if( SCIPcomprGetMinNodes(compr) > nleaveids )
180 {
181 SCIPdebugMsg(scip, "-> skip compression (min. leaves = %d)\n", SCIPcomprGetMinNodes(compr));
182 return SCIP_OKAY;
183 }
184
185 if( nleaveids == 0 )
186 {
187 SCIPdebugMsg(scip, "-> skip compression (k = %d, nleaves = %d)\n", 1, nleaveids);
188 return SCIP_OKAY;
189 }
190
191 SCIPdebugMsg(scip, "-> try compression with %d node(s)\n", 1);
192
194
195 /* collect the nodes to compress */
196 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &leaveids, nleaveids) );
197
198 SCIP_CALL( SCIPgetReoptLeaveIDs(scip, currentnode, leaveids, nleaveids, &nids) );
199 assert(nids == nleaveids);
200
201 /* sort the ids */
202 SCIP_CALL( sortIDs(scip, leaveids, nleaveids) );
203
204 /* allocate memory to store the old tree */
205
206 mem_vars = 2*SCIPgetNVars(scip);
207
208 /* we use normal instead of buffer memory because we may need to reallocate the 2-dimensional arrays */
211 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &boundtypes, size) );
212
213 /* allocate buffer memory */
214 SCIP_CALL( SCIPallocBufferArray(scip, &conss_var, size) );
215 SCIP_CALL( SCIPallocBufferArray(scip, &conss_val, size) );
216 SCIP_CALL( SCIPallocBufferArray(scip, &conss_boundtypes, size) );
217 SCIP_CALL( SCIPallocBufferArray(scip, &conss_nvars, size) );
219 SCIP_CALL( SCIPallocBufferArray(scip, &nconss, size) );
220
221 /* get data of nodes */
222 for( k = size-1; k < 1; k++ )
223 {
224 SCIP_REOPTNODE* reoptnode;
225 int mem_conss;
226 int nvars2;
227 int nafterdualvars;
228 SCIPdebug(int c);
229
230 /* we use normal instead of buffer memory because we may need to reallocate the 2-dimensional arrays */
231 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &vars[k], mem_vars) );
232 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &vals[k], mem_vars) );
233 SCIP_CALL( SCIPallocBlockMemoryArray(scip, &boundtypes[k], mem_vars) );
234
235 /* get the branching path */
236 reoptnode = SCIPgetReoptnode(scip, leaveids[k]);
237 assert(reoptnode != NULL);
238
239 SCIPgetReoptnodePath(scip, reoptnode, vars[k], vals[k], boundtypes[k], mem_vars, &nvars2, &nafterdualvars);
240 assert(mem_vars >= nvars2 + nafterdualvars);
241
242 nvars[k] = nvars2 + nafterdualvars;
243
244 /* get the constraints */
245 mem_conss = SCIPreoptnodeGetNConss(reoptnode);
246
247 SCIP_CALL( SCIPallocBufferArray(scip, &conss_var[k], mem_conss) ); /*lint !e866*/
248 SCIP_CALL( SCIPallocBufferArray(scip, &conss_val[k], mem_conss) ); /*lint !e866*/
249 SCIP_CALL( SCIPallocBufferArray(scip, &conss_boundtypes[k], mem_conss) ); /*lint !e866*/
250 SCIP_CALL( SCIPallocBufferArray(scip, &conss_nvars[k], mem_conss) ); /*lint !e866*/
251
252 SCIPreoptnodeGetConss(reoptnode, conss_var[k], conss_val[k], conss_boundtypes[k], mem_conss, &nconss[k],
253 conss_nvars[k]);
254 assert(mem_conss == nconss[k]);
255
256#ifdef SCIP_DEBUG
257 for( c = 0; c < mem_conss; c++ )
258 assert(conss_nvars[k][c] <= SCIPgetNBinVars(scip) + SCIPgetNIntVars(scip));
259#endif
260
261#ifndef NDEBUG
262 reoptnode = SCIPgetReoptnode(scip, leaveids[k]);
263 assert(reoptnode != NULL);
264
265 SCIPdebugMsg(scip, "-> use node at id %u, %d vars, %d conss, lowerbound = %.g\n", leaveids[k], nvars[k],
267#endif
268 }
269
270 /* perform the compression */
271 assert(comprdata->nrepresentatives == 0);
272
273 pos_repr_fix = 1;
274
275 /* calculate the number of representatives */
276 comprdata->nrepresentatives = (nvars[0] > 0 ? 2 : 1);
277 comprdata->nrepresentatives += nconss[0];
278
279 /* check memory size */
280 SCIP_CALL( checkMemSize(scip, comprdata, comprdata->nrepresentatives) );
281 assert(comprdata->nrepresentatives <= comprdata->representativessize);
282
283 /* initialize the representatives */
284 SCIP_CALL( SCIPinitRepresentation(scip, comprdata->representatives, comprdata->nrepresentatives) );
285
286 /* create 2 candidates for the fixed variables */
287 if( nvars[0] >= 1 )
288 {
289 SCIP_Bool linear;
290 int v;
291
292 assert(pos_repr_fix < comprdata->nrepresentatives);
293
294 linear = TRUE; /* todo: we have to adapt the compression to handle integer variables */
295
296 /* create a representative at position 1 with fixed branching path */
297 assert(SCIPreoptnodeGetNVars(comprdata->representatives[pos_repr_fix]) == 0);
298 for( r = pos_repr_fix; r < comprdata->nrepresentatives; r++ )
299 {
300 /* copy the branching path to all representatives */
301 assert(comprdata->representatives[r] != NULL);
302
303 for( v = 0; v < nvars[0]; v++ )
304 {
305 SCIP_CALL( SCIPaddReoptnodeBndchg(scip, comprdata->representatives[r], vars[0][v],
306 vals[0][v], SCIPisFeasEQ(scip, vals[0][v], 1.0) ? SCIP_BOUNDTYPE_LOWER : SCIP_BOUNDTYPE_UPPER) );
307 }
308 }
309
310 /* create a representative at position 0 with an added constraint corresponding
311 * to the branching path of the node
312 */
313 assert(comprdata->representatives[pos_repr_fix-1] != NULL);
314 SCIP_CALL( SCIPaddReoptnodeCons(scip, comprdata->representatives[pos_repr_fix-1], vars[0], vals[0], boundtypes[k],
315 1.0, SCIPinfinity(scip), nvars[0], REOPT_CONSTYPE_DUALREDS, linear) );
316 }
317
318 assert(0 <= pos_repr_fix && pos_repr_fix < comprdata->nrepresentatives);
319
320 /* create nconss[0] nodes for the added constraints */
321 for( k = 0; k < nconss[0]; k++ )
322 {
323 SCIP_Bool linear;
324 int v;
325
326 assert(pos_repr_fix < comprdata->nrepresentatives);
327
328 linear = TRUE; /* todo: we have to adapt the compression to handle integer variables */
329
330 /* create a node with fixed bounds corresponding to constraint at position k */
331
332 /* fix the branching path */
333 for( v = 0; v < conss_nvars[0][k]; v++ )
334 {
335 SCIP_CALL( SCIPaddReoptnodeBndchg(scip, comprdata->representatives[pos_repr_fix], conss_var[0][k][v],
336 conss_val[0][k][v], SCIPisFeasEQ(scip, conss_val[0][k][v], 1.0) ? SCIP_BOUNDTYPE_LOWER : SCIP_BOUNDTYPE_UPPER) );
337 }
338
339 /* add this constraint to all further representatives */
340 for( r = pos_repr_fix + 1; r < comprdata->nrepresentatives; r++ )
341 {
342 SCIP_CALL( SCIPaddReoptnodeCons(scip, comprdata->representatives[r], conss_var[0][k], conss_val[0][k],
343 conss_boundtypes[0][k], 1.0, SCIPinfinity(scip), conss_nvars[0][k], REOPT_CONSTYPE_DUALREDS, linear) );
344 }
345
346 pos_repr_fix++;
347 }
348
349 /* @todo use more than one node */
350
352
353 SCIPdebugMsg(scip, "-> found representation of size %d.\n", comprdata->nrepresentatives);
354
355 /* free memory */
356 for( k = size-1; k >= 0; k-- )
357 {
358 SCIPfreeBufferArray(scip, &conss_nvars[k]);
359 SCIPfreeBufferArray(scip, &conss_val[k]);
360 SCIPfreeBufferArray(scip, &conss_var[k]);
361 SCIPfreeBlockMemoryArray(scip, &boundtypes[k], mem_vars);
362 SCIPfreeBlockMemoryArray(scip, &vals[k], mem_vars);
363 SCIPfreeBlockMemoryArray(scip, &vars[k], mem_vars);
364 }
365
366 SCIPfreeBufferArray(scip, &nconss);
368 SCIPfreeBufferArray(scip, &conss_nvars);
369 SCIPfreeBufferArray(scip, &conss_val);
370 SCIPfreeBufferArray(scip, &conss_var);
371 SCIPfreeBlockMemoryArray(scip, &boundtypes, size);
372 SCIPfreeBlockMemoryArray(scip, &vals, size);
374
375 SCIPfreeBlockMemoryArray(scip, &leaveids, nleaveids);
376
377 return SCIP_OKAY;
378}
379
380/** apply the stored representation to the reopttree */
381static
383 SCIP* scip, /**< SCIP data structure */
384 SCIP_COMPR* compr, /**< compression method */
385 SCIP_COMPRDATA* comprdata, /**< compression data */
386 SCIP_RESULT* result /**< result pointer */
387 )
388{
389 SCIP_Bool success;
390 int r;
391
392 assert(scip != NULL);
393 assert(compr != NULL);
394 assert(comprdata != NULL);
395
397
398 if( comprdata->nrepresentatives == 0 )
399 return SCIP_OKAY;
400
401 /* set references to the root node */
402 for( r = 0; r < comprdata->nrepresentatives; r++ )
403 SCIPreoptnodeSetParentID(comprdata->representatives[r], 0);
404
405 success = FALSE;
406 SCIP_CALL( SCIPsetReoptCompression(scip, comprdata->representatives, comprdata->nrepresentatives, &success) );
407
408 if( success )
410
411 return SCIP_OKAY;
412}
413
414/*
415 * Callback methods of tree compression
416 */
417
418/** copy method for tree compression plugins (called when SCIP copies plugins) */
419static
420SCIP_DECL_COMPRCOPY(comprCopyWeakcompr)
421{ /*lint --e{715}*/
422 assert(scip != NULL);
423 assert(compr != NULL);
424 assert(strcmp(SCIPcomprGetName(compr), COMPR_NAME) == 0);
425
426 /* call inclusion method of primal heuristic */
428
429 return SCIP_OKAY;
430}
431
432/** destructor of tree compression to free user data (called when SCIP is exiting) */
433static
434SCIP_DECL_COMPRFREE(comprFreeWeakcompr)
435{
436 SCIP_COMPRDATA* comprdata;
437
438 assert(scip != NULL);
439 assert(compr != NULL);
440
441 comprdata = SCIPcomprGetData(compr);
442 assert(comprdata != NULL);
443
444 SCIPfreeBlockMemory(scip, &comprdata);
445 SCIPcomprSetData(compr, NULL);
446
447 return SCIP_OKAY;
448}
449
450/** deinitialization method of tree compression (called before transformed problem is freed) */
451static
452SCIP_DECL_COMPREXIT(comprExitWeakcompr)
453{
454 SCIP_COMPRDATA* comprdata;
455
456 assert(scip != NULL);
457 assert(compr != NULL);
458
459 comprdata = SCIPcomprGetData(compr);
460 assert(comprdata != NULL);
461
462 if( comprdata->initialized )
463 {
464 int r;
465
466 for( r = 0; r < comprdata->nrepresentatives; r++ )
467 {
468 SCIP_CALL( SCIPdeleteReoptnode(scip, &comprdata->representatives[r]) );
469 }
470
471 if( comprdata->representativessize > 0 )
472 {
473 SCIPfreeBlockMemoryArray(scip, &comprdata->representatives, comprdata->representativessize);
474 }
475
476 comprdata->representatives = NULL;
477 comprdata->representativessize = 0;
478 comprdata->nrepresentatives = 0;
479 comprdata->initialized = FALSE;
480 }
481
482 return SCIP_OKAY;
483}
484
485/** execution method of tree compression */
486static
487SCIP_DECL_COMPREXEC(comprExecWeakcompr)
488{
489 SCIP_COMPRDATA* comprdata;
490
492
493 comprdata = SCIPcomprGetData(compr);
494 assert(comprdata != NULL);
495
496 if( !comprdata->initialized )
497 {
498 SCIPdebugMsg(scip, ">> initializing <%s>\n", COMPR_NAME);
499
500 comprdata->representativessize = DEFAULT_MEM_REPR;
501 comprdata->nrepresentatives = 0;
502 SCIP_CALL( SCIPallocClearMemoryArray(scip, &comprdata->representatives, comprdata->representativessize) );
503 comprdata->initialized = TRUE;
504 }
505
506 /* try to find a representation */
507 SCIP_CALL( constructCompression(scip, compr, comprdata, result) );
508
510
511 /* apply the representation, if some was found */
512 if( *result == SCIP_SUCCESS )
513 {
514 SCIP_CALL( applyCompression(scip, compr, comprdata, result) );
516
517 SCIPdebugMsg(scip, "->%s apply compression.\n", *result == SCIP_DIDNOTRUN ? " did not" : "");
518 }
519
520 return SCIP_OKAY;
521}
522
523
524/*
525 * tree compression specific interface methods
526 */
527
528/** creates the weakcompr tree compression and includes it in SCIP */
530 SCIP* scip /**< SCIP data structure */
531 )
532{
533 SCIP_COMPRDATA* comprdata;
534 SCIP_COMPR* compr;
535
536 /* create weakcompr tree compression data */
537 SCIP_CALL( SCIPallocBlockMemory(scip, &comprdata) );
538 assert(comprdata != NULL);
539 comprdata->initialized = FALSE;
540
541 /* include tree compression */
543 comprExecWeakcompr, comprdata) );
544
545 assert(compr != NULL);
546
547 /* set non fundamental callbacks via setter functions */
548 SCIP_CALL( SCIPsetComprCopy(scip, compr, comprCopyWeakcompr) );
549 SCIP_CALL( SCIPsetComprExit(scip, compr, comprExitWeakcompr) );
550 SCIP_CALL( SCIPsetComprFree(scip, compr, comprFreeWeakcompr) );
551
552 /* add weakcompr tree compression parameters */
553 SCIP_CALL( SCIPaddBoolParam(scip, "compression/" COMPR_NAME "/convertconss", "convert constraints into nodes", &comprdata->convertconss, FALSE, FALSE, NULL, NULL) );
554
555 return SCIP_OKAY;
556}
#define COMPR_PRIORITY
#define COMPR_DESC
#define COMPR_MINNNODES
#define COMPR_NAME
static SCIP_RETCODE constructCompression(SCIP *scip, SCIP_COMPR *compr, SCIP_COMPRDATA *comprdata, SCIP_RESULT *result)
#define DEFAULT_MEM_REPR
static SCIP_RETCODE sortIDs(SCIP *scip, unsigned int *childids, int nchildids)
SCIP_RETCODE SCIPincludeComprWeakcompr(SCIP *scip)
static SCIP_RETCODE applyCompression(SCIP *scip, SCIP_COMPR *compr, SCIP_COMPRDATA *comprdata, SCIP_RESULT *result)
static SCIP_RETCODE checkMemSize(SCIP *scip, SCIP_COMPRDATA *comprdata, int nrepresentatives)
weakcompr tree compression
#define NULL
Definition def.h:266
#define SCIP_Bool
Definition def.h:91
#define SCIP_Real
Definition def.h:172
#define TRUE
Definition def.h:93
#define FALSE
Definition def.h:94
#define SCIP_LONGINT_FORMAT
Definition def.h:164
#define SCIP_CALL(x)
Definition def.h:373
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
Definition scip_prob.c:2082
int SCIPgetNVars(SCIP *scip)
Definition scip_prob.c:1992
int SCIPgetNBinVars(SCIP *scip)
Definition scip_prob.c:2037
#define SCIPdebugMsg
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:57
void SCIPcomprSetData(SCIP_COMPR *compr, SCIP_COMPRDATA *comprdata)
Definition compr.c:363
SCIP_RETCODE SCIPincludeComprBasic(SCIP *scip, SCIP_COMPR **compr, const char *name, const char *desc, int priority, int minnnodes, SCIP_DECL_COMPREXEC((*comprexec)), SCIP_COMPRDATA *comprdata)
Definition scip_compr.c:111
SCIP_COMPRDATA * SCIPcomprGetData(SCIP_COMPR *compr)
Definition compr.c:353
SCIP_RETCODE SCIPsetComprCopy(SCIP *scip, SCIP_COMPR *compr,)
Definition scip_compr.c:149
SCIP_RETCODE SCIPsetComprFree(SCIP *scip, SCIP_COMPR *compr,)
Definition scip_compr.c:165
SCIP_RETCODE SCIPsetComprExit(SCIP *scip, SCIP_COMPR *compr,)
Definition scip_compr.c:197
SCIP_Bool SCIPcomprIsInitialized(SCIP_COMPR *compr)
Definition compr.c:530
const char * SCIPcomprGetName(SCIP_COMPR *compr)
Definition compr.c:456
int SCIPcomprGetMinNodes(SCIP_COMPR *compr)
Definition compr.c:500
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
Definition scip_mem.h:110
#define SCIPallocBufferArray(scip, ptr, num)
Definition scip_mem.h:124
#define SCIPallocClearMemoryArray(scip, ptr, num)
Definition scip_mem.h:66
#define SCIPfreeBufferArray(scip, ptr)
Definition scip_mem.h:136
#define SCIPallocBlockMemoryArray(scip, ptr, num)
Definition scip_mem.h:93
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
Definition scip_mem.h:99
#define SCIPfreeBlockMemory(scip, ptr)
Definition scip_mem.h:108
#define SCIPallocBlockMemory(scip, ptr)
Definition scip_mem.h:89
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
Definition tree.c:7511
int SCIPnodeGetDepth(SCIP_NODE *node)
Definition tree.c:7521
int SCIPgetNReoptLeaves(SCIP *scip, SCIP_NODE *node)
Definition scip_reopt.c:141
SCIP_RETCODE SCIPaddReoptnodeBndchg(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR *var, SCIP_Real bound, SCIP_BOUNDTYPE boundtype)
Definition scip_reopt.c:176
SCIP_REOPTNODE * SCIPgetReoptnode(SCIP *scip, unsigned int id)
Definition scip_reopt.c:154
SCIP_RETCODE SCIPinitRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition scip_reopt.c:289
SCIP_RETCODE SCIPdeleteReoptnode(SCIP *scip, SCIP_REOPTNODE **reoptnode)
Definition scip_reopt.c:464
SCIP_RETCODE SCIPsetReoptCompression(SCIP *scip, SCIP_REOPTNODE **representation, int nrepresentatives, SCIP_Bool *success)
Definition scip_reopt.c:204
SCIP_RETCODE SCIPgetReoptLeaveIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int idssize, int *nids)
Definition scip_reopt.c:101
void SCIPgetReoptnodePath(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int mem, int *nvars, int *nafterdualvars)
Definition scip_reopt.c:260
SCIP_RETCODE SCIPaddReoptnodeCons(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, SCIP_Real lhs, SCIP_Real rhs, int nvars, REOPT_CONSTYPE constype, SCIP_Bool linear)
Definition scip_reopt.c:232
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition scip_tree.c:91
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
return SCIP_OKAY
int c
int r
assert(minobj< SCIPgetCutoffbound(scip))
int nvars
static SCIP_VAR ** vars
memory allocation routines
public methods for tree compressions
public methods for message output
#define SCIPdebug(x)
Definition pub_message.h:93
methods for sorting joint arrays of various types
public methods for reoptimization
SCIP_Real SCIPreoptnodeGetLowerbound(SCIP_REOPTNODE *reoptnode)
Definition reopt.c:5864
void SCIPreoptnodeSetParentID(SCIP_REOPTNODE *reoptnode, unsigned int parentid)
Definition reopt.c:5919
int SCIPreoptnodeGetNConss(SCIP_REOPTNODE *reoptnode)
Definition reopt.c:5831
void SCIPreoptnodeGetConss(SCIP_REOPTNODE *reoptnode, SCIP_VAR ***vars, SCIP_Real **bounds, SCIP_BOUNDTYPE **boundtypes, int mem, int *nconss, int *nvars)
Definition reopt.c:5884
int SCIPreoptnodeGetNVars(SCIP_REOPTNODE *reoptnode)
Definition reopt.c:5821
public methods for branch and bound tree
public methods for compression plugins
general public methods
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for reoptimization
public methods for the branch-and-bound tree
struct SCIP_Compr SCIP_COMPR
Definition type_compr.h:48
struct SCIP_ComprData SCIP_COMPRDATA
Definition type_compr.h:49
#define SCIP_DECL_COMPRFREE(x)
Definition type_compr.h:66
#define SCIP_DECL_COMPREXEC(x)
Definition type_compr.h:120
#define SCIP_DECL_COMPREXIT(x)
Definition type_compr.h:82
#define SCIP_DECL_COMPRCOPY(x)
Definition type_compr.h:58
@ SCIP_BOUNDTYPE_UPPER
Definition type_lp.h:57
@ SCIP_BOUNDTYPE_LOWER
Definition type_lp.h:56
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition type_lp.h:59
@ REOPT_CONSTYPE_DUALREDS
Definition type_reopt.h:72
struct SCIP_ReoptNode SCIP_REOPTNODE
Definition type_reopt.h:47
@ SCIP_DIDNOTRUN
Definition type_result.h:42
@ SCIP_DIDNOTFIND
Definition type_result.h:44
@ SCIP_SUCCESS
Definition type_result.h:58
enum SCIP_Result SCIP_RESULT
Definition type_result.h:61
enum SCIP_Retcode SCIP_RETCODE
struct Scip SCIP
Definition type_scip.h:39
@ SCIP_STAGE_PRESOLVED
Definition type_set.h:51
struct SCIP_Node SCIP_NODE
Definition type_tree.h:63
struct SCIP_Var SCIP_VAR
Definition type_var.h:119