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-2022 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  */
52 SCIP_EXPORT
53 void SCIPcolSort(
54  SCIP_COL* col /**< column to be sorted */
55  );
56 
57 /** gets objective value of column */
58 SCIP_EXPORT
60  SCIP_COL* col /**< LP column */
61  );
62 
63 /** gets lower bound of column */
64 SCIP_EXPORT
66  SCIP_COL* col /**< LP column */
67  );
68 
69 /** gets upper bound of column */
70 SCIP_EXPORT
72  SCIP_COL* col /**< LP column */
73  );
74 
75 /** gets best bound of column with respect to the objective function */
76 SCIP_EXPORT
78  SCIP_COL* col /**< LP column */
79  );
80 
81 /** gets the primal LP solution of a column */
82 SCIP_EXPORT
84  SCIP_COL* col /**< LP column */
85  );
86 
87 /** gets the minimal LP solution value, this column ever assumed */
88 SCIP_EXPORT
90  SCIP_COL* col /**< LP column */
91  );
92 
93 /** gets the maximal LP solution value, this column ever assumed */
94 SCIP_EXPORT
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  */
102 SCIP_EXPORT
104  SCIP_COL* col /**< LP column */
105  );
106 
107 /** gets variable this column represents */
108 SCIP_EXPORT
110  SCIP_COL* col /**< LP column */
111  );
112 
113 /** gets unique index of col */
114 SCIP_EXPORT
115 int SCIPcolGetIndex(
116  SCIP_COL* col /**< LP col */
117  );
118 
119 /** gets probindex of corresponding variable */
120 SCIP_EXPORT
122  SCIP_COL* col /**< LP col */
123  );
124 
125 /** returns whether the associated variable is of integral type (binary, integer, implicit integer) */
126 SCIP_EXPORT
128  SCIP_COL* col /**< LP column */
129  );
130 
131 /** returns TRUE iff column is removable from the LP (due to aging or cleanup) */
132 SCIP_EXPORT
134  SCIP_COL* col /**< LP column */
135  );
136 
137 /** gets position of column in current LP, or -1 if it is not in LP */
138 SCIP_EXPORT
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 */
144 SCIP_EXPORT
146  SCIP_COL* col /**< LP column */
147  );
148 
149 /** returns TRUE iff column is member of current LP */
150 SCIP_EXPORT
152  SCIP_COL* col /**< LP column */
153  );
154 
155 /** get number of nonzero entries in column vector */
156 SCIP_EXPORT
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  */
166 SCIP_EXPORT
168  SCIP_COL* col /**< LP column */
169  );
170 
171 /** gets array with rows of nonzero entries */
172 SCIP_EXPORT
174  SCIP_COL* col /**< LP column */
175  );
176 
177 /** gets array with coefficients of nonzero entries */
178 SCIP_EXPORT
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  */
186 SCIP_EXPORT
188  SCIP_COL* col /**< LP column */
189  );
190 
191 /** gets number of times, strong branching was applied in current run on the given column */
192 SCIP_EXPORT
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 */
198 SCIP_EXPORT
199 int SCIPcolGetAge(
200  SCIP_COL* col /**< LP column */
201  );
202 
203 /** gets opposite bound type of given bound type */
204 SCIP_EXPORT
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 */
252 SCIP_EXPORT
253 SCIP_DECL_SORTPTRCOMP(SCIProwComp);
254 
255 /** locks an unmodifiable row, which forbids further changes; has no effect on modifiable rows */
256 SCIP_EXPORT
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 */
262 SCIP_EXPORT
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 */
268 SCIP_EXPORT
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  */
278 SCIP_EXPORT
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  */
289 SCIP_EXPORT
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  */
299 SCIP_EXPORT
300 void SCIProwSort(
301  SCIP_ROW* row /**< row to be sorted */
302  );
303 
304 /** get number of nonzero entries in row vector */
305 SCIP_EXPORT
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  */
315 SCIP_EXPORT
317  SCIP_ROW* row /**< LP row */
318  );
319 
320 /** gets array with columns of nonzero entries */
321 SCIP_EXPORT
323  SCIP_ROW* row /**< LP row */
324  );
325 
326 /** gets array with coefficients of nonzero entries */
327 SCIP_EXPORT
329  SCIP_ROW* row /**< LP row */
330  );
331 
332 /** gets constant shift of row */
333 SCIP_EXPORT
335  SCIP_ROW* row /**< LP row */
336  );
337 
338 /** gets Euclidean norm of row vector */
339 SCIP_EXPORT
341  SCIP_ROW* row /**< LP row */
342  );
343 
344 /** gets sum norm of row vector (sum of absolute values of coefficients) */
345 SCIP_EXPORT
347  SCIP_ROW* row /**< LP row */
348  );
349 
350 /** returns the left hand side of the row */
351 SCIP_EXPORT
353  SCIP_ROW* row /**< LP row */
354  );
355 
356 /** returns the right hand side of the row */
357 SCIP_EXPORT
359  SCIP_ROW* row /**< LP row */
360  );
361 
362 /** gets the dual LP solution of a row */
363 SCIP_EXPORT
365  SCIP_ROW* row /**< LP row */
366  );
367 
368 /** gets the dual Farkas coefficient of a row in an infeasible LP */
369 SCIP_EXPORT
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  */
377 SCIP_EXPORT
379  SCIP_ROW* row /**< LP row */
380  );
381 
382 /** returns the name of the row */
383 SCIP_EXPORT
384 const char* SCIProwGetName(
385  SCIP_ROW* row /**< LP row */
386  );
387 
388 /** gets unique index of row */
389 SCIP_EXPORT
390 int SCIProwGetIndex(
391  SCIP_ROW* row /**< LP row */
392  );
393 
394 /** gets age of row */
395 SCIP_EXPORT
396 int SCIProwGetAge(
397  SCIP_ROW* row /**< LP row */
398  );
399 
400 /** gets rank of row */
401 SCIP_EXPORT
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 */
407 SCIP_EXPORT
409  SCIP_ROW* row /**< LP row */
410  );
411 
412 /** returns TRUE iff row is only valid locally */
413 SCIP_EXPORT
415  SCIP_ROW* row /**< LP row */
416  );
417 
418 /** returns TRUE iff row is modifiable during node processing (subject to column generation) */
419 SCIP_EXPORT
421  SCIP_ROW* row /**< LP row */
422  );
423 
424 /** returns TRUE iff row is removable from the LP (due to aging or cleanup) */
425 SCIP_EXPORT
427  SCIP_ROW* row /**< LP row */
428  );
429 
430 /** returns type of origin that created the row */
431 SCIP_EXPORT
433  SCIP_ROW* row /**< LP row */
434  );
435 
436 /** returns origin constraint handler that created the row (NULL if not available) */
437 SCIP_EXPORT
439  SCIP_ROW* row /**< LP row */
440  );
441 
442 /** returns origin constraint that created the row (NULL if not available) */
443 SCIP_EXPORT
445  SCIP_ROW* row /**< LP row */
446  );
447 
448 /** returns origin separator that created the row (NULL if not available) */
449 SCIP_EXPORT
451  SCIP_ROW* row /**< LP row */
452  );
453 
454 /** returns TRUE iff row is member of the global cut pool */
455 SCIP_EXPORT
457  SCIP_ROW* row /**< LP row */
458  );
459 
460 /** gets position of row in current LP, or -1 if it is not in LP */
461 SCIP_EXPORT
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 */
467 SCIP_EXPORT
469  SCIP_ROW* row /**< LP row */
470  );
471 
472 /** returns TRUE iff row is member of current LP */
473 SCIP_EXPORT
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 */
479 SCIP_EXPORT
481  SCIP_ROW* row /**< row */
482  );
483 
484 /** returns the number of LPs since this row has been created */
485 SCIP_EXPORT
487  SCIP_ROW* row /**< row */
488  );
489 
490 /** changes the rank of LP row */
491 SCIP_EXPORT
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_Bool SCIProwIsRemovable(SCIP_ROW *row)
Definition: lp.c:17387
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_Real SCIProwGetScalarProduct(SCIP_ROW *row1, SCIP_ROW *row2)
Definition: lp.c:7003
type definitions for miscellaneous datastructures
int SCIProwGetAge(SCIP_ROW *row)
Definition: lp.c:17337
SCIP_SEPA * SCIProwGetOriginSepa(SCIP_ROW *row)
Definition: lp.c:17442
enum SCIP_BaseStat SCIP_BASESTAT
Definition: type_lpi.h:87
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
Definition: lp.c:16997
enum SCIP_RowOriginType SCIP_ROWORIGINTYPE
Definition: type_lp.h:69
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
Definition: lp.c:17127
SCIP_Longint SCIPcolGetStrongbranchNode(SCIP_COL *col)
Definition: lp.c:17139
int SCIProwGetNNonz(SCIP_ROW *row)
Definition: lp.c:17179
const char * SCIProwGetName(SCIP_ROW *row)
Definition: lp.c:17317
SCIP_Longint SCIProwGetActiveLPCount(SCIP_ROW *row)
Definition: lp.c:17511
int SCIProwGetNLPNonz(SCIP_ROW *row)
Definition: lp.c:17193
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
Definition: lp.c:17258
SCIP_Bool SCIPcolIsIntegral(SCIP_COL *col)
Definition: lp.c:17038
SCIP_Real SCIPcolGetUb(SCIP_COL *col)
Definition: lp.c:16939
SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)
Definition: lp.c:17306
SCIP_Real SCIPcolGetObj(SCIP_COL *col)
Definition: lp.c:16919
int SCIPcolGetLPDepth(SCIP_COL *col)
Definition: lp.c:17070
SCIP_CONS * SCIProwGetOriginCons(SCIP_ROW *row)
Definition: lp.c:17407
SCIP_ROWORIGINTYPE SCIProwGetOrigintype(SCIP_ROW *row)
Definition: lp.c:17397
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
Definition: lp.c:17278
type definitions for LP management
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
Definition: lp.c:17489
int SCIPcolGetAge(SCIP_COL *col)
Definition: lp.c:17159
SCIP_Real SCIProwGetSumNorm(SCIP_ROW *row)
Definition: lp.c:17246
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
Definition: lp.c:16962
void SCIProwSort(SCIP_ROW *row)
Definition: lp.c:6011
SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)
Definition: lp.c:17169
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
Definition: lp.c:17117
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
Definition: lp.c:17367
SCIP_Real SCIPcolGetLb(SCIP_COL *col)
Definition: lp.c:16929
SCIP_Bool SCIProwIsIntegral(SCIP_ROW *row)
Definition: lp.c:17357
type definitions for specific LP solvers interface
type definitions for problem variables
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
Definition: lp.c:17268
SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)
Definition: lp.c:17377
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
Definition: lp.c:17204
int SCIPcolGetIndex(SCIP_COL *col)
Definition: lp.c:17018
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
Definition: lp.c:17214
#define SCIP_Bool
Definition: def.h:84
SCIP_Real SCIPcolGetBestBound(SCIP_COL *col)
Definition: lp.c:16949
SCIP_Bool SCIPcolIsRemovable(SCIP_COL *col)
Definition: lp.c:17049
SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
Definition: lp.c:17291
SCIP_CONSHDLR * SCIProwGetOriginConshdlr(SCIP_ROW *row)
Definition: lp.c:17422
int SCIProwGetRank(SCIP_ROW *row)
Definition: lp.c:17347
SCIP_Real SCIPcolGetMinPrimsol(SCIP_COL *col)
Definition: lp.c:16975
void SCIProwLock(SCIP_ROW *row)
Definition: lp.c:5373
SCIP_Real SCIProwGetParallelism(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
Definition: lp.c:7719
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
Definition: lp.c:17224
int SCIPcolGetNNonz(SCIP_COL *col)
Definition: lp.c:17092
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
Definition: lp.c:17008
void SCIProwChgRank(SCIP_ROW *row, int rank)
Definition: lp.c:17500
type definitions for separators
data structures for LP management
int SCIPcolGetNStrongbranchs(SCIP_COL *col)
Definition: lp.c:17149
int SCIProwGetLPPos(SCIP_ROW *row)
Definition: lp.c:17467
#define SCIP_Real
Definition: def.h:177
#define SCIP_Longint
Definition: def.h:162
int SCIProwGetLPDepth(SCIP_ROW *row)
Definition: lp.c:17478
int SCIProwGetIndex(SCIP_ROW *row)
Definition: lp.c:17327
void SCIPcolSort(SCIP_COL *col)
Definition: lp.c:3430
SCIP_DECL_SORTPTRCOMP(SCIProwComp)
Definition: lp.c:941
common defines and data types used in all packages of SCIP
SCIP_Real SCIPcolGetMaxPrimsol(SCIP_COL *col)
Definition: lp.c:16985
int SCIPcolGetNLPNonz(SCIP_COL *col)
Definition: lp.c:17106
int SCIPcolGetLPPos(SCIP_COL *col)
Definition: lp.c:17059
SCIP_Longint SCIProwGetNLPsAfterCreation(SCIP_ROW *row)
Definition: lp.c:17521
SCIP_Real SCIProwGetNorm(SCIP_ROW *row)
Definition: lp.c:17234
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
Definition: lp.c:17081
SCIP_Real SCIProwGetOrthogonality(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
Definition: lp.c:7783
type definitions for constraints and constraint handlers
int SCIPcolGetVarProbindex(SCIP_COL *col)
Definition: lp.c:17028
void SCIProwUnlock(SCIP_ROW *row)
Definition: lp.c:5388
SCIP_Bool SCIProwIsInGlobalCutpool(SCIP_ROW *row)
Definition: lp.c:17457