Scippy

SCIP

Solving Constraint Integer Programs

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