Scippy

SCIP

Solving Constraint Integer Programs

lp.h
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-2019 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 scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file lp.h
17  * @ingroup INTERNALAPI
18  * @brief internal methods for LP management
19  * @author Tobias Achterberg
20  * @author Marc Pfetsch
21  * @author Kati Wolter
22  * @author Gerald Gamrath
23  */
24 
25 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
26 
27 #ifndef __SCIP_LP_H__
28 #define __SCIP_LP_H__
29 
30 
31 #include <stdio.h>
32 
33 #include "scip/def.h"
34 #include "blockmemshell/memory.h"
35 #include "scip/type_set.h"
36 #include "scip/type_stat.h"
37 #include "scip/type_misc.h"
38 #include "scip/type_lp.h"
39 #include "scip/type_var.h"
40 #include "scip/type_prob.h"
41 #include "scip/type_sol.h"
42 #include "scip/pub_lp.h"
43 
44 #include "scip/struct_lp.h"
45 
46 #ifdef __cplusplus
47 extern "C" {
48 #endif
49 
50 /*
51  * Column methods
52  */
53 
54 /** creates an LP column */
55 SCIP_RETCODE SCIPcolCreate(
56  SCIP_COL** col, /**< pointer to column data */
57  BMS_BLKMEM* blkmem, /**< block memory */
58  SCIP_SET* set, /**< global SCIP settings */
59  SCIP_STAT* stat, /**< problem statistics */
60  SCIP_VAR* var, /**< variable, this column represents */
61  int len, /**< number of nonzeros in the column */
62  SCIP_ROW** rows, /**< array with rows of column entries */
63  SCIP_Real* vals, /**< array with coefficients of column entries */
64  SCIP_Bool removable /**< should the column be removed from the LP due to aging or cleanup? */
65  );
66 
67 /** frees an LP column */
68 SCIP_RETCODE SCIPcolFree(
69  SCIP_COL** col, /**< pointer to LP column */
70  BMS_BLKMEM* blkmem, /**< block memory */
71  SCIP_SET* set, /**< global SCIP settings */
72  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
73  SCIP_LP* lp /**< current LP data */
74  );
75 
76 /** output column to file stream */
77 void SCIPcolPrint(
78  SCIP_COL* col, /**< LP column */
79  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
80  FILE* file /**< output file (or NULL for standard output) */
81  );
82 
83 /** adds a previously non existing coefficient to an LP column */
84 SCIP_RETCODE SCIPcolAddCoef(
85  SCIP_COL* col, /**< LP column */
86  BMS_BLKMEM* blkmem, /**< block memory */
87  SCIP_SET* set, /**< global SCIP settings */
88  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
89  SCIP_LP* lp, /**< current LP data */
90  SCIP_ROW* row, /**< LP row */
91  SCIP_Real val /**< value of coefficient */
92  );
93 
94 /** deletes coefficient from column */
95 SCIP_RETCODE SCIPcolDelCoef(
96  SCIP_COL* col, /**< column to be changed */
97  BMS_BLKMEM* blkmem, /**< block memory */
98  SCIP_SET* set, /**< global SCIP settings */
99  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
100  SCIP_LP* lp, /**< current LP data */
101  SCIP_ROW* row /**< coefficient to be deleted */
102  );
103 
104 /** changes or adds a coefficient to an LP column */
105 SCIP_RETCODE SCIPcolChgCoef(
106  SCIP_COL* col, /**< LP column */
107  BMS_BLKMEM* blkmem, /**< block memory */
108  SCIP_SET* set, /**< global SCIP settings */
109  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
110  SCIP_LP* lp, /**< current LP data */
111  SCIP_ROW* row, /**< LP row */
112  SCIP_Real val /**< value of coefficient */
113  );
114 
115 /** increases value of an existing or nonexisting coefficient in an LP column */
116 SCIP_RETCODE SCIPcolIncCoef(
117  SCIP_COL* col, /**< LP column */
118  BMS_BLKMEM* blkmem, /**< block memory */
119  SCIP_SET* set, /**< global SCIP settings */
120  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
121  SCIP_LP* lp, /**< current LP data */
122  SCIP_ROW* row, /**< LP row */
123  SCIP_Real incval /**< value to add to the coefficient */
124  );
125 
126 /** changes objective value of column */
127 SCIP_RETCODE SCIPcolChgObj(
128  SCIP_COL* col, /**< LP column to change */
129  SCIP_SET* set, /**< global SCIP settings */
130  SCIP_LP* lp, /**< current LP data */
131  SCIP_Real newobj /**< new objective value */
132  );
133 
134 /** changes lower bound of column */
135 SCIP_RETCODE SCIPcolChgLb(
136  SCIP_COL* col, /**< LP column to change */
137  SCIP_SET* set, /**< global SCIP settings */
138  SCIP_LP* lp, /**< current LP data */
139  SCIP_Real newlb /**< new lower bound value */
140  );
141 
142 /** changes upper bound of column */
143 SCIP_RETCODE SCIPcolChgUb(
144  SCIP_COL* col, /**< LP column to change */
145  SCIP_SET* set, /**< global SCIP settings */
146  SCIP_LP* lp, /**< current LP data */
147  SCIP_Real newub /**< new upper bound value */
148  );
149 
150 /** calculates the reduced costs of a column using the given dual solution vector */
151 SCIP_Real SCIPcolCalcRedcost(
152  SCIP_COL* col, /**< LP column */
153  SCIP_Real* dualsol /**< dual solution vector for current LP rows */
154  );
155 
156 /** gets the reduced costs of a column in last LP or after recalculation */
157 SCIP_Real SCIPcolGetRedcost(
158  SCIP_COL* col, /**< LP column */
159  SCIP_STAT* stat, /**< problem statistics */
160  SCIP_LP* lp /**< current LP data */
161  );
162 
163 /** gets the feasibility of (the dual row of) a column in last LP or after recalculation */
164 SCIP_Real SCIPcolGetFeasibility(
165  SCIP_COL* col, /**< LP column */
166  SCIP_SET* set, /**< global SCIP settings */
167  SCIP_STAT* stat, /**< problem statistics */
168  SCIP_LP* lp /**< current LP data */
169  );
170 
171 /** calculates the Farkas coefficient y^T A_i of a column i using the given dual Farkas vector y */
172 SCIP_Real SCIPcolCalcFarkasCoef(
173  SCIP_COL* col, /**< LP column */
174  SCIP_Real* dualfarkas /**< dense dual Farkas vector for current LP rows */
175  );
176 
177 /** gets the Farkas coefficient y^T A_i of a column i in last LP (which must be infeasible) */
178 SCIP_Real SCIPcolGetFarkasCoef(
179  SCIP_COL* col, /**< LP column */
180  SCIP_STAT* stat, /**< problem statistics */
181  SCIP_LP* lp /**< current LP data */
182  );
183 
184 /** gets the Farkas value of a column in last LP (which must be infeasible), i.e. the Farkas coefficient y^T A_i times
185  * the best bound for this coefficient, i.e. max{y^T A_i x_i | lb <= x_i <= ub}
186  */
187 SCIP_Real SCIPcolGetFarkasValue(
188  SCIP_COL* col, /**< LP column */
189  SCIP_STAT* stat, /**< problem statistics */
190  SCIP_LP* lp /**< current LP data */
191  );
192 
193 /** start strong branching - call before any strong branching */
194 SCIP_RETCODE SCIPlpStartStrongbranch(
195  SCIP_LP* lp /**< LP data */
196  );
197 
198 /** end strong branching - call after any strong branching */
199 SCIP_RETCODE SCIPlpEndStrongbranch(
200  SCIP_LP* lp /**< LP data */
201  );
202 
203 /** sets strong branching information for a column variable */
204 void SCIPcolSetStrongbranchData(
205  SCIP_COL* col, /**< LP column */
206  SCIP_SET* set, /**< global SCIP settings */
207  SCIP_STAT* stat, /**< dynamic problem statistics */
208  SCIP_LP* lp, /**< LP data */
209  SCIP_Real lpobjval, /**< objective value of the current LP */
210  SCIP_Real primsol, /**< primal solution value of the column in the current LP */
211  SCIP_Real sbdown, /**< dual bound after branching column down */
212  SCIP_Real sbup, /**< dual bound after branching column up */
213  SCIP_Bool sbdownvalid, /**< is the returned down value a valid dual bound? */
214  SCIP_Bool sbupvalid, /**< is the returned up value a valid dual bound? */
215  SCIP_Longint iter, /**< total number of strong branching iterations */
216  int itlim /**< iteration limit applied to the strong branching call */
217  );
218 
219 /** invalidates strong branching information for a column variable */
220 void SCIPcolInvalidateStrongbranchData(
221  SCIP_COL* col, /**< LP column */
222  SCIP_SET* set, /**< global SCIP settings */
223  SCIP_STAT* stat, /**< dynamic problem statistics */
224  SCIP_LP* lp /**< LP data */
225  );
226 
227 /** gets strong branching information on a column variable */
228 SCIP_RETCODE SCIPcolGetStrongbranch(
229  SCIP_COL* col, /**< LP column */
230  SCIP_Bool integral, /**< should integral strong branching be performed? */
231  SCIP_SET* set, /**< global SCIP settings */
232  SCIP_STAT* stat, /**< dynamic problem statistics */
233  SCIP_PROB* prob, /**< problem data */
234  SCIP_LP* lp, /**< LP data */
235  int itlim, /**< iteration limit for strong branchings */
236  SCIP_Real* down, /**< stores dual bound after branching column down */
237  SCIP_Real* up, /**< stores dual bound after branching column up */
238  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
239  * otherwise, it can only be used as an estimate value */
240  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
241  * otherwise, it can only be used as an estimate value */
242  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */
243  );
244 
245 /** gets strong branching information on column variables */
246 SCIP_RETCODE SCIPcolGetStrongbranches(
247  SCIP_COL** cols, /**< LP columns */
248  int ncols, /**< number of columns */
249  SCIP_Bool integral, /**< should integral strong branching be performed? */
250  SCIP_SET* set, /**< global SCIP settings */
251  SCIP_STAT* stat, /**< dynamic problem statistics */
252  SCIP_PROB* prob, /**< problem data */
253  SCIP_LP* lp, /**< LP data */
254  int itlim, /**< iteration limit for strong branchings */
255  SCIP_Real* down, /**< stores dual bounds after branching columns down */
256  SCIP_Real* up, /**< stores dual bounds after branching columns up */
257  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
258  * otherwise, they can only be used as an estimate value */
259  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
260  * otherwise, they can only be used as an estimate value */
261  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */
262  );
263 
264 /** gets last strong branching information available for a column variable;
265  * returns values of SCIP_INVALID, if strong branching was not yet called on the given column;
266  * keep in mind, that the returned old values may have nothing to do with the current LP solution
267  */
268 void SCIPcolGetStrongbranchLast(
269  SCIP_COL* col, /**< LP column */
270  SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
271  SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
272  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
273  * otherwise, it can only be used as an estimate value */
274  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
275  * otherwise, it can only be used as an estimate value */
276  SCIP_Real* solval, /**< stores LP solution value of column at last strong branching call, or NULL */
277  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
278  );
279 
280 /** if strong branching was already applied on the column at the current node, returns the number of LPs solved after
281  * the LP where the strong branching on this column was applied;
282  * if strong branching was not yet applied on the column at the current node, returns INT_MAX
283  */
284 SCIP_Longint SCIPcolGetStrongbranchLPAge(
285  SCIP_COL* col, /**< LP column */
286  SCIP_STAT* stat /**< dynamic problem statistics */
287  );
288 
289 /** marks a column to be not removable from the LP in the current node because it became obsolete */
290 void SCIPcolMarkNotRemovableLocal(
291  SCIP_COL* col, /**< LP column */
292  SCIP_STAT* stat /**< problem statistics */
293  );
294 
295 
296 /*
297  * Row methods
298  */
299 
300 /** creates and captures an LP row */
301 SCIP_RETCODE SCIProwCreate(
302  SCIP_ROW** row, /**< pointer to LP row data */
303  BMS_BLKMEM* blkmem, /**< block memory */
304  SCIP_SET* set, /**< global SCIP settings */
305  SCIP_STAT* stat, /**< problem statistics */
306  SCIP_LP* lp, /**< current LP data */
307  const char* name, /**< name of row */
308  int len, /**< number of nonzeros in the row */
309  SCIP_COL** cols, /**< array with columns of row entries */
310  SCIP_Real* vals, /**< array with coefficients of row entries */
311  SCIP_Real lhs, /**< left hand side of row */
312  SCIP_Real rhs, /**< right hand side of row */
313  SCIP_ROWORIGINTYPE origintype, /**< type of origin of row */
314  void* origin, /**< pointer to constraint handler or separator who created the row (NULL if unkown) */
315  SCIP_Bool local, /**< is row only valid locally? */
316  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
317  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
318  );
319 
320 /** frees an LP row */
321 SCIP_RETCODE SCIProwFree(
322  SCIP_ROW** row, /**< pointer to LP row */
323  BMS_BLKMEM* blkmem, /**< block memory */
324  SCIP_SET* set, /**< global SCIP settings */
325  SCIP_LP* lp /**< current LP data */
326  );
327 
328 /** output row to file stream */
329 void SCIProwPrint(
330  SCIP_ROW* row, /**< LP row */
331  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
332  FILE* file /**< output file (or NULL for standard output) */
333  );
334 
335 /** ensures, that column array of row can store at least num entries */
336 SCIP_RETCODE SCIProwEnsureSize(
337  SCIP_ROW* row, /**< LP row */
338  BMS_BLKMEM* blkmem, /**< block memory */
339  SCIP_SET* set, /**< global SCIP settings */
340  int num /**< minimum number of entries to store */
341  );
342 
343 /** increases usage counter of LP row */
344 void SCIProwCapture(
345  SCIP_ROW* row /**< LP row */
346  );
347 
348 /** decreases usage counter of LP row, and frees memory if necessary */
349 SCIP_RETCODE SCIProwRelease(
350  SCIP_ROW** row, /**< pointer to LP row */
351  BMS_BLKMEM* blkmem, /**< block memory */
352  SCIP_SET* set, /**< global SCIP settings */
353  SCIP_LP* lp /**< current LP data */
354  );
355 
356 /** enables delaying of row sorting */
357 void SCIProwDelaySort(
358  SCIP_ROW* row /**< LP row */
359  );
360 
361 /** disables delaying of row sorting, sorts row and merges coefficients with equal columns */
362 void SCIProwForceSort(
363  SCIP_ROW* row, /**< LP row */
364  SCIP_SET* set /**< global SCIP settings */
365  );
366 
367 /** adds a previously non existing coefficient to an LP row */
368 SCIP_RETCODE SCIProwAddCoef(
369  SCIP_ROW* row, /**< LP row */
370  BMS_BLKMEM* blkmem, /**< block memory */
371  SCIP_SET* set, /**< global SCIP settings */
372  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
373  SCIP_LP* lp, /**< current LP data */
374  SCIP_COL* col, /**< LP column */
375  SCIP_Real val /**< value of coefficient */
376  );
377 
378 /** deletes coefficient from row */
379 SCIP_RETCODE SCIProwDelCoef(
380  SCIP_ROW* row, /**< LP row */
381  BMS_BLKMEM* blkmem, /**< block memory */
382  SCIP_SET* set, /**< global SCIP settings */
383  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
384  SCIP_LP* lp, /**< current LP data */
385  SCIP_COL* col /**< coefficient to be deleted */
386  );
387 
388 /** changes or adds a coefficient to an LP row */
389 SCIP_RETCODE SCIProwChgCoef(
390  SCIP_ROW* row, /**< LP row */
391  BMS_BLKMEM* blkmem, /**< block memory */
392  SCIP_SET* set, /**< global SCIP settings */
393  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
394  SCIP_LP* lp, /**< current LP data */
395  SCIP_COL* col, /**< LP column */
396  SCIP_Real val /**< value of coefficient */
397  );
398 
399 /** increases value of an existing or nonexisting coefficient in an LP column */
400 SCIP_RETCODE SCIProwIncCoef(
401  SCIP_ROW* row, /**< LP row */
402  BMS_BLKMEM* blkmem, /**< block memory */
403  SCIP_SET* set, /**< global SCIP settings */
404  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
405  SCIP_LP* lp, /**< current LP data */
406  SCIP_COL* col, /**< LP column */
407  SCIP_Real incval /**< value to add to the coefficient */
408  );
409 
410 /** changes constant value of a row */
411 SCIP_RETCODE SCIProwChgConstant(
412  SCIP_ROW* row, /**< LP row */
413  BMS_BLKMEM* blkmem, /**< block memory */
414  SCIP_SET* set, /**< global SCIP settings */
415  SCIP_STAT* stat, /**< problem statistics */
416  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
417  SCIP_LP* lp, /**< current LP data */
418  SCIP_Real constant /**< new constant value */
419  );
420 
421 /** add constant value to a row */
422 SCIP_RETCODE SCIProwAddConstant(
423  SCIP_ROW* row, /**< LP row */
424  BMS_BLKMEM* blkmem, /**< block memory */
425  SCIP_SET* set, /**< global SCIP settings */
426  SCIP_STAT* stat, /**< problem statistics */
427  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
428  SCIP_LP* lp, /**< current LP data */
429  SCIP_Real addval /**< constant value to add to the row */
430  );
431 
432 /** changes left hand side of LP row */
433 SCIP_RETCODE SCIProwChgLhs(
434  SCIP_ROW* row, /**< LP row */
435  BMS_BLKMEM* blkmem, /**< block memory */
436  SCIP_SET* set, /**< global SCIP settings */
437  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
438  SCIP_LP* lp, /**< current LP data */
439  SCIP_Real lhs /**< new left hand side */
440  );
441 
442 /** changes right hand side of LP row */
443 SCIP_RETCODE SCIProwChgRhs(
444  SCIP_ROW* row, /**< LP row */
445  BMS_BLKMEM* blkmem, /**< block memory */
446  SCIP_SET* set, /**< global SCIP settings */
447  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
448  SCIP_LP* lp, /**< current LP data */
449  SCIP_Real rhs /**< new right hand side */
450  );
451 
452 /** changes the local flag of LP row */
453 SCIP_RETCODE SCIProwChgLocal(
454  SCIP_ROW* row, /**< LP row */
455  SCIP_Bool local /**< new value for local flag */
456  );
457 
458 /** tries to find a value, such that all row coefficients, if scaled with this value become integral */
459 SCIP_RETCODE SCIProwCalcIntegralScalar(
460  SCIP_ROW* row, /**< LP row */
461  SCIP_SET* set, /**< global SCIP settings */
462  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
463  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
464  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
465  SCIP_Real maxscale, /**< maximal allowed scalar */
466  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
467  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral */
468  SCIP_Bool* success /**< stores whether returned value is valid */
469  );
470 
471 /** tries to scale row, s.t. all coefficients become integral */
472 SCIP_RETCODE SCIProwMakeIntegral(
473  SCIP_ROW* row, /**< LP row */
474  BMS_BLKMEM* blkmem, /**< block memory */
475  SCIP_SET* set, /**< global SCIP settings */
476  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
477  SCIP_STAT* stat, /**< problem statistics */
478  SCIP_LP* lp, /**< current LP data */
479  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
480  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
481  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
482  SCIP_Real maxscale, /**< maximal value to scale row with */
483  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
484  SCIP_Bool* success /**< stores whether row could be made rational */
485  );
486 
487 /** recalculates the current activity of a row */
488 void SCIProwRecalcLPActivity(
489  SCIP_ROW* row, /**< LP row */
490  SCIP_STAT* stat /**< problem statistics */
491  );
492 
493 /** returns the activity of a row in the current LP solution */
494 SCIP_Real SCIProwGetLPActivity(
495  SCIP_ROW* row, /**< LP row */
496  SCIP_SET* set, /**< global SCIP settings */
497  SCIP_STAT* stat, /**< problem statistics */
498  SCIP_LP* lp /**< current LP data */
499  );
500 
501 /** returns the feasibility of a row in the current LP solution: negative value means infeasibility */
502 SCIP_Real SCIProwGetLPFeasibility(
503  SCIP_ROW* row, /**< LP row */
504  SCIP_SET* set, /**< global SCIP settings */
505  SCIP_STAT* stat, /**< problem statistics */
506  SCIP_LP* lp /**< current LP data */
507  );
508 
509 /** returns the feasibility of a row in the current relaxed solution: negative value means infeasibility */
510 SCIP_Real SCIProwGetRelaxFeasibility(
511  SCIP_ROW* row, /**< LP row */
512  SCIP_SET* set, /**< global SCIP settings */
513  SCIP_STAT* stat /**< problem statistics */
514  );
515 
516 /** returns the feasibility of a row in the current NLP solution: negative value means infeasibility */
517 SCIP_Real SCIProwGetNLPFeasibility(
518  SCIP_ROW* row, /**< LP row */
519  SCIP_SET* set, /**< global SCIP settings */
520  SCIP_STAT* stat /**< problem statistics */
521  );
522 
523 /** calculates the current pseudo activity of a row */
524 void SCIProwRecalcPseudoActivity(
525  SCIP_ROW* row, /**< row data */
526  SCIP_STAT* stat /**< problem statistics */
527  );
528 
529 /** returns the pseudo activity of a row in the current pseudo solution */
530 SCIP_Real SCIProwGetPseudoActivity(
531  SCIP_ROW* row, /**< LP row */
532  SCIP_SET* set, /**< global SCIP settings */
533  SCIP_STAT* stat /**< problem statistics */
534  );
535 
536 /** returns the pseudo feasibility of a row in the current pseudo solution: negative value means infeasibility */
537 SCIP_Real SCIProwGetPseudoFeasibility(
538  SCIP_ROW* row, /**< LP row */
539  SCIP_SET* set, /**< global SCIP settings */
540  SCIP_STAT* stat /**< problem statistics */
541  );
542 
543 /** returns the activity of a row for a given solution */
544 SCIP_Real SCIProwGetSolActivity(
545  SCIP_ROW* row, /**< LP row */
546  SCIP_SET* set, /**< global SCIP settings */
547  SCIP_STAT* stat, /**< problem statistics data */
548  SCIP_SOL* sol /**< primal CIP solution */
549  );
550 
551 /** returns the feasibility of a row for the given solution */
552 SCIP_Real SCIProwGetSolFeasibility(
553  SCIP_ROW* row, /**< LP row */
554  SCIP_SET* set, /**< global SCIP settings */
555  SCIP_STAT* stat, /**< problem statistics data */
556  SCIP_SOL* sol /**< primal CIP solution */
557  );
558 
559 /** returns the minimal activity of a row w.r.t. the columns' bounds */
560 SCIP_Real SCIProwGetMinActivity(
561  SCIP_ROW* row, /**< LP row */
562  SCIP_SET* set, /**< global SCIP settings */
563  SCIP_STAT* stat /**< problem statistics data */
564  );
565 
566 /** returns the maximal activity of a row w.r.t. the columns' bounds */
567 SCIP_Real SCIProwGetMaxActivity(
568  SCIP_ROW* row, /**< LP row */
569  SCIP_SET* set, /**< global SCIP settings */
570  SCIP_STAT* stat /**< problem statistics data */
571  );
572 
573 /** returns whether the row is unmodifiable and redundant w.r.t. the columns' bounds */
574 SCIP_Bool SCIProwIsRedundant(
575  SCIP_ROW* row, /**< LP row */
576  SCIP_SET* set, /**< global SCIP settings */
577  SCIP_STAT* stat /**< problem statistics data */
578  );
579 
580 /** gets maximal absolute value of row vector coefficients */
581 SCIP_Real SCIProwGetMaxval(
582  SCIP_ROW* row, /**< LP row */
583  SCIP_SET* set /**< global SCIP settings */
584  );
585 
586 /** gets minimal absolute value of row vector's non-zero coefficients */
587 SCIP_Real SCIProwGetMinval(
588  SCIP_ROW* row, /**< LP row */
589  SCIP_SET* set /**< global SCIP settings */
590  );
591 
592 /** gets maximal column index of row entries */
593 int SCIProwGetMaxidx(
594  SCIP_ROW* row, /**< LP row */
595  SCIP_SET* set /**< global SCIP settings */
596  );
597 
598 /** gets minimal column index of row entries */
599 int SCIProwGetMinidx(
600  SCIP_ROW* row, /**< LP row */
601  SCIP_SET* set /**< global SCIP settings */
602  );
603 
604 /** gets number of integral columns in row */
605 int SCIProwGetNumIntCols(
606  SCIP_ROW* row, /**< LP row */
607  SCIP_SET* set /**< global SCIP settings */
608  );
609 
610 /** returns row's cutoff distance in the direction of the given primal solution */
611 SCIP_Real SCIProwGetLPSolCutoffDistance(
612  SCIP_ROW* row, /**< LP row */
613  SCIP_SET* set, /**< global SCIP settings */
614  SCIP_STAT* stat, /**< problem statistics data */
615  SCIP_SOL* sol, /**< solution to compute direction for cutoff distance; must not be NULL */
616  SCIP_LP* lp /**< current LP data */
617  );
618 
619 /** returns row's efficacy with respect to the current LP solution: e = -feasibility/norm */
620 SCIP_Real SCIProwGetLPEfficacy(
621  SCIP_ROW* row, /**< LP row */
622  SCIP_SET* set, /**< global SCIP settings */
623  SCIP_STAT* stat, /**< problem statistics data */
624  SCIP_LP* lp /**< current LP data */
625  );
626 
627 /** returns whether the row's efficacy with respect to the current LP solution is greater than the minimal cut efficacy */
628 SCIP_Bool SCIProwIsLPEfficacious(
629  SCIP_ROW* row, /**< LP row */
630  SCIP_SET* set, /**< global SCIP settings */
631  SCIP_STAT* stat, /**< problem statistics data */
632  SCIP_LP* lp, /**< current LP data */
633  SCIP_Bool root /**< should the root's minimal cut efficacy be used? */
634  );
635 
636 /** returns row's efficacy with respect to the given primal solution: e = -feasibility/norm */
637 SCIP_Real SCIProwGetSolEfficacy(
638  SCIP_ROW* row, /**< LP row */
639  SCIP_SET* set, /**< global SCIP settings */
640  SCIP_STAT* stat, /**< problem statistics data */
641  SCIP_SOL* sol /**< primal CIP solution */
642  );
643 
644 /** returns whether the row's efficacy with respect to the given primal solution is greater than the minimal cut
645  * efficacy
646  */
647 SCIP_Bool SCIProwIsSolEfficacious(
648  SCIP_ROW* row, /**< LP row */
649  SCIP_SET* set, /**< global SCIP settings */
650  SCIP_STAT* stat, /**< problem statistics data */
651  SCIP_SOL* sol, /**< primal CIP solution */
652  SCIP_Bool root /**< should the root's minimal cut efficacy be used? */
653  );
654 
655 /** returns row's efficacy with respect to the relaxed solution: e = -feasibility/norm */
656 SCIP_Real SCIProwGetRelaxEfficacy(
657  SCIP_ROW* row, /**< LP row */
658  SCIP_SET* set, /**< global SCIP settings */
659  SCIP_STAT* stat /**< problem statistics data */
660  );
661 
662 /** returns row's efficacy with respect to the NLP solution: e = -feasibility/norm */
663 SCIP_Real SCIProwGetNLPEfficacy(
664  SCIP_ROW* row, /**< LP row */
665  SCIP_SET* set, /**< global SCIP settings */
666  SCIP_STAT* stat /**< problem statistics data */
667  );
668 
669 /** gets parallelism of row with objective function: if the returned value is 1, the row is parallel to the objective
670  * function, if the value is 0, it is orthogonal to the objective function
671  */
672 SCIP_Real SCIProwGetObjParallelism(
673  SCIP_ROW* row, /**< LP row */
674  SCIP_SET* set, /**< global SCIP settings */
675  SCIP_LP* lp /**< current LP data */
676  );
677 
678 /** includes event handler with given data in row's event filter */
679 SCIP_RETCODE SCIProwCatchEvent(
680  SCIP_ROW* row, /**< row */
681  BMS_BLKMEM* blkmem, /**< block memory */
682  SCIP_SET* set, /**< global SCIP settings */
683  SCIP_EVENTTYPE eventtype, /**< event type to catch */
684  SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */
685  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */
686  int* filterpos /**< pointer to store position of event filter entry, or NULL */
687  );
688 
689 /** deletes event handler with given data from row's event filter */
690 SCIP_RETCODE SCIProwDropEvent(
691  SCIP_ROW* row, /**< row */
692  BMS_BLKMEM* blkmem, /**< block memory */
693  SCIP_SET* set, /**< global SCIP settings */
694  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
695  SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */
696  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */
697  int filterpos /**< position of event filter entry returned by SCIPvarCatchEvent(), or -1 */
698  );
699 
700 /** marks a row to be not removable from the LP in the current node */
701 void SCIProwMarkNotRemovableLocal(
702  SCIP_ROW* row, /**< LP row */
703  SCIP_STAT* stat /**< problem statistics */
704  );
705 
706 
707 /*
708  * LP methods
709  */
710 
711 /** creates empty LP data object */
712 SCIP_RETCODE SCIPlpCreate(
713  SCIP_LP** lp, /**< pointer to LP data object */
714  SCIP_SET* set, /**< global SCIP settings */
715  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
716  SCIP_STAT* stat, /**< problem statistics */
717  const char* name /**< problem name */
718  );
719 
720 /** frees LP data object */
721 SCIP_RETCODE SCIPlpFree(
722  SCIP_LP** lp, /**< pointer to LP data object */
723  BMS_BLKMEM* blkmem, /**< block memory */
724  SCIP_SET* set, /**< global SCIP settings */
725  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
726  SCIP_EVENTFILTER* eventfilter /**< global event filter */
727  );
728 
729 /** resets the LP to the empty LP by removing all columns and rows from LP, releasing all rows, and flushing the
730  * changes to the LP solver
731  */
732 SCIP_RETCODE SCIPlpReset(
733  SCIP_LP* lp, /**< LP data */
734  BMS_BLKMEM* blkmem, /**< block memory */
735  SCIP_SET* set, /**< global SCIP settings */
736  SCIP_STAT* stat, /**< problem statistics */
737  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
738  SCIP_EVENTFILTER* eventfilter /**< global event filter */
739  );
740 
741 /** adds a column to the LP and captures the variable */
742 SCIP_RETCODE SCIPlpAddCol(
743  SCIP_LP* lp, /**< LP data */
744  SCIP_SET* set, /**< global SCIP settings */
745  SCIP_COL* col, /**< LP column */
746  int depth /**< depth in the tree where the column addition is performed */
747  );
748 
749 /** adds a row to the LP and captures it */
750 SCIP_RETCODE SCIPlpAddRow(
751  SCIP_LP* lp, /**< LP data */
752  BMS_BLKMEM* blkmem, /**< block memory buffers */
753  SCIP_SET* set, /**< global SCIP settings */
754  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
755  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
756  SCIP_ROW* row, /**< LP row */
757  int depth /**< depth in the tree where the row addition is performed */
758  );
759 
760 /** removes all columns after the given number of columns from the LP */
761 SCIP_RETCODE SCIPlpShrinkCols(
762  SCIP_LP* lp, /**< LP data */
763  SCIP_SET* set, /**< global SCIP settings */
764  int newncols /**< new number of columns in the LP */
765  );
766 
767 /** removes and releases all rows after the given number of rows from the LP */
768 SCIP_RETCODE SCIPlpShrinkRows(
769  SCIP_LP* lp, /**< LP data */
770  BMS_BLKMEM* blkmem, /**< block memory */
771  SCIP_SET* set, /**< global SCIP settings */
772  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
773  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
774  int newnrows /**< new number of rows in the LP */
775  );
776 
777 /** removes all columns and rows from LP, releases all rows */
778 SCIP_RETCODE SCIPlpClear(
779  SCIP_LP* lp, /**< LP data */
780  BMS_BLKMEM* blkmem, /**< block memory */
781  SCIP_SET* set, /**< global SCIP settings */
782  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
783  SCIP_EVENTFILTER* eventfilter /**< global event filter */
784  );
785 
786 /** remembers number of columns and rows to track the newly added ones */
787 void SCIPlpMarkSize(
788  SCIP_LP* lp /**< current LP data */
789  );
790 
791 /** sets the remembered number of columns and rows to the given values */
792 void SCIPlpSetSizeMark(
793  SCIP_LP* lp, /**< current LP data */
794  int nrows, /**< number of rows to set the size marker to */
795  int ncols /**< number of columns to set the size marker to */
796  );
797 
798 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1 */
799 SCIP_RETCODE SCIPlpGetBasisInd(
800  SCIP_LP* lp, /**< LP data */
801  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
802  );
803 
804 /** gets current basis status for columns and rows; arrays must be large enough to store the basis status */
805 SCIP_RETCODE SCIPlpGetBase(
806  SCIP_LP* lp, /**< LP data */
807  int* cstat, /**< array to store column basis status, or NULL */
808  int* rstat /**< array to store row basis status, or NULL */
809  );
810 
811 /** gets a row from the inverse basis matrix B^-1 */
812 SCIP_RETCODE SCIPlpGetBInvRow(
813  SCIP_LP* lp, /**< LP data */
814  int r, /**< row number */
815  SCIP_Real* coef, /**< pointer to store the coefficients of the row */
816  int* inds, /**< array to store the non-zero indices, or NULL */
817  int* ninds /**< pointer to store the number of non-zero indices, or NULL
818  * (-1: if we do not store sparsity informations) */
819  );
820 
821 /** gets a column from the inverse basis matrix B^-1 */
822 SCIP_RETCODE SCIPlpGetBInvCol(
823  SCIP_LP* lp, /**< LP data */
824  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
825  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
826  * to get the array which links the B^-1 column numbers to the row and
827  * column numbers of the LP! c must be between 0 and nrows-1, since the
828  * basis has the size nrows * nrows */
829  SCIP_Real* coef, /**< pointer to store the coefficients of the column */
830  int* inds, /**< array to store the non-zero indices, or NULL */
831  int* ninds /**< pointer to store the number of non-zero indices, or NULL
832  * (-1: if we do not store sparsity informations) */
833  );
834 
835 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A) */
836 SCIP_RETCODE SCIPlpGetBInvARow(
837  SCIP_LP* lp, /**< LP data */
838  int r, /**< row number */
839  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPlpGetBInvRow(), or NULL */
840  SCIP_Real* coef, /**< pointer to store the coefficients of the row */
841  int* inds, /**< array to store the non-zero indices, or NULL */
842  int* ninds /**< pointer to store the number of non-zero indices, or NULL
843  * (-1: if we do not store sparsity informations) */
844  );
845 
846 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
847  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
848  */
849 SCIP_RETCODE SCIPlpGetBInvACol(
850  SCIP_LP* lp, /**< LP data */
851  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
852  SCIP_Real* coef, /**< pointer to store the coefficients of the column */
853  int* inds, /**< array to store the non-zero indices, or NULL */
854  int* ninds /**< pointer to store the number of non-zero indices, or NULL
855  * (-1: if we do not store sparsity informations) */
856  );
857 
858 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
859  * LP row are swapped in the summation
860  */
861 SCIP_RETCODE SCIPlpSumRows(
862  SCIP_LP* lp, /**< LP data */
863  SCIP_SET* set, /**< global SCIP settings */
864  SCIP_PROB* prob, /**< problem data */
865  SCIP_Real* weights, /**< row weights in row summation */
866  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
867  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
868  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
869  );
870 
871 /* calculates a MIR cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these
872  * rows cannot participate in a MIR cut.
873  */
874 SCIP_RETCODE SCIPlpCalcMIR(
875  SCIP_LP* lp, /**< LP data */
876  SCIP_SET* set, /**< global SCIP settings */
877  SCIP_STAT* stat, /**< problem statistics */
878  SCIP_PROB* prob, /**< problem data */
879  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
880  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
881  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
882  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
883  SCIP_Bool fixintegralrhs, /**< should complementation tried to be adjusted such that rhs gets fractional? */
884  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
885  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
886  * NULL for using closest bound for all variables */
887  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
888  * NULL for using closest bound for all variables */
889  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
890  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
891  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
892  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
893  SCIP_Real* weights, /**< row weights in row summation */
894  SCIP_Real maxweight, /**< largest magnitude of weights; set to -1 if sparsity information is unknown */
895  int* weightinds, /**< sparsity pattern of weights; size nrowinds; NULL if sparsity info is unknown */
896  int nweightinds, /**< number of nonzeros in weights; -1 if rowinds is NULL */
897  int rowlensum, /**< total number of non-zeros in used rows (row associated with nonzero weight coefficient); -1 if unknown */
898  int* sidetypes, /**< specify row side type (-1 = lhs, 0 = unkown, 1 = rhs) or NULL for automatic choices */
899  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
900  SCIP_Real* mksetcoefs, /**< array to store mixed knapsack set coefficients: size nvars; or NULL */
901  SCIP_Bool* mksetcoefsvalid, /**< pointer to store whether mixed knapsack set coefficients are valid; or NULL */
902  SCIP_Real* mircoef, /**< array to store MIR coefficients: must be of size nvars */
903  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the MIR row */
904  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
905  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid MIR cut */
906  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
907  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
908  );
909 
910 /* calculates a strong CG cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because
911  * these rows cannot participate in a strong CG cut.
912  */
913 SCIP_RETCODE SCIPlpCalcStrongCG(
914  SCIP_LP* lp, /**< LP data */
915  SCIP_SET* set, /**< global SCIP settings */
916  SCIP_STAT* stat, /**< problem statistics */
917  SCIP_PROB* prob, /**< problem data */
918  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
919  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
920  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
921  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
922  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
923  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce strong CG cut for */
924  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce strong CG cut for */
925  SCIP_Real* weights, /**< row weights in row summation */
926  int* rowinds, /**< array to store indices of non-zero entries of the weights array, or
927  * NULL */
928  int nrowinds, /**< number of non-zero entries in weights array, -1 if rowinds is NULL */
929  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
930  SCIP_Real* strongcgcoef, /**< array to store strong CG coefficients: must be of size nvars */
931  SCIP_Real* strongcgrhs, /**< pointer to store the right hand side of the strong CG row */
932  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
933  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid strong CG cut */
934  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
935  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
936  );
937 
938 /** stores LP state (like basis information) into LP state object */
939 SCIP_RETCODE SCIPlpGetState(
940  SCIP_LP* lp, /**< LP data */
941  BMS_BLKMEM* blkmem, /**< block memory */
942  SCIP_LPISTATE** lpistate /**< pointer to LP state information (like basis information) */
943  );
944 
945 /** loads LP state (like basis information) into solver */
946 SCIP_RETCODE SCIPlpSetState(
947  SCIP_LP* lp, /**< LP data */
948  BMS_BLKMEM* blkmem, /**< block memory */
949  SCIP_SET* set, /**< global SCIP settings */
950  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
951  SCIP_LPISTATE* lpistate, /**< LP state information (like basis information) */
952  SCIP_Bool wasprimfeas, /**< primal feasibility when LP state information was stored */
953  SCIP_Bool wasprimchecked, /**< true if the LP solution has passed the primal feasibility check */
954  SCIP_Bool wasdualfeas, /**< dual feasibility when LP state information was stored */
955  SCIP_Bool wasdualchecked /**< true if the LP solution has passed the dual feasibility check */
956  );
957 
958 /** frees LP state information */
959 SCIP_RETCODE SCIPlpFreeState(
960  SCIP_LP* lp, /**< LP data */
961  BMS_BLKMEM* blkmem, /**< block memory */
962  SCIP_LPISTATE** lpistate /**< pointer to LP state information (like basis information) */
963  );
964 
965 /** stores pricing norms into LP norms object */
966 SCIP_RETCODE SCIPlpGetNorms(
967  SCIP_LP* lp, /**< LP data */
968  BMS_BLKMEM* blkmem, /**< block memory */
969  SCIP_LPINORMS** lpinorms /**< pointer to LP pricing norms information */
970  );
971 
972 /** loads pricing norms from LP norms object into solver */
973 SCIP_RETCODE SCIPlpSetNorms(
974  SCIP_LP* lp, /**< LP data */
975  BMS_BLKMEM* blkmem, /**< block memory */
976  SCIP_LPINORMS* lpinorms /**< LP pricing norms information */
977  );
978 
979 /** frees pricing norms information */
980 SCIP_RETCODE SCIPlpFreeNorms(
981  SCIP_LP* lp, /**< LP data */
982  BMS_BLKMEM* blkmem, /**< block memory */
983  SCIP_LPINORMS** lpinorms /**< pointer to LP pricing norms information */
984  );
985 
986 /** return the current cutoff bound of the lp */
987 SCIP_Real SCIPlpGetCutoffbound(
988  SCIP_LP* lp /**< current LP data */
989  );
990 
991 /** sets the upper objective limit of the LP solver */
992 SCIP_RETCODE SCIPlpSetCutoffbound(
993  SCIP_LP* lp, /**< current LP data */
994  SCIP_SET* set, /**< global SCIP settings */
995  SCIP_PROB* prob, /**< problem data */
996  SCIP_Real cutoffbound /**< new upper objective limit */
997  );
998 
999 /** applies all cached changes to the LP solver */
1000 SCIP_RETCODE SCIPlpFlush(
1001  SCIP_LP* lp, /**< current LP data */
1002  BMS_BLKMEM* blkmem, /**< block memory */
1003  SCIP_SET* set, /**< global SCIP settings */
1004  SCIP_EVENTQUEUE* eventqueue /**< event queue */
1005  );
1006 
1007 /** marks the LP to be flushed, even if the LP thinks it is not flushed */
1008 SCIP_RETCODE SCIPlpMarkFlushed(
1009  SCIP_LP* lp, /**< current LP data */
1010  SCIP_SET* set /**< global SCIP settings */
1011  );
1012 
1013 /** solves the LP with simplex algorithm, and copy the solution into the column's data */
1014 SCIP_RETCODE SCIPlpSolveAndEval(
1015  SCIP_LP* lp, /**< LP data */
1016  SCIP_SET* set, /**< global SCIP settings */
1017  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1018  BMS_BLKMEM* blkmem, /**< block memory buffers */
1019  SCIP_STAT* stat, /**< problem statistics */
1020  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1021  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1022  SCIP_PROB* prob, /**< problem data */
1023  SCIP_Longint itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
1024  SCIP_Bool limitresolveiters, /**< should LP iterations for resolving calls be limited?
1025  * (limit is computed within the method w.r.t. the average LP iterations) */
1026  SCIP_Bool aging, /**< should aging and removal of obsolete cols/rows be applied? */
1027  SCIP_Bool keepsol, /**< should the old LP solution be kept if no iterations were performed? */
1028  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */
1029  );
1030 
1031 /** gets solution status of current LP */
1032 SCIP_LPSOLSTAT SCIPlpGetSolstat(
1033  SCIP_LP* lp /**< current LP data */
1034  );
1035 
1036 /** sets whether the root LP is a relaxation of the problem and its optimal objective value is a global lower bound */
1037 void SCIPlpSetRootLPIsRelax(
1038  SCIP_LP* lp, /**< LP data */
1039  SCIP_Bool isrelax /**< is the root lp a relaxation of the problem? */
1040  );
1041 
1042 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound */
1043 SCIP_Bool SCIPlpIsRootLPRelax(
1044  SCIP_LP* lp /**< LP data */
1045  );
1046 
1047 /** gets objective value of current LP
1048  *
1049  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
1050  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status is
1051  * SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
1052  */
1053 SCIP_Real SCIPlpGetObjval(
1054  SCIP_LP* lp, /**< current LP data */
1055  SCIP_SET* set, /**< global SCIP settings */
1056  SCIP_PROB* prob /**< problem data */
1057  );
1058 
1059 /** gets part of objective value of current LP that results from COLUMN variables only */
1060 SCIP_Real SCIPlpGetColumnObjval(
1061  SCIP_LP* lp /**< current LP data */
1062  );
1063 
1064 /** gets part of objective value of current LP that results from LOOSE variables only */
1065 SCIP_Real SCIPlpGetLooseObjval(
1066  SCIP_LP* lp, /**< current LP data */
1067  SCIP_SET* set, /**< global SCIP settings */
1068  SCIP_PROB* prob /**< problem data */
1069  );
1070 
1071 /** remembers the current LP objective value as root solution value */
1072 void SCIPlpStoreRootObjval(
1073  SCIP_LP* lp, /**< current LP data */
1074  SCIP_SET* set, /**< global SCIP settings */
1075  SCIP_PROB* prob /**< problem data */
1076  );
1077 
1078 /** invalidates the root LP solution value */
1079 void SCIPlpInvalidateRootObjval(
1080  SCIP_LP* lp /**< current LP data */
1081  );
1082 
1083 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective function)
1084  * global bound
1085  */
1086 SCIP_Real SCIPlpGetGlobalPseudoObjval(
1087  SCIP_LP* lp, /**< current LP data */
1088  SCIP_SET* set, /**< global SCIP settings */
1089  SCIP_PROB* prob /**< problem data */
1090  );
1091 
1092 /** recomputes local and global pseudo objective values */
1093 void SCIPlpRecomputeLocalAndGlobalPseudoObjval(
1094  SCIP_LP* lp, /**< current LP data */
1095  SCIP_SET* set, /**< global SCIP settings */
1096  SCIP_PROB* prob /**< problem data */
1097  );
1098 
1099 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
1100  * objective function) local bound
1101  */
1102 SCIP_Real SCIPlpGetPseudoObjval(
1103  SCIP_LP* lp, /**< current LP data */
1104  SCIP_SET* set, /**< global SCIP settings */
1105  SCIP_PROB* prob /**< problem data */
1106  );
1107 
1108 /** gets pseudo objective value, if a bound of the given variable would be modified in the given way */
1109 SCIP_Real SCIPlpGetModifiedPseudoObjval(
1110  SCIP_LP* lp, /**< current LP data */
1111  SCIP_SET* set, /**< global SCIP settings */
1112  SCIP_PROB* prob, /**< problem data */
1113  SCIP_VAR* var, /**< problem variable */
1114  SCIP_Real oldbound, /**< old value for bound */
1115  SCIP_Real newbound, /**< new value for bound */
1116  SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
1117  );
1118 
1119 /** gets pseudo objective value, if a bound of the given variable would be modified in the given way;
1120  * perform calculations with interval arithmetic to get an exact lower bound
1121  */
1122 SCIP_Real SCIPlpGetModifiedProvedPseudoObjval(
1123  SCIP_LP* lp, /**< current LP data */
1124  SCIP_SET* set, /**< global SCIP settings */
1125  SCIP_VAR* var, /**< problem variable */
1126  SCIP_Real oldbound, /**< old value for bound */
1127  SCIP_Real newbound, /**< new value for bound */
1128  SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
1129  );
1130 
1131 /** updates current pseudo and loose objective value for a change in a variable's objective value */
1132 SCIP_RETCODE SCIPlpUpdateVarObj(
1133  SCIP_LP* lp, /**< current LP data */
1134  SCIP_SET* set, /**< global SCIP settings */
1135  SCIP_VAR* var, /**< problem variable that changed */
1136  SCIP_Real oldobj, /**< old objective value of variable */
1137  SCIP_Real newobj /**< new objective value of variable */
1138  );
1139 
1140 /** updates current root pseudo objective value for a global change in a variable's lower bound */
1141 SCIP_RETCODE SCIPlpUpdateVarLbGlobal(
1142  SCIP_LP* lp, /**< current LP data */
1143  SCIP_SET* set, /**< global SCIP settings */
1144  SCIP_VAR* var, /**< problem variable that changed */
1145  SCIP_Real oldlb, /**< old lower bound of variable */
1146  SCIP_Real newlb /**< new lower bound of variable */
1147  );
1148 
1149 /** updates current pseudo and loose objective value for a change in a variable's lower bound */
1150 SCIP_RETCODE SCIPlpUpdateVarLb(
1151  SCIP_LP* lp, /**< current LP data */
1152  SCIP_SET* set, /**< global SCIP settings */
1153  SCIP_VAR* var, /**< problem variable that changed */
1154  SCIP_Real oldlb, /**< old lower bound of variable */
1155  SCIP_Real newlb /**< new lower bound of variable */
1156  );
1157 
1158 /** updates current root pseudo objective value for a global change in a variable's upper bound */
1159 SCIP_RETCODE SCIPlpUpdateVarUbGlobal(
1160  SCIP_LP* lp, /**< current LP data */
1161  SCIP_SET* set, /**< global SCIP settings */
1162  SCIP_VAR* var, /**< problem variable that changed */
1163  SCIP_Real oldub, /**< old upper bound of variable */
1164  SCIP_Real newub /**< new upper bound of variable */
1165  );
1166 
1167 /** updates current pseudo objective value for a change in a variable's upper bound */
1168 SCIP_RETCODE SCIPlpUpdateVarUb(
1169  SCIP_LP* lp, /**< current LP data */
1170  SCIP_SET* set, /**< global SCIP settings */
1171  SCIP_VAR* var, /**< problem variable that changed */
1172  SCIP_Real oldub, /**< old upper bound of variable */
1173  SCIP_Real newub /**< new upper bound of variable */
1174  );
1175 
1176 /** informs LP, that given variable was added to the problem */
1177 SCIP_RETCODE SCIPlpUpdateAddVar(
1178  SCIP_LP* lp, /**< current LP data */
1179  SCIP_SET* set, /**< global SCIP settings */
1180  SCIP_VAR* var /**< variable that is now a LOOSE problem variable */
1181  );
1182 
1183 /** informs LP, that given variable is to be deleted from the problem */
1184 SCIP_RETCODE SCIPlpUpdateDelVar(
1185  SCIP_LP* lp, /**< current LP data */
1186  SCIP_SET* set, /**< global SCIP settings */
1187  SCIP_VAR* var /**< variable that will be deleted from the problem */
1188  );
1189 
1190 /** informs LP, that given formerly loose problem variable is now a column variable */
1191 SCIP_RETCODE SCIPlpUpdateVarColumn(
1192  SCIP_LP* lp, /**< current LP data */
1193  SCIP_SET* set, /**< global SCIP settings */
1194  SCIP_VAR* var /**< problem variable that changed from LOOSE to COLUMN */
1195  );
1196 
1197 /** informs LP, that given formerly column problem variable is now again a loose variable */
1198 SCIP_RETCODE SCIPlpUpdateVarLoose(
1199  SCIP_LP* lp, /**< current LP data */
1200  SCIP_SET* set, /**< global SCIP settings */
1201  SCIP_VAR* var /**< problem variable that changed from COLUMN to LOOSE */
1202  );
1203 
1204 /** decrease the number of loose variables by one */
1205 void SCIPlpDecNLoosevars(
1206  SCIP_LP* lp /**< current LP data */
1207  );
1208 
1209 /** stores the LP solution in the columns and rows */
1210 SCIP_RETCODE SCIPlpGetSol(
1211  SCIP_LP* lp, /**< current LP data */
1212  SCIP_SET* set, /**< global SCIP settings */
1213  SCIP_STAT* stat, /**< problem statistics */
1214  SCIP_Bool* primalfeasible, /**< pointer to store whether the solution is primal feasible, or NULL */
1215  SCIP_Bool* dualfeasible /**< pointer to store whether the solution is dual feasible, or NULL */
1216  );
1217 
1218 /** stores LP solution with infinite objective value in the columns and rows */
1219 SCIP_RETCODE SCIPlpGetUnboundedSol(
1220  SCIP_LP* lp, /**< current LP data */
1221  SCIP_SET* set, /**< global SCIP settings */
1222  SCIP_STAT* stat, /**< problem statistics */
1223  SCIP_Bool* primalfeasible, /**< pointer to store whether the solution is primal feasible, or NULL */
1224  SCIP_Bool* rayfeasible /**< pointer to store whether the primal ray is a feasible unboundedness proof, or NULL */
1225  );
1226 
1227 /** returns primal ray proving the unboundedness of the current LP */
1228 SCIP_RETCODE SCIPlpGetPrimalRay(
1229  SCIP_LP* lp, /**< current LP data */
1230  SCIP_SET* set, /**< global SCIP settings */
1231  SCIP_Real* ray /**< array for storing primal ray values, they are stored w.r.t. the problem index of the variables,
1232  * so the size of this array should be at least number of active variables
1233  * (all entries have to be initialized to 0 before) */
1234  );
1235 
1236 /** stores the dual Farkas multipliers for infeasibility proof in rows. besides, the proof is checked for validity if
1237  * lp/checkfarkas = TRUE.
1238  *
1239  * @note the check will not be performed if @p valid is NULL.
1240  */
1241 SCIP_RETCODE SCIPlpGetDualfarkas(
1242  SCIP_LP* lp, /**< current LP data */
1243  SCIP_SET* set, /**< global SCIP settings */
1244  SCIP_STAT* stat, /**< problem statistics */
1245  SCIP_Bool* valid /**< pointer to store whether the Farkas proof is valid or NULL */
1246  );
1247 
1248 /** get number of iterations used in last LP solve */
1249 SCIP_RETCODE SCIPlpGetIterations(
1250  SCIP_LP* lp, /**< current LP data */
1251  int* iterations /**< pointer to store the iteration count */
1252  );
1253 
1254 /** increases age of columns with solution value 0.0 and rows with activity not at its bounds,
1255  * resets age of non-zero columns and sharp rows
1256  */
1257 SCIP_RETCODE SCIPlpUpdateAges(
1258  SCIP_LP* lp, /**< current LP data */
1259  SCIP_STAT* stat /**< problem statistics */
1260  );
1261 
1262 /** removes all non-basic columns and basic rows in the part of the LP created at the current node, that are too old */
1263 SCIP_RETCODE SCIPlpRemoveNewObsoletes(
1264  SCIP_LP* lp, /**< current LP data */
1265  BMS_BLKMEM* blkmem, /**< block memory buffers */
1266  SCIP_SET* set, /**< global SCIP settings */
1267  SCIP_STAT* stat, /**< problem statistics */
1268  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1269  SCIP_EVENTFILTER* eventfilter /**< global event filter */
1270  );
1271 
1272 /** removes all non-basic columns and basic rows in whole LP, that are too old */
1273 SCIP_RETCODE SCIPlpRemoveAllObsoletes(
1274  SCIP_LP* lp, /**< current LP data */
1275  BMS_BLKMEM* blkmem, /**< block memory buffers */
1276  SCIP_SET* set, /**< global SCIP settings */
1277  SCIP_STAT* stat, /**< problem statistics */
1278  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1279  SCIP_EVENTFILTER* eventfilter /**< global event filter */
1280  );
1281 
1282 /** removes all non-basic columns at 0.0 and basic rows in the part of the LP created at the current node */
1283 SCIP_RETCODE SCIPlpCleanupNew(
1284  SCIP_LP* lp, /**< current LP data */
1285  BMS_BLKMEM* blkmem, /**< block memory buffers */
1286  SCIP_SET* set, /**< global SCIP settings */
1287  SCIP_STAT* stat, /**< problem statistics */
1288  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1289  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1290  SCIP_Bool root /**< are we at the root node? */
1291  );
1292 
1293 /** removes all non-basic columns at 0.0 and basic rows in the whole LP */
1294 SCIP_RETCODE SCIPlpCleanupAll(
1295  SCIP_LP* lp, /**< current LP data */
1296  BMS_BLKMEM* blkmem, /**< block memory buffers */
1297  SCIP_SET* set, /**< global SCIP settings */
1298  SCIP_STAT* stat, /**< problem statistics */
1299  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1300  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1301  SCIP_Bool root /**< are we at the root node? */
1302  );
1303 
1304 /** removes all redundant rows that were added at the current node */
1305 SCIP_RETCODE SCIPlpRemoveRedundantRows(
1306  SCIP_LP* lp, /**< current LP data */
1307  BMS_BLKMEM* blkmem, /**< block memory buffers */
1308  SCIP_SET* set, /**< global SCIP settings */
1309  SCIP_STAT* stat, /**< problem statistics */
1310  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1311  SCIP_EVENTFILTER* eventfilter /**< global event filter */
1312  );
1313 
1314 /** initiates LP diving */
1315 SCIP_RETCODE SCIPlpStartDive(
1316  SCIP_LP* lp, /**< current LP data */
1317  BMS_BLKMEM* blkmem, /**< block memory */
1318  SCIP_SET* set, /**< global SCIP settings */
1319  SCIP_STAT* stat /**< problem statistics */
1320  );
1321 
1322 /** quits LP diving and resets bounds and objective values of columns to the current node's values */
1323 SCIP_RETCODE SCIPlpEndDive(
1324  SCIP_LP* lp, /**< current LP data */
1325  BMS_BLKMEM* blkmem, /**< block memory */
1326  SCIP_SET* set, /**< global SCIP settings */
1327  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1328  SCIP_STAT* stat, /**< problem statistics */
1329  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1330  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1331  SCIP_PROB* prob, /**< problem data */
1332  SCIP_VAR** vars, /**< array with all active variables */
1333  int nvars /**< number of active variables */
1334  );
1335 
1336 /** records a current row side such that any change will be undone after diving */
1337 SCIP_RETCODE SCIPlpRecordOldRowSideDive(
1338  SCIP_LP* lp, /**< LP data object */
1339  SCIP_ROW* row, /**< row affected by the change */
1340  SCIP_SIDETYPE sidetype /**< side type */
1341  );
1342 
1343 /** informs the LP that probing mode was initiated */
1344 SCIP_RETCODE SCIPlpStartProbing(
1345  SCIP_LP* lp /**< current LP data */
1346  );
1347 
1348 /** informs the LP that probing mode was finished */
1349 SCIP_RETCODE SCIPlpEndProbing(
1350  SCIP_LP* lp /**< current LP data */
1351  );
1352 
1353 /** informs the LP that the probing mode is now used for strongbranching */
1354 void SCIPlpStartStrongbranchProbing(
1355  SCIP_LP* lp /**< current LP data */
1356  );
1357 
1358 /** informs the LP that the probing mode is not used for strongbranching anymore */
1359 void SCIPlpEndStrongbranchProbing(
1360  SCIP_LP* lp /**< current LP data */
1361  );
1362 
1363 /** gets proven lower (dual) bound of last LP solution */
1364 SCIP_RETCODE SCIPlpGetProvedLowerbound(
1365  SCIP_LP* lp, /**< current LP data */
1366  SCIP_SET* set, /**< global SCIP settings */
1367  SCIP_Real* bound /**< pointer to store proven dual bound */
1368  );
1369 
1370 /** gets proven dual bound of last LP solution */
1371 SCIP_RETCODE SCIPlpIsInfeasibilityProved(
1372  SCIP_LP* lp, /**< current LP data */
1373  SCIP_SET* set, /**< global SCIP settings */
1374  SCIP_Bool* proved /**< pointer to store whether infeasibility is proven */
1375  );
1376 
1377 /** writes LP to a file */
1378 SCIP_RETCODE SCIPlpWrite(
1379  SCIP_LP* lp, /**< current LP data */
1380  const char* fname /**< file name */
1381  );
1382 
1383 /** writes MIP to a file */
1384 SCIP_RETCODE SCIPlpWriteMip(
1385  SCIP_LP* lp, /**< current LP data */
1386  SCIP_SET* set, /**< global SCIP settings */
1387  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1388  const char* fname, /**< file name */
1389  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
1390  * troubles with reserved symbols? */
1391  SCIP_Bool origobj, /**< should the original objective function be used? */
1392  SCIP_OBJSENSE objsense, /**< objective sense */
1393  SCIP_Real objscale, /**< objective scaling factor */
1394  SCIP_Real objoffset, /**< objective offset, e.g., caused by variable fixings in presolving */
1395  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
1396  );
1397 
1398 /** recalculates Euclidean norm of objective function vector of column variables if it have gotten unreliable during calculation */
1399 void SCIPlpRecalculateObjSqrNorm(
1400  SCIP_SET* set, /**< global SCIP settings */
1401  SCIP_LP* lp /**< LP data */
1402  );
1403 
1404 /** compute relative interior point */
1405 SCIP_RETCODE SCIPlpComputeRelIntPoint(
1406  SCIP_SET* set, /**< global SCIP settings */
1407  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1408  SCIP_LP* lp, /**< LP data */
1409  SCIP_PROB* prob, /**< problem data */
1410  SCIP_Bool relaxrows, /**< should the rows be relaxed */
1411  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
1412  SCIP_Real timelimit, /**< time limit for LP solver */
1413  int iterlimit, /**< iteration limit for LP solver */
1414  SCIP_Real* point, /**< array to store relative interior point on exit */
1415  SCIP_Bool* success /**< buffer to indicate whether interior point was successfully computed */
1416  );
1417 
1418 /** gets array with columns of the LP */
1419 SCIP_COL** SCIPlpGetCols(
1420  SCIP_LP* lp /**< current LP data */
1421  );
1422 
1423 /** gets current number of columns in LP */
1424 int SCIPlpGetNCols(
1425  SCIP_LP* lp /**< current LP data */
1426  );
1427 
1428 /** gets array with rows of the LP */
1429 SCIP_ROW** SCIPlpGetRows(
1430  SCIP_LP* lp /**< current LP data */
1431  );
1432 
1433 /** gets current number of rows in LP */
1434 int SCIPlpGetNRows(
1435  SCIP_LP* lp /**< current LP data */
1436  );
1437 
1438 /** gets array with newly added columns after the last mark */
1439 SCIP_COL** SCIPlpGetNewcols(
1440  SCIP_LP* lp /**< current LP data */
1441  );
1442 
1443 /** gets number of newly added columns after the last mark */
1444 int SCIPlpGetNNewcols(
1445  SCIP_LP* lp /**< current LP data */
1446  );
1447 
1448 /** gets array with newly added rows after the last mark */
1449 SCIP_ROW** SCIPlpGetNewrows(
1450  SCIP_LP* lp /**< current LP data */
1451  );
1452 
1453 /** gets number of newly added rows after the last mark */
1454 int SCIPlpGetNNewrows(
1455  SCIP_LP* lp /**< current LP data */
1456  );
1457 
1458 /** gets Euclidean norm of objective function vector of column variables, only use this method if
1459  * lp->objsqrnormunreliable == FALSE, so probably you have to call SCIPlpRecalculateObjSqrNorm before */
1460 SCIP_Real SCIPlpGetObjNorm(
1461  SCIP_LP* lp /**< LP data */
1462  );
1463 
1464 /** gets the objective value of the root node LP; returns SCIP_INVALID if the root node LP was not (yet) solved */
1465 SCIP_Real SCIPlpGetRootObjval(
1466  SCIP_LP* lp /**< LP data */
1467  );
1468 
1469 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
1470  * returns SCIP_INVALID if the root node LP was not (yet) solved
1471  */
1472 SCIP_Real SCIPlpGetRootColumnObjval(
1473  SCIP_LP* lp /**< LP data */
1474  );
1475 
1476 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
1477  * returns SCIP_INVALID if the root node LP was not (yet) solved
1478  */
1479 SCIP_Real SCIPlpGetRootLooseObjval(
1480  SCIP_LP* lp /**< LP data */
1481  );
1482 
1483 /** gets the LP solver interface */
1484 SCIP_LPI* SCIPlpGetLPI(
1485  SCIP_LP* lp /**< current LP data */
1486  );
1487 
1488 /** sets whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound */
1489 void SCIPlpSetIsRelax(
1490  SCIP_LP* lp, /**< LP data */
1491  SCIP_Bool relax /**< is the current lp a relaxation? */
1492  );
1493 
1494 /** returns whether the current LP is a relaxation of the problem for which it has been solved and its
1495  * solution value a valid local lower bound?
1496  */
1497 SCIP_Bool SCIPlpIsRelax(
1498  SCIP_LP* lp /**< LP data */
1499  );
1500 
1501 /** returns whether the current LP is flushed and solved */
1502 SCIP_Bool SCIPlpIsSolved(
1503  SCIP_LP* lp /**< current LP data */
1504  );
1505 
1506 /** return whether the current LP solution passed the primal feasibility check */
1507 SCIP_Bool SCIPlpIsPrimalReliable(
1508  SCIP_LP* lp /**< current LP data */
1509  );
1510 
1511 /** return whether the current LP solution passed the dual feasibility check */
1512 SCIP_Bool SCIPlpIsDualReliable(
1513  SCIP_LP* lp /**< current LP data */
1514  );
1515 
1516 /** returns whether the current LP solution is a basic solution */
1517 SCIP_Bool SCIPlpIsSolBasic(
1518  SCIP_LP* lp /**< current LP data */
1519  );
1520 
1521 /** returns whether the LP is in diving mode */
1522 SCIP_Bool SCIPlpDiving(
1523  SCIP_LP* lp /**< current LP data */
1524  );
1525 
1526 /** returns whether the LP is in diving mode and the objective value of at least one column was changed */
1527 SCIP_Bool SCIPlpDivingObjChanged(
1528  SCIP_LP* lp /**< current LP data */
1529  );
1530 
1531 /** marks the diving LP to have a changed objective function */
1532 void SCIPlpMarkDivingObjChanged(
1533  SCIP_LP* lp /**< current LP data */
1534  );
1535 
1536 /** marks the diving LP to not have a changed objective function anymore */
1537 void SCIPlpUnmarkDivingObjChanged(
1538  SCIP_LP* lp /**< current LP data */
1539  );
1540 
1541 /* returns TRUE if at least one left/right hand side of an LP row was changed during diving mode */
1542 SCIP_Bool SCIPlpDivingRowsChanged(
1543  SCIP_LP* lp /**< current LP data */
1544  );
1545 
1546 
1547 #ifdef NDEBUG
1548 
1549 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1550  * speed up the algorithms.
1551  */
1552 
1553 #define SCIPlpGetCols(lp) ((lp)->cols)
1554 #define SCIPlpGetNCols(lp) ((lp)->ncols)
1555 #define SCIPlpGetRows(lp) ((lp)->rows)
1556 #define SCIPlpGetNRows(lp) ((lp)->nrows)
1557 #define SCIPlpGetNewcols(lp) (&((lp)->cols[(lp)->firstnewcol]))
1558 #define SCIPlpGetNNewcols(lp) ((lp)->ncols - (lp)->firstnewcol)
1559 #define SCIPlpGetNewrows(lp) (&((lp)->rows[(lp)->firstnewrow]))
1560 #define SCIPlpGetNNewrows(lp) ((lp)->nrows - (lp)->firstnewrow)
1561 #define SCIPlpGetObjNorm(lp) (SQRT((lp)->objsqrnorm))
1562 #define SCIPlpGetRootObjval(lp) (MIN((lp)->rootlpobjval + (lp)->rootlooseobjval, SCIP_INVALID))
1563 #define SCIPlpGetRootColumnObjval(lp) ((lp)->rootlpobjval)
1564 #define SCIPlpGetRootLooseObjval(lp) ((lp)->rootlooseobjval)
1565 #define SCIPlpGetLPI(lp) (lp)->lpi
1566 #define SCIPlpSetIsRelax(lp,relax) ((lp)->isrelax = relax)
1567 #define SCIPlpIsRelax(lp) (lp)->isrelax
1568 #define SCIPlpIsSolved(lp) ((lp)->flushed && (lp)->solved)
1569 #define SCIPlpIsSolBasic(lp) ((lp)->solisbasic)
1570 #define SCIPlpDiving(lp) (lp)->diving
1571 #define SCIPlpDivingObjChanged(lp) (lp)->divingobjchg
1572 #define SCIPlpMarkDivingObjChanged(lp) ((lp)->divingobjchg = TRUE)
1573 #define SCIPlpUnmarkDivingObjChanged(lp) ((lp)->divingobjchg = FALSE)
1574 #define SCIPlpDivingRowsChanged(lp) ((lp)->ndivechgsides > 0)
1575 
1576 #endif
1577 
1578 #ifdef __cplusplus
1579 }
1580 #endif
1581 
1582 #endif
SCIPlpGetNewcols
SCIP_COL ** SCIPlpGetNewcols(SCIP_LP *lp)
Definition: lp.c:17259
SCIPlpUpdateVarLbGlobal
SCIP_RETCODE SCIPlpUpdateVarLbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)
Definition: lp.c:13691
SCIP_BOUNDTYPE
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIProwGetLPActivity
SCIP_Real SCIProwGetLPActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:6131
SCIPlpGetIterations
SCIP_RETCODE SCIPlpGetIterations(SCIP_LP *lp, int *iterations)
Definition: lp.c:14934
SCIPlpIsInfeasibilityProved
SCIP_RETCODE SCIPlpIsInfeasibilityProved(SCIP_LP *lp, SCIP_SET *set, SCIP_Bool *proved)
Definition: lp.c:16212
SCIPcolChgObj
SCIP_RETCODE SCIPcolChgObj(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
Definition: lp.c:3635
SCIPlpStartStrongbranchProbing
void SCIPlpStartStrongbranchProbing(SCIP_LP *lp)
Definition: lp.c:16052
SCIPlpGetBInvARow
SCIP_RETCODE SCIPlpGetBInvARow(SCIP_LP *lp, int r, SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9790
SCIPlpEndStrongbranchProbing
void SCIPlpEndStrongbranchProbing(SCIP_LP *lp)
Definition: lp.c:16065
SCIProwGetMaxval
SCIP_Real SCIProwGetMaxval(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6578
SCIPlpGetSol
SCIP_RETCODE SCIPlpGetSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
Definition: lp.c:14147
SCIPcolGetFarkasCoef
SCIP_Real SCIPcolGetFarkasCoef(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:4072
SCIPlpGetBInvCol
SCIP_RETCODE SCIPlpGetBInvCol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9764
type_misc.h
type definitions for miscellaneous datastructures
SCIPlpIsSolBasic
SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)
Definition: lp.c:17464
SCIPcolChgCoef
SCIP_RETCODE SCIPcolChgCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
Definition: lp.c:3450
SCIPlpGetRows
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
Definition: lp.c:17239
SCIPlpSetIsRelax
void SCIPlpSetIsRelax(SCIP_LP *lp, SCIP_Bool relax)
Definition: lp.c:17411
SCIPlpGetBInvACol
SCIP_RETCODE SCIPlpGetBInvACol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9815
SCIPlpUpdateVarColumn
SCIP_RETCODE SCIPlpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
Definition: lp.c:13984
SCIPcolMarkNotRemovableLocal
void SCIPcolMarkNotRemovableLocal(SCIP_COL *col, SCIP_STAT *stat)
Definition: lp.c:4674
SCIPlpUpdateVarLb
SCIP_RETCODE SCIPlpUpdateVarLb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)
Definition: lp.c:13718
SCIPlpGetProvedLowerbound
SCIP_RETCODE SCIPlpGetProvedLowerbound(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *bound)
Definition: lp.c:16198
SCIPlpGetModifiedProvedPseudoObjval
SCIP_Real SCIPlpGetModifiedProvedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
Definition: lp.c:13171
SCIPlpGetState
SCIP_RETCODE SCIPlpGetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
Definition: lp.c:9925
SCIPlpGetRootColumnObjval
SCIP_Real SCIPlpGetRootColumnObjval(SCIP_LP *lp)
Definition: lp.c:17379
SCIPcolGetRedcost
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:3889
SCIPlpEndProbing
SCIP_RETCODE SCIPlpEndProbing(SCIP_LP *lp)
Definition: lp.c:16037
SCIProwCapture
void SCIProwCapture(SCIP_ROW *row)
Definition: lp.c:5246
SCIProwChgConstant
SCIP_RETCODE SCIProwChgConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real constant)
Definition: lp.c:5492
SCIP_ROWORIGINTYPE
enum SCIP_RowOriginType SCIP_ROWORIGINTYPE
Definition: type_lp.h:68
SCIPcolCalcFarkasCoef
SCIP_Real SCIPcolCalcFarkasCoef(SCIP_COL *col, SCIP_Real *dualfarkas)
Definition: lp.c:3967
SCIProwGetNLPEfficacy
SCIP_Real SCIProwGetNLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6871
SCIProwGetPseudoActivity
SCIP_Real SCIProwGetPseudoActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6329
bound
static long bound
Definition: GomoryHuTree.cpp:35
SCIPlpSetRootLPIsRelax
void SCIPlpSetRootLPIsRelax(SCIP_LP *lp, SCIP_Bool isrelax)
Definition: lp.c:17346
SCIProwRecalcLPActivity
void SCIProwRecalcLPActivity(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:6079
SCIPcolDelCoef
SCIP_RETCODE SCIPcolDelCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row)
Definition: lp.c:3405
SCIProwGetLPEfficacy
SCIP_Real SCIProwGetLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:6715
SCIPlpFreeState
SCIP_RETCODE SCIPlpFreeState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
Definition: lp.c:9991
SCIPlpSetNorms
SCIP_RETCODE SCIPlpSetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS *lpinorms)
Definition: lp.c:10032
SCIP_Var
Definition: struct_var.h:198
SCIPlpFlush
SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
Definition: lp.c:8578
SCIProwIncCoef
SCIP_RETCODE SCIProwIncCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real incval)
Definition: lp.c:5435
SCIPlpRemoveAllObsoletes
SCIP_RETCODE SCIPlpRemoveAllObsoletes(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:15389
SCIPlpShrinkRows
SCIP_RETCODE SCIPlpShrinkRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int newnrows)
Definition: lp.c:9597
SCIProwGetLPSolCutoffDistance
SCIP_Real SCIProwGetLPSolCutoffDistance(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_LP *lp)
Definition: lp.c:6658
SCIPlpRecordOldRowSideDive
SCIP_RETCODE SCIPlpRecordOldRowSideDive(SCIP_LP *lp, SCIP_ROW *row, SCIP_SIDETYPE sidetype)
Definition: lp.c:15998
SCIPlpCleanupAll
SCIP_RETCODE SCIPlpCleanupAll(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool root)
Definition: lp.c:15597
SCIProwGetSolFeasibility
SCIP_Real SCIProwGetSolFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6415
SCIPcolGetStrongbranchLast
void SCIPcolGetStrongbranchLast(SCIP_COL *col, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
Definition: lp.c:4630
SCIP_LPINORMS
struct SCIP_LPiNorms SCIP_LPINORMS
Definition: type_lpi.h:98
SCIP_EventFilter
Definition: struct_event.h:170
SCIPcolCreate
SCIP_RETCODE SCIPcolCreate(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, int len, SCIP_ROW **rows, SCIP_Real *vals, SCIP_Bool removable)
Definition: lp.c:3216
SCIPlpSetState
SCIP_RETCODE SCIPlpSetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LPISTATE *lpistate, SCIP_Bool wasprimfeas, SCIP_Bool wasprimchecked, SCIP_Bool wasdualfeas, SCIP_Bool wasdualchecked)
Definition: lp.c:9949
SCIProwGetMaxidx
int SCIProwGetMaxidx(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6610
SCIP_Messagehdlr
Definition: struct_message.h:36
SCIPlpComputeRelIntPoint
SCIP_RETCODE SCIPlpComputeRelIntPoint(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_LP *lp, SCIP_PROB *prob, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_Real *point, SCIP_Bool *success)
Definition: lp.c:18230
SCIPlpFreeNorms
SCIP_RETCODE SCIPlpFreeNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
Definition: lp.c:10052
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIPlpGetNNewrows
int SCIPlpGetNNewrows(SCIP_LP *lp)
Definition: lp.c:17292
SCIProwChgLhs
SCIP_RETCODE SCIProwChgLhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real lhs)
Definition: lp.c:5573
SCIPlpEndDive
SCIP_RETCODE SCIPlpEndDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_VAR **vars, int nvars)
Definition: lp.c:15816
SCIProwMakeIntegral
SCIP_RETCODE SCIProwMakeIntegral(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)
Definition: lp.c:5888
type_set.h
type definitions for global SCIP settings
SCIProwIsRedundant
SCIP_Bool SCIProwIsRedundant(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6547
SCIPlpDiving
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
Definition: lp.c:17474
SCIPlpGetPseudoObjval
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13101
SCIPlpGetDualfarkas
SCIP_RETCODE SCIPlpGetDualfarkas(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *valid)
Definition: lp.c:14761
SCIP_Prob
Definition: struct_prob.h:39
SCIPlpRecalculateObjSqrNorm
void SCIPlpRecalculateObjSqrNorm(SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:17303
SCIPlpStartDive
SCIP_RETCODE SCIPlpStartDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:15710
SCIPlpStartProbing
SCIP_RETCODE SCIPlpStartProbing(SCIP_LP *lp)
Definition: lp.c:16022
SCIPlpWriteMip
SCIP_RETCODE SCIPlpWriteMip(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *fname, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, SCIP_Bool lazyconss)
Definition: lp.c:16249
SCIP_LPSOLSTAT
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
SCIPlpGetRootObjval
SCIP_Real SCIPlpGetRootObjval(SCIP_LP *lp)
Definition: lp.c:17367
SCIProwEnsureSize
SCIP_RETCODE SCIProwEnsureSize(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
Definition: lp.c:612
SCIPlpGetCutoffbound
SCIP_Real SCIPlpGetCutoffbound(SCIP_LP *lp)
Definition: lp.c:10066
SCIProwCreate
SCIP_RETCODE SCIProwCreate(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_ROWORIGINTYPE origintype, void *origin, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: lp.c:5033
SCIPlpUpdateAges
SCIP_RETCODE SCIPlpUpdateAges(SCIP_LP *lp, SCIP_STAT *stat)
Definition: lp.c:14949
SCIProwChgCoef
SCIP_RETCODE SCIProwChgCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real val)
Definition: lp.c:5383
SCIPlpAddCol
SCIP_RETCODE SCIPlpAddCol(SCIP_LP *lp, SCIP_SET *set, SCIP_COL *col, int depth)
Definition: lp.c:9342
SCIPlpGetNCols
int SCIPlpGetNCols(SCIP_LP *lp)
Definition: lp.c:17229
SCIPlpShrinkCols
SCIP_RETCODE SCIPlpShrinkCols(SCIP_LP *lp, SCIP_SET *set, int newncols)
Definition: lp.c:9525
SCIPlpWrite
SCIP_RETCODE SCIPlpWrite(SCIP_LP *lp, const char *fname)
Definition: lp.c:16234
type_stat.h
type definitions for problem statistics
SCIPcolGetStrongbranchLPAge
SCIP_Longint SCIPcolGetStrongbranchLPAge(SCIP_COL *col, SCIP_STAT *stat)
Definition: lp.c:4662
SCIPlpCalcStrongCG
SCIP_RETCODE SCIPlpCalcStrongCG(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, int maxmksetcoefs, SCIP_Real maxweightrange, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real *weights, int *rowinds, int nrowinds, SCIP_Real scale, SCIP_Real *strongcgcoef, SCIP_Real *strongcgrhs, SCIP_Real *cutactivity, SCIP_Bool *success, SCIP_Bool *cutislocal, int *cutrank)
SCIP_Col
Definition: struct_lp.h:126
type_lp.h
type definitions for LP management
SCIP_Sol
Definition: struct_sol.h:63
SCIPlpGetNRows
int SCIPlpGetNRows(SCIP_LP *lp)
Definition: lp.c:17249
SCIPlpDecNLoosevars
void SCIPlpDecNLoosevars(SCIP_LP *lp)
Definition: lp.c:14129
SCIP_Set
Definition: struct_set.h:61
SCIPlpCleanupNew
SCIP_RETCODE SCIPlpCleanupNew(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool root)
Definition: lp.c:15558
SCIPlpGetUnboundedSol
SCIP_RETCODE SCIPlpGetUnboundedSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *rayfeasible)
Definition: lp.c:14441
SCIProwCatchEvent
SCIP_RETCODE SCIProwCatchEvent(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: lp.c:7740
SCIPlpGetObjval
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:12918
SCIPlpGetObjNorm
SCIP_Real SCIPlpGetObjNorm(SCIP_LP *lp)
Definition: lp.c:17334
SCIPlpUpdateVarUbGlobal
SCIP_RETCODE SCIPlpUpdateVarUbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)
Definition: lp.c:13759
SCIProwRelease
SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:5259
SCIProwChgLocal
SCIP_RETCODE SCIProwChgLocal(SCIP_ROW *row, SCIP_Bool local)
Definition: lp.c:5637
SCIPlpSolveAndEval
SCIP_RETCODE SCIPlpSolveAndEval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_Longint itlim, SCIP_Bool limitresolveiters, SCIP_Bool aging, SCIP_Bool keepsol, SCIP_Bool *lperror)
Definition: lp.c:12222
SCIPcolCalcRedcost
SCIP_Real SCIPcolCalcRedcost(SCIP_COL *col, SCIP_Real *dualsol)
Definition: lp.c:3784
SCIPlpIsRootLPRelax
SCIP_Bool SCIPlpIsRootLPRelax(SCIP_LP *lp)
Definition: lp.c:17357
SCIP_RealArray
Definition: struct_misc.h:147
SCIPlpRecomputeLocalAndGlobalPseudoObjval
void SCIPlpRecomputeLocalAndGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13001
SCIPlpRemoveNewObsoletes
SCIP_RETCODE SCIPlpRemoveNewObsoletes(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:15358
SCIPlpUpdateVarUb
SCIP_RETCODE SCIPlpUpdateVarUb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)
Definition: lp.c:13786
SCIProwGetMinidx
int SCIProwGetMinidx(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6626
SCIPlpStartStrongbranch
SCIP_RETCODE SCIPlpStartStrongbranch(SCIP_LP *lp)
Definition: lp.c:4117
SCIPcolIncCoef
SCIP_RETCODE SCIPcolIncCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real incval)
Definition: lp.c:3501
SCIPcolChgLb
SCIP_RETCODE SCIPcolChgLb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newlb)
Definition: lp.c:3694
SCIPlpGetCols
SCIP_COL ** SCIPlpGetCols(SCIP_LP *lp)
Definition: lp.c:17219
SCIProwPrint
void SCIProwPrint(SCIP_ROW *row, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: lp.c:5206
SCIP_EVENTDATA
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:155
SCIPlpGetSolstat
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
Definition: lp.c:12902
SCIP_LPISTATE
struct SCIP_LPiState SCIP_LPISTATE
Definition: type_lpi.h:97
SCIPlpGetBase
SCIP_RETCODE SCIPlpGetBase(SCIP_LP *lp, int *cstat, int *rstat)
Definition: lp.c:9725
SCIPlpIsPrimalReliable
SCIP_Bool SCIPlpIsPrimalReliable(SCIP_LP *lp)
Definition: lp.c:17444
SCIPlpIsDualReliable
SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)
Definition: lp.c:17454
SCIPlpDivingObjChanged
SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)
Definition: lp.c:17484
SCIProwGetPseudoFeasibility
SCIP_Real SCIProwGetPseudoFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6357
SCIPlpGetLPI
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
Definition: lp.c:17401
SCIPcolAddCoef
SCIP_RETCODE SCIPcolAddCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
Definition: lp.c:3384
SCIPlpGetNNewcols
int SCIPlpGetNNewcols(SCIP_LP *lp)
Definition: lp.c:17270
SCIPcolPrint
void SCIPcolPrint(SCIP_COL *col, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: lp.c:3344
type_var.h
type definitions for problem variables
SCIProwGetNumIntCols
int SCIProwGetNumIntCols(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6642
SCIPlpFree
SCIP_RETCODE SCIPlpFree(SCIP_LP **lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:9264
SCIProwDelCoef
SCIP_RETCODE SCIProwDelCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col)
Definition: lp.c:5337
SCIPlpGetModifiedPseudoObjval
SCIP_Real SCIPlpGetModifiedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
Definition: lp.c:13131
SCIProwForceSort
void SCIProwForceSort(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6066
SCIProwDropEvent
SCIP_RETCODE SCIProwDropEvent(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: lp.c:7764
SCIProwGetMinActivity
SCIP_Real SCIProwGetMinActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6505
SCIProwIsSolEfficacious
SCIP_Bool SCIProwIsSolEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool root)
Definition: lp.c:6815
SCIP_Bool
#define SCIP_Bool
Definition: def.h:70
SCIPlpGetNewrows
SCIP_ROW ** SCIPlpGetNewrows(SCIP_LP *lp)
Definition: lp.c:17281
SCIPlpMarkFlushed
SCIP_RETCODE SCIPlpMarkFlushed(SCIP_LP *lp, SCIP_SET *set)
Definition: lp.c:8639
SCIPlpMarkSize
void SCIPlpMarkSize(SCIP_LP *lp)
Definition: lp.c:9682
SCIPlpGetLooseObjval
SCIP_Real SCIPlpGetLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:12957
SCIPlpGetBInvRow
SCIP_RETCODE SCIPlpGetBInvRow(SCIP_LP *lp, int r, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9742
SCIP_OBJSENSE
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:41
SCIProwGetRelaxEfficacy
SCIP_Real SCIProwGetRelaxEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6831
SCIProwDelaySort
void SCIProwDelaySort(SCIP_ROW *row)
Definition: lp.c:6055
SCIPcolChgUb
SCIP_RETCODE SCIPcolChgUb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newub)
Definition: lp.c:3739
SCIProwGetLPFeasibility
SCIP_Real SCIProwGetLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:6161
SCIP_Row
Definition: struct_lp.h:192
SCIPcolGetStrongbranches
SCIP_RETCODE SCIPcolGetStrongbranches(SCIP_COL **cols, int ncols, SCIP_Bool integral, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *lperror)
Definition: lp.c:4394
SCIPlpSumRows
SCIP_RETCODE SCIPlpSumRows(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
Definition: lp.c:9839
SCIProwGetSolActivity
SCIP_Real SCIProwGetSolActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6373
pub_lp.h
public methods for LP management
SCIProwGetObjParallelism
SCIP_Real SCIProwGetObjParallelism(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:7707
SCIPlpGetBasisInd
SCIP_RETCODE SCIPlpGetBasisInd(SCIP_LP *lp, int *basisind)
Definition: lp.c:9708
SCIPlpMarkDivingObjChanged
void SCIPlpMarkDivingObjChanged(SCIP_LP *lp)
Definition: lp.c:17494
SCIProwGetNLPFeasibility
SCIP_Real SCIProwGetNLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6243
SCIProwGetSolEfficacy
SCIP_Real SCIProwGetSolEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6772
SCIPlpClear
SCIP_RETCODE SCIPlpClear(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:9663
SCIPlpAddRow
SCIP_RETCODE SCIPlpAddRow(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_ROW *row, int depth)
Definition: lp.c:9401
SCIPcolSetStrongbranchData
void SCIPcolSetStrongbranchData(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real sbdown, SCIP_Real sbup, SCIP_Bool sbdownvalid, SCIP_Bool sbupvalid, SCIP_Longint iter, int itlim)
Definition: lp.c:4147
SCIPlpGetNorms
SCIP_RETCODE SCIPlpGetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
Definition: lp.c:10008
SCIPlpSetCutoffbound
SCIP_RETCODE SCIPlpSetCutoffbound(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real cutoffbound)
Definition: lp.c:10076
SCIProwGetMaxActivity
SCIP_Real SCIProwGetMaxActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6526
type_sol.h
type definitions for storing primal CIP solutions
SCIPcolGetFarkasValue
SCIP_Real SCIPcolGetFarkasValue(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:4098
type_prob.h
type definitions for storing and manipulating the main problem
SCIPlpUpdateVarObj
SCIP_RETCODE SCIPlpUpdateVarObj(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)
Definition: lp.c:13637
SCIPlpGetRootLooseObjval
SCIP_Real SCIPlpGetRootLooseObjval(SCIP_LP *lp)
Definition: lp.c:17391
SCIPlpUpdateVarLoose
SCIP_RETCODE SCIPlpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
Definition: lp.c:14108
r
SCIP_Real * r
Definition: circlepacking.c:50
SCIProwAddCoef
SCIP_RETCODE SCIProwAddCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real val)
Definition: lp.c:5316
SCIPlpIsSolved
SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)
Definition: lp.c:17434
SCIPlpSetSizeMark
void SCIPlpSetSizeMark(SCIP_LP *lp, int nrows, int ncols)
Definition: lp.c:9694
SCIPlpIsRelax
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
Definition: lp.c:17424
SCIPlpStoreRootObjval
void SCIPlpStoreRootObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:12977
SCIP_Lp
Definition: struct_lp.h:259
SCIProwFree
SCIP_RETCODE SCIProwFree(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:5174
SCIPlpReset
SCIP_RETCODE SCIPlpReset(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:9309
SCIPlpCreate
SCIP_RETCODE SCIPlpCreate(SCIP_LP **lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *name)
Definition: lp.c:8983
struct_lp.h
data structures for LP management
SCIP_LPI
struct SCIP_LPi SCIP_LPI
Definition: type_lpi.h:96
SCIP_Real
#define SCIP_Real
Definition: def.h:164
SCIPlpRemoveRedundantRows
SCIP_RETCODE SCIPlpRemoveRedundantRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:15636
SCIProwIsLPEfficacious
SCIP_Bool SCIProwIsLPEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool root)
Definition: lp.c:6756
SCIPcolFree
SCIP_RETCODE SCIPcolFree(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: lp.c:3314
SCIPcolInvalidateStrongbranchData
void SCIPcolInvalidateStrongbranchData(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:4201
SCIPlpUpdateDelVar
SCIP_RETCODE SCIPlpUpdateDelVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
Definition: lp.c:13848
SCIPcolGetStrongbranch
SCIP_RETCODE SCIPcolGetStrongbranch(SCIP_COL *col, SCIP_Bool integral, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *lperror)
Definition: lp.c:4236
SCIProwMarkNotRemovableLocal
void SCIProwMarkNotRemovableLocal(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:7785
SCIP_Longint
#define SCIP_Longint
Definition: def.h:149
SCIPlpGetColumnObjval
SCIP_Real SCIPlpGetColumnObjval(SCIP_LP *lp)
Definition: lp.c:12946
SCIProwRecalcPseudoActivity
void SCIProwRecalcPseudoActivity(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:6302
SCIPlpEndStrongbranch
SCIP_RETCODE SCIPlpEndStrongbranch(SCIP_LP *lp)
Definition: lp.c:4132
SCIPlpInvalidateRootObjval
void SCIPlpInvalidateRootObjval(SCIP_LP *lp)
Definition: lp.c:12990
SCIP_Stat
Definition: struct_stat.h:50
SCIPlpDivingRowsChanged
SCIP_Bool SCIPlpDivingRowsChanged(SCIP_LP *lp)
Definition: lp.c:17516
def.h
common defines and data types used in all packages of SCIP
SCIP_EventQueue
Definition: struct_event.h:205
BMS_BLKMEM
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:427
SCIProwChgRhs
SCIP_RETCODE SCIProwChgRhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real rhs)
Definition: lp.c:5605
SCIPlpUnmarkDivingObjChanged
void SCIPlpUnmarkDivingObjChanged(SCIP_LP *lp)
Definition: lp.c:17505
SCIProwCalcIntegralScalar
SCIP_RETCODE SCIProwCalcIntegralScalar(SCIP_ROW *row, SCIP_SET *set, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Real *intscalar, SCIP_Bool *success)
Definition: lp.c:5654
SCIProwGetMinval
SCIP_Real SCIProwGetMinval(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6594
SCIPlpCalcMIR
SCIP_RETCODE SCIPlpCalcMIR(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_SOL *sol, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Bool fixintegralrhs, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, int maxmksetcoefs, SCIP_Real maxweightrange, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real *weights, SCIP_Real maxweight, int *weightinds, int nweightinds, int rowlensum, int *sidetypes, SCIP_Real scale, SCIP_Real *mksetcoefs, SCIP_Bool *mksetcoefsvalid, SCIP_Real *mircoef, SCIP_Real *mirrhs, SCIP_Real *cutactivity, SCIP_Bool *success, SCIP_Bool *cutislocal, int *cutrank)
SCIProwAddConstant
SCIP_RETCODE SCIProwAddConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real addval)
Definition: lp.c:5547
SCIProwGetRelaxFeasibility
SCIP_Real SCIProwGetRelaxFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6181
SCIP_Eventhdlr
Definition: struct_event.h:186
SCIPlpUpdateAddVar
SCIP_RETCODE SCIPlpUpdateAddVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
Definition: lp.c:13827
SCIPcolGetFeasibility
SCIP_Real SCIPcolGetFeasibility(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:3913
SCIPlpGetGlobalPseudoObjval
SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13069
SCIP_EVENTTYPE
uint64_t SCIP_EVENTTYPE
Definition: type_event.h:134
SCIPlpGetPrimalRay
SCIP_RETCODE SCIPlpGetPrimalRay(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *ray)
Definition: lp.c:14700
memory.h
memory allocation routines
SCIP_SIDETYPE
enum SCIP_SideType SCIP_SIDETYPE
Definition: type_lp.h:58