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