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   lpi_none.c
26   	 * @ingroup LPIS
27   	 * @brief  dummy interface for the case no LP solver is needed
28   	 * @author Stefan Heinz
29   	 */
30   	
31   	/*--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32   	
33   	#include <assert.h>
34   	
35   	#include "lpi/lpi.h"
36   	#include "scip/pub_message.h"
37   	
38   	#define LPINAME          "NONE"              /**< name of the LPI interface */
39   	#define LPIINFINITY       1e20               /**< infinity value */
40   	
41   	
42   	/* globally turn off lint warnings: */
43   	/*lint --e{715}*/
44   	
45   	/** LP interface
46   	 *
47   	 *  Store several statistic values about the LP. These values are only needed in order to provide a rudimentary
48   	 *  communication, e.g., there are asserts that check the number of rows and columns.
49   	 */
50   	struct SCIP_LPi
51   	{
52   	   int                   nrows;              /**< number of rows */
53   	   int                   ncols;              /**< number of columns */
54   	};
55   	
56   	
57   	/*
58   	 * Local Methods
59   	 */
60   	
61   	/** error handling method */
62   	static
63   	void errorMessageAbort(
64   	   void
65   	   )
66   	{  /*lint --e{2707}*/
67   	   SCIPerrorMessage("No LP solver available (LPS=none).\n");
68   	   SCIPerrorMessage("Ensure <lp/solvefreq = -1>; note that continuous variables might require an LP-solver.\n");
69   	   SCIPABORT();
70   	}
71   	
72   	/** error handling method */
73   	static
74   	void errorMessage(
75   	   void
76   	   )
77   	{
78   	   SCIPerrorMessage("No LP solver available (LPS=none).\n");
79   	   SCIPerrorMessage("Ensure <lp/solvefreq = -1>; note that continuous variables might require an LP-solver.\n");
80   	}
81   	
82   	/*
83   	 * LP Interface Methods
84   	 */
85   	
86   	
87   	/*
88   	 * Miscellaneous Methods
89   	 */
90   	
91   	/**@name Miscellaneous Methods */
92   	/**@{ */
93   	
94   	/** gets name and version of LP solver */
95   	const char* SCIPlpiGetSolverName(
96   	   void
97   	   )
98   	{
99   	   return LPINAME;
100  	}
101  	
102  	/** gets description of LP solver (developer, webpage, ...) */
103  	const char* SCIPlpiGetSolverDesc(
104  	   void
105  	   )
106  	{
107  	   return "dummy LP solver interface which solely purpose is to resolve references at linking";
108  	}
109  	
110  	/** gets pointer for LP solver - use only with great care */
111  	void* SCIPlpiGetSolverPointer(
112  	   SCIP_LPI*             lpi                 /**< pointer to an LP interface structure */
113  	   )
114  	{  /*lint --e{715}*/
115  	   return (void*) NULL;
116  	}
117  	
118  	/** pass integrality information to LP solver */
119  	SCIP_RETCODE SCIPlpiSetIntegralityInformation(
120  	   SCIP_LPI*             lpi,                /**< pointer to an LP interface structure */
121  	   int                   ncols,              /**< length of integrality array */
122  	   int*                  intInfo             /**< integrality array (0: continuous, 1: integer). May be NULL iff ncols is 0.  */
123  	   )
124  	{ /*lint --e{715}*/
125  	   SCIPerrorMessage("SCIPlpiSetIntegralityInformation() has not been implemented yet.\n");
126  	   return SCIP_LPERROR;
127  	}
128  	
129  	/** informs about availability of a primal simplex solving method */
130  	SCIP_Bool SCIPlpiHasPrimalSolve(
131  	   void
132  	   )
133  	{
134  	   return FALSE;
135  	}
136  	
137  	/** informs about availability of a dual simplex solving method */
138  	SCIP_Bool SCIPlpiHasDualSolve(
139  	   void
140  	   )
141  	{
142  	   return FALSE;
143  	}
144  	
145  	/** informs about availability of a barrier solving method */
146  	SCIP_Bool SCIPlpiHasBarrierSolve(
147  	   void
148  	   )
149  	{
150  	   return FALSE;
151  	}
152  	
153  	/**@} */
154  	
155  	
156  	
157  	
158  	/*
159  	 * LPI Creation and Destruction Methods
160  	 */
161  	
162  	/**@name LPI Creation and Destruction Methods */
163  	/**@{ */
164  	
165  	/** creates an LP problem object */
166  	SCIP_RETCODE SCIPlpiCreate(
167  	   SCIP_LPI**            lpi,                /**< pointer to an LP interface structure */
168  	   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler to use for printing messages, or NULL */
169  	   const char*           name,               /**< problem name */
170  	   SCIP_OBJSEN           objsen              /**< objective sense */
171  	   )
172  	{  /*lint --e{715}*/
173  	   assert(lpi != NULL);
174  	   assert(name != NULL);
175  	   SCIPdebugMessage("SCIPlpiCreate()\n");
176  	   SCIPdebugMessage("Note that there is no LP solver linked to the binary\n");
177  	
178  	   /* create empty LPI */
179  	   SCIP_ALLOC( BMSallocMemory(lpi) );
180  	   (*lpi)->nrows = 0;
181  	   (*lpi)->ncols = 0;
182  	
183  	   return SCIP_OKAY;
184  	}
185  	
186  	/** deletes an LP problem object */
187  	SCIP_RETCODE SCIPlpiFree(
188  	   SCIP_LPI**            lpi                 /**< pointer to an LP interface structure */
189  	   )
190  	{  /*lint --e{715}*/
191  	   assert( lpi != NULL );
192  	   SCIPdebugMessage("SCIPlpiFree()\n");
193  	
194  	   BMSfreeMemory(lpi);
195  	
196  	   return SCIP_OKAY;
197  	}
198  	
199  	/**@} */
200  	
201  	
202  	
203  	
204  	/*
205  	 * Modification Methods
206  	 */
207  	
208  	/**@name Modification Methods */
209  	/**@{ */
210  	
211  	/** copies LP data with column matrix into LP solver */
212  	SCIP_RETCODE SCIPlpiLoadColLP(
213  	   SCIP_LPI*             lpi,                /**< LP interface structure */
214  	   SCIP_OBJSEN           objsen,             /**< objective sense */
215  	   int                   ncols,              /**< number of columns */
216  	   const SCIP_Real*      obj,                /**< objective function values of columns */
217  	   const SCIP_Real*      lb,                 /**< lower bounds of columns */
218  	   const SCIP_Real*      ub,                 /**< upper bounds of columns */
219  	   char**                colnames,           /**< column names, or NULL */
220  	   int                   nrows,              /**< number of rows */
221  	   const SCIP_Real*      lhs,                /**< left hand sides of rows */
222  	   const SCIP_Real*      rhs,                /**< right hand sides of rows */
223  	   char**                rownames,           /**< row names, or NULL */
224  	   int                   nnonz,              /**< number of nonzero elements in the constraint matrix */
225  	   const int*            beg,                /**< start index of each column in ind- and val-array */
226  	   const int*            ind,                /**< row indices of constraint matrix entries */
227  	   const SCIP_Real*      val                 /**< values of constraint matrix entries */
228  	   )
229  	{  /*lint --e{715}*/
230  	#ifndef NDEBUG
231  	   {
232  	      int j;
233  	      for( j = 0; j < nnonz; j++ )
234  	         assert( val[j] != 0 );
235  	   }
236  	#endif
237  	
238  	   assert( lpi != NULL );
239  	   assert(lhs != NULL);
240  	   assert(rhs != NULL);
241  	   assert(obj != NULL);
242  	   assert(lb != NULL);
243  	   assert(ub != NULL);
244  	   assert(beg != NULL);
245  	   assert(ind != NULL);
246  	   assert(val != NULL);
247  	
248  	   lpi->nrows = nrows;
249  	   lpi->ncols = ncols;
250  	   assert( lpi->nrows >= 0 );
251  	   assert( lpi->ncols >= 0 );
252  	
253  	   return SCIP_OKAY;
254  	}
255  	
256  	/** adds columns to the LP */
257  	SCIP_RETCODE SCIPlpiAddCols(
258  	   SCIP_LPI*             lpi,                /**< LP interface structure */
259  	   int                   ncols,              /**< number of columns to be added */
260  	   const SCIP_Real*      obj,                /**< objective function values of new columns */
261  	   const SCIP_Real*      lb,                 /**< lower bounds of new columns */
262  	   const SCIP_Real*      ub,                 /**< upper bounds of new columns */
263  	   char**                colnames,           /**< column names, or NULL */
264  	   int                   nnonz,              /**< number of nonzero elements to be added to the constraint matrix */
265  	   const int*            beg,                /**< start index of each column in ind- and val-array, or NULL if nnonz == 0 */
266  	   const int*            ind,                /**< row indices of constraint matrix entries, or NULL if nnonz == 0 */
267  	   const SCIP_Real*      val                 /**< values of constraint matrix entries, or NULL if nnonz == 0 */
268  	   )
269  	{  /*lint --e{715}*/
270  	   assert( lpi != NULL );
271  	   assert( lpi->ncols >= 0 );
272  	   assert(obj != NULL);
273  	   assert(lb != NULL);
274  	   assert(ub != NULL);
275  	   assert(nnonz == 0 || beg != NULL);
276  	   assert(nnonz == 0 || ind != NULL);
277  	   assert(nnonz == 0 || val != NULL);
278  	   assert(nnonz >= 0);
279  	   assert(ncols >= 0);
280  	
281  	#ifndef NDEBUG
282  	   {
283  	      int j;
284  	      for( j = 0; j < nnonz; j++ )
285  	      {
286  	         assert( val[j] != 0.0 );
287  	         /* perform check that no new rows are added - this is forbidden */
288  	         assert( 0 <= ind[j] && ind[j] < lpi->nrows );
289  	      }
290  	   }
291  	#endif
292  	
293  	   lpi->ncols += ncols;
294  	
295  	   return SCIP_OKAY;
296  	}
297  	
298  	/** deletes all columns in the given range from LP */
299  	SCIP_RETCODE SCIPlpiDelCols(
300  	   SCIP_LPI*             lpi,                /**< LP interface structure */
301  	   int                   firstcol,           /**< first column to be deleted */
302  	   int                   lastcol             /**< last column to be deleted */
303  	   )
304  	{  /*lint --e{715}*/
305  	   assert( lpi != NULL );
306  	   assert( lpi->ncols >= 0 );
307  	
308  	   lpi->ncols -= lastcol - firstcol + 1;
309  	   assert( lpi->ncols >= 0 );
310  	
311  	   return SCIP_OKAY;
312  	}
313  	
314  	/** deletes columns from SCIP_LP; the new position of a column must not be greater that its old position */
315  	SCIP_RETCODE SCIPlpiDelColset(
316  	   SCIP_LPI*             lpi,                /**< LP interface structure */
317  	   int*                  dstat               /**< deletion status of columns
318  	                                              *   input:  1 if column should be deleted, 0 if not
319  	                                              *   output: new position of column, -1 if column was deleted */
320  	   )
321  	{  /*lint --e{715}*/
322  	   int cnt = 0;
323  	   int j;
324  	
325  	   assert( lpi != NULL );
326  	   assert( dstat != NULL );
327  	   assert( lpi->ncols >= 0 );
328  	
329  	   for (j = 0; j < lpi->ncols; ++j)
330  	   {
331  	      if ( dstat[j] )
332  	      {
333  	         ++cnt;
334  	         dstat[j] = -1;
335  	      }
336  	      else
337  	         dstat[j] = cnt;
338  	   }
339  	   lpi->ncols -= cnt;
340  	   assert( lpi->ncols >= 0 );
341  	
342  	   return SCIP_OKAY;
343  	}
344  	
345  	/** adds rows to the LP */
346  	SCIP_RETCODE SCIPlpiAddRows(
347  	   SCIP_LPI*             lpi,                /**< LP interface structure */
348  	   int                   nrows,              /**< number of rows to be added */
349  	   const SCIP_Real*      lhs,                /**< left hand sides of new rows */
350  	   const SCIP_Real*      rhs,                /**< right hand sides of new rows */
351  	   char**                rownames,           /**< row names, or NULL */
352  	   int                   nnonz,              /**< number of nonzero elements to be added to the constraint matrix */
353  	   const int*            beg,                /**< start index of each row in ind- and val-array, or NULL if nnonz == 0 */
354  	   const int*            ind,                /**< column indices of constraint matrix entries, or NULL if nnonz == 0 */
355  	   const SCIP_Real*      val                 /**< values of constraint matrix entries, or NULL if nnonz == 0 */
356  	   )
357  	{  /*lint --e{715}*/
358  	   assert( lpi != NULL );
359  	   assert( lpi->nrows >= 0 );
360  	   assert(lhs != NULL);
361  	   assert(rhs != NULL);
362  	   assert(nnonz == 0 || beg != NULL);
363  	   assert(nnonz == 0 || ind != NULL);
364  	   assert(nnonz == 0 || val != NULL);
365  	
366  	#ifndef NDEBUG
367  	   /* perform check that no new columns are added - this is forbidden */
368  	   {
369  	      int j;
370  	      for (j = 0; j < nnonz; ++j)
371  	      {
372  	         assert( val[j] != 0.0 );
373  	         assert( 0 <= ind[j] && ind[j] < lpi->ncols );
374  	      }
375  	   }
376  	#endif
377  	
378  	   lpi->nrows += nrows;
379  	
380  	   return SCIP_OKAY;
381  	}
382  	
383  	/** deletes all rows in the given range from LP */
384  	SCIP_RETCODE SCIPlpiDelRows(
385  	   SCIP_LPI*             lpi,                /**< LP interface structure */
386  	   int                   firstrow,           /**< first row to be deleted */
387  	   int                   lastrow             /**< last row to be deleted */
388  	   )
389  	{  /*lint --e{715}*/
390  	   assert( lpi != NULL );
391  	   assert( lpi->nrows >= 0 );
392  	
393  	   lpi->nrows -= lastrow - firstrow + 1;
394  	   assert( lpi->nrows >= 0 );
395  	
396  	   return SCIP_OKAY;
397  	}
398  	
399  	/** deletes rows from SCIP_LP; the new position of a row must not be greater that its old position */
400  	SCIP_RETCODE SCIPlpiDelRowset(
401  	   SCIP_LPI*             lpi,                /**< LP interface structure */
402  	   int*                  dstat               /**< deletion status of rows
403  	                                              *   input:  1 if row should be deleted, 0 if not
404  	                                              *   output: new position of row, -1 if row was deleted */
405  	   )
406  	{  /*lint --e{715}*/
407  	   int cnt = 0;
408  	   int i;
409  	
410  	   assert( lpi != NULL );
411  	   assert( dstat != NULL );
412  	   assert( lpi->nrows >= 0 );
413  	
414  	   for (i = 0; i < lpi->nrows; ++i)
415  	   {
416  	      if ( dstat[i] )
417  	      {
418  	         ++cnt;
419  	         dstat[i] = -1;
420  	      }
421  	      else
422  	         dstat[i] = cnt;
423  	   }
424  	   lpi->nrows -= cnt;
425  	   assert( lpi->nrows >= 0 );
426  	
427  	   return SCIP_OKAY;
428  	}
429  	
430  	/** clears the whole LP */
431  	SCIP_RETCODE SCIPlpiClear(
432  	   SCIP_LPI*             lpi                 /**< LP interface structure */
433  	   )
434  	{  /*lint --e{715}*/
435  	   assert( lpi != NULL );
436  	   assert( lpi->nrows >= 0 );
437  	   assert( lpi->ncols >= 0 );
438  	
439  	   lpi->nrows = 0;
440  	   lpi->ncols = 0;
441  	
442  	   return SCIP_OKAY;
443  	}
444  	
445  	/** changes lower and upper bounds of columns */
446  	SCIP_RETCODE SCIPlpiChgBounds(
447  	   SCIP_LPI*             lpi,                /**< LP interface structure */
448  	   int                   ncols,              /**< number of columns to change bounds for */
449  	   const int*            ind,                /**< column indices or NULL if ncols is zero */
450  	   const SCIP_Real*      lb,                 /**< values for the new lower bounds or NULL if ncols is zero */
451  	   const SCIP_Real*      ub                  /**< values for the new upper bounds or NULL if ncols is zero */
452  	   )
453  	{  /*lint --e{715}*/
454  	   int j;
455  	
456  	   assert(ncols == 0 || (ind != NULL && lb != NULL && ub != NULL));
457  	
458  	   if( ncols <= 0 )
459  	      return SCIP_OKAY;
460  	
461  	   for (j = 0; j < ncols; ++j)
462  	   {
463  	      if ( SCIPlpiIsInfinity(lpi, lb[j]) )
464  	      {
465  	         SCIPerrorMessage("LP Error: fixing lower bound for variable %d to infinity.\n", ind[j]);
466  	         return SCIP_LPERROR;
467  	      }
468  	      if ( SCIPlpiIsInfinity(lpi, -ub[j]) )
469  	      {
470  	         SCIPerrorMessage("LP Error: fixing upper bound for variable %d to -infinity.\n", ind[j]);
471  	         return SCIP_LPERROR;
472  	      }
473  	   }
474  	
475  	   return SCIP_OKAY;
476  	}
477  	
478  	/** changes left and right hand sides of rows */
479  	SCIP_RETCODE SCIPlpiChgSides(
480  	   SCIP_LPI*             lpi,                /**< LP interface structure */
481  	   int                   nrows,              /**< number of rows to change sides for */
482  	   const int*            ind,                /**< row indices */
483  	   const SCIP_Real*      lhs,                /**< new values for left hand sides */
484  	   const SCIP_Real*      rhs                 /**< new values for right hand sides */
485  	   )
486  	{  /*lint --e{715}*/
487  	   assert(lpi != NULL);
488  	   assert(ind != NULL);
489  	   assert(lhs != NULL);
490  	   assert(rhs != NULL);
491  	   return SCIP_OKAY;
492  	}
493  	
494  	/** changes a single coefficient */
495  	SCIP_RETCODE SCIPlpiChgCoef(
496  	   SCIP_LPI*             lpi,                /**< LP interface structure */
497  	   int                   row,                /**< row number of coefficient to change */
498  	   int                   col,                /**< column number of coefficient to change */
499  	   SCIP_Real             newval              /**< new value of coefficient */
500  	   )
501  	{  /*lint --e{715}*/
502  	   assert(lpi != NULL);
503  	   return SCIP_OKAY;
504  	}
505  	
506  	/** changes the objective sense */
507  	SCIP_RETCODE SCIPlpiChgObjsen(
508  	   SCIP_LPI*             lpi,                /**< LP interface structure */
509  	   SCIP_OBJSEN           objsen              /**< new objective sense */
510  	   )
511  	{  /*lint --e{715}*/
512  	   assert(lpi != NULL);
513  	   return SCIP_OKAY;
514  	}
515  	
516  	/** changes objective values of columns in the LP */
517  	SCIP_RETCODE SCIPlpiChgObj(
518  	   SCIP_LPI*             lpi,                /**< LP interface structure */
519  	   int                   ncols,              /**< number of columns to change objective value for */
520  	   const int*            ind,                /**< column indices to change objective value for */
521  	   const SCIP_Real*      obj                 /**< new objective values for columns */
522  	   )
523  	{  /*lint --e{715}*/
524  	   assert(lpi != NULL);
525  	   assert(ind != NULL);
526  	   assert(obj != NULL);
527  	   return SCIP_OKAY;
528  	}
529  	
530  	/** multiplies a row with a non-zero scalar; for negative scalars, the row's sense is switched accordingly */
531  	SCIP_RETCODE SCIPlpiScaleRow(
532  	   SCIP_LPI*             lpi,                /**< LP interface structure */
533  	   int                   row,                /**< row number to scale */
534  	   SCIP_Real             scaleval            /**< scaling multiplier */
535  	   )
536  	{  /*lint --e{715}*/
537  	   assert(lpi != NULL);
538  	   return SCIP_OKAY;
539  	}
540  	
541  	/** multiplies a column with a non-zero scalar; the objective value is multiplied with the scalar, and the bounds
542  	 *  are divided by the scalar; for negative scalars, the column's bounds are switched
543  	 */
544  	SCIP_RETCODE SCIPlpiScaleCol(
545  	   SCIP_LPI*             lpi,                /**< LP interface structure */
546  	   int                   col,                /**< column number to scale */
547  	   SCIP_Real             scaleval            /**< scaling multiplier */
548  	   )
549  	{  /*lint --e{715}*/
550  	   assert(lpi != NULL);
551  	   return SCIP_OKAY;
552  	}
553  	
554  	/**@} */
555  	
556  	
557  	
558  	
559  	/*
560  	 * Data Accessing Methods
561  	 */
562  	
563  	/**@name Data Accessing Methods */
564  	/**@{ */
565  	
566  	/** gets the number of rows in the LP */
567  	SCIP_RETCODE SCIPlpiGetNRows(
568  	   SCIP_LPI*             lpi,                /**< LP interface structure */
569  	   int*                  nrows               /**< pointer to store the number of rows */
570  	   )
571  	{  /*lint --e{715}*/
572  	   assert( lpi != NULL );
573  	   assert( nrows != NULL );
574  	   assert( lpi->nrows >= 0 );
575  	
576  	   *nrows = lpi->nrows;
577  	
578  	   return SCIP_OKAY;
579  	}
580  	
581  	/** gets the number of columns in the LP */
582  	SCIP_RETCODE SCIPlpiGetNCols(
583  	   SCIP_LPI*             lpi,                /**< LP interface structure */
584  	   int*                  ncols               /**< pointer to store the number of cols */
585  	   )
586  	{  /*lint --e{715}*/
587  	   assert( lpi != NULL );
588  	   assert( ncols != NULL );
589  	   assert( lpi->ncols >= 0 );
590  	
591  	   *ncols = lpi->ncols;
592  	
593  	   return SCIP_OKAY;
594  	}
595  	
596  	/** gets the number of nonzero elements in the LP constraint matrix */
597  	SCIP_RETCODE SCIPlpiGetNNonz(
598  	   SCIP_LPI*             lpi,                /**< LP interface structure */
599  	   int*                  nnonz               /**< pointer to store the number of nonzeros */
600  	   )
601  	{  /*lint --e{715}*/
602  	   assert(nnonz != NULL);
603  	   assert(lpi != NULL);
604  	   errorMessage();
605  	   return SCIP_PLUGINNOTFOUND;
606  	}
607  	
608  	/** gets columns from LP problem object; the arrays have to be large enough to store all values
609  	 *  Either both, lb and ub, have to be NULL, or both have to be non-NULL,
610  	 *  either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
611  	 */
612  	SCIP_RETCODE SCIPlpiGetCols(
613  	   SCIP_LPI*             lpi,                /**< LP interface structure */
614  	   int                   firstcol,           /**< first column to get from LP */
615  	   int                   lastcol,            /**< last column to get from LP */
616  	   SCIP_Real*            lb,                 /**< buffer to store the lower bound vector, or NULL */
617  	   SCIP_Real*            ub,                 /**< buffer to store the upper bound vector, or NULL */
618  	   int*                  nnonz,              /**< pointer to store the number of nonzero elements returned, or NULL */
619  	   int*                  beg,                /**< buffer to store start index of each column in ind- and val-array, or NULL */
620  	   int*                  ind,                /**< buffer to store row indices of constraint matrix entries, or NULL */
621  	   SCIP_Real*            val                 /**< buffer to store values of constraint matrix entries, or NULL */
622  	   )
623  	{  /*lint --e{715}*/
624  	   errorMessage();
625  	   return SCIP_PLUGINNOTFOUND;
626  	}
627  	
628  	/** gets rows from LP problem object; the arrays have to be large enough to store all values.
629  	 *  Either both, lhs and rhs, have to be NULL, or both have to be non-NULL,
630  	 *  either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
631  	 */
632  	SCIP_RETCODE SCIPlpiGetRows(
633  	   SCIP_LPI*             lpi,                /**< LP interface structure */
634  	   int                   firstrow,           /**< first row to get from LP */
635  	   int                   lastrow,            /**< last row to get from LP */
636  	   SCIP_Real*            lhs,                /**< buffer to store left hand side vector, or NULL */
637  	   SCIP_Real*            rhs,                /**< buffer to store right hand side vector, or NULL */
638  	   int*                  nnonz,              /**< pointer to store the number of nonzero elements returned, or NULL */
639  	   int*                  beg,                /**< buffer to store start index of each row in ind- and val-array, or NULL */
640  	   int*                  ind,                /**< buffer to store column indices of constraint matrix entries, or NULL */
641  	   SCIP_Real*            val                 /**< buffer to store values of constraint matrix entries, or NULL */
642  	   )
643  	{  /*lint --e{715}*/
644  	   errorMessage();
645  	   return SCIP_PLUGINNOTFOUND;
646  	}
647  	
648  	/** gets column names */
649  	SCIP_RETCODE SCIPlpiGetColNames(
650  	   SCIP_LPI*             lpi,                /**< LP interface structure */
651  	   int                   firstcol,           /**< first column to get name from LP */
652  	   int                   lastcol,            /**< last column to get name from LP */
653  	   char**                colnames,           /**< pointers to column names (of size at least lastcol-firstcol+1) or NULL if namestoragesize is zero */
654  	   char*                 namestorage,        /**< storage for col names or NULL if namestoragesize is zero */
655  	   int                   namestoragesize,    /**< size of namestorage (if 0, storageleft returns the storage needed) */
656  	   int*                  storageleft         /**< amount of storage left (if < 0 the namestorage was not big enough) or NULL if namestoragesize is zero */
657  	   )
658  	{ /*lint --e{715}*/
659  	   assert(lpi != NULL);
660  	   assert(colnames != NULL || namestoragesize == 0);
661  	   assert(namestorage != NULL || namestoragesize == 0);
662  	   assert(namestoragesize >= 0);
663  	   assert(storageleft != NULL);
664  	   errorMessage();
665  	   return SCIP_PLUGINNOTFOUND;
666  	}
667  	
668  	/** gets row names */
669  	SCIP_RETCODE SCIPlpiGetRowNames(
670  	   SCIP_LPI*             lpi,                /**< LP interface structure */
671  	   int                   firstrow,           /**< first row to get name from LP */
672  	   int                   lastrow,            /**< last row to get name from LP */
673  	   char**                rownames,           /**< pointers to row names (of size at least lastrow-firstrow+1) or NULL if namestoragesize is zero */
674  	   char*                 namestorage,        /**< storage for row names or NULL if namestoragesize is zero */
675  	   int                   namestoragesize,    /**< size of namestorage (if 0, -storageleft returns the storage needed) */
676  	   int*                  storageleft         /**< amount of storage left (if < 0 the namestorage was not big enough) or NULL if namestoragesize is zero */
677  	   )
678  	{ /*lint --e{715}*/
679  	   assert(lpi != NULL);
680  	   assert(rownames != NULL || namestoragesize == 0);
681  	   assert(namestorage != NULL || namestoragesize == 0);
682  	   assert(namestoragesize >= 0);
683  	   assert(storageleft != NULL);
684  	   errorMessage();
685  	   return SCIP_PLUGINNOTFOUND;
686  	}
687  	
688  	/** gets the objective sense of the LP */
689  	SCIP_RETCODE SCIPlpiGetObjsen(
690  	   SCIP_LPI*             lpi,                /**< LP interface structure */
691  	   SCIP_OBJSEN*          objsen              /**< pointer to store objective sense */
692  	   )
693  	{  /*lint --e{715}*/
694  	   errorMessage();
695  	   return SCIP_PLUGINNOTFOUND;
696  	}
697  	
698  	/** gets objective coefficients from LP problem object */
699  	SCIP_RETCODE SCIPlpiGetObj(
700  	   SCIP_LPI*             lpi,                /**< LP interface structure */
701  	   int                   firstcol,           /**< first column to get objective coefficient for */
702  	   int                   lastcol,            /**< last column to get objective coefficient for */
703  	   SCIP_Real*            vals                /**< array to store objective coefficients */
704  	   )
705  	{  /*lint --e{715}*/
706  	   assert(lpi != NULL);
707  	   assert(firstcol <= lastcol);
708  	   assert(vals != NULL);
709  	   errorMessage();
710  	   return SCIP_PLUGINNOTFOUND;
711  	}
712  	
713  	/** gets current bounds from LP problem object */
714  	SCIP_RETCODE SCIPlpiGetBounds(
715  	   SCIP_LPI*             lpi,                /**< LP interface structure */
716  	   int                   firstcol,           /**< first column to get bounds for */
717  	   int                   lastcol,            /**< last column to get bounds for */
718  	   SCIP_Real*            lbs,                /**< array to store lower bound values, or NULL */
719  	   SCIP_Real*            ubs                 /**< array to store upper bound values, or NULL */
720  	   )
721  	{  /*lint --e{715}*/
722  	   assert(lpi != NULL);
723  	   assert(firstcol <= lastcol);
724  	   errorMessage();
725  	   return SCIP_PLUGINNOTFOUND;
726  	}
727  	
728  	/** gets current row sides from LP problem object */
729  	SCIP_RETCODE SCIPlpiGetSides(
730  	   SCIP_LPI*             lpi,                /**< LP interface structure */
731  	   int                   firstrow,           /**< first row to get sides for */
732  	   int                   lastrow,            /**< last row to get sides for */
733  	   SCIP_Real*            lhss,               /**< array to store left hand side values, or NULL */
734  	   SCIP_Real*            rhss                /**< array to store right hand side values, or NULL */
735  	   )
736  	{  /*lint --e{715}*/
737  	   assert(lpi != NULL);
738  	   assert(firstrow <= lastrow);
739  	   errorMessage();
740  	   return SCIP_PLUGINNOTFOUND;
741  	}
742  	
743  	/** gets a single coefficient */
744  	SCIP_RETCODE SCIPlpiGetCoef(
745  	   SCIP_LPI*             lpi,                /**< LP interface structure */
746  	   int                   row,                /**< row number of coefficient */
747  	   int                   col,                /**< column number of coefficient */
748  	   SCIP_Real*            val                 /**< pointer to store the value of the coefficient */
749  	   )
750  	{  /*lint --e{715}*/
751  	   assert(lpi != NULL);
752  	   assert(val != NULL);
753  	   errorMessage();
754  	   return SCIP_PLUGINNOTFOUND;
755  	}
756  	
757  	/**@} */
758  	
759  	
760  	
761  	
762  	/*
763  	 * Solving Methods
764  	 */
765  	
766  	/**@name Solving Methods */
767  	/**@{ */
768  	
769  	/** calls primal simplex to solve the LP */
770  	SCIP_RETCODE SCIPlpiSolvePrimal(
771  	   SCIP_LPI*             lpi                 /**< LP interface structure */
772  	   )
773  	{  /*lint --e{715}*/
774  	   assert(lpi != NULL);
775  	   errorMessage();
776  	   return SCIP_PLUGINNOTFOUND;
777  	}
778  	
779  	/** calls dual simplex to solve the LP */
780  	SCIP_RETCODE SCIPlpiSolveDual(
781  	   SCIP_LPI*             lpi                 /**< LP interface structure */
782  	   )
783  	{  /*lint --e{715}*/
784  	   assert(lpi != NULL);
785  	   errorMessage();
786  	   return SCIP_PLUGINNOTFOUND;
787  	}
788  	
789  	/** calls barrier or interior point algorithm to solve the LP with crossover to simplex basis */
790  	SCIP_RETCODE SCIPlpiSolveBarrier(
791  	   SCIP_LPI*             lpi,                /**< LP interface structure */
792  	   SCIP_Bool             crossover           /**< perform crossover */
793  	   )
794  	{  /*lint --e{715}*/
795  	   assert(lpi != NULL);
796  	   errorMessage();
797  	   return SCIP_PLUGINNOTFOUND;
798  	}
799  	
800  	/** start strong branching - call before any strong branching */
801  	SCIP_RETCODE SCIPlpiStartStrongbranch(
802  	   SCIP_LPI*             lpi                 /**< LP interface structure */
803  	   )
804  	{  /*lint --e{715}*/
805  	   assert(lpi != NULL);
806  	   return SCIP_OKAY;
807  	}
808  	
809  	/** end strong branching - call after any strong branching */
810  	SCIP_RETCODE SCIPlpiEndStrongbranch(
811  	   SCIP_LPI*             lpi                 /**< LP interface structure */
812  	   )
813  	{  /*lint --e{715}*/
814  	   assert(lpi != NULL);
815  	   return SCIP_OKAY;
816  	}
817  	
818  	/** performs strong branching iterations on one @b fractional candidate */
819  	SCIP_RETCODE SCIPlpiStrongbranchFrac(
820  	   SCIP_LPI*             lpi,                /**< LP interface structure */
821  	   int                   col,                /**< column to apply strong branching on */
822  	   SCIP_Real             psol,               /**< fractional current primal solution value of column */
823  	   int                   itlim,              /**< iteration limit for strong branchings */
824  	   SCIP_Real*            down,               /**< stores dual bound after branching column down */
825  	   SCIP_Real*            up,                 /**< stores dual bound after branching column up */
826  	   SCIP_Bool*            downvalid,          /**< stores whether the returned down value is a valid dual bound;
827  	                                              *   otherwise, it can only be used as an estimate value */
828  	   SCIP_Bool*            upvalid,            /**< stores whether the returned up value is a valid dual bound;
829  	                                              *   otherwise, it can only be used as an estimate value */
830  	   int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
831  	   )
832  	{  /*lint --e{715}*/
833  	   assert(lpi != NULL);
834  	   assert( down != NULL );
835  	   assert( up != NULL );
836  	   assert( downvalid != NULL );
837  	   assert( upvalid != NULL );
838  	   errorMessage();
839  	   return SCIP_PLUGINNOTFOUND;
840  	}
841  	
842  	/** performs strong branching iterations on given @b fractional candidates */
843  	SCIP_RETCODE SCIPlpiStrongbranchesFrac(
844  	   SCIP_LPI*             lpi,                /**< LP interface structure */
845  	   int*                  cols,               /**< columns to apply strong branching on */
846  	   int                   ncols,              /**< number of columns */
847  	   SCIP_Real*            psols,              /**< fractional current primal solution values of columns */
848  	   int                   itlim,              /**< iteration limit for strong branchings */
849  	   SCIP_Real*            down,               /**< stores dual bounds after branching columns down */
850  	   SCIP_Real*            up,                 /**< stores dual bounds after branching columns up */
851  	   SCIP_Bool*            downvalid,          /**< stores whether the returned down values are valid dual bounds;
852  	                                              *   otherwise, they can only be used as an estimate values */
853  	   SCIP_Bool*            upvalid,            /**< stores whether the returned up values are a valid dual bounds;
854  	                                              *   otherwise, they can only be used as an estimate values */
855  	   int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
856  	   )
857  	{  /*lint --e{715}*/
858  	   assert(lpi != NULL);
859  	   assert( cols != NULL );
860  	   assert( psols != NULL );
861  	   assert( down != NULL );
862  	   assert( up != NULL );
863  	   assert( downvalid != NULL );
864  	   assert( upvalid != NULL );
865  	   errorMessage();
866  	   return SCIP_PLUGINNOTFOUND;
867  	}
868  	
869  	/** performs strong branching iterations on one candidate with @b integral value */
870  	SCIP_RETCODE SCIPlpiStrongbranchInt(
871  	   SCIP_LPI*             lpi,                /**< LP interface structure */
872  	   int                   col,                /**< column to apply strong branching on */
873  	   SCIP_Real             psol,               /**< current integral primal solution value of column */
874  	   int                   itlim,              /**< iteration limit for strong branchings */
875  	   SCIP_Real*            down,               /**< stores dual bound after branching column down */
876  	   SCIP_Real*            up,                 /**< stores dual bound after branching column up */
877  	   SCIP_Bool*            downvalid,          /**< stores whether the returned down value is a valid dual bound;
878  	                                              *   otherwise, it can only be used as an estimate value */
879  	   SCIP_Bool*            upvalid,            /**< stores whether the returned up value is a valid dual bound;
880  	                                              *   otherwise, it can only be used as an estimate value */
881  	   int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
882  	   )
883  	{  /*lint --e{715}*/
884  	   assert(lpi != NULL);
885  	   assert( down != NULL );
886  	   assert( up != NULL );
887  	   assert( downvalid != NULL );
888  	   assert( upvalid != NULL );
889  	   errorMessage();
890  	   return SCIP_PLUGINNOTFOUND;
891  	}
892  	
893  	/** performs strong branching iterations on given candidates with @b integral values */
894  	SCIP_RETCODE SCIPlpiStrongbranchesInt(
895  	   SCIP_LPI*             lpi,                /**< LP interface structure */
896  	   int*                  cols,               /**< columns to apply strong branching on */
897  	   int                   ncols,              /**< number of columns */
898  	   SCIP_Real*            psols,              /**< current integral primal solution values of columns */
899  	   int                   itlim,              /**< iteration limit for strong branchings */
900  	   SCIP_Real*            down,               /**< stores dual bounds after branching columns down */
901  	   SCIP_Real*            up,                 /**< stores dual bounds after branching columns up */
902  	   SCIP_Bool*            downvalid,          /**< stores whether the returned down values are valid dual bounds;
903  	                                              *   otherwise, they can only be used as an estimate values */
904  	   SCIP_Bool*            upvalid,            /**< stores whether the returned up values are a valid dual bounds;
905  	                                              *   otherwise, they can only be used as an estimate values */
906  	   int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
907  	   )
908  	{  /*lint --e{715}*/
909  	   assert(lpi != NULL);
910  	   assert( cols != NULL );
911  	   assert( psols != NULL );
912  	   assert( down != NULL );
913  	   assert( up != NULL );
914  	   assert( downvalid != NULL );
915  	   assert( upvalid != NULL );
916  	   errorMessage();
917  	   return SCIP_PLUGINNOTFOUND;
918  	}
919  	/**@} */
920  	
921  	
922  	
923  	
924  	/*
925  	 * Solution Information Methods
926  	 */
927  	
928  	/**@name Solution Information Methods */
929  	/**@{ */
930  	
931  	/** returns whether a solve method was called after the last modification of the LP */
932  	SCIP_Bool SCIPlpiWasSolved(
933  	   SCIP_LPI*             lpi                 /**< LP interface structure */
934  	   )
935  	{  /*lint --e{715}*/
936  	   assert(lpi != NULL);
937  	   errorMessageAbort();
938  	   return FALSE;
939  	}
940  	
941  	/** gets information about primal and dual feasibility of the current LP solution
942  	 *
943  	 *  The feasibility information is with respect to the last solving call and it is only relevant if SCIPlpiWasSolved()
944  	 *  returns true. If the LP is changed, this information might be invalidated.
945  	 *
946  	 *  Note that @a primalfeasible and @a dualfeasible should only return true if the solver has proved the respective LP to
947  	 *  be feasible. Thus, the return values should be equal to the values of SCIPlpiIsPrimalFeasible() and
948  	 *  SCIPlpiIsDualFeasible(), respectively. Note that if feasibility cannot be proved, they should return false (even if
949  	 *  the problem might actually be feasible).
950  	 */
951  	SCIP_RETCODE SCIPlpiGetSolFeasibility(
952  	   SCIP_LPI*             lpi,                /**< LP interface structure */
953  	   SCIP_Bool*            primalfeasible,     /**< pointer to store primal feasibility status */
954  	   SCIP_Bool*            dualfeasible        /**< pointer to store dual feasibility status */
955  	   )
956  	{  /*lint --e{715}*/
957  	   assert(lpi != NULL);
958  	   assert(primalfeasible != NULL);
959  	   assert(dualfeasible != NULL);
960  	   errorMessage();
961  	   return SCIP_PLUGINNOTFOUND;
962  	}
963  	
964  	/** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point);
965  	 *  this does not necessarily mean, that the solver knows and can return the primal ray
966  	 */
967  	SCIP_Bool SCIPlpiExistsPrimalRay(
968  	   SCIP_LPI*             lpi                 /**< LP interface structure */
969  	   )
970  	{  /*lint --e{715}*/
971  	   assert(lpi != NULL);
972  	   errorMessageAbort();
973  	   return FALSE;
974  	}
975  	
976  	/** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point),
977  	 *  and the solver knows and can return the primal ray
978  	 */
979  	SCIP_Bool SCIPlpiHasPrimalRay(
980  	   SCIP_LPI*             lpi                 /**< LP interface structure */
981  	   )
982  	{  /*lint --e{715}*/
983  	   assert(lpi != NULL);
984  	   errorMessageAbort();
985  	   return FALSE;
986  	}
987  	
988  	/** returns TRUE iff LP is proven to be primal unbounded */
989  	SCIP_Bool SCIPlpiIsPrimalUnbounded(
990  	   SCIP_LPI*             lpi                 /**< LP interface structure */
991  	   )
992  	{  /*lint --e{715}*/
993  	   assert(lpi != NULL);
994  	   errorMessageAbort();
995  	   return FALSE;
996  	}
997  	
998  	/** returns TRUE iff LP is proven to be primal infeasible */
999  	SCIP_Bool SCIPlpiIsPrimalInfeasible(
1000 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1001 	   )
1002 	{  /*lint --e{715}*/
1003 	   assert(lpi != NULL);
1004 	   errorMessageAbort();
1005 	   return FALSE;
1006 	}
1007 	
1008 	/** returns TRUE iff LP is proven to be primal feasible */
1009 	SCIP_Bool SCIPlpiIsPrimalFeasible(
1010 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1011 	   )
1012 	{  /*lint --e{715}*/
1013 	   assert(lpi != NULL);
1014 	   errorMessageAbort();
1015 	   return FALSE;
1016 	}
1017 	
1018 	/** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point);
1019 	 *  this does not necessarily mean, that the solver knows and can return the dual ray
1020 	 */
1021 	SCIP_Bool SCIPlpiExistsDualRay(
1022 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1023 	   )
1024 	{  /*lint --e{715}*/
1025 	   assert(lpi != NULL);
1026 	   errorMessageAbort();
1027 	   return FALSE;
1028 	}
1029 	
1030 	/** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point),
1031 	 *  and the solver knows and can return the dual ray
1032 	 */
1033 	SCIP_Bool SCIPlpiHasDualRay(
1034 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1035 	   )
1036 	{  /*lint --e{715}*/
1037 	   assert(lpi != NULL);
1038 	   errorMessageAbort();
1039 	   return FALSE;
1040 	}
1041 	
1042 	/** returns TRUE iff LP is proven to be dual unbounded */
1043 	SCIP_Bool SCIPlpiIsDualUnbounded(
1044 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1045 	   )
1046 	{  /*lint --e{715}*/
1047 	   assert(lpi != NULL);
1048 	   errorMessageAbort();
1049 	   return FALSE;
1050 	}
1051 	
1052 	/** returns TRUE iff LP is proven to be dual infeasible */
1053 	SCIP_Bool SCIPlpiIsDualInfeasible(
1054 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1055 	   )
1056 	{  /*lint --e{715}*/
1057 	   assert(lpi != NULL);
1058 	   errorMessageAbort();
1059 	   return FALSE;
1060 	}
1061 	
1062 	/** returns TRUE iff LP is proven to be dual feasible */
1063 	SCIP_Bool SCIPlpiIsDualFeasible(
1064 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1065 	   )
1066 	{  /*lint --e{715}*/
1067 	   assert(lpi != NULL);
1068 	   errorMessageAbort();
1069 	   return FALSE;
1070 	}
1071 	
1072 	/** returns TRUE iff LP was solved to optimality */
1073 	SCIP_Bool SCIPlpiIsOptimal(
1074 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1075 	   )
1076 	{  /*lint --e{715}*/
1077 	   assert(lpi != NULL);
1078 	   errorMessageAbort();
1079 	   return FALSE;
1080 	}
1081 	
1082 	/** returns TRUE iff current LP solution is stable
1083 	 *
1084 	 *  This function should return true if the solution is reliable, i.e., feasible and optimal (or proven
1085 	 *  infeasible/unbounded) with respect to the original problem. The optimality status might be with respect to a scaled
1086 	 *  version of the problem, but the solution might not be feasible to the unscaled original problem; in this case,
1087 	 *  SCIPlpiIsStable() should return false.
1088 	 */
1089 	SCIP_Bool SCIPlpiIsStable(
1090 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1091 	   )
1092 	{  /*lint --e{715}*/
1093 	   assert(lpi != NULL);
1094 	   errorMessageAbort();
1095 	   return FALSE;
1096 	}
1097 	
1098 	/** returns TRUE iff the objective limit was reached */
1099 	SCIP_Bool SCIPlpiIsObjlimExc(
1100 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1101 	   )
1102 	{  /*lint --e{715}*/
1103 	   assert(lpi != NULL);
1104 	   errorMessageAbort();
1105 	   return FALSE;
1106 	}
1107 	
1108 	/** returns TRUE iff the iteration limit was reached */
1109 	SCIP_Bool SCIPlpiIsIterlimExc(
1110 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1111 	   )
1112 	{  /*lint --e{715}*/
1113 	   assert(lpi != NULL);
1114 	   errorMessageAbort();
1115 	   return FALSE;
1116 	}
1117 	
1118 	/** returns TRUE iff the time limit was reached */
1119 	SCIP_Bool SCIPlpiIsTimelimExc(
1120 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1121 	   )
1122 	{  /*lint --e{715}*/
1123 	   assert(lpi != NULL);
1124 	   errorMessageAbort();
1125 	   return FALSE;
1126 	}
1127 	
1128 	/** returns the internal solution status of the solver */
1129 	int SCIPlpiGetInternalStatus(
1130 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1131 	   )
1132 	{  /*lint --e{715}*/
1133 	   assert(lpi != NULL);
1134 	   errorMessageAbort();
1135 	   return FALSE;
1136 	}
1137 	
1138 	/** tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call */
1139 	SCIP_RETCODE SCIPlpiIgnoreInstability(
1140 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1141 	   SCIP_Bool*            success             /**< pointer to store, whether the instability could be ignored */
1142 	   )
1143 	{  /*lint --e{715}*/
1144 	   assert(lpi != NULL);
1145 	   assert(success != NULL);
1146 	   errorMessage();
1147 	   return SCIP_PLUGINNOTFOUND;
1148 	}
1149 	
1150 	/** gets objective value of solution */
1151 	SCIP_RETCODE SCIPlpiGetObjval(
1152 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1153 	   SCIP_Real*            objval              /**< stores the objective value */
1154 	   )
1155 	{  /*lint --e{715}*/
1156 	   assert(lpi != NULL);
1157 	   assert(objval != NULL);
1158 	   errorMessage();
1159 	   return SCIP_PLUGINNOTFOUND;
1160 	}
1161 	
1162 	/** gets primal and dual solution vectors for feasible LPs
1163 	 *
1164 	 *  Before calling this function, the caller must ensure that the LP has been solved to optimality, i.e., that
1165 	 *  SCIPlpiIsOptimal() returns true.
1166 	 */
1167 	SCIP_RETCODE SCIPlpiGetSol(
1168 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1169 	   SCIP_Real*            objval,             /**< stores the objective value, may be NULL if not needed */
1170 	   SCIP_Real*            primsol,            /**< primal solution vector, may be NULL if not needed */
1171 	   SCIP_Real*            dualsol,            /**< dual solution vector, may be NULL if not needed */
1172 	   SCIP_Real*            activity,           /**< row activity vector, may be NULL if not needed */
1173 	   SCIP_Real*            redcost             /**< reduced cost vector, may be NULL if not needed */
1174 	   )
1175 	{  /*lint --e{715}*/
1176 	   assert(lpi != NULL);
1177 	   errorMessage();
1178 	   return SCIP_PLUGINNOTFOUND;
1179 	}
1180 	
1181 	/** gets primal ray for unbounded LPs */
1182 	SCIP_RETCODE SCIPlpiGetPrimalRay(
1183 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1184 	   SCIP_Real*            ray                 /**< primal ray */
1185 	   )
1186 	{  /*lint --e{715}*/
1187 	   assert(lpi != NULL);
1188 	   assert(ray != NULL);
1189 	   errorMessage();
1190 	   return SCIP_PLUGINNOTFOUND;
1191 	}
1192 	
1193 	/** gets dual Farkas proof for infeasibility */
1194 	SCIP_RETCODE SCIPlpiGetDualfarkas(
1195 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1196 	   SCIP_Real*            dualfarkas          /**< dual Farkas row multipliers */
1197 	   )
1198 	{  /*lint --e{715}*/
1199 	   assert(lpi != NULL);
1200 	   assert(dualfarkas != NULL);
1201 	   errorMessage();
1202 	   return SCIP_PLUGINNOTFOUND;
1203 	}
1204 	
1205 	/** gets the number of LP iterations of the last solve call */
1206 	SCIP_RETCODE SCIPlpiGetIterations(
1207 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1208 	   int*                  iterations          /**< pointer to store the number of iterations of the last solve call */
1209 	   )
1210 	{  /*lint --e{715}*/
1211 	   assert(lpi != NULL);
1212 	   assert(iterations != NULL);
1213 	   errorMessage();
1214 	   return SCIP_PLUGINNOTFOUND;
1215 	}
1216 	
1217 	/** gets information about the quality of an LP solution
1218 	 *
1219 	 *  Such information is usually only available, if also a (maybe not optimal) solution is available.
1220 	 *  The LPI should return SCIP_INVALID for @p quality, if the requested quantity is not available.
1221 	 */
1222 	SCIP_RETCODE SCIPlpiGetRealSolQuality(
1223 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1224 	   SCIP_LPSOLQUALITY     qualityindicator,   /**< indicates which quality should be returned */
1225 	   SCIP_Real*            quality             /**< pointer to store quality number */
1226 	   )
1227 	{ /*lint --e{715}*/
1228 	   assert(lpi != NULL);
1229 	   assert(quality != NULL);
1230 	
1231 	   *quality = SCIP_INVALID;
1232 	
1233 	   return SCIP_OKAY;
1234 	}
1235 	
1236 	/**@} */
1237 	
1238 	
1239 	
1240 	
1241 	/*
1242 	 * LP Basis Methods
1243 	 */
1244 	
1245 	/**@name LP Basis Methods */
1246 	/**@{ */
1247 	
1248 	/** gets current basis status for columns and rows; arrays must be large enough to store the basis status */
1249 	SCIP_RETCODE SCIPlpiGetBase(
1250 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1251 	   int*                  cstat,              /**< array to store column basis status, or NULL */
1252 	   int*                  rstat               /**< array to store row basis status, or NULL */
1253 	   )
1254 	{  /*lint --e{715}*/
1255 	   assert(lpi != NULL);
1256 	   errorMessage();
1257 	   return SCIP_PLUGINNOTFOUND;
1258 	}
1259 	
1260 	/** sets current basis status for columns and rows */
1261 	SCIP_RETCODE SCIPlpiSetBase(
1262 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1263 	   const int*            cstat,              /**< array with column basis status */
1264 	   const int*            rstat               /**< array with row basis status */
1265 	   )
1266 	{  /*lint --e{715}*/
1267 	   assert(lpi != NULL);
1268 	   assert(cstat != NULL);
1269 	   assert(rstat != NULL);
1270 	   errorMessage();
1271 	   return SCIP_PLUGINNOTFOUND;
1272 	}
1273 	
1274 	/** returns the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m */
1275 	SCIP_RETCODE SCIPlpiGetBasisInd(
1276 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1277 	   int*                  bind                /**< pointer to store basis indices ready to keep number of rows entries */
1278 	   )
1279 	{  /*lint --e{715}*/
1280 	   assert(lpi != NULL);
1281 	   assert(bind != NULL);
1282 	   errorMessage();
1283 	   return SCIP_PLUGINNOTFOUND;
1284 	}
1285 	
1286 	/** get row of inverse basis matrix B^-1
1287 	 *
1288 	 *  @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
1289 	 *        uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
1290 	 *        see also the explanation in lpi.h.
1291 	 */
1292 	SCIP_RETCODE SCIPlpiGetBInvRow(
1293 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1294 	   int                   r,                  /**< row number */
1295 	   SCIP_Real*            coef,               /**< pointer to store the coefficients of the row */
1296 	   int*                  inds,               /**< array to store the non-zero indices, or NULL */
1297 	   int*                  ninds               /**< pointer to store the number of non-zero indices, or NULL
1298 	                                              *   (-1: if we do not store sparsity information) */
1299 	   )
1300 	{  /*lint --e{715}*/
1301 	   assert(lpi != NULL);
1302 	   assert(coef != NULL);
1303 	   errorMessage();
1304 	   return SCIP_PLUGINNOTFOUND;
1305 	}
1306 	
1307 	/** get column of inverse basis matrix B^-1
1308 	 *
1309 	 *  @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
1310 	 *        uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
1311 	 *        see also the explanation in lpi.h.
1312 	 */
1313 	SCIP_RETCODE SCIPlpiGetBInvCol(
1314 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1315 	   int                   c,                  /**< column number of B^-1; this is NOT the number of the column in the LP;
1316 	                                              *   you have to call SCIPlpiGetBasisInd() to get the array which links the
1317 	                                              *   B^-1 column numbers to the row and column numbers of the LP!
1318 	                                              *   c must be between 0 and nrows-1, since the basis has the size
1319 	                                              *   nrows * nrows */
1320 	   SCIP_Real*            coef,               /**< pointer to store the coefficients of the column */
1321 	   int*                  inds,               /**< array to store the non-zero indices, or NULL */
1322 	   int*                  ninds               /**< pointer to store the number of non-zero indices, or NULL
1323 	                                              *   (-1: if we do not store sparsity information) */
1324 	   )
1325 	{  /*lint --e{715}*/
1326 	   assert(lpi != NULL);
1327 	   assert(coef != NULL);
1328 	   errorMessage();
1329 	   return SCIP_PLUGINNOTFOUND;
1330 	}
1331 	
1332 	/** get row of inverse basis matrix times constraint matrix B^-1 * A
1333 	 *
1334 	 *  @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
1335 	 *        uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
1336 	 *        see also the explanation in lpi.h.
1337 	 */
1338 	SCIP_RETCODE SCIPlpiGetBInvARow(
1339 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1340 	   int                   r,                  /**< row number */
1341 	   const SCIP_Real*      binvrow,            /**< row in (A_B)^-1 from prior call to SCIPlpiGetBInvRow(), or NULL */
1342 	   SCIP_Real*            coef,               /**< vector to return coefficients of the row */
1343 	   int*                  inds,               /**< array to store the non-zero indices, or NULL */
1344 	   int*                  ninds               /**< pointer to store the number of non-zero indices, or NULL
1345 	                                              *   (-1: if we do not store sparsity information) */
1346 	   )
1347 	{  /*lint --e{715}*/
1348 	   assert(lpi != NULL);
1349 	   assert(coef != NULL);
1350 	   errorMessage();
1351 	   return SCIP_PLUGINNOTFOUND;
1352 	}
1353 	
1354 	/** get column of inverse basis matrix times constraint matrix B^-1 * A
1355 	 *
1356 	 *  @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
1357 	 *        uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
1358 	 *        see also the explanation in lpi.h.
1359 	 */
1360 	SCIP_RETCODE SCIPlpiGetBInvACol(
1361 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1362 	   int                   c,                  /**< column number */
1363 	   SCIP_Real*            coef,               /**< vector to return coefficients of the column */
1364 	   int*                  inds,               /**< array to store the non-zero indices, or NULL */
1365 	   int*                  ninds               /**< pointer to store the number of non-zero indices, or NULL
1366 	                                              *   (-1: if we do not store sparsity information) */
1367 	   )
1368 	{  /*lint --e{715}*/
1369 	   assert(lpi != NULL);
1370 	   assert(coef != NULL);
1371 	   errorMessage();
1372 	   return SCIP_PLUGINNOTFOUND;
1373 	}
1374 	
1375 	/**@} */
1376 	
1377 	
1378 	
1379 	
1380 	/*
1381 	 * LP State Methods
1382 	 */
1383 	
1384 	/**@name LP State Methods */
1385 	/**@{ */
1386 	
1387 	/** stores LPi state (like basis information) into lpistate object */
1388 	SCIP_RETCODE SCIPlpiGetState(
1389 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1390 	   BMS_BLKMEM*           blkmem,             /**< block memory */
1391 	   SCIP_LPISTATE**       lpistate            /**< pointer to LPi state information (like basis information) */
1392 	   )
1393 	{  /*lint --e{715}*/
1394 	   assert(lpi != NULL);
1395 	   assert(blkmem != NULL);
1396 	   assert(lpistate != NULL);
1397 	   assert(blkmem != NULL);
1398 	   errorMessage();
1399 	   return SCIP_PLUGINNOTFOUND;
1400 	}
1401 	
1402 	/** loads LPi state (like basis information) into solver; note that the LP might have been extended with additional
1403 	 *  columns and rows since the state was stored with SCIPlpiGetState()
1404 	 */
1405 	SCIP_RETCODE SCIPlpiSetState(
1406 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1407 	   BMS_BLKMEM*           blkmem,             /**< block memory */
1408 	   const SCIP_LPISTATE*  lpistate            /**< LPi state information (like basis information), or NULL */
1409 	   )
1410 	{  /*lint --e{715}*/
1411 	   assert(lpi != NULL);
1412 	   assert(blkmem != NULL);
1413 	   assert(lpistate != NULL);
1414 	   errorMessage();
1415 	   return SCIP_PLUGINNOTFOUND;
1416 	}
1417 	
1418 	/** clears current LPi state (like basis information) of the solver */
1419 	SCIP_RETCODE SCIPlpiClearState(
1420 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1421 	   )
1422 	{  /*lint --e{715}*/
1423 	   assert(lpi != NULL);
1424 	   return SCIP_OKAY;
1425 	}
1426 	
1427 	/** frees LPi state information */
1428 	SCIP_RETCODE SCIPlpiFreeState(
1429 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1430 	   BMS_BLKMEM*           blkmem,             /**< block memory */
1431 	   SCIP_LPISTATE**       lpistate            /**< pointer to LPi state information (like basis information) */
1432 	   )
1433 	{  /*lint --e{715}*/
1434 	   assert(lpi != NULL);
1435 	   assert(lpistate != NULL);
1436 	   assert(blkmem != NULL);
1437 	   return SCIP_OKAY;
1438 	}
1439 	
1440 	/** checks, whether the given LP state contains simplex basis information */
1441 	SCIP_Bool SCIPlpiHasStateBasis(
1442 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1443 	   SCIP_LPISTATE*        lpistate            /**< LP state information (like basis information), or NULL */
1444 	   )
1445 	{  /*lint --e{715}*/
1446 	   assert(lpi != NULL);
1447 	   errorMessageAbort();
1448 	   return FALSE;
1449 	}
1450 	
1451 	/** reads LP state (like basis information from a file */
1452 	SCIP_RETCODE SCIPlpiReadState(
1453 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1454 	   const char*           fname               /**< file name */
1455 	   )
1456 	{  /*lint --e{715}*/
1457 	   assert(lpi != NULL);
1458 	   assert(fname != NULL);
1459 	   errorMessage();
1460 	   return SCIP_PLUGINNOTFOUND;
1461 	}
1462 	
1463 	/** writes LPi state (i.e. basis information) to a file */
1464 	SCIP_RETCODE SCIPlpiWriteState(
1465 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1466 	   const char*           fname               /**< file name */
1467 	   )
1468 	{  /*lint --e{715}*/
1469 	   assert(lpi != NULL);
1470 	   assert(fname != NULL);
1471 	   errorMessage();
1472 	   return SCIP_PLUGINNOTFOUND;
1473 	}
1474 	
1475 	/**@} */
1476 	
1477 	
1478 	
1479 	
1480 	/*
1481 	 * LP Pricing Norms Methods
1482 	 */
1483 	
1484 	/**@name LP Pricing Norms Methods */
1485 	/**@{ */
1486 	
1487 	/** stores LPi pricing norms information
1488 	 *  @todo should we store norm information?
1489 	 */
1490 	SCIP_RETCODE SCIPlpiGetNorms(
1491 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1492 	   BMS_BLKMEM*           blkmem,             /**< block memory */
1493 	   SCIP_LPINORMS**       lpinorms            /**< pointer to LPi pricing norms information */
1494 	   )
1495 	{  /*lint --e{715}*/
1496 	   assert(lpi != NULL);
1497 	   assert(blkmem != NULL);
1498 	   assert(lpinorms != NULL);
1499 	   errorMessage();
1500 	   return SCIP_PLUGINNOTFOUND;
1501 	}
1502 	
1503 	/** loads LPi pricing norms into solver; note that the LP might have been extended with additional
1504 	 *  columns and rows since the state was stored with SCIPlpiGetNorms()
1505 	 */
1506 	SCIP_RETCODE SCIPlpiSetNorms(
1507 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1508 	   BMS_BLKMEM*           blkmem,             /**< block memory */
1509 	   const SCIP_LPINORMS*  lpinorms            /**< LPi pricing norms information, or NULL */
1510 	   )
1511 	{  /*lint --e{715}*/
1512 	   assert(lpi != NULL);
1513 	   errorMessage();
1514 	   return SCIP_PLUGINNOTFOUND;
1515 	}
1516 	
1517 	/** frees pricing norms information */
1518 	SCIP_RETCODE SCIPlpiFreeNorms(
1519 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1520 	   BMS_BLKMEM*           blkmem,             /**< block memory */
1521 	   SCIP_LPINORMS**       lpinorms            /**< pointer to LPi pricing norms information, or NULL */
1522 	   )
1523 	{  /*lint --e{715}*/
1524 	   assert(lpi != NULL);
1525 	   errorMessage();
1526 	   return SCIP_PLUGINNOTFOUND;
1527 	}
1528 	
1529 	/**@} */
1530 	
1531 	
1532 	
1533 	
1534 	/*
1535 	 * Parameter Methods
1536 	 */
1537 	
1538 	/**@name Parameter Methods */
1539 	/**@{ */
1540 	
1541 	/** gets integer parameter of LP */
1542 	SCIP_RETCODE SCIPlpiGetIntpar(
1543 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1544 	   SCIP_LPPARAM          type,               /**< parameter number */
1545 	   int*                  ival                /**< buffer to store the parameter value */
1546 	   )
1547 	{  /*lint --e{715}*/
1548 	   assert(lpi != NULL);
1549 	   assert(ival != NULL);
1550 	   return SCIP_PARAMETERUNKNOWN;
1551 	}
1552 	
1553 	/** sets integer parameter of LP */
1554 	SCIP_RETCODE SCIPlpiSetIntpar(
1555 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1556 	   SCIP_LPPARAM          type,               /**< parameter number */
1557 	   int                   ival                /**< parameter value */
1558 	   )
1559 	{  /*lint --e{715}*/
1560 	   assert(lpi != NULL);
1561 	   return SCIP_PARAMETERUNKNOWN;
1562 	}
1563 	
1564 	/** gets floating point parameter of LP */
1565 	SCIP_RETCODE SCIPlpiGetRealpar(
1566 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1567 	   SCIP_LPPARAM          type,               /**< parameter number */
1568 	   SCIP_Real*            dval                /**< buffer to store the parameter value */
1569 	   )
1570 	{  /*lint --e{715}*/
1571 	   assert(lpi != NULL);
1572 	   assert(dval != NULL);
1573 	   return SCIP_PARAMETERUNKNOWN;
1574 	}
1575 	
1576 	/** sets floating point parameter of LP */
1577 	SCIP_RETCODE SCIPlpiSetRealpar(
1578 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1579 	   SCIP_LPPARAM          type,               /**< parameter number */
1580 	   SCIP_Real             dval                /**< parameter value */
1581 	   )
1582 	{  /*lint --e{715}*/
1583 	   assert(lpi != NULL);
1584 	   return SCIP_PARAMETERUNKNOWN;
1585 	}
1586 	
1587 	/** interrupts the currently ongoing lp solve or disables the interrupt */
1588 	SCIP_RETCODE SCIPlpiInterrupt(
1589 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1590 	   SCIP_Bool             interrupt           /**< TRUE if interrupt should be set, FALSE if it should be disabled */
1591 	   )
1592 	{
1593 	   /*lint --e{715}*/
1594 	   assert(lpi != NULL);
1595 	
1596 	   return SCIP_OKAY;
1597 	}
1598 	
1599 	/**@} */
1600 	
1601 	/*
1602 	 * Numerical Methods
1603 	 */
1604 	
1605 	/**@name Numerical Methods */
1606 	/**@{ */
1607 	
1608 	/** returns value treated as infinity in the LP solver */
1609 	SCIP_Real SCIPlpiInfinity(
1610 	   SCIP_LPI*             lpi                 /**< LP interface structure */
1611 	   )
1612 	{  /*lint --e{715}*/
1613 	   assert(lpi != NULL);
1614 	   return LPIINFINITY;
1615 	}
1616 	
1617 	/** checks if given value is treated as infinity in the LP solver */
1618 	SCIP_Bool SCIPlpiIsInfinity(
1619 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1620 	   SCIP_Real             val                 /**< value to be checked for infinity */
1621 	   )
1622 	{  /*lint --e{715}*/
1623 	   assert(lpi != NULL);
1624 	   if( val >= LPIINFINITY )
1625 	      return TRUE;
1626 	   return FALSE;
1627 	}
1628 	
1629 	/**@} */
1630 	
1631 	
1632 	
1633 	
1634 	/*
1635 	 * File Interface Methods
1636 	 */
1637 	
1638 	/**@name File Interface Methods */
1639 	/**@{ */
1640 	
1641 	/** reads LP from a file */
1642 	SCIP_RETCODE SCIPlpiReadLP(
1643 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1644 	   const char*           fname               /**< file name */
1645 	   )
1646 	{  /*lint --e{715}*/
1647 	   assert(lpi != NULL);
1648 	   assert(fname != NULL);
1649 	   errorMessage();
1650 	   return SCIP_PLUGINNOTFOUND;
1651 	}
1652 	
1653 	/** writes LP to a file */
1654 	SCIP_RETCODE SCIPlpiWriteLP(
1655 	   SCIP_LPI*             lpi,                /**< LP interface structure */
1656 	   const char*           fname               /**< file name */
1657 	   )
1658 	{  /*lint --e{715}*/
1659 	   assert(lpi != NULL);
1660 	   errorMessage();
1661 	   return SCIP_PLUGINNOTFOUND;
1662 	}
1663 	
1664 	/**@} */
1665