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   struct_lp.h
26   	 * @ingroup INTERNALAPI
27   	 * @brief  data structures for LP management
28   	 * @author Tobias Achterberg
29   	 *
30   	 *  In SCIP, the LP is defined as follows:
31   	 *
32   	 *     min       obj * x
33   	 *        lhs <=   A * x + const <= rhs
34   	 *        lb  <=       x         <= ub
35   	 *
36   	 *  The row activities are defined as activity = A * x + const and must
37   	 *  therefore be in the range of [lhs,rhs].
38   	 *
39   	 *  Mathematically, each range constraint would account for two dual
40   	 *  variables, one for each inequality. Since in an optimal solution (at
41   	 *  least) one of them may be chosen to be zero, we may define one dual
42   	 *  multiplier for each row as the difference of those two.
43   	 *
44   	 *  Let y be the vector of dual multipliers for the rows, then the reduced
45   	 *  costs are defined as
46   	 *
47   	 *     redcost = obj - A^T * y.
48   	 *
49   	 *  In an optimal solution, y must be
50   	 *
51   	 *     - nonnegative, if the corresponding row activity is not tight at its rhs
52   	 *     - nonpositive, if the corresponding row activity is not tight at its lhs
53   	 *     - zero, if the corresponding row activity is not at any of its sides
54   	 *
55   	 *  and the reduced costs must be
56   	 *
57   	 *     - nonnegative, if the corresponding variable is not tight at its ub
58   	 *     - nonpositive, if the corresponding variable is not tight at its lb
59   	 *     - zero, if the corresponding variable is not at any of its bounds.
60   	 *
61   	 *  The main datastructures for storing an LP are the rows and the columns.
62   	 *  A row can live on its own (if it was created by a separator), or as SCIP_LP
63   	 *  relaxation of a constraint. Thus, it has a nuses-counter, and is
64   	 *  deleted, if not needed any more.
65   	 *  A column cannot live on its own. It is always connected to a problem
66   	 *  variable. Because pricing is always problem specific, it cannot create
67   	 *  LP columns without introducing new variables. Thus, each column is
68   	 *  connected to exactly one variable, and is deleted, if the variable
69   	 *  is deleted.
70   	 */
71   	
72   	/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
73   	
74   	#ifndef __SCIP_STRUCT_LP_H__
75   	#define __SCIP_STRUCT_LP_H__
76   	
77   	
78   	#include "scip/def.h"
79   	#include "scip/type_lp.h"
80   	#include "scip/type_var.h"
81   	#include "scip/type_event.h"
82   	#include "lpi/type_lpi.h"
83   	
84   	#ifdef __cplusplus
85   	extern "C" {
86   	#endif
87   	
88   	/** collected values of a column which depend on the LP solution
89   	 *  We store these values in each column to recover the LP solution at start of diving or probing mode, say, without
90   	 *  having to resolve the LP.  Note that we do not store the farkascoef value since we do expect a node with infeasible
91   	 *  LP to be pruned anyway.
92   	 */
93   	struct SCIP_ColSolVals
94   	{
95   	   SCIP_Real             primsol;            /**< primal solution value in LP, is 0 if col is not in LP */
96   	   SCIP_Real             redcost;            /**< reduced cost value in LP, or SCIP_INVALID if not yet calculated */
97   	   unsigned int          basisstatus:2;      /**< basis status of column in last LP solution, invalid for non-LP columns */
98   	};
99   	
100  	/** collected values of a row which depend on the LP solution
101  	 *  We store these values in each row to recover the LP solution at start of diving or probing mode, say, without having
102  	 *  to resolve the LP.  We do not store the dualfarkas value since we expect a node with infeasible LP to be pruned
103  	 *  anyway. In this unlikely case, we have to resolve the LP.
104  	 */
105  	struct SCIP_RowSolVals
106  	{
107  	   SCIP_Real             dualsol;            /**< dual solution value in LP, is 0 if row is not in LP */
108  	   SCIP_Real             activity;           /**< row activity value in LP, or SCIP_INVALID if not yet calculated */
109  	   unsigned int          basisstatus:2;      /**< basis status of row in last LP solution, invalid for non-LP rows */
110  	};
111  	
112  	/** collected values of the LP data which depend on the LP solution
113  	 *  We store these values to recover the LP solution at start of diving or probing mode, say, without having to resolve
114  	 *  the LP.
115  	 */
116  	struct SCIP_LpSolVals
117  	{
118  	   SCIP_LPSOLSTAT        lpsolstat;          /**< solution status of last LP solution */
119  	   SCIP_Real             lpobjval;           /**< objective value of LP without loose variables, or SCIP_INVALID */
120  	   SCIP_Bool             primalfeasible;     /**< is current LP solution primal feasible? */
121  	   SCIP_Bool             primalchecked;      /**< was current LP solution checked for primal feasibility? */
122  	   SCIP_Bool             dualfeasible;       /**< is current LP solution dual feasible? */
123  	   SCIP_Bool             dualchecked;        /**< was current LP solution checked for primal feasibility? */
124  	   SCIP_Bool             solisbasic;         /**< is current LP solution a basic solution? */
125  	   SCIP_Bool             lpissolved;         /**< is current LP solved? */
126  	};
127  	
128  	/** LP column;
129  	 *  The row vector of the LP column is partitioned into two parts: The first col->nlprows rows in the rows array
130  	 *  are the ones that belong to the current LP (col->rows[j]->lppos >= 0) and that are linked to the column
131  	 *  (col->linkpos[j] >= 0). The remaining col->len - col->nlprows rows in the rows array are the ones that
132  	 *  don't belong to the current LP (col->rows[j]->lppos == -1) or that are not linked to the column
133  	 *  (col->linkpos[j] == -1).
134  	 */
135  	struct SCIP_Col
136  	{
137  	   SCIP_Real             obj;                /**< current objective value of column in LP (might be changed in diving or probing) */
138  	   SCIP_Real             lb;                 /**< current lower bound of column in LP */
139  	   SCIP_Real             ub;                 /**< current upper bound of column in LP */
140  	   SCIP_Real             unchangedobj;       /**< unchanged objective value of column (ignoring diving or probing changes) */
141  	   SCIP_Real             lazylb;             /**< lazy lower bound of the column; if the current lower bound is not greater than 
142  	                                              *   the lazy lower bound, then the lower bound has not to be added to the LP */
143  	   SCIP_Real             lazyub;             /**< lazy upper bound of the column; if the current upper bound is not smaller than 
144  	                                              *   the lazy upper bound, then the upper bound has not to be added to the LP */
145  	   SCIP_Real             flushedobj;         /**< objective value of column already flushed to the LP solver */
146  	   SCIP_Real             flushedlb;          /**< lower bound of column already flushed to the LP solver */
147  	   SCIP_Real             flushedub;          /**< upper bound of column already flushed to the LP solver */
148  	   SCIP_Real             primsol;            /**< primal solution value in LP, is 0 if col is not in LP */
149  	   SCIP_Real             redcost;            /**< reduced cost value in LP, or SCIP_INVALID if not yet calculated */
150  	   SCIP_Real             farkascoef;         /**< coefficient in dual Farkas infeasibility proof (== dualfarkas^T A_c) */
151  	   SCIP_Real             minprimsol;         /**< minimal LP solution value, this column ever assumed */
152  	   SCIP_Real             maxprimsol;         /**< maximal LP solution value, this column ever assumed */
153  	   SCIP_Real             sbdown;             /**< strong branching information for downwards branching */
154  	   SCIP_Real             sbup;               /**< strong branching information for upwards branching */
155  	   SCIP_Real             sbsolval;           /**< LP solution value of column at last strong branching call */
156  	   SCIP_Real             sblpobjval;         /**< LP objective value at last strong branching call on the column */
157  	   SCIP_Longint          sbnode;             /**< node number of the last strong branching call on this column */
158  	   SCIP_Longint          obsoletenode;       /**< last node where this column was removed due to aging */
159  	   SCIP_COLSOLVALS*      storedsolvals;      /**< values stored before entering diving or probing mode */
160  	   SCIP_VAR*             var;                /**< variable, this column represents; there cannot be a column without variable */
161  	   SCIP_ROW**            rows;               /**< rows of column entries, that may have a nonzero dual solution value */
162  	   SCIP_Real*            vals;               /**< coefficients of column entries */
163  	   SCIP_Longint          validredcostlp;     /**< LP number for which reduced cost value is valid */
164  	   SCIP_Longint          validfarkaslp;      /**< LP number for which Farkas coefficient is valid */
165  	   SCIP_Longint          validsblp;          /**< LP number for which strong branching values are valid */
166  	   int*                  linkpos;            /**< position of col in col vector of the row, or -1 if not yet linked */
167  	   int                   index;              /**< consecutively numbered column identifier */
168  	   int                   size;               /**< size of the row- and val-arrays */
169  	   int                   len;                /**< number of nonzeros in column */
170  	   int                   nlprows;            /**< number of linked rows in column, that belong to the current LP */
171  	   int                   nunlinked;          /**< number of column entries, where the rows don't know about the column */
172  	   int                   lppos;              /**< column position number in current LP, or -1 if not in current LP */
173  	   int                   lpipos;             /**< column position number in LP solver, or -1 if not in LP solver */
174  	   int                   lpdepth;            /**< depth level at which column entered the LP, or -1 if not in current LP */
175  	   int                   sbitlim;            /**< strong branching iteration limit used to get strong branching values, or -1 */
176  	   int                   nsbcalls;           /**< number of times, strong branching was applied on the column */
177  	   int                   age;                /**< number of successive times this variable was in LP and was 0.0 in solution */
178  	   int                   var_probindex;      /**< copy of var->probindex for avoiding expensive dereferencing */
179  	   unsigned int          basisstatus:2;      /**< basis status of column in last LP solution, invalid for non-LP columns */
180  	   unsigned int          lprowssorted:1;     /**< are the linked LP rows in the rows array sorted by non-decreasing index? */
181  	   unsigned int          nonlprowssorted:1;  /**< are the non-LP/not linked rows sorted by non-decreasing index? */
182  	   unsigned int          objchanged:1;       /**< has objective value changed, and has data of LP solver to be updated? */
183  	   unsigned int          lbchanged:1;        /**< has lower bound changed, and has data of LP solver to be updated? */
184  	   unsigned int          ubchanged:1;        /**< has upper bound changed, and has data of LP solver to be updated? */
185  	   unsigned int          coefchanged:1;      /**< has the coefficient vector changed, and has LP solver to be updated? */
186  	   unsigned int          integral:1;         /**< is associated variable of integral type? */
187  	   unsigned int          removable:1;        /**< is column removable from the LP (due to aging or cleanup)? */
188  	   unsigned int          sbdownvalid:1;      /**< stores whether the stored strong branching down value is a valid dual bound;
189  	                                              *   otherwise, it can only be used as an estimate value */
190  	   unsigned int          sbupvalid:1;        /**< stores whether the stored strong branching up value is a valid dual bound;
191  	                                              *   otherwise, it can only be used as an estimate value */
192  	};
193  	
194  	/** LP row
195  	 *  The column vector of the LP row is partitioned into two parts: The first row->nlpcols columns in the cols array
196  	 *  are the ones that belong to the current LP (row->cols[j]->lppos >= 0) and that are linked to the row
197  	 *  (row->linkpos[j] >= 0). The remaining row->len - row->nlpcols columns in the cols array are the ones that
198  	 *  don't belong to the current LP (row->cols[j]->lppos == -1) or that are not linked to the row
199  	 *  (row->linkpos[j] == -1).
200  	 */
201  	struct SCIP_Row
202  	{
203  	   SCIP_Real             constant;           /**< constant shift c in row lhs <= ax + c <= rhs */
204  	   SCIP_Real             lhs;                /**< left hand side of row */
205  	   SCIP_Real             rhs;                /**< right hand side of row */
206  	   SCIP_Real             flushedlhs;         /**< left hand side minus constant of row already flushed to the LP solver */
207  	   SCIP_Real             flushedrhs;         /**< right hand side minus constant of row already flushed to the LP solver */
208  	   SCIP_Real             sqrnorm;            /**< squared Euclidean norm of row vector */
209  	   SCIP_Real             sumnorm;            /**< sum norm of row vector (sum of absolute values of coefficients) */
210  	   SCIP_Real             objprod;            /**< scalar product of row vector with objective function */
211  	   SCIP_Real             maxval;             /**< maximal absolute value of row vector, only valid if nummaxval > 0 */
212  	   SCIP_Real             minval;             /**< minimal absolute non-zero value of row vector, only valid if numminval > 0 */
213  	   SCIP_Real             dualsol;            /**< dual solution value in LP, is 0 if row is not in LP */
214  	   SCIP_Real             activity;           /**< row activity value in LP, or SCIP_INVALID if not yet calculated */
215  	   SCIP_Real             dualfarkas;         /**< multiplier value in dual Farkas infeasibility proof */
216  	   SCIP_Real             pseudoactivity;     /**< row activity value in pseudo solution, or SCIP_INVALID if not yet calculated */
217  	   SCIP_Real             minactivity;        /**< minimal activity value w.r.t. the column's bounds, or SCIP_INVALID */
218  	   SCIP_Real             maxactivity;        /**< maximal activity value w.r.t. the column's bounds, or SCIP_INVALID */
219  	   SCIP_Longint          validpsactivitydomchg; /**< domain change number for which pseudo activity value is valid */
220  	   SCIP_Longint          validactivitybdsdomchg;/**< domain change number for which activity bound values are valid */
221  	   SCIP_Longint          obsoletenode;       /**< last node where this row was removed due to aging */
222  	   SCIP_Longint          activeinlpcounter;  /**< counter for the number of times this row was active in an optimal LP solution */
223  	   SCIP_Longint          nlpsaftercreation;  /**< counter for the number of LPs after the row has been created */
224  	   SCIP_ROWSOLVALS*      storedsolvals;      /**< values stored before entering diving or probing mode */
225  	   void*                 origin;             /**< pointer to constraint handler or separator who created the row (NULL if unknown) */
226  	   char*                 name;               /**< name of the row */
227  	   SCIP_COL**            cols;               /**< columns of row entries, that may have a nonzero primal solution value */
228  	   int*                  cols_index;         /**< copy of cols[i]->index for avoiding expensive dereferencing */
229  	   SCIP_Real*            vals;               /**< coefficients of row entries */
230  	   int*                  linkpos;            /**< position of row in row vector of the column, or -1 if not yet linked */
231  	   SCIP_EVENTFILTER*     eventfilter;        /**< event filter for events concerning this row */
232  	   SCIP_Longint          validactivitylp;    /**< LP number for which activity value is valid */
233  	   int                   index;              /**< consecutively numbered row identifier */
234  	   int                   size;               /**< size of the col- and val-arrays */
235  	   int                   len;                /**< number of nonzeros in row */
236  	   int                   nlpcols;            /**< number of linked columns in row, that belong to the current LP */
237  	   int                   nunlinked;          /**< number of row entries, where the columns don't know about the row */
238  	   int                   nuses;              /**< number of times, this row is referenced */
239  	   int                   lppos;              /**< row position number in current LP, or -1 if not in current LP */
240  	   int                   lpipos;             /**< row position number in LP solver, or -1 if not in LP solver */
241  	   int                   lpdepth;            /**< depth level at which row entered the LP, or -1 if not in current LP */
242  	   int                   minidx;             /**< minimal column index of row entries */
243  	   int                   maxidx;             /**< maximal column index of row entries */
244  	   int                   numintcols;         /**< number of integral columns */
245  	   int                   nummaxval;          /**< number of coefs with absolute value equal to maxval, zero if maxval invalid */
246  	   int                   numminval;          /**< number of coefs with absolute value equal to minval, zero if minval invalid */
247  	   int                   age;                /**< number of successive times this row was in LP and was not sharp in solution */
248  	   int                   rank;               /**< rank of the row (upper bound, to be precise) */
249  	   unsigned int          fromcutpool:1;      /**< added from cutpool to sepastore */
250  	   unsigned int          basisstatus:2;      /**< basis status of row in last LP solution, invalid for non-LP rows */
251  	   unsigned int          lpcolssorted:1;     /**< are the linked LP columns in the cols array sorted by non-decreasing index? */
252  	   unsigned int          nonlpcolssorted:1;  /**< are the non-LP/not linked columns sorted by non-decreasing index? */
253  	   unsigned int          delaysort:1;        /**< should the row sorting be delayed and done in a lazy fashion? */
254  	   unsigned int          validminmaxidx:1;   /**< are minimal and maximal column index valid? */
255  	   unsigned int          lhschanged:1;       /**< was left hand side or constant changed, and has LP solver to be updated? */
256  	   unsigned int          rhschanged:1;       /**< was right hand side or constant changed, and has LP solver to be updated? */
257  	   unsigned int          coefchanged:1;      /**< was the coefficient vector changed, and has LP solver to be updated? */
258  	   unsigned int          integral:1;         /**< is activity (without constant) of row always integral in feasible solution? */
259  	   unsigned int          local:1;            /**< is row only valid locally? */
260  	   unsigned int          modifiable:1;       /**< is row modifiable during node processing (subject to column generation)? */
261  	   unsigned int          removable:1;        /**< is row removable from the LP (due to aging or cleanup)? */
262  	   unsigned int          inglobalcutpool:1;  /**< is row contained in the global cut pool? */
263  	   unsigned int          normunreliable:1;   /**< is the objective product of the row unreliable? */
264  	   unsigned int          nlocks:13;          /**< number of sealed locks of an unmodifiable row */
265  	   unsigned int          origintype:3;       /**< origin of row (0: unknown, 1: constraint handler, 2: constraint, 3: separator, 4: reoptimization) */
266  	};
267  	
268  	/** current LP data */
269  	struct SCIP_Lp
270  	{
271  	   SCIP_Real             lpobjval;           /**< objective value of LP without loose variables, or SCIP_INVALID */
272  	   SCIP_Real             looseobjval;        /**< current solution value of all loose variables set to their best bounds,
273  	                                              *   ignoring variables, with infinite best bound */
274  	   SCIP_Real             rellooseobjval;     /**< last reliable solution value of all loose variables set to their best bounds,
275  	                                              *   ignoring variables, with infinite best bound */
276  	   SCIP_Real             glbpseudoobjval;    /**< global pseudo solution value with all variables set to their best global bounds,
277  	                                              *   ignoring variables, with infinite best bound */
278  	   SCIP_Real             relglbpseudoobjval; /**< last reliable global pseudo solution value */
279  	   SCIP_Real             pseudoobjval;       /**< current pseudo solution value with all variables set to their best bounds,
280  	                                              *   ignoring variables, with infinite best bound */
281  	   SCIP_Real             relpseudoobjval;    /**< last reliable pseudo solution value */
282  	   SCIP_Real             rootlpobjval;       /**< objective value of root LP without loose variables, or SCIP_INVALID */
283  	   SCIP_Real             rootlooseobjval;    /**< objective value of loose variables in root node, or SCIP_INVALID */
284  	   SCIP_Real             cutoffbound;        /**< upper objective limit of LP (copy of primal->cutoffbound) */
285  	   SCIP_Real             feastol;            /**< current feasibility tolerance */
286  	   SCIP_Real             lpiobjlim;          /**< current objective limit in LPI */
287  	   SCIP_Real             lpifeastol;         /**< current feasibility tolerance in LPI */
288  	   SCIP_Real             lpidualfeastol;     /**< current reduced costs feasibility tolerance in LPI */
289  	   SCIP_Real             lpibarrierconvtol;  /**< current convergence tolerance used in barrier algorithm in LPI */
290  	   SCIP_Real             lpiconditionlimit;  /**< current condition number limit in LPI */
291  	   SCIP_Real             lpimarkowitz;       /**< current markowitz threshold */
292  	   SCIP_Real             objsqrnorm;         /**< squared Euclidean norm of objective function vector of problem variables */
293  	   SCIP_Real             objsumnorm;         /**< sum norm of objective function vector of problem variables */
294  	   SCIP_Real             degeneracy;         /**< share of degenerate non-basic variables in the current LP */
295  	   SCIP_Real             varconsratio;       /**< variable-constraint ratio of the optimal face */
296  	   SCIP_LPI*             lpi;                /**< LP solver interface */
297  	   SCIP_COL**            lpicols;            /**< array with columns currently stored in the LP solver */
298  	   SCIP_ROW**            lpirows;            /**< array with rows currently stored in the LP solver */
299  	   SCIP_COL**            chgcols;            /**< array of changed columns not yet applied to the LP solver */
300  	   SCIP_ROW**            chgrows;            /**< array of changed rows not yet applied to the LP solver */
301  	   SCIP_COL**            cols;               /**< array with current LP columns in correct order */
302  	   SCIP_COL**            lazycols;           /**< array with current LP lazy columns */
303  	   SCIP_ROW**            rows;               /**< array with current LP rows in correct order */
304  	   SCIP_Real*            soldirection;       /**< normalized vector in direction of primal solution from current LP solution */
305  	   SCIP_LPISTATE*        divelpistate;       /**< stores LPI state (basis information) before diving starts */
306  	   SCIP_Real*            divechgsides;       /**< stores the lhs/rhs changed in the current diving */
307  	   SCIP_SIDETYPE*        divechgsidetypes;   /**< stores the side type of the changes done in the current diving */
308  	   SCIP_ROW**            divechgrows;        /**< stores the rows changed in the current diving */
309  	   SCIP_LPSOLVALS*       storedsolvals;      /**< collected values of the LP data which depend on the LP solution */
310  	   SCIP_SOL*             validsoldirsol;     /**< primal solution for which the currently stored solution direction vector is valid */
311  	   SCIP_Longint          validsollp;         /**< LP number for which the currently stored solution values are valid */
312  	   SCIP_Longint          validfarkaslp;      /**< LP number for which the currently stored Farkas row multipliers are valid */
313  	   SCIP_Longint          validsoldirlp;      /**< LP number for which the currently stored solution direction vector is valid */
314  	   SCIP_Longint          validdegeneracylp;  /**< LP number for which the currently stored degeneracy information is valid */
315  	   SCIP_Longint          divenolddomchgs;    /**< number of domain changes before diving has started */
316  	   int                   lpicolssize;        /**< available slots in lpicols vector */
317  	   int                   nlpicols;           /**< number of columns in the LP solver */
318  	   int                   lpifirstchgcol;     /**< first column of the LP which differs from the column in the LP solver */
319  	   int                   lpirowssize;        /**< available slots in lpirows vector */
320  	   int                   nlpirows;           /**< number of rows in the LP solver */
321  	   int                   lpifirstchgrow;     /**< first row of the LP which differs from the row in the LP solver */
322  	   int                   chgcolssize;        /**< available slots in chgcols vector */
323  	   int                   nchgcols;           /**< current number of chgcols (number of used slots in chgcols vector) */
324  	   int                   chgrowssize;        /**< available slots in chgrows vector */
325  	   int                   nchgrows;           /**< current number of chgrows (number of used slots in chgrows vector) */
326  	   int                   colssize;           /**< available slots in cols vector */
327  	   int                   soldirectionsize;   /**< available slots in soldirection vector */
328  	   int                   ncols;              /**< current number of LP columns (number of used slots in cols vector) */
329  	   int                   lazycolssize;       /**< available slots in lazycols vector */
330  	   int                   nlazycols;          /**< current number of LP lazy columns (number of used slots in lazycols vector) */
331  	   int                   nremovablecols;     /**< number of removable columns in the LP */
332  	   int                   firstnewcol;        /**< first column added at the current node */
333  	   int                   rowssize;           /**< available slots in rows vector */
334  	   int                   nrows;              /**< current number of LP rows (number of used slots in rows vector) */
335  	   int                   nremovablerows;     /**< number of removable rows in the LP */
336  	   int                   firstnewrow;        /**< first row added at the current node */
337  	   int                   looseobjvalinf;     /**< number of loose variables with infinite best bound in current solution */
338  	   int                   nloosevars;         /**< number of loose variables in LP */
339  	   int                   glbpseudoobjvalinf; /**< number of variables with infinite best bound in global pseudo solution */
340  	   int                   pseudoobjvalinf;    /**< number of variables with infinite best bound in current pseudo solution */
341  	   int                   ndivingrows;        /**< number of rows when entering diving mode */
342  	   int                   ndivechgsides;      /**< number of side changes in current diving */
343  	   int                   divechgsidessize;   /**< size of the arrays */
344  	   int                   divinglpiitlim;     /**< LPI iteration limit when entering diving mode */
345  	   int                   lpiitlim;           /**< current iteration limit setting in LPI */
346  	   int                   lpifastmip;         /**< current FASTMIP setting in LPI */
347  	   int                   lpithreads;         /**< current THREADS setting in LPI */
348  	   int                   lpitiming;          /**< current timing type in LPI */
349  	   int                   lpirandomseed;      /**< current initial random seed in LPI */
350  	   int                   lpiscaling;         /**< current SCALING setting in LPI */
351  	   int                   lpirefactorinterval;/**< current refactorization interval */
352  	   SCIP_PRICING          lpipricing;         /**< current pricing setting in LPI */
353  	   SCIP_LPSOLSTAT        lpsolstat;          /**< solution status of last LP solution */
354  	   SCIP_LPALGO           lastlpalgo;         /**< algorithm used for last LP solve */
355  	   SCIP_Bool             objsqrnormunreliable;/**< is squared Euclidean norm of objective function vector of problem
356  	                                               *   variables unreliable and need recalculation? */
357  	   SCIP_Bool             lpisolutionpolishing;/**< LP solution polishing method (0: disabled, 1: enabled) */
358  	   SCIP_Bool             looseobjvalid;      /**< is the loose objective value valid or should it be recomputed from scratch? */
359  	   SCIP_Bool             glbpseudoobjvalid;  /**< is the global pseudo solution value valid or should it be recomputed from scratch? */
360  	   SCIP_Bool             pseudoobjvalid;     /**< is the pseudo solution value valid or should it be recomputed from scratch? */
361  	   SCIP_Bool             flushdeletedcols;   /**< have LPI-columns been deleted in the last lpFlush() call? */
362  	   SCIP_Bool             flushaddedcols;     /**< have LPI-columns been added in the last lpFlush() call? */
363  	   SCIP_Bool             flushdeletedrows;   /**< have LPI-rows been deleted in the last lpFlush() call? */
364  	   SCIP_Bool             flushaddedrows;     /**< have LPI-rows been added in the last lpFlush() call? */
365  	   SCIP_Bool             updateintegrality;  /**< does integrality information need to be updated? */
366  	   SCIP_Bool             flushed;            /**< are all cached changes applied to the LP solver? */
367  	   SCIP_Bool             solved;             /**< is current LP solved? */
368  	   SCIP_Bool             primalfeasible;     /**< is current LP solution (rather LPI state) primal feasible? */
369  	   SCIP_Bool             primalchecked;      /**< was current LP solution checked for primal feasibility?? */
370  	   SCIP_Bool             dualfeasible;       /**< is current LP solution (rather LPI state) dual feasible? */
371  	   SCIP_Bool             dualchecked;        /**< was current LP solution checked for primal feasibility?? */
372  	   SCIP_Bool             solisbasic;         /**< is current LP solution a basic solution? */
373  	   SCIP_Bool             rootlpisrelax;      /**< is root LP a relaxation of the problem and its solution value a valid global lower bound? */
374  	   SCIP_Bool             isrelax;            /**< is the current LP a relaxation of the problem for which it has been solved and its 
375  	                                              *   solution value a valid local lower bound? */
376  	   SCIP_Bool             installing;         /**< whether the solution process is in stalling */
377  	   SCIP_Bool             strongbranching;    /**< whether the lp is used for strong branching */
378  	   SCIP_Bool             probing;            /**< are we currently in probing mode? */
379  	   SCIP_Bool             strongbranchprobing;/**< are we currently in probing mode for strong branching? */
380  	   SCIP_Bool             diving;             /**< LP is used for diving: col bounds and obj don't correspond to variables */
381  	   SCIP_Bool             divingobjchg;       /**< objective values were changed in diving or probing: LP objective is invalid */
382  	   SCIP_Bool             divinglazyapplied;  /**< lazy bounds were applied to the LP during diving */
383  	   SCIP_Bool             resolvelperror;     /**< an error occurred during resolving the LP after diving or probing */
384  	   SCIP_Bool             adjustlpval;        /**< does an infinite LP objective value has been adjusted so far? */
385  	   SCIP_Bool             lpifromscratch;     /**< current FROMSCRATCH setting in LPI */
386  	   SCIP_Bool             lpipresolving;      /**< current PRESOLVING setting in LPI */
387  	   SCIP_Bool             lpilpinfo;          /**< current LPINFO setting in LPI */
388  	   SCIP_Bool             lpihasfeastol;      /**< does the LPI support the FEASTOL parameter? */
389  	   SCIP_Bool             lpihasdualfeastol;  /**< does the LPI support the DUALFEASTOL parameter? */
390  	   SCIP_Bool             lpihasbarrierconvtol;/**< does the LPI support the BARRIERCONVTOL parameter? */
391  	   SCIP_Bool             lpihasfastmip;      /**< does the LPI support the FASTMIP parameter? */
392  	   SCIP_Bool             lpihasscaling;      /**< does the LPI support the SCALING parameter? */
393  	   SCIP_Bool             lpihaspresolving;   /**< does the LPI support the PRESOLVING parameter? */
394  	   SCIP_Bool             lpihasrowrep;       /**< does the LPI support row representation of a simplex basis? */
395  	   SCIP_Bool             lpihaspolishing;    /**< does the LPI support solution polishing? */
396  	   SCIP_Bool             lpihasrefactor;     /**< does the LPI support changing the refactorization interval? */
397  	   SCIP_Real             lpirowrepswitch;    /**< simplex algorithm shall use row representation of the basis
398  	                                              *   if number of rows divided by number of columns exceeds this value */
399  	   SCIP_Bool             divelpwasprimfeas;  /**< primal feasibility when diving started */
400  	   SCIP_Bool             divelpwasprimchecked;/**< primal feasibility was checked when diving started */
401  	   SCIP_Bool             divelpwasdualfeas;  /**< dual feasibility when diving started */
402  	   SCIP_Bool             divelpwasdualchecked;/**< dual feasibility was checked when diving started */
403  	};
404  	
405  	#ifdef __cplusplus
406  	}
407  	#endif
408  	
409  	#endif
410