Scippy

SCIP

Solving Constraint Integer Programs

lpi_none.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (c) 2002-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
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
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 */
96  void
97  )
98 {
99  return LPINAME;
100 }
101 
102 /** gets description of LP solver (developer, webpage, ...) */
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 */
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 */
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 */
131  void
132  )
133 {
134  return FALSE;
135 }
136 
137 /** informs about availability of a dual simplex solving method */
139  void
140  )
141 {
142  return FALSE;
143 }
144 
145 /** informs about availability of a barrier solving method */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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  */
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 */
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 */
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 */
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  */
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  */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
933  SCIP_LPI* lpi /**< LP interface structure */
934  )
935 { /*lint --e{715}*/
936  assert(lpi != NULL);
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  */
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  */
968  SCIP_LPI* lpi /**< LP interface structure */
969  )
970 { /*lint --e{715}*/
971  assert(lpi != NULL);
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  */
980  SCIP_LPI* lpi /**< LP interface structure */
981  )
982 { /*lint --e{715}*/
983  assert(lpi != NULL);
985  return FALSE;
986 }
987 
988 /** returns TRUE iff LP is proven to be primal unbounded */
990  SCIP_LPI* lpi /**< LP interface structure */
991  )
992 { /*lint --e{715}*/
993  assert(lpi != NULL);
995  return FALSE;
996 }
997 
998 /** returns TRUE iff LP is proven to be primal infeasible */
1000  SCIP_LPI* lpi /**< LP interface structure */
1001  )
1002 { /*lint --e{715}*/
1003  assert(lpi != NULL);
1005  return FALSE;
1006 }
1007 
1008 /** returns TRUE iff LP is proven to be primal feasible */
1010  SCIP_LPI* lpi /**< LP interface structure */
1011  )
1012 { /*lint --e{715}*/
1013  assert(lpi != NULL);
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  */
1022  SCIP_LPI* lpi /**< LP interface structure */
1023  )
1024 { /*lint --e{715}*/
1025  assert(lpi != NULL);
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  */
1034  SCIP_LPI* lpi /**< LP interface structure */
1035  )
1036 { /*lint --e{715}*/
1037  assert(lpi != NULL);
1039  return FALSE;
1040 }
1041 
1042 /** returns TRUE iff LP is proven to be dual unbounded */
1044  SCIP_LPI* lpi /**< LP interface structure */
1045  )
1046 { /*lint --e{715}*/
1047  assert(lpi != NULL);
1049  return FALSE;
1050 }
1051 
1052 /** returns TRUE iff LP is proven to be dual infeasible */
1054  SCIP_LPI* lpi /**< LP interface structure */
1055  )
1056 { /*lint --e{715}*/
1057  assert(lpi != NULL);
1059  return FALSE;
1060 }
1061 
1062 /** returns TRUE iff LP is proven to be dual feasible */
1064  SCIP_LPI* lpi /**< LP interface structure */
1065  )
1066 { /*lint --e{715}*/
1067  assert(lpi != NULL);
1069  return FALSE;
1070 }
1071 
1072 /** returns TRUE iff LP was solved to optimality */
1074  SCIP_LPI* lpi /**< LP interface structure */
1075  )
1076 { /*lint --e{715}*/
1077  assert(lpi != NULL);
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  */
1090  SCIP_LPI* lpi /**< LP interface structure */
1091  )
1092 { /*lint --e{715}*/
1093  assert(lpi != NULL);
1095  return FALSE;
1096 }
1097 
1098 /** returns TRUE iff the objective limit was reached */
1100  SCIP_LPI* lpi /**< LP interface structure */
1101  )
1102 { /*lint --e{715}*/
1103  assert(lpi != NULL);
1105  return FALSE;
1106 }
1107 
1108 /** returns TRUE iff the iteration limit was reached */
1110  SCIP_LPI* lpi /**< LP interface structure */
1111  )
1112 { /*lint --e{715}*/
1113  assert(lpi != NULL);
1115  return FALSE;
1116 }
1117 
1118 /** returns TRUE iff the time limit was reached */
1120  SCIP_LPI* lpi /**< LP interface structure */
1121  )
1122 { /*lint --e{715}*/
1123  assert(lpi != NULL);
1125  return FALSE;
1126 }
1127 
1128 /** returns the internal solution status of the solver */
1130  SCIP_LPI* lpi /**< LP interface structure */
1131  )
1132 { /*lint --e{715}*/
1133  assert(lpi != NULL);
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 */
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 */
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  */
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 */
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 */
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 */
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  */
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 */
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 */
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 */
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  */
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  */
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  */
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  */
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 */
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  */
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 */
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 */
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 */
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);
1448  return FALSE;
1449 }
1450 
1451 /** reads LP state (like basis information from a file */
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 */
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  */
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  */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 /**@} */
SCIP_RETCODE SCIPlpiGetBInvCol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
Definition: lpi_none.c:1313
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
Definition: lpi_none.c:567
enum SCIP_LPSolQuality SCIP_LPSOLQUALITY
Definition: type_lpi.h:104
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
Definition: lpi_none.c:187
SCIP_RETCODE SCIPlpiSetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPISTATE *lpistate)
Definition: lpi_none.c:1405
SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)
Definition: lpi_none.c:1618
SCIP_Bool SCIPlpiIsDualUnbounded(SCIP_LPI *lpi)
Definition: lpi_none.c:1043
SCIP_RETCODE SCIPlpiSetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPINORMS *lpinorms)
Definition: lpi_none.c:1506
int nrows
Definition: lpi_none.c:52
SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
Definition: lpi_none.c:1194
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
Definition: lpi_none.c:801
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
Definition: lpi_none.c:1167
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
Definition: lpi_none.c:1554
enum SCIP_ObjSen SCIP_OBJSEN
Definition: type_lpi.h:45
SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)
Definition: lpi_none.c:770
void * SCIPlpiGetSolverPointer(SCIP_LPI *lpi)
Definition: lpi_none.c:111
SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
Definition: lpi_none.c:1249
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
Definition: lpi_none.c:479
SCIP_RETCODE SCIPlpiGetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int *ival)
Definition: lpi_none.c:1542
interface methods for specific LP solvers
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
Definition: lpi_none.c:1206
static void errorMessageAbort(void)
Definition: lpi_none.c:63
SCIP_RETCODE SCIPlpiGetNNonz(SCIP_LPI *lpi, int *nnonz)
Definition: lpi_none.c:597
#define FALSE
Definition: def.h:96
#define TRUE
Definition: def.h:95
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
Definition: lpi_none.c:1577
SCIP_Bool SCIPlpiHasPrimalRay(SCIP_LPI *lpi)
Definition: lpi_none.c:979
SCIP_RETCODE SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
Definition: lpi_none.c:1490
enum SCIP_LPParam SCIP_LPPARAM
Definition: type_lpi.h:73
SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
Definition: lpi_none.c:582
SCIP_RETCODE SCIPlpiReadState(SCIP_LPI *lpi, const char *fname)
Definition: lpi_none.c:1452
#define SCIPdebugMessage
Definition: pub_message.h:96
SCIP_Bool SCIPlpiHasDualSolve(void)
Definition: lpi_none.c:138
SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)
Definition: lpi_none.c:714
SCIP_RETCODE SCIPlpiClear(SCIP_LPI *lpi)
Definition: lpi_none.c:431
SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)
Definition: lpi_none.c:1222
SCIP_RETCODE SCIPlpiScaleCol(SCIP_LPI *lpi, int col, SCIP_Real scaleval)
Definition: lpi_none.c:544
SCIP_RETCODE SCIPlpiGetObjsen(SCIP_LPI *lpi, SCIP_OBJSEN *objsen)
Definition: lpi_none.c:689
#define BMSfreeMemory(ptr)
Definition: memory.h:147
SCIP_RETCODE SCIPlpiSetIntegralityInformation(SCIP_LPI *lpi, int ncols, int *intInfo)
Definition: lpi_none.c:119
SCIP_RETCODE SCIPlpiClearState(SCIP_LPI *lpi)
Definition: lpi_none.c:1419
SCIP_RETCODE SCIPlpiGetCols(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lb, SCIP_Real *ub, int *nnonz, int *beg, int *ind, SCIP_Real *val)
Definition: lpi_none.c:612
SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
Definition: lpi_none.c:166
SCIP_RETCODE SCIPlpiGetBInvARow(SCIP_LPI *lpi, int r, const SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
Definition: lpi_none.c:1338
SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
Definition: lpi_none.c:257
SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)
Definition: lpi_none.c:989
int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)
Definition: lpi_none.c:1129
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
Definition: lpi_none.c:780
SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)
Definition: lpi_none.c:1089
SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
Definition: lpi_none.c:346
SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)
Definition: lpi_none.c:1654
#define SCIPerrorMessage
Definition: pub_message.h:64
int ncols
Definition: lpi_none.c:53
SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI *lpi, int *bind)
Definition: lpi_none.c:1275
SCIP_RETCODE SCIPlpiStrongbranchesFrac(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
Definition: lpi_none.c:843
static void errorMessage(void)
Definition: lpi_none.c:74
SCIP_RETCODE SCIPlpiFreeState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
Definition: lpi_none.c:1428
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
Definition: lpi_none.c:999
SCIP_RETCODE SCIPlpiGetColNames(SCIP_LPI *lpi, int firstcol, int lastcol, char **colnames, char *namestorage, int namestoragesize, int *storageleft)
Definition: lpi_none.c:649
SCIP_RETCODE SCIPlpiStrongbranchFrac(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
Definition: lpi_none.c:819
#define NULL
Definition: lpi_spx1.cpp:164
SCIP_RETCODE SCIPlpiStrongbranchesInt(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
Definition: lpi_none.c:894
int * rstat
Definition: lpi_clp.cpp:108
const char * SCIPlpiGetSolverDesc(void)
Definition: lpi_none.c:103
SCIP_Bool SCIPlpiHasBarrierSolve(void)
Definition: lpi_none.c:146
SCIP_RETCODE SCIPlpiGetSolFeasibility(SCIP_LPI *lpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
Definition: lpi_none.c:951
SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
Definition: lpi_none.c:1518
SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI *lpi, int firstrow, int lastrow)
Definition: lpi_none.c:384
SCIP_RETCODE SCIPlpiReadLP(SCIP_LPI *lpi, const char *fname)
Definition: lpi_none.c:1642
SCIP_Bool SCIPlpiWasSolved(SCIP_LPI *lpi)
Definition: lpi_none.c:932
SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)
Definition: lpi_none.c:967
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
Definition: lpi_none.c:1151
SCIP_RETCODE SCIPlpiDelRowset(SCIP_LPI *lpi, int *dstat)
Definition: lpi_none.c:400
#define SCIP_Bool
Definition: def.h:93
SCIP_Bool SCIPlpiHasStateBasis(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)
Definition: lpi_none.c:1441
SCIP_RETCODE SCIPlpiDelCols(SCIP_LPI *lpi, int firstcol, int lastcol)
Definition: lpi_none.c:299
SCIP_RETCODE SCIPlpiWriteState(SCIP_LPI *lpi, const char *fname)
Definition: lpi_none.c:1464
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
Definition: lpi_none.c:1609
SCIP_RETCODE SCIPlpiChgCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real newval)
Definition: lpi_none.c:495
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
Definition: lpi_none.c:1063
SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
Definition: lpi_none.c:1388
SCIP_Bool SCIPlpiIsDualInfeasible(SCIP_LPI *lpi)
Definition: lpi_none.c:1053
SCIP_RETCODE SCIPlpiGetRowNames(SCIP_LPI *lpi, int firstrow, int lastrow, char **rownames, char *namestorage, int namestoragesize, int *storageleft)
Definition: lpi_none.c:669
#define LPIINFINITY
Definition: lpi_none.c:39
SCIP_RETCODE SCIPlpiSetBase(SCIP_LPI *lpi, const int *cstat, const int *rstat)
Definition: lpi_none.c:1261
#define LPINAME
Definition: lpi_none.c:38
int iterations
Definition: lpi_cpx.c:166
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
Definition: lpi_none.c:1073
SCIP_Bool SCIPlpiHasPrimalSolve(void)
Definition: lpi_none.c:130
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
Definition: lpi_none.c:446
SCIP_Bool SCIPlpiIsTimelimExc(SCIP_LPI *lpi)
Definition: lpi_none.c:1119
SCIP_Real * r
Definition: circlepacking.c:59
SCIP_RETCODE SCIPlpiGetRows(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhs, SCIP_Real *rhs, int *nnonz, int *beg, int *ind, SCIP_Real *val)
Definition: lpi_none.c:632
SCIP_RETCODE SCIPlpiStrongbranchInt(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
Definition: lpi_none.c:870
SCIP_RETCODE SCIPlpiSolveBarrier(SCIP_LPI *lpi, SCIP_Bool crossover)
Definition: lpi_none.c:790
SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI *lpi, SCIP_Real *ray)
Definition: lpi_none.c:1182
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
Definition: lpi_none.c:810
SCIP_RETCODE SCIPlpiLoadColLP(SCIP_LPI *lpi, SCIP_OBJSEN objsen, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
Definition: lpi_none.c:212
SCIP_RETCODE SCIPlpiScaleRow(SCIP_LPI *lpi, int row, SCIP_Real scaleval)
Definition: lpi_none.c:531
SCIP_RETCODE SCIPlpiGetSides(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhss, SCIP_Real *rhss)
Definition: lpi_none.c:729
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
Definition: lpi_none.c:1033
public methods for message output
SCIP_RETCODE SCIPlpiGetBInvACol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
Definition: lpi_none.c:1360
SCIP_RETCODE SCIPlpiGetObj(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *vals)
Definition: lpi_none.c:699
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
Definition: lpi_none.c:1099
#define SCIP_Real
Definition: def.h:186
SCIP_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)
Definition: lpi_none.c:1009
#define BMSallocMemory(ptr)
Definition: memory.h:120
#define SCIP_INVALID
Definition: def.h:206
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
Definition: lpi_none.c:517
SCIP_Bool SCIPlpiExistsDualRay(SCIP_LPI *lpi)
Definition: lpi_none.c:1021
SCIP_MESSAGEHDLR * messagehdlr
Definition: lpi_cpx.c:184
SCIP_RETCODE SCIPlpiInterrupt(SCIP_LPI *lpi, SCIP_Bool interrupt)
Definition: lpi_none.c:1588
SCIP_Bool SCIPlpiIsIterlimExc(SCIP_LPI *lpi)
Definition: lpi_none.c:1109
SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)
Definition: lpi_none.c:744
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:439
SCIP_RETCODE SCIPlpiChgObjsen(SCIP_LPI *lpi, SCIP_OBJSEN objsen)
Definition: lpi_none.c:507
SCIP_RETCODE SCIPlpiGetBInvRow(SCIP_LPI *lpi, int r, SCIP_Real *coef, int *inds, int *ninds)
Definition: lpi_none.c:1292
#define SCIP_ALLOC(x)
Definition: def.h:405
#define SCIPABORT()
Definition: def.h:366
const char * SCIPlpiGetSolverName(void)
Definition: lpi_none.c:95
char name[200]
Definition: lpi_xprs.c:90
int * cstat
Definition: lpi_clp.cpp:107
SCIP_RETCODE SCIPlpiIgnoreInstability(SCIP_LPI *lpi, SCIP_Bool *success)
Definition: lpi_none.c:1139
SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
Definition: lpi_none.c:1565
SCIP_RETCODE SCIPlpiDelColset(SCIP_LPI *lpi, int *dstat)
Definition: lpi_none.c:315