Scippy

SCIP

Solving Constraint Integer Programs

pub_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 pub_lp.h
26 * @ingroup PUBLICCOREAPI
27 * @brief public methods for LP management
28 * @author Tobias Achterberg
29 */
30
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#ifndef __SCIP_PUB_LP_H__
34#define __SCIP_PUB_LP_H__
35
36
37#include "lpi/type_lpi.h"
38#include "scip/def.h"
39#include "scip/type_cons.h"
40#include "scip/type_lp.h"
41#include "scip/type_sepa.h"
42#include "scip/type_var.h"
43#include "scip/type_misc.h"
44
45#ifdef NDEBUG
46#include "scip/struct_lp.h"
47#endif
48
49#ifdef __cplusplus
50extern "C" {
51#endif
52
53
54/**@addtogroup PublicColumnMethods
55 *
56 * @{
57 */
58
59/** sorts column entries such that LP rows precede non-LP rows and inside both parts lower row indices precede higher ones
60 */
61SCIP_EXPORT
62void SCIPcolSort(
63 SCIP_COL* col /**< column to be sorted */
64 );
65
66/** gets objective value of column */
67SCIP_EXPORT
69 SCIP_COL* col /**< LP column */
70 );
71
72/** gets lower bound of column */
73SCIP_EXPORT
75 SCIP_COL* col /**< LP column */
76 );
77
78/** gets upper bound of column */
79SCIP_EXPORT
81 SCIP_COL* col /**< LP column */
82 );
83
84/** gets best bound of column with respect to the objective function */
85SCIP_EXPORT
87 SCIP_COL* col /**< LP column */
88 );
89
90/** gets the primal LP solution of a column */
91SCIP_EXPORT
93 SCIP_COL* col /**< LP column */
94 );
95
96/** gets the minimal LP solution value, this column ever assumed */
97SCIP_EXPORT
99 SCIP_COL* col /**< LP column */
100 );
101
102/** gets the maximal LP solution value, this column ever assumed */
103SCIP_EXPORT
105 SCIP_COL* col /**< LP column */
106 );
107
108/** gets the basis status of a column in the LP solution; only valid for LPs with status SCIP_LPSOLSTAT_OPTIMAL
109 * and with SCIPisLPSolBasic(scip) == TRUE; returns SCIP_BASESTAT_ZERO for columns not in the current SCIP_LP
110 */
111SCIP_EXPORT
113 SCIP_COL* col /**< LP column */
114 );
115
116/** gets variable this column represents */
117SCIP_EXPORT
119 SCIP_COL* col /**< LP column */
120 );
121
122/** gets unique index of col */
123SCIP_EXPORT
125 SCIP_COL* col /**< LP col */
126 );
127
128/** gets probindex of corresponding variable */
129SCIP_EXPORT
131 SCIP_COL* col /**< LP col */
132 );
133
134/** returns whether the associated variable is of integral type (binary, integer, implicit integer) */
135SCIP_EXPORT
137 SCIP_COL* col /**< LP column */
138 );
139
140/** returns TRUE iff column is removable from the LP (due to aging or cleanup) */
141SCIP_EXPORT
143 SCIP_COL* col /**< LP column */
144 );
145
146/** gets position of column in current LP, or -1 if it is not in LP */
147SCIP_EXPORT
149 SCIP_COL* col /**< LP column */
150 );
151
152/** gets depth in the tree where the column entered the LP, or -1 if it is not in LP */
153SCIP_EXPORT
155 SCIP_COL* col /**< LP column */
156 );
157
158/** returns TRUE iff column is member of current LP */
159SCIP_EXPORT
161 SCIP_COL* col /**< LP column */
162 );
163
164/** get number of nonzero entries in column vector */
165SCIP_EXPORT
167 SCIP_COL* col /**< LP column */
168 );
169
170/** get number of nonzero entries in column vector, that correspond to rows currently in the SCIP_LP;
171 *
172 * @warning This method is only applicable on columns, that are completely linked to their rows (e.g. a column
173 * that is in the current LP and the LP was solved, or a column that was in a solved LP and didn't change afterwards
174 */
175SCIP_EXPORT
177 SCIP_COL* col /**< LP column */
178 );
179
180/** gets array with rows of nonzero entries */
181SCIP_EXPORT
183 SCIP_COL* col /**< LP column */
184 );
185
186/** gets array with coefficients of nonzero entries */
187SCIP_EXPORT
189 SCIP_COL* col /**< LP column */
190 );
191
192/** gets node number of the last node in current branch and bound run, where strong branching was used on the
193 * given column, or -1 if strong branching was never applied to the column in current run
194 */
195SCIP_EXPORT
197 SCIP_COL* col /**< LP column */
198 );
199
200/** gets number of times, strong branching was applied in current run on the given column */
201SCIP_EXPORT
203 SCIP_COL* col /**< LP column */
204 );
205
206/** gets the age of a column, i.e., the total number of successive times a column was in the LP and was 0.0 in the solution */
207SCIP_EXPORT
208int SCIPcolGetAge(
209 SCIP_COL* col /**< LP column */
210 );
211
212/** gets opposite bound type of given bound type */
213SCIP_EXPORT
215 SCIP_BOUNDTYPE boundtype /**< type of bound (lower or upper) */
216 );
217
218#ifdef NDEBUG
219
220/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
221 * speed up the algorithms.
222 */
223
224#define SCIPcolGetObj(col) (col)->obj
225#define SCIPcolGetLb(col) (col)->lb
226#define SCIPcolGetUb(col) (col)->ub
227#define SCIPcolGetBestBound(col) ((col)->obj >= 0.0 ? (col)->lb : (col)->ub)
228#define SCIPcolGetPrimsol(col) ((col)->lppos >= 0 ? (col)->primsol : 0.0)
229#define SCIPcolGetMinPrimsol(col) ((col)->minprimsol)
230#define SCIPcolGetMaxPrimsol(col) ((col)->maxprimsol)
231#define SCIPcolGetBasisStatus(col) ((SCIP_BASESTAT)(col)->basisstatus)
232#define SCIPcolGetVar(col) (col)->var
233#define SCIPcolGetIndex(col) (col)->index
234#define SCIPcolIsIntegral(col) (col)->integral
235#define SCIPcolIsRemovable(col) (col)->removable
236#define SCIPcolGetLPPos(col) (col)->lppos
237#define SCIPcolGetLPDepth(col) (col)->lpdepth
238#define SCIPcolIsInLP(col) ((col)->lppos >= 0)
239#define SCIPcolGetNNonz(col) (col)->len
240#define SCIPcolGetNLPNonz(col) (col)->nlprows
241#define SCIPcolGetRows(col) (col)->rows
242#define SCIPcolGetVals(col) (col)->vals
243#define SCIPcolGetStrongbranchNode(col) (col)->sbnode
244#define SCIPcolGetNStrongbranchs(col) (col)->nsbcalls
245#define SCIPcolGetAge(col) (col)->age
246#define SCIPboundtypeOpposite(boundtype) \
247 ((boundtype) == SCIP_BOUNDTYPE_LOWER ? SCIP_BOUNDTYPE_UPPER : SCIP_BOUNDTYPE_LOWER)
248
249#endif
250
251/**@} */
252
253
254
255/**@addtogroup PublicRowMethods
256 *
257 * @{
258 */
259
260/** comparison method for sorting rows by non-decreasing index */
261SCIP_EXPORT
262SCIP_DECL_SORTPTRCOMP(SCIProwComp);
263
264/** locks an unmodifiable row, which forbids further changes; has no effect on modifiable rows */
265SCIP_EXPORT
266void SCIProwLock(
267 SCIP_ROW* row /**< LP row */
268 );
269
270/** unlocks a lock of an unmodifiable row; a row with no sealed lock may be modified; has no effect on modifiable rows */
271SCIP_EXPORT
272void SCIProwUnlock(
273 SCIP_ROW* row /**< LP row */
274 );
275
276/** returns the scalar product of the coefficient vectors of the two given rows */
277SCIP_EXPORT
279 SCIP_ROW* row1, /**< first LP row */
280 SCIP_ROW* row2 /**< second LP row */
281 );
282
283/** returns the degree of parallelism between the hyperplanes defined by the two row vectors v, w:
284 * p = |v*w|/(|v|*|w|);
285 * the hyperplanes are parallel, iff p = 1, they are orthogonal, iff p = 0
286 */
287SCIP_EXPORT
289 SCIP_ROW* row1, /**< first LP row */
290 SCIP_ROW* row2, /**< second LP row */
291 char orthofunc /**< function used for calc. scalar prod. ('e'uclidean, 'd'iscrete) */
292 );
293
294/** returns the degree of orthogonality between the hyperplanes defined by the two row vectors v, w:
295 * o = 1 - |v*w|/(|v|*|w|);
296 * the hyperplanes are orthogonal, iff p = 1, they are parallel, iff p = 0
297 */
298SCIP_EXPORT
300 SCIP_ROW* row1, /**< first LP row */
301 SCIP_ROW* row2, /**< second LP row */
302 char orthofunc /**< function used for calc. scalar prod. ('e'uclidean, 'd'iscrete) */
303 );
304
305/** sorts row entries such that LP columns precede non-LP columns and inside both parts lower column indices precede
306 * higher ones
307 */
308SCIP_EXPORT
309void SCIProwSort(
310 SCIP_ROW* row /**< row to be sorted */
311 );
312
313/** get number of nonzero entries in row vector */
314SCIP_EXPORT
316 SCIP_ROW* row /**< LP row */
317 );
318
319/** get number of nonzero entries in row vector, that correspond to columns currently in the SCIP_LP;
320 *
321 * @warning This method is only applicable on rows, that are completely linked to their columns (e.g. a row
322 * that is in the current LP and the LP was solved, or a row that was in a solved LP and didn't change afterwards
323 */
324SCIP_EXPORT
326 SCIP_ROW* row /**< LP row */
327 );
328
329/** gets array with columns of nonzero entries */
330SCIP_EXPORT
332 SCIP_ROW* row /**< LP row */
333 );
334
335/** gets array with coefficients of nonzero entries */
336SCIP_EXPORT
338 SCIP_ROW* row /**< LP row */
339 );
340
341/** gets constant shift of row */
342SCIP_EXPORT
344 SCIP_ROW* row /**< LP row */
345 );
346
347/** gets Euclidean norm of row vector */
348SCIP_EXPORT
350 SCIP_ROW* row /**< LP row */
351 );
352
353/** gets sum norm of row vector (sum of absolute values of coefficients) */
354SCIP_EXPORT
356 SCIP_ROW* row /**< LP row */
357 );
358
359/** returns the left hand side of the row */
360SCIP_EXPORT
362 SCIP_ROW* row /**< LP row */
363 );
364
365/** returns the right hand side of the row */
366SCIP_EXPORT
368 SCIP_ROW* row /**< LP row */
369 );
370
371/** gets the dual LP solution of a row */
372SCIP_EXPORT
374 SCIP_ROW* row /**< LP row */
375 );
376
377/** gets the dual Farkas coefficient of a row in an infeasible LP */
378SCIP_EXPORT
380 SCIP_ROW* row /**< LP row */
381 );
382
383/** gets the basis status of a row in the LP solution; only valid for LPs with status SCIP_LPSOLSTAT_OPTIMAL
384 * and with SCIPisLPSolBasic(scip) == TRUE; returns SCIP_BASESTAT_BASIC for rows not in the current SCIP_LP
385 */
386SCIP_EXPORT
388 SCIP_ROW* row /**< LP row */
389 );
390
391/** returns the name of the row */
392SCIP_EXPORT
393const char* SCIProwGetName(
394 SCIP_ROW* row /**< LP row */
395 );
396
397/** gets unique index of row */
398SCIP_EXPORT
400 SCIP_ROW* row /**< LP row */
401 );
402
403/** gets age of row */
404SCIP_EXPORT
405int SCIProwGetAge(
406 SCIP_ROW* row /**< LP row */
407 );
408
409/** gets rank of row */
410SCIP_EXPORT
412 SCIP_ROW* row /**< LP row */
413 );
414
415/** returns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution */
416SCIP_EXPORT
418 SCIP_ROW* row /**< LP row */
419 );
420
421/** returns TRUE iff row is only valid locally */
422SCIP_EXPORT
424 SCIP_ROW* row /**< LP row */
425 );
426
427/** returns TRUE iff row is modifiable during node processing (subject to column generation) */
428SCIP_EXPORT
430 SCIP_ROW* row /**< LP row */
431 );
432
433/** returns TRUE iff row is removable from the LP (due to aging or cleanup) */
434SCIP_EXPORT
436 SCIP_ROW* row /**< LP row */
437 );
438
439/** returns type of origin that created the row */
440SCIP_EXPORT
442 SCIP_ROW* row /**< LP row */
443 );
444
445/** returns origin constraint handler that created the row (NULL if not available) */
446SCIP_EXPORT
448 SCIP_ROW* row /**< LP row */
449 );
450
451/** returns origin constraint that created the row (NULL if not available) */
452SCIP_EXPORT
454 SCIP_ROW* row /**< LP row */
455 );
456
457/** returns origin separator that created the row (NULL if not available) */
458SCIP_EXPORT
460 SCIP_ROW* row /**< LP row */
461 );
462
463/** returns TRUE iff row is member of the global cut pool */
464SCIP_EXPORT
466 SCIP_ROW* row /**< LP row */
467 );
468
469/** gets position of row in current LP, or -1 if it is not in LP */
470SCIP_EXPORT
472 SCIP_ROW* row /**< LP row */
473 );
474
475/** gets depth in the tree where the row entered the LP, or -1 if it is not in LP */
476SCIP_EXPORT
478 SCIP_ROW* row /**< LP row */
479 );
480
481/** returns TRUE iff row is member of current LP */
482SCIP_EXPORT
484 SCIP_ROW* row /**< LP row */
485 );
486
487/** returns the number of times that this row has been sharp in an optimal LP solution */
488SCIP_EXPORT
490 SCIP_ROW* row /**< row */
491 );
492
493/** returns the number of LPs since this row has been created */
494SCIP_EXPORT
496 SCIP_ROW* row /**< row */
497 );
498
499/** changes the rank of LP row */
500SCIP_EXPORT
501void SCIProwChgRank(
502 SCIP_ROW* row, /**< LP row */
503 int rank /**< new value for rank */
504 );
505
506#ifdef NDEBUG
507
508/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
509 * speed up the algorithms.
510 */
511
512#define SCIProwGetNNonz(row) (row)->len
513#define SCIProwGetNLPNonz(row) (row)->nlpcols
514#define SCIProwGetCols(row) (row)->cols
515#define SCIProwGetVals(row) (row)->vals
516#define SCIProwGetConstant(row) (row)->constant
517#define SCIProwGetNorm(row) sqrt((row)->sqrnorm)
518#define SCIProwGetSumNorm(row) (row)->sumnorm
519#define SCIProwGetLhs(row) (row)->lhs
520#define SCIProwGetRhs(row) (row)->rhs
521#define SCIProwGetDualsol(row) ((row)->lppos >= 0 ? (row)->dualsol : 0.0)
522#define SCIProwGetDualfarkas(row) ((row)->lppos >= 0 ? (row)->dualfarkas : 0.0)
523#define SCIProwGetBasisStatus(row) ((SCIP_BASESTAT) (row)->basisstatus)
524#define SCIProwGetName(row) (row)->name
525#define SCIProwGetIndex(row) (row)->index
526#define SCIProwGetAge(row) (row)->age
527#define SCIProwGetRank(row) (row)->rank
528#define SCIProwIsIntegral(row) (row)->integral
529#define SCIProwIsLocal(row) (row)->local
530#define SCIProwIsModifiable(row) (row)->modifiable
531#define SCIProwIsRemovable(row) (row)->removable
532#define SCIProwGetOrigintype(row) (row)->origintype
533#define SCIProwGetOriginCons(row) ((SCIP_CONS*) ((SCIP_ROWORIGINTYPE) row->origintype == SCIP_ROWORIGINTYPE_CONS ? (row)->origin : NULL))
534#define SCIProwGetOriginSepa(row) ((SCIP_SEPA*) ((SCIP_ROWORIGINTYPE) row->origintype == SCIP_ROWORIGINTYPE_SEPA ? (row)->origin : NULL))
535#define SCIProwIsInGlobalCutpool(row) (row)->inglobalcutpool
536#define SCIProwGetLPPos(row) (row)->lppos
537#define SCIProwGetLPDepth(row) (row)->lpdepth
538#define SCIProwIsInLP(row) ((row)->lppos >= 0)
539#define SCIProwGetActiveLPCount(row) ((row)->activeinlpcounter)
540#define SCIProwGetNLPsAfterCreation(row) ((row)->nlpsaftercreation)
541#define SCIProwChgRank(row, cutrank) ((row)->rank = (cutrank))
542
543#endif
544
545/**@} */
546
547#ifdef __cplusplus
548}
549#endif
550
551#endif
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_Real SCIPcolGetMinPrimsol(SCIP_COL *col)
Definition: lp.c:17009
int SCIPcolGetLPPos(SCIP_COL *col)
Definition: lp.c:17093
int SCIPcolGetVarProbindex(SCIP_COL *col)
Definition: lp.c:17062
SCIP_Bool SCIPcolIsRemovable(SCIP_COL *col)
Definition: lp.c:17083
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
Definition: lp.c:17042
SCIP_Bool SCIPcolIsIntegral(SCIP_COL *col)
Definition: lp.c:17072
SCIP_Real SCIPcolGetObj(SCIP_COL *col)
Definition: lp.c:16953
int SCIPcolGetNNonz(SCIP_COL *col)
Definition: lp.c:17126
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
Definition: lp.c:17161
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
Definition: lp.c:17151
void SCIPcolSort(SCIP_COL *col)
Definition: lp.c:3435
int SCIPcolGetIndex(SCIP_COL *col)
Definition: lp.c:17052
SCIP_Real SCIPcolGetBestBound(SCIP_COL *col)
Definition: lp.c:16983
SCIP_Real SCIPcolGetLb(SCIP_COL *col)
Definition: lp.c:16963
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
Definition: lp.c:16996
SCIP_Real SCIPcolGetUb(SCIP_COL *col)
Definition: lp.c:16973
SCIP_Longint SCIPcolGetStrongbranchNode(SCIP_COL *col)
Definition: lp.c:17173
int SCIPcolGetNLPNonz(SCIP_COL *col)
Definition: lp.c:17140
int SCIPcolGetNStrongbranchs(SCIP_COL *col)
Definition: lp.c:17183
int SCIPcolGetAge(SCIP_COL *col)
Definition: lp.c:17193
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
Definition: lp.c:17115
int SCIPcolGetLPDepth(SCIP_COL *col)
Definition: lp.c:17104
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
Definition: lp.c:17031
SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)
Definition: lp.c:17203
SCIP_Real SCIPcolGetMaxPrimsol(SCIP_COL *col)
Definition: lp.c:17019
SCIP_Bool SCIProwIsIntegral(SCIP_ROW *row)
Definition: lp.c:17391
void SCIProwSort(SCIP_ROW *row)
Definition: lp.c:6016
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
Definition: lp.c:17292
SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)
Definition: lp.c:17411
SCIP_Longint SCIProwGetActiveLPCount(SCIP_ROW *row)
Definition: lp.c:17545
SCIP_Real SCIProwGetOrthogonality(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
Definition: lp.c:7788
SCIP_Real SCIProwGetScalarProduct(SCIP_ROW *row1, SCIP_ROW *row2)
Definition: lp.c:7008
int SCIProwGetLPDepth(SCIP_ROW *row)
Definition: lp.c:17512
SCIP_Real SCIProwGetParallelism(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
Definition: lp.c:7724
SCIP_CONS * SCIProwGetOriginCons(SCIP_ROW *row)
Definition: lp.c:17441
int SCIProwGetNNonz(SCIP_ROW *row)
Definition: lp.c:17213
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
Definition: lp.c:17238
SCIP_Bool SCIProwIsInGlobalCutpool(SCIP_ROW *row)
Definition: lp.c:17491
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
Definition: lp.c:17302
int SCIProwGetAge(SCIP_ROW *row)
Definition: lp.c:17371
int SCIProwGetNLPNonz(SCIP_ROW *row)
Definition: lp.c:17227
SCIP_Real SCIProwGetNorm(SCIP_ROW *row)
Definition: lp.c:17268
int SCIProwGetLPPos(SCIP_ROW *row)
Definition: lp.c:17501
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
Definition: lp.c:17401
SCIP_CONSHDLR * SCIProwGetOriginConshdlr(SCIP_ROW *row)
Definition: lp.c:17456
SCIP_Longint SCIProwGetNLPsAfterCreation(SCIP_ROW *row)
Definition: lp.c:17555
void SCIProwLock(SCIP_ROW *row)
Definition: lp.c:5378
SCIP_Bool SCIProwIsRemovable(SCIP_ROW *row)
Definition: lp.c:17421
const char * SCIProwGetName(SCIP_ROW *row)
Definition: lp.c:17351
SCIP_SEPA * SCIProwGetOriginSepa(SCIP_ROW *row)
Definition: lp.c:17476
void SCIProwUnlock(SCIP_ROW *row)
Definition: lp.c:5393
SCIP_Real SCIProwGetSumNorm(SCIP_ROW *row)
Definition: lp.c:17280
SCIP_DECL_SORTPTRCOMP(SCIProwComp)
Definition: lp.c:950
int SCIProwGetRank(SCIP_ROW *row)
Definition: lp.c:17381
SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
Definition: lp.c:17325
int SCIProwGetIndex(SCIP_ROW *row)
Definition: lp.c:17361
void SCIProwChgRank(SCIP_ROW *row, int rank)
Definition: lp.c:17534
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
Definition: lp.c:17258
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
Definition: lp.c:17523
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
Definition: lp.c:17312
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
Definition: lp.c:17248
SCIP_ROWORIGINTYPE SCIProwGetOrigintype(SCIP_ROW *row)
Definition: lp.c:17431
SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)
Definition: lp.c:17340
data structures for LP management
type definitions for constraints and constraint handlers
type definitions for LP management
enum SCIP_RowOriginType SCIP_ROWORIGINTYPE
Definition: type_lp.h:78
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
type definitions for specific LP solvers interface
enum SCIP_BaseStat SCIP_BASESTAT
Definition: type_lpi.h:96
type definitions for miscellaneous datastructures
type definitions for separators
type definitions for problem variables