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-2020 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file pub_lp.h
17  * @ingroup PUBLICCOREAPI
18  * @brief public methods for LP management
19  * @author Tobias Achterberg
20  */
21 
22 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
23 
24 #ifndef __SCIP_PUB_LP_H__
25 #define __SCIP_PUB_LP_H__
26 
27 
28 #include "lpi/type_lpi.h"
29 #include "scip/def.h"
30 #include "scip/type_cons.h"
31 #include "scip/type_lp.h"
32 #include "scip/type_sepa.h"
33 #include "scip/type_var.h"
34 #include "scip/type_misc.h"
35 
36 #ifdef NDEBUG
37 #include "scip/struct_lp.h"
38 #endif
39 
40 #ifdef __cplusplus
41 extern "C" {
42 #endif
43 
44 
45 /**@addtogroup PublicColumnMethods
46  *
47  * @{
48  */
49 
50 /** sorts column entries such that LP rows precede non-LP rows and inside both parts lower row indices precede higher ones
51  */
53 void SCIPcolSort(
54  SCIP_COL* col /**< column to be sorted */
55  );
56 
57 /** gets objective value of column */
60  SCIP_COL* col /**< LP column */
61  );
62 
63 /** gets lower bound of column */
66  SCIP_COL* col /**< LP column */
67  );
68 
69 /** gets upper bound of column */
72  SCIP_COL* col /**< LP column */
73  );
74 
75 /** gets best bound of column with respect to the objective function */
78  SCIP_COL* col /**< LP column */
79  );
80 
81 /** gets the primal LP solution of a column */
84  SCIP_COL* col /**< LP column */
85  );
86 
87 /** gets the minimal LP solution value, this column ever assumed */
90  SCIP_COL* col /**< LP column */
91  );
92 
93 /** gets the maximal LP solution value, this column ever assumed */
96  SCIP_COL* col /**< LP column */
97  );
98 
99 /** gets the basis status of a column in the LP solution; only valid for LPs with status SCIP_LPSOLSTAT_OPTIMAL
100  * and with SCIPisLPSolBasic(scip) == TRUE; returns SCIP_BASESTAT_ZERO for columns not in the current SCIP_LP
101  */
104  SCIP_COL* col /**< LP column */
105  );
106 
107 /** gets variable this column represents */
110  SCIP_COL* col /**< LP column */
111  );
112 
113 /** gets unique index of col */
115 int SCIPcolGetIndex(
116  SCIP_COL* col /**< LP col */
117  );
118 
119 /** gets probindex of corresponding variable */
122  SCIP_COL* col /**< LP col */
123  );
124 
125 /** returns whether the associated variable is of integral type (binary, integer, implicit integer) */
128  SCIP_COL* col /**< LP column */
129  );
130 
131 /** returns TRUE iff column is removable from the LP (due to aging or cleanup) */
134  SCIP_COL* col /**< LP column */
135  );
136 
137 /** gets position of column in current LP, or -1 if it is not in LP */
139 int SCIPcolGetLPPos(
140  SCIP_COL* col /**< LP column */
141  );
142 
143 /** gets depth in the tree where the column entered the LP, or -1 if it is not in LP */
146  SCIP_COL* col /**< LP column */
147  );
148 
149 /** returns TRUE iff column is member of current LP */
152  SCIP_COL* col /**< LP column */
153  );
154 
155 /** get number of nonzero entries in column vector */
157 int SCIPcolGetNNonz(
158  SCIP_COL* col /**< LP column */
159  );
160 
161 /** get number of nonzero entries in column vector, that correspond to rows currently in the SCIP_LP;
162  *
163  * @warning This method is only applicable on columns, that are completely linked to their rows (e.g. a column
164  * 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
165  */
168  SCIP_COL* col /**< LP column */
169  );
170 
171 /** gets array with rows of nonzero entries */
174  SCIP_COL* col /**< LP column */
175  );
176 
177 /** gets array with coefficients of nonzero entries */
180  SCIP_COL* col /**< LP column */
181  );
182 
183 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
184  * given column, or -1 if strong branching was never applied to the column in current run
185  */
188  SCIP_COL* col /**< LP column */
189  );
190 
191 /** gets number of times, strong branching was applied in current run on the given column */
194  SCIP_COL* col /**< LP column */
195  );
196 
197 /** 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 */
199 int SCIPcolGetAge(
200  SCIP_COL* col /**< LP column */
201  );
202 
203 /** gets opposite bound type of given bound type */
206  SCIP_BOUNDTYPE boundtype /**< type of bound (lower or upper) */
207  );
208 
209 #ifdef NDEBUG
210 
211 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
212  * speed up the algorithms.
213  */
214 
215 #define SCIPcolGetObj(col) (col)->obj
216 #define SCIPcolGetLb(col) (col)->lb
217 #define SCIPcolGetUb(col) (col)->ub
218 #define SCIPcolGetBestBound(col) ((col)->obj >= 0.0 ? (col)->lb : (col)->ub)
219 #define SCIPcolGetPrimsol(col) ((col)->lppos >= 0 ? (col)->primsol : 0.0)
220 #define SCIPcolGetMinPrimsol(col) ((col)->minprimsol)
221 #define SCIPcolGetMaxPrimsol(col) ((col)->maxprimsol)
222 #define SCIPcolGetBasisStatus(col) ((SCIP_BASESTAT)(col)->basisstatus)
223 #define SCIPcolGetVar(col) (col)->var
224 #define SCIPcolGetIndex(col) (col)->index
225 #define SCIPcolIsIntegral(col) (col)->integral
226 #define SCIPcolIsRemovable(col) (col)->removable
227 #define SCIPcolGetLPPos(col) (col)->lppos
228 #define SCIPcolGetLPDepth(col) (col)->lpdepth
229 #define SCIPcolIsInLP(col) ((col)->lppos >= 0)
230 #define SCIPcolGetNNonz(col) (col)->len
231 #define SCIPcolGetNLPNonz(col) (col)->nlprows
232 #define SCIPcolGetRows(col) (col)->rows
233 #define SCIPcolGetVals(col) (col)->vals
234 #define SCIPcolGetStrongbranchNode(col) (col)->sbnode
235 #define SCIPcolGetNStrongbranchs(col) (col)->nsbcalls
236 #define SCIPcolGetAge(col) (col)->age
237 #define SCIPboundtypeOpposite(boundtype) \
238  ((boundtype) == SCIP_BOUNDTYPE_LOWER ? SCIP_BOUNDTYPE_UPPER : SCIP_BOUNDTYPE_LOWER)
239 
240 #endif
241 
242 /**@} */
243 
244 
245 
246 /**@addtogroup PublicRowMethods
247  *
248  * @{
249  */
250 
251 /** comparison method for sorting rows by non-decreasing index */
253 SCIP_DECL_SORTPTRCOMP(SCIProwComp);
254 
255 /** locks an unmodifiable row, which forbids further changes; has no effect on modifiable rows */
257 void SCIProwLock(
258  SCIP_ROW* row /**< LP row */
259  );
260 
261 /** unlocks a lock of an unmodifiable row; a row with no sealed lock may be modified; has no effect on modifiable rows */
263 void SCIProwUnlock(
264  SCIP_ROW* row /**< LP row */
265  );
266 
267 /** returns the scalar product of the coefficient vectors of the two given rows */
270  SCIP_ROW* row1, /**< first LP row */
271  SCIP_ROW* row2 /**< second LP row */
272  );
273 
274 /** returns the degree of parallelism between the hyperplanes defined by the two row vectors v, w:
275  * p = |v*w|/(|v|*|w|);
276  * the hyperplanes are parallel, iff p = 1, they are orthogonal, iff p = 0
277  */
280  SCIP_ROW* row1, /**< first LP row */
281  SCIP_ROW* row2, /**< second LP row */
282  char orthofunc /**< function used for calc. scalar prod. ('e'uclidean, 'd'iscrete) */
283  );
284 
285 /** returns the degree of orthogonality between the hyperplanes defined by the two row vectors v, w:
286  * o = 1 - |v*w|/(|v|*|w|);
287  * the hyperplanes are orthogonal, iff p = 1, they are parallel, iff p = 0
288  */
291  SCIP_ROW* row1, /**< first LP row */
292  SCIP_ROW* row2, /**< second LP row */
293  char orthofunc /**< function used for calc. scalar prod. ('e'uclidean, 'd'iscrete) */
294  );
295 
296 /** sorts row entries such that LP columns precede non-LP columns and inside both parts lower column indices precede
297  * higher ones
298  */
300 void SCIProwSort(
301  SCIP_ROW* row /**< row to be sorted */
302  );
303 
304 /** get number of nonzero entries in row vector */
306 int SCIProwGetNNonz(
307  SCIP_ROW* row /**< LP row */
308  );
309 
310 /** get number of nonzero entries in row vector, that correspond to columns currently in the SCIP_LP;
311  *
312  * @warning This method is only applicable on rows, that are completely linked to their columns (e.g. a row
313  * 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
314  */
317  SCIP_ROW* row /**< LP row */
318  );
319 
320 /** gets array with columns of nonzero entries */
323  SCIP_ROW* row /**< LP row */
324  );
325 
326 /** gets array with coefficients of nonzero entries */
329  SCIP_ROW* row /**< LP row */
330  );
331 
332 /** gets constant shift of row */
335  SCIP_ROW* row /**< LP row */
336  );
337 
338 /** gets Euclidean norm of row vector */
341  SCIP_ROW* row /**< LP row */
342  );
343 
344 /** gets sum norm of row vector (sum of absolute values of coefficients) */
347  SCIP_ROW* row /**< LP row */
348  );
349 
350 /** returns the left hand side of the row */
353  SCIP_ROW* row /**< LP row */
354  );
355 
356 /** returns the right hand side of the row */
359  SCIP_ROW* row /**< LP row */
360  );
361 
362 /** gets the dual LP solution of a row */
365  SCIP_ROW* row /**< LP row */
366  );
367 
368 /** gets the dual Farkas coefficient of a row in an infeasible LP */
371  SCIP_ROW* row /**< LP row */
372  );
373 
374 /** gets the basis status of a row in the LP solution; only valid for LPs with status SCIP_LPSOLSTAT_OPTIMAL
375  * and with SCIPisLPSolBasic(scip) == TRUE; returns SCIP_BASESTAT_BASIC for rows not in the current SCIP_LP
376  */
379  SCIP_ROW* row /**< LP row */
380  );
381 
382 /** returns the name of the row */
384 const char* SCIProwGetName(
385  SCIP_ROW* row /**< LP row */
386  );
387 
388 /** gets unique index of row */
390 int SCIProwGetIndex(
391  SCIP_ROW* row /**< LP row */
392  );
393 
394 /** gets age of row */
396 int SCIProwGetAge(
397  SCIP_ROW* row /**< LP row */
398  );
399 
400 /** gets rank of row */
402 int SCIProwGetRank(
403  SCIP_ROW* row /**< LP row */
404  );
405 
406 /** returns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution */
409  SCIP_ROW* row /**< LP row */
410  );
411 
412 /** returns TRUE iff row is only valid locally */
415  SCIP_ROW* row /**< LP row */
416  );
417 
418 /** returns TRUE iff row is modifiable during node processing (subject to column generation) */
421  SCIP_ROW* row /**< LP row */
422  );
423 
424 /** returns TRUE iff row is removable from the LP (due to aging or cleanup) */
427  SCIP_ROW* row /**< LP row */
428  );
429 
430 /** returns type of origin that created the row */
433  SCIP_ROW* row /**< LP row */
434  );
435 
436 /** returns origin constraint handler that created the row (NULL if not available) */
439  SCIP_ROW* row /**< LP row */
440  );
441 
442 /** returns origin constraint that created the row (NULL if not available) */
445  SCIP_ROW* row /**< LP row */
446  );
447 
448 /** returns origin separator that created the row (NULL if not available) */
451  SCIP_ROW* row /**< LP row */
452  );
453 
454 /** returns TRUE iff row is member of the global cut pool */
457  SCIP_ROW* row /**< LP row */
458  );
459 
460 /** gets position of row in current LP, or -1 if it is not in LP */
462 int SCIProwGetLPPos(
463  SCIP_ROW* row /**< LP row */
464  );
465 
466 /** gets depth in the tree where the row entered the LP, or -1 if it is not in LP */
469  SCIP_ROW* row /**< LP row */
470  );
471 
472 /** returns TRUE iff row is member of current LP */
475  SCIP_ROW* row /**< LP row */
476  );
477 
478 /** returns the number of times that this row has been sharp in an optimal LP solution */
481  SCIP_ROW* row /**< row */
482  );
483 
484 /** returns the number of LPs since this row has been created */
487  SCIP_ROW* row /**< row */
488  );
489 
490 /** changes the rank of LP row */
492 void SCIProwChgRank(
493  SCIP_ROW* row, /**< LP row */
494  int rank /**< new value for rank */
495  );
496 
497 #ifdef NDEBUG
498 
499 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
500  * speed up the algorithms.
501  */
502 
503 #define SCIProwGetNNonz(row) (row)->len
504 #define SCIProwGetNLPNonz(row) (row)->nlpcols
505 #define SCIProwGetCols(row) (row)->cols
506 #define SCIProwGetVals(row) (row)->vals
507 #define SCIProwGetConstant(row) (row)->constant
508 #define SCIProwGetNorm(row) sqrt((row)->sqrnorm)
509 #define SCIProwGetSumNorm(row) (row)->sumnorm
510 #define SCIProwGetLhs(row) (row)->lhs
511 #define SCIProwGetRhs(row) (row)->rhs
512 #define SCIProwGetDualsol(row) ((row)->lppos >= 0 ? (row)->dualsol : 0.0)
513 #define SCIProwGetDualfarkas(row) ((row)->lppos >= 0 ? (row)->dualfarkas : 0.0)
514 #define SCIProwGetBasisStatus(row) ((SCIP_BASESTAT) (row)->basisstatus)
515 #define SCIProwGetName(row) (row)->name
516 #define SCIProwGetIndex(row) (row)->index
517 #define SCIProwGetAge(row) (row)->age
518 #define SCIProwGetRank(row) (row)->rank
519 #define SCIProwIsIntegral(row) (row)->integral
520 #define SCIProwIsLocal(row) (row)->local
521 #define SCIProwIsModifiable(row) (row)->modifiable
522 #define SCIProwIsRemovable(row) (row)->removable
523 #define SCIProwGetOrigintype(row) (row)->origintype
524 #define SCIProwGetOriginCons(row) ((SCIP_CONS*) ((SCIP_ROWORIGINTYPE) row->origintype == SCIP_ROWORIGINTYPE_CONS ? (row)->origin : NULL))
525 #define SCIProwGetOriginSepa(row) ((SCIP_SEPA*) ((SCIP_ROWORIGINTYPE) row->origintype == SCIP_ROWORIGINTYPE_SEPA ? (row)->origin : NULL))
526 #define SCIProwIsInGlobalCutpool(row) (row)->inglobalcutpool
527 #define SCIProwGetLPPos(row) (row)->lppos
528 #define SCIProwGetLPDepth(row) (row)->lpdepth
529 #define SCIProwIsInLP(row) ((row)->lppos >= 0)
530 #define SCIProwGetActiveLPCount(row) ((row)->activeinlpcounter)
531 #define SCIProwGetNLPsAfterCreation(row) ((row)->nlpsaftercreation)
532 #define SCIProwChgRank(row, cutrank) ((row)->rank = (cutrank))
533 
534 #endif
535 
536 /**@} */
537 
538 #ifdef __cplusplus
539 }
540 #endif
541 
542 #endif
SCIP_EXPORT SCIP_Longint SCIProwGetActiveLPCount(SCIP_ROW *row)
Definition: lp.c:17407
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_EXPORT SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
Definition: lp.c:17263
SCIP_EXPORT SCIP_Longint SCIPcolGetStrongbranchNode(SCIP_COL *col)
Definition: lp.c:17035
SCIP_EXPORT SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
Definition: lp.c:17174
SCIP_EXPORT int SCIProwGetNLPNonz(SCIP_ROW *row)
Definition: lp.c:17089
type definitions for miscellaneous datastructures
enum SCIP_BaseStat SCIP_BASESTAT
Definition: type_lpi.h:87
SCIP_EXPORT SCIP_Bool SCIProwIsRemovable(SCIP_ROW *row)
Definition: lp.c:17283
SCIP_EXPORT SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
Definition: lp.c:17023
enum SCIP_RowOriginType SCIP_ROWORIGINTYPE
Definition: type_lp.h:69
SCIP_EXPORT SCIP_Bool SCIPcolIsIntegral(SCIP_COL *col)
Definition: lp.c:16934
SCIP_EXPORT int SCIProwGetNNonz(SCIP_ROW *row)
Definition: lp.c:17075
#define SCIP_EXPORT
Definition: def.h:100
SCIP_EXPORT int SCIPcolGetNNonz(SCIP_COL *col)
Definition: lp.c:16988
SCIP_EXPORT SCIP_Real SCIPcolGetMaxPrimsol(SCIP_COL *col)
Definition: lp.c:16881
SCIP_EXPORT SCIP_Real SCIProwGetOrthogonality(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
Definition: lp.c:7776
SCIP_EXPORT SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
Definition: lp.c:17120
SCIP_EXPORT SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
Definition: lp.c:17013
SCIP_EXPORT int SCIProwGetRank(SCIP_ROW *row)
Definition: lp.c:17243
SCIP_EXPORT SCIP_Real SCIPcolGetBestBound(SCIP_COL *col)
Definition: lp.c:16845
SCIP_EXPORT SCIP_Real SCIPcolGetObj(SCIP_COL *col)
Definition: lp.c:16815
SCIP_EXPORT int SCIProwGetLPPos(SCIP_ROW *row)
Definition: lp.c:17363
SCIP_EXPORT SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)
Definition: lp.c:17273
SCIP_EXPORT SCIP_Real SCIPcolGetLb(SCIP_COL *col)
Definition: lp.c:16825
SCIP_EXPORT SCIP_CONS * SCIProwGetOriginCons(SCIP_ROW *row)
Definition: lp.c:17303
SCIP_EXPORT SCIP_Real SCIProwGetNorm(SCIP_ROW *row)
Definition: lp.c:17130
SCIP_EXPORT SCIP_Real SCIPcolGetMinPrimsol(SCIP_COL *col)
Definition: lp.c:16871
type definitions for LP management
SCIP_EXPORT SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
Definition: lp.c:17385
SCIP_EXPORT SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)
Definition: lp.c:17065
SCIP_EXPORT SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
Definition: lp.c:17100
SCIP_EXPORT void SCIPcolSort(SCIP_COL *col)
Definition: lp.c:3424
SCIP_EXPORT SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
Definition: lp.c:17110
SCIP_EXPORT int SCIProwGetIndex(SCIP_ROW *row)
Definition: lp.c:17223
SCIP_EXPORT int SCIPcolGetNLPNonz(SCIP_COL *col)
Definition: lp.c:17002
type definitions for specific LP solvers interface
SCIP_EXPORT SCIP_Longint SCIProwGetNLPsAfterCreation(SCIP_ROW *row)
Definition: lp.c:17417
SCIP_EXPORT SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
Definition: lp.c:16858
SCIP_EXPORT SCIP_Real SCIPcolGetUb(SCIP_COL *col)
Definition: lp.c:16835
type definitions for problem variables
SCIP_EXPORT SCIP_SEPA * SCIProwGetOriginSepa(SCIP_ROW *row)
Definition: lp.c:17338
SCIP_EXPORT SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)
Definition: lp.c:17202
SCIP_EXPORT SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
Definition: lp.c:17187
SCIP_EXPORT int SCIPcolGetNStrongbranchs(SCIP_COL *col)
Definition: lp.c:17045
#define SCIP_Bool
Definition: def.h:70
SCIP_EXPORT int SCIProwGetAge(SCIP_ROW *row)
Definition: lp.c:17233
SCIP_EXPORT SCIP_Real SCIProwGetSumNorm(SCIP_ROW *row)
Definition: lp.c:17142
SCIP_EXPORT SCIP_Bool SCIProwIsIntegral(SCIP_ROW *row)
Definition: lp.c:17253
SCIP_EXPORT int SCIProwGetLPDepth(SCIP_ROW *row)
Definition: lp.c:17374
SCIP_EXPORT SCIP_Bool SCIPcolIsRemovable(SCIP_COL *col)
Definition: lp.c:16945
SCIP_EXPORT SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
Definition: lp.c:17154
SCIP_EXPORT void SCIProwChgRank(SCIP_ROW *row, int rank)
Definition: lp.c:17396
SCIP_EXPORT void SCIProwSort(SCIP_ROW *row)
Definition: lp.c:6004
SCIP_EXPORT SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
Definition: lp.c:16904
SCIP_EXPORT int SCIPcolGetAge(SCIP_COL *col)
Definition: lp.c:17055
SCIP_EXPORT SCIP_Real SCIProwGetScalarProduct(SCIP_ROW *row1, SCIP_ROW *row2)
Definition: lp.c:6996
SCIP_EXPORT SCIP_Real SCIProwGetParallelism(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
Definition: lp.c:7712
SCIP_EXPORT int SCIPcolGetVarProbindex(SCIP_COL *col)
Definition: lp.c:16924
SCIP_EXPORT SCIP_Bool SCIProwIsInGlobalCutpool(SCIP_ROW *row)
Definition: lp.c:17353
type definitions for separators
SCIP_EXPORT SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
Definition: lp.c:16977
SCIP_EXPORT int SCIPcolGetLPDepth(SCIP_COL *col)
Definition: lp.c:16966
data structures for LP management
#define SCIP_Real
Definition: def.h:163
SCIP_EXPORT void SCIProwUnlock(SCIP_ROW *row)
Definition: lp.c:5381
SCIP_EXPORT SCIP_CONSHDLR * SCIProwGetOriginConshdlr(SCIP_ROW *row)
Definition: lp.c:17318
SCIP_EXPORT const char * SCIProwGetName(SCIP_ROW *row)
Definition: lp.c:17213
#define SCIP_Longint
Definition: def.h:148
SCIP_EXPORT SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
Definition: lp.c:16893
SCIP_EXPORT SCIP_DECL_SORTPTRCOMP(SCIProwComp)
Definition: lp.c:936
SCIP_EXPORT SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
Definition: lp.c:17164
common defines and data types used in all packages of SCIP
SCIP_EXPORT void SCIProwLock(SCIP_ROW *row)
Definition: lp.c:5366
type definitions for constraints and constraint handlers
SCIP_EXPORT int SCIPcolGetIndex(SCIP_COL *col)
Definition: lp.c:16914
SCIP_EXPORT int SCIPcolGetLPPos(SCIP_COL *col)
Definition: lp.c:16955
SCIP_EXPORT SCIP_ROWORIGINTYPE SCIProwGetOrigintype(SCIP_ROW *row)
Definition: lp.c:17293