Scippy

SCIP

Solving Constraint Integer Programs

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