1    	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2    	/*                                                                           */
3    	/*                  This file is part of the program and library             */
4    	/*         SCIP --- Solving Constraint Integer Programs                      */
5    	/*                                                                           */
6    	/*  Copyright (c) 2002-2023 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 	{
(1) Event cond_false: Condition "(_restat_ = SCIP_OKAY) != SCIP_OKAY", taking false branch.
(2) Event if_end: End of if statement.
1708 	   SCIP_CALL( SCIPcheckStage(scip, "SCIPaddVarToRow", FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE) );
1709 	
(3) Event deref_parm_in_call: Function "SCIPvarAddToRow" dereferences "var". [details]
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 	}
2808