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-2021 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file 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 Leona 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 primal feasibility tolerance of LP */
334  SCIP* scip /**< SCIP data structure */
335  );
336 
337 /** sets primal feasibility tolerance of LP */
339 void SCIPsetLPFeastol(
340  SCIP* scip, /**< SCIP data structure */
341  SCIP_Real newfeastol /**< new primal feasibility tolerance for LP */
342  );
343 
344 /** resets primal feasibility tolerance of LP
345  *
346  * Sets primal feasibility tolerance to min of numerics/lpfeastolfactor * numerics/feastol and relaxfeastol.
347  */
349 void SCIPresetLPFeastol(
350  SCIP* scip /**< SCIP data structure */
351  );
352 
353 /** gets current LP columns along with the current number of LP columns
354  *
355  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
356  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
357  *
358  * @pre This method can be called if @p scip is in one of the following stages:
359  * - \ref SCIP_STAGE_SOLVING
360  *
361  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
362  */
365  SCIP* scip, /**< SCIP data structure */
366  SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */
367  int* ncols /**< pointer to store the number of LP columns, or NULL */
368  );
369 
370 /** gets current LP columns
371  *
372  * @return the current LP columns.
373  *
374  * @pre This method can be called if @p scip is in one of the following stages:
375  * - \ref SCIP_STAGE_SOLVING
376  *
377  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
378  */
381  SCIP* scip /**< SCIP data structure */
382  );
383 
384 /** gets current number of LP columns
385  *
386  * @return the current number of LP columns.
387  *
388  * @pre This method can be called if @p scip is in one of the following stages:
389  * - \ref SCIP_STAGE_SOLVING
390  *
391  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
392  */
394 int SCIPgetNLPCols(
395  SCIP* scip /**< SCIP data structure */
396  );
397 
398 /** gets current LP rows along with the current number of LP rows
399  *
400  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
401  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
402  *
403  * @pre This method can be called if @p scip is in one of the following stages:
404  * - \ref SCIP_STAGE_SOLVING
405  *
406  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
407  */
410  SCIP* scip, /**< SCIP data structure */
411  SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */
412  int* nrows /**< pointer to store the number of LP rows, or NULL */
413  );
414 
415 /** gets current LP rows
416  *
417  * @return the current LP rows.
418  *
419  * @pre This method can be called if @p scip is in one of the following stages:
420  * - \ref SCIP_STAGE_SOLVING
421  *
422  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
423  */
426  SCIP* scip /**< SCIP data structure */
427  );
428 
429 /** gets current number of LP rows
430  *
431  * @return the current number of LP rows.
432  *
433  * @pre This method can be called if @p scip is in one of the following stages:
434  * - \ref SCIP_STAGE_SOLVING
435  *
436  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
437  */
439 int SCIPgetNLPRows(
440  SCIP* scip /**< SCIP data structure */
441  );
442 
443 /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
444  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
445  *
446  * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
447  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.
448  *
449  * @pre This method can be called if @p scip is in one of the following stages:
450  * - \ref SCIP_STAGE_SOLVING
451  *
452  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
453  */
456  SCIP* scip /**< SCIP data structure */
457  );
458 
459 /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
460  *
461  * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis.
462  *
463  * @pre This method can be called if @p scip is in one of the following stages:
464  * - \ref SCIP_STAGE_SOLVING
465  *
466  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
467  */
470  SCIP* scip /**< SCIP data structure */
471  );
472 
473 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
474  *
475  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
476  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
477  *
478  * @pre This method can be called if @p scip is in one of the following stages:
479  * - \ref SCIP_STAGE_SOLVING
480  *
481  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
482  */
485  SCIP* scip, /**< SCIP data structure */
486  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
487  );
488 
489 /** gets a row from the inverse basis matrix B^-1
490  *
491  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
492  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
493  *
494  * @pre This method can be called if @p scip is in one of the following stages:
495  * - \ref SCIP_STAGE_SOLVING
496  *
497  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
498  */
501  SCIP* scip, /**< SCIP data structure */
502  int r, /**< row number */
503  SCIP_Real* coefs, /**< array to store the coefficients of the row */
504  int* inds, /**< array to store the non-zero indices, or NULL */
505  int* ninds /**< pointer to store the number of non-zero indices, or NULL
506  * (-1: if we do not store sparsity informations) */
507  );
508 
509 /** gets a column from the inverse basis matrix B^-1
510  *
511  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
512  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
513  *
514  * @pre This method can be called if @p scip is in one of the following stages:
515  * - \ref SCIP_STAGE_SOLVING
516  *
517  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
518  */
521  SCIP* scip, /**< SCIP data structure */
522  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
523  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
524  * to get the array which links the B^-1 column numbers to the row and
525  * column numbers of the LP! c must be between 0 and nrows-1, since the
526  * basis has the size nrows * nrows */
527  SCIP_Real* coefs, /**< array to store the coefficients of the column */
528  int* inds, /**< array to store the non-zero indices, or NULL */
529  int* ninds /**< pointer to store the number of non-zero indices, or NULL
530  * (-1: if we do not store sparsity informations) */
531  );
532 
533 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * 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 r, /**< row number */
547  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */
548  SCIP_Real* coefs, /**< array to store the coefficients of the row */
549  int* inds, /**< array to store the non-zero indices, or NULL */
550  int* ninds /**< pointer to store the number of non-zero indices, or NULL
551  * (-1: if we do not store sparsity informations) */
552  );
553 
554 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
555  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
556  *
557  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
558  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
559  *
560  * @pre This method can be called if @p scip is in one of the following stages:
561  * - \ref SCIP_STAGE_SOLVING
562  *
563  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
564  */
567  SCIP* scip, /**< SCIP data structure */
568  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
569  SCIP_Real* coefs, /**< array to store the coefficients of the column */
570  int* inds, /**< array to store the non-zero indices, or NULL */
571  int* ninds /**< pointer to store the number of non-zero indices, or NULL
572  * (-1: if we do not store sparsity informations) */
573  );
574 
575 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
576  * LP row are swapped in the summation
577  *
578  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
579  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
580  *
581  * @pre This method can be called if @p scip is in one of the following stages:
582  * - \ref SCIP_STAGE_SOLVING
583  *
584  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
585  */
588  SCIP* scip, /**< SCIP data structure */
589  SCIP_Real* weights, /**< row weights in row summation */
590  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
591  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
592  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
593  );
594 
595 /** writes current LP to a file
596  *
597  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
598  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
599  *
600  * @pre This method can be called if @p scip is in one of the following stages:
601  * - \ref SCIP_STAGE_SOLVING
602  *
603  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
604  */
607  SCIP* scip, /**< SCIP data structure */
608  const char* filename /**< file name */
609  );
610 
611 /** writes MIP relaxation of the current branch-and-bound node to a file
612  *
613  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
614  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
615  *
616  * @pre This method can be called if @p scip is in one of the following stages:
617  * - \ref SCIP_STAGE_SOLVING
618  *
619  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
620  */
623  SCIP* scip, /**< SCIP data structure */
624  const char* filename, /**< file name */
625  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
626  * troubles with reserved symbols? */
627  SCIP_Bool origobj, /**< should the original objective function be used? */
628  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
629  );
630 
631 /** gets the LP interface of SCIP;
632  * with the LPI you can use all of the methods defined in lpi/lpi.h;
633  *
634  * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely
635  * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution
636  * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in
637  * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make
638  * sure, the internal solution status is recovered completely at the end of your method. This can be achieved
639  * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it
640  * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the
641  * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.
642  *
643  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
644  *
645  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
646  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
647  *
648  * @pre This method can be called if @p scip is in one of the following stages:
649  * - \ref SCIP_STAGE_TRANSFORMED
650  * - \ref SCIP_STAGE_INITPRESOLVE
651  * - \ref SCIP_STAGE_PRESOLVING
652  * - \ref SCIP_STAGE_EXITPRESOLVE
653  * - \ref SCIP_STAGE_PRESOLVED
654  * - \ref SCIP_STAGE_INITSOLVE
655  * - \ref SCIP_STAGE_SOLVING
656  * - \ref SCIP_STAGE_SOLVED
657  * - \ref SCIP_STAGE_EXITSOLVE
658  *
659  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
660  */
663  SCIP* scip, /**< SCIP data structure */
664  SCIP_LPI** lpi /**< pointer to store the LP interface */
665  );
666 
667 /** Displays quality information about the current LP solution. An LP solution need to be available. Information printed
668  * is subject to what the LP solver supports
669  *
670  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
671  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
672  *
673  * @pre This method can be called if @p scip is in one of the following stages:
674  * - \ref SCIP_STAGE_INIT
675  * - \ref SCIP_STAGE_PROBLEM
676  * - \ref SCIP_STAGE_TRANSFORMED
677  * - \ref SCIP_STAGE_INITPRESOLVE
678  * - \ref SCIP_STAGE_PRESOLVING
679  * - \ref SCIP_STAGE_EXITPRESOLVE
680  * - \ref SCIP_STAGE_PRESOLVED
681  * - \ref SCIP_STAGE_SOLVING
682  * - \ref SCIP_STAGE_SOLVED
683  * - \ref SCIP_STAGE_FREE
684  *
685  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
686  *
687  * @note The printing process is done via the message handler system.
688  */
691  SCIP* scip, /**< SCIP data structure */
692  FILE* file /**< output file (or NULL for standard output) */
693  );
694 
695 /** compute relative interior point to current LP
696  * @see SCIPlpComputeRelIntPoint
697  *
698  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
699  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
700  *
701  * @pre This method can be called if @p scip is in one of the following stages:
702  * - \ref SCIP_STAGE_TRANSFORMED
703  * - \ref SCIP_STAGE_INITPRESOLVE
704  * - \ref SCIP_STAGE_PRESOLVING
705  * - \ref SCIP_STAGE_EXITPRESOLVE
706  * - \ref SCIP_STAGE_PRESOLVED
707  * - \ref SCIP_STAGE_SOLVING
708  * - \ref SCIP_STAGE_SOLVED
709  *
710  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
711  */
714  SCIP* scip, /**< SCIP data structure */
715  SCIP_Bool relaxrows, /**< should the rows be relaxed */
716  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
717  SCIP_Real timelimit, /**< time limit for LP solver */
718  int iterlimit, /**< iteration limit for LP solver */
719  SCIP_SOL** point /**< relative interior point on exit */
720  );
721 
722 /**@} */
723 
724 /**@addtogroup PublicColumnMethods
725  *
726  * @{
727  */
728 
729 /** returns the reduced costs of a column in the last (feasible) LP
730  *
731  * @return the reduced costs of a column in the last (feasible) LP
732  *
733  * @pre this method can be called in one of the following stages of the SCIP solving process:
734  * - \ref SCIP_STAGE_SOLVING
735  * - \ref SCIP_STAGE_SOLVED
736  *
737  * @note calling this method in SCIP_STAGE_SOLVED is only recommended to experienced users and should only be called
738  * for pure LP instances (without presolving)
739  *
740  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
741  */
744  SCIP* scip, /**< SCIP data structure */
745  SCIP_COL* col /**< LP column */
746  );
747 
748 /** returns the Farkas coefficient of a column in the last (infeasible) LP
749  *
750  * @return the Farkas coefficient of a column in the last (infeasible) LP
751  *
752  * @pre this method can be called in one of the following stages of the SCIP solving process:
753  * - \ref SCIP_STAGE_SOLVING
754  */
757  SCIP* scip, /**< SCIP data structure */
758  SCIP_COL* col /**< LP column */
759  );
760 
761 /** marks a column to be not removable from the LP in the current node
762  *
763  * @pre this method can be called in the following stage of the SCIP solving process:
764  * - \ref SCIP_STAGE_SOLVING
765  */
768  SCIP* scip, /**< SCIP data structure */
769  SCIP_COL* col /**< LP column */
770  );
771 
772 /**@} */
773 
774 /**@addtogroup PublicRowMethods
775  *
776  * @{
777  */
778 
779 /** creates and captures an LP row from a constraint handler
780  *
781  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
782  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
783  *
784  * @pre this method can be called in one of the following stages of the SCIP solving process:
785  * - \ref SCIP_STAGE_INITSOLVE
786  * - \ref SCIP_STAGE_SOLVING
787  */
790  SCIP* scip, /**< SCIP data structure */
791  SCIP_ROW** row, /**< pointer to row */
792  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
793  const char* name, /**< name of row */
794  int len, /**< number of nonzeros in the row */
795  SCIP_COL** cols, /**< array with columns of row entries */
796  SCIP_Real* vals, /**< array with coefficients of row entries */
797  SCIP_Real lhs, /**< left hand side of row */
798  SCIP_Real rhs, /**< right hand side of row */
799  SCIP_Bool local, /**< is row only valid locally? */
800  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
801  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
802  );
803 
804 /** creates and captures an LP row from a constraint
805  *
806  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
807  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
808  *
809  * @pre this method can be called in one of the following stages of the SCIP solving process:
810  * - \ref SCIP_STAGE_INITSOLVE
811  * - \ref SCIP_STAGE_SOLVING
812  */
815  SCIP* scip, /**< SCIP data structure */
816  SCIP_ROW** row, /**< pointer to row */
817  SCIP_CONS* cons, /**< constraint that creates the row */
818  const char* name, /**< name of row */
819  int len, /**< number of nonzeros in the row */
820  SCIP_COL** cols, /**< array with columns of row entries */
821  SCIP_Real* vals, /**< array with coefficients of row entries */
822  SCIP_Real lhs, /**< left hand side of row */
823  SCIP_Real rhs, /**< right hand side of row */
824  SCIP_Bool local, /**< is row only valid locally? */
825  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
826  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
827  );
828 
829 /** creates and captures an LP row from a separator
830  *
831  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
832  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
833  *
834  * @pre this method can be called in one of the following stages of the SCIP solving process:
835  * - \ref SCIP_STAGE_INITSOLVE
836  * - \ref SCIP_STAGE_SOLVING
837  */
840  SCIP* scip, /**< SCIP data structure */
841  SCIP_ROW** row, /**< pointer to row */
842  SCIP_SEPA* sepa, /**< separator that creates the row */
843  const char* name, /**< name of row */
844  int len, /**< number of nonzeros in the row */
845  SCIP_COL** cols, /**< array with columns of row entries */
846  SCIP_Real* vals, /**< array with coefficients of row entries */
847  SCIP_Real lhs, /**< left hand side of row */
848  SCIP_Real rhs, /**< right hand side of row */
849  SCIP_Bool local, /**< is row only valid locally? */
850  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
851  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
852  );
853 
854 /** creates and captures an LP row from an unspecified source
855  *
856  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
857  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
858  *
859  * @pre this method can be called in one of the following stages of the SCIP solving process:
860  * - \ref SCIP_STAGE_INITSOLVE
861  * - \ref SCIP_STAGE_SOLVING
862  */
865  SCIP* scip, /**< SCIP data structure */
866  SCIP_ROW** row, /**< pointer to row */
867  const char* name, /**< name of row */
868  int len, /**< number of nonzeros in the row */
869  SCIP_COL** cols, /**< array with columns of row entries */
870  SCIP_Real* vals, /**< array with coefficients of row entries */
871  SCIP_Real lhs, /**< left hand side of row */
872  SCIP_Real rhs, /**< right hand side of row */
873  SCIP_Bool local, /**< is row only valid locally? */
874  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
875  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
876  );
877 
878 /** creates and captures an LP row
879  *
880  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
881  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
882  *
883  * @pre this method can be called in one of the following stages of the SCIP solving process:
884  * - \ref SCIP_STAGE_INITSOLVE
885  * - \ref SCIP_STAGE_SOLVING
886  *
887  * @deprecated Please use SCIPcreateRowConshdlr() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order
888  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().
889  */
892  SCIP* scip, /**< SCIP data structure */
893  SCIP_ROW** row, /**< pointer to row */
894  const char* name, /**< name of row */
895  int len, /**< number of nonzeros in the row */
896  SCIP_COL** cols, /**< array with columns of row entries */
897  SCIP_Real* vals, /**< array with coefficients of row entries */
898  SCIP_Real lhs, /**< left hand side of row */
899  SCIP_Real rhs, /**< right hand side of row */
900  SCIP_Bool local, /**< is row only valid locally? */
901  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
902  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
903  );
904 
905 /** creates and captures an LP row without any coefficients from a constraint handler
906  *
907  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
908  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
909  *
910  * @pre this method can be called in one of the following stages of the SCIP solving process:
911  * - \ref SCIP_STAGE_INITSOLVE
912  * - \ref SCIP_STAGE_SOLVING
913  */
916  SCIP* scip, /**< SCIP data structure */
917  SCIP_ROW** row, /**< pointer to row */
918  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
919  const char* name, /**< name of row */
920  SCIP_Real lhs, /**< left hand side of row */
921  SCIP_Real rhs, /**< right hand side of row */
922  SCIP_Bool local, /**< is row only valid locally? */
923  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
924  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
925  );
926 
927 /** creates and captures an LP row without any coefficients from a constraint
928  *
929  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
930  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
931  *
932  * @pre this method can be called in one of the following stages of the SCIP solving process:
933  * - \ref SCIP_STAGE_INITSOLVE
934  * - \ref SCIP_STAGE_SOLVING
935  */
938  SCIP* scip, /**< SCIP data structure */
939  SCIP_ROW** row, /**< pointer to row */
940  SCIP_CONS* cons, /**< constraint that creates the row */
941  const char* name, /**< name of row */
942  SCIP_Real lhs, /**< left hand side of row */
943  SCIP_Real rhs, /**< right hand side of row */
944  SCIP_Bool local, /**< is row only valid locally? */
945  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
946  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
947  );
948 
949 /** creates and captures an LP row without any coefficients from a separator
950  *
951  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
952  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
953  *
954  * @pre this method can be called in one of the following stages of the SCIP solving process:
955  * - \ref SCIP_STAGE_INITSOLVE
956  * - \ref SCIP_STAGE_SOLVING
957  */
960  SCIP* scip, /**< SCIP data structure */
961  SCIP_ROW** row, /**< pointer to row */
962  SCIP_SEPA* sepa, /**< separator that creates the row */
963  const char* name, /**< name of row */
964  SCIP_Real lhs, /**< left hand side of row */
965  SCIP_Real rhs, /**< right hand side of row */
966  SCIP_Bool local, /**< is row only valid locally? */
967  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
968  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
969  );
970 
971 /** creates and captures an LP row without any coefficients from an unspecified source
972  *
973  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
974  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
975  *
976  * @pre this method can be called in one of the following stages of the SCIP solving process:
977  * - \ref SCIP_STAGE_INITSOLVE
978  * - \ref SCIP_STAGE_SOLVING
979  */
982  SCIP* scip, /**< SCIP data structure */
983  SCIP_ROW** row, /**< pointer to row */
984  const char* name, /**< name of row */
985  SCIP_Real lhs, /**< left hand side of row */
986  SCIP_Real rhs, /**< right hand side of row */
987  SCIP_Bool local, /**< is row only valid locally? */
988  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
989  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
990  );
991 
992 /** creates and captures an LP row without any coefficients
993  *
994  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
995  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
996  *
997  * @pre this method can be called in one of the following stages of the SCIP solving process:
998  * - \ref SCIP_STAGE_INITSOLVE
999  * - \ref SCIP_STAGE_SOLVING
1000  *
1001  * @deprecated Please use SCIPcreateEmptyRowConshdlr() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order
1002  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().
1003  */
1006  SCIP* scip, /**< SCIP data structure */
1007  SCIP_ROW** row, /**< pointer to row */
1008  const char* name, /**< name of row */
1009  SCIP_Real lhs, /**< left hand side of row */
1010  SCIP_Real rhs, /**< right hand side of row */
1011  SCIP_Bool local, /**< is row only valid locally? */
1012  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1013  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1014  );
1015 
1016 /** increases usage counter of LP row
1017  *
1018  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1019  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1020  *
1021  * @pre this method can be called in one of the following stages of the SCIP solving process:
1022  * - \ref SCIP_STAGE_INITSOLVE
1023  * - \ref SCIP_STAGE_SOLVING
1024  */
1027  SCIP* scip, /**< SCIP data structure */
1028  SCIP_ROW* row /**< row to capture */
1029  );
1030 
1031 /** decreases usage counter of LP row, and frees memory if necessary
1032  *
1033  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1034  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1035  *
1036  * @pre this method can be called in one of the following stages of the SCIP solving process:
1037  * - \ref SCIP_STAGE_INITSOLVE
1038  * - \ref SCIP_STAGE_SOLVING
1039  * - \ref SCIP_STAGE_EXITSOLVE
1040  */
1043  SCIP* scip, /**< SCIP data structure */
1044  SCIP_ROW** row /**< pointer to LP row */
1045  );
1046 
1047 /** changes left hand side of LP row
1048  *
1049  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1050  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
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  */
1058  SCIP* scip, /**< SCIP data structure */
1059  SCIP_ROW* row, /**< LP row */
1060  SCIP_Real lhs /**< new left hand side */
1061  );
1062 
1063 /** changes right hand side of LP row
1064  *
1065  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1066  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1067  *
1068  * @pre this method can be called in one of the following stages of the SCIP solving process:
1069  * - \ref SCIP_STAGE_INITSOLVE
1070  * - \ref SCIP_STAGE_SOLVING
1071  */
1074  SCIP* scip, /**< SCIP data structure */
1075  SCIP_ROW* row, /**< LP row */
1076  SCIP_Real rhs /**< new right hand side */
1077  );
1078 
1079 /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
1080  * after all additions were applied, SCIPflushRowExtensions() must be called;
1081  * while the caching of row extensions is activated, information methods of the row give invalid results;
1082  * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase
1083  * the performance
1084  *
1085  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1086  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1087  *
1088  * @pre this method can be called in one of the following stages of the SCIP solving process:
1089  * - \ref SCIP_STAGE_INITSOLVE
1090  * - \ref SCIP_STAGE_SOLVING
1091  */
1094  SCIP* scip, /**< SCIP data structure */
1095  SCIP_ROW* row /**< LP row */
1096  );
1097 
1098 /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with
1099  * equal columns into a single coefficient
1100  *
1101  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1102  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1103  *
1104  * @pre this method can be called in one of the following stages of the SCIP solving process:
1105  * - \ref SCIP_STAGE_INITSOLVE
1106  * - \ref SCIP_STAGE_SOLVING
1107  */
1110  SCIP* scip, /**< SCIP data structure */
1111  SCIP_ROW* row /**< LP row */
1112  );
1113 
1114 /** resolves variable to columns and adds them with the coefficient to the row
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  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variable will not added.
1120  *
1121  * @pre this method can be called in one of the following stages of the SCIP solving process:
1122  * - \ref SCIP_STAGE_INITSOLVE
1123  * - \ref SCIP_STAGE_SOLVING
1124  *
1125  * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables,
1126  * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP.
1127  * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution
1128  * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but
1129  * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the
1130  * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was
1131  * violated, the linear relaxation might not be violated anymore.)
1132  */
1135  SCIP* scip, /**< SCIP data structure */
1136  SCIP_ROW* row, /**< LP row */
1137  SCIP_VAR* var, /**< problem variable */
1138  SCIP_Real val /**< value of coefficient */
1139  );
1140 
1141 /** resolves variables to columns and adds them with the coefficients to the row;
1142  * this method caches the row extensions and flushes them afterwards to gain better performance
1143  *
1144  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1145  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1146  *
1147  * @attention If a coefficients absolute value is below the SCIP epsilon tolerance, the variable with its value is not added.
1148  *
1149  * @pre this method can be called in one of the following stages of the SCIP solving process:
1150  * - \ref SCIP_STAGE_INITSOLVE
1151  * - \ref SCIP_STAGE_SOLVING
1152  */
1155  SCIP* scip, /**< SCIP data structure */
1156  SCIP_ROW* row, /**< LP row */
1157  int nvars, /**< number of variables to add to the row */
1158  SCIP_VAR** vars, /**< problem variables to add */
1159  SCIP_Real* vals /**< values of coefficients */
1160  );
1161 
1162 /** resolves variables to columns and adds them with the same single coefficient to the row;
1163  * this method caches the row extensions and flushes them afterwards to gain better performance
1164  *
1165  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1166  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1167  *
1168  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variables will not added.
1169  *
1170  * @pre this method can be called in one of the following stages of the SCIP solving process:
1171  * - \ref SCIP_STAGE_INITSOLVE
1172  * - \ref SCIP_STAGE_SOLVING
1173  */
1176  SCIP* scip, /**< SCIP data structure */
1177  SCIP_ROW* row, /**< LP row */
1178  int nvars, /**< number of variables to add to the row */
1179  SCIP_VAR** vars, /**< problem variables to add */
1180  SCIP_Real val /**< unique value of all coefficients */
1181  );
1182 
1183 /** tries to find a value, such that all row coefficients, if scaled with this value become integral
1184  *
1185  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1186  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1187  *
1188  * @pre this method can be called in one of the following stages of the SCIP solving process:
1189  * - \ref SCIP_STAGE_INITSOLVE
1190  * - \ref SCIP_STAGE_SOLVING
1191  */
1194  SCIP* scip, /**< SCIP data structure */
1195  SCIP_ROW* row, /**< LP row */
1196  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
1197  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
1198  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
1199  SCIP_Real maxscale, /**< maximal allowed scalar */
1200  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
1201  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
1202  SCIP_Bool* success /**< stores whether returned value is valid */
1203  );
1204 
1205 /** tries to scale row, s.t. all coefficients (of integer variables) become integral
1206  *
1207  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1208  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1209  *
1210  * @pre this method can be called in one of the following stages of the SCIP solving process:
1211  * - \ref SCIP_STAGE_INITSOLVE
1212  * - \ref SCIP_STAGE_SOLVING
1213  */
1216  SCIP* scip, /**< SCIP data structure */
1217  SCIP_ROW* row, /**< LP row */
1218  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
1219  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
1220  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
1221  SCIP_Real maxscale, /**< maximal value to scale row with */
1222  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
1223  SCIP_Bool* success /**< stores whether row could be made rational */
1224  );
1225 
1226 /** marks a row to be not removable from the LP in the current node
1227  *
1228  * @pre this method can be called in the following stage of the SCIP solving process:
1229  * - \ref SCIP_STAGE_SOLVING
1230  */
1233  SCIP* scip, /**< SCIP data structure */
1234  SCIP_ROW* row /**< LP row */
1235  );
1236 
1237 /** returns number of integral columns in the row
1238  *
1239  * @return number of integral columns in the row
1240  *
1241  * @pre this method can be called in one of the following stages of the SCIP solving process:
1242  * - \ref SCIP_STAGE_INITSOLVE
1243  * - \ref SCIP_STAGE_SOLVING
1244  */
1247  SCIP* scip, /**< SCIP data structure */
1248  SCIP_ROW* row /**< LP row */
1249  );
1250 
1251 /** returns minimal absolute value of row vector's non-zero coefficients
1252  *
1253  * @return minimal absolute value of row vector's non-zero coefficients
1254  *
1255  * @pre this method can be called in one of the following stages of the SCIP solving process:
1256  * - \ref SCIP_STAGE_INITSOLVE
1257  * - \ref SCIP_STAGE_SOLVING
1258  */
1261  SCIP* scip, /**< SCIP data structure */
1262  SCIP_ROW* row /**< LP row */
1263  );
1264 
1265 /** returns maximal absolute value of row vector's non-zero coefficients
1266  *
1267  * @return maximal absolute value of row vector's non-zero coefficients
1268  *
1269  * @pre this method can be called in one of the following stages of the SCIP solving process:
1270  * - \ref SCIP_STAGE_INITSOLVE
1271  * - \ref SCIP_STAGE_SOLVING
1272  */
1275  SCIP* scip, /**< SCIP data structure */
1276  SCIP_ROW* row /**< LP row */
1277  );
1278 
1279 /** returns the minimal activity of a row w.r.t. the column's bounds
1280  *
1281  * @return the minimal activity of a row w.r.t. the column's bounds
1282  *
1283  * @pre this method can be called in one of the following stages of the SCIP solving process:
1284  * - \ref SCIP_STAGE_SOLVING
1285  */
1288  SCIP* scip, /**< SCIP data structure */
1289  SCIP_ROW* row /**< LP row */
1290  );
1291 
1292 /** returns the maximal activity of a row w.r.t. the column's bounds
1293  *
1294  * @return the maximal activity of a row w.r.t. the column's bounds
1295  *
1296  * @pre this method can be called in one of the following stages of the SCIP solving process:
1297  * - \ref SCIP_STAGE_SOLVING
1298  */
1301  SCIP* scip, /**< SCIP data structure */
1302  SCIP_ROW* row /**< LP row */
1303  );
1304 
1305 /** recalculates the activity of a row in the last LP solution
1306  *
1307  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1308  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1309  *
1310  * @pre this method can be called in one of the following stages of the SCIP solving process:
1311  * - \ref SCIP_STAGE_SOLVING
1312  */
1315  SCIP* scip, /**< SCIP data structure */
1316  SCIP_ROW* row /**< LP row */
1317  );
1318 
1319 /** returns the activity of a row in the last LP solution
1320  *
1321  * @return activity of a row in the last LP solution
1322  *
1323  * @pre this method can be called in one of the following stages of the SCIP solving process:
1324  * - \ref SCIP_STAGE_SOLVING
1325  */
1328  SCIP* scip, /**< SCIP data structure */
1329  SCIP_ROW* row /**< LP row */
1330  );
1331 
1332 /** returns the feasibility of a row in the last LP solution
1333  *
1334  * @return the feasibility of a row in the last LP solution: negative value means infeasibility
1335  *
1336  * @pre this method can be called in one of the following stages of the SCIP solving process:
1337  * - \ref SCIP_STAGE_SOLVING
1338  */
1341  SCIP* scip, /**< SCIP data structure */
1342  SCIP_ROW* row /**< LP row */
1343  );
1344 
1345 /** recalculates the activity of a row for the current pseudo solution
1346  *
1347  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1348  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1349  *
1350  * @pre this method can be called in one of the following stages of the SCIP solving process:
1351  * - \ref SCIP_STAGE_SOLVING
1352  */
1355  SCIP* scip, /**< SCIP data structure */
1356  SCIP_ROW* row /**< LP row */
1357  );
1358 
1359 /** returns the activity of a row for the current pseudo solution
1360  *
1361  * @return the activity of a row for the current pseudo solution
1362  *
1363  * @pre this method can be called in one of the following stages of the SCIP solving process:
1364  * - \ref SCIP_STAGE_SOLVING
1365  */
1368  SCIP* scip, /**< SCIP data structure */
1369  SCIP_ROW* row /**< LP row */
1370  );
1371 
1372 /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
1373  *
1374  * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility
1375  *
1376  * @pre this method can be called in one of the following stages of the SCIP solving process:
1377  * - \ref SCIP_STAGE_SOLVING
1378  */
1381  SCIP* scip, /**< SCIP data structure */
1382  SCIP_ROW* row /**< LP row */
1383  );
1384 
1385 /** recalculates the activity of a row in the last LP or pseudo solution
1386  *
1387  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1388  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1389  *
1390  * @pre this method can be called in one of the following stages of the SCIP solving process:
1391  * - \ref SCIP_STAGE_SOLVING
1392  */
1395  SCIP* scip, /**< SCIP data structure */
1396  SCIP_ROW* row /**< LP row */
1397  );
1398 
1399 /** returns the activity of a row in the last LP or pseudo solution
1400  *
1401  * @return the activity of a row in the last LP or pseudo solution
1402  *
1403  * @pre this method can be called in one of the following stages of the SCIP solving process:
1404  * - \ref SCIP_STAGE_SOLVING
1405  */
1408  SCIP* scip, /**< SCIP data structure */
1409  SCIP_ROW* row /**< LP row */
1410  );
1411 
1412 /** returns the feasibility of a row in the last LP or pseudo solution
1413  *
1414  * @return the feasibility of a row in the last LP or pseudo solution
1415  *
1416  * @pre this method can be called in one of the following stages of the SCIP solving process:
1417  * - \ref SCIP_STAGE_SOLVING
1418  */
1421  SCIP* scip, /**< SCIP data structure */
1422  SCIP_ROW* row /**< LP row */
1423  );
1424 
1425 /** returns the activity of a row for the given primal solution
1426  *
1427  * @return the activitiy of a row for the given primal solution
1428  *
1429  * @pre this method can be called in one of the following stages of the SCIP solving process:
1430  * - \ref SCIP_STAGE_SOLVING
1431  */
1434  SCIP* scip, /**< SCIP data structure */
1435  SCIP_ROW* row, /**< LP row */
1436  SCIP_SOL* sol /**< primal CIP solution */
1437  );
1438 
1439 /** returns the feasibility of a row for the given primal solution
1440  *
1441  * @return the feasibility of a row for the given primal solution
1442  *
1443  * @pre this method can be called in one of the following stages of the SCIP solving process:
1444  * - \ref SCIP_STAGE_SOLVING
1445  */
1448  SCIP* scip, /**< SCIP data structure */
1449  SCIP_ROW* row, /**< LP row */
1450  SCIP_SOL* sol /**< primal CIP solution */
1451  );
1452 
1453 /** returns the parallelism of row with objective function
1454  *
1455  * @return 1 is returned if the row is parallel to the objective function and 0 if it is orthogonal
1456  *
1457  * @pre this method can be called in one of the following stages of the SCIP solving process:
1458  * - \ref SCIP_STAGE_SOLVING
1459  */
1462  SCIP* scip, /**< SCIP data structure */
1463  SCIP_ROW* row /**< LP row */
1464  );
1465 
1466 /** output row to file stream via the message handler system
1467  *
1468  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1469  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1470  *
1471  * @pre this method can be called in one of the following stages of the SCIP solving process:
1472  * - \ref SCIP_STAGE_INITSOLVE
1473  * - \ref SCIP_STAGE_SOLVING
1474  * - \ref SCIP_STAGE_SOLVED
1475  * - \ref SCIP_STAGE_EXITSOLVE
1476  */
1479  SCIP* scip, /**< SCIP data structure */
1480  SCIP_ROW* row, /**< LP row */
1481  FILE* file /**< output file (or NULL for standard output) */
1482  );
1483 
1484 /**@} */
1485 
1486 /**@addtogroup PublicLPDivingMethods
1487  *
1488  * @{
1489  */
1490 
1491 /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
1492  *
1493  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1494  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1495  *
1496  * @pre This method can be called if @p scip is in one of the following stages:
1497  * - \ref SCIP_STAGE_SOLVING
1498  *
1499  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1500  *
1501  * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware
1502  * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from
1503  * numerical troubles during the last LP solve; because of this, most users will want to call this method only if
1504  * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL
1505  */
1508  SCIP* scip /**< SCIP data structure */
1509  );
1510 
1511 /** quits LP diving and resets bounds and objective values of columns to the current node's values
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  );
1525 
1526 /** changes cutoffbound in current dive
1527  *
1528  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1529  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1530  *
1531  * @pre This method can be called if @p scip is in one of the following stages:
1532  * - \ref SCIP_STAGE_SOLVING
1533  *
1534  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1535  */
1538  SCIP* scip, /**< SCIP data structure */
1539  SCIP_Real newcutoffbound /**< new cutoffbound */
1540  );
1541 
1542 /** changes variable's objective value in current dive
1543  *
1544  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1545  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1546  *
1547  * @pre This method can be called if @p scip is in one of the following stages:
1548  * - \ref SCIP_STAGE_SOLVING
1549  *
1550  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1551  */
1554  SCIP* scip, /**< SCIP data structure */
1555  SCIP_VAR* var, /**< variable to change the objective value for */
1556  SCIP_Real newobj /**< new objective value */
1557  );
1558 
1559 /** changes variable's lower bound in current dive
1560  *
1561  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1562  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1563  *
1564  * @pre This method can be called if @p scip is in one of the following stages:
1565  * - \ref SCIP_STAGE_SOLVING
1566  *
1567  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1568  */
1571  SCIP* scip, /**< SCIP data structure */
1572  SCIP_VAR* var, /**< variable to change the bound for */
1573  SCIP_Real newbound /**< new value for bound */
1574  );
1575 
1576 /** changes variable's upper bound in current dive
1577  *
1578  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1579  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1580  *
1581  * @pre This method can be called if @p scip is in one of the following stages:
1582  * - \ref SCIP_STAGE_SOLVING
1583  *
1584  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1585  */
1588  SCIP* scip, /**< SCIP data structure */
1589  SCIP_VAR* var, /**< variable to change the bound for */
1590  SCIP_Real newbound /**< new value for bound */
1591  );
1592 
1593 /** adds a row to the LP in current dive
1594  *
1595  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1596  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1597  *
1598  * @pre This method can be called if @p scip is in one of the following stages:
1599  * - \ref SCIP_STAGE_SOLVING
1600  *
1601  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1602  */
1605  SCIP* scip, /**< SCIP data structure */
1606  SCIP_ROW* row /**< row to be added */
1607  );
1608 
1609 /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
1610  *
1611  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1612  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1613  *
1614  * @pre This method can be called if @p scip is in one of the following stages:
1615  * - \ref SCIP_STAGE_SOLVING
1616  *
1617  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1618  */
1621  SCIP* scip, /**< SCIP data structure */
1622  SCIP_ROW* row, /**< row to change the lhs for */
1623  SCIP_Real newlhs /**< new value for lhs */
1624  );
1625 
1626 /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
1627  *
1628  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1629  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1630  *
1631  * @pre This method can be called if @p scip is in one of the following stages:
1632  * - \ref SCIP_STAGE_SOLVING
1633  *
1634  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1635  */
1638  SCIP* scip, /**< SCIP data structure */
1639  SCIP_ROW* row, /**< row to change the lhs for */
1640  SCIP_Real newrhs /**< new value for rhs */
1641  );
1642 
1643 /** gets variable's objective value in current dive
1644  *
1645  * @return the variable's objective value in current dive.
1646  *
1647  * @pre This method can be called if @p scip is in one of the following stages:
1648  * - \ref SCIP_STAGE_SOLVING
1649  *
1650  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1651  */
1654  SCIP* scip, /**< SCIP data structure */
1655  SCIP_VAR* var /**< variable to get the bound for */
1656  );
1657 
1658 /** gets variable's lower bound in current dive
1659  *
1660  * @return the variable's lower bound in current dive.
1661  *
1662  * @pre This method can be called if @p scip is in one of the following stages:
1663  * - \ref SCIP_STAGE_SOLVING
1664  *
1665  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1666  */
1669  SCIP* scip, /**< SCIP data structure */
1670  SCIP_VAR* var /**< variable to get the bound for */
1671  );
1672 
1673 /** gets variable's upper bound in current dive
1674  *
1675  * @return the variable's upper bound in current dive.
1676  *
1677  * @pre This method can be called if @p scip is in one of the following stages:
1678  * - \ref SCIP_STAGE_SOLVING
1679  *
1680  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1681  */
1684  SCIP* scip, /**< SCIP data structure */
1685  SCIP_VAR* var /**< variable to get the bound for */
1686  );
1687 /** solves the LP of the current dive; no separation or pricing is applied
1688  *
1689  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1690  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1691  *
1692  * @pre This method can be called if @p scip is in one of the following stages:
1693  * - \ref SCIP_STAGE_SOLVING
1694  *
1695  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1696  *
1697  * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL,
1698  * compare the explanation of SCIPstartDive()
1699  */
1702  SCIP* scip, /**< SCIP data structure */
1703  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
1704  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
1705  SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective
1706  * limit was reached (or NULL, if not needed) */
1707  );
1708 
1709 /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving
1710  * or probing mode
1711  *
1712  * @return the number of the node in the current branch and bound run, where the last LP was solved in diving
1713  * or probing mode.
1714  *
1715  * @pre This method can be called if @p scip is in one of the following stages:
1716  * - \ref SCIP_STAGE_TRANSFORMING
1717  * - \ref SCIP_STAGE_TRANSFORMED
1718  * - \ref SCIP_STAGE_INITPRESOLVE
1719  * - \ref SCIP_STAGE_PRESOLVING
1720  * - \ref SCIP_STAGE_EXITPRESOLVE
1721  * - \ref SCIP_STAGE_PRESOLVED
1722  * - \ref SCIP_STAGE_INITSOLVE
1723  * - \ref SCIP_STAGE_SOLVING
1724  * - \ref SCIP_STAGE_SOLVED
1725  * - \ref SCIP_STAGE_EXITSOLVE
1726  * - \ref SCIP_STAGE_FREETRANS
1727  *
1728  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1729  */
1732  SCIP* scip /**< SCIP data structure */
1733  );
1734 
1735 /** returns whether we are in diving mode
1736  *
1737  * @return whether we are in diving mode.
1738  *
1739  * @pre This method can be called if @p scip is in one of the following stages:
1740  * - \ref SCIP_STAGE_TRANSFORMING
1741  * - \ref SCIP_STAGE_TRANSFORMED
1742  * - \ref SCIP_STAGE_INITPRESOLVE
1743  * - \ref SCIP_STAGE_PRESOLVING
1744  * - \ref SCIP_STAGE_EXITPRESOLVE
1745  * - \ref SCIP_STAGE_PRESOLVED
1746  * - \ref SCIP_STAGE_INITSOLVE
1747  * - \ref SCIP_STAGE_SOLVING
1748  * - \ref SCIP_STAGE_SOLVED
1749  * - \ref SCIP_STAGE_EXITSOLVE
1750  * - \ref SCIP_STAGE_FREETRANS
1751  *
1752  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1753  */
1756  SCIP* scip /**< SCIP data structure */
1757  );
1758 
1759 /** computes the changes to the problem when fixing to the optimal face
1760  *
1761  * returns the degeneracy rate, i.e., the number of nonbasic variables with reduced cost 0
1762  * and the variable constraint ratio, i.e., the number of unfixed variables in relation to the basis size
1763  */
1766  SCIP* scip, /**< SCIP data structure */
1767  SCIP_Real* degeneracy, /**< pointer to store degeneracy share */
1768  SCIP_Real* varconsratio /**< pointer to store variable constraint ratio */
1769  );
1770 
1771 /**@} */
1772 
1773 #ifdef __cplusplus
1774 }
1775 #endif
1776 
1777 #endif
SCIP_EXPORT SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
Definition: scip_lp.c:462
SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1968
SCIP_EXPORT SCIP_RETCODE SCIPcaptureRow(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1486
type definitions for miscellaneous datastructures
SCIP_EXPORT int SCIPgetNLPRows(SCIP *scip)
Definition: scip_lp.c:596
SCIP_EXPORT SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1896
SCIP_EXPORT SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2556
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:1307
SCIP_EXPORT SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
Definition: scip_lp.c:2152
SCIP_EXPORT int SCIPgetNLPCols(SCIP *scip)
Definition: scip_lp.c:518
#define SCIP_EXPORT
Definition: def.h:100
SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2022
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:1040
SCIP_EXPORT SCIP_Bool SCIPisRootLPRelax(SCIP *scip)
Definition: scip_lp.c:342
SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip_lp.c:1368
SCIP_EXPORT int SCIPgetRowNumIntCols(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1826
SCIP_EXPORT SCIP_Real SCIPgetLPRootColumnObjval(SCIP *scip)
Definition: scip_lp.c:386
SCIP_EXPORT SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
Definition: scip_lp.c:299
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:1428
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIP_EXPORT SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2585
SCIP_EXPORT SCIP_Real SCIPgetLPLooseObjval(SCIP *scip)
Definition: scip_lp.c:274
SCIP_EXPORT SCIP_Bool SCIPisLPConstructed(SCIP *scip)
Definition: scip_lp.c:92
SCIP_EXPORT SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_lp.c:2359
type definitions for return codes for SCIP methods
SCIP_EXPORT SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1604
SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1914
SCIP_EXPORT SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
Definition: scip_lp.c:324
SCIP_EXPORT SCIP_Real SCIPgetRowObjParallelism(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2130
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:2618
SCIP_EXPORT SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip_lp.c:2107
SCIP_EXPORT SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip_lp.c:159
SCIP_EXPORT void SCIPsetLPFeastol(SCIP *scip, SCIP_Real newfeastol)
Definition: scip_lp.c:429
SCIP_EXPORT SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip_lp.c:74
SCIP_EXPORT SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
Definition: scip_lp.c:575
type definitions for LP management
SCIP_EXPORT SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1844
SCIP_EXPORT SCIP_Bool SCIPisLPRelax(SCIP *scip)
Definition: scip_lp.c:216
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:1755
SCIP_EXPORT SCIP_RETCODE SCIPchgCutoffboundDive(SCIP *scip, SCIP_Real newcutoffbound)
Definition: scip_lp.c:2288
SCIP_EXPORT SCIP_RETCODE SCIPaddRowDive(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2423
SCIP_EXPORT SCIP_RETCODE SCIPchgRowRhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)
Definition: scip_lp.c:2495
SCIP_EXPORT SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1581
SCIP_EXPORT void SCIPresetLPFeastol(SCIP *scip)
Definition: scip_lp.c:443
SCIP_EXPORT SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)
Definition: scip_lp.c:967
SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowConshdlr(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:1337
SCIP_EXPORT SCIP_Bool SCIPallColsInLP(SCIP *scip)
Definition: scip_lp.c:619
SCIP_EXPORT SCIP_RETCODE SCIPcreateRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, 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:1205
SCIP_EXPORT SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
Definition: scip_lp.c:540
SCIP_EXPORT SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
Definition: scip_lp.c:1508
SCIP_EXPORT SCIP_RETCODE SCIPstartDive(SCIP *scip)
Definition: scip_lp.c:2182
type definitions for SCIP&#39;s main datastructure
SCIP_EXPORT SCIP_RETCODE SCIPcreateRowConshdlr(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:1171
SCIP_EXPORT SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
Definition: scip_lp.c:881
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvCol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:719
SCIP_EXPORT SCIP_RETCODE SCIPchgRowLhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)
Definition: scip_lp.c:2462
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:822
SCIP_EXPORT SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
Definition: scip_lp.c:637
SCIP_EXPORT SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip_lp.c:238
SCIP_EXPORT SCIP_Bool SCIPisLPPrimalReliable(SCIP *scip)
Definition: scip_lp.c:180
SCIP_EXPORT SCIP_Real SCIPgetRowPseudoFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2004
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:755
SCIP_EXPORT SCIP_Real SCIPgetLPFeastol(SCIP *scip)
Definition: scip_lp.c:419
SCIP_EXPORT SCIP_RETCODE SCIPendDive(SCIP *scip)
Definition: scip_lp.c:2231
SCIP_EXPORT SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)
Definition: scip_lp.c:1713
#define SCIP_Bool
Definition: def.h:70
SCIP_EXPORT SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_lp.c:115
SCIP_EXPORT SCIP_Real SCIPgetRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1987
SCIP_EXPORT SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_lp.c:2391
SCIP_EXPORT SCIP_RETCODE SCIPflushLP(SCIP *scip)
Definition: scip_lp.c:139
SCIP_EXPORT SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip_lp.c:931
SCIP_EXPORT void SCIPmarkColNotRemovableLocal(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1148
type definitions for storing primal CIP solutions
SCIP_EXPORT SCIP_Bool SCIPinDive(SCIP *scip)
Definition: scip_lp.c:2715
SCIP_Real * r
Definition: circlepacking.c:50
SCIP_EXPORT SCIP_Real SCIPgetVarObjDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2527
SCIP_EXPORT SCIP_RETCODE SCIPgetLPDegeneracy(SCIP *scip, SCIP_Real *degeneracy, SCIP_Real *varconsratio)
Definition: scip_lp.c:2731
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvACol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:789
SCIP_EXPORT SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
Definition: scip_lp.c:1553
SCIP_EXPORT SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
Definition: scip_lp.c:1529
SCIP_EXPORT SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1933
SCIP_EXPORT SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
Definition: scip_lp.c:847
type definitions for separators
SCIP_EXPORT SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1126
SCIP_EXPORT SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
Definition: scip_lp.c:1641
SCIP_EXPORT SCIP_Longint SCIPgetLastDivenode(SCIP *scip)
Definition: scip_lp.c:2685
SCIP_EXPORT SCIP_Real SCIPgetLPColumnObjval(SCIP *scip)
Definition: scip_lp.c:256
#define SCIP_Real
Definition: def.h:163
SCIP_EXPORT SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1950
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
Definition: scip_lp.c:656
SCIP_EXPORT SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1100
#define SCIP_Longint
Definition: def.h:148
SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:684
SCIP_EXPORT SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2064
SCIP_EXPORT SCIP_COL ** SCIPgetLPCols(SCIP *scip)
Definition: scip_lp.c:497
SCIP_EXPORT SCIP_Real SCIPgetLPRootObjval(SCIP *scip)
Definition: scip_lp.c:363
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:1239
SCIP_EXPORT SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1862
SCIP_EXPORT SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip_lp.c:1667
common defines and data types used in all packages of SCIP
SCIP_EXPORT SCIP_Bool SCIPisLPDualReliable(SCIP *scip)
Definition: scip_lp.c:198
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:1459
SCIP_EXPORT void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1808
SCIP_EXPORT SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_lp.c:2318
SCIP_EXPORT SCIP_Real SCIPgetLPRootLooseObjval(SCIP *scip)
Definition: scip_lp.c:409
SCIP_EXPORT SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1879
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:1784
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:1399
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:1273
SCIP_EXPORT SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip_lp.c:2084
SCIP_EXPORT SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2044