Scippy

SCIP

Solving Constraint Integer Programs

scip_lp.c
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-2024 Zuse Institute Berlin (ZIB) */
7 /* */
8 /* Licensed under the Apache License, Version 2.0 (the "License"); */
9 /* you may not use this file except in compliance with the License. */
10 /* You may obtain a copy of the License at */
11 /* */
12 /* http://www.apache.org/licenses/LICENSE-2.0 */
13 /* */
14 /* Unless required by applicable law or agreed to in writing, software */
15 /* distributed under the License is distributed on an "AS IS" BASIS, */
16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17 /* See the License for the specific language governing permissions and */
18 /* limitations under the License. */
19 /* */
20 /* You should have received a copy of the Apache-2.0 license */
21 /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22 /* */
23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24 
25 /**@file scip_lp.c
26  * @ingroup OTHER_CFILES
27  * @brief public methods for the LP relaxation, rows and columns
28  * @author Tobias Achterberg
29  * @author Timo Berthold
30  * @author Gerald Gamrath
31  * @author Leona Gottwald
32  * @author Stefan Heinz
33  * @author Gregor Hendel
34  * @author Thorsten Koch
35  * @author Alexander Martin
36  * @author Marc Pfetsch
37  * @author Michael Winkler
38  * @author Kati Wolter
39  *
40  * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
41  */
42 
43 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
44 
45 #include "blockmemshell/memory.h"
46 #include "lpi/lpi.h"
47 #include "scip/conflict.h"
48 #include "scip/debug.h"
49 #include "scip/lp.h"
50 #include "scip/prob.h"
51 #include "scip/pub_lp.h"
52 #include "scip/pub_message.h"
53 #include "scip/pub_tree.h"
54 #include "scip/scip_lp.h"
55 #include "scip/scip_mem.h"
56 #include "scip/scip_numerics.h"
57 #include "scip/scip_sol.h"
58 #include "scip/scip_solvingstats.h"
59 #include "scip/scip_tree.h"
60 #include "scip/scip_var.h"
61 #include "scip/set.h"
62 #include "scip/solve.h"
63 #include "scip/struct_lp.h"
64 #include "scip/struct_mem.h"
65 #include "scip/struct_primal.h"
66 #include "scip/struct_prob.h"
67 #include "scip/struct_scip.h"
68 #include "scip/struct_set.h"
69 #include "scip/struct_stat.h"
70 #include "scip/struct_tree.h"
71 #include "scip/tree.h"
72 #include "scip/var.h"
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 SCIP_Bool SCIPhasCurrentNodeLP(
84  SCIP* scip /**< SCIP data structure */
85  )
86 {
87  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPhasCurrentNodeLP", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
88 
89  return SCIPtreeHasCurrentNodeLP(scip->tree);
90 }
91 
92 /** returns, whether the LP of the current node is already constructed
93  *
94  * @return whether the LP of the current node is already constructed.
95  *
96  * @pre This method can be called if @p scip is in one of the following stages:
97  * - \ref SCIP_STAGE_SOLVING
98  *
99  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
100  */
101 SCIP_Bool SCIPisLPConstructed(
102  SCIP* scip /**< SCIP data structure */
103  )
104 {
105  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisLPConstructed", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
106 
107  return SCIPtreeIsFocusNodeLPConstructed(scip->tree);
108 }
109 
110 /** makes sure that the LP of the current node is loaded and may be accessed through the LP information methods
111  *
112  * @warning Contructing the LP might change the amount of variables known in the transformed problem and therefore also
113  * the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to
114  * call one of the later method after this one
115  *
116  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
117  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
118  *
119  * @pre This method can be called if @p scip is in one of the following stages:
120  * - \ref SCIP_STAGE_SOLVING
121  *
122  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
123  */
124 SCIP_RETCODE SCIPconstructLP(
125  SCIP* scip, /**< SCIP data structure */
126  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
127  )
128 {
129  SCIP_CALL( SCIPcheckStage(scip, "SCIPconstructLP", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
130 
131  SCIP_CALL( SCIPconstructCurrentLP(scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
132  scip->tree, scip->reopt, scip->lp, scip->pricestore, scip->sepastore, scip->cutpool, scip->branchcand,
133  scip->eventqueue, scip->eventfilter, scip->cliquetable, FALSE, cutoff) );
134 
135  return SCIP_OKAY;
136 }
137 
138 /** makes sure that the LP of the current node is flushed
139  *
140  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
141  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
142  *
143  * @pre This method can be called if @p scip is in one of the following stages:
144  * - \ref SCIP_STAGE_SOLVING
145  *
146  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
147  */
148 SCIP_RETCODE SCIPflushLP(
149  SCIP* scip /**< SCIP data structure */
150  )
151 {
152  SCIP_CALL( SCIPcheckStage(scip, "SCIPflushLP", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
153 
154  SCIP_CALL( SCIPlpFlush(scip->lp, scip->mem->probmem, scip->set, scip->transprob, scip->eventqueue) );
155 
156  return SCIP_OKAY;
157 }
158 
159 /** gets solution status of current LP
160  *
161  * @return the solution status of current LP.
162  *
163  * @pre This method can be called if @p scip is in one of the following stages:
164  * - \ref SCIP_STAGE_SOLVING
165  *
166  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
167  */
168 SCIP_LPSOLSTAT SCIPgetLPSolstat(
169  SCIP* scip /**< SCIP data structure */
170  )
171 {
172  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPSolstat", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
173 
174  if( SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
175  return SCIPlpGetSolstat(scip->lp);
176  else
177  return SCIP_LPSOLSTAT_NOTSOLVED;
178 }
179 
180 /** returns whether the current LP solution passed the primal feasibility check
181  *
182  * @return whether the current LP solution passed the primal feasibility check.
183  *
184  * @pre This method can be called if @p scip is in one of the following stages:
185  * - \ref SCIP_STAGE_SOLVING
186  *
187  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
188  */
189 SCIP_Bool SCIPisLPPrimalReliable(
190  SCIP* scip /**< SCIP data structure */
191  )
192 {
193  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisLPPrimalReliable", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
194 
195  return SCIPlpIsPrimalReliable(scip->lp);
196 }
197 
198 /** returns whether the current LP solution passed the dual feasibility check
199  *
200  * @returns whether the current LP solution passed the dual feasibility check.
201  *
202  * @pre This method can be called if @p scip is in one of the following stages:
203  * - \ref SCIP_STAGE_SOLVING
204  *
205  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
206  */
207 SCIP_Bool SCIPisLPDualReliable(
208  SCIP* scip /**< SCIP data structure */
209  )
210 {
211  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisLPDualReliable", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
212 
213  return SCIPlpIsDualReliable(scip->lp);
214 }
215 
216 /** returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
217  *
218  * @return whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.
219  *
220  * @pre This method can be called if @p scip is in one of the following stages:
221  * - \ref SCIP_STAGE_SOLVING
222  *
223  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
224  */
225 SCIP_Bool SCIPisLPRelax(
226  SCIP* scip /**< SCIP data structure */
227  )
228 {
229  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisLPRelax", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
230 
231  return SCIPlpIsRelax(scip->lp);
232 }
233 
234 /** gets objective value of current LP (which is the sum of column and loose objective value)
235  *
236  * @return the objective value of current LP (which is the sum of column and loose objective value).
237  *
238  * @pre This method can be called if @p scip is in one of the following stages:
239  * - \ref SCIP_STAGE_SOLVING
240  *
241  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
242  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by
243  * SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
244  *
245  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
246  */
247 SCIP_Real SCIPgetLPObjval(
248  SCIP* scip /**< SCIP data structure */
249  )
250 {
251  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPObjval", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
252 
253  return SCIPlpGetObjval(scip->lp, scip->set, scip->transprob);
254 }
255 
256 /** gets part of objective value of current LP that results from COLUMN variables only
257  *
258  * @return the part of objective value of current LP that results from COLUMN variables only.
259  *
260  * @pre This method can be called if @p scip is in one of the following stages:
261  * - \ref SCIP_STAGE_SOLVING
262  *
263  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
264  */
265 SCIP_Real SCIPgetLPColumnObjval(
266  SCIP* scip /**< SCIP data structure */
267  )
268 {
269  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPColumnObjval", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
270 
271  return SCIPlpGetColumnObjval(scip->lp);
272 }
273 
274 /** gets part of objective value of current LP that results from LOOSE variables only
275  *
276  * @return part of objective value of current LP that results from LOOSE variables only.
277  *
278  * @pre This method can be called if @p scip is in one of the following stages:
279  * - \ref SCIP_STAGE_SOLVING
280  *
281  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
282  */
283 SCIP_Real SCIPgetLPLooseObjval(
284  SCIP* scip /**< SCIP data structure */
285  )
286 {
287  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPLooseObjval", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
288 
289  return SCIPlpGetLooseObjval(scip->lp, scip->set, scip->transprob);
290 }
291 
292 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
293  * function) global bound
294  *
295  * @return the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
296  * function) global bound.
297  *
298  * @pre This method can be called if @p scip is in one of the following stages:
299  * - \ref SCIP_STAGE_INITPRESOLVE
300  * - \ref SCIP_STAGE_PRESOLVING
301  * - \ref SCIP_STAGE_EXITPRESOLVE
302  * - \ref SCIP_STAGE_PRESOLVED
303  * - \ref SCIP_STAGE_INITSOLVE
304  * - \ref SCIP_STAGE_SOLVING
305  *
306  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
307  */
308 SCIP_Real SCIPgetGlobalPseudoObjval(
309  SCIP* scip /**< SCIP data structure */
310  )
311 {
312  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetGlobalPseudoObjval", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
313 
314  return SCIPlpGetGlobalPseudoObjval(scip->lp, scip->set, scip->transprob);
315 }
316 
317 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
318  * objective function) local bound
319  *
320  * @return the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
321  * objective function) local bound.
322  *
323  * @pre This method can be called if @p scip is in one of the following stages:
324  * - \ref SCIP_STAGE_INITPRESOLVE
325  * - \ref SCIP_STAGE_PRESOLVING
326  * - \ref SCIP_STAGE_EXITPRESOLVE
327  * - \ref SCIP_STAGE_PRESOLVED
328  * - \ref SCIP_STAGE_INITSOLVE
329  * - \ref SCIP_STAGE_SOLVING
330  *
331  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
332  */
333 SCIP_Real SCIPgetPseudoObjval(
334  SCIP* scip /**< SCIP data structure */
335  )
336 {
337  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetPseudoObjval", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
338 
339  return SCIPlpGetPseudoObjval(scip->lp, scip->set, scip->transprob);
340 }
341 
342 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
343  *
344  * @return whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.
345  *
346  * @pre This method can be called if @p scip is in one of the following stages:
347  * - \ref SCIP_STAGE_SOLVING
348  *
349  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
350  */
351 SCIP_Bool SCIPisRootLPRelax(
352  SCIP* scip /**< SCIP data structure */
353  )
354 {
355  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisRootLPRelax", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
356 
357  return SCIPlpIsRootLPRelax(scip->lp);
358 }
359 
360 /** gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved
361  *
362  * @return the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved.
363  *
364  * @pre This method can be called if @p scip is in one of the following stages:
365  * - \ref SCIP_STAGE_INITPRESOLVE
366  * - \ref SCIP_STAGE_PRESOLVING
367  * - \ref SCIP_STAGE_EXITPRESOLVE
368  * - \ref SCIP_STAGE_SOLVING
369  *
370  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
371  */
372 SCIP_Real SCIPgetLPRootObjval(
373  SCIP* scip /**< SCIP data structure */
374  )
375 {
376  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPRootObjval", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
377 
378  return SCIPlpGetRootObjval(scip->lp);
379 }
380 
381 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
382  * returns SCIP_INVALID if the root node LP was not (yet) solved
383  *
384  * @return the part of the objective value of the root node LP that results from COLUMN variables only;
385  * or SCIP_INVALID if the root node LP was not (yet) solved.
386  *
387  * @pre This method can be called if @p scip is in one of the following stages:
388  * - \ref SCIP_STAGE_INITPRESOLVE
389  * - \ref SCIP_STAGE_PRESOLVING
390  * - \ref SCIP_STAGE_EXITPRESOLVE
391  * - \ref SCIP_STAGE_SOLVING
392  *
393  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
394  */
395 SCIP_Real SCIPgetLPRootColumnObjval(
396  SCIP* scip /**< SCIP data structure */
397  )
398 {
399  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPRootColumnObjval", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
400 
401  return SCIPlpGetRootColumnObjval(scip->lp);
402 }
403 
404 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
405  * returns SCIP_INVALID if the root node LP was not (yet) solved
406  *
407  * @return the part of the objective value of the root node LP that results from LOOSE variables only;
408  * or SCIP_INVALID if the root node LP was not (yet) solved.
409  *
410  * @pre This method can be called if @p scip is in one of the following stages:
411  * - \ref SCIP_STAGE_INITPRESOLVE
412  * - \ref SCIP_STAGE_PRESOLVING
413  * - \ref SCIP_STAGE_EXITPRESOLVE
414  * - \ref SCIP_STAGE_SOLVING
415  *
416  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
417  */
418 SCIP_Real SCIPgetLPRootLooseObjval(
419  SCIP* scip /**< SCIP data structure */
420  )
421 {
422  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPRootLooseObjval", FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
423 
424  return SCIPlpGetRootLooseObjval(scip->lp);
425 }
426 
427 /** gets current primal feasibility tolerance of LP */
428 SCIP_Real SCIPgetLPFeastol(
429  SCIP* scip /**< SCIP data structure */
430  )
431 {
432  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPFeastol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
433 
434  return SCIPlpGetFeastol(scip->lp);
435 }
436 
437 /** sets primal feasibility tolerance of LP */
438 void SCIPsetLPFeastol(
439  SCIP* scip, /**< SCIP data structure */
440  SCIP_Real newfeastol /**< new primal feasibility tolerance for LP */
441  )
442 {
443  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPsetLPFeastol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
444 
445  SCIPlpSetFeastol(scip->lp, scip->set, newfeastol);
446 }
447 
448 /** resets primal feasibility tolerance of LP
449  *
450  * Sets primal feasibility tolerance to min of numerics/lpfeastolfactor * numerics/feastol and relaxfeastol.
451  */
452 void SCIPresetLPFeastol(
453  SCIP* scip /**< SCIP data structure */
454  )
455 {
456  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPresetLPFeastol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
457 
458  SCIPlpResetFeastol(scip->lp, scip->set);
459 }
460 
461 /** gets current LP columns along with the current number of LP columns
462  *
463  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
464  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
465  *
466  * @pre This method can be called if @p scip is in one of the following stages:
467  * - \ref SCIP_STAGE_SOLVING
468  *
469  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
470  */
471 SCIP_RETCODE SCIPgetLPColsData(
472  SCIP* scip, /**< SCIP data structure */
473  SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */
474  int* ncols /**< pointer to store the number of LP columns, or NULL */
475  )
476 {
477  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPColsData", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
478 
479  if( SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
480  {
481  if( cols != NULL )
482  *cols = SCIPlpGetCols(scip->lp);
483  if( ncols != NULL )
484  *ncols = SCIPlpGetNCols(scip->lp);
485  }
486  else
487  {
488  if( cols != NULL )
489  *cols = NULL;
490  if( ncols != NULL )
491  *ncols = 0;
492  }
493 
494  return SCIP_OKAY;
495 }
496 
497 /** gets current LP columns
498  *
499  * @return the current LP columns.
500  *
501  * @pre This method can be called if @p scip is in one of the following stages:
502  * - \ref SCIP_STAGE_SOLVING
503  *
504  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
505  */
506 SCIP_COL** SCIPgetLPCols(
507  SCIP* scip /**< SCIP data structure */
508  )
509 {
510  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPCols", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
511 
512  if( SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
513  return SCIPlpGetCols(scip->lp);
514  else
515  return NULL;
516 }
517 
518 /** gets current number of LP columns
519  *
520  * @return the current number of LP columns.
521  *
522  * @pre This method can be called if @p scip is in one of the following stages:
523  * - \ref SCIP_STAGE_SOLVING
524  *
525  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
526  */
527 int SCIPgetNLPCols(
528  SCIP* scip /**< SCIP data structure */
529  )
530 {
531  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLPCols", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
532 
533  if( SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
534  return SCIPlpGetNCols(scip->lp);
535  else
536  return 0;
537 }
538 
539 /** gets current number of unfixed LP columns
540  *
541  * @return the current number of unfixed LP columns.
542  *
543  * @pre This method can be called if @p scip is in one of the following stages:
544  * - \ref SCIP_STAGE_SOLVING
545  *
546  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
547  */
548 int SCIPgetNUnfixedLPCols(
549  SCIP* scip /**< SCIP data structure */
550  )
551 {
552  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNUnfixedLPCols", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
553 
554  if( SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
555  return SCIPlpGetNUnfixedCols(scip->lp, scip->set->num_epsilon);
556  else
557  return 0;
558 }
559 
560 /** gets current LP rows along with the current number of LP rows
561  *
562  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
563  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
564  *
565  * @pre This method can be called if @p scip is in one of the following stages:
566  * - \ref SCIP_STAGE_SOLVING
567  *
568  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
569  */
570 SCIP_RETCODE SCIPgetLPRowsData(
571  SCIP* scip, /**< SCIP data structure */
572  SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */
573  int* nrows /**< pointer to store the number of LP rows, or NULL */
574  )
575 {
576  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPRowsData", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
577 
578  if( SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
579  {
580  if( rows != NULL )
581  *rows = SCIPlpGetRows(scip->lp);
582  if( nrows != NULL )
583  *nrows = SCIPlpGetNRows(scip->lp);
584  }
585  else
586  {
587  if( rows != NULL )
588  *rows = NULL;
589  if( nrows != NULL )
590  *nrows = 0;
591  }
592 
593  return SCIP_OKAY;
594 }
595 
596 /** gets current LP rows
597  *
598  * @return the current LP rows.
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  */
605 SCIP_ROW** SCIPgetLPRows(
606  SCIP* scip /**< SCIP data structure */
607  )
608 {
609  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLPRows", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
610 
611  if( SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
612  return SCIPlpGetRows(scip->lp);
613  else
614  return NULL;
615 }
616 
617 /** gets current number of LP rows
618  *
619  * @return the current number of LP rows.
620  *
621  * @pre This method can be called if @p scip is in one of the following stages:
622  * - \ref SCIP_STAGE_SOLVING
623  *
624  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
625  */
626 int SCIPgetNLPRows(
627  SCIP* scip /**< SCIP data structure */
628  )
629 {
630  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetNLPRows", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
631 
632  if( SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
633  return SCIPlpGetNRows(scip->lp);
634  else
635  return 0;
636 }
637 
638 /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
639  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
640  *
641  * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
642  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.
643  *
644  * @pre This method can be called if @p scip is in one of the following stages:
645  * - \ref SCIP_STAGE_SOLVING
646  *
647  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
648  */
649 SCIP_Bool SCIPallColsInLP(
650  SCIP* scip /**< SCIP data structure */
651  )
652 {
653  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPallColsInLP", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
654 
655  return SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp);
656 }
657 
658 /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
659  *
660  * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis.
661  *
662  * @pre This method can be called if @p scip is in one of the following stages:
663  * - \ref SCIP_STAGE_SOLVING
664  *
665  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
666  */
667 SCIP_Bool SCIPisLPSolBasic(
668  SCIP* scip /**< SCIP data structure */
669  )
670 {
671  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPisLPSolBasic", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
672 
673  return SCIPlpIsSolBasic(scip->lp);
674 }
675 
676 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
677  *
678  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
679  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
680  *
681  * @pre This method can be called if @p scip is in one of the following stages:
682  * - \ref SCIP_STAGE_SOLVING
683  *
684  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
685  */
686 SCIP_RETCODE SCIPgetLPBasisInd(
687  SCIP* scip, /**< SCIP data structure */
688  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
689  )
690 {
691  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPBasisInd", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
692 
693  if( !SCIPlpIsSolBasic(scip->lp) )
694  {
695  SCIPerrorMessage("current LP solution is not basic\n");
696  return SCIP_INVALIDCALL;
697  }
698 
699  SCIP_CALL( SCIPlpGetBasisInd(scip->lp, basisind) );
700 
701  return SCIP_OKAY;
702 }
703 
704 /** gets a row from the inverse basis matrix B^-1
705  *
706  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
707  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
708  *
709  * @pre This method can be called if @p scip is in one of the following stages:
710  * - \ref SCIP_STAGE_SOLVING
711  *
712  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
713  */
714 SCIP_RETCODE SCIPgetLPBInvRow(
715  SCIP* scip, /**< SCIP data structure */
716  int r, /**< row number */
717  SCIP_Real* coefs, /**< array to store the coefficients of the row */
718  int* inds, /**< array to store the non-zero indices, or NULL */
719  int* ninds /**< pointer to store the number of non-zero indices, or NULL
720  * (-1: if we do not store sparsity informations) */
721  )
722 {
723  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPBInvRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
724 
725  if( !SCIPlpIsSolBasic(scip->lp) )
726  {
727  SCIPerrorMessage("current LP solution is not basic\n");
728  return SCIP_INVALIDCALL;
729  }
730 
731  SCIP_CALL( SCIPlpGetBInvRow(scip->lp, r, coefs, inds, ninds) );
732 
733  /* debug check if the coef is the r-th line of the inverse matrix B^-1 */
734  SCIP_CALL( SCIPdebugCheckBInvRow(scip, r, coefs) ); /*lint !e506 !e774*/
735 
736  return SCIP_OKAY;
737 }
738 
739 /** gets a column from the inverse basis matrix B^-1
740  *
741  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
742  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
743  *
744  * @pre This method can be called if @p scip is in one of the following stages:
745  * - \ref SCIP_STAGE_SOLVING
746  *
747  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
748  */
749 SCIP_RETCODE SCIPgetLPBInvCol(
750  SCIP* scip, /**< SCIP data structure */
751  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
752  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
753  * to get the array which links the B^-1 column numbers to the row and
754  * column numbers of the LP! c must be between 0 and nrows-1, since the
755  * basis has the size nrows * nrows */
756  SCIP_Real* coefs, /**< array to store the coefficients of the column */
757  int* inds, /**< array to store the non-zero indices, or NULL */
758  int* ninds /**< pointer to store the number of non-zero indices, or NULL
759  * (-1: if we do not store sparsity informations) */
760  )
761 {
762  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPBInvCol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
763 
764  if( !SCIPlpIsSolBasic(scip->lp) )
765  {
766  SCIPerrorMessage("current LP solution is not basic\n");
767  return SCIP_INVALIDCALL;
768  }
769 
770  SCIP_CALL( SCIPlpGetBInvCol(scip->lp, c, coefs, inds, ninds) );
771 
772  return SCIP_OKAY;
773 }
774 
775 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
776  *
777  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
778  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
779  *
780  * @pre This method can be called if @p scip is in one of the following stages:
781  * - \ref SCIP_STAGE_SOLVING
782  *
783  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
784  */
785 SCIP_RETCODE SCIPgetLPBInvARow(
786  SCIP* scip, /**< SCIP data structure */
787  int r, /**< row number */
788  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */
789  SCIP_Real* coefs, /**< array to store the coefficients of the row */
790  int* inds, /**< array to store the non-zero indices, or NULL */
791  int* ninds /**< pointer to store the number of non-zero indices, or NULL
792  * (-1: if we do not store sparsity informations) */
793  )
794 {
795  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPBInvARow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
796 
797  if( !SCIPlpIsSolBasic(scip->lp) )
798  {
799  SCIPerrorMessage("current LP solution is not basic\n");
800  return SCIP_INVALIDCALL;
801  }
802 
803  SCIP_CALL( SCIPlpGetBInvARow(scip->lp, r, binvrow, coefs, inds, ninds) );
804 
805  return SCIP_OKAY;
806 }
807 
808 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
809  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
810  *
811  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
812  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
813  *
814  * @pre This method can be called if @p scip is in one of the following stages:
815  * - \ref SCIP_STAGE_SOLVING
816  *
817  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
818  */
819 SCIP_RETCODE SCIPgetLPBInvACol(
820  SCIP* scip, /**< SCIP data structure */
821  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
822  SCIP_Real* coefs, /**< array to store the coefficients of the column */
823  int* inds, /**< array to store the non-zero indices, or NULL */
824  int* ninds /**< pointer to store the number of non-zero indices, or NULL
825  * (-1: if we do not store sparsity informations) */
826  )
827 {
828  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPBInvACol", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
829 
830  if( !SCIPlpIsSolBasic(scip->lp) )
831  {
832  SCIPerrorMessage("current LP solution is not basic\n");
833  return SCIP_INVALIDCALL;
834  }
835 
836  SCIP_CALL( SCIPlpGetBInvACol(scip->lp, c, coefs, inds, ninds) );
837 
838  return SCIP_OKAY;
839 }
840 
841 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
842  * LP row are swapped in the summation
843  *
844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
846  *
847  * @pre This method can be called if @p scip is in one of the following stages:
848  * - \ref SCIP_STAGE_SOLVING
849  *
850  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
851  */
852 SCIP_RETCODE SCIPsumLPRows(
853  SCIP* scip, /**< SCIP data structure */
854  SCIP_Real* weights, /**< row weights in row summation */
855  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
856  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
857  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
858  )
859 {
860  SCIP_CALL( SCIPcheckStage(scip, "SCIPsumLPRows", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
861 
862  SCIP_CALL( SCIPlpSumRows(scip->lp, scip->set, scip->transprob, weights, sumcoef, sumlhs, sumrhs) );
863 
864  return SCIP_OKAY;
865 }
866 
867 /** interrupts or disables the interrupt of the currently ongoing lp solve; if the lp is not currently constructed just returns with no effect
868  *
869  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
870  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
871  *
872  * @pre This method can be called in any SCIP stage
873  */
874 SCIP_RETCODE SCIPinterruptLP(
875  SCIP* scip, /**< SCIP data structure */
876  SCIP_Bool interrupt /**< TRUE if interrupt should be set, FALSE if it should be disabled */
877  )
878 {
879  SCIP_CALL( SCIPcheckStage(scip, "SCIPinterruptLP", TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE) );
880 
881  if( scip->lp == NULL )
882  return SCIP_OKAY;
883 
884  SCIP_CALL( SCIPlpInterrupt(scip->lp, interrupt) );
885  if( interrupt )
886  scip->stat->userinterrupt = TRUE;
887 
888  return SCIP_OKAY;
889 }
890 
891 /** writes current LP to a file
892  *
893  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
894  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
895  *
896  * @pre This method can be called if @p scip is in one of the following stages:
897  * - \ref SCIP_STAGE_SOLVING
898  *
899  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
900  */
901 SCIP_RETCODE SCIPwriteLP(
902  SCIP* scip, /**< SCIP data structure */
903  const char* filename /**< file name */
904  )
905 {
906  SCIP_Bool cutoff;
907 
908  SCIP_CALL( SCIPcheckStage(scip, "SCIPwriteLP", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
909 
910  if( !SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
911  {
912  SCIP_CALL( SCIPconstructCurrentLP(scip->mem->probmem, scip->set, scip->stat, scip->transprob, scip->origprob,
913  scip->tree, scip->reopt, scip->lp, scip->pricestore, scip->sepastore, scip->cutpool, scip->branchcand,
914  scip->eventqueue, scip->eventfilter, scip->cliquetable, FALSE, &cutoff) );
915  }
916 
917  /* we need a flushed lp to write the current lp */
918  SCIP_CALL( SCIPlpFlush(scip->lp, scip->mem->probmem, scip->set, scip->transprob, scip->eventqueue) );
919 
920  SCIP_CALL( SCIPlpWrite(scip->lp, filename) );
921 
922  return SCIP_OKAY;
923 }
924 
925 /** writes MIP relaxation of the current branch-and-bound node to a file
926  *
927  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
928  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
929  *
930  * @pre This method can be called if @p scip is in one of the following stages:
931  * - \ref SCIP_STAGE_SOLVING
932  *
933  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
934  */
935 SCIP_RETCODE SCIPwriteMIP(
936  SCIP* scip, /**< SCIP data structure */
937  const char* filename, /**< file name */
938  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
939  * troubles with reserved symbols? */
940  SCIP_Bool origobj, /**< should the original objective function be used? */
941  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
942  )
943 {
944  SCIP_CALL( SCIPcheckStage(scip, "SCIPwriteMIP", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
945 
946  /* we need a flushed lp to write the current mip */
947  SCIP_CALL( SCIPlpFlush(scip->lp, scip->mem->probmem, scip->set, scip->transprob, scip->eventqueue) );
948 
949  SCIP_CALL( SCIPlpWriteMip(scip->lp, scip->set, scip->messagehdlr, filename, genericnames,
950  origobj, scip->origprob->objsense, scip->transprob->objscale, scip->transprob->objoffset, lazyconss) );
951 
952  return SCIP_OKAY;
953 }
954 
955 /** gets the LP interface of SCIP;
956  * with the LPI you can use all of the methods defined in lpi/lpi.h;
957  *
958  * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely
959  * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution
960  * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in
961  * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make
962  * sure, the internal solution status is recovered completely at the end of your method. This can be achieved
963  * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it
964  * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the
965  * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.
966  *
967  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
968  *
969  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
970  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
971  *
972  * @pre This method can be called if @p scip is in one of the following stages:
973  * - \ref SCIP_STAGE_TRANSFORMED
974  * - \ref SCIP_STAGE_INITPRESOLVE
975  * - \ref SCIP_STAGE_PRESOLVING
976  * - \ref SCIP_STAGE_EXITPRESOLVE
977  * - \ref SCIP_STAGE_PRESOLVED
978  * - \ref SCIP_STAGE_INITSOLVE
979  * - \ref SCIP_STAGE_SOLVING
980  * - \ref SCIP_STAGE_SOLVED
981  * - \ref SCIP_STAGE_EXITSOLVE
982  *
983  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
984  */
985 SCIP_RETCODE SCIPgetLPI(
986  SCIP* scip, /**< SCIP data structure */
987  SCIP_LPI** lpi /**< pointer to store the LP interface */
988  )
989 {
990  assert(lpi != NULL);
991 
992  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPI", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
993 
994  *lpi = SCIPlpGetLPI(scip->lp);
995 
996  return SCIP_OKAY;
997 }
998 
999 /** displays quality information about the current LP solution. An LP solution need to be available; information printed
1000  * is subject to what the LP solver supports
1001  *
1002  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1003  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1004  *
1005  * @pre This method can be called if @p scip is in one of the following stages:
1006  * - \ref SCIP_STAGE_INIT
1007  * - \ref SCIP_STAGE_PROBLEM
1008  * - \ref SCIP_STAGE_TRANSFORMED
1009  * - \ref SCIP_STAGE_INITPRESOLVE
1010  * - \ref SCIP_STAGE_PRESOLVING
1011  * - \ref SCIP_STAGE_EXITPRESOLVE
1012  * - \ref SCIP_STAGE_PRESOLVED
1013  * - \ref SCIP_STAGE_SOLVING
1014  * - \ref SCIP_STAGE_SOLVED
1015  * - \ref SCIP_STAGE_FREE
1016  *
1017  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1018  *
1019  * @note The printing process is done via the message handler system.
1020  */
1021 SCIP_RETCODE SCIPprintLPSolutionQuality(
1022  SCIP* scip, /**< SCIP data structure */
1023  FILE* file /**< output file (or NULL for standard output) */
1024  )
1025 {
1026  SCIP_LPI* lpi;
1027  SCIP_Real quality;
1028 
1029  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintLPSolutionQuality", TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, TRUE) );
1030 
1031  switch( scip->set->stage )
1032  {
1033  case SCIP_STAGE_INIT:
1034  case SCIP_STAGE_PROBLEM:
1035  case SCIP_STAGE_TRANSFORMED:
1036  case SCIP_STAGE_INITPRESOLVE:
1037  case SCIP_STAGE_PRESOLVING:
1038  case SCIP_STAGE_EXITPRESOLVE:
1039  case SCIP_STAGE_PRESOLVED:
1040  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Problem not solving yet, no LP available.\n");
1041  return SCIP_OKAY;
1042 
1043  case SCIP_STAGE_SOLVING:
1044  case SCIP_STAGE_SOLVED:
1045  break;
1046 
1047  default:
1048  SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
1049  return SCIP_INVALIDCALL;
1050  } /*lint !e788*/
1051 
1052  /* note that after diving mode, the LPI may only have the basis information, but SCIPlpiWasSolved() can be false; in
1053  * this case, we will (depending on the LP solver) probably not obtain the quality measure; one solution would be to
1054  * store the results of SCIPlpiGetRealSolQuality() within the SCIP_LP after each LP solve; this would have the added
1055  * advantage, that we reduce direct access to the LPI, but it sounds potentially expensive
1056  */
1057  lpi = SCIPlpGetLPI(scip->lp);
1058  assert(lpi != NULL);
1059 
1060  SCIP_CALL( SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_ESTIMCONDITION, &quality) );
1061  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Basis matrix condition (estimated): ");
1062  if( quality != SCIP_INVALID ) /*lint !e777*/
1063  SCIPmessageFPrintInfo(scip->messagehdlr, file, "%.6e\n", quality);
1064  else
1065  SCIPmessageFPrintInfo(scip->messagehdlr, file, "not available\n");
1066 
1067  SCIP_CALL( SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_EXACTCONDITION, &quality) );
1068  SCIPmessageFPrintInfo(scip->messagehdlr, file, "Basis matrix condition (exact): ");
1069  if( quality != SCIP_INVALID ) /*lint !e777*/
1070  SCIPmessageFPrintInfo(scip->messagehdlr, file, "%.6e\n", quality);
1071  else
1072  SCIPmessageFPrintInfo(scip->messagehdlr, file, "not available\n");
1073 
1074  return SCIP_OKAY;
1075 }
1076 
1077 /** compute relative interior point to current LP
1078  * @see SCIPlpComputeRelIntPoint
1079  *
1080  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1081  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1082  *
1083  * @pre This method can be called if @p scip is in one of the following stages:
1084  * - \ref SCIP_STAGE_TRANSFORMED
1085  * - \ref SCIP_STAGE_INITPRESOLVE
1086  * - \ref SCIP_STAGE_PRESOLVING
1087  * - \ref SCIP_STAGE_EXITPRESOLVE
1088  * - \ref SCIP_STAGE_PRESOLVED
1089  * - \ref SCIP_STAGE_SOLVING
1090  * - \ref SCIP_STAGE_SOLVED
1091  *
1092  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1093  */
1094 SCIP_RETCODE SCIPcomputeLPRelIntPoint(
1095  SCIP* scip, /**< SCIP data structure */
1096  SCIP_Bool relaxrows, /**< should the rows be relaxed */
1097  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
1098  SCIP_Real timelimit, /**< time limit for LP solver */
1099  int iterlimit, /**< iteration limit for LP solver */
1100  SCIP_SOL** point /**< relative interior point on exit */
1101  )
1102 {
1103  SCIP_Real* pointvals;
1104  SCIP_Bool success;
1105 
1106  SCIP_CALL( SCIPcheckStage(scip, "SCIPcomputeLPRelIntPoint", FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1107 
1108  assert(scip != NULL);
1109  assert(scip->lp != NULL);
1110  assert(point != NULL);
1111 
1112  *point = NULL;
1113 
1114  SCIP_CALL( SCIPallocBufferArray(scip, &pointvals, SCIPlpGetNCols(scip->lp)) );
1115 
1116  SCIP_CALL( SCIPlpComputeRelIntPoint(scip->set, scip->messagehdlr, scip->lp, scip->transprob,
1117  relaxrows, inclobjcutoff, timelimit, iterlimit, pointvals, &success) );
1118 
1119  /* if successful, create new solution with point values */
1120  if( success )
1121  {
1122  int i;
1123 
1124  SCIP_CALL( SCIPcreateSol(scip, point, NULL) );
1125 
1126  for( i = 0; i < SCIPlpGetNCols(scip->lp); ++i )
1127  {
1128  SCIP_CALL( SCIPsetSolVal(scip, *point, SCIPcolGetVar(SCIPlpGetCols(scip->lp)[i]), pointvals[i]) );
1129  }
1130  }
1131 
1132  SCIPfreeBufferArray(scip, &pointvals);
1133 
1134  return SCIP_OKAY;
1135 }
1136 
1137 /*
1138  * LP column methods
1139  */
1140 
1141 /** returns the reduced costs of a column in the last (feasible) LP
1142  *
1143  * @return the reduced costs of a column in the last (feasible) LP
1144  *
1145  * @pre this method can be called in one of the following stages of the SCIP solving process:
1146  * - \ref SCIP_STAGE_SOLVING
1147  * - \ref SCIP_STAGE_SOLVED
1148  *
1149  * @note calling this method in SCIP_STAGE_SOLVED is only recommended to experienced users and should only be called
1150  * for pure LP instances (without presolving)
1151  *
1152  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
1153  */
1154 SCIP_Real SCIPgetColRedcost(
1155  SCIP* scip, /**< SCIP data structure */
1156  SCIP_COL* col /**< LP column */
1157  )
1158 {
1159  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetColRedcost", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1160 
1161  if( !SCIPtreeHasCurrentNodeLP(scip->tree) )
1162  {
1163  SCIPerrorMessage("cannot get reduced costs, because node LP is not processed\n");
1164  SCIPABORT();
1165  return 0.0; /*lint !e527*/
1166  }
1167 
1168  return SCIPcolGetRedcost(col, scip->stat, scip->lp);
1169 }
1170 
1171 
1172 /** returns the Farkas coefficient of a column in the last (infeasible) LP
1173  *
1174  * @return the Farkas coefficient of a column in the last (infeasible) LP
1175  *
1176  * @pre this method can be called in one of the following stages of the SCIP solving process:
1177  * - \ref SCIP_STAGE_SOLVING
1178  * - \ref SCIP_STAGE_SOLVED
1179  */
1180 SCIP_Real SCIPgetColFarkasCoef(
1181  SCIP* scip, /**< SCIP data structure */
1182  SCIP_COL* col /**< LP column */
1183  )
1184 {
1185  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetColFarkasCoef", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
1186 
1187  if( !SCIPtreeHasCurrentNodeLP(scip->tree) )
1188  {
1189  SCIPerrorMessage("cannot get Farkas coeff, because node LP is not processed\n");
1190  SCIPABORT();
1191  return 0.0; /*lint !e527*/
1192  }
1193 
1194  return SCIPcolGetFarkasCoef(col, scip->stat, scip->lp);
1195 }
1196 
1197 /** marks a column to be not removable from the LP in the current node
1198  *
1199  * @pre this method can be called in the following stage of the SCIP solving process:
1200  * - \ref SCIP_STAGE_SOLVING
1201  */
1202 void SCIPmarkColNotRemovableLocal(
1203  SCIP* scip, /**< SCIP data structure */
1204  SCIP_COL* col /**< LP column */
1205  )
1206 {
1207  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPmarkColNotRemovableLocal", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1208 
1209  SCIPcolMarkNotRemovableLocal(col, scip->stat);
1210 }
1211 
1212 /*
1213  * LP row methods
1214  */
1215 
1216 /** creates and captures an LP row from a constraint handler
1217  *
1218  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1219  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1220  *
1221  * @pre this method can be called in one of the following stages of the SCIP solving process:
1222  * - \ref SCIP_STAGE_INITSOLVE
1223  * - \ref SCIP_STAGE_SOLVING
1224  */
1225 SCIP_RETCODE SCIPcreateRowConshdlr(
1226  SCIP* scip, /**< SCIP data structure */
1227  SCIP_ROW** row, /**< pointer to row */
1228  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
1229  const char* name, /**< name of row */
1230  int len, /**< number of nonzeros in the row */
1231  SCIP_COL** cols, /**< array with columns of row entries */
1232  SCIP_Real* vals, /**< array with coefficients of row entries */
1233  SCIP_Real lhs, /**< left hand side of row */
1234  SCIP_Real rhs, /**< right hand side of row */
1235  SCIP_Bool local, /**< is row only valid locally? */
1236  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1237  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1238  )
1239 {
1240  assert(conshdlr != NULL);
1241 
1242  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateRowConshdlr", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1243 
1244  SCIP_CALL( SCIProwCreate(row, scip->mem->probmem, scip->set, scip->stat,
1245  name, len, cols, vals, lhs, rhs, SCIP_ROWORIGINTYPE_CONSHDLR, (void*) conshdlr, local, modifiable, removable) );
1246 
1247  return SCIP_OKAY;
1248 }
1249 
1250 /** creates and captures an LP row from a constraint
1251  *
1252  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1253  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
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  */
1259 SCIP_RETCODE SCIPcreateRowCons(
1260  SCIP* scip, /**< SCIP data structure */
1261  SCIP_ROW** row, /**< pointer to row */
1262  SCIP_CONS* cons, /**< constraint that creates the row */
1263  const char* name, /**< name of row */
1264  int len, /**< number of nonzeros in the row */
1265  SCIP_COL** cols, /**< array with columns of row entries */
1266  SCIP_Real* vals, /**< array with coefficients of row entries */
1267  SCIP_Real lhs, /**< left hand side of row */
1268  SCIP_Real rhs, /**< right hand side of row */
1269  SCIP_Bool local, /**< is row only valid locally? */
1270  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1271  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1272  )
1273 {
1274  assert(cons != NULL);
1275 
1276  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateRowCons", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1277 
1278  SCIP_CALL( SCIProwCreate(row, scip->mem->probmem, scip->set, scip->stat,
1279  name, len, cols, vals, lhs, rhs, SCIP_ROWORIGINTYPE_CONS, (void*) cons, local, modifiable, removable) );
1280 
1281  return SCIP_OKAY;
1282 }
1283 
1284 /** creates and captures an LP row from a separator
1285  *
1286  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1287  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1288  *
1289  * @pre this method can be called in one of the following stages of the SCIP solving process:
1290  * - \ref SCIP_STAGE_INITSOLVE
1291  * - \ref SCIP_STAGE_SOLVING
1292  */
1293 SCIP_RETCODE SCIPcreateRowSepa(
1294  SCIP* scip, /**< SCIP data structure */
1295  SCIP_ROW** row, /**< pointer to row */
1296  SCIP_SEPA* sepa, /**< separator that creates the row */
1297  const char* name, /**< name of row */
1298  int len, /**< number of nonzeros in the row */
1299  SCIP_COL** cols, /**< array with columns of row entries */
1300  SCIP_Real* vals, /**< array with coefficients of row entries */
1301  SCIP_Real lhs, /**< left hand side of row */
1302  SCIP_Real rhs, /**< right hand side of row */
1303  SCIP_Bool local, /**< is row only valid locally? */
1304  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1305  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1306  )
1307 {
1308  assert(sepa != NULL);
1309 
1310  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateRowSepa", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1311 
1312  SCIP_CALL( SCIProwCreate(row, scip->mem->probmem, scip->set, scip->stat,
1313  name, len, cols, vals, lhs, rhs, SCIP_ROWORIGINTYPE_SEPA, (void*) sepa, local, modifiable, removable) );
1314 
1315  return SCIP_OKAY;
1316 }
1317 
1318 /** creates and captures an LP row from an unspecified source
1319  *
1320  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1321  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1322  *
1323  * @pre this method can be called in one of the following stages of the SCIP solving process:
1324  * - \ref SCIP_STAGE_INITSOLVE
1325  * - \ref SCIP_STAGE_SOLVING
1326  */
1327 SCIP_RETCODE SCIPcreateRowUnspec(
1328  SCIP* scip, /**< SCIP data structure */
1329  SCIP_ROW** row, /**< pointer to row */
1330  const char* name, /**< name of row */
1331  int len, /**< number of nonzeros in the row */
1332  SCIP_COL** cols, /**< array with columns of row entries */
1333  SCIP_Real* vals, /**< array with coefficients of row entries */
1334  SCIP_Real lhs, /**< left hand side of row */
1335  SCIP_Real rhs, /**< right hand side of row */
1336  SCIP_Bool local, /**< is row only valid locally? */
1337  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1338  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1339  )
1340 {
1341  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateRowUnspec", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1342 
1343  SCIP_CALL( SCIProwCreate(row, scip->mem->probmem, scip->set, scip->stat,
1344  name, len, cols, vals, lhs, rhs, SCIP_ROWORIGINTYPE_UNSPEC, NULL, local, modifiable, removable) );
1345 
1346  return SCIP_OKAY;
1347 }
1348 
1349 /** creates and captures an LP row
1350  *
1351  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1352  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1353  *
1354  * @pre this method can be called in one of the following stages of the SCIP solving process:
1355  * - \ref SCIP_STAGE_INITSOLVE
1356  * - \ref SCIP_STAGE_SOLVING
1357  *
1358  * @deprecated Please use SCIPcreateRowConshdlr() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order
1359  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().
1360  */
1361 SCIP_RETCODE SCIPcreateRow(
1362  SCIP* scip, /**< SCIP data structure */
1363  SCIP_ROW** row, /**< pointer to row */
1364  const char* name, /**< name of row */
1365  int len, /**< number of nonzeros in the row */
1366  SCIP_COL** cols, /**< array with columns of row entries */
1367  SCIP_Real* vals, /**< array with coefficients of row entries */
1368  SCIP_Real lhs, /**< left hand side of row */
1369  SCIP_Real rhs, /**< right hand side of row */
1370  SCIP_Bool local, /**< is row only valid locally? */
1371  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1372  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1373  )
1374 {
1375  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1376 
1377  SCIP_CALL( SCIPcreateRowUnspec(scip, row, name, len, cols, vals, lhs, rhs, local, modifiable, removable) );
1378 
1379  return SCIP_OKAY;
1380 }
1381 
1382 /** creates and captures an LP row without any coefficients from a constraint handler
1383  *
1384  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1385  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1386  *
1387  * @pre this method can be called in one of the following stages of the SCIP solving process:
1388  * - \ref SCIP_STAGE_INITSOLVE
1389  * - \ref SCIP_STAGE_SOLVING
1390  */
1391 SCIP_RETCODE SCIPcreateEmptyRowConshdlr(
1392  SCIP* scip, /**< SCIP data structure */
1393  SCIP_ROW** row, /**< pointer to row */
1394  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
1395  const char* name, /**< name of row */
1396  SCIP_Real lhs, /**< left hand side of row */
1397  SCIP_Real rhs, /**< right hand side of row */
1398  SCIP_Bool local, /**< is row only valid locally? */
1399  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1400  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1401  )
1402 {
1403  assert(conshdlr != NULL);
1404 
1405  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateEmptyRowConshdlr", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1406 
1407  SCIP_CALL( SCIProwCreate(row, scip->mem->probmem, scip->set, scip->stat,
1408  name, 0, NULL, NULL, lhs, rhs, SCIP_ROWORIGINTYPE_CONSHDLR, (void*) conshdlr, local, modifiable, removable) );
1409 
1410  return SCIP_OKAY;
1411 }
1412 
1413 /** creates and captures an LP row without any coefficients from a constraint
1414  *
1415  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1416  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1417  *
1418  * @pre this method can be called in one of the following stages of the SCIP solving process:
1419  * - \ref SCIP_STAGE_INITSOLVE
1420  * - \ref SCIP_STAGE_SOLVING
1421  */
1422 SCIP_RETCODE SCIPcreateEmptyRowCons(
1423  SCIP* scip, /**< SCIP data structure */
1424  SCIP_ROW** row, /**< pointer to row */
1425  SCIP_CONS* cons, /**< constraint that creates the row */
1426  const char* name, /**< name of row */
1427  SCIP_Real lhs, /**< left hand side of row */
1428  SCIP_Real rhs, /**< right hand side of row */
1429  SCIP_Bool local, /**< is row only valid locally? */
1430  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1431  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1432  )
1433 {
1434  assert(cons != NULL);
1435 
1436  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateEmptyRowCons", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1437 
1438  SCIP_CALL( SCIProwCreate(row, scip->mem->probmem, scip->set, scip->stat,
1439  name, 0, NULL, NULL, lhs, rhs, SCIP_ROWORIGINTYPE_CONS, (void*) cons, local, modifiable, removable) );
1440 
1441  return SCIP_OKAY;
1442 }
1443 
1444 /** creates and captures an LP row without any coefficients from a separator
1445  *
1446  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1447  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1448  *
1449  * @pre this method can be called in one of the following stages of the SCIP solving process:
1450  * - \ref SCIP_STAGE_INITSOLVE
1451  * - \ref SCIP_STAGE_SOLVING
1452  */
1453 SCIP_RETCODE SCIPcreateEmptyRowSepa(
1454  SCIP* scip, /**< SCIP data structure */
1455  SCIP_ROW** row, /**< pointer to row */
1456  SCIP_SEPA* sepa, /**< separator that creates the row */
1457  const char* name, /**< name of row */
1458  SCIP_Real lhs, /**< left hand side of row */
1459  SCIP_Real rhs, /**< right hand side of row */
1460  SCIP_Bool local, /**< is row only valid locally? */
1461  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1462  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1463  )
1464 {
1465  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateEmptyRowSepa", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1466 
1467  SCIP_CALL( SCIProwCreate(row, scip->mem->probmem, scip->set, scip->stat,
1468  name, 0, NULL, NULL, lhs, rhs, SCIP_ROWORIGINTYPE_SEPA, (void*) sepa, local, modifiable, removable) );
1469 
1470  return SCIP_OKAY;
1471 }
1472 
1473 /** creates and captures an LP row without any coefficients from an unspecified source
1474  *
1475  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1476  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1477  *
1478  * @pre this method can be called in one of the following stages of the SCIP solving process:
1479  * - \ref SCIP_STAGE_INITSOLVE
1480  * - \ref SCIP_STAGE_SOLVING
1481  */
1482 SCIP_RETCODE SCIPcreateEmptyRowUnspec(
1483  SCIP* scip, /**< SCIP data structure */
1484  SCIP_ROW** row, /**< pointer to row */
1485  const char* name, /**< name of row */
1486  SCIP_Real lhs, /**< left hand side of row */
1487  SCIP_Real rhs, /**< right hand side of row */
1488  SCIP_Bool local, /**< is row only valid locally? */
1489  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1490  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1491  )
1492 {
1493  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateEmptyRowUnspec", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1494 
1495  SCIP_CALL( SCIProwCreate(row, scip->mem->probmem, scip->set, scip->stat,
1496  name, 0, NULL, NULL, lhs, rhs, SCIP_ROWORIGINTYPE_UNSPEC, NULL, local, modifiable, removable) );
1497 
1498  return SCIP_OKAY;
1499 }
1500 
1501 /** creates and captures an LP row without any coefficients
1502  *
1503  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1504  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1505  *
1506  * @pre this method can be called in one of the following stages of the SCIP solving process:
1507  * - \ref SCIP_STAGE_INITSOLVE
1508  * - \ref SCIP_STAGE_SOLVING
1509  *
1510  * @deprecated Please use SCIPcreateEmptyRowConshdlr() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order
1511  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().
1512  */
1513 SCIP_RETCODE SCIPcreateEmptyRow(
1514  SCIP* scip, /**< SCIP data structure */
1515  SCIP_ROW** row, /**< pointer to row */
1516  const char* name, /**< name of row */
1517  SCIP_Real lhs, /**< left hand side of row */
1518  SCIP_Real rhs, /**< right hand side of row */
1519  SCIP_Bool local, /**< is row only valid locally? */
1520  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
1521  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
1522  )
1523 {
1524  SCIP_CALL( SCIPcheckStage(scip, "SCIPcreateEmptyRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1525 
1526  SCIP_CALL( SCIPcreateEmptyRowUnspec(scip, row, name, lhs, rhs, local, modifiable, removable) );
1527 
1528  return SCIP_OKAY;
1529 }
1530 
1531 /** increases usage counter of LP row
1532  *
1533  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1534  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1535  *
1536  * @pre this method can be called in one of the following stages of the SCIP solving process:
1537  * - \ref SCIP_STAGE_INITSOLVE
1538  * - \ref SCIP_STAGE_SOLVING
1539  */
1540 SCIP_RETCODE SCIPcaptureRow(
1541  SCIP* scip, /**< SCIP data structure */
1542  SCIP_ROW* row /**< row to capture */
1543  )
1544 {
1545  SCIP_CALL( SCIPcheckStage(scip, "SCIPcaptureRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1546 
1547  SCIProwCapture(row);
1548 
1549  return SCIP_OKAY;
1550 }
1551 
1552 /** decreases usage counter of LP row, and frees memory if necessary
1553  *
1554  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1555  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1556  *
1557  * @pre this method can be called in one of the following stages of the SCIP solving process:
1558  * - \ref SCIP_STAGE_INITSOLVE
1559  * - \ref SCIP_STAGE_SOLVING
1560  * - \ref SCIP_STAGE_EXITSOLVE
1561  */
1562 SCIP_RETCODE SCIPreleaseRow(
1563  SCIP* scip, /**< SCIP data structure */
1564  SCIP_ROW** row /**< pointer to LP row */
1565  )
1566 {
1567  SCIP_CALL( SCIPcheckStage(scip, "SCIPreleaseRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE) );
1568 
1569  SCIP_CALL( SCIProwRelease(row, scip->mem->probmem, scip->set, scip->lp) );
1570 
1571  return SCIP_OKAY;
1572 }
1573 
1574 /** changes left hand side of LP row
1575  *
1576  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1577  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1578  *
1579  * @pre this method can be called in one of the following stages of the SCIP solving process:
1580  * - \ref SCIP_STAGE_INITSOLVE
1581  * - \ref SCIP_STAGE_SOLVING
1582  */
1583 SCIP_RETCODE SCIPchgRowLhs(
1584  SCIP* scip, /**< SCIP data structure */
1585  SCIP_ROW* row, /**< LP row */
1586  SCIP_Real lhs /**< new left hand side */
1587  )
1588 {
1589  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgRowLhs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1590 
1591  assert(!SCIPlpDiving(scip->lp) || (row->lppos == -1));
1592 
1593  SCIP_CALL( SCIProwChgLhs(row, scip->mem->probmem, scip->set, scip->eventqueue, scip->lp, lhs) );
1594 
1595  return SCIP_OKAY;
1596 }
1597 
1598 /** changes right hand side of LP row
1599  *
1600  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1601  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1602  *
1603  * @pre this method can be called in one of the following stages of the SCIP solving process:
1604  * - \ref SCIP_STAGE_INITSOLVE
1605  * - \ref SCIP_STAGE_SOLVING
1606  */
1607 SCIP_RETCODE SCIPchgRowRhs(
1608  SCIP* scip, /**< SCIP data structure */
1609  SCIP_ROW* row, /**< LP row */
1610  SCIP_Real rhs /**< new right hand side */
1611  )
1612 {
1613  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgRowRhs", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1614 
1615  assert(!SCIPlpDiving(scip->lp) || (row->lppos == -1));
1616 
1617  SCIP_CALL( SCIProwChgRhs(row, scip->mem->probmem, scip->set, scip->eventqueue, scip->lp, rhs) );
1618 
1619  return SCIP_OKAY;
1620 }
1621 
1622 /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
1623  * after all additions were applied, SCIPflushRowExtensions() must be called;
1624  * while the caching of row extensions is activated, information methods of the row give invalid results;
1625  * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase
1626  * the performance
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 in one of the following stages of the SCIP solving process:
1632  * - \ref SCIP_STAGE_INITSOLVE
1633  * - \ref SCIP_STAGE_SOLVING
1634  */
1635 SCIP_RETCODE SCIPcacheRowExtensions(
1636  SCIP* scip, /**< SCIP data structure */
1637  SCIP_ROW* row /**< LP row */
1638  )
1639 {
1640  SCIP_CALL( SCIPcheckStage(scip, "SCIPcacheRowExtensions", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1641 
1642  /* delay the row sorting */
1643  SCIProwDelaySort(row);
1644 
1645  return SCIP_OKAY;
1646 }
1647 
1648 /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with
1649  * equal columns into a single coefficient
1650  *
1651  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1652  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1653  *
1654  * @pre this method can be called in one of the following stages of the SCIP solving process:
1655  * - \ref SCIP_STAGE_INITSOLVE
1656  * - \ref SCIP_STAGE_SOLVING
1657  */
1658 SCIP_RETCODE SCIPflushRowExtensions(
1659  SCIP* scip, /**< SCIP data structure */
1660  SCIP_ROW* row /**< LP row */
1661  )
1662 {
1663  SCIP_CALL( SCIPcheckStage(scip, "SCIPflushRowExtensions", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1664 
1665  /* force the row sorting, and merge equal column entries */
1666  SCIProwForceSort(row, scip->set);
1667 
1668  /* link row to columns */
1669  SCIP_CALL( rowLink(row, scip->mem->probmem, scip->set, scip->eventqueue, scip->lp) );
1670 
1671  return SCIP_OKAY;
1672 }
1673 
1674 /** resolves variable to columns and adds them with the coefficient to the row
1675  *
1676  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1677  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1678  *
1679  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variable will not added.
1680  *
1681  * @pre this method can be called in one of the following stages of the SCIP solving process:
1682  * - \ref SCIP_STAGE_INITSOLVE
1683  * - \ref SCIP_STAGE_SOLVING
1684  *
1685  * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables,
1686  * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP.
1687  * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution
1688  * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but
1689  * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the
1690  * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was
1691  * violated, the linear relaxation might not be violated anymore.)
1692  *
1693  * @note If the variable being added is FIXED (as given by the status SCIP_VARSTATUS_FIXED), then the variable is not
1694  * added to the row, but the corresponding constant is added. Similarly, if the input variable is aggregated (as
1695  * given by the status SCIP_VARSTATUS_AGGREGATED), then the input variable is substituted with its aggregation.
1696  * For other cases, and to better understand the function behavior, please check the code of SCIPvarAddToRow.
1697  *
1698  * @note When several variables are added to a row with the use of this function, performance can be improved by
1699  * calling SCIPcacheRowExtensions() before these additions and SCIPflushRowExtensions() after.
1700  */
1701 SCIP_RETCODE SCIPaddVarToRow(
1702  SCIP* scip, /**< SCIP data structure */
1703  SCIP_ROW* row, /**< LP row */
1704  SCIP_VAR* var, /**< problem variable */
1705  SCIP_Real val /**< value of coefficient */
1706  )
1707 {
1708  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarToRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1709 
1710  SCIP_CALL( SCIPvarAddToRow(var, scip->mem->probmem, scip->set, scip->stat, scip->eventqueue, scip->transprob, scip->lp, row, val) );
1711 
1712  return SCIP_OKAY;
1713 }
1714 
1715 /** resolves variables to columns and adds them with the coefficients to the row;
1716  * this method caches the row extensions and flushes them afterwards to gain better performance
1717  *
1718  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1719  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1720  *
1721  * @attention If a coefficients absolute value is below the SCIP epsilon tolerance, the variable with its value is not added.
1722  *
1723  * @pre this method can be called in one of the following stages of the SCIP solving process:
1724  * - \ref SCIP_STAGE_INITSOLVE
1725  * - \ref SCIP_STAGE_SOLVING
1726  */
1727 SCIP_RETCODE SCIPaddVarsToRow(
1728  SCIP* scip, /**< SCIP data structure */
1729  SCIP_ROW* row, /**< LP row */
1730  int nvars, /**< number of variables to add to the row */
1731  SCIP_VAR** vars, /**< problem variables to add */
1732  SCIP_Real* vals /**< values of coefficients */
1733  )
1734 {
1735  int v;
1736 
1737  assert(nvars == 0 || vars != NULL);
1738  assert(nvars == 0 || vals != NULL);
1739 
1740  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarsToRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1741 
1742  /* resize the row to be able to store all variables (at least, if they are COLUMN variables) */
1743  SCIP_CALL( SCIProwEnsureSize(row, scip->mem->probmem, scip->set, SCIProwGetNNonz(row) + nvars) );
1744 
1745  /* delay the row sorting */
1746  SCIProwDelaySort(row);
1747 
1748  /* add the variables to the row */
1749  for( v = 0; v < nvars; ++v )
1750  {
1751  SCIP_CALL( SCIPvarAddToRow(vars[v], scip->mem->probmem, scip->set, scip->stat, scip->eventqueue, scip->transprob, scip->lp,
1752  row, vals[v]) );
1753  }
1754 
1755  /* force the row sorting */
1756  SCIProwForceSort(row, scip->set);
1757 
1758  return SCIP_OKAY;
1759 }
1760 
1761 /** resolves variables to columns and adds them with the same single coefficient to the row;
1762  * this method caches the row extensions and flushes them afterwards to gain better performance
1763  *
1764  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1765  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1766  *
1767  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variables will not added.
1768  *
1769  * @pre this method can be called in one of the following stages of the SCIP solving process:
1770  * - \ref SCIP_STAGE_INITSOLVE
1771  * - \ref SCIP_STAGE_SOLVING
1772  */
1773 SCIP_RETCODE SCIPaddVarsToRowSameCoef(
1774  SCIP* scip, /**< SCIP data structure */
1775  SCIP_ROW* row, /**< LP row */
1776  int nvars, /**< number of variables to add to the row */
1777  SCIP_VAR** vars, /**< problem variables to add */
1778  SCIP_Real val /**< unique value of all coefficients */
1779  )
1780 {
1781  int v;
1782 
1783  assert(nvars == 0 || vars != NULL);
1784 
1785  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarsToRowSameCoef", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1786 
1787  /* resize the row to be able to store all variables (at least, if they are COLUMN variables) */
1788  SCIP_CALL( SCIProwEnsureSize(row, scip->mem->probmem, scip->set, SCIProwGetNNonz(row) + nvars) );
1789 
1790  /* delay the row sorting */
1791  SCIProwDelaySort(row);
1792 
1793  /* add the variables to the row */
1794  for( v = 0; v < nvars; ++v )
1795  {
1796  SCIP_CALL( SCIPvarAddToRow(vars[v], scip->mem->probmem, scip->set, scip->stat, scip->eventqueue, scip->transprob, scip->lp,
1797  row, val) );
1798  }
1799 
1800  /* force the row sorting */
1801  SCIProwForceSort(row, scip->set);
1802 
1803  return SCIP_OKAY;
1804 }
1805 
1806 /** tries to find a value, such that all row coefficients, if scaled with this value become integral
1807  *
1808  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1809  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1810  *
1811  * @pre this method can be called in one of the following stages of the SCIP solving process:
1812  * - \ref SCIP_STAGE_INITSOLVE
1813  * - \ref SCIP_STAGE_SOLVING
1814  */
1815 SCIP_RETCODE SCIPcalcRowIntegralScalar(
1816  SCIP* scip, /**< SCIP data structure */
1817  SCIP_ROW* row, /**< LP row */
1818  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
1819  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
1820  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
1821  SCIP_Real maxscale, /**< maximal allowed scalar */
1822  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
1823  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
1824  SCIP_Bool* success /**< stores whether returned value is valid */
1825  )
1826 {
1827  SCIP_CALL( SCIPcheckStage(scip, "SCIPcalcRowIntegralScalar", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1828 
1829  SCIP_CALL( SCIProwCalcIntegralScalar(row, scip->set, mindelta, maxdelta, maxdnom, maxscale,
1830  usecontvars, intscalar, success) );
1831 
1832  return SCIP_OKAY;
1833 }
1834 
1835 /** tries to scale row, s.t. all coefficients (of integer variables) become integral
1836  *
1837  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1838  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1839  *
1840  * @pre this method can be called in one of the following stages of the SCIP solving process:
1841  * - \ref SCIP_STAGE_INITSOLVE
1842  * - \ref SCIP_STAGE_SOLVING
1843  */
1844 SCIP_RETCODE SCIPmakeRowIntegral(
1845  SCIP* scip, /**< SCIP data structure */
1846  SCIP_ROW* row, /**< LP row */
1847  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
1848  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
1849  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
1850  SCIP_Real maxscale, /**< maximal value to scale row with */
1851  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
1852  SCIP_Bool* success /**< stores whether row could be made rational */
1853  )
1854 {
1855  SCIP_CALL( SCIPcheckStage(scip, "SCIPmakeRowIntegral", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1856 
1857  SCIP_CALL( SCIProwMakeIntegral(row, scip->mem->probmem, scip->set, scip->eventqueue, scip->stat, scip->lp, mindelta, maxdelta, maxdnom, maxscale,
1858  usecontvars, success) );
1859 
1860  return SCIP_OKAY;
1861 }
1862 
1863 /** marks a row to be not removable from the LP in the current node
1864  *
1865  * @pre this method can be called in the following stage of the SCIP solving process:
1866  * - \ref SCIP_STAGE_SOLVING
1867  */
1868 void SCIPmarkRowNotRemovableLocal(
1869  SCIP* scip, /**< SCIP data structure */
1870  SCIP_ROW* row /**< LP row */
1871  )
1872 {
1873  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPmarkRowNotRemovableLocal", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1874 
1875  SCIProwMarkNotRemovableLocal(row, scip->stat);
1876 }
1877 
1878 /** returns number of integral columns in the row
1879  *
1880  * @return number of integral columns in the row
1881  *
1882  * @pre this method can be called in one of the following stages of the SCIP solving process:
1883  * - \ref SCIP_STAGE_INITSOLVE
1884  * - \ref SCIP_STAGE_SOLVING
1885  */
1886 int SCIPgetRowNumIntCols(
1887  SCIP* scip, /**< SCIP data structure */
1888  SCIP_ROW* row /**< LP row */
1889  )
1890 {
1891  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowNumIntCols", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1892 
1893  return SCIProwGetNumIntCols(row, scip->set);
1894 }
1895 
1896 /** returns minimal absolute value of row vector's non-zero coefficients
1897  *
1898  * @return minimal absolute value of row vector's non-zero coefficients
1899  *
1900  * @pre this method can be called in one of the following stages of the SCIP solving process:
1901  * - \ref SCIP_STAGE_INITSOLVE
1902  * - \ref SCIP_STAGE_SOLVING
1903  */
1904 SCIP_Real SCIPgetRowMinCoef(
1905  SCIP* scip, /**< SCIP data structure */
1906  SCIP_ROW* row /**< LP row */
1907  )
1908 {
1909  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowMinCoef", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1910 
1911  return SCIProwGetMinval(row, scip->set);
1912 }
1913 
1914 /** returns maximal absolute value of row vector's non-zero coefficients
1915  *
1916  * @return maximal absolute value of row vector's non-zero coefficients
1917  *
1918  * @pre this method can be called in one of the following stages of the SCIP solving process:
1919  * - \ref SCIP_STAGE_INITSOLVE
1920  * - \ref SCIP_STAGE_SOLVING
1921  */
1922 SCIP_Real SCIPgetRowMaxCoef(
1923  SCIP* scip, /**< SCIP data structure */
1924  SCIP_ROW* row /**< LP row */
1925  )
1926 {
1927  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowMaxCoef", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1928 
1929  return SCIProwGetMaxval(row, scip->set);
1930 }
1931 
1932 /** returns the minimal activity of a row w.r.t. the column's bounds
1933  *
1934  * @return the minimal activity of a row w.r.t. the column's bounds
1935  *
1936  * @pre this method can be called in one of the following stages of the SCIP solving process:
1937  * - \ref SCIP_STAGE_SOLVING
1938  */
1939 SCIP_Real SCIPgetRowMinActivity(
1940  SCIP* scip, /**< SCIP data structure */
1941  SCIP_ROW* row /**< LP row */
1942  )
1943 {
1944  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowMinActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1945 
1946  return SCIProwGetMinActivity(row, scip->set, scip->stat);
1947 }
1948 
1949 /** returns the maximal activity of a row w.r.t. the column's bounds
1950  *
1951  * @return the maximal activity of a row w.r.t. the column's bounds
1952  *
1953  * @pre this method can be called in one of the following stages of the SCIP solving process:
1954  * - \ref SCIP_STAGE_SOLVING
1955  */
1956 SCIP_Real SCIPgetRowMaxActivity(
1957  SCIP* scip, /**< SCIP data structure */
1958  SCIP_ROW* row /**< LP row */
1959  )
1960 {
1961  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowMaxActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1962 
1963  return SCIProwGetMaxActivity(row, scip->set, scip->stat);
1964 }
1965 
1966 /** recalculates the activity of a row in the last LP solution
1967  *
1968  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1969  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1970  *
1971  * @pre this method can be called in one of the following stages of the SCIP solving process:
1972  * - \ref SCIP_STAGE_SOLVING
1973  */
1974 SCIP_RETCODE SCIPrecalcRowLPActivity(
1975  SCIP* scip, /**< SCIP data structure */
1976  SCIP_ROW* row /**< LP row */
1977  )
1978 {
1979  SCIP_CALL( SCIPcheckStage(scip, "SCIPrecalcRowLPActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1980 
1981  SCIProwRecalcLPActivity(row, scip->stat);
1982 
1983  return SCIP_OKAY;
1984 }
1985 
1986 /** returns the activity of a row in the last LP solution
1987  *
1988  * @return activity of a row in the last LP solution
1989  *
1990  * @pre this method can be called in one of the following stages of the SCIP solving process:
1991  * - \ref SCIP_STAGE_SOLVING
1992  */
1993 SCIP_Real SCIPgetRowLPActivity(
1994  SCIP* scip, /**< SCIP data structure */
1995  SCIP_ROW* row /**< LP row */
1996  )
1997 {
1998  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowLPActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1999 
2000  return SCIProwGetLPActivity(row, scip->set, scip->stat, scip->lp);
2001 }
2002 
2003 /** returns the feasibility of a row in the last LP solution
2004  *
2005  * @return the feasibility of a row in the last LP solution: negative value means infeasibility
2006  *
2007  * @pre this method can be called in one of the following stages of the SCIP solving process:
2008  * - \ref SCIP_STAGE_SOLVING
2009  */
2010 SCIP_Real SCIPgetRowLPFeasibility(
2011  SCIP* scip, /**< SCIP data structure */
2012  SCIP_ROW* row /**< LP row */
2013  )
2014 {
2015  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowLPFeasibility", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2016 
2017  return SCIProwGetLPFeasibility(row, scip->set, scip->stat, scip->lp);
2018 }
2019 
2020 /** recalculates the activity of a row for the current pseudo solution
2021  *
2022  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2023  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2024  *
2025  * @pre this method can be called in one of the following stages of the SCIP solving process:
2026  * - \ref SCIP_STAGE_SOLVING
2027  */
2028 SCIP_RETCODE SCIPrecalcRowPseudoActivity(
2029  SCIP* scip, /**< SCIP data structure */
2030  SCIP_ROW* row /**< LP row */
2031  )
2032 {
2033  SCIP_CALL( SCIPcheckStage(scip, "SCIPrecalcRowPseudoActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2034 
2035  SCIProwRecalcPseudoActivity(row, scip->stat);
2036 
2037  return SCIP_OKAY;
2038 }
2039 
2040 /** returns the activity of a row for the current pseudo solution
2041  *
2042  * @return the activity of a row for the current pseudo solution
2043  *
2044  * @pre this method can be called in one of the following stages of the SCIP solving process:
2045  * - \ref SCIP_STAGE_SOLVING
2046  */
2047 SCIP_Real SCIPgetRowPseudoActivity(
2048  SCIP* scip, /**< SCIP data structure */
2049  SCIP_ROW* row /**< LP row */
2050  )
2051 {
2052  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowPseudoActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2053 
2054  return SCIProwGetPseudoActivity(row, scip->set, scip->stat);
2055 }
2056 
2057 /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
2058  *
2059  * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility
2060  *
2061  * @pre this method can be called in one of the following stages of the SCIP solving process:
2062  * - \ref SCIP_STAGE_SOLVING
2063  */
2064 SCIP_Real SCIPgetRowPseudoFeasibility(
2065  SCIP* scip, /**< SCIP data structure */
2066  SCIP_ROW* row /**< LP row */
2067  )
2068 {
2069  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowPseudoFeasibility", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2070 
2071  return SCIProwGetPseudoFeasibility(row, scip->set, scip->stat);
2072 }
2073 
2074 /** recalculates the activity of a row in the last LP or pseudo solution
2075  *
2076  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2077  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2078  *
2079  * @pre this method can be called in one of the following stages of the SCIP solving process:
2080  * - \ref SCIP_STAGE_SOLVING
2081  */
2082 SCIP_RETCODE SCIPrecalcRowActivity(
2083  SCIP* scip, /**< SCIP data structure */
2084  SCIP_ROW* row /**< LP row */
2085  )
2086 {
2087  SCIP_CALL( SCIPcheckStage(scip, "SCIPrecalcRowActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2088 
2089  if( SCIPtreeHasCurrentNodeLP(scip->tree) )
2090  SCIProwRecalcLPActivity(row, scip->stat);
2091  else
2092  SCIProwRecalcPseudoActivity(row, scip->stat);
2093 
2094  return SCIP_OKAY;
2095 }
2096 
2097 /** returns the activity of a row in the last LP or pseudo solution
2098  *
2099  * @return the activity of a row in the last LP or pseudo solution
2100  *
2101  * @pre this method can be called in one of the following stages of the SCIP solving process:
2102  * - \ref SCIP_STAGE_SOLVING
2103  */
2104 SCIP_Real SCIPgetRowActivity(
2105  SCIP* scip, /**< SCIP data structure */
2106  SCIP_ROW* row /**< LP row */
2107  )
2108 {
2109  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2110 
2111  if( SCIPtreeHasCurrentNodeLP(scip->tree) )
2112  return SCIProwGetLPActivity(row, scip->set, scip->stat, scip->lp);
2113  else
2114  return SCIProwGetPseudoActivity(row, scip->set, scip->stat);
2115 }
2116 
2117 /** returns the feasibility of a row in the last LP or pseudo solution
2118  *
2119  * @return the feasibility of a row in the last LP or pseudo solution
2120  *
2121  * @pre this method can be called in one of the following stages of the SCIP solving process:
2122  * - \ref SCIP_STAGE_SOLVING
2123  */
2124 SCIP_Real SCIPgetRowFeasibility(
2125  SCIP* scip, /**< SCIP data structure */
2126  SCIP_ROW* row /**< LP row */
2127  )
2128 {
2129  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowFeasibility", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2130 
2131  if( SCIPtreeHasCurrentNodeLP(scip->tree) )
2132  return SCIProwGetLPFeasibility(row, scip->set, scip->stat, scip->lp);
2133  else
2134  return SCIProwGetPseudoFeasibility(row, scip->set, scip->stat);
2135 }
2136 
2137 /** returns the activity of a row for the given primal solution
2138  *
2139  * @return the activitiy of a row for the given primal solution
2140  *
2141  * @pre this method can be called in one of the following stages of the SCIP solving process:
2142  * - \ref SCIP_STAGE_SOLVING
2143  */
2144 SCIP_Real SCIPgetRowSolActivity(
2145  SCIP* scip, /**< SCIP data structure */
2146  SCIP_ROW* row, /**< LP row */
2147  SCIP_SOL* sol /**< primal CIP solution */
2148  )
2149 {
2150  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowSolActivity", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE) );
2151 
2152  if( sol != NULL )
2153  return SCIProwGetSolActivity(row, scip->set, scip->stat, sol);
2154  else if( SCIPtreeHasCurrentNodeLP(scip->tree) )
2155  return SCIProwGetLPActivity(row, scip->set, scip->stat, scip->lp);
2156  else
2157  return SCIProwGetPseudoActivity(row, scip->set, scip->stat);
2158 }
2159 
2160 /** returns the feasibility of a row for the given primal solution
2161  *
2162  * @return the feasibility of a row for the given primal solution
2163  *
2164  * @pre this method can be called in one of the following stages of the SCIP solving process:
2165  * - \ref SCIP_STAGE_SOLVING
2166  */
2167 SCIP_Real SCIPgetRowSolFeasibility(
2168  SCIP* scip, /**< SCIP data structure */
2169  SCIP_ROW* row, /**< LP row */
2170  SCIP_SOL* sol /**< primal CIP solution */
2171  )
2172 {
2173  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowSolFeasibility", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2174 
2175  if( sol != NULL )
2176  return SCIProwGetSolFeasibility(row, scip->set, scip->stat, sol);
2177  else if( SCIPtreeHasCurrentNodeLP(scip->tree) )
2178  return SCIProwGetLPFeasibility(row, scip->set, scip->stat, scip->lp);
2179  else
2180  return SCIProwGetPseudoFeasibility(row, scip->set, scip->stat);
2181 }
2182 
2183 /** returns the parallelism of row with objective function
2184  *
2185  * @return 1 is returned if the row is parallel to the objective function and 0 if it is orthogonal
2186  *
2187  * @pre this method can be called in one of the following stages of the SCIP solving process:
2188  * - \ref SCIP_STAGE_SOLVING
2189  */
2190 SCIP_Real SCIPgetRowObjParallelism(
2191  SCIP* scip, /**< SCIP data structure */
2192  SCIP_ROW* row /**< LP row */
2193  )
2194 {
2195  assert(row != NULL);
2196 
2197  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetRowObjParallelism", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2198 
2199  return SCIProwGetObjParallelism(row, scip->set, scip->lp);
2200 }
2201 
2202 /** output row to file stream via the message handler system
2203  *
2204  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2205  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2206  *
2207  * @pre this method can be called in one of the following stages of the SCIP solving process:
2208  * - \ref SCIP_STAGE_SOLVING
2209  * - \ref SCIP_STAGE_SOLVED
2210  * - \ref SCIP_STAGE_EXITSOLVE
2211  */
2212 SCIP_RETCODE SCIPprintRow(
2213  SCIP* scip, /**< SCIP data structure */
2214  SCIP_ROW* row, /**< LP row */
2215  FILE* file /**< output file (or NULL for standard output) */
2216  )
2217 {
2218  assert(row != NULL);
2219 
2220  SCIP_CALL( SCIPcheckStage(scip, "SCIPprintRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE) );
2221 
2222  SCIProwPrint(row, scip->messagehdlr, file);
2223 
2224  return SCIP_OKAY;
2225 }
2226 
2227 /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
2228  *
2229  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2230  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2231  *
2232  * @pre This method can be called if @p scip is in one of the following stages:
2233  * - \ref SCIP_STAGE_SOLVING
2234  *
2235  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2236  *
2237  * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware
2238  * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from
2239  * numerical troubles during the last LP solve; because of this, most users will want to call this method only if
2240  * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL
2241  */
2242 SCIP_RETCODE SCIPstartDive(
2243  SCIP* scip /**< SCIP data structure */
2244  )
2245 {
2246  assert(scip != NULL);
2247 
2248  SCIP_CALL( SCIPcheckStage(scip, "SCIPstartDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2249  assert(SCIPnodeGetType(SCIPgetCurrentNode(scip)) == SCIP_NODETYPE_FOCUSNODE);
2250 
2251  if( SCIPlpDiving(scip->lp) )
2252  {
2253  SCIPerrorMessage("already in diving mode\n");
2254  return SCIP_INVALIDCALL;
2255  }
2256 
2257  if( SCIPtreeProbing(scip->tree) )
2258  {
2259  SCIPerrorMessage("cannot start diving while being in probing mode\n");
2260  return SCIP_INVALIDCALL;
2261  }
2262 
2263  if( !SCIPtreeIsFocusNodeLPConstructed(scip->tree) )
2264  {
2265  SCIPerrorMessage("cannot start diving if LP has not been constructed\n");
2266  return SCIP_INVALIDCALL;
2267  }
2268  assert(SCIPtreeHasCurrentNodeLP(scip->tree));
2269 
2270  SCIP_CALL( SCIPlpStartDive(scip->lp, scip->mem->probmem, scip->set, scip->stat) );
2271 
2272  /* remember the relaxation solution to reset it later */
2273  if( SCIPisRelaxSolValid(scip) )
2274  {
2275  SCIP_CALL( SCIPtreeStoreRelaxSol(scip->tree, scip->set, scip->relaxation, scip->transprob) );
2276  }
2277 
2278  return SCIP_OKAY;
2279 }
2280 
2281 /** quits LP diving and resets bounds and objective values of columns to the current node's values
2282  *
2283  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2284  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2285  *
2286  * @pre This method can be called if @p scip is in one of the following stages:
2287  * - \ref SCIP_STAGE_SOLVING
2288  *
2289  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2290  */
2291 SCIP_RETCODE SCIPendDive(
2292  SCIP* scip /**< SCIP data structure */
2293  )
2294 {
2295  assert(scip != NULL);
2296 
2297  SCIP_CALL( SCIPcheckStage(scip, "SCIPendDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2298 
2299  if( !SCIPlpDiving(scip->lp) )
2300  {
2301  SCIPerrorMessage("not in diving mode\n");
2302  return SCIP_INVALIDCALL;
2303  }
2304 
2305  /* unmark the diving flag in the LP and reset all variables' objective and bound values */
2306  SCIP_CALL( SCIPlpEndDive(scip->lp, scip->mem->probmem, scip->set, scip->messagehdlr, scip->stat, scip->eventqueue, scip->eventfilter,
2307  scip->transprob, scip->transprob->vars, scip->transprob->nvars) );
2308 
2309  /* the lower bound may have changed slightly due to LP resolve in SCIPlpEndDive() */
2310  if( !scip->lp->resolvelperror && scip->tree->focusnode != NULL && SCIPlpIsRelax(scip->lp) && SCIPlpIsSolved(scip->lp) )
2311  {
2312  assert(SCIPtreeIsFocusNodeLPConstructed(scip->tree));
2313  SCIP_CALL( SCIPnodeUpdateLowerboundLP(scip->tree->focusnode, scip->set, scip->stat, scip->tree, scip->transprob,
2314  scip->origprob, scip->lp) );
2315  }
2316  /* reset the probably changed LP's cutoff bound */
2317  SCIP_CALL( SCIPlpSetCutoffbound(scip->lp, scip->set, scip->transprob, scip->primal->cutoffbound) );
2318  assert(scip->lp->cutoffbound == scip->primal->cutoffbound); /*lint !e777*/
2319 
2320  /* if a new best solution was created, the cutoff of the tree was delayed due to diving;
2321  * the cutoff has to be done now.
2322  */
2323  if( scip->tree->cutoffdelayed )
2324  {
2325  SCIP_CALL( SCIPtreeCutoff(scip->tree, scip->reopt, scip->mem->probmem, scip->set, scip->stat, scip->eventfilter,
2326  scip->eventqueue, scip->lp, scip->primal->cutoffbound) );
2327  }
2328 
2329  /* if a relaxation was stored before diving, restore it now */
2330  if( scip->tree->probdiverelaxstored )
2331  {
2332  SCIP_CALL( SCIPtreeRestoreRelaxSol(scip->tree, scip->set, scip->relaxation, scip->transprob) );
2333  }
2334 
2335  return SCIP_OKAY;
2336 }
2337 
2338 /** changes cutoffbound in current dive
2339  *
2340  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2341  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2342  *
2343  * @pre This method can be called if @p scip is in one of the following stages:
2344  * - \ref SCIP_STAGE_SOLVING
2345  *
2346  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2347  */
2348 SCIP_RETCODE SCIPchgCutoffboundDive(
2349  SCIP* scip, /**< SCIP data structure */
2350  SCIP_Real newcutoffbound /**< new cutoffbound */
2351  )
2352 {
2353  assert(scip != NULL);
2354 
2355  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgCutoffboundDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2356 
2357  if( !SCIPlpDiving(scip->lp) )
2358  {
2359  SCIPerrorMessage("not in diving mode\n");
2360  return SCIP_INVALIDCALL;
2361  }
2362 
2363  SCIP_CALL( SCIPlpSetCutoffbound(scip->lp, scip->set, scip->transprob, newcutoffbound) );
2364 
2365  return SCIP_OKAY;
2366 }
2367 
2368 /** changes variable's objective value in current dive
2369  *
2370  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2371  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2372  *
2373  * @pre This method can be called if @p scip is in one of the following stages:
2374  * - \ref SCIP_STAGE_SOLVING
2375  *
2376  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2377  */
2378 SCIP_RETCODE SCIPchgVarObjDive(
2379  SCIP* scip, /**< SCIP data structure */
2380  SCIP_VAR* var, /**< variable to change the objective value for */
2381  SCIP_Real newobj /**< new objective value */
2382  )
2383 {
2384  assert(scip != NULL);
2385  assert(var != NULL);
2386 
2387  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarObjDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2388 
2389  if( !SCIPlpDiving(scip->lp) )
2390  {
2391  SCIPerrorMessage("not in diving mode\n");
2392  return SCIP_INVALIDCALL;
2393  }
2394 
2395  /* invalidate the LP's cutoff bound, since this has nothing to do with the current objective value anymore;
2396  * the cutoff bound is reset in SCIPendDive()
2397  */
2398  SCIP_CALL( SCIPlpSetCutoffbound(scip->lp, scip->set, scip->transprob, SCIPsetInfinity(scip->set)) );
2399 
2400  /* mark the LP's objective function invalid */
2401  SCIPlpMarkDivingObjChanged(scip->lp);
2402 
2403  /* change the objective value of the variable in the diving LP */
2404  SCIP_CALL( SCIPvarChgObjDive(var, scip->set, scip->lp, newobj) );
2405 
2406  return SCIP_OKAY;
2407 }
2408 
2409 /** changes variable's lower bound in current dive
2410  *
2411  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2412  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2413  *
2414  * @pre This method can be called if @p scip is in one of the following stages:
2415  * - \ref SCIP_STAGE_SOLVING
2416  *
2417  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2418  */
2419 SCIP_RETCODE SCIPchgVarLbDive(
2420  SCIP* scip, /**< SCIP data structure */
2421  SCIP_VAR* var, /**< variable to change the bound for */
2422  SCIP_Real newbound /**< new value for bound */
2423  )
2424 {
2425  assert(scip != NULL);
2426  assert(var != NULL);
2427 
2428  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarLbDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2429 
2430  if( !SCIPlpDiving(scip->lp) )
2431  {
2432  SCIPerrorMessage("not in diving mode\n");
2433  return SCIP_INVALIDCALL;
2434  }
2435 
2436  SCIP_CALL( SCIPvarChgLbDive(var, scip->set, scip->lp, newbound) );
2437 
2438  return SCIP_OKAY;
2439 }
2440 
2441 /** changes variable's upper bound in current dive
2442  *
2443  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2444  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2445  *
2446  * @pre This method can be called if @p scip is in one of the following stages:
2447  * - \ref SCIP_STAGE_SOLVING
2448  *
2449  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2450  */
2451 SCIP_RETCODE SCIPchgVarUbDive(
2452  SCIP* scip, /**< SCIP data structure */
2453  SCIP_VAR* var, /**< variable to change the bound for */
2454  SCIP_Real newbound /**< new value for bound */
2455  )
2456 {
2457  assert(scip != NULL);
2458  assert(var != NULL);
2459 
2460  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgVarUbDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2461 
2462  if( !SCIPlpDiving(scip->lp) )
2463  {
2464  SCIPerrorMessage("not in diving mode\n");
2465  return SCIP_INVALIDCALL;
2466  }
2467 
2468  SCIP_CALL( SCIPvarChgUbDive(var, scip->set, scip->lp, newbound) );
2469 
2470  return SCIP_OKAY;
2471 }
2472 
2473 /** adds a row to the LP in current dive
2474  *
2475  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2476  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2477  *
2478  * @pre This method can be called if @p scip is in one of the following stages:
2479  * - \ref SCIP_STAGE_SOLVING
2480  *
2481  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2482  */
2483 SCIP_RETCODE SCIPaddRowDive(
2484  SCIP* scip, /**< SCIP data structure */
2485  SCIP_ROW* row /**< row to be added */
2486  )
2487 {
2488  SCIP_NODE* node;
2489  int depth;
2490 
2491  assert(scip != NULL);
2492  assert(row != NULL);
2493 
2494  SCIP_CALL( SCIPcheckStage(scip, "SCIPaddRowDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2495 
2496  if( !SCIPlpDiving(scip->lp) )
2497  {
2498  SCIPerrorMessage("not in diving mode\n");
2499  return SCIP_INVALIDCALL;
2500  }
2501 
2502  /* get depth of current node */
2503  node = SCIPtreeGetCurrentNode(scip->tree);
2504  assert(node != NULL);
2505  depth = SCIPnodeGetDepth(node);
2506 
2507  SCIP_CALL( SCIPlpAddRow(scip->lp, scip->mem->probmem, scip->set, scip->eventqueue, scip->eventfilter, row, depth) );
2508 
2509  return SCIP_OKAY;
2510 }
2511 
2512 /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
2513  *
2514  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2515  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2516  *
2517  * @pre This method can be called if @p scip is in one of the following stages:
2518  * - \ref SCIP_STAGE_SOLVING
2519  *
2520  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2521  */
2522 SCIP_RETCODE SCIPchgRowLhsDive(
2523  SCIP* scip, /**< SCIP data structure */
2524  SCIP_ROW* row, /**< row to change the lhs for */
2525  SCIP_Real newlhs /**< new value for lhs */
2526  )
2527 {
2528  assert(scip != NULL);
2529  assert(row != NULL);
2530 
2531  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgRowLhsDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2532 
2533  if( !SCIPlpDiving(scip->lp) )
2534  {
2535  SCIPerrorMessage("not in diving mode\n");
2536  return SCIP_INVALIDCALL;
2537  }
2538 
2539  SCIP_CALL( SCIPlpRecordOldRowSideDive(scip->lp, row, SCIP_SIDETYPE_LEFT) );
2540  SCIP_CALL( SCIProwChgLhs(row, scip->mem->probmem, scip->set, scip->eventqueue, scip->lp, newlhs) );
2541 
2542  return SCIP_OKAY;
2543 }
2544 
2545 /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
2546  *
2547  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2548  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2549  *
2550  * @pre This method can be called if @p scip is in one of the following stages:
2551  * - \ref SCIP_STAGE_SOLVING
2552  *
2553  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2554  */
2555 SCIP_RETCODE SCIPchgRowRhsDive(
2556  SCIP* scip, /**< SCIP data structure */
2557  SCIP_ROW* row, /**< row to change the lhs for */
2558  SCIP_Real newrhs /**< new value for rhs */
2559  )
2560 {
2561  assert(scip != NULL);
2562  assert(row != NULL);
2563 
2564  SCIP_CALL( SCIPcheckStage(scip, "SCIPchgRowRhsDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2565 
2566  if( !SCIPlpDiving(scip->lp) )
2567  {
2568  SCIPerrorMessage("not in diving mode\n");
2569  return SCIP_INVALIDCALL;
2570  }
2571 
2572  SCIP_CALL( SCIPlpRecordOldRowSideDive(scip->lp, row, SCIP_SIDETYPE_RIGHT) );
2573  SCIP_CALL( SCIProwChgRhs(row, scip->mem->probmem, scip->set, scip->eventqueue, scip->lp, newrhs) );
2574 
2575  return SCIP_OKAY;
2576 }
2577 
2578 /** gets variable's objective value in current dive
2579  *
2580  * @return the variable's objective value in current dive.
2581  *
2582  * @pre This method can be called if @p scip is in one of the following stages:
2583  * - \ref SCIP_STAGE_SOLVING
2584  *
2585  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2586  */
2587 SCIP_Real SCIPgetVarObjDive(
2588  SCIP* scip, /**< SCIP data structure */
2589  SCIP_VAR* var /**< variable to get the bound for */
2590  )
2591 {
2592  assert(scip != NULL);
2593  assert(var != NULL);
2594 
2595  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarObjDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2596 
2597  if( !SCIPlpDiving(scip->lp) )
2598  {
2599  SCIPerrorMessage("not in diving mode\n");
2600  SCIPABORT();
2601  return SCIP_INVALID; /*lint !e527*/
2602  }
2603 
2604  return SCIPvarGetObjLP(var);
2605 }
2606 
2607 /** gets variable's lower bound in current dive
2608  *
2609  * @return the variable's lower bound in current dive.
2610  *
2611  * @pre This method can be called if @p scip is in one of the following stages:
2612  * - \ref SCIP_STAGE_SOLVING
2613  *
2614  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2615  */
2616 SCIP_Real SCIPgetVarLbDive(
2617  SCIP* scip, /**< SCIP data structure */
2618  SCIP_VAR* var /**< variable to get the bound for */
2619  )
2620 {
2621  assert(scip != NULL);
2622  assert(var != NULL);
2623 
2624  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarLbDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2625 
2626  if( !SCIPlpDiving(scip->lp) )
2627  {
2628  SCIPerrorMessage("not in diving mode\n");
2629  SCIPABORT();
2630  return SCIP_INVALID; /*lint !e527*/
2631  }
2632 
2633  return SCIPvarGetLbLP(var, scip->set);
2634 }
2635 
2636 /** gets variable's upper bound in current dive
2637  *
2638  * @return the variable's upper bound in current dive.
2639  *
2640  * @pre This method can be called if @p scip is in one of the following stages:
2641  * - \ref SCIP_STAGE_SOLVING
2642  *
2643  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2644  */
2645 SCIP_Real SCIPgetVarUbDive(
2646  SCIP* scip, /**< SCIP data structure */
2647  SCIP_VAR* var /**< variable to get the bound for */
2648  )
2649 {
2650  assert(scip != NULL);
2651  assert(var != NULL);
2652 
2653  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetVarUbDive", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2654 
2655  if( !SCIPlpDiving(scip->lp) )
2656  {
2657  SCIPerrorMessage("not in diving mode\n");
2658  SCIPABORT();
2659  return SCIP_INVALID; /*lint !e527*/
2660  }
2661 
2662  return SCIPvarGetUbLP(var, scip->set);
2663 }
2664 
2665 /** solves the LP of the current dive; no separation or pricing is applied
2666  *
2667  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2668  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2669  *
2670  * @pre This method can be called if @p scip is in one of the following stages:
2671  * - \ref SCIP_STAGE_SOLVING
2672  *
2673  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2674  *
2675  * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL,
2676  * compare the explanation of SCIPstartDive()
2677  */
2678 SCIP_RETCODE SCIPsolveDiveLP(
2679  SCIP* scip, /**< SCIP data structure */
2680  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
2681  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
2682  SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective
2683  * limit was reached (or NULL, if not needed) */
2684  )
2685 {
2686  assert(scip != NULL);
2687 
2688  SCIP_CALL( SCIPcheckStage(scip, "SCIPsolveDiveLP", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2689 
2690  if( !SCIPlpDiving(scip->lp) )
2691  {
2692  SCIPerrorMessage("not in diving mode\n");
2693  return SCIP_INVALIDCALL;
2694  }
2695 
2696  if( cutoff != NULL )
2697  *cutoff = FALSE;
2698 
2699  /* solve diving LP */
2700  SCIP_CALL( SCIPlpSolveAndEval(scip->lp, scip->set, scip->messagehdlr, scip->mem->probmem, scip->stat,
2701  scip->eventqueue, scip->eventfilter, scip->transprob, (SCIP_Longint)itlim, FALSE, FALSE, FALSE, lperror) );
2702 
2703  /* the LP is infeasible or the objective limit was reached */
2704  if( SCIPlpGetSolstat(scip->lp) == SCIP_LPSOLSTAT_INFEASIBLE || SCIPlpGetSolstat(scip->lp) == SCIP_LPSOLSTAT_OBJLIMIT
2705  || (SCIPlpGetSolstat(scip->lp) == SCIP_LPSOLSTAT_OPTIMAL &&
2706  SCIPisGE(scip, SCIPgetLPObjval(scip), SCIPgetCutoffbound(scip))) )
2707  {
2708  /* analyze the infeasible LP (only if the objective was not changed, all columns are in the LP, and no external
2709  * pricers exist) */
2710  if( !scip->set->misc_exactsolve && !(SCIPlpDivingObjChanged(scip->lp) || SCIPlpDivingRowsChanged(scip->lp))
2711  && SCIPprobAllColsInLP(scip->transprob, scip->set, scip->lp) )
2712  {
2713  SCIP_CALL( SCIPconflictAnalyzeLP(scip->conflict, scip->conflictstore, scip->mem->probmem, scip->set, scip->stat, scip->transprob,
2714  scip->origprob, scip->tree, scip->reopt, scip->lp, scip->branchcand, scip->eventqueue, scip->cliquetable, NULL) );
2715  }
2716 
2717  if( cutoff != NULL )
2718  *cutoff = TRUE;
2719  }
2720 
2721  return SCIP_OKAY;
2722 }
2723 
2724 /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving
2725  * or probing mode
2726  *
2727  * @return the number of the node in the current branch and bound run, where the last LP was solved in diving
2728  * or probing mode.
2729  *
2730  * @pre This method can be called if @p scip is in one of the following stages:
2731  * - \ref SCIP_STAGE_TRANSFORMING
2732  * - \ref SCIP_STAGE_TRANSFORMED
2733  * - \ref SCIP_STAGE_INITPRESOLVE
2734  * - \ref SCIP_STAGE_PRESOLVING
2735  * - \ref SCIP_STAGE_EXITPRESOLVE
2736  * - \ref SCIP_STAGE_PRESOLVED
2737  * - \ref SCIP_STAGE_INITSOLVE
2738  * - \ref SCIP_STAGE_SOLVING
2739  * - \ref SCIP_STAGE_SOLVED
2740  * - \ref SCIP_STAGE_EXITSOLVE
2741  * - \ref SCIP_STAGE_FREETRANS
2742  *
2743  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2744  */
2745 SCIP_Longint SCIPgetLastDivenode(
2746  SCIP* scip /**< SCIP data structure */
2747  )
2748 {
2749  assert(scip != NULL);
2750 
2751  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPgetLastDivenode", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2752 
2753  return scip->stat->lastdivenode;
2754 }
2755 
2756 /** returns whether we are in diving mode
2757  *
2758  * @return whether we are in diving mode.
2759  *
2760  * @pre This method can be called if @p scip is in one of the following stages:
2761  * - \ref SCIP_STAGE_TRANSFORMING
2762  * - \ref SCIP_STAGE_TRANSFORMED
2763  * - \ref SCIP_STAGE_INITPRESOLVE
2764  * - \ref SCIP_STAGE_PRESOLVING
2765  * - \ref SCIP_STAGE_EXITPRESOLVE
2766  * - \ref SCIP_STAGE_PRESOLVED
2767  * - \ref SCIP_STAGE_INITSOLVE
2768  * - \ref SCIP_STAGE_SOLVING
2769  * - \ref SCIP_STAGE_SOLVED
2770  * - \ref SCIP_STAGE_EXITSOLVE
2771  * - \ref SCIP_STAGE_FREETRANS
2772  *
2773  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
2774  */
2775 SCIP_Bool SCIPinDive(
2776  SCIP* scip /**< SCIP data structure */
2777  )
2778 {
2779  assert(scip != NULL);
2780 
2781  SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPinDive", FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
2782 
2783  return SCIPlpDiving(scip->lp);
2784 }
2785 
2786 /** computes two measures for dual degeneracy (dual degeneracy rate and variable-constraint ratio)
2787  * based on the changes applied when reducing the problem to the optimal face
2788  *
2789  * returns the dual degeneracy rate, i.e., the share of nonbasic variables with reduced cost 0
2790  * and the variable-constraint ratio, i.e., the number of unfixed variables in relation to the basis size
2791  */
2792 SCIP_RETCODE SCIPgetLPDualDegeneracy(
2793  SCIP* scip, /**< SCIP data structure */
2794  SCIP_Real* degeneracy, /**< pointer to store the dual degeneracy rate */
2795  SCIP_Real* varconsratio /**< pointer to store the variable-constraint ratio */
2796  )
2797 {
2798  assert(scip != NULL);
2799  assert(degeneracy != NULL);
2800  assert(varconsratio != NULL);
2801 
2802  SCIP_CALL( SCIPcheckStage(scip, "SCIPgetLPDualDegeneracy", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE) );
2803 
2804  SCIP_CALL( SCIPlpGetDualDegeneracy(scip->lp, scip->set, scip->stat, degeneracy, varconsratio) );
2805 
2806  return SCIP_OKAY;
2807 }
SCIP_Primal::cutoffbound
SCIP_Real cutoffbound
Definition: struct_primal.h:55
Scip::stat
SCIP_STAT * stat
Definition: struct_scip.h:80
SCIPaddVarsToRowSameCoef
SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)
Definition: scip_lp.c:1773
SCIP_ROWORIGINTYPE_CONS
Definition: type_lp.h:74
SCIPgetLPRows
SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
Definition: scip_lp.c:605
SCIPcreateRowSepa
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:1293
SCIPcreateEmptyRow
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:1513
SCIPcolMarkNotRemovableLocal
void SCIPcolMarkNotRemovableLocal(SCIP_COL *col, SCIP_STAT *stat)
Definition: lp.c:4751
SCIProwGetSolFeasibility
SCIP_Real SCIProwGetSolFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6508
SCIPcreateEmptyRowCons
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:1422
SCIPlpResetFeastol
void SCIPlpResetFeastol(SCIP_LP *lp, SCIP_SET *set)
Definition: lp.c:10281
SCIPconflictAnalyzeLP
SCIP_RETCODE SCIPconflictAnalyzeLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)
Definition: conflict_general.c:2511
SCIPgetLPBInvRow
SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:714
NULL
#define NULL
Definition: def.h:267
SCIPlpDivingRowsChanged
SCIP_Bool SCIPlpDivingRowsChanged(SCIP_LP *lp)
Definition: lp.c:17889
SCIPcomputeLPRelIntPoint
SCIP_RETCODE SCIPcomputeLPRelIntPoint(SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)
Definition: scip_lp.c:1094
SCIPcacheRowExtensions
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1635
SCIPlpDiving
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
Definition: lp.c:17847
SCIPgetCurrentNode
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition: scip_tree.c:91
pub_tree.h
public methods for branch and bound tree
tree.h
internal methods for branch and bound tree
Scip::conflict
SCIP_CONFLICT * conflict
Definition: struct_scip.h:97
SCIPcreateEmptyRowUnspec
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:1482
SCIPrecalcRowLPActivity
SCIP_RETCODE SCIPrecalcRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1974
SCIProwGetMinval
SCIP_Real SCIProwGetMinval(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6687
SCIPsetLPFeastol
void SCIPsetLPFeastol(SCIP *scip, SCIP_Real newfeastol)
Definition: scip_lp.c:438
SCIPlpComputeRelIntPoint
SCIP_RETCODE SCIPlpComputeRelIntPoint(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_LP *lp, SCIP_PROB *prob, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_Real *point, SCIP_Bool *success)
Definition: lp.c:18603
scip_mem.h
public methods for memory management
SCIPlpGetBInvCol
SCIP_RETCODE SCIPlpGetBInvCol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9872
SCIPgetCutoffbound
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
Definition: scip_solvingstats.c:1584
SCIPwriteLP
SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
Definition: scip_lp.c:901
SCIPflushRowExtensions
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1658
SCIProwGetPseudoActivity
SCIP_Real SCIProwGetPseudoActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6422
SCIPcreateRowUnspec
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:1327
SCIProwRecalcLPActivity
void SCIProwRecalcLPActivity(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:6172
SCIPlpInterrupt
SCIP_RETCODE SCIPlpInterrupt(SCIP_LP *lp, SCIP_Bool interrupt)
Definition: lp.c:10117
SCIPcreateRowCons
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:1259
SCIPaddVarToRow
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
Definition: scip_lp.c:1701
SCIProwGetNNonz
int SCIProwGetNNonz(SCIP_ROW *row)
Definition: lp.c:17213
SCIPgetRowPseudoFeasibility
SCIP_Real SCIPgetRowPseudoFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2064
SCIPgetLPDualDegeneracy
SCIP_RETCODE SCIPgetLPDualDegeneracy(SCIP *scip, SCIP_Real *degeneracy, SCIP_Real *varconsratio)
Definition: scip_lp.c:2792
SCIPgetColRedcost
SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1154
SCIPisGE
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:497
SCIProwCapture
void SCIProwCapture(SCIP_ROW *row)
Definition: lp.c:5339
Scip::eventqueue
SCIP_EVENTQUEUE * eventqueue
Definition: struct_scip.h:90
Scip::primal
SCIP_PRIMAL * primal
Definition: struct_scip.h:95
SCIP_Var
Definition: struct_var.h:207
lpi.h
interface methods for specific LP solvers
SCIPconstructCurrentLP
SCIP_RETCODE SCIPconstructCurrentLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool newinitconss, SCIP_Bool *cutoff)
Definition: solve.c:1285
SCIPsetInfinity
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
Definition: set.c:6146
SCIPaddRowDive
SCIP_RETCODE SCIPaddRowDive(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2483
SCIPgetLPI
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip_lp.c:985
SCIPlpGetGlobalPseudoObjval
SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13270
SCIProwEnsureSize
SCIP_RETCODE SCIProwEnsureSize(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
Definition: lp.c:629
SCIPvarGetLbLP
SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:12933
Scip::branchcand
SCIP_BRANCHCAND * branchcand
Definition: struct_scip.h:91
SCIP_ROWORIGINTYPE_CONSHDLR
Definition: type_lp.h:73
SCIP_Tree::probdiverelaxstored
SCIP_Bool probdiverelaxstored
Definition: struct_tree.h:251
FALSE
#define FALSE
Definition: def.h:94
SCIPlpWrite
SCIP_RETCODE SCIPlpWrite(SCIP_LP *lp, const char *fname)
Definition: lp.c:16527
SCIPlpIsSolBasic
SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)
Definition: lp.c:17837
SCIP_Prob::objoffset
SCIP_Real objoffset
Definition: struct_prob.h:50
SCIP_Set::stage
SCIP_STAGE stage
Definition: struct_set.h:75
TRUE
#define TRUE
Definition: def.h:93
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_LPSOLQUALITY_ESTIMCONDITION
Definition: type_lpi.h:101
SCIPlpGetRootColumnObjval
SCIP_Real SCIPlpGetRootColumnObjval(SCIP_LP *lp)
Definition: lp.c:17752
SCIPchgVarLbDive
SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_lp.c:2419
SCIPgetLPBInvCol
SCIP_RETCODE SCIPgetLPBInvCol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:749
SCIPgetLPFeastol
SCIP_Real SCIPgetLPFeastol(SCIP *scip)
Definition: scip_lp.c:428
SCIPvarChgLbDive
SCIP_RETCODE SCIPvarChgLbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
Definition: var.c:8250
SCIPlpEndDive
SCIP_RETCODE SCIPlpEndDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_VAR **vars, int nvars)
Definition: lp.c:16109
SCIProwMakeIntegral
SCIP_RETCODE SCIProwMakeIntegral(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)
Definition: lp.c:5981
SCIPlpSolveAndEval
SCIP_RETCODE SCIPlpSolveAndEval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_Longint itlim, SCIP_Bool limitresolveiters, SCIP_Bool aging, SCIP_Bool keepsol, SCIP_Bool *lperror)
Definition: lp.c:12413
SCIP_SIDETYPE_LEFT
Definition: type_lp.h:64
SCIPlpGetRows
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
Definition: lp.c:17612
SCIPrecalcRowActivity
SCIP_RETCODE SCIPrecalcRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2082
SCIPlpGetPseudoObjval
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13302
SCIPlpiGetRealSolQuality
SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)
Definition: lpi_clp.cpp:2940
Scip::transprob
SCIP_PROB * transprob
Definition: struct_scip.h:99
SCIPcreateRow
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:1361
SCIPisLPDualReliable
SCIP_Bool SCIPisLPDualReliable(SCIP *scip)
Definition: scip_lp.c:207
SCIP_Sepa
Definition: struct_sepa.h:46
SCIPnodeGetDepth
int SCIPnodeGetDepth(SCIP_NODE *node)
Definition: tree.c:7500
SCIPconstructLP
SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_lp.c:124
SCIPfreeBufferArray
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:136
SCIP_LPSOLSTAT
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:51
SCIPgetLPColsData
SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
Definition: scip_lp.c:471
SCIP_LPSOLSTAT_OBJLIMIT
Definition: type_lp.h:46
scip_var.h
public methods for SCIP variables
SCIPisRootLPRelax
SCIP_Bool SCIPisRootLPRelax(SCIP *scip)
Definition: scip_lp.c:351
SCIPlpGetSolstat
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
Definition: lp.c:13103
SCIP_ROWORIGINTYPE_SEPA
Definition: type_lp.h:75
lp.h
internal methods for LP management
Scip::origprob
SCIP_PROB * origprob
Definition: struct_scip.h:81
SCIPtreeIsFocusNodeLPConstructed
SCIP_Bool SCIPtreeIsFocusNodeLPConstructed(SCIP_TREE *tree)
Definition: tree.c:8413
SCIP_Node
Definition: struct_tree.h:141
SCIPgetRowFeasibility
SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2124
SCIPlpIsRootLPRelax
SCIP_Bool SCIPlpIsRootLPRelax(SCIP_LP *lp)
Definition: lp.c:17730
SCIPlpRecordOldRowSideDive
SCIP_RETCODE SCIPlpRecordOldRowSideDive(SCIP_LP *lp, SCIP_ROW *row, SCIP_SIDETYPE sidetype)
Definition: lp.c:16291
SCIPgetRowMaxCoef
SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1922
SCIPgetRowMaxActivity
SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1956
scip_numerics.h
public methods for numerical tolerances
SCIPlpGetNCols
int SCIPlpGetNCols(SCIP_LP *lp)
Definition: lp.c:17575
SCIPvarGetUbLP
SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)
Definition: var.c:13003
SCIP_Col
Definition: struct_lp.h:135
scip_solvingstats.h
public methods for querying solving statistics
SCIP_Sol
Definition: struct_sol.h:73
Scip::pricestore
SCIP_PRICESTORE * pricestore
Definition: struct_scip.h:102
scip_tree.h
public methods for the branch-and-bound tree
SCIP_Prob::nvars
int nvars
Definition: struct_prob.h:71
SCIPisLPConstructed
SCIP_Bool SCIPisLPConstructed(SCIP *scip)
Definition: scip_lp.c:101
SCIPisLPRelax
SCIP_Bool SCIPisLPRelax(SCIP *scip)
Definition: scip_lp.c:225
SCIPlpGetRootObjval
SCIP_Real SCIPlpGetRootObjval(SCIP_LP *lp)
Definition: lp.c:17740
SCIPisLPSolBasic
SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
Definition: scip_lp.c:667
SCIP_Row::lppos
int lppos
Definition: struct_lp.h:239
SCIProwForceSort
void SCIProwForceSort(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6159
SCIPvarGetObjLP
SCIP_Real SCIPvarGetObjLP(SCIP_VAR *var)
Definition: var.c:12887
Scip::mem
SCIP_MEM * mem
Definition: struct_scip.h:72
SCIPchgRowLhsDive
SCIP_RETCODE SCIPchgRowLhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)
Definition: scip_lp.c:2522
SCIPtreeProbing
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
Definition: tree.c:8332
SCIPgetLPLooseObjval
SCIP_Real SCIPgetLPLooseObjval(SCIP *scip)
Definition: scip_lp.c:283
SCIPgetVarUbDive
SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2645
SCIP_RealArray
Definition: struct_misc.h:157
SCIPlpStartDive
SCIP_RETCODE SCIPlpStartDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:16003
SCIPmarkRowNotRemovableLocal
void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1868
SCIProwChgLhs
SCIP_RETCODE SCIProwChgLhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real lhs)
Definition: lp.c:5666
SCIP_LPSOLQUALITY_EXACTCONDITION
Definition: type_lpi.h:102
SCIPlpFlush
SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue)
Definition: lp.c:8671
SCIPlpWriteMip
SCIP_RETCODE SCIPlpWriteMip(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *fname, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, SCIP_Bool lazyconss)
Definition: lp.c:16542
SCIPgetRowMinCoef
SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1904
SCIPlpIsPrimalReliable
SCIP_Bool SCIPlpIsPrimalReliable(SCIP_LP *lp)
Definition: lp.c:17817
prob.h
internal methods for storing and manipulating the main problem
SCIP_Cons
Definition: struct_cons.h:46
SCIPerrorMessage
#define SCIPerrorMessage
Definition: pub_message.h:64
Scip::eventfilter
SCIP_EVENTFILTER * eventfilter
Definition: struct_scip.h:89
SCIPlpIsDualReliable
SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)
Definition: lp.c:17827
SCIPsolveDiveLP
SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_lp.c:2678
SCIP_Conshdlr
Definition: struct_cons.h:126
SCIP_INVALIDCALL
Definition: type_retcode.h:51
SCIPrecalcRowPseudoActivity
SCIP_RETCODE SCIPrecalcRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2028
SCIPlpGetCols
SCIP_COL ** SCIPlpGetCols(SCIP_LP *lp)
Definition: lp.c:17565
SCIPchgCutoffboundDive
SCIP_RETCODE SCIPchgCutoffboundDive(SCIP *scip, SCIP_Real newcutoffbound)
Definition: scip_lp.c:2348
SCIPvarChgObjDive
SCIP_RETCODE SCIPvarChgObjDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
Definition: var.c:6455
SCIPcheckStage
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
Definition: debug.c:2208
SCIPlpSumRows
SCIP_RETCODE SCIPlpSumRows(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
Definition: lp.c:9947
Scip::conflictstore
SCIP_CONFLICTSTORE * conflictstore
Definition: struct_scip.h:105
SCIP_NODETYPE_FOCUSNODE
Definition: type_tree.h:41
SCIP_Prob::objsense
SCIP_OBJSENSE objsense
Definition: struct_prob.h:87
SCIPsumLPRows
SCIP_RETCODE SCIPsumLPRows(SCIP *scip, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
Definition: scip_lp.c:852
Scip::reopt
SCIP_REOPT * reopt
Definition: struct_scip.h:86
SCIPresetLPFeastol
void SCIPresetLPFeastol(SCIP *scip)
Definition: scip_lp.c:452
SCIProwDelaySort
void SCIProwDelaySort(SCIP_ROW *row)
Definition: lp.c:6148
SCIP_Lp::cutoffbound
SCIP_Real cutoffbound
Definition: struct_lp.h:284
SCIProwGetPseudoFeasibility
SCIP_Real SCIProwGetPseudoFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6450
SCIPlpAddRow
SCIP_RETCODE SCIPlpAddRow(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_ROW *row, int depth)
Definition: lp.c:9509
struct_tree.h
data structures for branch and bound tree
SCIP_Stat::userinterrupt
SCIP_Bool userinterrupt
Definition: struct_stat.h:278
SCIP_OKAY
Definition: type_retcode.h:42
SCIPgetNLPRows
int SCIPgetNLPRows(SCIP *scip)
Definition: scip_lp.c:626
set.h
internal methods for global SCIP settings
SCIPgetNUnfixedLPCols
int SCIPgetNUnfixedLPCols(SCIP *scip)
Definition: scip_lp.c:548
SCIP_CALL
#define SCIP_CALL(x)
Definition: def.h:380
SCIPlpSetFeastol
void SCIPlpSetFeastol(SCIP_LP *lp, SCIP_SET *set, SCIP_Real newfeastol)
Definition: lp.c:10256
struct_scip.h
SCIP main data structure.
SCIPlpGetNRows
int SCIPlpGetNRows(SCIP_LP *lp)
Definition: lp.c:17622
SCIPlpMarkDivingObjChanged
void SCIPlpMarkDivingObjChanged(SCIP_LP *lp)
Definition: lp.c:17867
SCIP_Lp::resolvelperror
SCIP_Bool resolvelperror
Definition: struct_lp.h:383
SCIPgetRowLPActivity
SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1993
SCIPdebugCheckBInvRow
#define SCIPdebugCheckBInvRow(scip, r, coef)
Definition: debug.h:324
SCIPlpGetLPI
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
Definition: lp.c:17774
SCIPlpGetObjval
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13119
SCIProwPrint
void SCIProwPrint(SCIP_ROW *row, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
Definition: lp.c:5299
SCIP_LPSOLSTAT_OPTIMAL
Definition: type_lp.h:43
SCIProwGetNumIntCols
int SCIProwGetNumIntCols(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6735
SCIPhasCurrentNodeLP
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip_lp.c:83
SCIPgetLPBInvACol
SCIP_RETCODE SCIPgetLPBInvACol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:819
SCIPgetLastDivenode
SCIP_Longint SCIPgetLastDivenode(SCIP *scip)
Definition: scip_lp.c:2745
SCIProwRelease
SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:5352
Scip::cutpool
SCIP_CUTPOOL * cutpool
Definition: struct_scip.h:106
SCIPlpGetDualDegeneracy
SCIP_RETCODE SCIPlpGetDualDegeneracy(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *degeneracy, SCIP_Real *varconsratio)
Definition: lp.c:18675
Scip::cliquetable
SCIP_CLIQUETABLE * cliquetable
Definition: struct_scip.h:98
SCIProwGetSolActivity
SCIP_Real SCIProwGetSolActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
Definition: lp.c:6466
SCIPlpGetFeastol
SCIP_Real SCIPlpGetFeastol(SCIP_LP *lp)
Definition: lp.c:10246
var.h
internal methods for problem variables
SCIPallocBufferArray
#define SCIPallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:124
SCIPsetSolVal
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
Definition: scip_sol.c:1077
SCIPgetRowObjParallelism
SCIP_Real SCIPgetRowObjParallelism(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2190
SCIPlpGetBasisInd
SCIP_RETCODE SCIPlpGetBasisInd(SCIP_LP *lp, int *basisind)
Definition: lp.c:9816
SCIPgetLPBInvARow
SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip_lp.c:785
Scip::sepastore
SCIP_SEPASTORE * sepastore
Definition: struct_scip.h:103
SCIPlpGetRootLooseObjval
SCIP_Real SCIPlpGetRootLooseObjval(SCIP_LP *lp)
Definition: lp.c:17764
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
SCIPchgRowRhs
SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
Definition: scip_lp.c:1607
SCIPgetLPSolstat
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip_lp.c:168
SCIPgetRowPseudoActivity
SCIP_Real SCIPgetRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2047
SCIPlpGetNUnfixedCols
int SCIPlpGetNUnfixedCols(SCIP_LP *lp, SCIP_Real eps)
Definition: lp.c:17585
SCIPgetRowNumIntCols
int SCIPgetRowNumIntCols(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1886
SCIPlpGetBInvRow
SCIP_RETCODE SCIPlpGetBInvRow(SCIP_LP *lp, int r, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9850
SCIPchgVarUbDive
SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_lp.c:2451
SCIPvarChgUbDive
SCIP_RETCODE SCIPvarChgUbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
Definition: var.c:8340
SCIPcaptureRow
SCIP_RETCODE SCIPcaptureRow(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1540
SCIPlpDivingObjChanged
SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)
Definition: lp.c:17857
SCIPisLPPrimalReliable
SCIP_Bool SCIPisLPPrimalReliable(SCIP *scip)
Definition: scip_lp.c:189
SCIP_Row
Definition: struct_lp.h:201
debug.h
methods for debugging
pub_lp.h
public methods for LP management
SCIP_STAGE_PRESOLVING
Definition: type_set.h:49
SCIPcreateEmptyRowSepa
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:1453
SCIP_Stat::lastdivenode
SCIP_Longint lastdivenode
Definition: struct_stat.h:111
SCIPchgRowLhs
SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
Definition: scip_lp.c:1583
struct_mem.h
datastructures for block memory pools and memory buffers
SCIPprobAllColsInLP
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
Definition: prob.c:2350
SCIP_STAGE_EXITPRESOLVE
Definition: type_set.h:50
SCIPgetLPRootLooseObjval
SCIP_Real SCIPgetLPRootLooseObjval(SCIP *scip)
Definition: scip_lp.c:418
SCIPmarkColNotRemovableLocal
void SCIPmarkColNotRemovableLocal(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1202
rowLink
SCIP_RETCODE rowLink(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
Definition: lp.c:2433
SCIPtreeHasCurrentNodeLP
SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)
Definition: tree.c:8467
SCIPgetLPRootColumnObjval
SCIP_Real SCIPgetLPRootColumnObjval(SCIP *scip)
Definition: scip_lp.c:395
SCIP_ROWORIGINTYPE_UNSPEC
Definition: type_lp.h:72
SCIPgetLPBasisInd
SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
Definition: scip_lp.c:686
SCIPgetLPCols
SCIP_COL ** SCIPgetLPCols(SCIP *scip)
Definition: scip_lp.c:506
SCIP_STAGE_SOLVED
Definition: type_set.h:54
SCIPflushLP
SCIP_RETCODE SCIPflushLP(SCIP *scip)
Definition: scip_lp.c:148
struct_stat.h
datastructures for problem statistics
SCIPgetRowSolActivity
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip_lp.c:2144
SCIP_STAGE_PRESOLVED
Definition: type_set.h:51
SCIP_Tree::cutoffdelayed
SCIP_Bool cutoffdelayed
Definition: struct_tree.h:238
SCIP_Set::num_epsilon
SCIP_Real num_epsilon
Definition: struct_set.h:434
scip_lp.h
public methods for the LP relaxation, rows and columns
SCIProwGetMaxActivity
SCIP_Real SCIProwGetMaxActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6619
SCIPlpGetLooseObjval
SCIP_Real SCIPlpGetLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
Definition: lp.c:13158
struct_prob.h
datastructures for storing and manipulating the main problem
SCIP_STAGE_INITPRESOLVE
Definition: type_set.h:48
r
SCIP_Real * r
Definition: circlepacking.c:59
SCIPvarAddToRow
SCIP_RETCODE SCIPvarAddToRow(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
Definition: var.c:14271
SCIP_STAGE_PROBLEM
Definition: type_set.h:45
SCIPinDive
SCIP_Bool SCIPinDive(SCIP *scip)
Definition: scip_lp.c:2775
SCIPreleaseRow
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
Definition: scip_lp.c:1562
SCIP_STAGE_INIT
Definition: type_set.h:44
SCIP_Set::misc_exactsolve
SCIP_Bool misc_exactsolve
Definition: struct_set.h:395
SCIPprintLPSolutionQuality
SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)
Definition: scip_lp.c:1021
SCIPgetLPObjval
SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip_lp.c:247
SCIPwriteMIP
SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
Definition: scip_lp.c:935
SCIP_Mem::probmem
BMS_BLKMEM * probmem
Definition: struct_mem.h:49
SCIPinterruptLP
SCIP_RETCODE SCIPinterruptLP(SCIP *scip, SCIP_Bool interrupt)
Definition: scip_lp.c:874
SCIProwGetMinActivity
SCIP_Real SCIProwGetMinActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
Definition: lp.c:6598
SCIPchgVarObjDive
SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_lp.c:2378
SCIPcolGetVar
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
Definition: lp.c:17042
scip_sol.h
public methods for solutions
conflict.h
internal methods for conflict analysis
SCIPlpSetCutoffbound
SCIP_RETCODE SCIPlpSetCutoffbound(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real cutoffbound)
Definition: lp.c:10201
solve.h
internal methods for main solving loop and node processing
SCIPtreeGetCurrentNode
SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)
Definition: tree.c:8433
SCIPisRelaxSolValid
SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
Definition: scip_var.c:2536
Scip::set
SCIP_SET * set
Definition: struct_scip.h:73
pub_message.h
public methods for message output
SCIPgetRowLPFeasibility
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2010
struct_lp.h
data structures for LP management
SCIPmessageFPrintInfo
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
Definition: message.c:618
SCIProwGetLPFeasibility
SCIP_Real SCIProwGetLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:6254
Scip::messagehdlr
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:76
SCIPnodeGetType
SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)
Definition: tree.c:7480
SCIP_Real
#define SCIP_Real
Definition: def.h:173
SCIPaddVarsToRow
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip_lp.c:1727
SCIP_LPi
Definition: lpi_clp.cpp:104
SCIP_Prob::vars
SCIP_VAR ** vars
Definition: struct_prob.h:64
SCIPlpIsSolved
SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)
Definition: lp.c:17807
SCIProwGetObjParallelism
SCIP_Real SCIProwGetObjParallelism(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp)
Definition: lp.c:7800
SCIPtreeStoreRelaxSol
SCIP_RETCODE SCIPtreeStoreRelaxSol(SCIP_TREE *tree, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob)
Definition: tree.c:7076
SCIPgetRowMinActivity
SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:1939
SCIP_SIDETYPE_RIGHT
Definition: type_lp.h:65
SCIProwCreate
SCIP_RETCODE SCIProwCreate(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_ROWORIGINTYPE origintype, void *origin, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: lp.c:5110
struct_primal.h
datastructures for collecting primal CIP solutions and primal informations
SCIPgetGlobalPseudoObjval
SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
Definition: scip_lp.c:308
SCIPcreateRowConshdlr
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:1225
SCIP_INVALID
#define SCIP_INVALID
Definition: def.h:193
SCIProwChgRhs
SCIP_RETCODE SCIProwChgRhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real rhs)
Definition: lp.c:5698
SCIPprintRow
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
Definition: scip_lp.c:2212
SCIPcalcRowIntegralScalar
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:1815
SCIPlpIsRelax
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
Definition: lp.c:17797
SCIP_Longint
#define SCIP_Longint
Definition: def.h:158
SCIPallColsInLP
SCIP_Bool SCIPallColsInLP(SCIP *scip)
Definition: scip_lp.c:649
SCIPgetRowSolFeasibility
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip_lp.c:2167
SCIPgetVarLbDive
SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2616
SCIProwCalcIntegralScalar
SCIP_RETCODE SCIProwCalcIntegralScalar(SCIP_ROW *row, SCIP_SET *set, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Real *intscalar, SCIP_Bool *success)
Definition: lp.c:5747
SCIP_STAGE_SOLVING
Definition: type_set.h:53
SCIPnodeUpdateLowerboundLP
SCIP_RETCODE SCIPnodeUpdateLowerboundLP(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp)
Definition: tree.c:2455
SCIP_LPSOLSTAT_INFEASIBLE
Definition: type_lp.h:44
Scip::tree
SCIP_TREE * tree
Definition: struct_scip.h:96
SCIPlpGetBInvARow
SCIP_RETCODE SCIPlpGetBInvARow(SCIP_LP *lp, int r, SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9898
SCIProwMarkNotRemovableLocal
void SCIProwMarkNotRemovableLocal(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:7878
SCIPstartDive
SCIP_RETCODE SCIPstartDive(SCIP *scip)
Definition: scip_lp.c:2242
Scip::relaxation
SCIP_RELAXATION * relaxation
Definition: struct_scip.h:94
SCIProwGetMaxval
SCIP_Real SCIProwGetMaxval(SCIP_ROW *row, SCIP_SET *set)
Definition: lp.c:6671
SCIPcolGetFarkasCoef
SCIP_Real SCIPcolGetFarkasCoef(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:4135
SCIProwGetLPActivity
SCIP_Real SCIProwGetLPActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:6224
SCIPgetLPRootObjval
SCIP_Real SCIPgetLPRootObjval(SCIP *scip)
Definition: scip_lp.c:372
SCIPgetColFarkasCoef
SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)
Definition: scip_lp.c:1180
SCIPgetNLPCols
int SCIPgetNLPCols(SCIP *scip)
Definition: scip_lp.c:527
SCIP_LPSOLSTAT_NOTSOLVED
Definition: type_lp.h:42
SCIPtreeRestoreRelaxSol
SCIP_RETCODE SCIPtreeRestoreRelaxSol(SCIP_TREE *tree, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob)
Definition: tree.c:7120
SCIPlpGetBInvACol
SCIP_RETCODE SCIPlpGetBInvACol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
Definition: lp.c:9923
SCIPgetLPRowsData
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
Definition: scip_lp.c:570
SCIPgetPseudoObjval
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
Definition: scip_lp.c:333
SCIPendDive
SCIP_RETCODE SCIPendDive(SCIP *scip)
Definition: scip_lp.c:2291
SCIP_CALL_ABORT
#define SCIP_CALL_ABORT(x)
Definition: def.h:359
SCIPcreateEmptyRowConshdlr
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:1391
SCIPchgRowRhsDive
SCIP_RETCODE SCIPchgRowRhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)
Definition: scip_lp.c:2555
SCIPcolGetRedcost
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
Definition: lp.c:3952
Scip::lp
SCIP_LP * lp
Definition: struct_scip.h:92
SCIPlpGetColumnObjval
SCIP_Real SCIPlpGetColumnObjval(SCIP_LP *lp)
Definition: lp.c:13147
SCIProwRecalcPseudoActivity
void SCIProwRecalcPseudoActivity(SCIP_ROW *row, SCIP_STAT *stat)
Definition: lp.c:6395
SCIPABORT
#define SCIPABORT()
Definition: def.h:352
SCIPmakeRowIntegral
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:1844
SCIPgetVarObjDive
SCIP_Real SCIPgetVarObjDive(SCIP *scip, SCIP_VAR *var)
Definition: scip_lp.c:2587
SCIP_STAGE_TRANSFORMED
Definition: type_set.h:47
struct_set.h
datastructures for global SCIP settings
SCIPgetRowActivity
SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip_lp.c:2104
SCIP_Prob::objscale
SCIP_Real objscale
Definition: struct_prob.h:51
SCIPgetLPColumnObjval
SCIP_Real SCIPgetLPColumnObjval(SCIP *scip)
Definition: scip_lp.c:265
SCIP_Tree::focusnode
SCIP_NODE * focusnode
Definition: struct_tree.h:191
SCIPcreateSol
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip_sol.c:184
SCIPtreeCutoff
SCIP_RETCODE SCIPtreeCutoff(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real cutoffbound)
Definition: tree.c:5182
memory.h
memory allocation routines