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-2016 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  * The basis status for (column) variables are as follows:
33  * - If x_j = lb, then j is at its lower bound (SCIP_BASESTAT_LOWER).
34  * - If x_j = ub, then j is at its lower bound (SCIP_BASESTAT_UPPER).
35  * - If x_j is in the basis, it has SCIP_BASESTAT_BASIC status.
36  * - If x_j is free and non-basic, it has SCIP_BASESTAT_ZERO status.
37  *
38  * The basis status for (row) slack variables are:
39  * - If (A * x)_i = lhs, then i is at its lower bound (SCIP_BASESTAT_LOWER).
40  * - If (A * x)_i = rhs, then i is at its upper bound (SCIP_BASESTAT_UPPER).
41  * - If the slack variable for row i is basic, it has SCIP_BASESTAT_BASIC status.
42  *
43  * If the solvers use their status differently, the have to be corrected.
44  *
45  * In the methods accessing information about the (inverse of the) basis matrix, the interface assumes the following
46  * column-oriented format: slack variables of rows have coefficient +1 and the basis matrix is a regular m times m
47  * submatrix of (A,I), where m is the number of rows and I is the identity matrix. This means that if, internally, the
48  * LP solver uses coefficients -1 for some of the slack variables, then rows associated with slacks variables whose
49  * coefficient is -1 should be negated in order to return the result in terms of the LP interface definition.
50  */
51 
52 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
53 
54 #ifndef __SCIP_LPI_H__
55 #define __SCIP_LPI_H__
56 
57 
58 #include "scip/def.h"
59 #include "blockmemshell/memory.h"
60 #include "scip/type_retcode.h"
61 #include "lpi/type_lpi.h"
62 
63 #ifdef __cplusplus
64 extern "C" {
65 #endif
66 
67 /*
68  * Miscellaneous Methods
69  */
70 
71 /**@name Miscellaneous Methods */
72 /**@{ */
73 
74 /** gets name and version of LP solver */
75 extern
76 const char* SCIPlpiGetSolverName(
77  void
78  );
79 
80 /** gets description of LP solver (developer, webpage, ...) */
81 extern
82 const char* SCIPlpiGetSolverDesc(
83  void
84  );
85 
86 /** gets pointer for LP solver - use only with great care
87  *
88  * The behavior of this function depends on the solver and its use is
89  * therefore only recommended if you really know what you are
90  * doing. In general, it returns a pointer to the LP solver object.
91  */
92 extern
94  SCIP_LPI* lpi /**< pointer to an LP interface structure */
95  );
96 
97 /**@} */
98 
99 
100 
101 
102 /*
103  * LPI Creation and Destruction Methods
104  */
105 
106 /**@name LPI Creation and Destruction Methods */
107 /**@{ */
108 
109 /** creates an LP problem object */
110 extern
112  SCIP_LPI** lpi, /**< pointer to an LP interface structure */
113  SCIP_MESSAGEHDLR* messagehdlr, /**< message handler to use for printing messages, or NULL */
114  const char* name, /**< problem name */
115  SCIP_OBJSEN objsen /**< objective sense */
116  );
117 
118 /** deletes an LP problem object */
119 extern
121  SCIP_LPI** lpi /**< pointer to an LP interface structure */
122  );
123 
124 /**@} */
125 
126 
127 
128 
129 /*
130  * Modification Methods
131  */
132 
133 /**@name Modification Methods */
134 /**@{ */
135 
136 /** copies LP data with column matrix into LP solver */
137 extern
139  SCIP_LPI* lpi, /**< LP interface structure */
140  SCIP_OBJSEN objsen, /**< objective sense */
141  int ncols, /**< number of columns */
142  const SCIP_Real* obj, /**< objective function values of columns */
143  const SCIP_Real* lb, /**< lower bounds of columns */
144  const SCIP_Real* ub, /**< upper bounds of columns */
145  char** colnames, /**< column names, or NULL */
146  int nrows, /**< number of rows */
147  const SCIP_Real* lhs, /**< left hand sides of rows */
148  const SCIP_Real* rhs, /**< right hand sides of rows */
149  char** rownames, /**< row names, or NULL */
150  int nnonz, /**< number of nonzero elements in the constraint matrix */
151  const int* beg, /**< start index of each column in ind- and val-array */
152  const int* ind, /**< row indices of constraint matrix entries */
153  const SCIP_Real* val /**< values of constraint matrix entries */
154  );
155 
156 /** adds columns to the LP
157  *
158  * @note ind array is not checked for duplicates, problems may appear if indeces are added more than once
159  */
160 extern
162  SCIP_LPI* lpi, /**< LP interface structure */
163  int ncols, /**< number of columns to be added */
164  const SCIP_Real* obj, /**< objective function values of new columns */
165  const SCIP_Real* lb, /**< lower bounds of new columns */
166  const SCIP_Real* ub, /**< upper bounds of new columns */
167  char** colnames, /**< column names, or NULL */
168  int nnonz, /**< number of nonzero elements to be added to the constraint matrix */
169  const int* beg, /**< start index of each column in ind- and val-array, or NULL if nnonz == 0 */
170  const int* ind, /**< row indices of constraint matrix entries, or NULL if nnonz == 0 */
171  const SCIP_Real* val /**< values of constraint matrix entries, or NULL if nnonz == 0 */
172  );
173 
174 /** deletes all columns in the given range from LP */
175 extern
177  SCIP_LPI* lpi, /**< LP interface structure */
178  int firstcol, /**< first column to be deleted */
179  int lastcol /**< last column to be deleted */
180  );
181 
182 /** deletes columns from SCIP_LPI; the new position of a column must not be greater that its old position */
183 extern
185  SCIP_LPI* lpi, /**< LP interface structure */
186  int* dstat /**< deletion status of columns
187  * input: 1 if column should be deleted, 0 if not
188  * output: new position of column, -1 if column was deleted */
189  );
190 
191 /** adds rows to the LP
192  *
193  * @note ind array is not checked for duplicates, problems may appear if indeces are added more than once
194  */
195 extern
197  SCIP_LPI* lpi, /**< LP interface structure */
198  int nrows, /**< number of rows to be added */
199  const SCIP_Real* lhs, /**< left hand sides of new rows */
200  const SCIP_Real* rhs, /**< right hand sides of new rows */
201  char** rownames, /**< row names, or NULL */
202  int nnonz, /**< number of nonzero elements to be added to the constraint matrix */
203  const int* beg, /**< start index of each row in ind- and val-array, or NULL if nnonz == 0 */
204  const int* ind, /**< column indices of constraint matrix entries, or NULL if nnonz == 0 */
205  const SCIP_Real* val /**< values of constraint matrix entries, or NULL if nnonz == 0 */
206  );
207 
208 /** deletes all rows in the given range from LP */
209 extern
211  SCIP_LPI* lpi, /**< LP interface structure */
212  int firstrow, /**< first row to be deleted */
213  int lastrow /**< last row to be deleted */
214  );
215 
216 /** deletes rows from SCIP_LPI; the new position of a row must not be greater that its old position */
217 extern
219  SCIP_LPI* lpi, /**< LP interface structure */
220  int* dstat /**< deletion status of rows
221  * input: 1 if row should be deleted, 0 if not
222  * output: new position of row, -1 if row was deleted */
223  );
224 
225 /** clears the whole LP */
226 extern
228  SCIP_LPI* lpi /**< LP interface structure */
229  );
230 
231 /** changes lower and upper bounds of columns */
232 extern
234  SCIP_LPI* lpi, /**< LP interface structure */
235  int ncols, /**< number of columns to change bounds for */
236  const int* ind, /**< column indices */
237  const SCIP_Real* lb, /**< values for the new lower bounds */
238  const SCIP_Real* ub /**< values for the new upper bounds */
239  );
240 
241 /** changes left and right hand sides of rows */
242 extern
244  SCIP_LPI* lpi, /**< LP interface structure */
245  int nrows, /**< number of rows to change sides for */
246  const int* ind, /**< row indices */
247  const SCIP_Real* lhs, /**< new values for left hand sides */
248  const SCIP_Real* rhs /**< new values for right hand sides */
249  );
250 
251 /** changes a single coefficient */
252 extern
254  SCIP_LPI* lpi, /**< LP interface structure */
255  int row, /**< row number of coefficient to change */
256  int col, /**< column number of coefficient to change */
257  SCIP_Real newval /**< new value of coefficient */
258  );
259 
260 /** changes the objective sense */
261 extern
263  SCIP_LPI* lpi, /**< LP interface structure */
264  SCIP_OBJSEN objsen /**< new objective sense */
265  );
266 
267 /** changes objective values of columns in the LP */
268 extern
270  SCIP_LPI* lpi, /**< LP interface structure */
271  int ncols, /**< number of columns to change objective value for */
272  int* ind, /**< column indices to change objective value for */
273  SCIP_Real* obj /**< new objective values for columns */
274  );
275 
276 /** multiplies a row with a non-zero scalar; for negative scalars, the row's sense is switched accordingly */
277 extern
279  SCIP_LPI* lpi, /**< LP interface structure */
280  int row, /**< row number to scale */
281  SCIP_Real scaleval /**< scaling multiplier */
282  );
283 
284 /** multiplies a column with a non-zero scalar; the objective value is multiplied with the scalar, and the bounds
285  * are divided by the scalar; for negative scalars, the column's bounds are switched
286  */
287 extern
289  SCIP_LPI* lpi, /**< LP interface structure */
290  int col, /**< column number to scale */
291  SCIP_Real scaleval /**< scaling multiplier */
292  );
293 
294 /**@} */
295 
296 
297 
298 
299 /*
300  * Data Accessing Methods
301  */
302 
303 /**@name Data Accessing Methods */
304 /**@{ */
305 
306 /** gets the number of rows in the LP */
307 extern
309  SCIP_LPI* lpi, /**< LP interface structure */
310  int* nrows /**< pointer to store the number of rows */
311  );
312 
313 /** gets the number of columns in the LP */
314 extern
316  SCIP_LPI* lpi, /**< LP interface structure */
317  int* ncols /**< pointer to store the number of cols */
318  );
319 
320 /** gets the objective sense of the LP */
322  SCIP_LPI* lpi, /**< LP interface structure */
323  SCIP_OBJSEN* objsen /**< pointer to store objective sense */
324  );
325 
326 /** gets the number of nonzero elements in the LP constraint matrix */
327 extern
329  SCIP_LPI* lpi, /**< LP interface structure */
330  int* nnonz /**< pointer to store the number of nonzeros */
331  );
332 
333 /** gets columns from LP problem object; the arrays have to be large enough to store all values;
334  * Either both, lb and ub, have to be NULL, or both have to be non-NULL,
335  * either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
336  */
337 extern
339  SCIP_LPI* lpi, /**< LP interface structure */
340  int firstcol, /**< first column to get from LP */
341  int lastcol, /**< last column to get from LP */
342  SCIP_Real* lb, /**< buffer to store the lower bound vector, or NULL */
343  SCIP_Real* ub, /**< buffer to store the upper bound vector, or NULL */
344  int* nnonz, /**< pointer to store the number of nonzero elements returned, or NULL */
345  int* beg, /**< buffer to store start index of each column in ind- and val-array, or NULL */
346  int* ind, /**< buffer to store column indices of constraint matrix entries, or NULL */
347  SCIP_Real* val /**< buffer to store values of constraint matrix entries, or NULL */
348  );
349 
350 /** gets rows from LP problem object; the arrays have to be large enough to store all values.
351  * Either both, lhs and rhs, have to be NULL, or both have to be non-NULL,
352  * either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
353  */
354 extern
356  SCIP_LPI* lpi, /**< LP interface structure */
357  int firstrow, /**< first row to get from LP */
358  int lastrow, /**< last row to get from LP */
359  SCIP_Real* lhs, /**< buffer to store left hand side vector, or NULL */
360  SCIP_Real* rhs, /**< buffer to store right hand side vector, or NULL */
361  int* nnonz, /**< pointer to store the number of nonzero elements returned, or NULL */
362  int* beg, /**< buffer to store start index of each row in ind- and val-array, or NULL */
363  int* ind, /**< buffer to store row indices of constraint matrix entries, or NULL */
364  SCIP_Real* val /**< buffer to store values of constraint matrix entries, or NULL */
365  );
366 
367 /** gets column names */
368 extern
370  SCIP_LPI* lpi, /**< LP interface structure */
371  int firstcol, /**< first column to get name from LP */
372  int lastcol, /**< last column to get name from LP */
373  char** colnames, /**< pointers to column names (of size at least lastcol-firstcol+1) */
374  char* namestorage, /**< storage for col names */
375  int namestoragesize, /**< size of namestorage (if 0, -storageleft returns the storage needed) */
376  int* storageleft /**< amount of storage left (if < 0 the namestorage was not big enough) */
377  );
378 
379 /** gets row names */
380 extern
382  SCIP_LPI* lpi, /**< LP interface structure */
383  int firstrow, /**< first row to get name from LP */
384  int lastrow, /**< last row to get name from LP */
385  char** rownames, /**< pointers to row names (of size at least lastrow-firstrow+1) */
386  char* namestorage, /**< storage for row names */
387  int namestoragesize, /**< size of namestorage (if 0, -storageleft returns the storage needed) */
388  int* storageleft /**< amount of storage left (if < 0 the namestorage was not big enough) */
389  );
390 
391 /** gets objective coefficients from LP problem object */
392 extern
394  SCIP_LPI* lpi, /**< LP interface structure */
395  int firstcol, /**< first column to get objective coefficient for */
396  int lastcol, /**< last column to get objective coefficient for */
397  SCIP_Real* vals /**< array to store objective coefficients */
398  );
399 
400 /** gets current bounds from LP problem object */
401 extern
403  SCIP_LPI* lpi, /**< LP interface structure */
404  int firstcol, /**< first column to get bounds for */
405  int lastcol, /**< last column to get bounds for */
406  SCIP_Real* lbs, /**< array to store lower bound values, or NULL */
407  SCIP_Real* ubs /**< array to store upper bound values, or NULL */
408  );
409 
410 /** gets current row sides from LP problem object */
411 extern
413  SCIP_LPI* lpi, /**< LP interface structure */
414  int firstrow, /**< first row to get sides for */
415  int lastrow, /**< last row to get sides for */
416  SCIP_Real* lhss, /**< array to store left hand side values, or NULL */
417  SCIP_Real* rhss /**< array to store right hand side values, or NULL */
418  );
419 
420 /** gets a single coefficient */
421 extern
423  SCIP_LPI* lpi, /**< LP interface structure */
424  int row, /**< row number of coefficient */
425  int col, /**< column number of coefficient */
426  SCIP_Real* val /**< pointer to store the value of the coefficient */
427  );
428 
429 /**@} */
430 
431 
432 
433 
434 /*
435  * Solving Methods
436  */
437 
438 /**@name Solving Methods */
439 /**@{ */
440 
441 /** calls primal simplex to solve the LP */
442 extern
444  SCIP_LPI* lpi /**< LP interface structure */
445  );
446 
447 /** calls dual simplex to solve the LP */
448 extern
450  SCIP_LPI* lpi /**< LP interface structure */
451  );
452 
453 /** calls barrier or interior point algorithm to solve the LP with crossover to simplex basis */
454 extern
456  SCIP_LPI* lpi, /**< LP interface structure */
457  SCIP_Bool crossover /**< perform crossover */
458  );
459 
460 /** start strong branching - call before any strong branching */
461 extern
463  SCIP_LPI* lpi /**< LP interface structure */
464  );
465 
466 /** end strong branching - call after any strong branching */
467 extern
469  SCIP_LPI* lpi /**< LP interface structure */
470  );
471 
472 /** performs strong branching iterations on one @b fractional candidate */
473 extern
475  SCIP_LPI* lpi, /**< LP interface structure */
476  int col, /**< column to apply strong branching on */
477  SCIP_Real psol, /**< fractional current primal solution value of column */
478  int itlim, /**< iteration limit for strong branchings */
479  SCIP_Real* down, /**< stores dual bound after branching column down */
480  SCIP_Real* up, /**< stores dual bound after branching column up */
481  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound;
482  * otherwise, it can only be used as an estimate value */
483  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound;
484  * otherwise, it can only be used as an estimate value */
485  int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */
486  );
487 
488 /** performs strong branching iterations on given @b fractional candidates */
489 extern
491  SCIP_LPI* lpi, /**< LP interface structure */
492  int* cols, /**< columns to apply strong branching on */
493  int ncols, /**< number of columns */
494  SCIP_Real* psols, /**< fractional current primal solution values of columns */
495  int itlim, /**< iteration limit for strong branchings */
496  SCIP_Real* down, /**< stores dual bounds after branching columns down */
497  SCIP_Real* up, /**< stores dual bounds after branching columns up */
498  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds;
499  * otherwise, they can only be used as an estimate values */
500  SCIP_Bool* upvalid, /**< stores whether the returned up values are a valid dual bounds;
501  * otherwise, they can only be used as an estimate values */
502  int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */
503  );
504 
505 /** performs strong branching iterations on one candidate with @b integral value */
506 extern
508  SCIP_LPI* lpi, /**< LP interface structure */
509  int col, /**< column to apply strong branching on */
510  SCIP_Real psol, /**< current integral primal solution value of column */
511  int itlim, /**< iteration limit for strong branchings */
512  SCIP_Real* down, /**< stores dual bound after branching column down */
513  SCIP_Real* up, /**< stores dual bound after branching column up */
514  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound;
515  * otherwise, it can only be used as an estimate value */
516  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound;
517  * otherwise, it can only be used as an estimate value */
518  int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */
519  );
520 
521 /** performs strong branching iterations on given candidates with @b integral values */
522 extern
524  SCIP_LPI* lpi, /**< LP interface structure */
525  int* cols, /**< columns to apply strong branching on */
526  int ncols, /**< number of columns */
527  SCIP_Real* psols, /**< current integral primal solution values of columns */
528  int itlim, /**< iteration limit for strong branchings */
529  SCIP_Real* down, /**< stores dual bounds after branching columns down */
530  SCIP_Real* up, /**< stores dual bounds after branching columns up */
531  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds;
532  * otherwise, they can only be used as an estimate values */
533  SCIP_Bool* upvalid, /**< stores whether the returned up values are a valid dual bounds;
534  * otherwise, they can only be used as an estimate values */
535  int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */
536  );
537 /**@} */
538 
539 
540 
541 
542 /*
543  * Solution Information Methods
544  */
545 
546 /**@name Solution Information Methods */
547 /**@{ */
548 
549 /** returns whether a solve method was called after the last modification of the LP */
550 extern
552  SCIP_LPI* lpi /**< LP interface structure */
553  );
554 
555 /** gets information about primal and dual feasibility of the current LP solution */
556 extern
558  SCIP_LPI* lpi, /**< LP interface structure */
559  SCIP_Bool* primalfeasible, /**< stores primal feasibility status */
560  SCIP_Bool* dualfeasible /**< stores dual feasibility status */
561  );
562 
563 /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point);
564  * this does not necessarily mean, that the solver knows and can return the primal ray
565  */
566 extern
568  SCIP_LPI* lpi /**< LP interface structure */
569  );
570 
571 /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point),
572  * and the solver knows and can return the primal ray
573  */
574 extern
576  SCIP_LPI* lpi /**< LP interface structure */
577  );
578 
579 /** returns TRUE iff LP is proven to be primal unbounded */
580 extern
582  SCIP_LPI* lpi /**< LP interface structure */
583  );
584 
585 /** returns TRUE iff LP is proven to be primal infeasible */
586 extern
588  SCIP_LPI* lpi /**< LP interface structure */
589  );
590 
591 /** returns TRUE iff LP is proven to be primal feasible */
592 extern
594  SCIP_LPI* lpi /**< LP interface structure */
595  );
596 
597 /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point);
598  * this does not necessarily mean, that the solver knows and can return the dual ray
599  */
600 extern
602  SCIP_LPI* lpi /**< LP interface structure */
603  );
604 
605 /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point),
606  * and the solver knows and can return the dual ray
607  */
608 extern
610  SCIP_LPI* lpi /**< LP interface structure */
611  );
612 
613 /** returns TRUE iff LP is proven to be dual unbounded */
614 extern
616  SCIP_LPI* lpi /**< LP interface structure */
617  );
618 
619 /** returns TRUE iff LP is proven to be dual infeasible */
620 extern
622  SCIP_LPI* lpi /**< LP interface structure */
623  );
624 
625 /** returns TRUE iff LP is proven to be dual feasible */
626 extern
628  SCIP_LPI* lpi /**< LP interface structure */
629  );
630 
631 /** returns TRUE iff LP was solved to optimality */
632 extern
634  SCIP_LPI* lpi /**< LP interface structure */
635  );
636 
637 /** returns TRUE iff current LP basis is stable */
638 extern
640  SCIP_LPI* lpi /**< LP interface structure */
641  );
642 
643 /** returns TRUE iff the objective limit was reached */
644 extern
646  SCIP_LPI* lpi /**< LP interface structure */
647  );
648 
649 /** returns TRUE iff the iteration limit was reached */
650 extern
652  SCIP_LPI* lpi /**< LP interface structure */
653  );
654 
655 /** returns TRUE iff the time limit was reached */
656 extern
658  SCIP_LPI* lpi /**< LP interface structure */
659  );
660 
661 /** returns the internal solution status of the solver */
662 extern
664  SCIP_LPI* lpi /**< LP interface structure */
665  );
666 
667 /** tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call */
668 extern
670  SCIP_LPI* lpi, /**< LP interface structure */
671  SCIP_Bool* success /**< pointer to store, whether the instability could be ignored */
672  );
673 
674 /** gets objective value of solution */
675 extern
677  SCIP_LPI* lpi, /**< LP interface structure */
678  SCIP_Real* objval /**< stores the objective value */
679  );
680 
681 /** gets primal and dual solution vectors for feasible LPs */
682 extern
684  SCIP_LPI* lpi, /**< LP interface structure */
685  SCIP_Real* objval, /**< stores the objective value, may be NULL if not needed */
686  SCIP_Real* primsol, /**< primal solution vector, may be NULL if not needed */
687  SCIP_Real* dualsol, /**< dual solution vector, may be NULL if not needed */
688  SCIP_Real* activity, /**< row activity vector, may be NULL if not needed */
689  SCIP_Real* redcost /**< reduced cost vector, may be NULL if not needed */
690  );
691 
692 /** gets primal ray for unbounded LPs */
693 extern
695  SCIP_LPI* lpi, /**< LP interface structure */
696  SCIP_Real* ray /**< primal ray */
697  );
698 
699 /** gets dual Farkas proof for infeasibility */
700 extern
702  SCIP_LPI* lpi, /**< LP interface structure */
703  SCIP_Real* dualfarkas /**< dual Farkas row multipliers */
704  );
705 
706 /** gets the number of LP iterations of the last solve call */
707 extern
709  SCIP_LPI* lpi, /**< LP interface structure */
710  int* iterations /**< pointer to store the number of iterations of the last solve call */
711  );
712 
713 /** gets information about the quality of an LP solution
714  *
715  * Such information is usually only available, if also a (maybe not optimal) solution is available.
716  * The LPI should return SCIP_INVALID for @p quality, if the requested quantity is not available.
717  */
718 extern
720  SCIP_LPI* lpi, /**< LP interface structure */
721  SCIP_LPSOLQUALITY qualityindicator, /**< indicates which quality should be returned */
722  SCIP_Real* quality /**< pointer to store quality number */
723  );
724 
725 /**@} */
726 
727 
728 
729 
730 /*
731  * LP Basis Methods
732  */
733 
734 /**@name LP Basis Methods */
735 /**@{ */
736 
737 /** gets current basis status for columns and rows; arrays must be large enough to store the basis status */
738 extern
740  SCIP_LPI* lpi, /**< LP interface structure */
741  int* cstat, /**< array to store column basis status, or NULL */
742  int* rstat /**< array to store row basis status, or NULL */
743  );
744 
745 /** sets current basis status for columns and rows */
746 extern
748  SCIP_LPI* lpi, /**< LP interface structure */
749  int* cstat, /**< array with column basis status */
750  int* rstat /**< array with row basis status */
751  );
752 
753 /** returns the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m */
754 extern
756  SCIP_LPI* lpi, /**< LP interface structure */
757  int* bind /**< pointer to store basis indices ready to keep number of rows entries */
758  );
759 
760 /** get dense row of inverse basis matrix B^-1
761  *
762  * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
763  * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
764  * see also the explanation in lpi.h.
765  */
766 extern
768  SCIP_LPI* lpi, /**< LP interface structure */
769  int r, /**< row number */
770  SCIP_Real* coef, /**< pointer to store the coefficients of the row */
771  int* inds, /**< array to store the non-zero indices, or NULL */
772  int* ninds /**< pointer to store the number of non-zero indices, or NULL
773  * (-1: if we do not store sparsity informations) */
774  );
775 
776 
777 /** get dense column of inverse basis matrix B^-1
778  *
779  * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
780  * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
781  * see also the explanation in lpi.h.
782  */
783 extern
785  SCIP_LPI* lpi, /**< LP interface structure */
786  int c, /**< column number of B^-1; this is NOT the number of the column in the LP;
787  * you have to call SCIPlpiGetBasisInd() to get the array which links the
788  * B^-1 column numbers to the row and column numbers of the LP!
789  * c must be between 0 and nrows-1, since the basis has the size
790  * nrows * nrows */
791  SCIP_Real* coef, /**< pointer to store the coefficients of the column */
792  int* inds, /**< array to store the non-zero indices, or NULL */
793  int* ninds /**< pointer to store the number of non-zero indices, or NULL
794  * (-1: if we do not store sparsity informations) */
795  );
796 
797 /** get dense row of inverse basis matrix times constraint matrix B^-1 * A
798  *
799  * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
800  * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
801  * see also the explanation in lpi.h.
802  */
803 extern
805  SCIP_LPI* lpi, /**< LP interface structure */
806  int r, /**< row number */
807  const SCIP_Real* binvrow, /**< row in (A_B)^-1 from prior call to SCIPlpiGetBInvRow(), or NULL */
808  SCIP_Real* coef, /**< vector to return coefficients */
809  int* inds, /**< array to store the non-zero indices, or NULL */
810  int* ninds /**< pointer to store the number of non-zero indices, or NULL
811  * (-1: if we do not store sparsity informations) */
812  );
813 
814 /** get dense column of inverse basis matrix times constraint matrix B^-1 * A
815  *
816  * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
817  * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
818  * see also the explanation in lpi.h.
819  */
820 extern
822  SCIP_LPI* lpi, /**< LP interface structure */
823  int c, /**< column number */
824  SCIP_Real* coef, /**< vector to return coefficients */
825  int* inds, /**< array to store the non-zero indices, or NULL */
826  int* ninds /**< pointer to store the number of non-zero indices, or NULL
827  * (-1: if we do not store sparsity informations) */
828  );
829 
830 /**@} */
831 
832 
833 
834 
835 /*
836  * LPi State Methods
837  */
838 
839 /**@name LPi State Methods */
840 /**@{ */
841 
842 /** stores LPi state (like basis information) into lpistate object */
843 extern
845  SCIP_LPI* lpi, /**< LP interface structure */
846  BMS_BLKMEM* blkmem, /**< block memory */
847  SCIP_LPISTATE** lpistate /**< pointer to LPi state information (like basis information) */
848  );
849 
850 /** loads LPi state (like basis information) into solver; note that the LP might have been extended with additional
851  * columns and rows since the state was stored with SCIPlpiGetState()
852  */
853 extern
855  SCIP_LPI* lpi, /**< LP interface structure */
856  BMS_BLKMEM* blkmem, /**< block memory */
857  SCIP_LPISTATE* lpistate /**< LPi state information (like basis information) */
858  );
859 
860 /** clears current LPi state (like basis information) of the solver */
861 extern
863  SCIP_LPI* lpi /**< LP interface structure */
864  );
865 
866 /** frees LPi state information */
867 extern
869  SCIP_LPI* lpi, /**< LP interface structure */
870  BMS_BLKMEM* blkmem, /**< block memory */
871  SCIP_LPISTATE** lpistate /**< pointer to LPi state information (like basis information) */
872  );
873 
874 /** checks, whether the given LPi state contains simplex basis information */
875 extern
877  SCIP_LPI* lpi, /**< LP interface structure */
878  SCIP_LPISTATE* lpistate /**< LPi state information (like basis information) */
879  );
880 
881 /** reads LPi state (like basis information from a file */
882 extern
884  SCIP_LPI* lpi, /**< LP interface structure */
885  const char* fname /**< file name */
886  );
887 
888 /** writes LPi state (like basis information) to a file */
889 extern
891  SCIP_LPI* lpi, /**< LP interface structure */
892  const char* fname /**< file name */
893  );
894 
895 /**@} */
896 
897 
898 /*
899  * LPi Pricing Norms Methods
900  */
901 
902 /**@name LPi Pricing Norms Methods */
903 /**@{ */
904 
905 /** stores LPi pricing norms into lpinorms object */
906 extern
908  SCIP_LPI* lpi, /**< LP interface structure */
909  BMS_BLKMEM* blkmem, /**< block memory */
910  SCIP_LPINORMS** lpinorms /**< pointer to LPi pricing norms information */
911  );
912 
913 /** loads LPi pricing norms into solver; note that the LP might have been extended with additional
914  * columns and rows since the norms were stored with SCIPlpiGetNorms()
915  */
916 extern
918  SCIP_LPI* lpi, /**< LP interface structure */
919  BMS_BLKMEM* blkmem, /**< block memory */
920  SCIP_LPINORMS* lpinorms /**< LPi pricing norms information */
921  );
922 
923 /** frees LPi pricing norms information */
924 extern
926  SCIP_LPI* lpi, /**< LP interface structure */
927  BMS_BLKMEM* blkmem, /**< block memory */
928  SCIP_LPINORMS** lpinorms /**< pointer to LPi pricing norms information */
929  );
930 
931 
932 /**@} */
933 
934 
935 
936 
937 /*
938  * Parameter Methods
939  */
940 
941 /**@name Parameter Methods */
942 /**@{ */
943 
944 /** gets integer parameter of LP */
945 extern
947  SCIP_LPI* lpi, /**< LP interface structure */
948  SCIP_LPPARAM type, /**< parameter number */
949  int* ival /**< buffer to store the parameter value */
950  );
951 
952 /** sets integer parameter of LP */
953 extern
955  SCIP_LPI* lpi, /**< LP interface structure */
956  SCIP_LPPARAM type, /**< parameter number */
957  int ival /**< parameter value */
958  );
959 
960 /** gets floating point parameter of LP */
961 extern
963  SCIP_LPI* lpi, /**< LP interface structure */
964  SCIP_LPPARAM type, /**< parameter number */
965  SCIP_Real* dval /**< buffer to store the parameter value */
966  );
967 
968 /** sets floating point parameter of LP */
969 extern
971  SCIP_LPI* lpi, /**< LP interface structure */
972  SCIP_LPPARAM type, /**< parameter number */
973  SCIP_Real dval /**< parameter value */
974  );
975 
976 /**@} */
977 
978 
979 
980 
981 /*
982  * Numerical Methods
983  */
984 
985 /**@name Numerical Methods */
986 /**@{ */
987 
988 /** returns value treated as infinity in the LP solver */
989 extern
991  SCIP_LPI* lpi /**< LP interface structure */
992  );
993 
994 /** checks if given value is treated as infinity in the LP solver */
995 extern
997  SCIP_LPI* lpi, /**< LP interface structure */
998  SCIP_Real val /**< value to be checked for infinity */
999  );
1000 
1001 /**@} */
1002 
1003 
1004 
1005 
1006 /*
1007  * File Interface Methods
1008  */
1009 
1010 /**@name File Interface Methods */
1011 /**@{ */
1012 
1013 /** reads LP from a file */
1014 extern
1016  SCIP_LPI* lpi, /**< LP interface structure */
1017  const char* fname /**< file name */
1018  );
1019 
1020 /** writes LP to a file */
1021 extern
1023  SCIP_LPI* lpi, /**< LP interface structure */
1024  const char* fname /**< file name */
1025  );
1026 
1027 /**@} */
1028 
1029 #ifdef __cplusplus
1030 }
1031 #endif
1032 
1033 #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
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
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:53
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
#define SCIP_Real
Definition: def.h:127
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
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:392
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
memory allocation routines