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