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-2022 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file 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/type_branch.h"
43 #include "scip/pub_lp.h"
44 
45 #include "scip/struct_lp.h"
46 
47 #ifdef __cplusplus
48 extern "C" {
49 #endif
50 
51 /*
52  * Column methods
53  */
54 
55 /** creates an LP column */
56 SCIP_RETCODE SCIPcolCreate(
57  SCIP_COL** col, /**< pointer to column data */
58  BMS_BLKMEM* blkmem, /**< block memory */
59  SCIP_SET* set, /**< global SCIP settings */
60  SCIP_STAT* stat, /**< problem statistics */
61  SCIP_VAR* var, /**< variable, this column represents */
62  int len, /**< number of nonzeros in the column */
63  SCIP_ROW** rows, /**< array with rows of column entries */
64  SCIP_Real* vals, /**< array with coefficients of column entries */
65  SCIP_Bool removable /**< should the column be removed from the LP due to aging or cleanup? */
66  );
67 
68 /** frees an LP column */
69 SCIP_RETCODE SCIPcolFree(
70  SCIP_COL** col, /**< pointer to LP column */
71  BMS_BLKMEM* blkmem, /**< block memory */
72  SCIP_SET* set, /**< global SCIP settings */
73  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
74  SCIP_LP* lp /**< current LP data */
75  );
76 
77 /** output column to file stream */
78 void SCIPcolPrint(
79  SCIP_COL* col, /**< LP column */
80  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
81  FILE* file /**< output file (or NULL for standard output) */
82  );
83 
84 /** adds a previously non existing coefficient to an LP column */
85 SCIP_RETCODE SCIPcolAddCoef(
86  SCIP_COL* col, /**< LP column */
87  BMS_BLKMEM* blkmem, /**< block memory */
88  SCIP_SET* set, /**< global SCIP settings */
89  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
90  SCIP_LP* lp, /**< current LP data */
91  SCIP_ROW* row, /**< LP row */
92  SCIP_Real val /**< value of coefficient */
93  );
94 
95 /** deletes coefficient from column */
96 SCIP_RETCODE SCIPcolDelCoef(
97  SCIP_COL* col, /**< column to be changed */
98  BMS_BLKMEM* blkmem, /**< block memory */
99  SCIP_SET* set, /**< global SCIP settings */
100  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
101  SCIP_LP* lp, /**< current LP data */
102  SCIP_ROW* row /**< coefficient to be deleted */
103  );
104 
105 /** changes or adds a coefficient to an LP column */
106 SCIP_RETCODE SCIPcolChgCoef(
107  SCIP_COL* col, /**< LP column */
108  BMS_BLKMEM* blkmem, /**< block memory */
109  SCIP_SET* set, /**< global SCIP settings */
110  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
111  SCIP_LP* lp, /**< current LP data */
112  SCIP_ROW* row, /**< LP row */
113  SCIP_Real val /**< value of coefficient */
114  );
115 
116 /** increases value of an existing or nonexisting coefficient in an LP column */
117 SCIP_RETCODE SCIPcolIncCoef(
118  SCIP_COL* col, /**< LP column */
119  BMS_BLKMEM* blkmem, /**< block memory */
120  SCIP_SET* set, /**< global SCIP settings */
121  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
122  SCIP_LP* lp, /**< current LP data */
123  SCIP_ROW* row, /**< LP row */
124  SCIP_Real incval /**< value to add to the coefficient */
125  );
126 
127 /** changes objective value of column */
128 SCIP_RETCODE SCIPcolChgObj(
129  SCIP_COL* col, /**< LP column to change */
130  SCIP_SET* set, /**< global SCIP settings */
131  SCIP_LP* lp, /**< current LP data */
132  SCIP_Real newobj /**< new objective value */
133  );
134 
135 /** changes lower bound of column */
136 SCIP_RETCODE SCIPcolChgLb(
137  SCIP_COL* col, /**< LP column to change */
138  SCIP_SET* set, /**< global SCIP settings */
139  SCIP_LP* lp, /**< current LP data */
140  SCIP_Real newlb /**< new lower bound value */
141  );
142 
143 /** changes upper bound of column */
144 SCIP_RETCODE SCIPcolChgUb(
145  SCIP_COL* col, /**< LP column to change */
146  SCIP_SET* set, /**< global SCIP settings */
147  SCIP_LP* lp, /**< current LP data */
148  SCIP_Real newub /**< new upper bound value */
149  );
150 
151 /** calculates the reduced costs of a column using the given dual solution vector */
152 SCIP_Real SCIPcolCalcRedcost(
153  SCIP_COL* col, /**< LP column */
154  SCIP_Real* dualsol /**< dual solution vector for current LP rows */
155  );
156 
157 /** gets the reduced costs of a column in last LP or after recalculation */
158 SCIP_Real SCIPcolGetRedcost(
159  SCIP_COL* col, /**< LP column */
160  SCIP_STAT* stat, /**< problem statistics */
161  SCIP_LP* lp /**< current LP data */
162  );
163 
164 /** gets the feasibility of (the dual row of) a column in last LP or after recalculation */
165 SCIP_Real SCIPcolGetFeasibility(
166  SCIP_COL* col, /**< LP column */
167  SCIP_SET* set, /**< global SCIP settings */
168  SCIP_STAT* stat, /**< problem statistics */
169  SCIP_LP* lp /**< current LP data */
170  );
171 
172 /** calculates the Farkas coefficient y^T A_i of a column i using the given dual Farkas vector y */
173 SCIP_Real SCIPcolCalcFarkasCoef(
174  SCIP_COL* col, /**< LP column */
175  SCIP_Real* dualfarkas /**< dense dual Farkas vector for current LP rows */
176  );
177 
178 /** gets the Farkas coefficient y^T A_i of a column i in last LP (which must be infeasible) */
179 SCIP_Real SCIPcolGetFarkasCoef(
180  SCIP_COL* col, /**< LP column */
181  SCIP_STAT* stat, /**< problem statistics */
182  SCIP_LP* lp /**< current LP data */
183  );
184 
185 /** gets the Farkas value of a column in last LP (which must be infeasible), i.e. the Farkas coefficient y^T A_i times
186  * the best bound for this coefficient, i.e. max{y^T A_i x_i | lb <= x_i <= ub}
187  */
188 SCIP_Real SCIPcolGetFarkasValue(
189  SCIP_COL* col, /**< LP column */
190  SCIP_STAT* stat, /**< problem statistics */
191  SCIP_LP* lp /**< current LP data */
192  );
193 
194 /** start strong branching - call before any strong branching */
195 SCIP_RETCODE SCIPlpStartStrongbranch(
196  SCIP_LP* lp /**< LP data */
197  );
198 
199 /** end strong branching - call after any strong branching */
200 SCIP_RETCODE SCIPlpEndStrongbranch(
201  SCIP_LP* lp /**< LP data */
202  );
203 
204 /** sets strong branching information for a column variable */
205 void SCIPcolSetStrongbranchData(
206  SCIP_COL* col, /**< LP column */
207  SCIP_SET* set, /**< global SCIP settings */
208  SCIP_STAT* stat, /**< dynamic problem statistics */
209  SCIP_LP* lp, /**< LP data */
210  SCIP_Real lpobjval, /**< objective value of the current LP */
211  SCIP_Real primsol, /**< primal solution value of the column in the current LP */
212  SCIP_Real sbdown, /**< dual bound after branching column down */
213  SCIP_Real sbup, /**< dual bound after branching column up */
214  SCIP_Bool sbdownvalid, /**< is the returned down value a valid dual bound? */
215  SCIP_Bool sbupvalid, /**< is the returned up value a valid dual bound? */
216  SCIP_Longint iter, /**< total number of strong branching iterations */
217  int itlim /**< iteration limit applied to the strong branching call */
218  );
219 
220 /** invalidates strong branching information for a column variable */
221 void SCIPcolInvalidateStrongbranchData(
222  SCIP_COL* col, /**< LP column */
223  SCIP_SET* set, /**< global SCIP settings */
224  SCIP_STAT* stat, /**< dynamic problem statistics */
225  SCIP_LP* lp /**< LP data */
226  );
227 
228 /** gets strong branching information on a column variable */
229 SCIP_RETCODE SCIPcolGetStrongbranch(
230  SCIP_COL* col, /**< LP column */
231  SCIP_Bool integral, /**< should integral strong branching be performed? */
232  SCIP_SET* set, /**< global SCIP settings */
233  SCIP_STAT* stat, /**< dynamic problem statistics */
234  SCIP_PROB* prob, /**< problem data */
235  SCIP_LP* lp, /**< LP data */
236  int itlim, /**< iteration limit for strong branchings */
237  SCIP_Bool updatecol, /**< should col be updated, or should it stay in its current state ? */
238  SCIP_Bool updatestat, /**< should stat be updated, or should it stay in its current state ? */
239  SCIP_Real* down, /**< stores dual bound after branching column down */
240  SCIP_Real* up, /**< stores dual bound after branching column up */
241  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
242  * otherwise, it can only be used as an estimate value */
243  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
244  * otherwise, it can only be used as an estimate value */
245  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */
246  );
247 
248 /** gets strong branching information on column variables */
249 SCIP_RETCODE SCIPcolGetStrongbranches(
250  SCIP_COL** cols, /**< LP columns */
251  int ncols, /**< number of columns */
252  SCIP_Bool integral, /**< should integral strong branching be performed? */
253  SCIP_SET* set, /**< global SCIP settings */
254  SCIP_STAT* stat, /**< dynamic problem statistics */
255  SCIP_PROB* prob, /**< problem data */
256  SCIP_LP* lp, /**< LP data */
257  int itlim, /**< iteration limit for strong branchings */
258  SCIP_Real* down, /**< stores dual bounds after branching columns down */
259  SCIP_Real* up, /**< stores dual bounds after branching columns up */
260  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
261  * otherwise, they can only be used as an estimate value */
262  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
263  * otherwise, they can only be used as an estimate value */
264  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */
265  );
266 
267 /** gets last strong branching information available for a column variable;
268  * returns values of SCIP_INVALID, if strong branching was not yet called on the given column;
269  * keep in mind, that the returned old values may have nothing to do with the current LP solution
270  */
271 void SCIPcolGetStrongbranchLast(
272  SCIP_COL* col, /**< LP column */
273  SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
274  SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
275  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
276  * otherwise, it can only be used as an estimate value */
277  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
278  * otherwise, it can only be used as an estimate value */
279  SCIP_Real* solval, /**< stores LP solution value of column at last strong branching call, or NULL */
280  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
281  );
282 
283 /** if strong branching was already applied on the column at the current node, returns the number of LPs solved after
284  * the LP where the strong branching on this column was applied;
285  * if strong branching was not yet applied on the column at the current node, returns INT_MAX
286  */
287 SCIP_Longint SCIPcolGetStrongbranchLPAge(
288  SCIP_COL* col, /**< LP column */
289  SCIP_STAT* stat /**< dynamic problem statistics */
290  );
291 
292 /** marks a column to be not removable from the LP in the current node because it became obsolete */
293 void SCIPcolMarkNotRemovableLocal(
294  SCIP_COL* col, /**< LP column */
295  SCIP_STAT* stat /**< problem statistics */
296  );
297 
298 
299 /*
300  * Row methods
301  */
302 
303 /** creates and captures an LP row */
304 SCIP_RETCODE SCIProwCreate(
305  SCIP_ROW** row, /**< pointer to LP row data */
306  BMS_BLKMEM* blkmem, /**< block memory */
307  SCIP_SET* set, /**< global SCIP settings */
308  SCIP_STAT* stat, /**< problem statistics */
309  const char* name, /**< name of row */
310  int len, /**< number of nonzeros in the row */
311  SCIP_COL** cols, /**< array with columns of row entries */
312  SCIP_Real* vals, /**< array with coefficients of row entries */
313  SCIP_Real lhs, /**< left hand side of row */
314  SCIP_Real rhs, /**< right hand side of row */
315  SCIP_ROWORIGINTYPE origintype, /**< type of origin of row */
316  void* origin, /**< pointer to constraint handler or separator who created the row (NULL if unkown) */
317  SCIP_Bool local, /**< is row only valid locally? */
318  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
319  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
320  );
321 
322 /** frees an LP row */
323 SCIP_RETCODE SCIProwFree(
324  SCIP_ROW** row, /**< pointer to LP row */
325  BMS_BLKMEM* blkmem, /**< block memory */
326  SCIP_SET* set, /**< global SCIP settings */
327  SCIP_LP* lp /**< current LP data */
328  );
329 
330 /** output row to file stream */
331 void SCIProwPrint(
332  SCIP_ROW* row, /**< LP row */
333  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
334  FILE* file /**< output file (or NULL for standard output) */
335  );
336 
337 /** ensures, that column array of row can store at least num entries */
338 SCIP_RETCODE SCIProwEnsureSize(
339  SCIP_ROW* row, /**< LP row */
340  BMS_BLKMEM* blkmem, /**< block memory */
341  SCIP_SET* set, /**< global SCIP settings */
342  int num /**< minimum number of entries to store */
343  );
344 
345 /** increases usage counter of LP row */
346 void SCIProwCapture(
347  SCIP_ROW* row /**< LP row */
348  );
349 
350 /** decreases usage counter of LP row, and frees memory if necessary */
351 SCIP_RETCODE SCIProwRelease(
352  SCIP_ROW** row, /**< pointer to LP row */
353  BMS_BLKMEM* blkmem, /**< block memory */
354  SCIP_SET* set, /**< global SCIP settings */
355  SCIP_LP* lp /**< current LP data */
356  );
357 
358 /** enables delaying of row sorting */
359 void SCIProwDelaySort(
360  SCIP_ROW* row /**< LP row */
361  );
362 
363 /** disables delaying of row sorting, sorts row and merges coefficients with equal columns */
364 void SCIProwForceSort(
365  SCIP_ROW* row, /**< LP row */
366  SCIP_SET* set /**< global SCIP settings */
367  );
368 
369 /** adds a previously non existing coefficient to an LP row */
370 SCIP_RETCODE SCIProwAddCoef(
371  SCIP_ROW* row, /**< LP row */
372  BMS_BLKMEM* blkmem, /**< block memory */
373  SCIP_SET* set, /**< global SCIP settings */
374  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
375  SCIP_LP* lp, /**< current LP data */
376  SCIP_COL* col, /**< LP column */
377  SCIP_Real val /**< value of coefficient */
378  );
379 
380 /** deletes coefficient from row */
381 SCIP_RETCODE SCIProwDelCoef(
382  SCIP_ROW* row, /**< LP row */
383  BMS_BLKMEM* blkmem, /**< block memory */
384  SCIP_SET* set, /**< global SCIP settings */
385  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
386  SCIP_LP* lp, /**< current LP data */
387  SCIP_COL* col /**< coefficient to be deleted */
388  );
389 
390 /** changes or adds a coefficient to an LP row */
391 SCIP_RETCODE SCIProwChgCoef(
392  SCIP_ROW* row, /**< LP row */
393  BMS_BLKMEM* blkmem, /**< block memory */
394  SCIP_SET* set, /**< global SCIP settings */
395  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
396  SCIP_LP* lp, /**< current LP data */
397  SCIP_COL* col, /**< LP column */
398  SCIP_Real val /**< value of coefficient */
399  );
400 
401 /** increases value of an existing or nonexisting coefficient in an LP column */
402 SCIP_RETCODE SCIProwIncCoef(
403  SCIP_ROW* row, /**< LP row */
404  BMS_BLKMEM* blkmem, /**< block memory */
405  SCIP_SET* set, /**< global SCIP settings */
406  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
407  SCIP_LP* lp, /**< current LP data */
408  SCIP_COL* col, /**< LP column */
409  SCIP_Real incval /**< value to add to the coefficient */
410  );
411 
412 /** changes constant value of a row */
413 SCIP_RETCODE SCIProwChgConstant(
414  SCIP_ROW* row, /**< LP row */
415  BMS_BLKMEM* blkmem, /**< block memory */
416  SCIP_SET* set, /**< global SCIP settings */
417  SCIP_STAT* stat, /**< problem statistics */
418  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
419  SCIP_LP* lp, /**< current LP data */
420  SCIP_Real constant /**< new constant value */
421  );
422 
423 /** add constant value to a row */
424 SCIP_RETCODE SCIProwAddConstant(
425  SCIP_ROW* row, /**< LP row */
426  BMS_BLKMEM* blkmem, /**< block memory */
427  SCIP_SET* set, /**< global SCIP settings */
428  SCIP_STAT* stat, /**< problem statistics */
429  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
430  SCIP_LP* lp, /**< current LP data */
431  SCIP_Real addval /**< constant value to add to the row */
432  );
433 
434 /** changes left hand side of LP row */
435 SCIP_RETCODE SCIProwChgLhs(
436  SCIP_ROW* row, /**< LP row */
437  BMS_BLKMEM* blkmem, /**< block memory */
438  SCIP_SET* set, /**< global SCIP settings */
439  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
440  SCIP_LP* lp, /**< current LP data */
441  SCIP_Real lhs /**< new left hand side */
442  );
443 
444 /** changes right hand side of LP row */
445 SCIP_RETCODE SCIProwChgRhs(
446  SCIP_ROW* row, /**< LP row */
447  BMS_BLKMEM* blkmem, /**< block memory */
448  SCIP_SET* set, /**< global SCIP settings */
449  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
450  SCIP_LP* lp, /**< current LP data */
451  SCIP_Real rhs /**< new right hand side */
452  );
453 
454 /** changes the local flag of LP row */
455 SCIP_RETCODE SCIProwChgLocal(
456  SCIP_ROW* row, /**< LP row */
457  SCIP_Bool local /**< new value for local flag */
458  );
459 
460 /** tries to find a value, such that all row coefficients, if scaled with this value become integral */
461 SCIP_RETCODE SCIProwCalcIntegralScalar(
462  SCIP_ROW* row, /**< LP row */
463  SCIP_SET* set, /**< global SCIP settings */
464  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
465  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
466  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
467  SCIP_Real maxscale, /**< maximal allowed scalar */
468  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
469  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral */
470  SCIP_Bool* success /**< stores whether returned value is valid */
471  );
472 
473 /** tries to scale row, s.t. all coefficients become integral */
474 SCIP_RETCODE SCIProwMakeIntegral(
475  SCIP_ROW* row, /**< LP row */
476  BMS_BLKMEM* blkmem, /**< block memory */
477  SCIP_SET* set, /**< global SCIP settings */
478  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
479  SCIP_STAT* stat, /**< problem statistics */
480  SCIP_LP* lp, /**< current LP data */
481  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
482  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
483  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
484  SCIP_Real maxscale, /**< maximal value to scale row with */
485  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
486  SCIP_Bool* success /**< stores whether row could be made rational */
487  );
488 
489 /** recalculates the current activity of a row */
490 void SCIProwRecalcLPActivity(
491  SCIP_ROW* row, /**< LP row */
492  SCIP_STAT* stat /**< problem statistics */
493  );
494 
495 /** returns the activity of a row in the current LP solution */
496 SCIP_Real SCIProwGetLPActivity(
497  SCIP_ROW* row, /**< LP row */
498  SCIP_SET* set, /**< global SCIP settings */
499  SCIP_STAT* stat, /**< problem statistics */
500  SCIP_LP* lp /**< current LP data */
501  );
502 
503 /** returns the feasibility of a row in the current LP solution: negative value means infeasibility */
504 SCIP_Real SCIProwGetLPFeasibility(
505  SCIP_ROW* row, /**< LP row */
506  SCIP_SET* set, /**< global SCIP settings */
507  SCIP_STAT* stat, /**< problem statistics */
508  SCIP_LP* lp /**< current LP data */
509  );
510 
511 /** returns the feasibility of a row in the current relaxed solution: negative value means infeasibility */
512 SCIP_Real SCIProwGetRelaxFeasibility(
513  SCIP_ROW* row, /**< LP row */
514  SCIP_SET* set, /**< global SCIP settings */
515  SCIP_STAT* stat /**< problem statistics */
516  );
517 
518 /** returns the feasibility of a row in the current NLP solution: negative value means infeasibility */
519 SCIP_Real SCIProwGetNLPFeasibility(
520  SCIP_ROW* row, /**< LP row */
521  SCIP_SET* set, /**< global SCIP settings */
522  SCIP_STAT* stat /**< problem statistics */
523  );
524 
525 /** calculates the current pseudo activity of a row */
526 void SCIProwRecalcPseudoActivity(
527  SCIP_ROW* row, /**< row data */
528  SCIP_STAT* stat /**< problem statistics */
529  );
530 
531 /** returns the pseudo activity of a row in the current pseudo solution */
532 SCIP_Real SCIProwGetPseudoActivity(
533  SCIP_ROW* row, /**< LP row */
534  SCIP_SET* set, /**< global SCIP settings */
535  SCIP_STAT* stat /**< problem statistics */
536  );
537 
538 /** returns the pseudo feasibility of a row in the current pseudo solution: negative value means infeasibility */
539 SCIP_Real SCIProwGetPseudoFeasibility(
540  SCIP_ROW* row, /**< LP row */
541  SCIP_SET* set, /**< global SCIP settings */
542  SCIP_STAT* stat /**< problem statistics */
543  );
544 
545 /** returns the activity of a row for a given solution */
546 SCIP_Real SCIProwGetSolActivity(
547  SCIP_ROW* row, /**< LP row */
548  SCIP_SET* set, /**< global SCIP settings */
549  SCIP_STAT* stat, /**< problem statistics data */
550  SCIP_SOL* sol /**< primal CIP solution */
551  );
552 
553 /** returns the feasibility of a row for the given solution */
554 SCIP_Real SCIProwGetSolFeasibility(
555  SCIP_ROW* row, /**< LP row */
556  SCIP_SET* set, /**< global SCIP settings */
557  SCIP_STAT* stat, /**< problem statistics data */
558  SCIP_SOL* sol /**< primal CIP solution */
559  );
560 
561 /** returns the minimal activity of a row w.r.t. the columns' bounds */
562 SCIP_Real SCIProwGetMinActivity(
563  SCIP_ROW* row, /**< LP row */
564  SCIP_SET* set, /**< global SCIP settings */
565  SCIP_STAT* stat /**< problem statistics data */
566  );
567 
568 /** returns the maximal activity of a row w.r.t. the columns' bounds */
569 SCIP_Real SCIProwGetMaxActivity(
570  SCIP_ROW* row, /**< LP row */
571  SCIP_SET* set, /**< global SCIP settings */
572  SCIP_STAT* stat /**< problem statistics data */
573  );
574 
575 /** returns whether the row is unmodifiable and redundant w.r.t. the columns' bounds */
576 SCIP_Bool SCIProwIsRedundant(
577  SCIP_ROW* row, /**< LP row */
578  SCIP_SET* set, /**< global SCIP settings */
579  SCIP_STAT* stat /**< problem statistics data */
580  );
581 
582 /** gets maximal absolute value of row vector coefficients */
583 SCIP_Real SCIProwGetMaxval(
584  SCIP_ROW* row, /**< LP row */
585  SCIP_SET* set /**< global SCIP settings */
586  );
587 
588 /** gets minimal absolute value of row vector's non-zero coefficients */
589 SCIP_Real SCIProwGetMinval(
590  SCIP_ROW* row, /**< LP row */
591  SCIP_SET* set /**< global SCIP settings */
592  );
593 
594 /** gets maximal column index of row entries */
595 int SCIProwGetMaxidx(
596  SCIP_ROW* row, /**< LP row */
597  SCIP_SET* set /**< global SCIP settings */
598  );
599 
600 /** gets minimal column index of row entries */
601 int SCIProwGetMinidx(
602  SCIP_ROW* row, /**< LP row */
603  SCIP_SET* set /**< global SCIP settings */
604  );
605 
606 /** gets number of integral columns in row */
607 int SCIProwGetNumIntCols(
608  SCIP_ROW* row, /**< LP row */
609  SCIP_SET* set /**< global SCIP settings */
610  );
611 
612 /** returns row's cutoff distance in the direction of the given primal solution */
613 SCIP_Real SCIProwGetLPSolCutoffDistance(
614  SCIP_ROW* row, /**< LP row */
615  SCIP_SET* set, /**< global SCIP settings */
616  SCIP_STAT* stat, /**< problem statistics data */
617  SCIP_SOL* sol, /**< solution to compute direction for cutoff distance; must not be NULL */
618  SCIP_LP* lp /**< current LP data */
619  );
620 
621 /** returns row's efficacy with respect to the current LP solution: e = -feasibility/norm */
622 SCIP_Real SCIProwGetLPEfficacy(
623  SCIP_ROW* row, /**< LP row */
624  SCIP_SET* set, /**< global SCIP settings */
625  SCIP_STAT* stat, /**< problem statistics data */
626  SCIP_LP* lp /**< current LP data */
627  );
628 
629 /** returns whether the row's efficacy with respect to the current LP solution is greater than the minimal cut efficacy */
630 SCIP_Bool SCIProwIsLPEfficacious(
631  SCIP_ROW* row, /**< LP row */
632  SCIP_SET* set, /**< global SCIP settings */
633  SCIP_STAT* stat, /**< problem statistics data */
634  SCIP_LP* lp, /**< current LP data */
635  SCIP_Bool root /**< should the root's minimal cut efficacy be used? */
636  );
637 
638 /** returns row's efficacy with respect to the given primal solution: e = -feasibility/norm */
639 SCIP_Real SCIProwGetSolEfficacy(
640  SCIP_ROW* row, /**< LP row */
641  SCIP_SET* set, /**< global SCIP settings */
642  SCIP_STAT* stat, /**< problem statistics data */
643  SCIP_SOL* sol /**< primal CIP solution */
644  );
645 
646 /** returns whether the row's efficacy with respect to the given primal solution is greater than the minimal cut
647  * efficacy
648  */
649 SCIP_Bool SCIProwIsSolEfficacious(
650  SCIP_ROW* row, /**< LP row */
651  SCIP_SET* set, /**< global SCIP settings */
652  SCIP_STAT* stat, /**< problem statistics data */
653  SCIP_SOL* sol, /**< primal CIP solution */
654  SCIP_Bool root /**< should the root's minimal cut efficacy be used? */
655  );
656 
657 /** returns row's efficacy with respect to the relaxed solution: e = -feasibility/norm */
658 SCIP_Real SCIProwGetRelaxEfficacy(
659  SCIP_ROW* row, /**< LP row */
660  SCIP_SET* set, /**< global SCIP settings */
661  SCIP_STAT* stat /**< problem statistics data */
662  );
663 
664 /** returns row's efficacy with respect to the NLP solution: e = -feasibility/norm */
665 SCIP_Real SCIProwGetNLPEfficacy(
666  SCIP_ROW* row, /**< LP row */
667  SCIP_SET* set, /**< global SCIP settings */
668  SCIP_STAT* stat /**< problem statistics data */
669  );
670 
671 /** gets parallelism of row with objective function: if the returned value is 1, the row is parallel to the objective
672  * function, if the value is 0, it is orthogonal to the objective function
673  */
674 SCIP_Real SCIProwGetObjParallelism(
675  SCIP_ROW* row, /**< LP row */
676  SCIP_SET* set, /**< global SCIP settings */
677  SCIP_LP* lp /**< current LP data */
678  );
679 
680 /** includes event handler with given data in row's event filter */
681 SCIP_RETCODE SCIProwCatchEvent(
682  SCIP_ROW* row, /**< row */
683  BMS_BLKMEM* blkmem, /**< block memory */
684  SCIP_SET* set, /**< global SCIP settings */
685  SCIP_EVENTTYPE eventtype, /**< event type to catch */
686  SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */
687  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */
688  int* filterpos /**< pointer to store position of event filter entry, or NULL */
689  );
690 
691 /** deletes event handler with given data from row's event filter */
692 SCIP_RETCODE SCIProwDropEvent(
693  SCIP_ROW* row, /**< row */
694  BMS_BLKMEM* blkmem, /**< block memory */
695  SCIP_SET* set, /**< global SCIP settings */
696  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
697  SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */
698  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */
699  int filterpos /**< position of event filter entry returned by SCIPvarCatchEvent(), or -1 */
700  );
701 
702 /** marks a row to be not removable from the LP in the current node */
703 void SCIProwMarkNotRemovableLocal(
704  SCIP_ROW* row, /**< LP row */
705  SCIP_STAT* stat /**< problem statistics */
706  );
707 
708 
709 /*
710  * LP methods
711  */
712 
713 /** creates empty LP data object */
714 SCIP_RETCODE SCIPlpCreate(
715  SCIP_LP** lp, /**< pointer to LP data object */
716  SCIP_SET* set, /**< global SCIP settings */
717  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
718  SCIP_STAT* stat, /**< problem statistics */
719  const char* name /**< problem name */
720  );
721 
722 /** frees LP data object */
723 SCIP_RETCODE SCIPlpFree(
724  SCIP_LP** lp, /**< pointer to LP data object */
725  BMS_BLKMEM* blkmem, /**< block memory */
726  SCIP_SET* set, /**< global SCIP settings */
727  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
728  SCIP_EVENTFILTER* eventfilter /**< global event filter */
729  );
730 
731 /** resets the LP to the empty LP by removing all columns and rows from LP, releasing all rows, and flushing the
732  * changes to the LP solver
733  */
734 SCIP_RETCODE SCIPlpReset(
735  SCIP_LP* lp, /**< LP data */
736  BMS_BLKMEM* blkmem, /**< block memory */
737  SCIP_SET* set, /**< global SCIP settings */
738  SCIP_PROB* prob, /**< problem data */
739  SCIP_STAT* stat, /**< problem statistics */
740  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
741  SCIP_EVENTFILTER* eventfilter /**< global event filter */
742  );
743 
744 /** adds a column to the LP and captures the variable */
745 SCIP_RETCODE SCIPlpAddCol(
746  SCIP_LP* lp, /**< LP data */
747  SCIP_SET* set, /**< global SCIP settings */
748  SCIP_COL* col, /**< LP column */
749  int depth /**< depth in the tree where the column addition is performed */
750  );
751 
752 /** adds a row to the LP and captures it */
753 SCIP_RETCODE SCIPlpAddRow(
754  SCIP_LP* lp, /**< LP data */
755  BMS_BLKMEM* blkmem, /**< block memory buffers */
756  SCIP_SET* set, /**< global SCIP settings */
757  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
758  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
759  SCIP_ROW* row, /**< LP row */
760  int depth /**< depth in the tree where the row addition is performed */
761  );
762 
763 /** removes all columns after the given number of columns from the LP */
764 SCIP_RETCODE SCIPlpShrinkCols(
765  SCIP_LP* lp, /**< LP data */
766  SCIP_SET* set, /**< global SCIP settings */
767  int newncols /**< new number of columns in the LP */
768  );
769 
770 /** removes and releases all rows after the given number of rows from the LP */
771 SCIP_RETCODE SCIPlpShrinkRows(
772  SCIP_LP* lp, /**< LP data */
773  BMS_BLKMEM* blkmem, /**< block memory */
774  SCIP_SET* set, /**< global SCIP settings */
775  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
776  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
777  int newnrows /**< new number of rows in the LP */
778  );
779 
780 /** removes all columns and rows from LP, releases all rows */
781 SCIP_RETCODE SCIPlpClear(
782  SCIP_LP* lp, /**< LP data */
783  BMS_BLKMEM* blkmem, /**< block memory */
784  SCIP_SET* set, /**< global SCIP settings */
785  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
786  SCIP_EVENTFILTER* eventfilter /**< global event filter */
787  );
788 
789 /** remembers number of columns and rows to track the newly added ones */
790 void SCIPlpMarkSize(
791  SCIP_LP* lp /**< current LP data */
792  );
793 
794 /** sets the remembered number of columns and rows to the given values */
795 void SCIPlpSetSizeMark(
796  SCIP_LP* lp, /**< current LP data */
797  int nrows, /**< number of rows to set the size marker to */
798  int ncols /**< number of columns to set the size marker to */
799  );
800 
801 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1 */
802 SCIP_RETCODE SCIPlpGetBasisInd(
803  SCIP_LP* lp, /**< LP data */
804  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
805  );
806 
807 /** gets current basis status for columns and rows; arrays must be large enough to store the basis status */
808 SCIP_RETCODE SCIPlpGetBase(
809  SCIP_LP* lp, /**< LP data */
810  int* cstat, /**< array to store column basis status, or NULL */
811  int* rstat /**< array to store row basis status, or NULL */
812  );
813 
814 /** gets a row from the inverse basis matrix B^-1 */
815 SCIP_RETCODE SCIPlpGetBInvRow(
816  SCIP_LP* lp, /**< LP data */
817  int r, /**< row number */
818  SCIP_Real* coef, /**< pointer to store the coefficients of the row */
819  int* inds, /**< array to store the non-zero indices, or NULL */
820  int* ninds /**< pointer to store the number of non-zero indices, or NULL
821  * (-1: if we do not store sparsity informations) */
822  );
823 
824 /** gets a column from the inverse basis matrix B^-1 */
825 SCIP_RETCODE SCIPlpGetBInvCol(
826  SCIP_LP* lp, /**< LP data */
827  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
828  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
829  * to get the array which links the B^-1 column numbers to the row and
830  * column numbers of the LP! c must be between 0 and nrows-1, since the
831  * basis has the size nrows * nrows */
832  SCIP_Real* coef, /**< pointer to store the coefficients of the column */
833  int* inds, /**< array to store the non-zero indices, or NULL */
834  int* ninds /**< pointer to store the number of non-zero indices, or NULL
835  * (-1: if we do not store sparsity informations) */
836  );
837 
838 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A) */
839 SCIP_RETCODE SCIPlpGetBInvARow(
840  SCIP_LP* lp, /**< LP data */
841  int r, /**< row number */
842  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPlpGetBInvRow(), or NULL */
843  SCIP_Real* coef, /**< pointer to store the coefficients of the row */
844  int* inds, /**< array to store the non-zero indices, or NULL */
845  int* ninds /**< pointer to store the number of non-zero indices, or NULL
846  * (-1: if we do not store sparsity informations) */
847  );
848 
849 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
850  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
851  */
852 SCIP_RETCODE SCIPlpGetBInvACol(
853  SCIP_LP* lp, /**< LP data */
854  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
855  SCIP_Real* coef, /**< pointer to store the coefficients of the column */
856  int* inds, /**< array to store the non-zero indices, or NULL */
857  int* ninds /**< pointer to store the number of non-zero indices, or NULL
858  * (-1: if we do not store sparsity informations) */
859  );
860 
861 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
862  * LP row are swapped in the summation
863  */
864 SCIP_RETCODE SCIPlpSumRows(
865  SCIP_LP* lp, /**< LP data */
866  SCIP_SET* set, /**< global SCIP settings */
867  SCIP_PROB* prob, /**< problem data */
868  SCIP_Real* weights, /**< row weights in row summation */
869  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
870  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
871  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
872  );
873 
874 /** stores LP state (like basis information) into LP state object */
875 SCIP_RETCODE SCIPlpGetState(
876  SCIP_LP* lp, /**< LP data */
877  BMS_BLKMEM* blkmem, /**< block memory */
878  SCIP_LPISTATE** lpistate /**< pointer to LP state information (like basis information) */
879  );
880 
881 /** loads LP state (like basis information) into solver */
882 SCIP_RETCODE SCIPlpSetState(
883  SCIP_LP* lp, /**< LP data */
884  BMS_BLKMEM* blkmem, /**< block memory */
885  SCIP_SET* set, /**< global SCIP settings */
886  SCIP_PROB* prob, /**< problem data */
887  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
888  SCIP_LPISTATE* lpistate, /**< LP state information (like basis information) */
889  SCIP_Bool wasprimfeas, /**< primal feasibility when LP state information was stored */
890  SCIP_Bool wasprimchecked, /**< true if the LP solution has passed the primal feasibility check */
891  SCIP_Bool wasdualfeas, /**< dual feasibility when LP state information was stored */
892  SCIP_Bool wasdualchecked /**< true if the LP solution has passed the dual feasibility check */
893  );
894 
895 /** frees LP state information */
896 SCIP_RETCODE SCIPlpFreeState(
897  SCIP_LP* lp, /**< LP data */
898  BMS_BLKMEM* blkmem, /**< block memory */
899  SCIP_LPISTATE** lpistate /**< pointer to LP state information (like basis information) */
900  );
901 
902 /** interrupts the currently ongoing lp solve or disables the interrupt */
903 SCIP_RETCODE SCIPlpInterrupt(
904  SCIP_LP* lp, /**< LP data */
905  SCIP_Bool interrupt /**< TRUE if interrupt should be set, FALSE if it should be disabled */
906  );
907 
908 /** stores pricing norms into LP norms object */
909 SCIP_RETCODE SCIPlpGetNorms(
910  SCIP_LP* lp, /**< LP data */
911  BMS_BLKMEM* blkmem, /**< block memory */
912  SCIP_LPINORMS** lpinorms /**< pointer to LP pricing norms information */
913  );
914 
915 /** loads pricing norms from LP norms object into solver */
916 SCIP_RETCODE SCIPlpSetNorms(
917  SCIP_LP* lp, /**< LP data */
918  BMS_BLKMEM* blkmem, /**< block memory */
919  SCIP_LPINORMS* lpinorms /**< LP pricing norms information */
920  );
921 
922 /** frees pricing norms information */
923 SCIP_RETCODE SCIPlpFreeNorms(
924  SCIP_LP* lp, /**< LP data */
925  BMS_BLKMEM* blkmem, /**< block memory */
926  SCIP_LPINORMS** lpinorms /**< pointer to LP pricing norms information */
927  );
928 
929 /** return the current cutoff bound of the lp */
930 SCIP_Real SCIPlpGetCutoffbound(
931  SCIP_LP* lp /**< current LP data */
932  );
933 
934 /** sets the upper objective limit of the LP solver */
935 SCIP_RETCODE SCIPlpSetCutoffbound(
936  SCIP_LP* lp, /**< current LP data */
937  SCIP_SET* set, /**< global SCIP settings */
938  SCIP_PROB* prob, /**< problem data */
939  SCIP_Real cutoffbound /**< new upper objective limit */
940  );
941 
942 /** gets current primal feasibility tolerance of LP solver */
943 SCIP_Real SCIPlpGetFeastol(
944  SCIP_LP* lp /**< current LP data */
945  );
946 
947 /** sets primal feasibility tolerance of LP solver */
948 void SCIPlpSetFeastol(
949  SCIP_LP* lp, /**< current LP data */
950  SCIP_SET* set, /**< global SCIP settings */
951  SCIP_Real newfeastol /**< new primal feasibility tolerance for LP */
952  );
953 
954 /** resets primal feasibility tolerance of LP solver
955  *
956  * Sets primal feasibility tolerance to min of numerics/lpfeastolfactor * numerics/feastol and relaxfeastol.
957  */
958 void SCIPlpResetFeastol(
959  SCIP_LP* lp, /**< current LP data */
960  SCIP_SET* set /**< global SCIP settings */
961  );
962 
963 /** applies all cached changes to the LP solver */
964 SCIP_RETCODE SCIPlpFlush(
965  SCIP_LP* lp, /**< current LP data */
966  BMS_BLKMEM* blkmem, /**< block memory */
967  SCIP_SET* set, /**< global SCIP settings */
968  SCIP_PROB* prob, /**< problem data */
969  SCIP_EVENTQUEUE* eventqueue /**< event queue */
970  );
971 
972 /** marks the LP to be flushed, even if the LP thinks it is not flushed */
973 SCIP_RETCODE SCIPlpMarkFlushed(
974  SCIP_LP* lp, /**< current LP data */
975  SCIP_SET* set /**< global SCIP settings */
976  );
977 
978 /** solves the LP with simplex algorithm, and copy the solution into the column's data */
979 SCIP_RETCODE SCIPlpSolveAndEval(
980  SCIP_LP* lp, /**< LP data */
981  SCIP_SET* set, /**< global SCIP settings */
982  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
983  BMS_BLKMEM* blkmem, /**< block memory buffers */
984  SCIP_STAT* stat, /**< problem statistics */
985  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
986  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
987  SCIP_PROB* prob, /**< problem data */
988  SCIP_Longint itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
989  SCIP_Bool limitresolveiters, /**< should LP iterations for resolving calls be limited?
990  * (limit is computed within the method w.r.t. the average LP iterations) */
991  SCIP_Bool aging, /**< should aging and removal of obsolete cols/rows be applied? */
992  SCIP_Bool keepsol, /**< should the old LP solution be kept if no iterations were performed? */
993  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */
994  );
995 
996 /** gets solution status of current LP */
997 SCIP_LPSOLSTAT SCIPlpGetSolstat(
998  SCIP_LP* lp /**< current LP data */
999  );
1000 
1001 /** sets whether the root LP is a relaxation of the problem and its optimal objective value is a global lower bound */
1002 void SCIPlpSetRootLPIsRelax(
1003  SCIP_LP* lp, /**< LP data */
1004  SCIP_Bool isrelax /**< is the root lp a relaxation of the problem? */
1005  );
1006 
1007 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound */
1008 SCIP_Bool SCIPlpIsRootLPRelax(
1009  SCIP_LP* lp /**< LP data */
1010  );
1011 
1012 /** gets objective value of current LP
1013  *
1014  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
1015  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status is
1016  * SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
1017  */
1018 SCIP_Real SCIPlpGetObjval(
1019  SCIP_LP* lp, /**< current LP data */
1020  SCIP_SET* set, /**< global SCIP settings */
1021  SCIP_PROB* prob /**< problem data */
1022  );
1023 
1024 /** gets part of objective value of current LP that results from COLUMN variables only */
1025 SCIP_Real SCIPlpGetColumnObjval(
1026  SCIP_LP* lp /**< current LP data */
1027  );
1028 
1029 /** gets part of objective value of current LP that results from LOOSE variables only */
1030 SCIP_Real SCIPlpGetLooseObjval(
1031  SCIP_LP* lp, /**< current LP data */
1032  SCIP_SET* set, /**< global SCIP settings */
1033  SCIP_PROB* prob /**< problem data */
1034  );
1035 
1036 /** remembers the current LP objective value as root solution value */
1037 void SCIPlpStoreRootObjval(
1038  SCIP_LP* lp, /**< current LP data */
1039  SCIP_SET* set, /**< global SCIP settings */
1040  SCIP_PROB* prob /**< problem data */
1041  );
1042 
1043 /** invalidates the root LP solution value */
1044 void SCIPlpInvalidateRootObjval(
1045  SCIP_LP* lp /**< current LP data */
1046  );
1047 
1048 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective function)
1049  * global bound
1050  */
1051 SCIP_Real SCIPlpGetGlobalPseudoObjval(
1052  SCIP_LP* lp, /**< current LP data */
1053  SCIP_SET* set, /**< global SCIP settings */
1054  SCIP_PROB* prob /**< problem data */
1055  );
1056 
1057 /** recomputes local and global pseudo objective values */
1058 void SCIPlpRecomputeLocalAndGlobalPseudoObjval(
1059  SCIP_LP* lp, /**< current LP data */
1060  SCIP_SET* set, /**< global SCIP settings */
1061  SCIP_PROB* prob /**< problem data */
1062  );
1063 
1064 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
1065  * objective function) local bound
1066  */
1067 SCIP_Real SCIPlpGetPseudoObjval(
1068  SCIP_LP* lp, /**< current LP data */
1069  SCIP_SET* set, /**< global SCIP settings */
1070  SCIP_PROB* prob /**< problem data */
1071  );
1072 
1073 /** gets pseudo objective value, if a bound of the given variable would be modified in the given way */
1074 SCIP_Real SCIPlpGetModifiedPseudoObjval(
1075  SCIP_LP* lp, /**< current LP data */
1076  SCIP_SET* set, /**< global SCIP settings */
1077  SCIP_PROB* prob, /**< problem data */
1078  SCIP_VAR* var, /**< problem variable */
1079  SCIP_Real oldbound, /**< old value for bound */
1080  SCIP_Real newbound, /**< new value for bound */
1081  SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
1082  );
1083 
1084 /** gets pseudo objective value, if a bound of the given variable would be modified in the given way;
1085  * perform calculations with interval arithmetic to get an exact lower bound
1086  */
1087 SCIP_Real SCIPlpGetModifiedProvedPseudoObjval(
1088  SCIP_LP* lp, /**< current LP data */
1089  SCIP_SET* set, /**< global SCIP settings */
1090  SCIP_VAR* var, /**< problem variable */
1091  SCIP_Real oldbound, /**< old value for bound */
1092  SCIP_Real newbound, /**< new value for bound */
1093  SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */
1094  );
1095 
1096 /** updates current pseudo and loose objective value for a change in a variable's objective coefficient */
1097 SCIP_RETCODE SCIPlpUpdateVarObj(
1098  SCIP_LP* lp, /**< current LP data */
1099  SCIP_SET* set, /**< global SCIP settings */
1100  SCIP_VAR* var, /**< problem variable that changed */
1101  SCIP_Real oldobj, /**< old objective coefficient of variable */
1102  SCIP_Real newobj /**< new objective coefficient of variable */
1103  );
1104 
1105 /** updates current root pseudo objective value for a global change in a variable's lower bound */
1106 SCIP_RETCODE SCIPlpUpdateVarLbGlobal(
1107  SCIP_LP* lp, /**< current LP data */
1108  SCIP_SET* set, /**< global SCIP settings */
1109  SCIP_VAR* var, /**< problem variable that changed */
1110  SCIP_Real oldlb, /**< old lower bound of variable */
1111  SCIP_Real newlb /**< new lower bound of variable */
1112  );
1113 
1114 /** updates current pseudo and loose objective value for a change in a variable's lower bound */
1115 SCIP_RETCODE SCIPlpUpdateVarLb(
1116  SCIP_LP* lp, /**< current LP data */
1117  SCIP_SET* set, /**< global SCIP settings */
1118  SCIP_VAR* var, /**< problem variable that changed */
1119  SCIP_Real oldlb, /**< old lower bound of variable */
1120  SCIP_Real newlb /**< new lower bound of variable */
1121  );
1122 
1123 /** updates current root pseudo objective value for a global change in a variable's upper bound */
1124 SCIP_RETCODE SCIPlpUpdateVarUbGlobal(
1125  SCIP_LP* lp, /**< current LP data */
1126  SCIP_SET* set, /**< global SCIP settings */
1127  SCIP_VAR* var, /**< problem variable that changed */
1128  SCIP_Real oldub, /**< old upper bound of variable */
1129  SCIP_Real newub /**< new upper bound of variable */
1130  );
1131 
1132 /** updates current pseudo objective value for a change in a variable's upper bound */
1133 SCIP_RETCODE SCIPlpUpdateVarUb(
1134  SCIP_LP* lp, /**< current LP data */
1135  SCIP_SET* set, /**< global SCIP settings */
1136  SCIP_VAR* var, /**< problem variable that changed */
1137  SCIP_Real oldub, /**< old upper bound of variable */
1138  SCIP_Real newub /**< new upper bound of variable */
1139  );
1140 
1141 /** informs LP, that given variable was added to the problem */
1142 SCIP_RETCODE SCIPlpUpdateAddVar(
1143  SCIP_LP* lp, /**< current LP data */
1144  SCIP_SET* set, /**< global SCIP settings */
1145  SCIP_VAR* var /**< variable that is now a LOOSE problem variable */
1146  );
1147 
1148 /** informs LP, that given variable is to be deleted from the problem */
1149 SCIP_RETCODE SCIPlpUpdateDelVar(
1150  SCIP_LP* lp, /**< current LP data */
1151  SCIP_SET* set, /**< global SCIP settings */
1152  SCIP_VAR* var /**< variable that will be deleted from the problem */
1153  );
1154 
1155 /** informs LP, that given formerly loose problem variable is now a column variable */
1156 SCIP_RETCODE SCIPlpUpdateVarColumn(
1157  SCIP_LP* lp, /**< current LP data */
1158  SCIP_SET* set, /**< global SCIP settings */
1159  SCIP_VAR* var /**< problem variable that changed from LOOSE to COLUMN */
1160  );
1161 
1162 /** informs LP, that given formerly column problem variable is now again a loose variable */
1163 SCIP_RETCODE SCIPlpUpdateVarLoose(
1164  SCIP_LP* lp, /**< current LP data */
1165  SCIP_SET* set, /**< global SCIP settings */
1166  SCIP_VAR* var /**< problem variable that changed from COLUMN to LOOSE */
1167  );
1168 
1169 /** decrease the number of loose variables by one */
1170 void SCIPlpDecNLoosevars(
1171  SCIP_LP* lp /**< current LP data */
1172  );
1173 
1174 /** stores the LP solution in the columns and rows */
1175 SCIP_RETCODE SCIPlpGetSol(
1176  SCIP_LP* lp, /**< current LP data */
1177  SCIP_SET* set, /**< global SCIP settings */
1178  SCIP_STAT* stat, /**< problem statistics */
1179  SCIP_Bool* primalfeasible, /**< pointer to store whether the solution is primal feasible, or NULL */
1180  SCIP_Bool* dualfeasible /**< pointer to store whether the solution is dual feasible, or NULL */
1181  );
1182 
1183 /** stores LP solution with infinite objective value in the columns and rows */
1184 SCIP_RETCODE SCIPlpGetUnboundedSol(
1185  SCIP_LP* lp, /**< current LP data */
1186  SCIP_SET* set, /**< global SCIP settings */
1187  SCIP_STAT* stat, /**< problem statistics */
1188  SCIP_Bool* primalfeasible, /**< pointer to store whether the solution is primal feasible, or NULL */
1189  SCIP_Bool* rayfeasible /**< pointer to store whether the primal ray is a feasible unboundedness proof, or NULL */
1190  );
1191 
1192 /** returns primal ray proving the unboundedness of the current LP */
1193 SCIP_RETCODE SCIPlpGetPrimalRay(
1194  SCIP_LP* lp, /**< current LP data */
1195  SCIP_SET* set, /**< global SCIP settings */
1196  SCIP_Real* ray /**< array for storing primal ray values, they are stored w.r.t. the problem index of the variables,
1197  * so the size of this array should be at least number of active variables
1198  * (all entries have to be initialized to 0 before) */
1199  );
1200 
1201 /** stores the dual Farkas multipliers for infeasibility proof in rows. besides, the proof is checked for validity if
1202  * lp/checkfarkas = TRUE.
1203  *
1204  * @note the check will not be performed if @p valid is NULL.
1205  */
1206 SCIP_RETCODE SCIPlpGetDualfarkas(
1207  SCIP_LP* lp, /**< current LP data */
1208  SCIP_SET* set, /**< global SCIP settings */
1209  SCIP_STAT* stat, /**< problem statistics */
1210  SCIP_Bool* valid /**< pointer to store whether the Farkas proof is valid or NULL */
1211  );
1212 
1213 /** get number of iterations used in last LP solve */
1214 SCIP_RETCODE SCIPlpGetIterations(
1215  SCIP_LP* lp, /**< current LP data */
1216  int* iterations /**< pointer to store the iteration count */
1217  );
1218 
1219 /** increases age of columns with solution value 0.0 and rows with activity not at its bounds,
1220  * resets age of non-zero columns and sharp rows
1221  */
1222 SCIP_RETCODE SCIPlpUpdateAges(
1223  SCIP_LP* lp, /**< current LP data */
1224  SCIP_STAT* stat /**< problem statistics */
1225  );
1226 
1227 /** removes all non-basic columns and basic rows in the part of the LP created at the current node, that are too old */
1228 SCIP_RETCODE SCIPlpRemoveNewObsoletes(
1229  SCIP_LP* lp, /**< current LP data */
1230  BMS_BLKMEM* blkmem, /**< block memory buffers */
1231  SCIP_SET* set, /**< global SCIP settings */
1232  SCIP_STAT* stat, /**< problem statistics */
1233  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1234  SCIP_EVENTFILTER* eventfilter /**< global event filter */
1235  );
1236 
1237 /** removes all non-basic columns and basic rows in whole LP, that are too old */
1238 SCIP_RETCODE SCIPlpRemoveAllObsoletes(
1239  SCIP_LP* lp, /**< current LP data */
1240  BMS_BLKMEM* blkmem, /**< block memory buffers */
1241  SCIP_SET* set, /**< global SCIP settings */
1242  SCIP_STAT* stat, /**< problem statistics */
1243  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1244  SCIP_EVENTFILTER* eventfilter /**< global event filter */
1245  );
1246 
1247 /** removes all non-basic columns at 0.0 and basic rows in the part of the LP created at the current node */
1248 SCIP_RETCODE SCIPlpCleanupNew(
1249  SCIP_LP* lp, /**< current LP data */
1250  BMS_BLKMEM* blkmem, /**< block memory buffers */
1251  SCIP_SET* set, /**< global SCIP settings */
1252  SCIP_STAT* stat, /**< problem statistics */
1253  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1254  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1255  SCIP_Bool root /**< are we at the root node? */
1256  );
1257 
1258 /** removes all non-basic columns at 0.0 and basic rows in the whole LP */
1259 SCIP_RETCODE SCIPlpCleanupAll(
1260  SCIP_LP* lp, /**< current LP data */
1261  BMS_BLKMEM* blkmem, /**< block memory buffers */
1262  SCIP_SET* set, /**< global SCIP settings */
1263  SCIP_STAT* stat, /**< problem statistics */
1264  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1265  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1266  SCIP_Bool root /**< are we at the root node? */
1267  );
1268 
1269 /** removes all redundant rows that were added at the current node */
1270 SCIP_RETCODE SCIPlpRemoveRedundantRows(
1271  SCIP_LP* lp, /**< current LP data */
1272  BMS_BLKMEM* blkmem, /**< block memory buffers */
1273  SCIP_SET* set, /**< global SCIP settings */
1274  SCIP_STAT* stat, /**< problem statistics */
1275  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1276  SCIP_EVENTFILTER* eventfilter /**< global event filter */
1277  );
1278 
1279 /** initiates LP diving */
1280 SCIP_RETCODE SCIPlpStartDive(
1281  SCIP_LP* lp, /**< current LP data */
1282  BMS_BLKMEM* blkmem, /**< block memory */
1283  SCIP_SET* set, /**< global SCIP settings */
1284  SCIP_STAT* stat /**< problem statistics */
1285  );
1286 
1287 /** quits LP diving and resets bounds and objective values of columns to the current node's values */
1288 SCIP_RETCODE SCIPlpEndDive(
1289  SCIP_LP* lp, /**< current LP data */
1290  BMS_BLKMEM* blkmem, /**< block memory */
1291  SCIP_SET* set, /**< global SCIP settings */
1292  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1293  SCIP_STAT* stat, /**< problem statistics */
1294  SCIP_EVENTQUEUE* eventqueue, /**< event queue */
1295  SCIP_EVENTFILTER* eventfilter, /**< global event filter */
1296  SCIP_PROB* prob, /**< problem data */
1297  SCIP_VAR** vars, /**< array with all active variables */
1298  int nvars /**< number of active variables */
1299  );
1300 
1301 /** records a current row side such that any change will be undone after diving */
1302 SCIP_RETCODE SCIPlpRecordOldRowSideDive(
1303  SCIP_LP* lp, /**< LP data object */
1304  SCIP_ROW* row, /**< row affected by the change */
1305  SCIP_SIDETYPE sidetype /**< side type */
1306  );
1307 
1308 /** informs the LP that probing mode was initiated */
1309 SCIP_RETCODE SCIPlpStartProbing(
1310  SCIP_LP* lp /**< current LP data */
1311  );
1312 
1313 /** informs the LP that probing mode was finished */
1314 SCIP_RETCODE SCIPlpEndProbing(
1315  SCIP_LP* lp /**< current LP data */
1316  );
1317 
1318 /** informs the LP that the probing mode is now used for strongbranching */
1319 void SCIPlpStartStrongbranchProbing(
1320  SCIP_LP* lp /**< current LP data */
1321  );
1322 
1323 /** informs the LP that the probing mode is not used for strongbranching anymore */
1324 void SCIPlpEndStrongbranchProbing(
1325  SCIP_LP* lp /**< current LP data */
1326  );
1327 
1328 /** gets proven lower (dual) bound of last LP solution */
1329 SCIP_RETCODE SCIPlpGetProvedLowerbound(
1330  SCIP_LP* lp, /**< current LP data */
1331  SCIP_SET* set, /**< global SCIP settings */
1332  SCIP_Real* bound /**< pointer to store proven dual bound */
1333  );
1334 
1335 /** gets proven dual bound of last LP solution */
1336 SCIP_RETCODE SCIPlpIsInfeasibilityProved(
1337  SCIP_LP* lp, /**< current LP data */
1338  SCIP_SET* set, /**< global SCIP settings */
1339  SCIP_Bool* proved /**< pointer to store whether infeasibility is proven */
1340  );
1341 
1342 /** writes LP to a file */
1343 SCIP_RETCODE SCIPlpWrite(
1344  SCIP_LP* lp, /**< current LP data */
1345  const char* fname /**< file name */
1346  );
1347 
1348 /** writes MIP to a file */
1349 SCIP_RETCODE SCIPlpWriteMip(
1350  SCIP_LP* lp, /**< current LP data */
1351  SCIP_SET* set, /**< global SCIP settings */
1352  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1353  const char* fname, /**< file name */
1354  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
1355  * troubles with reserved symbols? */
1356  SCIP_Bool origobj, /**< should the original objective function be used? */
1357  SCIP_OBJSENSE objsense, /**< objective sense */
1358  SCIP_Real objscale, /**< objective scaling factor */
1359  SCIP_Real objoffset, /**< objective offset, e.g., caused by variable fixings in presolving */
1360  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
1361  );
1362 
1363 /** recalculates Euclidean norm of objective function vector of column variables if it have gotten unreliable during calculation */
1364 void SCIPlpRecalculateObjSqrNorm(
1365  SCIP_SET* set, /**< global SCIP settings */
1366  SCIP_LP* lp /**< LP data */
1367  );
1368 
1369 /** compute relative interior point */
1370 SCIP_RETCODE SCIPlpComputeRelIntPoint(
1371  SCIP_SET* set, /**< global SCIP settings */
1372  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1373  SCIP_LP* lp, /**< LP data */
1374  SCIP_PROB* prob, /**< problem data */
1375  SCIP_Bool relaxrows, /**< should the rows be relaxed */
1376  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
1377  SCIP_Real timelimit, /**< time limit for LP solver */
1378  int iterlimit, /**< iteration limit for LP solver */
1379  SCIP_Real* point, /**< array to store relative interior point on exit */
1380  SCIP_Bool* success /**< buffer to indicate whether interior point was successfully computed */
1381  );
1382 
1383 /** computes two measures for dual degeneracy (dual degeneracy rate and variable-constraint ratio)
1384  * based on the changes applied when reducing the problem to the optimal face
1385  *
1386  * returns the dual degeneracy rate, i.e., the share of nonbasic variables with reduced cost 0
1387  * and the variable-constraint ratio, i.e., the number of unfixed variables in relation to the basis size
1388  */
1389 SCIP_RETCODE SCIPlpGetDualDegeneracy(
1390  SCIP_LP* lp, /**< LP data */
1391  SCIP_SET* set, /**< global SCIP settings */
1392  SCIP_STAT* stat, /**< problem statistics */
1393  SCIP_Real* degeneracy, /**< pointer to store the dual degeneracy rate */
1394  SCIP_Real* varconsratio /**< pointer to store the variable-constraint ratio */
1395  );
1396 
1397 /** gets array with columns of the LP */
1398 SCIP_COL** SCIPlpGetCols(
1399  SCIP_LP* lp /**< current LP data */
1400  );
1401 
1402 /** gets current number of columns in LP */
1403 int SCIPlpGetNCols(
1404  SCIP_LP* lp /**< current LP data */
1405  );
1406 
1407 /** gets current number of unfixed columns in LP */
1408 int SCIPlpGetNUnfixedCols(
1409  SCIP_LP* lp, /**< current LP data */
1410  SCIP_Real eps /**< numerical tolerance */
1411  );
1412 
1413 /** gets array with rows of the LP */
1414 SCIP_ROW** SCIPlpGetRows(
1415  SCIP_LP* lp /**< current LP data */
1416  );
1417 
1418 /** gets current number of rows in LP */
1419 int SCIPlpGetNRows(
1420  SCIP_LP* lp /**< current LP data */
1421  );
1422 
1423 /** gets array with newly added columns after the last mark */
1424 SCIP_COL** SCIPlpGetNewcols(
1425  SCIP_LP* lp /**< current LP data */
1426  );
1427 
1428 /** gets number of newly added columns after the last mark */
1429 int SCIPlpGetNNewcols(
1430  SCIP_LP* lp /**< current LP data */
1431  );
1432 
1433 /** gets array with newly added rows after the last mark */
1434 SCIP_ROW** SCIPlpGetNewrows(
1435  SCIP_LP* lp /**< current LP data */
1436  );
1437 
1438 /** gets number of newly added rows after the last mark */
1439 int SCIPlpGetNNewrows(
1440  SCIP_LP* lp /**< current LP data */
1441  );
1442 
1443 /** gets Euclidean norm of objective function vector of column variables, only use this method if
1444  * lp->objsqrnormunreliable == FALSE, so probably you have to call SCIPlpRecalculateObjSqrNorm before */
1445 SCIP_Real SCIPlpGetObjNorm(
1446  SCIP_LP* lp /**< LP data */
1447  );
1448 
1449 /** gets the objective value of the root node LP; returns SCIP_INVALID if the root node LP was not (yet) solved */
1450 SCIP_Real SCIPlpGetRootObjval(
1451  SCIP_LP* lp /**< LP data */
1452  );
1453 
1454 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
1455  * returns SCIP_INVALID if the root node LP was not (yet) solved
1456  */
1457 SCIP_Real SCIPlpGetRootColumnObjval(
1458  SCIP_LP* lp /**< LP data */
1459  );
1460 
1461 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
1462  * returns SCIP_INVALID if the root node LP was not (yet) solved
1463  */
1464 SCIP_Real SCIPlpGetRootLooseObjval(
1465  SCIP_LP* lp /**< LP data */
1466  );
1467 
1468 /** gets the LP solver interface */
1469 SCIP_LPI* SCIPlpGetLPI(
1470  SCIP_LP* lp /**< current LP data */
1471  );
1472 
1473 /** sets whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound */
1474 void SCIPlpSetIsRelax(
1475  SCIP_LP* lp, /**< LP data */
1476  SCIP_Bool relax /**< is the current lp a relaxation? */
1477  );
1478 
1479 /** returns whether the current LP is a relaxation of the problem for which it has been solved and its
1480  * solution value a valid local lower bound?
1481  */
1482 SCIP_Bool SCIPlpIsRelax(
1483  SCIP_LP* lp /**< LP data */
1484  );
1485 
1486 /** returns whether the current LP is flushed and solved */
1487 SCIP_Bool SCIPlpIsSolved(
1488  SCIP_LP* lp /**< current LP data */
1489  );
1490 
1491 /** return whether the current LP solution passed the primal feasibility check */
1492 SCIP_Bool SCIPlpIsPrimalReliable(
1493  SCIP_LP* lp /**< current LP data */
1494  );
1495 
1496 /** return whether the current LP solution passed the dual feasibility check */
1497 SCIP_Bool SCIPlpIsDualReliable(
1498  SCIP_LP* lp /**< current LP data */
1499  );
1500 
1501 /** returns whether the current LP solution is a basic solution */
1502 SCIP_Bool SCIPlpIsSolBasic(
1503  SCIP_LP* lp /**< current LP data */
1504  );
1505 
1506 /** returns whether the LP is in diving mode */
1507 SCIP_Bool SCIPlpDiving(
1508  SCIP_LP* lp /**< current LP data */
1509  );
1510 
1511 /** returns whether the LP is in diving mode and the objective value of at least one column was changed */
1512 SCIP_Bool SCIPlpDivingObjChanged(
1513  SCIP_LP* lp /**< current LP data */
1514  );
1515 
1516 /** marks the diving LP to have a changed objective function */
1517 void SCIPlpMarkDivingObjChanged(
1518  SCIP_LP* lp /**< current LP data */
1519  );
1520 
1521 /** marks the diving LP to not have a changed objective function anymore */
1522 void SCIPlpUnmarkDivingObjChanged(
1523  SCIP_LP* lp /**< current LP data */
1524  );
1525 
1526 /* returns TRUE if at least one left/right hand side of an LP row was changed during diving mode */
1527 SCIP_Bool SCIPlpDivingRowsChanged(
1528  SCIP_LP* lp /**< current LP data */
1529  );
1530 
1531 /** checks, if absolute difference of values is in range of LP primal feastol */
1532 SCIP_Bool SCIPlpIsFeasEQ(
1533  SCIP_SET* set, /**< global SCIP settings */
1534  SCIP_LP* lp, /**< current LP data */
1535  SCIP_Real val1, /**< first value to be compared */
1536  SCIP_Real val2 /**< second value to be compared */
1537  );
1538 
1539 /** checks, if absolute difference of val1 and val2 is lower than LP primal feastol */
1540 SCIP_Bool SCIPlpIsFeasLT(
1541  SCIP_SET* set, /**< global SCIP settings */
1542  SCIP_LP* lp, /**< current LP data */
1543  SCIP_Real val1, /**< first value to be compared */
1544  SCIP_Real val2 /**< second value to be compared */
1545  );
1546 
1547 /** checks, if absolute difference of val1 and val2 is not greater than LP primal feastol */
1548 SCIP_Bool SCIPlpIsFeasLE(
1549  SCIP_SET* set, /**< global SCIP settings */
1550  SCIP_LP* lp, /**< current LP data */
1551  SCIP_Real val1, /**< first value to be compared */
1552  SCIP_Real val2 /**< second value to be compared */
1553  );
1554 
1555 /** checks, if absolute difference of val1 and val2 is greater than LP primal feastol */
1556 SCIP_Bool SCIPlpIsFeasGT(
1557  SCIP_SET* set, /**< global SCIP settings */
1558  SCIP_LP* lp, /**< current LP data */
1559  SCIP_Real val1, /**< first value to be compared */
1560  SCIP_Real val2 /**< second value to be compared */
1561  );
1562 
1563 /** checks, if absolute difference of val1 and val2 is not lower than -LP primal feastol */
1564 SCIP_Bool SCIPlpIsFeasGE(
1565  SCIP_SET* set, /**< global SCIP settings */
1566  SCIP_LP* lp, /**< current LP data */
1567  SCIP_Real val1, /**< first value to be compared */
1568  SCIP_Real val2 /**< second value to be compared */
1569  );
1570 
1571 /** checks, if value is in range LP primal feasibility tolerance of 0.0 */
1572 SCIP_Bool SCIPlpIsFeasZero(
1573  SCIP_LP* lp, /**< current LP data */
1574  SCIP_Real val /**< value to be compared against zero */
1575  );
1576 
1577 /** checks, if value is greater than LP primal feasibility tolerance */
1578 SCIP_Bool SCIPlpIsFeasPositive(
1579  SCIP_LP* lp, /**< current LP data */
1580  SCIP_Real val /**< value to be compared against zero */
1581  );
1582 
1583 /** checks, if value is lower than -LP primal feasibility tolerance */
1584 SCIP_Bool SCIPlpIsFeasNegative(
1585  SCIP_LP* lp, /**< current LP data */
1586  SCIP_Real val /**< value to be compared against zero */
1587  );
1588 
1589 
1590 #ifdef NDEBUG
1591 
1592 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
1593  * speed up the algorithms.
1594  */
1595 
1596 #define SCIPlpGetCols(lp) ((lp)->cols)
1597 #define SCIPlpGetNCols(lp) ((lp)->ncols)
1598 #define SCIPlpGetRows(lp) ((lp)->rows)
1599 #define SCIPlpGetNRows(lp) ((lp)->nrows)
1600 #define SCIPlpGetNewcols(lp) (&((lp)->cols[(lp)->firstnewcol]))
1601 #define SCIPlpGetNNewcols(lp) ((lp)->ncols - (lp)->firstnewcol)
1602 #define SCIPlpGetNewrows(lp) (&((lp)->rows[(lp)->firstnewrow]))
1603 #define SCIPlpGetNNewrows(lp) ((lp)->nrows - (lp)->firstnewrow)
1604 #define SCIPlpGetObjNorm(lp) (SQRT((lp)->objsqrnorm))
1605 #define SCIPlpGetRootObjval(lp) (MIN((lp)->rootlpobjval + (lp)->rootlooseobjval, SCIP_INVALID))
1606 #define SCIPlpGetRootColumnObjval(lp) ((lp)->rootlpobjval)
1607 #define SCIPlpGetRootLooseObjval(lp) ((lp)->rootlooseobjval)
1608 #define SCIPlpGetLPI(lp) (lp)->lpi
1609 #define SCIPlpSetIsRelax(lp,relax) ((lp)->isrelax = relax)
1610 #define SCIPlpIsRelax(lp) (lp)->isrelax
1611 #define SCIPlpIsSolved(lp) ((lp)->flushed && (lp)->solved)
1612 #define SCIPlpIsSolBasic(lp) ((lp)->solisbasic)
1613 #define SCIPlpDiving(lp) (lp)->diving
1614 #define SCIPlpDivingObjChanged(lp) (lp)->divingobjchg
1615 #define SCIPlpMarkDivingObjChanged(lp) ((lp)->divingobjchg = TRUE)
1616 #define SCIPlpUnmarkDivingObjChanged(lp) ((lp)->divingobjchg = FALSE)
1617 #define SCIPlpDivingRowsChanged(lp) ((lp)->ndivechgsides > 0)
1618 
1619 #define SCIPlpIsFeasEQ(set, lp, val1, val2) ( EPSEQ(val1, val2, (lp)->feastol) )
1620 #define SCIPlpIsFeasLT(set, lp, val1, val2) ( EPSLT(val1, val2, (lp)->feastol) )
1621 #define SCIPlpIsFeasLE(set, lp, val1, val2) ( EPSLE(val1, val2, (lp)->feastol) )
1622 #define SCIPlpIsFeasGT(set, lp, val1, val2) ( EPSGT(val1, val2, (lp)->feastol) )
1623 #define SCIPlpIsFeasGE(set, lp, val1, val2) ( EPSGE(val1, val2, (lp)->feastol) )
1624 #define SCIPlpIsFeasZero(lp, val) ( EPSZ(val, (lp)->feastol) )
1625 #define SCIPlpIsFeasPositive(lp, val) ( EPSP(val, (lp)->feastol) )
1626 #define SCIPlpIsFeasNegative(lp, val) ( EPSN(val, (lp)->feastol) )
1627 
1628 #endif
1629 
1630 #ifdef __cplusplus
1631 }
1632 #endif
1633 
1634 #endif
SCIPlpGetNewcols
SCIP_COL ** SCIPlpGetNewcols(SCIP_LP *lp)
Definition: lp.c:17598
SCIPlpUpdateVarLbGlobal
SCIP_RETCODE SCIPlpUpdateVarLbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)
Definition: lp.c:13872
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:6219
SCIPlpGetIterations
SCIP_RETCODE SCIPlpGetIterations(SCIP_LP *lp, int *iterations)
Definition: lp.c:15193
SCIPlpIsInfeasibilityProved
SCIP_RETCODE SCIPlpIsInfeasibilityProved(SCIP_LP *lp, SCIP_SET *set, SCIP_Bool *proved)
Definition: lp.c:16471
SCIPcolChgObj
SCIP_RETCODE SCIPcolChgObj(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
Definition: lp.c:3693
SCIPlpInterrupt
SCIP_RETCODE SCIPlpInterrupt(SCIP_LP *lp, SCIP_Bool interrupt)
Definition: lp.c:10112
SCIPlpStartStrongbranchProbing
void SCIPlpStartStrongbranchProbing(SCIP_LP *lp)
Definition: lp.c:16311
SCIPlpGetBInvARow
SCIP_RETCODE SCIPlpGetBInvARow(SCIP_LP *lp, int r, SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9893
SCIPlpEndStrongbranchProbing
void SCIPlpEndStrongbranchProbing(SCIP_LP *lp)
Definition: lp.c:16324
SCIProwGetMaxval
SCIP_Real SCIProwGetMaxval(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6666
SCIPlpGetSol
SCIP_RETCODE SCIPlpGetSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
Definition: lp.c:14328
SCIPcolGetFarkasCoef
SCIP_Real SCIPcolGetFarkasCoef(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:4130
SCIPlpGetBInvCol
SCIP_RETCODE SCIPlpGetBInvCol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9867
type_misc.h
type definitions for miscellaneous datastructures
SCIPlpIsSolBasic
SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)
Definition: lp.c:17803
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:3508
SCIPlpGetRows
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
Definition: lp.c:17578
SCIPlpSetIsRelax
void SCIPlpSetIsRelax(SCIP_LP *lp, SCIP_Bool relax)
Definition: lp.c:17750
SCIPlpGetBInvACol
SCIP_RETCODE SCIPlpGetBInvACol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9918
SCIPlpUpdateVarColumn
SCIP_RETCODE SCIPlpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
Definition: lp.c:14165
SCIPcolMarkNotRemovableLocal
void SCIPcolMarkNotRemovableLocal(SCIP_COL *col, SCIP_STAT *stat)
Definition: lp.c:4746
SCIPlpUpdateVarLb
SCIP_RETCODE SCIPlpUpdateVarLb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)
Definition: lp.c:13899
SCIPlpGetProvedLowerbound
SCIP_RETCODE SCIPlpGetProvedLowerbound(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *bound)
Definition: lp.c:16457
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:13352
SCIPlpGetState
SCIP_RETCODE SCIPlpGetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
Definition: lp.c:10028
SCIPlpGetRootColumnObjval
SCIP_Real SCIPlpGetRootColumnObjval(SCIP_LP *lp)
Definition: lp.c:17718
SCIPlpIsFeasLE
SCIP_Bool SCIPlpIsFeasLE(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
Definition: lp.c:18806
SCIPcolGetRedcost
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:3947
SCIPlpEndProbing
SCIP_RETCODE SCIPlpEndProbing(SCIP_LP *lp)
Definition: lp.c:16296
SCIProwCapture
void SCIProwCapture(SCIP_ROW *row)
Definition: lp.c:5334
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:5580
SCIP_ROWORIGINTYPE
enum SCIP_RowOriginType SCIP_ROWORIGINTYPE
Definition: type_lp.h:69
SCIPcolCalcFarkasCoef
SCIP_Real SCIPcolCalcFarkasCoef(SCIP_COL *col, SCIP_Real *dualfarkas)
Definition: lp.c:4025
SCIProwGetNLPEfficacy
SCIP_Real SCIProwGetNLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6959
SCIProwGetPseudoActivity
SCIP_Real SCIProwGetPseudoActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6417
bound
static long bound
Definition: GomoryHuTree.cpp:38
SCIPlpSetRootLPIsRelax
void SCIPlpSetRootLPIsRelax(SCIP_LP *lp, SCIP_Bool isrelax)
Definition: lp.c:17685
SCIProwRecalcLPActivity
void SCIProwRecalcLPActivity(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:6167
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:3463
SCIProwGetLPEfficacy
SCIP_Real SCIProwGetLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:6803
SCIPlpFreeState
SCIP_RETCODE SCIPlpFreeState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
Definition: lp.c:10095
SCIPlpSetNorms
SCIP_RETCODE SCIPlpSetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS *lpinorms)
Definition: lp.c:10152
SCIP_Var
Definition: struct_var.h:198
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:5523
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:15648
SCIPlpShrinkRows
SCIP_RETCODE SCIPlpShrinkRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int newnrows)
Definition: lp.c:9700
SCIProwGetLPSolCutoffDistance
SCIP_Real SCIProwGetLPSolCutoffDistance(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_LP *lp)
Definition: lp.c:6746
SCIPlpRecordOldRowSideDive
SCIP_RETCODE SCIPlpRecordOldRowSideDive(SCIP_LP *lp, SCIP_ROW *row, SCIP_SIDETYPE sidetype)
Definition: lp.c:16257
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:15856
SCIProwGetSolFeasibility
SCIP_Real SCIProwGetSolFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6503
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:4702
SCIP_EventFilter
Definition: struct_event.h:179
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:3274
SCIProwGetMaxidx
int SCIProwGetMaxidx(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6698
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:18569
SCIPlpFreeNorms
SCIP_RETCODE SCIPlpFreeNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
Definition: lp.c:10172
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIPlpGetNNewrows
int SCIPlpGetNNewrows(SCIP_LP *lp)
Definition: lp.c:17631
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:5661
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:16075
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:5976
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:6635
SCIPlpDiving
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
Definition: lp.c:17813
SCIPlpGetPseudoObjval
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13282
SCIPlpGetDualfarkas
SCIP_RETCODE SCIPlpGetDualfarkas(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *valid)
Definition: lp.c:15018
SCIP_Prob
Definition: struct_prob.h:39
SCIPlpRecalculateObjSqrNorm
void SCIPlpRecalculateObjSqrNorm(SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:17642
SCIPlpStartDive
SCIP_RETCODE SCIPlpStartDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:15969
SCIPlpStartProbing
SCIP_RETCODE SCIPlpStartProbing(SCIP_LP *lp)
Definition: lp.c:16281
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:16508
SCIP_LPSOLSTAT
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
SCIPlpGetRootObjval
SCIP_Real SCIPlpGetRootObjval(SCIP_LP *lp)
Definition: lp.c:17706
SCIProwEnsureSize
SCIP_RETCODE SCIProwEnsureSize(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
Definition: lp.c:620
SCIPlpGetCutoffbound
SCIP_Real SCIPlpGetCutoffbound(SCIP_LP *lp)
Definition: lp.c:10186
SCIPlpUpdateAges
SCIP_RETCODE SCIPlpUpdateAges(SCIP_LP *lp, SCIP_STAT *stat)
Definition: lp.c:15208
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:5471
SCIPlpAddCol
SCIP_RETCODE SCIPlpAddCol(SCIP_LP *lp, SCIP_SET *set, SCIP_COL *col, int depth)
Definition: lp.c:9445
SCIPlpGetNCols
int SCIPlpGetNCols(SCIP_LP *lp)
Definition: lp.c:17541
type_branch.h
type definitions for branching rules
SCIPlpShrinkCols
SCIP_RETCODE SCIPlpShrinkCols(SCIP_LP *lp, SCIP_SET *set, int newncols)
Definition: lp.c:9628
SCIPlpWrite
SCIP_RETCODE SCIPlpWrite(SCIP_LP *lp, const char *fname)
Definition: lp.c:16493
type_stat.h
type definitions for problem statistics
eps
real eps
Definition: nlpi_filtersqp.c:240
SCIPcolGetStrongbranchLPAge
SCIP_Longint SCIPcolGetStrongbranchLPAge(SCIP_COL *col, SCIP_STAT *stat)
Definition: lp.c:4734
SCIP_Col
Definition: struct_lp.h:126
SCIP_LPiNorms
Definition: lpi_cpx.c:188
SCIPlpIsFeasEQ
SCIP_Bool SCIPlpIsFeasEQ(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
Definition: lp.c:18766
type_lp.h
type definitions for LP management
SCIP_Sol
Definition: struct_sol.h:64
SCIPlpGetNRows
int SCIPlpGetNRows(SCIP_LP *lp)
Definition: lp.c:17588
SCIPlpDecNLoosevars
void SCIPlpDecNLoosevars(SCIP_LP *lp)
Definition: lp.c:14310
SCIP_Set
Definition: struct_set.h:63
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:15817
SCIPlpGetUnboundedSol
SCIP_RETCODE SCIPlpGetUnboundedSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *rayfeasible)
Definition: lp.c:14634
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:7828
SCIPlpGetObjval
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13099
SCIPlpGetObjNorm
SCIP_Real SCIPlpGetObjNorm(SCIP_LP *lp)
Definition: lp.c:17673
SCIPlpUpdateVarUbGlobal
SCIP_RETCODE SCIPlpUpdateVarUbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)
Definition: lp.c:13940
SCIProwRelease
SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:5347
SCIProwChgLocal
SCIP_RETCODE SCIProwChgLocal(SCIP_ROW *row, SCIP_Bool local)
Definition: lp.c:5725
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:12404
SCIPcolCalcRedcost
SCIP_Real SCIPcolCalcRedcost(SCIP_COL *col, SCIP_Real *dualsol)
Definition: lp.c:3842
SCIPlpIsRootLPRelax
SCIP_Bool SCIPlpIsRootLPRelax(SCIP_LP *lp)
Definition: lp.c:17696
SCIP_RealArray
Definition: struct_misc.h:148
SCIPlpRecomputeLocalAndGlobalPseudoObjval
void SCIPlpRecomputeLocalAndGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13182
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:15617
SCIPlpUpdateVarUb
SCIP_RETCODE SCIPlpUpdateVarUb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)
Definition: lp.c:13967
SCIProwGetMinidx
int SCIProwGetMinidx(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6714
SCIPlpStartStrongbranch
SCIP_RETCODE SCIPlpStartStrongbranch(SCIP_LP *lp)
Definition: lp.c:4175
SCIPlpFlush
SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue)
Definition: lp.c:8666
SCIPlpReset
SCIP_RETCODE SCIPlpReset(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:9410
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:3559
SCIPcolChgLb
SCIP_RETCODE SCIPcolChgLb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newlb)
Definition: lp.c:3752
SCIPlpGetCols
SCIP_COL ** SCIPlpGetCols(SCIP_LP *lp)
Definition: lp.c:17531
SCIProwPrint
void SCIProwPrint(SCIP_ROW *row, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: lp.c:5294
SCIP_EVENTDATA
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:164
SCIPlpGetSolstat
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
Definition: lp.c:13083
SCIPlpGetBase
SCIP_RETCODE SCIPlpGetBase(SCIP_LP *lp, int *cstat, int *rstat)
Definition: lp.c:9828
SCIPlpSetFeastol
void SCIPlpSetFeastol(SCIP_LP *lp, SCIP_SET *set, SCIP_Real newfeastol)
Definition: lp.c:10251
SCIPlpIsPrimalReliable
SCIP_Bool SCIPlpIsPrimalReliable(SCIP_LP *lp)
Definition: lp.c:17783
SCIPlpIsDualReliable
SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)
Definition: lp.c:17793
SCIPlpDivingObjChanged
SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)
Definition: lp.c:17823
SCIProwGetPseudoFeasibility
SCIP_Real SCIProwGetPseudoFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6445
SCIPlpGetLPI
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
Definition: lp.c:17740
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:3442
SCIPlpGetNNewcols
int SCIPlpGetNNewcols(SCIP_LP *lp)
Definition: lp.c:17609
SCIPcolPrint
void SCIPcolPrint(SCIP_COL *col, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: lp.c:3402
type_var.h
type definitions for problem variables
SCIProwGetNumIntCols
int SCIProwGetNumIntCols(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6730
SCIPlpFree
SCIP_RETCODE SCIPlpFree(SCIP_LP **lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:9365
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:5425
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:13312
SCIProwForceSort
void SCIProwForceSort(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6154
SCIPlpSetState
SCIP_RETCODE SCIPlpSetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue, SCIP_LPISTATE *lpistate, SCIP_Bool wasprimfeas, SCIP_Bool wasprimchecked, SCIP_Bool wasdualfeas, SCIP_Bool wasdualchecked)
Definition: lp.c:10052
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:7852
SCIProwGetMinActivity
SCIP_Real SCIProwGetMinActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6593
SCIProwIsSolEfficacious
SCIP_Bool SCIProwIsSolEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool root)
Definition: lp.c:6903
SCIP_Bool
#define SCIP_Bool
Definition: def.h:84
SCIPlpGetNewrows
SCIP_ROW ** SCIPlpGetNewrows(SCIP_LP *lp)
Definition: lp.c:17620
SCIPlpMarkFlushed
SCIP_RETCODE SCIPlpMarkFlushed(SCIP_LP *lp, SCIP_SET *set)
Definition: lp.c:8729
SCIPlpMarkSize
void SCIPlpMarkSize(SCIP_LP *lp)
Definition: lp.c:9785
SCIPlpGetLooseObjval
SCIP_Real SCIPlpGetLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13138
SCIPlpGetBInvRow
SCIP_RETCODE SCIPlpGetBInvRow(SCIP_LP *lp, int r, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9845
SCIPlpIsFeasGT
SCIP_Bool SCIPlpIsFeasGT(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
Definition: lp.c:18826
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:6919
SCIProwDelaySort
void SCIProwDelaySort(SCIP_ROW *row)
Definition: lp.c:6143
SCIPcolChgUb
SCIP_RETCODE SCIPcolChgUb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newub)
Definition: lp.c:3797
SCIProwGetLPFeasibility
SCIP_Real SCIProwGetLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:6249
SCIP_Row
Definition: struct_lp.h:192
SCIPlpGetDualDegeneracy
SCIP_RETCODE SCIPlpGetDualDegeneracy(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *degeneracy, SCIP_Real *varconsratio)
Definition: lp.c:18641
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:4479
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:9942
SCIPlpGetNUnfixedCols
int SCIPlpGetNUnfixedCols(SCIP_LP *lp, SCIP_Real eps)
Definition: lp.c:17551
SCIProwGetSolActivity
SCIP_Real SCIProwGetSolActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6461
pub_lp.h
public methods for LP management
SCIProwGetObjParallelism
SCIP_Real SCIProwGetObjParallelism(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:7795
SCIProwCreate
SCIP_RETCODE SCIProwCreate(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, 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:5105
SCIPlpGetBasisInd
SCIP_RETCODE SCIPlpGetBasisInd(SCIP_LP *lp, int *basisind)
Definition: lp.c:9811
SCIPlpMarkDivingObjChanged
void SCIPlpMarkDivingObjChanged(SCIP_LP *lp)
Definition: lp.c:17833
SCIProwGetNLPFeasibility
SCIP_Real SCIProwGetNLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6331
SCIProwGetSolEfficacy
SCIP_Real SCIProwGetSolEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6860
SCIPlpClear
SCIP_RETCODE SCIPlpClear(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
Definition: lp.c:9766
SCIPlpIsFeasGE
SCIP_Bool SCIPlpIsFeasGE(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
Definition: lp.c:18846
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:9504
SCIPlpIsFeasNegative
SCIP_Bool SCIPlpIsFeasNegative(SCIP_LP *lp, SCIP_Real val)
Definition: lp.c:18888
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:4205
SCIPlpGetNorms
SCIP_RETCODE SCIPlpGetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
Definition: lp.c:10128
SCIPlpSetCutoffbound
SCIP_RETCODE SCIPlpSetCutoffbound(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real cutoffbound)
Definition: lp.c:10196
SCIProwGetMaxActivity
SCIP_Real SCIProwGetMaxActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6614
SCIPlpGetFeastol
SCIP_Real SCIPlpGetFeastol(SCIP_LP *lp)
Definition: lp.c:10241
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:4156
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:13818
SCIPlpGetRootLooseObjval
SCIP_Real SCIPlpGetRootLooseObjval(SCIP_LP *lp)
Definition: lp.c:17730
SCIPlpUpdateVarLoose
SCIP_RETCODE SCIPlpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
Definition: lp.c:14289
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:5404
SCIPlpIsSolved
SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)
Definition: lp.c:17773
SCIPlpSetSizeMark
void SCIPlpSetSizeMark(SCIP_LP *lp, int nrows, int ncols)
Definition: lp.c:9797
SCIPlpIsRelax
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
Definition: lp.c:17763
SCIP_LPiState
Definition: lpi_clp.cpp:123
SCIPlpStoreRootObjval
void SCIPlpStoreRootObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13158
SCIPlpIsFeasZero
SCIP_Bool SCIPlpIsFeasZero(SCIP_LP *lp, SCIP_Real val)
Definition: lp.c:18866
SCIP_Lp
Definition: struct_lp.h:260
SCIProwFree
SCIP_RETCODE SCIProwFree(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:5254
SCIPlpCreate
SCIP_RETCODE SCIPlpCreate(SCIP_LP **lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *name)
Definition: lp.c:9073
struct_lp.h
data structures for LP management
SCIPlpIsFeasPositive
SCIP_Bool SCIPlpIsFeasPositive(SCIP_LP *lp, SCIP_Real val)
Definition: lp.c:18877
SCIP_Real
#define SCIP_Real
Definition: def.h:177
SCIP_LPi
Definition: lpi_clp.cpp:95
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:15895
SCIProwIsLPEfficacious
SCIP_Bool SCIProwIsLPEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool root)
Definition: lp.c:6844
SCIPcolFree
SCIP_RETCODE SCIPcolFree(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: lp.c:3372
SCIPcolInvalidateStrongbranchData
void SCIPcolInvalidateStrongbranchData(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:4259
SCIPlpUpdateDelVar
SCIP_RETCODE SCIPlpUpdateDelVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
Definition: lp.c:14029
SCIProwMarkNotRemovableLocal
void SCIProwMarkNotRemovableLocal(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:7873
SCIP_Longint
#define SCIP_Longint
Definition: def.h:162
SCIPlpGetColumnObjval
SCIP_Real SCIPlpGetColumnObjval(SCIP_LP *lp)
Definition: lp.c:13127
SCIProwRecalcPseudoActivity
void SCIProwRecalcPseudoActivity(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:6390
SCIPlpEndStrongbranch
SCIP_RETCODE SCIPlpEndStrongbranch(SCIP_LP *lp)
Definition: lp.c:4190
SCIPlpInvalidateRootObjval
void SCIPlpInvalidateRootObjval(SCIP_LP *lp)
Definition: lp.c:13171
SCIPlpResetFeastol
void SCIPlpResetFeastol(SCIP_LP *lp, SCIP_SET *set)
Definition: lp.c:10276
SCIP_Stat
Definition: struct_stat.h:50
SCIPlpDivingRowsChanged
SCIP_Bool SCIPlpDivingRowsChanged(SCIP_LP *lp)
Definition: lp.c:17855
def.h
common defines and data types used in all packages of SCIP
SCIP_EventQueue
Definition: struct_event.h:214
BMS_BLKMEM
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:430
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:5693
SCIPlpUnmarkDivingObjChanged
void SCIPlpUnmarkDivingObjChanged(SCIP_LP *lp)
Definition: lp.c:17844
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:5742
SCIProwGetMinval
SCIP_Real SCIProwGetMinval(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6682
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_Bool updatecol, SCIP_Bool updatestat, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *lperror)
Definition: lp.c:4294
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:5635
SCIProwGetRelaxFeasibility
SCIP_Real SCIProwGetRelaxFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6269
SCIP_Eventhdlr
Definition: struct_event.h:195
SCIPlpUpdateAddVar
SCIP_RETCODE SCIPlpUpdateAddVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
Definition: lp.c:14008
SCIPcolGetFeasibility
SCIP_Real SCIPcolGetFeasibility(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:3971
SCIPlpGetGlobalPseudoObjval
SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13250
SCIP_EVENTTYPE
uint64_t SCIP_EVENTTYPE
Definition: type_event.h:142
SCIPlpGetPrimalRay
SCIP_RETCODE SCIPlpGetPrimalRay(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *ray)
Definition: lp.c:14957
SCIPlpIsFeasLT
SCIP_Bool SCIPlpIsFeasLT(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
Definition: lp.c:18786
memory.h
memory allocation routines
SCIP_SIDETYPE
enum SCIP_SideType SCIP_SIDETYPE
Definition: type_lp.h:58