Scippy

SCIP

Solving Constraint Integer Programs

lpi.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-2017 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 email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file lpi.h
17  * @ingroup LPIS
18  * @brief interface methods for specific LP solvers
19  * @author Tobias Achterberg
20  * @author Marc Pfetsch
21  *
22  */
23 
24 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
25 
26 #ifndef __SCIP_LPI_H__
27 #define __SCIP_LPI_H__
28 
29 
30 #include "scip/def.h"
31 #include "blockmemshell/memory.h"
32 #include "scip/type_retcode.h"
33 #include "lpi/type_lpi.h"
34 
35 #ifdef __cplusplus
36 extern "C" {
37 #endif
38 
39 /**@addtogroup LPIS
40  *
41  * This file specifies a generic LP solver interface used by SCIP to create, modify, and solve linear programs of the
42  * form
43  *
44  * min/max obj * x
45  * lhs <= A * x <= rhs
46  * lb <= x <= ub
47  *
48  * and query information about the solution. Although it includes a few SCIP header files, e.g., because it uses SCIP's
49  * return codes, it can be used independently of any SCIP instance.
50  *
51  * The basis status for (column) variables are as follows:
52  * - If x_j = lb, then j is at its lower bound (SCIP_BASESTAT_LOWER).
53  * - If x_j = ub, then j is at its lower bound (SCIP_BASESTAT_UPPER).
54  * - If x_j is in the basis, it has SCIP_BASESTAT_BASIC status.
55  * - If x_j is free and non-basic, it has SCIP_BASESTAT_ZERO status.
56  *
57  * The basis status for (row) slack variables are:
58  * - If (A * x)_i = lhs, then i is at its lower bound (SCIP_BASESTAT_LOWER).
59  * - If (A * x)_i = rhs, then i is at its upper bound (SCIP_BASESTAT_UPPER).
60  * - If the slack variable for row i is basic, it has SCIP_BASESTAT_BASIC status.
61  *
62  * If the solvers use their status differently, those status codes have to be corrected.
63  *
64  * In the methods accessing information about the (inverse of the) basis matrix, the interface assumes the following
65  * column-oriented format: slack variables of rows have coefficient +1 and the basis matrix is a regular m times m
66  * submatrix of (A,I), where m is the number of rows and I is the identity matrix. This means that if, internally, the
67  * LP solver uses coefficients -1 for some of the slack variables, then every row associated with a slack variable whose
68  * coefficient is -1 should be negated in order to return the result in terms of the LP interface definition.
69  *
70  * The creation of a new LP should always be done in the following ways: Either one can use SCIPlpiLoadColLP() or one
71  * first adds empty columns or rows. Then the matrix entries can be added by adding columns and rows, respectively.
72  * Adding matrix entries for a row or column that have not been added before will result in an error.
73  *
74  * The handling of the objective limit is as follows, if supported by the LP-solver: If the objective is larger than the
75  * objective limit for minimization problems or smaller than the objective limit for maximization problems, the solution
76  * process can be stopped. This naturally occurs in a branch-and-bound process, where the objective limit is set to the
77  * value of the best solution found so far. If the problem is a minimization problem and we use the dual simplex, the
78  * dual feasible solutions are maximized. If their value are larger than the objective limit, the process can be
79  * stopped. In this case, no feasible integer solution can be found in the corresponding branch.
80  *
81  * Some LP-solvers also support the opposite setting, but this can easily be checked after the solution process (i.e.,
82  * for a minimization problem a check whether the optimal value is smaller than the limit). Note that this check can
83  * only be determined at the end of the optimization. Thus, we do not support this.
84  *
85  * @{
86  */
87 
88 /*
89  * Miscellaneous Methods
90  */
91 
92 /**@name Miscellaneous Methods */
93 /**@{ */
94 
95 /** gets name and version of LP solver */
96 extern
97 const char* SCIPlpiGetSolverName(
98  void
99  );
100 
101 /** gets description of LP solver (developer, webpage, ...) */
102 extern
103 const char* SCIPlpiGetSolverDesc(
104  void
105  );
106 
107 /** gets pointer for LP solver - use only with great care
108  *
109  * The behavior of this function depends on the solver and its use is
110  * therefore only recommended if you really know what you are
111  * doing. In general, it returns a pointer to the LP solver object.
112  */
113 extern
115  SCIP_LPI* lpi /**< pointer to an LP interface structure */
116  );
117 
118 /** pass integrality information about variables to the solver */
119 extern
121  SCIP_LPI* lpi, /**< pointer to an LP interface structure */
122  int ncols, /**< length of integrality array */
123  int* intInfo /**< integrality array (0: continuous, 1: integer) */
124  );
125 
126 /**@} */
127 
128 
129 
130 
131 /*
132  * LPI Creation and Destruction Methods
133  */
134 
135 /**@name LPI Creation and Destruction Methods */
136 /**@{ */
137 
138 /** creates an LP problem object */
139 extern
141  SCIP_LPI** lpi, /**< pointer to an LP interface structure */
142  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler to use for printing messages, or NULL */
143  const char* name, /**< problem name */
144  SCIP_OBJSEN objsen /**< objective sense */
145  );
146 
147 /** deletes an LP problem object */
148 extern
150  SCIP_LPI** lpi /**< pointer to an LP interface structure */
151  );
152 
153 /**@} */
154 
155 
156 
157 
158 /*
159  * Modification Methods
160  */
161 
162 /**@name Modification Methods */
163 /**@{ */
164 
165 /** copies LP data with column matrix into LP solver */
166 extern
168  SCIP_LPI* lpi, /**< LP interface structure */
169  SCIP_OBJSEN objsen, /**< objective sense */
170  int ncols, /**< number of columns */
171  const SCIP_Real* obj, /**< objective function values of columns */
172  const SCIP_Real* lb, /**< lower bounds of columns */
173  const SCIP_Real* ub, /**< upper bounds of columns */
174  char** colnames, /**< column names, or NULL */
175  int nrows, /**< number of rows */
176  const SCIP_Real* lhs, /**< left hand sides of rows */
177  const SCIP_Real* rhs, /**< right hand sides of rows */
178  char** rownames, /**< row names, or NULL */
179  int nnonz, /**< number of nonzero elements in the constraint matrix */
180  const int* beg, /**< start index of each column in ind- and val-array */
181  const int* ind, /**< row indices of constraint matrix entries */
182  const SCIP_Real* val /**< values of constraint matrix entries */
183  );
184 
185 /** adds columns to the LP
186  *
187  * @note ind array is not checked for duplicates, problems may appear if indeces are added more than once
188  */
189 extern
191  SCIP_LPI* lpi, /**< LP interface structure */
192  int ncols, /**< number of columns to be added */
193  const SCIP_Real* obj, /**< objective function values of new columns */
194  const SCIP_Real* lb, /**< lower bounds of new columns */
195  const SCIP_Real* ub, /**< upper bounds of new columns */
196  char** colnames, /**< column names, or NULL */
197  int nnonz, /**< number of nonzero elements to be added to the constraint matrix */
198  const int* beg, /**< start index of each column in ind- and val-array, or NULL if nnonz == 0 */
199  const int* ind, /**< row indices of constraint matrix entries, or NULL if nnonz == 0 */
200  const SCIP_Real* val /**< values of constraint matrix entries, or NULL if nnonz == 0 */
201  );
202 
203 /** deletes all columns in the given range from LP */
204 extern
206  SCIP_LPI* lpi, /**< LP interface structure */
207  int firstcol, /**< first column to be deleted */
208  int lastcol /**< last column to be deleted */
209  );
210 
211 /** deletes columns from SCIP_LPI; the new position of a column must not be greater that its old position */
212 extern
214  SCIP_LPI* lpi, /**< LP interface structure */
215  int* dstat /**< deletion status of columns
216  * input: 1 if column should be deleted, 0 if not
217  * output: new position of column, -1 if column was deleted */
218  );
219 
220 /** adds rows to the LP
221  *
222  * @note ind array is not checked for duplicates, problems may appear if indeces are added more than once
223  */
224 extern
226  SCIP_LPI* lpi, /**< LP interface structure */
227  int nrows, /**< number of rows to be added */
228  const SCIP_Real* lhs, /**< left hand sides of new rows */
229  const SCIP_Real* rhs, /**< right hand sides of new rows */
230  char** rownames, /**< row names, or NULL */
231  int nnonz, /**< number of nonzero elements to be added to the constraint matrix */
232  const int* beg, /**< start index of each row in ind- and val-array, or NULL if nnonz == 0 */
233  const int* ind, /**< column indices of constraint matrix entries, or NULL if nnonz == 0 */
234  const SCIP_Real* val /**< values of constraint matrix entries, or NULL if nnonz == 0 */
235  );
236 
237 /** deletes all rows in the given range from LP */
238 extern
240  SCIP_LPI* lpi, /**< LP interface structure */
241  int firstrow, /**< first row to be deleted */
242  int lastrow /**< last row to be deleted */
243  );
244 
245 /** deletes rows from SCIP_LPI; the new position of a row must not be greater that its old position */
246 extern
248  SCIP_LPI* lpi, /**< LP interface structure */
249  int* dstat /**< deletion status of rows
250  * input: 1 if row should be deleted, 0 if not
251  * output: new position of row, -1 if row was deleted */
252  );
253 
254 /** clears the whole LP */
255 extern
257  SCIP_LPI* lpi /**< LP interface structure */
258  );
259 
260 /** changes lower and upper bounds of columns */
261 extern
263  SCIP_LPI* lpi, /**< LP interface structure */
264  int ncols, /**< number of columns to change bounds for */
265  const int* ind, /**< column indices */
266  const SCIP_Real* lb, /**< values for the new lower bounds */
267  const SCIP_Real* ub /**< values for the new upper bounds */
268  );
269 
270 /** changes left and right hand sides of rows */
271 extern
273  SCIP_LPI* lpi, /**< LP interface structure */
274  int nrows, /**< number of rows to change sides for */
275  const int* ind, /**< row indices */
276  const SCIP_Real* lhs, /**< new values for left hand sides */
277  const SCIP_Real* rhs /**< new values for right hand sides */
278  );
279 
280 /** changes a single coefficient */
281 extern
283  SCIP_LPI* lpi, /**< LP interface structure */
284  int row, /**< row number of coefficient to change */
285  int col, /**< column number of coefficient to change */
286  SCIP_Real newval /**< new value of coefficient */
287  );
288 
289 /** changes the objective sense */
290 extern
292  SCIP_LPI* lpi, /**< LP interface structure */
293  SCIP_OBJSEN objsen /**< new objective sense */
294  );
295 
296 /** changes objective values of columns in the LP */
297 extern
299  SCIP_LPI* lpi, /**< LP interface structure */
300  int ncols, /**< number of columns to change objective value for */
301  const int* ind, /**< column indices to change objective value for */
302  const SCIP_Real* obj /**< new objective values for columns */
303  );
304 
305 /** multiplies a row with a non-zero scalar; for negative scalars, the row's sense is switched accordingly */
306 extern
308  SCIP_LPI* lpi, /**< LP interface structure */
309  int row, /**< row number to scale */
310  SCIP_Real scaleval /**< scaling multiplier */
311  );
312 
313 /** multiplies a column with a non-zero scalar; the objective value is multiplied with the scalar, and the bounds
314  * are divided by the scalar; for negative scalars, the column's bounds are switched
315  */
316 extern
318  SCIP_LPI* lpi, /**< LP interface structure */
319  int col, /**< column number to scale */
320  SCIP_Real scaleval /**< scaling multiplier */
321  );
322 
323 /**@} */
324 
325 
326 
327 
328 /*
329  * Data Accessing Methods
330  */
331 
332 /**@name Data Accessing Methods */
333 /**@{ */
334 
335 /** gets the number of rows in the LP */
336 extern
338  SCIP_LPI* lpi, /**< LP interface structure */
339  int* nrows /**< pointer to store the number of rows */
340  );
341 
342 /** gets the number of columns in the LP */
343 extern
345  SCIP_LPI* lpi, /**< LP interface structure */
346  int* ncols /**< pointer to store the number of cols */
347  );
348 
349 /** gets the objective sense of the LP */
351  SCIP_LPI* lpi, /**< LP interface structure */
352  SCIP_OBJSEN* objsen /**< pointer to store objective sense */
353  );
354 
355 /** gets the number of nonzero elements in the LP constraint matrix */
356 extern
358  SCIP_LPI* lpi, /**< LP interface structure */
359  int* nnonz /**< pointer to store the number of nonzeros */
360  );
361 
362 /** gets columns from LP problem object; the arrays have to be large enough to store all values;
363  * Either both, lb and ub, have to be NULL, or both have to be non-NULL,
364  * either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
365  */
366 extern
368  SCIP_LPI* lpi, /**< LP interface structure */
369  int firstcol, /**< first column to get from LP */
370  int lastcol, /**< last column to get from LP */
371  SCIP_Real* lb, /**< buffer to store the lower bound vector, or NULL */
372  SCIP_Real* ub, /**< buffer to store the upper bound vector, or NULL */
373  int* nnonz, /**< pointer to store the number of nonzero elements returned, or NULL */
374  int* beg, /**< buffer to store start index of each column in ind- and val-array, or NULL */
375  int* ind, /**< buffer to store row indices of constraint matrix entries, or NULL */
376  SCIP_Real* val /**< buffer to store values of constraint matrix entries, or NULL */
377  );
378 
379 /** gets rows from LP problem object; the arrays have to be large enough to store all values.
380  * Either both, lhs and rhs, have to be NULL, or both have to be non-NULL,
381  * either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
382  */
383 extern
385  SCIP_LPI* lpi, /**< LP interface structure */
386  int firstrow, /**< first row to get from LP */
387  int lastrow, /**< last row to get from LP */
388  SCIP_Real* lhs, /**< buffer to store left hand side vector, or NULL */
389  SCIP_Real* rhs, /**< buffer to store right hand side vector, or NULL */
390  int* nnonz, /**< pointer to store the number of nonzero elements returned, or NULL */
391  int* beg, /**< buffer to store start index of each row in ind- and val-array, or NULL */
392  int* ind, /**< buffer to store column indices of constraint matrix entries, or NULL */
393  SCIP_Real* val /**< buffer to store values of constraint matrix entries, or NULL */
394  );
395 
396 /** gets column names */
397 extern
399  SCIP_LPI* lpi, /**< LP interface structure */
400  int firstcol, /**< first column to get name from LP */
401  int lastcol, /**< last column to get name from LP */
402  char** colnames, /**< pointers to column names (of size at least lastcol-firstcol+1) */
403  char* namestorage, /**< storage for col names */
404  int namestoragesize, /**< size of namestorage (if 0, -storageleft returns the storage needed) */
405  int* storageleft /**< amount of storage left (if < 0 the namestorage was not big enough) */
406  );
407 
408 /** gets row names */
409 extern
411  SCIP_LPI* lpi, /**< LP interface structure */
412  int firstrow, /**< first row to get name from LP */
413  int lastrow, /**< last row to get name from LP */
414  char** rownames, /**< pointers to row names (of size at least lastrow-firstrow+1) */
415  char* namestorage, /**< storage for row names */
416  int namestoragesize, /**< size of namestorage (if 0, -storageleft returns the storage needed) */
417  int* storageleft /**< amount of storage left (if < 0 the namestorage was not big enough) */
418  );
419 
420 /** gets objective coefficients from LP problem object */
421 extern
423  SCIP_LPI* lpi, /**< LP interface structure */
424  int firstcol, /**< first column to get objective coefficient for */
425  int lastcol, /**< last column to get objective coefficient for */
426  SCIP_Real* vals /**< array to store objective coefficients */
427  );
428 
429 /** gets current bounds from LP problem object */
430 extern
432  SCIP_LPI* lpi, /**< LP interface structure */
433  int firstcol, /**< first column to get bounds for */
434  int lastcol, /**< last column to get bounds for */
435  SCIP_Real* lbs, /**< array to store lower bound values, or NULL */
436  SCIP_Real* ubs /**< array to store upper bound values, or NULL */
437  );
438 
439 /** gets current row sides from LP problem object */
440 extern
442  SCIP_LPI* lpi, /**< LP interface structure */
443  int firstrow, /**< first row to get sides for */
444  int lastrow, /**< last row to get sides for */
445  SCIP_Real* lhss, /**< array to store left hand side values, or NULL */
446  SCIP_Real* rhss /**< array to store right hand side values, or NULL */
447  );
448 
449 /** gets a single coefficient */
450 extern
452  SCIP_LPI* lpi, /**< LP interface structure */
453  int row, /**< row number of coefficient */
454  int col, /**< column number of coefficient */
455  SCIP_Real* val /**< pointer to store the value of the coefficient */
456  );
457 
458 /**@} */
459 
460 
461 
462 
463 /*
464  * Solving Methods
465  */
466 
467 /**@name Solving Methods */
468 /**@{ */
469 
470 /** calls primal simplex to solve the LP */
471 extern
473  SCIP_LPI* lpi /**< LP interface structure */
474  );
475 
476 /** calls dual simplex to solve the LP */
477 extern
479  SCIP_LPI* lpi /**< LP interface structure */
480  );
481 
482 /** calls barrier or interior point algorithm to solve the LP with crossover to simplex basis */
483 extern
485  SCIP_LPI* lpi, /**< LP interface structure */
486  SCIP_Bool crossover /**< perform crossover */
487  );
488 
489 /** start strong branching - call before any strong branching */
490 extern
492  SCIP_LPI* lpi /**< LP interface structure */
493  );
494 
495 /** end strong branching - call after any strong branching */
496 extern
498  SCIP_LPI* lpi /**< LP interface structure */
499  );
500 
501 /** performs strong branching iterations on one @b fractional candidate */
502 extern
504  SCIP_LPI* lpi, /**< LP interface structure */
505  int col, /**< column to apply strong branching on */
506  SCIP_Real psol, /**< fractional current primal solution value of column */
507  int itlim, /**< iteration limit for strong branchings */
508  SCIP_Real* down, /**< stores dual bound after branching column down */
509  SCIP_Real* up, /**< stores dual bound after branching column up */
510  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound;
511  * otherwise, it can only be used as an estimate value */
512  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound;
513  * otherwise, it can only be used as an estimate value */
514  int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */
515  );
516 
517 /** performs strong branching iterations on given @b fractional candidates */
518 extern
520  SCIP_LPI* lpi, /**< LP interface structure */
521  int* cols, /**< columns to apply strong branching on */
522  int ncols, /**< number of columns */
523  SCIP_Real* psols, /**< fractional current primal solution values of columns */
524  int itlim, /**< iteration limit for strong branchings */
525  SCIP_Real* down, /**< stores dual bounds after branching columns down */
526  SCIP_Real* up, /**< stores dual bounds after branching columns up */
527  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds;
528  * otherwise, they can only be used as an estimate values */
529  SCIP_Bool* upvalid, /**< stores whether the returned up values are a valid dual bounds;
530  * otherwise, they can only be used as an estimate values */
531  int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */
532  );
533 
534 /** performs strong branching iterations on one candidate with @b integral value */
535 extern
537  SCIP_LPI* lpi, /**< LP interface structure */
538  int col, /**< column to apply strong branching on */
539  SCIP_Real psol, /**< current integral primal solution value of column */
540  int itlim, /**< iteration limit for strong branchings */
541  SCIP_Real* down, /**< stores dual bound after branching column down */
542  SCIP_Real* up, /**< stores dual bound after branching column up */
543  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound;
544  * otherwise, it can only be used as an estimate value */
545  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound;
546  * otherwise, it can only be used as an estimate value */
547  int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */
548  );
549 
550 /** performs strong branching iterations on given candidates with @b integral values */
551 extern
553  SCIP_LPI* lpi, /**< LP interface structure */
554  int* cols, /**< columns to apply strong branching on */
555  int ncols, /**< number of columns */
556  SCIP_Real* psols, /**< current integral primal solution values of columns */
557  int itlim, /**< iteration limit for strong branchings */
558  SCIP_Real* down, /**< stores dual bounds after branching columns down */
559  SCIP_Real* up, /**< stores dual bounds after branching columns up */
560  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds;
561  * otherwise, they can only be used as an estimate values */
562  SCIP_Bool* upvalid, /**< stores whether the returned up values are a valid dual bounds;
563  * otherwise, they can only be used as an estimate values */
564  int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */
565  );
566 /**@} */
567 
568 
569 
570 
571 /*
572  * Solution Information Methods
573  */
574 
575 /**@name Solution Information Methods */
576 /**@{ */
577 
578 /** returns whether a solve method was called after the last modification of the LP */
579 extern
581  SCIP_LPI* lpi /**< LP interface structure */
582  );
583 
584 /** gets information about primal and dual feasibility of the current LP solution */
585 extern
587  SCIP_LPI* lpi, /**< LP interface structure */
588  SCIP_Bool* primalfeasible, /**< stores primal feasibility status */
589  SCIP_Bool* dualfeasible /**< stores dual feasibility status */
590  );
591 
592 /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point);
593  * this does not necessarily mean, that the solver knows and can return the primal ray
594  */
595 extern
597  SCIP_LPI* lpi /**< LP interface structure */
598  );
599 
600 /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point),
601  * and the solver knows and can return the primal ray
602  */
603 extern
605  SCIP_LPI* lpi /**< LP interface structure */
606  );
607 
608 /** returns TRUE iff LP is proven to be primal unbounded */
609 extern
611  SCIP_LPI* lpi /**< LP interface structure */
612  );
613 
614 /** returns TRUE iff LP is proven to be primal infeasible */
615 extern
617  SCIP_LPI* lpi /**< LP interface structure */
618  );
619 
620 /** returns TRUE iff LP is proven to be primal feasible */
621 extern
623  SCIP_LPI* lpi /**< LP interface structure */
624  );
625 
626 /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point);
627  * this does not necessarily mean, that the solver knows and can return the dual ray
628  */
629 extern
631  SCIP_LPI* lpi /**< LP interface structure */
632  );
633 
634 /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point),
635  * and the solver knows and can return the dual ray
636  */
637 extern
639  SCIP_LPI* lpi /**< LP interface structure */
640  );
641 
642 /** returns TRUE iff LP is proven to be dual unbounded */
643 extern
645  SCIP_LPI* lpi /**< LP interface structure */
646  );
647 
648 /** returns TRUE iff LP is proven to be dual infeasible */
649 extern
651  SCIP_LPI* lpi /**< LP interface structure */
652  );
653 
654 /** returns TRUE iff LP is proven to be dual feasible */
655 extern
657  SCIP_LPI* lpi /**< LP interface structure */
658  );
659 
660 /** returns TRUE iff LP was solved to optimality */
661 extern
663  SCIP_LPI* lpi /**< LP interface structure */
664  );
665 
666 /** returns TRUE iff current LP basis is stable */
667 extern
669  SCIP_LPI* lpi /**< LP interface structure */
670  );
671 
672 /** returns TRUE iff the objective limit was reached */
673 extern
675  SCIP_LPI* lpi /**< LP interface structure */
676  );
677 
678 /** returns TRUE iff the iteration limit was reached */
679 extern
681  SCIP_LPI* lpi /**< LP interface structure */
682  );
683 
684 /** returns TRUE iff the time limit was reached */
685 extern
687  SCIP_LPI* lpi /**< LP interface structure */
688  );
689 
690 /** returns the internal solution status of the solver */
691 extern
693  SCIP_LPI* lpi /**< LP interface structure */
694  );
695 
696 /** tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call */
697 extern
699  SCIP_LPI* lpi, /**< LP interface structure */
700  SCIP_Bool* success /**< pointer to store, whether the instability could be ignored */
701  );
702 
703 /** gets objective value of solution */
704 extern
706  SCIP_LPI* lpi, /**< LP interface structure */
707  SCIP_Real* objval /**< stores the objective value */
708  );
709 
710 /** gets primal and dual solution vectors for feasible LPs */
711 extern
713  SCIP_LPI* lpi, /**< LP interface structure */
714  SCIP_Real* objval, /**< stores the objective value, may be NULL if not needed */
715  SCIP_Real* primsol, /**< primal solution vector, may be NULL if not needed */
716  SCIP_Real* dualsol, /**< dual solution vector, may be NULL if not needed */
717  SCIP_Real* activity, /**< row activity vector, may be NULL if not needed */
718  SCIP_Real* redcost /**< reduced cost vector, may be NULL if not needed */
719  );
720 
721 /** gets primal ray for unbounded LPs */
722 extern
724  SCIP_LPI* lpi, /**< LP interface structure */
725  SCIP_Real* ray /**< primal ray */
726  );
727 
728 /** gets dual Farkas proof for infeasibility */
729 extern
731  SCIP_LPI* lpi, /**< LP interface structure */
732  SCIP_Real* dualfarkas /**< dual Farkas row multipliers */
733  );
734 
735 /** gets the number of LP iterations of the last solve call */
736 extern
738  SCIP_LPI* lpi, /**< LP interface structure */
739  int* iterations /**< pointer to store the number of iterations of the last solve call */
740  );
741 
742 /** gets information about the quality of an LP solution
743  *
744  * Such information is usually only available, if also a (maybe not optimal) solution is available.
745  * The LPI should return SCIP_INVALID for @p quality, if the requested quantity is not available.
746  */
747 extern
749  SCIP_LPI* lpi, /**< LP interface structure */
750  SCIP_LPSOLQUALITY qualityindicator, /**< indicates which quality should be returned */
751  SCIP_Real* quality /**< pointer to store quality number */
752  );
753 
754 /**@} */
755 
756 
757 
758 
759 /*
760  * LP Basis Methods
761  */
762 
763 /**@name LP Basis Methods */
764 /**@{ */
765 
766 /** gets current basis status for columns and rows; arrays must be large enough to store the basis status */
767 extern
769  SCIP_LPI* lpi, /**< LP interface structure */
770  int* cstat, /**< array to store column basis status, or NULL */
771  int* rstat /**< array to store row basis status, or NULL */
772  );
773 
774 /** sets current basis status for columns and rows */
775 extern
777  SCIP_LPI* lpi, /**< LP interface structure */
778  const int* cstat, /**< array with column basis status */
779  const int* rstat /**< array with row basis status */
780  );
781 
782 /** returns the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m */
783 extern
785  SCIP_LPI* lpi, /**< LP interface structure */
786  int* bind /**< pointer to store basis indices ready to keep number of rows entries */
787  );
788 
789 /** get row of inverse basis matrix B^-1
790  *
791  * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
792  * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
793  * see also the explanation in lpi.h.
794  */
795 extern
797  SCIP_LPI* lpi, /**< LP interface structure */
798  int r, /**< row number */
799  SCIP_Real* coef, /**< pointer to store the coefficients of the row */
800  int* inds, /**< array to store the non-zero indices, or NULL */
801  int* ninds /**< pointer to store the number of non-zero indices, or NULL
802  * (-1: if we do not store sparsity informations) */
803  );
804 
805 
806 /** get column of inverse basis matrix B^-1
807  *
808  * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
809  * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
810  * see also the explanation in lpi.h.
811  */
812 extern
814  SCIP_LPI* lpi, /**< LP interface structure */
815  int c, /**< column number of B^-1; this is NOT the number of the column in the LP;
816  * you have to call SCIPlpiGetBasisInd() to get the array which links the
817  * B^-1 column numbers to the row and column numbers of the LP!
818  * c must be between 0 and nrows-1, since the basis has the size
819  * nrows * nrows */
820  SCIP_Real* coef, /**< pointer to store the coefficients of the column */
821  int* inds, /**< array to store the non-zero indices, or NULL */
822  int* ninds /**< pointer to store the number of non-zero indices, or NULL
823  * (-1: if we do not store sparsity informations) */
824  );
825 
826 /** get row of inverse basis matrix times constraint matrix B^-1 * A
827  *
828  * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
829  * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
830  * see also the explanation in lpi.h.
831  */
832 extern
834  SCIP_LPI* lpi, /**< LP interface structure */
835  int r, /**< row number */
836  const SCIP_Real* binvrow, /**< row in (A_B)^-1 from prior call to SCIPlpiGetBInvRow(), or NULL */
837  SCIP_Real* coef, /**< vector to return coefficients */
838  int* inds, /**< array to store the non-zero indices, or NULL */
839  int* ninds /**< pointer to store the number of non-zero indices, or NULL
840  * (-1: if we do not store sparsity informations) */
841  );
842 
843 /** get column of inverse basis matrix times constraint matrix B^-1 * A
844  *
845  * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
846  * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
847  * see also the explanation in lpi.h.
848  */
849 extern
851  SCIP_LPI* lpi, /**< LP interface structure */
852  int c, /**< column number */
853  SCIP_Real* coef, /**< vector to return coefficients */
854  int* inds, /**< array to store the non-zero indices, or NULL */
855  int* ninds /**< pointer to store the number of non-zero indices, or NULL
856  * (-1: if we do not store sparsity informations) */
857  );
858 
859 /**@} */
860 
861 
862 
863 
864 /*
865  * LPi State Methods
866  */
867 
868 /**@name LPi State Methods */
869 /**@{ */
870 
871 /** stores LPi state (like basis information) into lpistate object */
872 extern
874  SCIP_LPI* lpi, /**< LP interface structure */
875  BMS_BLKMEM* blkmem, /**< block memory */
876  SCIP_LPISTATE** lpistate /**< pointer to LPi state information (like basis information) */
877  );
878 
879 /** loads LPi state (like basis information) into solver; note that the LP might have been extended with additional
880  * columns and rows since the state was stored with SCIPlpiGetState()
881  */
882 extern
884  SCIP_LPI* lpi, /**< LP interface structure */
885  BMS_BLKMEM* blkmem, /**< block memory */
886  const SCIP_LPISTATE* lpistate /**< LPi state information (like basis information) */
887  );
888 
889 /** clears current LPi state (like basis information) of the solver */
890 extern
892  SCIP_LPI* lpi /**< LP interface structure */
893  );
894 
895 /** frees LPi state information */
896 extern
898  SCIP_LPI* lpi, /**< LP interface structure */
899  BMS_BLKMEM* blkmem, /**< block memory */
900  SCIP_LPISTATE** lpistate /**< pointer to LPi state information (like basis information) */
901  );
902 
903 /** checks, whether the given LPi state contains simplex basis information */
904 extern
906  SCIP_LPI* lpi, /**< LP interface structure */
907  SCIP_LPISTATE* lpistate /**< LPi state information (like basis information) */
908  );
909 
910 /** reads LPi state (like basis information from a file */
911 extern
913  SCIP_LPI* lpi, /**< LP interface structure */
914  const char* fname /**< file name */
915  );
916 
917 /** writes LPi state (like basis information) to a file */
918 extern
920  SCIP_LPI* lpi, /**< LP interface structure */
921  const char* fname /**< file name */
922  );
923 
924 /**@} */
925 
926 
927 /*
928  * LPi Pricing Norms Methods
929  */
930 
931 /**@name LPi Pricing Norms Methods */
932 /**@{ */
933 
934 /** stores LPi pricing norms into lpinorms object */
935 extern
937  SCIP_LPI* lpi, /**< LP interface structure */
938  BMS_BLKMEM* blkmem, /**< block memory */
939  SCIP_LPINORMS** lpinorms /**< pointer to LPi pricing norms information */
940  );
941 
942 /** loads LPi pricing norms into solver; note that the LP might have been extended with additional
943  * columns and rows since the norms were stored with SCIPlpiGetNorms()
944  */
945 extern
947  SCIP_LPI* lpi, /**< LP interface structure */
948  BMS_BLKMEM* blkmem, /**< block memory */
949  const SCIP_LPINORMS* lpinorms /**< LPi pricing norms information */
950  );
951 
952 /** frees LPi pricing norms information */
953 extern
955  SCIP_LPI* lpi, /**< LP interface structure */
956  BMS_BLKMEM* blkmem, /**< block memory */
957  SCIP_LPINORMS** lpinorms /**< pointer to LPi pricing norms information */
958  );
959 
960 
961 /**@} */
962 
963 
964 
965 
966 /*
967  * Parameter Methods
968  */
969 
970 /**@name Parameter Methods */
971 /**@{ */
972 
973 /** gets integer parameter of LP */
974 extern
976  SCIP_LPI* lpi, /**< LP interface structure */
977  SCIP_LPPARAM type, /**< parameter number */
978  int* ival /**< buffer to store the parameter value */
979  );
980 
981 /** sets integer parameter of LP */
982 extern
984  SCIP_LPI* lpi, /**< LP interface structure */
985  SCIP_LPPARAM type, /**< parameter number */
986  int ival /**< parameter value */
987  );
988 
989 /** gets floating point parameter of LP */
990 extern
992  SCIP_LPI* lpi, /**< LP interface structure */
993  SCIP_LPPARAM type, /**< parameter number */
994  SCIP_Real* dval /**< buffer to store the parameter value */
995  );
996 
997 /** sets floating point parameter of LP */
998 extern
1000  SCIP_LPI* lpi, /**< LP interface structure */
1001  SCIP_LPPARAM type, /**< parameter number */
1002  SCIP_Real dval /**< parameter value */
1003  );
1004 
1005 /**@} */
1006 
1007 
1008 
1009 
1010 /*
1011  * Numerical Methods
1012  */
1013 
1014 /**@name Numerical Methods */
1015 /**@{ */
1016 
1017 /** returns value treated as infinity in the LP solver */
1018 extern
1020  SCIP_LPI* lpi /**< LP interface structure */
1021  );
1022 
1023 /** checks if given value is treated as infinity in the LP solver */
1024 extern
1026  SCIP_LPI* lpi, /**< LP interface structure */
1027  SCIP_Real val /**< value to be checked for infinity */
1028  );
1029 
1030 /**@} */
1031 
1032 
1033 
1034 
1035 /*
1036  * File Interface Methods
1037  */
1038 
1039 /**@name File Interface Methods */
1040 /**@{ */
1041 
1042 /** reads LP from a file */
1043 extern
1045  SCIP_LPI* lpi, /**< LP interface structure */
1046  const char* fname /**< file name */
1047  );
1048 
1049 /** writes LP to a file */
1050 extern
1052  SCIP_LPI* lpi, /**< LP interface structure */
1053  const char* fname /**< file name */
1054  );
1055 
1056 /**@} */
1057 
1058 /**@} */
1059 
1060 
1061 #ifdef __cplusplus
1062 }
1063 #endif
1064 
1065 #endif
SCIP_RETCODE SCIPlpiGetBInvCol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
enum SCIP_LPSolQuality SCIP_LPSOLQUALITY
Definition: type_lpi.h:94
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
SCIP_RETCODE SCIPlpiSetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPISTATE *lpistate)
SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)
SCIP_Bool SCIPlpiIsDualUnbounded(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPINORMS *lpinorms)
SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
enum SCIP_ObjSen SCIP_OBJSEN
Definition: type_lpi.h:36
SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)
void * SCIPlpiGetSolverPointer(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_RETCODE SCIPlpiGetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int *ival)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
SCIP_RETCODE SCIPlpiGetNNonz(SCIP_LPI *lpi, int *nnonz)
struct SCIP_LPiNorms SCIP_LPINORMS
Definition: type_lpi.h:98
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_Bool SCIPlpiHasPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
enum SCIP_LPParam SCIP_LPPARAM
Definition: type_lpi.h:63
SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
SCIP_RETCODE SCIPlpiReadState(SCIP_LPI *lpi, const char *fname)
type definitions for return codes for SCIP methods
SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)
SCIP_RETCODE SCIPlpiClear(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)
SCIP_RETCODE SCIPlpiScaleCol(SCIP_LPI *lpi, int col, SCIP_Real scaleval)
SCIP_RETCODE SCIPlpiGetObjsen(SCIP_LPI *lpi, SCIP_OBJSEN *objsen)
SCIP_RETCODE SCIPlpiSetIntegralityInformation(SCIP_LPI *lpi, int ncols, int *intInfo)
SCIP_RETCODE SCIPlpiClearState(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetCols(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lb, SCIP_Real *ub, int *nnonz, int *beg, int *ind, SCIP_Real *val)
SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
SCIP_RETCODE SCIPlpiGetBInvARow(SCIP_LPI *lpi, int r, const SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)
int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI *lpi, int *bind)
SCIP_RETCODE SCIPlpiStrongbranchesFrac(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiFreeState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetColNames(SCIP_LPI *lpi, int firstcol, int lastcol, char **colnames, char *namestorage, int namestoragesize, int *storageleft)
SCIP_RETCODE SCIPlpiStrongbranchFrac(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
type definitions for specific LP solvers interface
struct SCIP_LPiState SCIP_LPISTATE
Definition: type_lpi.h:97
SCIP_RETCODE SCIPlpiStrongbranchesInt(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
const char * SCIPlpiGetSolverDesc(void)
SCIP_RETCODE SCIPlpiGetSolFeasibility(SCIP_LPI *lpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI *lpi, int firstrow, int lastrow)
SCIP_RETCODE SCIPlpiReadLP(SCIP_LPI *lpi, const char *fname)
SCIP_Bool SCIPlpiWasSolved(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
SCIP_RETCODE SCIPlpiDelRowset(SCIP_LPI *lpi, int *dstat)
#define SCIP_Bool
Definition: def.h:61
SCIP_Bool SCIPlpiHasStateBasis(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)
SCIP_RETCODE SCIPlpiDelCols(SCIP_LPI *lpi, int firstcol, int lastcol)
SCIP_RETCODE SCIPlpiWriteState(SCIP_LPI *lpi, const char *fname)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real newval)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_Bool SCIPlpiIsDualInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetRowNames(SCIP_LPI *lpi, int firstrow, int lastrow, char **rownames, char *namestorage, int namestoragesize, int *storageleft)
SCIP_RETCODE SCIPlpiSetBase(SCIP_LPI *lpi, const int *cstat, const int *rstat)
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_Bool SCIPlpiIsTimelimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetRows(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhs, SCIP_Real *rhs, int *nnonz, int *beg, int *ind, SCIP_Real *val)
SCIP_RETCODE SCIPlpiStrongbranchInt(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiSolveBarrier(SCIP_LPI *lpi, SCIP_Bool crossover)
SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI *lpi, SCIP_Real *ray)
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiLoadColLP(SCIP_LPI *lpi, SCIP_OBJSEN objsen, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiScaleRow(SCIP_LPI *lpi, int row, SCIP_Real scaleval)
SCIP_RETCODE SCIPlpiGetSides(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhss, SCIP_Real *rhss)
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBInvACol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetObj(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *vals)
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
struct SCIP_LPi SCIP_LPI
Definition: type_lpi.h:96
#define SCIP_Real
Definition: def.h:149
SCIP_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
SCIP_Bool SCIPlpiExistsDualRay(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsIterlimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)
common defines and data types used in all packages of SCIP
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:419
SCIP_RETCODE SCIPlpiChgObjsen(SCIP_LPI *lpi, SCIP_OBJSEN objsen)
SCIP_RETCODE SCIPlpiGetBInvRow(SCIP_LPI *lpi, int r, SCIP_Real *coef, int *inds, int *ninds)
const char * SCIPlpiGetSolverName(void)
SCIP_RETCODE SCIPlpiIgnoreInstability(SCIP_LPI *lpi, SCIP_Bool *success)
SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
SCIP_RETCODE SCIPlpiDelColset(SCIP_LPI *lpi, int *dstat)
memory allocation routines