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