Scippy

SCIP

Solving Constraint Integer Programs

scip_lp.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2019 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_lp.h
17  * @ingroup PUBLICCOREAPI
18  * @brief public methods for the LP relaxation, rows and columns
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  * @author Gregor Hendel
26  * @author Robert Lion Gottwald
27  */
28 
29 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
30 
31 #ifndef __SCIP_SCIP_LP_H__
32 #define __SCIP_SCIP_LP_H__
33 
34 
35 #include "lpi/type_lpi.h"
36 #include "scip/def.h"
37 #include "scip/type_cons.h"
38 #include "scip/type_lp.h"
39 #include "scip/type_misc.h"
40 #include "scip/type_retcode.h"
41 #include "scip/type_scip.h"
42 #include "scip/type_sepa.h"
43 #include "scip/type_sol.h"
44 #include "scip/type_var.h"
45 
46 #ifdef __cplusplus
47 extern "C" {
48 #endif
49 
50 /**@addtogroup PublicLPMethods
51  *
52  * @{
53  */
54 
55 /** returns, whether the LP was or is to be solved in the current node
56  *
57  * @return whether the LP was or is to be solved in the current node.
58  *
59  * @pre This method can be called if @p scip is in one of the following stages:
60  * - \ref SCIP_STAGE_SOLVING
61  *
62  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
63  */
66  SCIP* scip /**< SCIP data structure */
67  );
68 
69 /** returns, whether the LP of the current node is already constructed
70  *
71  * @return whether the LP of the current node is already constructed.
72  *
73  * @pre This method can be called if @p scip is in one of the following stages:
74  * - \ref SCIP_STAGE_SOLVING
75  *
76  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
77  */
80  SCIP* scip /**< SCIP data structure */
81  );
82 
83 /** makes sure that the LP of the current node is loaded and may be accessed through the LP information methods
84  *
85  * @warning Contructing the LP might change the amount of variables known in the transformed problem and therefore also
86  * the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to
87  * call one of the later method after this one
88  *
89  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
90  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
91  *
92  * @pre This method can be called if @p scip is in one of the following stages:
93  * - \ref SCIP_STAGE_SOLVING
94  *
95  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
96  */
99  SCIP* scip, /**< SCIP data structure */
100  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
101  );
102 
103 /** makes sure that the LP of the current node is flushed
104  *
105  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
106  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
107  *
108  * @pre This method can be called if @p scip is in one of the following stages:
109  * - \ref SCIP_STAGE_SOLVING
110  *
111  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
112  */
115  SCIP* scip /**< SCIP data structure */
116  );
117 
118 /** gets solution status of current LP
119  *
120  * @return the solution status of current LP.
121  *
122  * @pre This method can be called if @p scip is in one of the following stages:
123  * - \ref SCIP_STAGE_SOLVING
124  *
125  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
126  */
129  SCIP* scip /**< SCIP data structure */
130  );
131 
132 /** returns whether the current LP solution passed the primal feasibility check
133  *
134  * @returns whether the current LP solution passed the primal feasibility check.
135  *
136  * @pre This method can be called if @p scip is in one of the following stages:
137  * - \ref SCIP_STAGE_SOLVING
138  *
139  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
140  */
143  SCIP* scip /**< SCIP data structure */
144  );
145 
146 /** returns whether the current LP solution passed the dual feasibility check
147  *
148  * @returns whether the current LP solution passed the dual feasibility check.
149  *
150  * @pre This method can be called if @p scip is in one of the following stages:
151  * - \ref SCIP_STAGE_SOLVING
152  *
153  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
154  */
157  SCIP* scip /**< SCIP data structure */
158  );
159 
160 /** returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
161  *
162  * @return whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.
163  *
164  * @pre This method can be called if @p scip is in one of the following stages:
165  * - \ref SCIP_STAGE_SOLVING
166  *
167  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
168  */
171  SCIP* scip /**< SCIP data structure */
172  );
173 
174 /** gets objective value of current LP (which is the sum of column and loose objective value)
175  *
176  * @return the objective value of current LP (which is the sum of column and loose objective value).
177  *
178  * @pre This method can be called if @p scip is in one of the following stages:
179  * - \ref SCIP_STAGE_SOLVING
180  *
181  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
182  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by
183  * SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
184  *
185  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
186  */
189  SCIP* scip /**< SCIP data structure */
190  );
191 
192 /** gets part of objective value of current LP that results from COLUMN variables only
193  *
194  * @return the part of objective value of current LP that results from COLUMN variables only.
195  *
196  * @pre This method can be called if @p scip is in one of the following stages:
197  * - \ref SCIP_STAGE_SOLVING
198  *
199  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
200  */
203  SCIP* scip /**< SCIP data structure */
204  );
205 
206 /** gets part of objective value of current LP that results from LOOSE variables only
207  *
208  * @return part of objective value of current LP that results from LOOSE variables only.
209  *
210  * @pre This method can be called if @p scip is in one of the following stages:
211  * - \ref SCIP_STAGE_SOLVING
212  *
213  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
214  */
217  SCIP* scip /**< SCIP data structure */
218  );
219 
220 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
221  * function) global bound
222  *
223  * @return the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
224  * function) global bound.
225  *
226  * @pre This method can be called if @p scip is in one of the following stages:
227  * - \ref SCIP_STAGE_INITPRESOLVE
228  * - \ref SCIP_STAGE_PRESOLVING
229  * - \ref SCIP_STAGE_EXITPRESOLVE
230  * - \ref SCIP_STAGE_PRESOLVED
231  * - \ref SCIP_STAGE_INITSOLVE
232  * - \ref SCIP_STAGE_SOLVING
233  *
234  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
235  */
238  SCIP* scip /**< SCIP data structure */
239  );
240 
241 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
242  * objective function) local bound
243  *
244  * @return the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
245  * objective function) local bound.
246  *
247  * @pre This method can be called if @p scip is in one of the following stages:
248  * - \ref SCIP_STAGE_INITPRESOLVE
249  * - \ref SCIP_STAGE_PRESOLVING
250  * - \ref SCIP_STAGE_EXITPRESOLVE
251  * - \ref SCIP_STAGE_PRESOLVED
252  * - \ref SCIP_STAGE_INITSOLVE
253  * - \ref SCIP_STAGE_SOLVING
254  *
255  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
256  */
259  SCIP* scip /**< SCIP data structure */
260  );
261 
262 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
263  *
264  * @return whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.
265  *
266  * @pre This method can be called if @p scip is in one of the following stages:
267  * - \ref SCIP_STAGE_SOLVING
268  *
269  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
270  */
273  SCIP* scip /**< SCIP data structure */
274  );
275 
276 /** gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved
277  *
278  * @return the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved.
279  *
280  * @pre This method can be called if @p scip is in one of the following stages:
281  * - \ref SCIP_STAGE_INITPRESOLVE
282  * - \ref SCIP_STAGE_PRESOLVING
283  * - \ref SCIP_STAGE_EXITPRESOLVE
284  * - \ref SCIP_STAGE_SOLVING
285  *
286  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
287  */
290  SCIP* scip /**< SCIP data structure */
291  );
292 
293 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
294  * returns SCIP_INVALID if the root node LP was not (yet) solved
295  *
296  * @return the part of the objective value of the root node LP that results from COLUMN variables only;
297  * or SCIP_INVALID if the root node LP was not (yet) solved.
298  *
299  * @pre This method can be called if @p scip is in one of the following stages:
300  * - \ref SCIP_STAGE_INITPRESOLVE
301  * - \ref SCIP_STAGE_PRESOLVING
302  * - \ref SCIP_STAGE_EXITPRESOLVE
303  * - \ref SCIP_STAGE_SOLVING
304  *
305  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
306  */
309  SCIP* scip /**< SCIP data structure */
310  );
311 
312 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
313  * returns SCIP_INVALID if the root node LP was not (yet) solved
314  *
315  * @return the part of the objective value of the root node LP that results from LOOSE variables only;
316  * or SCIP_INVALID if the root node LP was not (yet) solved.
317  *
318  * @pre This method can be called if @p scip is in one of the following stages:
319  * - \ref SCIP_STAGE_INITPRESOLVE
320  * - \ref SCIP_STAGE_PRESOLVING
321  * - \ref SCIP_STAGE_EXITPRESOLVE
322  * - \ref SCIP_STAGE_SOLVING
323  *
324  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
325  */
328  SCIP* scip /**< SCIP data structure */
329  );
330 
331 /** gets current LP columns along with the current number of LP columns
332  *
333  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
334  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
335  *
336  * @pre This method can be called if @p scip is in one of the following stages:
337  * - \ref SCIP_STAGE_SOLVING
338  *
339  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
340  */
343  SCIP* scip, /**< SCIP data structure */
344  SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */
345  int* ncols /**< pointer to store the number of LP columns, or NULL */
346  );
347 
348 /** gets current LP columns
349  *
350  * @return the current LP columns.
351  *
352  * @pre This method can be called if @p scip is in one of the following stages:
353  * - \ref SCIP_STAGE_SOLVING
354  *
355  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
356  */
359  SCIP* scip /**< SCIP data structure */
360  );
361 
362 /** gets current number of LP columns
363  *
364  * @return the current number of LP columns.
365  *
366  * @pre This method can be called if @p scip is in one of the following stages:
367  * - \ref SCIP_STAGE_SOLVING
368  *
369  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
370  */
372 int SCIPgetNLPCols(
373  SCIP* scip /**< SCIP data structure */
374  );
375 
376 /** gets current LP rows along with the current number of LP rows
377  *
378  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
379  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
380  *
381  * @pre This method can be called if @p scip is in one of the following stages:
382  * - \ref SCIP_STAGE_SOLVING
383  *
384  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
385  */
388  SCIP* scip, /**< SCIP data structure */
389  SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */
390  int* nrows /**< pointer to store the number of LP rows, or NULL */
391  );
392 
393 /** gets current LP rows
394  *
395  * @return the current LP rows.
396  *
397  * @pre This method can be called if @p scip is in one of the following stages:
398  * - \ref SCIP_STAGE_SOLVING
399  *
400  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
401  */
404  SCIP* scip /**< SCIP data structure */
405  );
406 
407 /** gets current number of LP rows
408  *
409  * @return the current number of LP rows.
410  *
411  * @pre This method can be called if @p scip is in one of the following stages:
412  * - \ref SCIP_STAGE_SOLVING
413  *
414  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
415  */
417 int SCIPgetNLPRows(
418  SCIP* scip /**< SCIP data structure */
419  );
420 
421 /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
422  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
423  *
424  * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
425  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.
426  *
427  * @pre This method can be called if @p scip is in one of the following stages:
428  * - \ref SCIP_STAGE_SOLVING
429  *
430  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
431  */
434  SCIP* scip /**< SCIP data structure */
435  );
436 
437 /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
438  *
439  * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis.
440  *
441  * @pre This method can be called if @p scip is in one of the following stages:
442  * - \ref SCIP_STAGE_SOLVING
443  *
444  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
445  */
448  SCIP* scip /**< SCIP data structure */
449  );
450 
451 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
452  *
453  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
454  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
455  *
456  * @pre This method can be called if @p scip is in one of the following stages:
457  * - \ref SCIP_STAGE_SOLVING
458  *
459  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
460  */
463  SCIP* scip, /**< SCIP data structure */
464  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
465  );
466 
467 /** gets a row from the inverse basis matrix B^-1
468  *
469  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
470  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
471  *
472  * @pre This method can be called if @p scip is in one of the following stages:
473  * - \ref SCIP_STAGE_SOLVING
474  *
475  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
476  */
479  SCIP* scip, /**< SCIP data structure */
480  int r, /**< row number */
481  SCIP_Real* coefs, /**< array to store the coefficients of the row */
482  int* inds, /**< array to store the non-zero indices, or NULL */
483  int* ninds /**< pointer to store the number of non-zero indices, or NULL
484  * (-1: if we do not store sparsity informations) */
485  );
486 
487 /** gets a column from the inverse basis matrix B^-1
488  *
489  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
490  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
491  *
492  * @pre This method can be called if @p scip is in one of the following stages:
493  * - \ref SCIP_STAGE_SOLVING
494  *
495  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
496  */
499  SCIP* scip, /**< SCIP data structure */
500  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
501  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
502  * to get the array which links the B^-1 column numbers to the row and
503  * column numbers of the LP! c must be between 0 and nrows-1, since the
504  * basis has the size nrows * nrows */
505  SCIP_Real* coefs, /**< array to store the coefficients of the column */
506  int* inds, /**< array to store the non-zero indices, or NULL */
507  int* ninds /**< pointer to store the number of non-zero indices, or NULL
508  * (-1: if we do not store sparsity informations) */
509  );
510 
511 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
512  *
513  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
514  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
515  *
516  * @pre This method can be called if @p scip is in one of the following stages:
517  * - \ref SCIP_STAGE_SOLVING
518  *
519  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
520  */
523  SCIP* scip, /**< SCIP data structure */
524  int r, /**< row number */
525  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */
526  SCIP_Real* coefs, /**< array to store the coefficients of the row */
527  int* inds, /**< array to store the non-zero indices, or NULL */
528  int* ninds /**< pointer to store the number of non-zero indices, or NULL
529  * (-1: if we do not store sparsity informations) */
530  );
531 
532 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
533  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
534  *
535  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
537  *
538  * @pre This method can be called if @p scip is in one of the following stages:
539  * - \ref SCIP_STAGE_SOLVING
540  *
541  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
542  */
545  SCIP* scip, /**< SCIP data structure */
546  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
547  SCIP_Real* coefs, /**< array to store the coefficients of the column */
548  int* inds, /**< array to store the non-zero indices, or NULL */
549  int* ninds /**< pointer to store the number of non-zero indices, or NULL
550  * (-1: if we do not store sparsity informations) */
551  );
552 
553 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
554  * LP row are swapped in the summation
555  *
556  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
557  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
558  *
559  * @pre This method can be called if @p scip is in one of the following stages:
560  * - \ref SCIP_STAGE_SOLVING
561  *
562  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
563  */
566  SCIP* scip, /**< SCIP data structure */
567  SCIP_Real* weights, /**< row weights in row summation */
568  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
569  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
570  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
571  );
572 
573 /** writes current LP to a file
574  *
575  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
576  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
577  *
578  * @pre This method can be called if @p scip is in one of the following stages:
579  * - \ref SCIP_STAGE_SOLVING
580  *
581  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
582  */
585  SCIP* scip, /**< SCIP data structure */
586  const char* filename /**< file name */
587  );
588 
589 /** writes MIP relaxation of the current branch-and-bound node to a file
590  *
591  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
592  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
593  *
594  * @pre This method can be called if @p scip is in one of the following stages:
595  * - \ref SCIP_STAGE_SOLVING
596  *
597  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
598  */
601  SCIP* scip, /**< SCIP data structure */
602  const char* filename, /**< file name */
603  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
604  * troubles with reserved symbols? */
605  SCIP_Bool origobj, /**< should the original objective function be used? */
606  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
607  );
608 
609 /** gets the LP interface of SCIP;
610  * with the LPI you can use all of the methods defined in lpi/lpi.h;
611  *
612  * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely
613  * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution
614  * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in
615  * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make
616  * sure, the internal solution status is recovered completely at the end of your method. This can be achieved
617  * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it
618  * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the
619  * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.
620  *
621  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
622  *
623  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
624  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
625  *
626  * @pre This method can be called if @p scip is in one of the following stages:
627  * - \ref SCIP_STAGE_TRANSFORMED
628  * - \ref SCIP_STAGE_INITPRESOLVE
629  * - \ref SCIP_STAGE_PRESOLVING
630  * - \ref SCIP_STAGE_EXITPRESOLVE
631  * - \ref SCIP_STAGE_PRESOLVED
632  * - \ref SCIP_STAGE_INITSOLVE
633  * - \ref SCIP_STAGE_SOLVING
634  * - \ref SCIP_STAGE_SOLVED
635  * - \ref SCIP_STAGE_EXITSOLVE
636  *
637  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
638  */
641  SCIP* scip, /**< SCIP data structure */
642  SCIP_LPI** lpi /**< pointer to store the LP interface */
643  );
644 
645 /** Displays quality information about the current LP solution. An LP solution need to be available. Information printed
646  * is subject to what the LP solver supports
647  *
648  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
649  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
650  *
651  * @pre This method can be called if @p scip is in one of the following stages:
652  * - \ref SCIP_STAGE_INIT
653  * - \ref SCIP_STAGE_PROBLEM
654  * - \ref SCIP_STAGE_TRANSFORMED
655  * - \ref SCIP_STAGE_INITPRESOLVE
656  * - \ref SCIP_STAGE_PRESOLVING
657  * - \ref SCIP_STAGE_EXITPRESOLVE
658  * - \ref SCIP_STAGE_PRESOLVED
659  * - \ref SCIP_STAGE_SOLVING
660  * - \ref SCIP_STAGE_SOLVED
661  * - \ref SCIP_STAGE_FREE
662  *
663  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
664  *
665  * @note The printing process is done via the message handler system.
666  */
669  SCIP* scip, /**< SCIP data structure */
670  FILE* file /**< output file (or NULL for standard output) */
671  );
672 
673 /** compute relative interior point to current LP
674  * @see SCIPlpComputeRelIntPoint
675  *
676  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
677  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
678  *
679  * @pre This method can be called if @p scip is in one of the following stages:
680  * - \ref SCIP_STAGE_TRANSFORMED
681  * - \ref SCIP_STAGE_INITPRESOLVE
682  * - \ref SCIP_STAGE_PRESOLVING
683  * - \ref SCIP_STAGE_EXITPRESOLVE
684  * - \ref SCIP_STAGE_PRESOLVED
685  * - \ref SCIP_STAGE_SOLVING
686  * - \ref SCIP_STAGE_SOLVED
687  *
688  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
689  */
692  SCIP* scip, /**< SCIP data structure */
693  SCIP_Bool relaxrows, /**< should the rows be relaxed */
694  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
695  SCIP_Real timelimit, /**< time limit for LP solver */
696  int iterlimit, /**< iteration limit for LP solver */
697  SCIP_SOL** point /**< relative interior point on exit */
698  );
699 
700 /**@} */
701 
702 /**@addtogroup PublicColumnMethods
703  *
704  * @{
705  */
706 
707 /** returns the reduced costs of a column in the last (feasible) LP
708  *
709  * @return the reduced costs of a column in the last (feasible) LP
710  *
711  * @pre this method can be called in one of the following stages of the SCIP solving process:
712  * - \ref SCIP_STAGE_SOLVING
713  * - \ref SCIP_STAGE_SOLVED
714  *
715  * @note calling this method in SCIP_STAGE_SOLVED is only recommended to experienced users and should only be called
716  * for pure LP instances (without presolving)
717  *
718  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
719  */
722  SCIP* scip, /**< SCIP data structure */
723  SCIP_COL* col /**< LP column */
724  );
725 
726 /** returns the Farkas coefficient of a column in the last (infeasible) LP
727  *
728  * @return the Farkas coefficient of a column in the last (infeasible) LP
729  *
730  * @pre this method can be called in one of the following stages of the SCIP solving process:
731  * - \ref SCIP_STAGE_SOLVING
732  */
735  SCIP* scip, /**< SCIP data structure */
736  SCIP_COL* col /**< LP column */
737  );
738 
739 /** marks a column to be not removable from the LP in the current node
740  *
741  * @pre this method can be called in the following stage of the SCIP solving process:
742  * - \ref SCIP_STAGE_SOLVING
743  */
746  SCIP* scip, /**< SCIP data structure */
747  SCIP_COL* col /**< LP column */
748  );
749 
750 /**@} */
751 
752 /**@addtogroup PublicRowMethods
753  *
754  * @{
755  */
756 
757 /** creates and captures an LP row from a constraint handler
758  *
759  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
760  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
761  *
762  * @pre this method can be called in one of the following stages of the SCIP solving process:
763  * - \ref SCIP_STAGE_INITSOLVE
764  * - \ref SCIP_STAGE_SOLVING
765  */
768  SCIP* scip, /**< SCIP data structure */
769  SCIP_ROW** row, /**< pointer to row */
770  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
771  const char* name, /**< name of row */
772  int len, /**< number of nonzeros in the row */
773  SCIP_COL** cols, /**< array with columns of row entries */
774  SCIP_Real* vals, /**< array with coefficients of row entries */
775  SCIP_Real lhs, /**< left hand side of row */
776  SCIP_Real rhs, /**< right hand side of row */
777  SCIP_Bool local, /**< is row only valid locally? */
778  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
779  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
780  );
781 
782 /** creates and captures an LP row from a separator
783  *
784  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
785  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
786  *
787  * @pre this method can be called in one of the following stages of the SCIP solving process:
788  * - \ref SCIP_STAGE_INITSOLVE
789  * - \ref SCIP_STAGE_SOLVING
790  */
793  SCIP* scip, /**< SCIP data structure */
794  SCIP_ROW** row, /**< pointer to row */
795  SCIP_SEPA* sepa, /**< separator that creates the row */
796  const char* name, /**< name of row */
797  int len, /**< number of nonzeros in the row */
798  SCIP_COL** cols, /**< array with columns of row entries */
799  SCIP_Real* vals, /**< array with coefficients of row entries */
800  SCIP_Real lhs, /**< left hand side of row */
801  SCIP_Real rhs, /**< right hand side of row */
802  SCIP_Bool local, /**< is row only valid locally? */
803  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
804  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
805  );
806 
807 /** creates and captures an LP row from an unspecified source
808  *
809  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
810  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
811  *
812  * @pre this method can be called in one of the following stages of the SCIP solving process:
813  * - \ref SCIP_STAGE_INITSOLVE
814  * - \ref SCIP_STAGE_SOLVING
815  */
818  SCIP* scip, /**< SCIP data structure */
819  SCIP_ROW** row, /**< pointer to row */
820  const char* name, /**< name of row */
821  int len, /**< number of nonzeros in the row */
822  SCIP_COL** cols, /**< array with columns of row entries */
823  SCIP_Real* vals, /**< array with coefficients of row entries */
824  SCIP_Real lhs, /**< left hand side of row */
825  SCIP_Real rhs, /**< right hand side of row */
826  SCIP_Bool local, /**< is row only valid locally? */
827  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
828  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
829  );
830 
831 /** creates and captures an LP row
832  *
833  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
834  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
835  *
836  * @pre this method can be called in one of the following stages of the SCIP solving process:
837  * - \ref SCIP_STAGE_INITSOLVE
838  * - \ref SCIP_STAGE_SOLVING
839  *
840  * @deprecated Please use SCIPcreateRowCons() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order
841  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().
842  */
845  SCIP* scip, /**< SCIP data structure */
846  SCIP_ROW** row, /**< pointer to row */
847  const char* name, /**< name of row */
848  int len, /**< number of nonzeros in the row */
849  SCIP_COL** cols, /**< array with columns of row entries */
850  SCIP_Real* vals, /**< array with coefficients of row entries */
851  SCIP_Real lhs, /**< left hand side of row */
852  SCIP_Real rhs, /**< right hand side of row */
853  SCIP_Bool local, /**< is row only valid locally? */
854  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
855  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
856  );
857 
858 /** creates and captures an LP row without any coefficients from a constraint handler
859  *
860  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
861  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
862  *
863  * @pre this method can be called in one of the following stages of the SCIP solving process:
864  * - \ref SCIP_STAGE_INITSOLVE
865  * - \ref SCIP_STAGE_SOLVING
866  */
869  SCIP* scip, /**< SCIP data structure */
870  SCIP_ROW** row, /**< pointer to row */
871  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
872  const char* name, /**< name of row */
873  SCIP_Real lhs, /**< left hand side of row */
874  SCIP_Real rhs, /**< right hand side of row */
875  SCIP_Bool local, /**< is row only valid locally? */
876  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
877  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
878  );
879 
880 /** creates and captures an LP row without any coefficients from a separator
881  *
882  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
883  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
884  *
885  * @pre this method can be called in one of the following stages of the SCIP solving process:
886  * - \ref SCIP_STAGE_INITSOLVE
887  * - \ref SCIP_STAGE_SOLVING
888  */
891  SCIP* scip, /**< SCIP data structure */
892  SCIP_ROW** row, /**< pointer to row */
893  SCIP_SEPA* sepa, /**< separator that creates the row */
894  const char* name, /**< name of row */
895  SCIP_Real lhs, /**< left hand side of row */
896  SCIP_Real rhs, /**< right hand side of row */
897  SCIP_Bool local, /**< is row only valid locally? */
898  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
899  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
900  );
901 
902 /** creates and captures an LP row without any coefficients from an unspecified source
903  *
904  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
905  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
906  *
907  * @pre this method can be called in one of the following stages of the SCIP solving process:
908  * - \ref SCIP_STAGE_INITSOLVE
909  * - \ref SCIP_STAGE_SOLVING
910  */
913  SCIP* scip, /**< SCIP data structure */
914  SCIP_ROW** row, /**< pointer to row */
915  const char* name, /**< name of row */
916  SCIP_Real lhs, /**< left hand side of row */
917  SCIP_Real rhs, /**< right hand side of row */
918  SCIP_Bool local, /**< is row only valid locally? */
919  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
920  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
921  );
922 
923 /** creates and captures an LP row without any coefficients
924  *
925  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
926  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
927  *
928  * @pre this method can be called in one of the following stages of the SCIP solving process:
929  * - \ref SCIP_STAGE_INITSOLVE
930  * - \ref SCIP_STAGE_SOLVING
931  *
932  * @deprecated Please use SCIPcreateEmptyRowCons() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order
933  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().
934  */
937  SCIP* scip, /**< SCIP data structure */
938  SCIP_ROW** row, /**< pointer to row */
939  const char* name, /**< name of row */
940  SCIP_Real lhs, /**< left hand side of row */
941  SCIP_Real rhs, /**< right hand side of row */
942  SCIP_Bool local, /**< is row only valid locally? */
943  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
944  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
945  );
946 
947 /** increases usage counter of LP row
948  *
949  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
950  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
951  *
952  * @pre this method can be called in one of the following stages of the SCIP solving process:
953  * - \ref SCIP_STAGE_INITSOLVE
954  * - \ref SCIP_STAGE_SOLVING
955  */
958  SCIP* scip, /**< SCIP data structure */
959  SCIP_ROW* row /**< row to capture */
960  );
961 
962 /** decreases usage counter of LP row, and frees memory if necessary
963  *
964  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
965  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
966  *
967  * @pre this method can be called in one of the following stages of the SCIP solving process:
968  * - \ref SCIP_STAGE_INITSOLVE
969  * - \ref SCIP_STAGE_SOLVING
970  * - \ref SCIP_STAGE_EXITSOLVE
971  */
974  SCIP* scip, /**< SCIP data structure */
975  SCIP_ROW** row /**< pointer to LP row */
976  );
977 
978 /** changes left hand side of LP row
979  *
980  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
981  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
982  *
983  * @pre this method can be called in one of the following stages of the SCIP solving process:
984  * - \ref SCIP_STAGE_INITSOLVE
985  * - \ref SCIP_STAGE_SOLVING
986  */
989  SCIP* scip, /**< SCIP data structure */
990  SCIP_ROW* row, /**< LP row */
991  SCIP_Real lhs /**< new left hand side */
992  );
993 
994 /** changes right hand side of LP row
995  *
996  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
997  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
998  *
999  * @pre this method can be called in one of the following stages of the SCIP solving process:
1000  * - \ref SCIP_STAGE_INITSOLVE
1001  * - \ref SCIP_STAGE_SOLVING
1002  */
1005  SCIP* scip, /**< SCIP data structure */
1006  SCIP_ROW* row, /**< LP row */
1007  SCIP_Real rhs /**< new right hand side */
1008  );
1009 
1010 /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
1011  * after all additions were applied, SCIPflushRowExtensions() must be called;
1012  * while the caching of row extensions is activated, information methods of the row give invalid results;
1013  * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase
1014  * the performance
1015  *
1016  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1017  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1018  *
1019  * @pre this method can be called in one of the following stages of the SCIP solving process:
1020  * - \ref SCIP_STAGE_INITSOLVE
1021  * - \ref SCIP_STAGE_SOLVING
1022  */
1025  SCIP* scip, /**< SCIP data structure */
1026  SCIP_ROW* row /**< LP row */
1027  );
1028 
1029 /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with
1030  * equal columns into a single coefficient
1031  *
1032  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1033  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1034  *
1035  * @pre this method can be called in one of the following stages of the SCIP solving process:
1036  * - \ref SCIP_STAGE_INITSOLVE
1037  * - \ref SCIP_STAGE_SOLVING
1038  */
1041  SCIP* scip, /**< SCIP data structure */
1042  SCIP_ROW* row /**< LP row */
1043  );
1044 
1045 /** resolves variable to columns and adds them with the coefficient to the row
1046  *
1047  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1048  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1049  *
1050  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variable will not added.
1051  *
1052  * @pre this method can be called in one of the following stages of the SCIP solving process:
1053  * - \ref SCIP_STAGE_INITSOLVE
1054  * - \ref SCIP_STAGE_SOLVING
1055  *
1056  * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables,
1057  * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP.
1058  * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution
1059  * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but
1060  * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the
1061  * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was
1062  * violated, the linear relaxation might not be violated anymore.)
1063  */
1066  SCIP* scip, /**< SCIP data structure */
1067  SCIP_ROW* row, /**< LP row */
1068  SCIP_VAR* var, /**< problem variable */
1069  SCIP_Real val /**< value of coefficient */
1070  );
1071 
1072 /** resolves variables to columns and adds them with the coefficients to the row;
1073  * this method caches the row extensions and flushes them afterwards to gain better performance
1074  *
1075  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1076  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1077  *
1078  * @attention If a coefficients absolute value is below the SCIP epsilon tolerance, the variable with its value is not added.
1079  *
1080  * @pre this method can be called in one of the following stages of the SCIP solving process:
1081  * - \ref SCIP_STAGE_INITSOLVE
1082  * - \ref SCIP_STAGE_SOLVING
1083  */
1086  SCIP* scip, /**< SCIP data structure */
1087  SCIP_ROW* row, /**< LP row */
1088  int nvars, /**< number of variables to add to the row */
1089  SCIP_VAR** vars, /**< problem variables to add */
1090  SCIP_Real* vals /**< values of coefficients */
1091  );
1092 
1093 /** resolves variables to columns and adds them with the same single coefficient to the row;
1094  * this method caches the row extensions and flushes them afterwards to gain better performance
1095  *
1096  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1097  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1098  *
1099  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variables will not added.
1100  *
1101  * @pre this method can be called in one of the following stages of the SCIP solving process:
1102  * - \ref SCIP_STAGE_INITSOLVE
1103  * - \ref SCIP_STAGE_SOLVING
1104  */
1107  SCIP* scip, /**< SCIP data structure */
1108  SCIP_ROW* row, /**< LP row */
1109  int nvars, /**< number of variables to add to the row */
1110  SCIP_VAR** vars, /**< problem variables to add */
1111  SCIP_Real val /**< unique value of all coefficients */
1112  );
1113 
1114 /** tries to find a value, such that all row coefficients, if scaled with this value become integral
1115  *
1116  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1117  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1118  *
1119  * @pre this method can be called in one of the following stages of the SCIP solving process:
1120  * - \ref SCIP_STAGE_INITSOLVE
1121  * - \ref SCIP_STAGE_SOLVING
1122  */
1125  SCIP* scip, /**< SCIP data structure */
1126  SCIP_ROW* row, /**< LP row */
1127  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
1128  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
1129  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
1130  SCIP_Real maxscale, /**< maximal allowed scalar */
1131  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
1132  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
1133  SCIP_Bool* success /**< stores whether returned value is valid */
1134  );
1135 
1136 /** tries to scale row, s.t. all coefficients (of integer variables) become integral
1137  *
1138  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1139  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1140  *
1141  * @pre this method can be called in one of the following stages of the SCIP solving process:
1142  * - \ref SCIP_STAGE_INITSOLVE
1143  * - \ref SCIP_STAGE_SOLVING
1144  */
1147  SCIP* scip, /**< SCIP data structure */
1148  SCIP_ROW* row, /**< LP row */
1149  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
1150  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
1151  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
1152  SCIP_Real maxscale, /**< maximal value to scale row with */
1153  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
1154  SCIP_Bool* success /**< stores whether row could be made rational */
1155  );
1156 
1157 /** marks a row to be not removable from the LP in the current node
1158  *
1159  * @pre this method can be called in the following stage of the SCIP solving process:
1160  * - \ref SCIP_STAGE_SOLVING
1161  */
1164  SCIP* scip, /**< SCIP data structure */
1165  SCIP_ROW* row /**< LP row */
1166  );
1167 
1168 /** returns number of integral columns in the row
1169  *
1170  * @return number of integral columns in the row
1171  *
1172  * @pre this method can be called in one of the following stages of the SCIP solving process:
1173  * - \ref SCIP_STAGE_INITSOLVE
1174  * - \ref SCIP_STAGE_SOLVING
1175  */
1178  SCIP* scip, /**< SCIP data structure */
1179  SCIP_ROW* row /**< LP row */
1180  );
1181 
1182 /** returns minimal absolute value of row vector's non-zero coefficients
1183  *
1184  * @return minimal absolute value of row vector's non-zero coefficients
1185  *
1186  * @pre this method can be called in one of the following stages of the SCIP solving process:
1187  * - \ref SCIP_STAGE_INITSOLVE
1188  * - \ref SCIP_STAGE_SOLVING
1189  */
1192  SCIP* scip, /**< SCIP data structure */
1193  SCIP_ROW* row /**< LP row */
1194  );
1195 
1196 /** returns maximal absolute value of row vector's non-zero coefficients
1197  *
1198  * @return maximal absolute value of row vector's non-zero coefficients
1199  *
1200  * @pre this method can be called in one of the following stages of the SCIP solving process:
1201  * - \ref SCIP_STAGE_INITSOLVE
1202  * - \ref SCIP_STAGE_SOLVING
1203  */
1206  SCIP* scip, /**< SCIP data structure */
1207  SCIP_ROW* row /**< LP row */
1208  );
1209 
1210 /** returns the minimal activity of a row w.r.t. the column's bounds
1211  *
1212  * @return the minimal activity of a row w.r.t. the column's bounds
1213  *
1214  * @pre this method can be called in one of the following stages of the SCIP solving process:
1215  * - \ref SCIP_STAGE_SOLVING
1216  */
1219  SCIP* scip, /**< SCIP data structure */
1220  SCIP_ROW* row /**< LP row */
1221  );
1222 
1223 /** returns the maximal activity of a row w.r.t. the column's bounds
1224  *
1225  * @return the maximal activity of a row w.r.t. the column's bounds
1226  *
1227  * @pre this method can be called in one of the following stages of the SCIP solving process:
1228  * - \ref SCIP_STAGE_SOLVING
1229  */
1232  SCIP* scip, /**< SCIP data structure */
1233  SCIP_ROW* row /**< LP row */
1234  );
1235 
1236 /** recalculates the activity of a row in the last LP solution
1237  *
1238  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1239  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1240  *
1241  * @pre this method can be called in one of the following stages of the SCIP solving process:
1242  * - \ref SCIP_STAGE_SOLVING
1243  */
1246  SCIP* scip, /**< SCIP data structure */
1247  SCIP_ROW* row /**< LP row */
1248  );
1249 
1250 /** returns the activity of a row in the last LP solution
1251  *
1252  * @return activity of a row in the last LP solution
1253  *
1254  * @pre this method can be called in one of the following stages of the SCIP solving process:
1255  * - \ref SCIP_STAGE_SOLVING
1256  */
1259  SCIP* scip, /**< SCIP data structure */
1260  SCIP_ROW* row /**< LP row */
1261  );
1262 
1263 /** returns the feasibility of a row in the last LP solution
1264  *
1265  * @return the feasibility of a row in the last LP solution: negative value means infeasibility
1266  *
1267  * @pre this method can be called in one of the following stages of the SCIP solving process:
1268  * - \ref SCIP_STAGE_SOLVING
1269  */
1272  SCIP* scip, /**< SCIP data structure */
1273  SCIP_ROW* row /**< LP row */
1274  );
1275 
1276 /** recalculates the activity of a row for the current pseudo solution
1277  *
1278  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1279  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1280  *
1281  * @pre this method can be called in one of the following stages of the SCIP solving process:
1282  * - \ref SCIP_STAGE_SOLVING
1283  */
1286  SCIP* scip, /**< SCIP data structure */
1287  SCIP_ROW* row /**< LP row */
1288  );
1289 
1290 /** returns the activity of a row for the current pseudo solution
1291  *
1292  * @return the activity of a row for the current pseudo solution
1293  *
1294  * @pre this method can be called in one of the following stages of the SCIP solving process:
1295  * - \ref SCIP_STAGE_SOLVING
1296  */
1299  SCIP* scip, /**< SCIP data structure */
1300  SCIP_ROW* row /**< LP row */
1301  );
1302 
1303 /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
1304  *
1305  * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility
1306  *
1307  * @pre this method can be called in one of the following stages of the SCIP solving process:
1308  * - \ref SCIP_STAGE_SOLVING
1309  */
1312  SCIP* scip, /**< SCIP data structure */
1313  SCIP_ROW* row /**< LP row */
1314  );
1315 
1316 /** recalculates the activity of a row in the last LP or pseudo solution
1317  *
1318  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1319  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1320  *
1321  * @pre this method can be called in one of the following stages of the SCIP solving process:
1322  * - \ref SCIP_STAGE_SOLVING
1323  */
1326  SCIP* scip, /**< SCIP data structure */
1327  SCIP_ROW* row /**< LP row */
1328  );
1329 
1330 /** returns the activity of a row in the last LP or pseudo solution
1331  *
1332  * @return the activity of a row in the last LP or pseudo solution
1333  *
1334  * @pre this method can be called in one of the following stages of the SCIP solving process:
1335  * - \ref SCIP_STAGE_SOLVING
1336  */
1339  SCIP* scip, /**< SCIP data structure */
1340  SCIP_ROW* row /**< LP row */
1341  );
1342 
1343 /** returns the feasibility of a row in the last LP or pseudo solution
1344  *
1345  * @return the feasibility of a row in the last LP or pseudo solution
1346  *
1347  * @pre this method can be called in one of the following stages of the SCIP solving process:
1348  * - \ref SCIP_STAGE_SOLVING
1349  */
1352  SCIP* scip, /**< SCIP data structure */
1353  SCIP_ROW* row /**< LP row */
1354  );
1355 
1356 /** returns the activity of a row for the given primal solution
1357  *
1358  * @return the activitiy of a row for the given primal solution
1359  *
1360  * @pre this method can be called in one of the following stages of the SCIP solving process:
1361  * - \ref SCIP_STAGE_SOLVING
1362  */
1365  SCIP* scip, /**< SCIP data structure */
1366  SCIP_ROW* row, /**< LP row */
1367  SCIP_SOL* sol /**< primal CIP solution */
1368  );
1369 
1370 /** returns the feasibility of a row for the given primal solution
1371  *
1372  * @return the feasibility of a row for the given primal solution
1373  *
1374  * @pre this method can be called in one of the following stages of the SCIP solving process:
1375  * - \ref SCIP_STAGE_SOLVING
1376  */
1379  SCIP* scip, /**< SCIP data structure */
1380  SCIP_ROW* row, /**< LP row */
1381  SCIP_SOL* sol /**< primal CIP solution */
1382  );
1383 
1384 /** output row to file stream via the message handler system
1385  *
1386  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1387  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1388  *
1389  * @pre this method can be called in one of the following stages of the SCIP solving process:
1390  * - \ref SCIP_STAGE_INITSOLVE
1391  * - \ref SCIP_STAGE_SOLVING
1392  * - \ref SCIP_STAGE_SOLVED
1393  * - \ref SCIP_STAGE_EXITSOLVE
1394  */
1397  SCIP* scip, /**< SCIP data structure */
1398  SCIP_ROW* row, /**< LP row */
1399  FILE* file /**< output file (or NULL for standard output) */
1400  );
1401 
1402 /**@} */
1403 
1404 /**@addtogroup PublicLPDivingMethods
1405  *
1406  * @{
1407  */
1408 
1409 /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
1410  *
1411  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1412  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1413  *
1414  * @pre This method can be called if @p scip is in one of the following stages:
1415  * - \ref SCIP_STAGE_SOLVING
1416  *
1417  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1418  *
1419  * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware
1420  * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from
1421  * numerical troubles during the last LP solve; because of this, most users will want to call this method only if
1422  * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL
1423  */
1426  SCIP* scip /**< SCIP data structure */
1427  );
1428 
1429 /** quits LP diving and resets bounds and objective values of columns to the current node's values
1430  *
1431  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1432  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1433  *
1434  * @pre This method can be called if @p scip is in one of the following stages:
1435  * - \ref SCIP_STAGE_SOLVING
1436  *
1437  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1438  */
1441  SCIP* scip /**< SCIP data structure */
1442  );
1443 
1444 /** changes cutoffbound in current dive
1445  *
1446  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1447  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1448  *
1449  * @pre This method can be called if @p scip is in one of the following stages:
1450  * - \ref SCIP_STAGE_SOLVING
1451  *
1452  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1453  */
1456  SCIP* scip, /**< SCIP data structure */
1457  SCIP_Real newcutoffbound /**< new cutoffbound */
1458  );
1459 
1460 /** changes variable's objective value in current dive
1461  *
1462  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1463  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1464  *
1465  * @pre This method can be called if @p scip is in one of the following stages:
1466  * - \ref SCIP_STAGE_SOLVING
1467  *
1468  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1469  */
1472  SCIP* scip, /**< SCIP data structure */
1473  SCIP_VAR* var, /**< variable to change the objective value for */
1474  SCIP_Real newobj /**< new objective value */
1475  );
1476 
1477 /** changes variable's lower bound in current dive
1478  *
1479  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1480  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1481  *
1482  * @pre This method can be called if @p scip is in one of the following stages:
1483  * - \ref SCIP_STAGE_SOLVING
1484  *
1485  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1486  */
1489  SCIP* scip, /**< SCIP data structure */
1490  SCIP_VAR* var, /**< variable to change the bound for */
1491  SCIP_Real newbound /**< new value for bound */
1492  );
1493 
1494 /** changes variable's upper bound in current dive
1495  *
1496  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1497  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1498  *
1499  * @pre This method can be called if @p scip is in one of the following stages:
1500  * - \ref SCIP_STAGE_SOLVING
1501  *
1502  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1503  */
1506  SCIP* scip, /**< SCIP data structure */
1507  SCIP_VAR* var, /**< variable to change the bound for */
1508  SCIP_Real newbound /**< new value for bound */
1509  );
1510 
1511 /** adds a row to the LP in current dive
1512  *
1513  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1514  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1515  *
1516  * @pre This method can be called if @p scip is in one of the following stages:
1517  * - \ref SCIP_STAGE_SOLVING
1518  *
1519  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1520  */
1523  SCIP* scip, /**< SCIP data structure */
1524  SCIP_ROW* row /**< row to be added */
1525  );
1526 
1527 /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
1528  *
1529  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1530  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1531  *
1532  * @pre This method can be called if @p scip is in one of the following stages:
1533  * - \ref SCIP_STAGE_SOLVING
1534  *
1535  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1536  */
1539  SCIP* scip, /**< SCIP data structure */
1540  SCIP_ROW* row, /**< row to change the lhs for */
1541  SCIP_Real newlhs /**< new value for lhs */
1542  );
1543 
1544 /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
1545  *
1546  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1547  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1548  *
1549  * @pre This method can be called if @p scip is in one of the following stages:
1550  * - \ref SCIP_STAGE_SOLVING
1551  *
1552  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1553  */
1556  SCIP* scip, /**< SCIP data structure */
1557  SCIP_ROW* row, /**< row to change the lhs for */
1558  SCIP_Real newrhs /**< new value for rhs */
1559  );
1560 
1561 /** gets variable's objective value in current dive
1562  *
1563  * @return the variable's objective value in current dive.
1564  *
1565  * @pre This method can be called if @p scip is in one of the following stages:
1566  * - \ref SCIP_STAGE_SOLVING
1567  *
1568  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1569  */
1572  SCIP* scip, /**< SCIP data structure */
1573  SCIP_VAR* var /**< variable to get the bound for */
1574  );
1575 
1576 /** gets variable's lower bound in current dive
1577  *
1578  * @return the variable's lower bound in current dive.
1579  *
1580  * @pre This method can be called if @p scip is in one of the following stages:
1581  * - \ref SCIP_STAGE_SOLVING
1582  *
1583  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1584  */
1587  SCIP* scip, /**< SCIP data structure */
1588  SCIP_VAR* var /**< variable to get the bound for */
1589  );
1590 
1591 /** gets variable's upper bound in current dive
1592  *
1593  * @return the variable's upper bound in current dive.
1594  *
1595  * @pre This method can be called if @p scip is in one of the following stages:
1596  * - \ref SCIP_STAGE_SOLVING
1597  *
1598  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1599  */
1602  SCIP* scip, /**< SCIP data structure */
1603  SCIP_VAR* var /**< variable to get the bound for */
1604  );
1605 /** solves the LP of the current dive; no separation or pricing is applied
1606  *
1607  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1608  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1609  *
1610  * @pre This method can be called if @p scip is in one of the following stages:
1611  * - \ref SCIP_STAGE_SOLVING
1612  *
1613  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1614  *
1615  * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL,
1616  * compare the explanation of SCIPstartDive()
1617  */
1620  SCIP* scip, /**< SCIP data structure */
1621  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
1622  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
1623  SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective
1624  * limit was reached (or NULL, if not needed) */
1625  );
1626 
1627 /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving
1628  * or probing mode
1629  *
1630  * @return the number of the node in the current branch and bound run, where the last LP was solved in diving
1631  * or probing mode.
1632  *
1633  * @pre This method can be called if @p scip is in one of the following stages:
1634  * - \ref SCIP_STAGE_TRANSFORMING
1635  * - \ref SCIP_STAGE_TRANSFORMED
1636  * - \ref SCIP_STAGE_INITPRESOLVE
1637  * - \ref SCIP_STAGE_PRESOLVING
1638  * - \ref SCIP_STAGE_EXITPRESOLVE
1639  * - \ref SCIP_STAGE_PRESOLVED
1640  * - \ref SCIP_STAGE_INITSOLVE
1641  * - \ref SCIP_STAGE_SOLVING
1642  * - \ref SCIP_STAGE_SOLVED
1643  * - \ref SCIP_STAGE_EXITSOLVE
1644  * - \ref SCIP_STAGE_FREETRANS
1645  *
1646  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1647  */
1650  SCIP* scip /**< SCIP data structure */
1651  );
1652 
1653 /** returns whether we are in diving mode
1654  *
1655  * @return whether we are in diving mode.
1656  *
1657  * @pre This method can be called if @p scip is in one of the following stages:
1658  * - \ref SCIP_STAGE_TRANSFORMING
1659  * - \ref SCIP_STAGE_TRANSFORMED
1660  * - \ref SCIP_STAGE_INITPRESOLVE
1661  * - \ref SCIP_STAGE_PRESOLVING
1662  * - \ref SCIP_STAGE_EXITPRESOLVE
1663  * - \ref SCIP_STAGE_PRESOLVED
1664  * - \ref SCIP_STAGE_INITSOLVE
1665  * - \ref SCIP_STAGE_SOLVING
1666  * - \ref SCIP_STAGE_SOLVED
1667  * - \ref SCIP_STAGE_EXITSOLVE
1668  * - \ref SCIP_STAGE_FREETRANS
1669  *
1670  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1671  */
1674  SCIP* scip /**< SCIP data structure */
1675  );
1676 
1677 /**@} */
1678 
1679 #ifdef __cplusplus
1680 }
1681 #endif
1682 
1683 #endif
SCIP_EXPORT SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
Definition: scip_lp.c:427
SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1866
SCIP_EXPORT SCIP_RETCODE SCIPcaptureRow(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1384
type definitions for miscellaneous datastructures
SCIP_EXPORT int SCIPgetNLPRows(SCIP *scip)
Definition: scip_lp.c:561
SCIP_EXPORT SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1794
SCIP_EXPORT SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2435
SCIP_EXPORT SCIP_RETCODE SCIPcreateRow(SCIP *scip, SCIP_ROW **row, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1238
SCIP_EXPORT SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
Definition: scip_lp.c:2031
SCIP_EXPORT int SCIPgetNLPCols(SCIP *scip)
Definition: scip_lp.c:483
#define SCIP_EXPORT
Definition: def.h:98
SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1920
SCIP_EXPORT SCIP_RETCODE SCIPcomputeLPRelIntPoint(SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)
Definition: scip_lp.c:1005
SCIP_EXPORT SCIP_Bool SCIPisRootLPRelax(SCIP *scip)
Definition: scip_lp.c:341
SCIP_EXPORT int SCIPgetRowNumIntCols(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1724
SCIP_EXPORT SCIP_Real SCIPgetLPRootColumnObjval(SCIP *scip)
Definition: scip_lp.c:385
SCIP_EXPORT SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
Definition: scip_lp.c:298
SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowUnspec(SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1326
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_EXPORT SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2464
SCIP_EXPORT SCIP_Real SCIPgetLPLooseObjval(SCIP *scip)
Definition: scip_lp.c:273
SCIP_EXPORT SCIP_Bool SCIPisLPConstructed(SCIP *scip)
Definition: scip_lp.c:91
SCIP_EXPORT SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_lp.c:2238
type definitions for return codes for SCIP methods
SCIP_EXPORT SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1502
SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1812
SCIP_EXPORT SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
Definition: scip_lp.c:323
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
SCIP_EXPORT SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_lp.c:2497
SCIP_EXPORT SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip_lp.c:2005
SCIP_EXPORT SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip_lp.c:158
SCIP_EXPORT SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip_lp.c:73
SCIP_EXPORT SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
Definition: scip_lp.c:540
type definitions for LP management
SCIP_EXPORT SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1742
SCIP_EXPORT SCIP_Bool SCIPisLPRelax(SCIP *scip)
Definition: scip_lp.c:215
SCIP_EXPORT SCIP_RETCODE SCIPcalcRowIntegralScalar(SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Real *intscalar, SCIP_Bool *success)
Definition: scip_lp.c:1653
SCIP_EXPORT SCIP_RETCODE SCIPchgCutoffboundDive(SCIP *scip, SCIP_Real newcutoffbound)
Definition: scip_lp.c:2167
SCIP_EXPORT SCIP_RETCODE SCIPaddRowDive(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2302
SCIP_EXPORT SCIP_RETCODE SCIPchgRowRhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)
Definition: scip_lp.c:2374
SCIP_EXPORT SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1479
SCIP_EXPORT SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)
Definition: scip_lp.c:932
SCIP_EXPORT SCIP_Bool SCIPallColsInLP(SCIP *scip)
Definition: scip_lp.c:584
SCIP_EXPORT SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
Definition: scip_lp.c:505
SCIP_EXPORT SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
Definition: scip_lp.c:1406
SCIP_EXPORT SCIP_RETCODE SCIPstartDive(SCIP *scip)
Definition: scip_lp.c:2061
type definitions for SCIP&#39;s main datastructure
SCIP_EXPORT SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
Definition: scip_lp.c:846
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvCol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:684
SCIP_EXPORT SCIP_RETCODE SCIPchgRowLhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)
Definition: scip_lp.c:2341
type definitions for specific LP solvers interface
type definitions for problem variables
SCIP_EXPORT SCIP_RETCODE SCIPsumLPRows(SCIP *scip, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
Definition: scip_lp.c:787
SCIP_EXPORT SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
Definition: scip_lp.c:602
SCIP_EXPORT SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip_lp.c:237
SCIP_EXPORT SCIP_Bool SCIPisLPPrimalReliable(SCIP *scip)
Definition: scip_lp.c:179
SCIP_EXPORT SCIP_Real SCIPgetRowPseudoFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1902
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:720
SCIP_EXPORT SCIP_RETCODE SCIPendDive(SCIP *scip)
Definition: scip_lp.c:2110
SCIP_EXPORT SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)
Definition: scip_lp.c:1611
#define SCIP_Bool
Definition: def.h:70
SCIP_EXPORT SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_lp.c:114
SCIP_EXPORT SCIP_Real SCIPgetRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1885
SCIP_EXPORT SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_lp.c:2270
SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1268
SCIP_EXPORT SCIP_RETCODE SCIPflushLP(SCIP *scip)
Definition: scip_lp.c:138
SCIP_EXPORT SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip_lp.c:896
SCIP_EXPORT void SCIPmarkColNotRemovableLocal(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1113
type definitions for storing primal CIP solutions
SCIP_EXPORT SCIP_Bool SCIPinDive(SCIP *scip)
Definition: scip_lp.c:2594
SCIP_Real * r
Definition: circlepacking.c:50
SCIP_EXPORT SCIP_Real SCIPgetVarObjDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2406
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvACol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:754
SCIP_EXPORT SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
Definition: scip_lp.c:1451
SCIP_EXPORT SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
Definition: scip_lp.c:1427
SCIP_EXPORT SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1831
SCIP_EXPORT SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
Definition: scip_lp.c:812
type definitions for separators
SCIP_EXPORT SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1091
SCIP_EXPORT SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
Definition: scip_lp.c:1539
SCIP_EXPORT SCIP_Longint SCIPgetLastDivenode(SCIP *scip)
Definition: scip_lp.c:2564
SCIP_EXPORT SCIP_Real SCIPgetLPColumnObjval(SCIP *scip)
Definition: scip_lp.c:255
struct SCIP_LPi SCIP_LPI
Definition: type_lpi.h:96
#define SCIP_Real
Definition: def.h:164
SCIP_EXPORT SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1848
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
Definition: scip_lp.c:621
SCIP_EXPORT SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1065
#define SCIP_Longint
Definition: def.h:149
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:649
SCIP_EXPORT SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1962
SCIP_EXPORT SCIP_COL ** SCIPgetLPCols(SCIP *scip)
Definition: scip_lp.c:462
SCIP_EXPORT SCIP_Real SCIPgetLPRootObjval(SCIP *scip)
Definition: scip_lp.c:362
SCIP_EXPORT SCIP_RETCODE SCIPcreateRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1170
SCIP_EXPORT SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1760
SCIP_EXPORT SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip_lp.c:1565
common defines and data types used in all packages of SCIP
SCIP_EXPORT SCIP_Bool SCIPisLPDualReliable(SCIP *scip)
Definition: scip_lp.c:197
SCIP_EXPORT SCIP_RETCODE SCIPcreateRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1136
SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRow(SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1357
SCIP_EXPORT void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1706
SCIP_EXPORT SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_lp.c:2197
SCIP_EXPORT SCIP_Real SCIPgetLPRootLooseObjval(SCIP *scip)
Definition: scip_lp.c:408
SCIP_EXPORT SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1777
SCIP_EXPORT SCIP_RETCODE SCIPmakeRowIntegral(SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)
Definition: scip_lp.c:1682
type definitions for constraints and constraint handlers
SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1297
SCIP_EXPORT SCIP_RETCODE SCIPcreateRowUnspec(SCIP *scip, SCIP_ROW **row, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1204
SCIP_EXPORT SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip_lp.c:1982
SCIP_EXPORT SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1942