Scippy

SCIP

Solving Constraint Integer Programs

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