source: ThirdParty/SCIP/trunk/lpiswitch.c @ 2690

Last change on this file since 2690 was 2690, checked in by stefan, 7 years ago

allow for several LP solvers in one SCIP library - yeah :-)

  • Property svn:eol-style set to native
File size: 69.6 KB
Line 
1/* Copyright (C) 2012 Stefan Vigerske and others
2 * All Rights Reserved.
3 * This code is published under the Eclipse Public License.
4 *
5 * Author: Stefan Vigerske
6 */
7
8#include <stdlib.h>
9
10#include "config_scip.h"
11#undef SCIP_VERSION
12
13#include "scip/scip.h"
14#include "lpiswitch.h"
15
16/*
17 *  declaration of LPI functions for all available LP solvers
18 */
19
20#ifdef COIN_HAS_CLP
21#define LPISW_RENAME_SUFFIX Clp
22#include "lpiswitch_rename.h"
23#undef __SCIP_LPI_H__
24#include "scip/lpi.h"
25#include "lpiswitch_unrename.h"
26#endif
27
28#ifdef COIN_HAS_CPX
29#undef LPISW_RENAME_SUFFIX
30#define LPISW_RENAME_SUFFIX Cplex
31#include "lpiswitch_rename.h"
32#undef __SCIP_LPI_H__
33#include "scip/lpi.h"
34#include "lpiswitch_unrename.h"
35#endif
36
37#ifdef COIN_HAS_GRB
38#undef LPISW_RENAME_SUFFIX
39#define LPISW_RENAME_SUFFIX Gurobi
40#include "lpiswitch_rename.h"
41#undef __SCIP_LPI_H__
42#include "scip/lpi.h"
43#include "lpiswitch_unrename.h"
44#endif
45
46#ifdef COIN_HAS_MSK
47#undef LPISW_RENAME_SUFFIX
48#define LPISW_RENAME_SUFFIX Mosek
49#include "lpiswitch_rename.h"
50#undef __SCIP_LPI_H__
51#include "scip/lpi.h"
52#include "lpiswitch_unrename.h"
53#endif
54
55#ifdef COIN_HAS_QSO
56#undef LPISW_RENAME_SUFFIX
57#define LPISW_RENAME_SUFFIX Qsopt
58#include "lpiswitch_rename.h"
59#undef __SCIP_LPI_H__
60#include "scip/lpi.h"
61#include "lpiswitch_unrename.h"
62#endif
63
64#undef LPISW_RENAME_SUFFIX
65#define LPISW_RENAME_SUFFIX None
66#include "lpiswitch_rename.h"
67#undef __SCIP_LPI_H__
68#include "scip/lpi.h"
69#include "lpiswitch_unrename.h"
70
71#ifdef COIN_HAS_SOPLEX
72#undef LPISW_RENAME_SUFFIX
73#define LPISW_RENAME_SUFFIX Soplex
74#include "lpiswitch_rename.h"
75#undef __SCIP_LPI_H__
76#include "scip/lpi.h"
77#include "lpiswitch_unrename.h"
78#endif
79
80#ifdef COIN_HAS_XPR
81#undef LPISW_RENAME_SUFFIX
82#define LPISW_RENAME_SUFFIX Xpress
83#include "lpiswitch_rename.h"
84#undef __SCIP_LPI_H__
85#include "scip/lpi.h"
86#include "lpiswitch_unrename.h"
87#endif
88
89/*
90 *  macros for function pointer declarations
91 */
92
93#define LPISW_DECL_LPIGETSOLVERNAME(x) const char* x (void)
94
95#define LPISW_DECL_LPIGETSOLVERDESC(x) const char* x (void)
96
97#define LPISW_DECL_LPIGETSOLVERPOINTER(x) void* x (SCIP_LPI* lpi)
98
99#define LPISW_DECL_LPICREATE(x) SCIP_RETCODE x ( \
100   SCIP_LPI**            lpi,         \
101   SCIP_MESSAGEHDLR*     messagehdlr, \
102   const char*           name,        \
103   SCIP_OBJSEN           objsen       \
104   )
105
106#define LPISW_DECL_LPIFREE(x) SCIP_RETCODE x (SCIP_LPI** lpi)
107
108#define LPISW_DECL_LPILOADCOLLP(x) SCIP_RETCODE x ( \
109   SCIP_LPI*             lpi,       \
110   SCIP_OBJSEN           objsen,    \
111   int                   ncols,     \
112   const SCIP_Real*      obj,       \
113   const SCIP_Real*      lb,        \
114   const SCIP_Real*      ub,        \
115   char**                colnames,  \
116   int                   nrows,     \
117   const SCIP_Real*      lhs,       \
118   const SCIP_Real*      rhs,       \
119   char**                rownames,  \
120   int                   nnonz,     \
121   const int*            beg,       \
122   const int*            ind,       \
123   const SCIP_Real*      val        \
124   )
125
126#define LPISW_DECL_LPIADDCOLS(x) SCIP_RETCODE x ( \
127   SCIP_LPI*             lpi,       \
128   int                   ncols,     \
129   const SCIP_Real*      obj,       \
130   const SCIP_Real*      lb,        \
131   const SCIP_Real*      ub,        \
132   char**                colnames,  \
133   int                   nnonz,     \
134   const int*            beg,       \
135   const int*            ind,       \
136   const SCIP_Real*      val        \
137   )
138
139#define LPISW_DECL_LPIDELCOLS(x) SCIP_RETCODE x ( \
140   SCIP_LPI*             lpi,       \
141   int                   firstcol,  \
142   int                   lastcol    \
143   )
144
145#define LPISW_DECL_LPIDELCOLSET(x) SCIP_RETCODE x ( \
146   SCIP_LPI*             lpi,   \
147   int*                  dstat  \
148   )
149
150#define LPISW_DECL_LPIADDROWS(x) SCIP_RETCODE x ( \
151   SCIP_LPI*             lpi,      \
152   int                   nrows,    \
153   const SCIP_Real*      lhs,      \
154   const SCIP_Real*      rhs,      \
155   char**                rownames, \
156   int                   nnonz,    \
157   const int*            beg,      \
158   const int*            ind,      \
159   const SCIP_Real*      val       \
160   )
161
162#define LPISW_DECL_LPIDELROWS(x) SCIP_RETCODE x ( \
163   SCIP_LPI*             lpi,       \
164   int                   firstrow,  \
165   int                   lastrow    \
166   )
167
168#define LPISW_DECL_LPIDELROWSET(x) SCIP_RETCODE x ( \
169   SCIP_LPI*             lpi,   \
170   int*                  dstat  \
171   )
172
173#define LPISW_DECL_LPICLEAR(x) SCIP_RETCODE x ( SCIP_LPI* lpi )
174
175#define LPISW_DECL_LPICHGBOUNDS(x) SCIP_RETCODE x ( \
176   SCIP_LPI*             lpi,   \
177   int                   ncols, \
178   const int*            ind,   \
179   const SCIP_Real*      lb,    \
180   const SCIP_Real*      ub     \
181   )
182
183#define LPISW_DECL_LPICHGSIDES(x) SCIP_RETCODE x ( \
184   SCIP_LPI*             lpi,    \
185   int                   nrows,  \
186   const int*            ind,    \
187   const SCIP_Real*      lhs,    \
188   const SCIP_Real*      rhs     \
189   )
190
191#define LPISW_DECL_LPICHGCOEF(x) SCIP_RETCODE x ( \
192   SCIP_LPI*             lpi,    \
193   int                   row,    \
194   int                   col,    \
195   SCIP_Real             newval  \
196   )
197
198#define LPISW_DECL_LPICHGOBJSEN(x) SCIP_RETCODE x ( \
199   SCIP_LPI*             lpi,    \
200   SCIP_OBJSEN           objsen  \
201   )
202
203#define LPISW_DECL_LPICHGOBJ(x) SCIP_RETCODE x ( \
204   SCIP_LPI*             lpi,    \
205   int                   ncols,  \
206   int*                  ind,    \
207   SCIP_Real*            obj     \
208   )
209
210#define LPISW_DECL_LPISCALEROW(x) SCIP_RETCODE x ( \
211   SCIP_LPI*             lpi,     \
212   int                   row,     \
213   SCIP_Real             scaleval \
214   )
215
216#define LPISW_DECL_LPISCALECOL(x) SCIP_RETCODE x ( \
217   SCIP_LPI*             lpi,      \
218   int                   col,      \
219   SCIP_Real             scaleval  \
220   )
221
222#define LPISW_DECL_LPIGETNROWS(x) SCIP_RETCODE x ( \
223   SCIP_LPI*             lpi,    \
224   int*                  nrows   \
225   )
226
227#define LPISW_DECL_LPIGETNCOLS(x) SCIP_RETCODE x ( \
228   SCIP_LPI*             lpi,    \
229   int*                  ncols   \
230   )
231
232#define LPISW_DECL_LPIGETOBJSEN(x) SCIP_RETCODE x ( \
233   SCIP_LPI*             lpi,    \
234   SCIP_OBJSEN*          objsen  \
235   )
236
237#define LPISW_DECL_LPIGETNNONZ(x) SCIP_RETCODE x ( \
238   SCIP_LPI*             lpi,   \
239   int*                  nnonz  \
240   )
241
242#define LPISW_DECL_LPIGETCOLS(x) SCIP_RETCODE x ( \
243   SCIP_LPI*             lpi,      \
244   int                   firstcol, \
245   int                   lastcol,  \
246   SCIP_Real*            lb,       \
247   SCIP_Real*            ub,       \
248   int*                  nnonz,    \
249   int*                  beg,      \
250   int*                  ind,      \
251   SCIP_Real*            val       \
252   )
253
254#define LPISW_DECL_LPIGETROWS(x) SCIP_RETCODE x ( \
255   SCIP_LPI*             lpi,                \
256   int                   firstrow,           \
257   int                   lastrow,            \
258   SCIP_Real*            lhs,                \
259   SCIP_Real*            rhs,                \
260   int*                  nnonz,              \
261   int*                  beg,                \
262   int*                  ind,                \
263   SCIP_Real*            val                 \
264   )
265
266#define LPISW_DECL_LPIGETCOLNAMES(x) SCIP_RETCODE x ( \
267   SCIP_LPI*             lpi,                \
268   int                   firstcol,           \
269   int                   lastcol,            \
270   char**                colnames,           \
271   char*                 namestorage,        \
272   int                   namestoragesize,    \
273   int*                  storageleft         \
274   )
275
276#define LPISW_DECL_LPIGETROWNAMES(x) SCIP_RETCODE x ( \
277   SCIP_LPI*             lpi,                \
278   int                   firstrow,           \
279   int                   lastrow,            \
280   char**                rownames,           \
281   char*                 namestorage,        \
282   int                   namestoragesize,    \
283   int*                  storageleft         \
284   )
285
286#define LPISW_DECL_LPIGETOBJ(x) SCIP_RETCODE x ( \
287   SCIP_LPI*             lpi,                \
288   int                   firstcol,           \
289   int                   lastcol,            \
290   SCIP_Real*            vals                \
291   )
292
293#define LPISW_DECL_LPIGETBOUNDS(x) SCIP_RETCODE x ( \
294   SCIP_LPI*             lpi,                \
295   int                   firstcol,           \
296   int                   lastcol,            \
297   SCIP_Real*            lbs,                \
298   SCIP_Real*            ubs                 \
299   )
300
301#define LPISW_DECL_LPIGETSIDES(x) SCIP_RETCODE x ( \
302   SCIP_LPI*             lpi,                \
303   int                   firstrow,           \
304   int                   lastrow,            \
305   SCIP_Real*            lhss,               \
306   SCIP_Real*            rhss                \
307   )
308
309#define LPISW_DECL_LPIGETCOEF(x) SCIP_RETCODE x ( \
310   SCIP_LPI*             lpi,                \
311   int                   row,                \
312   int                   col,                \
313   SCIP_Real*            val                 \
314   )
315
316#define LPISW_DECL_LPISOLVEPRIMAL(x) SCIP_RETCODE x ( \
317   SCIP_LPI*             lpi                 \
318   )
319
320#define LPISW_DECL_LPISOLVEDUAL(x) SCIP_RETCODE x ( \
321   SCIP_LPI*             lpi                 \
322   )
323
324#define LPISW_DECL_LPISOLVEBARRIER(x) SCIP_RETCODE x ( \
325   SCIP_LPI*             lpi,                \
326   SCIP_Bool             crossover           \
327   )
328
329#define LPISW_DECL_LPISTARTSTRONGBRANCH(x) SCIP_RETCODE x ( \
330   SCIP_LPI*             lpi                 \
331   )
332
333#define LPISW_DECL_LPIENDSTRONGBRANCH(x) SCIP_RETCODE x ( \
334   SCIP_LPI*             lpi                 \
335   )
336
337#define LPISW_DECL_LPISTRONGBRANCHFRAC(x) SCIP_RETCODE x ( \
338   SCIP_LPI*             lpi,                \
339   int                   col,                \
340   SCIP_Real             psol,               \
341   int                   itlim,              \
342   SCIP_Real*            down,               \
343   SCIP_Real*            up,                 \
344   SCIP_Bool*            downvalid,          \
345   SCIP_Bool*            upvalid,            \
346   int*                  iter                \
347   )
348
349#define LPISW_DECL_LPISTRONGBRANCHESFRAC(x) SCIP_RETCODE x ( \
350   SCIP_LPI*             lpi,                \
351   int*                  cols,               \
352   int                   ncols,              \
353   SCIP_Real*            psols,              \
354   int                   itlim,              \
355   SCIP_Real*            down,               \
356   SCIP_Real*            up,                 \
357   SCIP_Bool*            downvalid,          \
358   SCIP_Bool*            upvalid,            \
359   int*                  iter                \
360   )
361
362#define LPISW_DECL_LPISTRONGBRANCHINT(x) SCIP_RETCODE x ( \
363   SCIP_LPI*             lpi,                \
364   int                   col,                \
365   SCIP_Real             psol,               \
366   int                   itlim,              \
367   SCIP_Real*            down,               \
368   SCIP_Real*            up,                 \
369   SCIP_Bool*            downvalid,          \
370   SCIP_Bool*            upvalid,            \
371   int*                  iter                \
372   )
373
374#define LPISW_DECL_LPISTRONGBRANCHESINT(x) SCIP_RETCODE x ( \
375   SCIP_LPI*             lpi,                \
376   int*                  cols,               \
377   int                   ncols,              \
378   SCIP_Real*            psols,              \
379   int                   itlim,              \
380   SCIP_Real*            down,               \
381   SCIP_Real*            up,                 \
382   SCIP_Bool*            downvalid,          \
383   SCIP_Bool*            upvalid,            \
384   int*                  iter                \
385   )
386
387#define LPISW_DECL_LPIWASSOLVED(x) SCIP_Bool x ( \
388   SCIP_LPI*             lpi                 \
389   )
390
391#define LPISW_DECL_LPIGETSOLFEASIBILITY(x) SCIP_RETCODE x ( \
392   SCIP_LPI*             lpi,                \
393   SCIP_Bool*            primalfeasible,     \
394   SCIP_Bool*            dualfeasible        \
395   )
396
397#define LPISW_DECL_LPIEXISTSPRIMALRAY(x) SCIP_Bool x ( \
398   SCIP_LPI*             lpi                 \
399   )
400
401#define LPISW_DECL_LPIHASPRIMALRAY(x) SCIP_Bool x ( \
402   SCIP_LPI*             lpi                 \
403   )
404
405#define LPISW_DECL_LPIISPRIMALUNBOUNDED(x) SCIP_Bool x ( \
406   SCIP_LPI*             lpi                 \
407   )
408
409#define LPISW_DECL_LPIISPRIMALINFEASIBLE(x) SCIP_Bool x ( \
410   SCIP_LPI*             lpi                 \
411   )
412
413#define LPISW_DECL_LPIISPRIMALFEASIBLE(x) SCIP_Bool x ( \
414   SCIP_LPI*             lpi                 \
415   )
416
417#define LPISW_DECL_LPIEXISTSDUALRAY(x) SCIP_Bool x ( \
418   SCIP_LPI*             lpi                 \
419   )
420
421#define LPISW_DECL_LPIHASDUALRAY(x) SCIP_Bool x ( \
422   SCIP_LPI*             lpi                 \
423   )
424
425#define LPISW_DECL_LPIISDUALUNBOUNDED(x) SCIP_Bool x ( \
426   SCIP_LPI*             lpi                 \
427   )
428
429#define LPISW_DECL_LPIISDUALINFEASIBLE(x) SCIP_Bool x ( \
430   SCIP_LPI*             lpi                 \
431   )
432
433#define LPISW_DECL_LPIISDUALFEASIBLE(x) SCIP_Bool x ( \
434   SCIP_LPI*             lpi                 \
435   )
436
437#define LPISW_DECL_LPIISOPTIMAL(x) SCIP_Bool x ( \
438   SCIP_LPI*             lpi                 \
439   )
440
441#define LPISW_DECL_LPIISSTABLE(x) SCIP_Bool x ( \
442   SCIP_LPI*             lpi                 \
443   )
444
445#define LPISW_DECL_LPIISOBJLIMEXC(x) SCIP_Bool x ( \
446   SCIP_LPI*             lpi                 \
447   )
448
449#define LPISW_DECL_LPIISITERLIMEXC(x) SCIP_Bool x ( \
450   SCIP_LPI*             lpi                 \
451   )
452
453#define LPISW_DECL_LPIISTIMELIMEXC(x) SCIP_Bool x ( \
454   SCIP_LPI*             lpi                 \
455   )
456
457#define LPISW_DECL_LPIGETINTERNALSTATUS(x) int x ( \
458   SCIP_LPI*             lpi                 \
459   )
460
461#define LPISW_DECL_LPIIGNOREINSTABILITY(x) SCIP_RETCODE x ( \
462   SCIP_LPI*             lpi,                \
463   SCIP_Bool*            success             \
464   )
465
466#define LPISW_DECL_LPIGETOBJVAL(x) SCIP_RETCODE x ( \
467   SCIP_LPI*             lpi,                \
468   SCIP_Real*            objval              \
469   )
470
471#define LPISW_DECL_LPIGETSOL(x) SCIP_RETCODE x ( \
472   SCIP_LPI*             lpi,                \
473   SCIP_Real*            objval,             \
474   SCIP_Real*            primsol,            \
475   SCIP_Real*            dualsol,            \
476   SCIP_Real*            activity,           \
477   SCIP_Real*            redcost             \
478   )
479
480#define LPISW_DECL_LPIGETPRIMALRAY(x) SCIP_RETCODE x ( \
481   SCIP_LPI*             lpi,                \
482   SCIP_Real*            ray                 \
483   )
484
485#define LPISW_DECL_LPIGETDUALFARKAS(x) SCIP_RETCODE x ( \
486   SCIP_LPI*             lpi,                \
487   SCIP_Real*            dualfarkas          \
488   )
489
490#define LPISW_DECL_LPIGETITERATIONS(x) SCIP_RETCODE x ( \
491   SCIP_LPI*             lpi,                \
492   int*                  iterations          \
493   )
494
495#define LPISW_DECL_LPIGETREALSOLQUALITY(x) SCIP_RETCODE x ( \
496   SCIP_LPI*             lpi,                \
497   SCIP_LPSOLQUALITY     qualityindicator,   \
498   SCIP_Real*            quality             \
499   )
500
501#define LPISW_DECL_LPIGETBASE(x) SCIP_RETCODE x ( \
502   SCIP_LPI*             lpi,                \
503   int*                  cstat,              \
504   int*                  rstat               \
505   )
506
507#define LPISW_DECL_LPISETBASE(x) SCIP_RETCODE x ( \
508   SCIP_LPI*             lpi,                \
509   int*                  cstat,              \
510   int*                  rstat               \
511   )
512
513#define LPISW_DECL_LPIGETBASISIND(x) SCIP_RETCODE x ( \
514   SCIP_LPI*             lpi,                \
515   int*                  bind                \
516   )
517
518#define LPISW_DECL_LPIGETBINVROW(x) SCIP_RETCODE x ( \
519   SCIP_LPI*             lpi,                \
520   int                   r,                  \
521   SCIP_Real*            coef                \
522   )
523
524#define LPISW_DECL_LPIGETBINVCOL(x) SCIP_RETCODE x ( \
525   SCIP_LPI*             lpi,                \
526   int                   c,                  \
527   SCIP_Real*            coef                \
528   )
529
530#define LPISW_DECL_LPIGETBINVAROW(x) SCIP_RETCODE x ( \
531   SCIP_LPI*             lpi,                \
532   int                   r,                  \
533   const SCIP_Real*      binvrow,            \
534   SCIP_Real*            coef                \
535   )
536
537#define LPISW_DECL_LPIGETBINVACOL(x) SCIP_RETCODE x ( \
538   SCIP_LPI*             lpi,                \
539   int                   c,                  \
540   SCIP_Real*            coef                \
541   )
542
543#define LPISW_DECL_LPIGETSTATE(x) SCIP_RETCODE x ( \
544   SCIP_LPI*             lpi,                \
545   BMS_BLKMEM*           blkmem,             \
546   SCIP_LPISTATE**       lpistate            \
547   )
548
549#define LPISW_DECL_LPISETSTATE(x) SCIP_RETCODE x ( \
550   SCIP_LPI*             lpi,                \
551   BMS_BLKMEM*           blkmem,             \
552   SCIP_LPISTATE*        lpistate            \
553   )
554
555#define LPISW_DECL_LPICLEARSTATE(x) SCIP_RETCODE x ( \
556   SCIP_LPI*             lpi                 \
557   )
558
559#define LPISW_DECL_LPIFREESTATE(x) SCIP_RETCODE x ( \
560   SCIP_LPI*             lpi,                \
561   BMS_BLKMEM*           blkmem,             \
562   SCIP_LPISTATE**       lpistate            \
563   )
564
565#define LPISW_DECL_LPIHASSTATEBASIS(x) SCIP_Bool x ( \
566   SCIP_LPI*             lpi,                \
567   SCIP_LPISTATE*        lpistate            \
568   )
569
570#define LPISW_DECL_LPIREADSTATE(x) SCIP_RETCODE x ( \
571   SCIP_LPI*             lpi,                \
572   const char*           fname               \
573   )
574
575#define LPISW_DECL_LPIWRITESTATE(x) SCIP_RETCODE x ( \
576   SCIP_LPI*             lpi,                \
577   const char*           fname               \
578   )
579
580#define LPISW_DECL_LPIGETINTPAR(x) SCIP_RETCODE x ( \
581   SCIP_LPI*             lpi,                \
582   SCIP_LPPARAM          type,               \
583   int*                  ival                \
584   )
585
586#define LPISW_DECL_LPISETINTPAR(x) SCIP_RETCODE x ( \
587   SCIP_LPI*             lpi,                \
588   SCIP_LPPARAM          type,               \
589   int                   ival                \
590   )
591
592#define LPISW_DECL_LPIGETREALPAR(x) SCIP_RETCODE x ( \
593   SCIP_LPI*             lpi,                \
594   SCIP_LPPARAM          type,               \
595   SCIP_Real*            dval                \
596   )
597
598#define LPISW_DECL_LPISETREALPAR(x) SCIP_RETCODE x ( \
599   SCIP_LPI*             lpi,                \
600   SCIP_LPPARAM          type,               \
601   SCIP_Real             dval                \
602   )
603
604#define LPISW_DECL_LPIINFINITY(x) SCIP_Real x ( \
605   SCIP_LPI*             lpi                 \
606   )
607
608#define LPISW_DECL_LPIISINFINITY(x) SCIP_Bool x ( \
609   SCIP_LPI*             lpi,                \
610   SCIP_Real             val                 \
611   )
612
613#define LPISW_DECL_LPIREADLP(x) SCIP_RETCODE x ( \
614   SCIP_LPI*             lpi,                \
615   const char*           fname               \
616   )
617
618#define LPISW_DECL_LPIWRITELP(x) SCIP_RETCODE x ( \
619   SCIP_LPI*             lpi,                \
620   const char*           fname               \
621   )
622
623/*
624 *  pointer to currently used LPI functions
625 */
626
627static LPISW_DECL_LPIGETSOLVERNAME((*lpiGetSolverName)) = NULL;
628static LPISW_DECL_LPIGETSOLVERDESC((*lpiGetSolverDesc)) = NULL;
629static LPISW_DECL_LPIGETSOLVERPOINTER((*lpiGetSolverPointer)) = NULL;
630static LPISW_DECL_LPICREATE((*lpiCreate)) = NULL;
631static LPISW_DECL_LPIFREE((*lpiFree)) = NULL;
632static LPISW_DECL_LPILOADCOLLP((*lpiLoadColLP)) = NULL;
633static LPISW_DECL_LPIADDCOLS((*lpiAddCols)) = NULL;
634static LPISW_DECL_LPIDELCOLS((*lpiDelCols)) = NULL;
635static LPISW_DECL_LPIDELCOLSET((*lpiDelColset)) = NULL;
636static LPISW_DECL_LPIADDROWS((*lpiAddRows)) = NULL;
637static LPISW_DECL_LPIDELROWS((*lpiDelRows)) = NULL;
638static LPISW_DECL_LPIDELROWSET((*lpiDelRowset)) = NULL;
639static LPISW_DECL_LPICLEAR((*lpiClear)) = NULL;
640static LPISW_DECL_LPICHGBOUNDS((*lpiChgBounds)) = NULL;
641static LPISW_DECL_LPICHGSIDES((*lpiChgSides)) = NULL;
642static LPISW_DECL_LPICHGCOEF((*lpiChgCoef)) = NULL;
643static LPISW_DECL_LPICHGOBJSEN((*lpiChgObjsen)) = NULL;
644static LPISW_DECL_LPICHGOBJ((*lpiChgObj)) = NULL;
645static LPISW_DECL_LPISCALEROW((*lpiScaleRow)) = NULL;
646static LPISW_DECL_LPISCALECOL((*lpiScaleCol)) = NULL;
647static LPISW_DECL_LPIGETNROWS((*lpiGetNRows)) = NULL;
648static LPISW_DECL_LPIGETNCOLS((*lpiGetNCols)) = NULL;
649static LPISW_DECL_LPIGETOBJSEN((*lpiGetObjsen)) = NULL;
650static LPISW_DECL_LPIGETNNONZ((*lpiGetNNonz)) = NULL;
651static LPISW_DECL_LPIGETCOLS((*lpiGetCols)) = NULL;
652static LPISW_DECL_LPIGETROWS((*lpiGetRows)) = NULL;
653static LPISW_DECL_LPIGETCOLNAMES((*lpiGetColNames)) = NULL;
654static LPISW_DECL_LPIGETROWNAMES((*lpiGetRowNames)) = NULL;
655static LPISW_DECL_LPIGETOBJ((*lpiGetObj)) = NULL;
656static LPISW_DECL_LPIGETBOUNDS((*lpiGetBounds)) = NULL;
657static LPISW_DECL_LPIGETSIDES((*lpiGetSides)) = NULL;
658static LPISW_DECL_LPIGETCOEF((*lpiGetCoef)) = NULL;
659static LPISW_DECL_LPISOLVEPRIMAL((*lpiSolvePrimal)) = NULL;
660static LPISW_DECL_LPISOLVEDUAL((*lpiSolveDual)) = NULL;
661static LPISW_DECL_LPISOLVEBARRIER((*lpiSolveBarrier)) = NULL;
662static LPISW_DECL_LPISTARTSTRONGBRANCH((*lpiStartStrongbranch)) = NULL;
663static LPISW_DECL_LPIENDSTRONGBRANCH((*lpiEndStrongbranch)) = NULL;
664static LPISW_DECL_LPISTRONGBRANCHFRAC((*lpiStrongbranchFrac)) = NULL;
665static LPISW_DECL_LPISTRONGBRANCHESFRAC((*lpiStrongbranchesFrac)) = NULL;
666static LPISW_DECL_LPISTRONGBRANCHINT((*lpiStrongbranchInt)) = NULL;
667static LPISW_DECL_LPISTRONGBRANCHESINT((*lpiStrongbranchesInt)) = NULL;
668static LPISW_DECL_LPIWASSOLVED((*lpiWasSolved)) = NULL;
669static LPISW_DECL_LPIGETSOLFEASIBILITY((*lpiGetSolFeasibility)) = NULL;
670static LPISW_DECL_LPIEXISTSPRIMALRAY((*lpiExistsPrimalRay)) = NULL;
671static LPISW_DECL_LPIHASPRIMALRAY((*lpiHasPrimalRay)) = NULL;
672static LPISW_DECL_LPIISPRIMALUNBOUNDED((*lpiIsPrimalUnbounded)) = NULL;
673static LPISW_DECL_LPIISPRIMALINFEASIBLE((*lpiIsPrimalInfeasible)) = NULL;
674static LPISW_DECL_LPIISPRIMALFEASIBLE((*lpiIsPrimalFeasible)) = NULL;
675static LPISW_DECL_LPIEXISTSDUALRAY((*lpiExistsDualRay)) = NULL;
676static LPISW_DECL_LPIHASDUALRAY((*lpiHasDualRay)) = NULL;
677static LPISW_DECL_LPIISDUALUNBOUNDED((*lpiIsDualUnbounded)) = NULL;
678static LPISW_DECL_LPIISDUALINFEASIBLE((*lpiIsDualInfeasible)) = NULL;
679static LPISW_DECL_LPIISDUALFEASIBLE((*lpiIsDualFeasible)) = NULL;
680static LPISW_DECL_LPIISOPTIMAL((*lpiIsOptimal)) = NULL;
681static LPISW_DECL_LPIISSTABLE((*lpiIsStable)) = NULL;
682static LPISW_DECL_LPIISOBJLIMEXC((*lpiIsObjlimExc)) = NULL;
683static LPISW_DECL_LPIISITERLIMEXC((*lpiIsIterlimExc)) = NULL;
684static LPISW_DECL_LPIISTIMELIMEXC((*lpiIsTimelimExc)) = NULL;
685static LPISW_DECL_LPIGETINTERNALSTATUS((*lpiGetInternalStatus)) = NULL;
686static LPISW_DECL_LPIIGNOREINSTABILITY((*lpiIgnoreInstability)) = NULL;
687static LPISW_DECL_LPIGETOBJVAL((*lpiGetObjval)) = NULL;
688static LPISW_DECL_LPIGETSOL((*lpiGetSol)) = NULL;
689static LPISW_DECL_LPIGETPRIMALRAY((*lpiGetPrimalRay)) = NULL;
690static LPISW_DECL_LPIGETDUALFARKAS((*lpiGetDualfarkas)) = NULL;
691static LPISW_DECL_LPIGETITERATIONS((*lpiGetIterations)) = NULL;
692static LPISW_DECL_LPIGETREALSOLQUALITY((*lpiGetRealSolQuality)) = NULL;
693static LPISW_DECL_LPIGETBASE((*lpiGetBase)) = NULL;
694static LPISW_DECL_LPISETBASE((*lpiSetBase)) = NULL;
695static LPISW_DECL_LPIGETBASISIND((*lpiGetBasisInd)) = NULL;
696static LPISW_DECL_LPIGETBINVROW((*lpiGetBInvRow)) = NULL;
697static LPISW_DECL_LPIGETBINVCOL((*lpiGetBInvCol)) = NULL;
698static LPISW_DECL_LPIGETBINVAROW((*lpiGetBInvARow)) = NULL;
699static LPISW_DECL_LPIGETBINVACOL((*lpiGetBInvACol)) = NULL;
700static LPISW_DECL_LPIGETSTATE((*lpiGetState)) = NULL;
701static LPISW_DECL_LPISETSTATE((*lpiSetState)) = NULL;
702static LPISW_DECL_LPICLEARSTATE((*lpiClearState)) = NULL;
703static LPISW_DECL_LPIFREESTATE((*lpiFreeState)) = NULL;
704static LPISW_DECL_LPIHASSTATEBASIS((*lpiHasStateBasis)) = NULL;
705static LPISW_DECL_LPIREADSTATE((*lpiReadState)) = NULL;
706static LPISW_DECL_LPIWRITESTATE((*lpiWriteState)) = NULL;
707static LPISW_DECL_LPIGETINTPAR((*lpiGetIntpar)) = NULL;
708static LPISW_DECL_LPISETINTPAR((*lpiSetIntpar)) = NULL;
709static LPISW_DECL_LPIGETREALPAR((*lpiGetRealpar)) = NULL;
710static LPISW_DECL_LPISETREALPAR((*lpiSetRealpar)) = NULL;
711static LPISW_DECL_LPIINFINITY((*lpiInfinity)) = NULL;
712static LPISW_DECL_LPIISINFINITY((*lpiIsInfinity)) = NULL;
713static LPISW_DECL_LPIREADLP((*lpiReadLP)) = NULL;
714static LPISW_DECL_LPIWRITELP((*lpiWriteLP)) = NULL;
715
716static SCIP_LPISW_LPSOLVER currentsolver = -1;
717
718/** macro to set static function pointers to LPI functions of a particular solver
719 */
720#define LPISW_ASSIGN_FUNCPTRS(x) \
721   lpiGetSolverName = SCIPlpiGetSolverName ## x ; \
722   lpiGetSolverDesc = SCIPlpiGetSolverDesc ## x ; \
723   lpiGetSolverPointer = SCIPlpiGetSolverPointer ## x ; \
724   lpiCreate = SCIPlpiCreate ## x ; \
725   lpiFree = SCIPlpiFree ## x ; \
726   lpiLoadColLP = SCIPlpiLoadColLP ## x ; \
727   lpiAddCols = SCIPlpiAddCols ## x ; \
728   lpiDelCols = SCIPlpiDelCols ## x ; \
729   lpiDelColset = SCIPlpiDelColset ## x ; \
730   lpiAddRows = SCIPlpiAddRows ## x ; \
731   lpiDelRows = SCIPlpiDelRows ## x ; \
732   lpiDelRowset = SCIPlpiDelRowset ## x ; \
733   lpiClear = SCIPlpiClear ## x ; \
734   lpiChgBounds = SCIPlpiChgBounds ## x ; \
735   lpiChgSides = SCIPlpiChgSides ## x ; \
736   lpiChgCoef = SCIPlpiChgCoef ## x ; \
737   lpiChgObjsen = SCIPlpiChgObjsen ## x ; \
738   lpiChgObj = SCIPlpiChgObj ## x ; \
739   lpiScaleRow = SCIPlpiScaleRow ## x ; \
740   lpiScaleCol = SCIPlpiScaleCol ## x ; \
741   lpiGetNRows = SCIPlpiGetNRows ## x ; \
742   lpiGetNCols = SCIPlpiGetNCols ## x ; \
743   lpiGetObjsen = SCIPlpiGetObjsen ## x ; \
744   lpiGetNNonz = SCIPlpiGetNNonz ## x ; \
745   lpiGetCols = SCIPlpiGetCols ## x ; \
746   lpiGetRows = SCIPlpiGetRows ## x ; \
747   lpiGetColNames = SCIPlpiGetColNames ## x ; \
748   lpiGetRowNames = SCIPlpiGetRowNames ## x ; \
749   lpiGetObj = SCIPlpiGetObj ## x ; \
750   lpiGetBounds = SCIPlpiGetBounds ## x ; \
751   lpiGetSides = SCIPlpiGetSides ## x ; \
752   lpiGetCoef = SCIPlpiGetCoef ## x ; \
753   lpiSolvePrimal = SCIPlpiSolvePrimal ## x ; \
754   lpiSolveDual = SCIPlpiSolveDual ## x ; \
755   lpiSolveBarrier = SCIPlpiSolveBarrier ## x ; \
756   lpiStartStrongbranch = SCIPlpiStartStrongbranch ## x ; \
757   lpiEndStrongbranch = SCIPlpiEndStrongbranch ## x ; \
758   lpiStrongbranchFrac = SCIPlpiStrongbranchFrac ## x ; \
759   lpiStrongbranchesFrac = SCIPlpiStrongbranchesFrac ## x ; \
760   lpiStrongbranchInt = SCIPlpiStrongbranchInt ## x ; \
761   lpiStrongbranchesInt = SCIPlpiStrongbranchesInt ## x ; \
762   lpiWasSolved = SCIPlpiWasSolved ## x ; \
763   lpiGetSolFeasibility = SCIPlpiGetSolFeasibility ## x ; \
764   lpiExistsPrimalRay = SCIPlpiExistsPrimalRay ## x ; \
765   lpiHasPrimalRay = SCIPlpiHasPrimalRay ## x ; \
766   lpiIsPrimalUnbounded = SCIPlpiIsPrimalUnbounded ## x ; \
767   lpiIsPrimalInfeasible = SCIPlpiIsPrimalInfeasible ## x ; \
768   lpiIsPrimalFeasible = SCIPlpiIsPrimalFeasible ## x ; \
769   lpiExistsDualRay = SCIPlpiExistsDualRay ## x ; \
770   lpiHasDualRay = SCIPlpiHasDualRay ## x ; \
771   lpiIsDualUnbounded = SCIPlpiIsDualUnbounded ## x ; \
772   lpiIsDualInfeasible = SCIPlpiIsDualInfeasible ## x ; \
773   lpiIsDualFeasible = SCIPlpiIsDualFeasible ## x ; \
774   lpiIsOptimal = SCIPlpiIsOptimal ## x ; \
775   lpiIsStable = SCIPlpiIsStable ## x ; \
776   lpiIsObjlimExc = SCIPlpiIsObjlimExc ## x ; \
777   lpiIsIterlimExc = SCIPlpiIsIterlimExc ## x ; \
778   lpiIsTimelimExc = SCIPlpiIsTimelimExc ## x ; \
779   lpiGetInternalStatus = SCIPlpiGetInternalStatus ## x ; \
780   lpiIgnoreInstability = SCIPlpiIgnoreInstability ## x ; \
781   lpiGetObjval = SCIPlpiGetObjval ## x ; \
782   lpiGetSol = SCIPlpiGetSol ## x ; \
783   lpiGetPrimalRay = SCIPlpiGetPrimalRay ## x ; \
784   lpiGetDualfarkas = SCIPlpiGetDualfarkas ## x ; \
785   lpiGetIterations = SCIPlpiGetIterations ## x ; \
786   lpiGetRealSolQuality = SCIPlpiGetRealSolQuality ## x ; \
787   lpiGetBase = SCIPlpiGetBase ## x ; \
788   lpiSetBase = SCIPlpiSetBase ## x ; \
789   lpiGetBasisInd = SCIPlpiGetBasisInd ## x ; \
790   lpiGetBInvRow = SCIPlpiGetBInvRow ## x ; \
791   lpiGetBInvCol = SCIPlpiGetBInvCol ## x ; \
792   lpiGetBasisInd = SCIPlpiGetBasisInd ## x ; \
793   lpiGetBInvARow = SCIPlpiGetBInvARow ## x ; \
794   lpiGetBInvRow = SCIPlpiGetBInvRow ## x ; \
795   lpiGetBInvACol = SCIPlpiGetBInvACol ## x ; \
796   lpiGetState = SCIPlpiGetState ## x ; \
797   lpiSetState = SCIPlpiSetState ## x ; \
798   lpiClearState = SCIPlpiClearState ## x ; \
799   lpiFreeState = SCIPlpiFreeState ## x ; \
800   lpiHasStateBasis = SCIPlpiHasStateBasis ## x ; \
801   lpiReadState = SCIPlpiReadState ## x ; \
802   lpiWriteState = SCIPlpiWriteState ## x ; \
803   lpiGetIntpar = SCIPlpiGetIntpar ## x ; \
804   lpiSetIntpar = SCIPlpiSetIntpar ## x ; \
805   lpiGetRealpar = SCIPlpiGetRealpar ## x ; \
806   lpiSetRealpar = SCIPlpiSetRealpar ## x ; \
807   lpiInfinity = SCIPlpiInfinity ## x ; \
808   lpiIsInfinity = SCIPlpiIsInfinity ## x ; \
809   lpiReadLP = SCIPlpiReadLP ## x ; \
810   lpiWriteLP = SCIPlpiWriteLP ## x ;
811
812/** gets enum of currently used LP solver */
813SCIP_LPISW_LPSOLVER SCIPlpiSwitchGetCurrentSolver()
814{
815   return currentsolver;
816}
817
818/** sets static function pointers to LPI functions of a particular solver */
819SCIP_RETCODE SCIPlpiSwitchSetSolver(
820   SCIP_LPISW_LPSOLVER   lpsolver            /**< LP Solver to use */
821   )
822{
823   currentsolver = lpsolver;
824   switch( lpsolver )
825   {
826      case SCIP_LPISW_CLP:
827      {
828#ifdef COIN_HAS_CLP
829         LPISW_ASSIGN_FUNCPTRS(Clp);
830         return SCIP_OKAY;
831#else
832         SCIPerrorMessage("CLP not available as LP solver.\n");
833         return SCIP_PLUGINNOTFOUND;
834#endif
835      }
836
837      case SCIP_LPISW_CPLEX:
838      {
839#ifdef COIN_HAS_CPX
840         LPISW_ASSIGN_FUNCPTRS(Cplex);
841         return SCIP_OKAY;
842#else
843         SCIPerrorMessage("Cplex not available as LP solver.\n");
844         return SCIP_PLUGINNOTFOUND;
845#endif
846      }
847
848      case SCIP_LPISW_GUROBI:
849      {
850#ifdef COIN_HAS_GRB
851         LPISW_ASSIGN_FUNCPTRS(Gurobi);
852         return SCIP_OKAY;
853#else
854         SCIPerrorMessage("Gurobi not available as LP solver.\n");
855         return SCIP_PLUGINNOTFOUND;
856#endif
857      }
858
859      case SCIP_LPISW_MOSEK:
860      {
861#ifdef COIN_HAS_MSK
862         LPISW_ASSIGN_FUNCPTRS(Mosek);
863         return SCIP_OKAY;
864#else
865         SCIPerrorMessage("Mosek not available as LP solver.\n");
866         return SCIP_PLUGINNOTFOUND;
867#endif
868      }
869
870      case SCIP_LPISW_NONE:
871      {
872         LPISW_ASSIGN_FUNCPTRS(None);
873         return SCIP_OKAY;
874      }
875
876      case SCIP_LPISW_QSOPT:
877      {
878#ifdef COIN_HAS_QSO
879         LPISW_ASSIGN_FUNCPTRS(Qsopt);
880         return SCIP_OKAY;
881#else
882         SCIPerrorMessage("Qsopt not available as LP solver.\n");
883         return SCIP_PLUGINNOTFOUND;
884#endif
885      }
886
887      case SCIP_LPISW_SOPLEX:
888      {
889#ifdef COIN_HAS_SOPLEX
890         LPISW_ASSIGN_FUNCPTRS(Soplex);
891         return SCIP_OKAY;
892#else
893         SCIPerrorMessage("SoPlex not available as LP solver.\n");
894         return SCIP_PLUGINNOTFOUND;
895#endif
896      }
897
898      case SCIP_LPISW_XPRESS:
899      {
900#ifdef COIN_HAS_XPR
901         LPISW_ASSIGN_FUNCPTRS(Xpress);
902         return SCIP_OKAY;
903#else
904         SCIPerrorMessage("Xpress not available as LP solver.\n");
905         return SCIP_PLUGINNOTFOUND;
906#endif
907      }
908   }
909   SCIPerrorMessage("Unknown LP solver id %d\n", lpsolver);
910
911   return SCIP_ERROR;
912}
913
914/*
915 * our implementation of the SCIP LPI
916 * calls whatever has been set in our function pointers
917 */
918
919#undef __SCIP_LPI_H__
920#include "scip/lpi.h"
921
922/** gets name and version of LP solver */
923const char* SCIPlpiGetSolverName(
924   void
925   )
926{
927   return (*lpiGetSolverName)();
928}
929
930/** gets description of LP solver (developer, webpage, ...) */
931const char* SCIPlpiGetSolverDesc(
932   void
933   )
934{
935   return (*lpiGetSolverDesc)();
936}
937
938/** gets pointer for LP solver - use only with great care
939 *
940 *  The behavior of this function depends on the solver and its use is
941 *  therefore only recommended if you really know what you are
942 *  doing. In general, it returns a pointer to the LP solver object.
943 */
944void* SCIPlpiGetSolverPointer(
945   SCIP_LPI*             lpi                 /**< pointer to an LP interface structure */
946   )
947{
948   return (*lpiGetSolverPointer)(lpi);
949}
950
951/** creates an LP problem object */
952SCIP_RETCODE SCIPlpiCreate(
953   SCIP_LPI**            lpi,                /**< pointer to an LP interface structure */
954   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler to use for printing messages, or NULL */
955   const char*           name,               /**< problem name */
956   SCIP_OBJSEN           objsen              /**< objective sense */
957   )
958{
959   return (*lpiCreate)(lpi, messagehdlr, name, objsen);
960}
961
962/** deletes an LP problem object */
963SCIP_RETCODE SCIPlpiFree(
964   SCIP_LPI**            lpi                 /**< pointer to an LP interface structure */
965   )
966{
967   return (*lpiFree)(lpi);
968}
969
970/** copies LP data with column matrix into LP solver */
971SCIP_RETCODE SCIPlpiLoadColLP(
972   SCIP_LPI*             lpi,                /**< LP interface structure */
973   SCIP_OBJSEN           objsen,             /**< objective sense */
974   int                   ncols,              /**< number of columns */
975   const SCIP_Real*      obj,                /**< objective function values of columns */
976   const SCIP_Real*      lb,                 /**< lower bounds of columns */
977   const SCIP_Real*      ub,                 /**< upper bounds of columns */
978   char**                colnames,           /**< column names, or NULL */
979   int                   nrows,              /**< number of rows */
980   const SCIP_Real*      lhs,                /**< left hand sides of rows */
981   const SCIP_Real*      rhs,                /**< right hand sides of rows */
982   char**                rownames,           /**< row names, or NULL */
983   int                   nnonz,              /**< number of nonzero elements in the constraint matrix */
984   const int*            beg,                /**< start index of each column in ind- and val-array */
985   const int*            ind,                /**< row indices of constraint matrix entries */
986   const SCIP_Real*      val                 /**< values of constraint matrix entries */
987   )
988{
989   return (*lpiLoadColLP)(lpi, objsen, ncols, obj, lb, ub, colnames, nrows, lhs, rhs, rownames, nnonz, beg, ind, val);
990}
991
992/** adds columns to the LP */
993SCIP_RETCODE SCIPlpiAddCols(
994   SCIP_LPI*             lpi,                /**< LP interface structure */
995   int                   ncols,              /**< number of columns to be added */
996   const SCIP_Real*      obj,                /**< objective function values of new columns */
997   const SCIP_Real*      lb,                 /**< lower bounds of new columns */
998   const SCIP_Real*      ub,                 /**< upper bounds of new columns */
999   char**                colnames,           /**< column names, or NULL */
1000   int                   nnonz,              /**< number of nonzero elements to be added to the constraint matrix */
1001   const int*            beg,                /**< start index of each column in ind- and val-array, or NULL if nnonz == 0 */
1002   const int*            ind,                /**< row indices of constraint matrix entries, or NULL if nnonz == 0 */
1003   const SCIP_Real*      val                 /**< values of constraint matrix entries, or NULL if nnonz == 0 */
1004   )
1005{
1006   return (*lpiAddCols)(lpi, ncols, obj, lb, ub, colnames, nnonz, beg, ind, val);
1007}
1008
1009/** deletes all columns in the given range from LP */
1010SCIP_RETCODE SCIPlpiDelCols(
1011   SCIP_LPI*             lpi,                /**< LP interface structure */
1012   int                   firstcol,           /**< first column to be deleted */
1013   int                   lastcol             /**< last column to be deleted */
1014   )
1015{
1016   return (*lpiDelCols)(lpi, firstcol, lastcol);
1017}
1018
1019/** deletes columns from SCIP_LPI; the new position of a column must not be greater that its old position */
1020SCIP_RETCODE SCIPlpiDelColset(
1021   SCIP_LPI*             lpi,                /**< LP interface structure */
1022   int*                  dstat               /**< deletion status of columns
1023                                              *   input:  1 if column should be deleted, 0 if not
1024                                              *   output: new position of column, -1 if column was deleted */
1025   )
1026{
1027   return (*lpiDelColset)(lpi, dstat);
1028}
1029
1030/** adds rows to the LP */
1031SCIP_RETCODE SCIPlpiAddRows(
1032   SCIP_LPI*             lpi,                /**< LP interface structure */
1033   int                   nrows,              /**< number of rows to be added */
1034   const SCIP_Real*      lhs,                /**< left hand sides of new rows */
1035   const SCIP_Real*      rhs,                /**< right hand sides of new rows */
1036   char**                rownames,           /**< row names, or NULL */
1037   int                   nnonz,              /**< number of nonzero elements to be added to the constraint matrix */
1038   const int*            beg,                /**< start index of each row in ind- and val-array, or NULL if nnonz == 0 */
1039   const int*            ind,                /**< column indices of constraint matrix entries, or NULL if nnonz == 0 */
1040   const SCIP_Real*      val                 /**< values of constraint matrix entries, or NULL if nnonz == 0 */
1041   )
1042{
1043   return (*lpiAddRows)(lpi, nrows, lhs, rhs, rownames, nnonz, beg, ind, val);
1044}
1045
1046/** deletes all rows in the given range from LP */
1047SCIP_RETCODE SCIPlpiDelRows(
1048   SCIP_LPI*             lpi,                /**< LP interface structure */
1049   int                   firstrow,           /**< first row to be deleted */
1050   int                   lastrow             /**< last row to be deleted */
1051   )
1052{
1053   return (*lpiDelRows)(lpi, firstrow, lastrow);
1054}
1055
1056/** deletes rows from SCIP_LPI; the new position of a row must not be greater that its old position */
1057SCIP_RETCODE SCIPlpiDelRowset(
1058   SCIP_LPI*             lpi,                /**< LP interface structure */
1059   int*                  dstat               /**< deletion status of rows
1060                                              *   input:  1 if row should be deleted, 0 if not
1061                                              *   output: new position of row, -1 if row was deleted */
1062   )
1063{
1064   return (*lpiDelRowset)(lpi, dstat);
1065}
1066
1067/** clears the whole LP */
1068SCIP_RETCODE SCIPlpiClear(
1069   SCIP_LPI*             lpi                 /**< LP interface structure */
1070   )
1071{
1072   return (*lpiClear)(lpi);
1073}
1074
1075/** changes lower and upper bounds of columns */
1076SCIP_RETCODE SCIPlpiChgBounds(
1077   SCIP_LPI*             lpi,                /**< LP interface structure */
1078   int                   ncols,              /**< number of columns to change bounds for */
1079   const int*            ind,                /**< column indices */
1080   const SCIP_Real*      lb,                 /**< values for the new lower bounds */
1081   const SCIP_Real*      ub                  /**< values for the new upper bounds */
1082   )
1083{
1084   return (*lpiChgBounds)(lpi, ncols, ind, lb, ub);
1085}
1086
1087/** changes left and right hand sides of rows */
1088SCIP_RETCODE SCIPlpiChgSides(
1089   SCIP_LPI*             lpi,                /**< LP interface structure */
1090   int                   nrows,              /**< number of rows to change sides for */
1091   const int*            ind,                /**< row indices */
1092   const SCIP_Real*      lhs,                /**< new values for left hand sides */
1093   const SCIP_Real*      rhs                 /**< new values for right hand sides */
1094   )
1095{
1096   return (*lpiChgSides)(lpi, nrows, ind, lhs, rhs);
1097}
1098
1099/** changes a single coefficient */
1100SCIP_RETCODE SCIPlpiChgCoef(
1101   SCIP_LPI*             lpi,                /**< LP interface structure */
1102   int                   row,                /**< row number of coefficient to change */
1103   int                   col,                /**< column number of coefficient to change */
1104   SCIP_Real             newval              /**< new value of coefficient */
1105   )
1106{
1107   return (*lpiChgCoef)(lpi, row, col, newval);
1108}
1109
1110/** changes the objective sense */
1111SCIP_RETCODE SCIPlpiChgObjsen(
1112   SCIP_LPI*             lpi,                /**< LP interface structure */
1113   SCIP_OBJSEN           objsen              /**< new objective sense */
1114   )
1115{
1116   return (*lpiChgObjsen)(lpi, objsen);
1117}
1118
1119/** changes objective values of columns in the LP */
1120SCIP_RETCODE SCIPlpiChgObj(
1121   SCIP_LPI*             lpi,                /**< LP interface structure */
1122   int                   ncols,              /**< number of columns to change objective value for */
1123   int*                  ind,                /**< column indices to change objective value for */
1124   SCIP_Real*            obj                 /**< new objective values for columns */
1125   )
1126{
1127   return (*lpiChgObj)(lpi, ncols, ind, obj);
1128}
1129
1130/** multiplies a row with a non-zero scalar; for negative scalars, the row's sense is switched accordingly */
1131SCIP_RETCODE SCIPlpiScaleRow(
1132   SCIP_LPI*             lpi,                /**< LP interface structure */
1133   int                   row,                /**< row number to scale */
1134   SCIP_Real             scaleval            /**< scaling multiplier */
1135   )
1136{
1137   return (*lpiScaleRow)(lpi, row, scaleval);
1138}
1139
1140/** multiplies a column with a non-zero scalar; the objective value is multiplied with the scalar, and the bounds
1141 *  are divided by the scalar; for negative scalars, the column's bounds are switched
1142 */
1143SCIP_RETCODE SCIPlpiScaleCol(
1144   SCIP_LPI*             lpi,                /**< LP interface structure */
1145   int                   col,                /**< column number to scale */
1146   SCIP_Real             scaleval            /**< scaling multiplier */
1147   )
1148{
1149   return (*lpiScaleCol)(lpi, col, scaleval);
1150}
1151
1152/** gets the number of rows in the LP */
1153SCIP_RETCODE SCIPlpiGetNRows(
1154   SCIP_LPI*             lpi,                /**< LP interface structure */
1155   int*                  nrows               /**< pointer to store the number of rows */
1156   )
1157{
1158   return (*lpiGetNRows)(lpi, nrows);
1159}
1160
1161/** gets the number of columns in the LP */
1162SCIP_RETCODE SCIPlpiGetNCols(
1163   SCIP_LPI*             lpi,                /**< LP interface structure */
1164   int*                  ncols               /**< pointer to store the number of cols */
1165   )
1166{
1167   return (*lpiGetNCols)(lpi, ncols);
1168}
1169
1170/** gets the objective sense of the LP */
1171SCIP_RETCODE SCIPlpiGetObjsen(
1172   SCIP_LPI*             lpi,                /**< LP interface structure */
1173   SCIP_OBJSEN*          objsen              /**< pointer to store objective sense */
1174   )
1175{
1176   return (*lpiGetObjsen)(lpi, objsen);
1177}
1178
1179/** gets the number of nonzero elements in the LP constraint matrix */
1180SCIP_RETCODE SCIPlpiGetNNonz(
1181   SCIP_LPI*             lpi,                /**< LP interface structure */
1182   int*                  nnonz               /**< pointer to store the number of nonzeros */
1183   )
1184{
1185   return (*lpiGetNNonz)(lpi, nnonz);
1186}
1187
1188/** gets columns from LP problem object; the arrays have to be large enough to store all values;
1189 *  Either both, lb and ub, have to be NULL, or both have to be non-NULL,
1190 *  either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
1191 */
1192SCIP_RETCODE SCIPlpiGetCols(
1193   SCIP_LPI*             lpi,                /**< LP interface structure */
1194   int                   firstcol,           /**< first column to get from LP */
1195   int                   lastcol,            /**< last column to get from LP */
1196   SCIP_Real*            lb,                 /**< buffer to store the lower bound vector, or NULL */
1197   SCIP_Real*            ub,                 /**< buffer to store the upper bound vector, or NULL */
1198   int*                  nnonz,              /**< pointer to store the number of nonzero elements returned, or NULL */
1199   int*                  beg,                /**< buffer to store start index of each column in ind- and val-array, or NULL */
1200   int*                  ind,                /**< buffer to store column indices of constraint matrix entries, or NULL */
1201   SCIP_Real*            val                 /**< buffer to store values of constraint matrix entries, or NULL */
1202   )
1203{
1204   return (*lpiGetCols)(lpi, firstcol, lastcol, lb, ub, nnonz, beg, ind, val);
1205}
1206
1207/** gets rows from LP problem object; the arrays have to be large enough to store all values.
1208 *  Either both, lhs and rhs, have to be NULL, or both have to be non-NULL,
1209 *  either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
1210 */
1211SCIP_RETCODE SCIPlpiGetRows(
1212   SCIP_LPI*             lpi,                /**< LP interface structure */
1213   int                   firstrow,           /**< first row to get from LP */
1214   int                   lastrow,            /**< last row to get from LP */
1215   SCIP_Real*            lhs,                /**< buffer to store left hand side vector, or NULL */
1216   SCIP_Real*            rhs,                /**< buffer to store right hand side vector, or NULL */
1217   int*                  nnonz,              /**< pointer to store the number of nonzero elements returned, or NULL */
1218   int*                  beg,                /**< buffer to store start index of each row in ind- and val-array, or NULL */
1219   int*                  ind,                /**< buffer to store row indices of constraint matrix entries, or NULL */
1220   SCIP_Real*            val                 /**< buffer to store values of constraint matrix entries, or NULL */
1221   )
1222{
1223   return (*lpiGetRows)(lpi, firstrow, lastrow, lhs, rhs, nnonz, beg, ind, val);
1224}
1225
1226/** gets column names */
1227SCIP_RETCODE SCIPlpiGetColNames(
1228   SCIP_LPI*             lpi,                /**< LP interface structure */
1229   int                   firstcol,           /**< first column to get name from LP */
1230   int                   lastcol,            /**< last column to get name from LP */
1231   char**                colnames,           /**< pointers to column names (of size at least lastcol-firstcol+1) */
1232   char*                 namestorage,        /**< storage for col names */
1233   int                   namestoragesize,    /**< size of namestorage (if 0, -storageleft returns the storage needed) */
1234   int*                  storageleft         /**< amount of storage left (if < 0 the namestorage was not big enough) */
1235   )
1236{
1237   return (*lpiGetColNames)(lpi, firstcol, lastcol, colnames, namestorage, namestoragesize, storageleft);
1238}
1239
1240/** gets row names */
1241SCIP_RETCODE SCIPlpiGetRowNames(
1242   SCIP_LPI*             lpi,                /**< LP interface structure */
1243   int                   firstrow,           /**< first row to get name from LP */
1244   int                   lastrow,            /**< last row to get name from LP */
1245   char**                rownames,           /**< pointers to row names (of size at least lastrow-firstrow+1) */
1246   char*                 namestorage,        /**< storage for row names */
1247   int                   namestoragesize,    /**< size of namestorage (if 0, -storageleft returns the storage needed) */
1248   int*                  storageleft         /**< amount of storage left (if < 0 the namestorage was not big enough) */
1249   )
1250{
1251   return (*lpiGetRowNames)(lpi, firstrow, lastrow, rownames, namestorage, namestoragesize, storageleft);
1252}
1253
1254/** gets objective coefficients from LP problem object */
1255SCIP_RETCODE SCIPlpiGetObj(
1256   SCIP_LPI*             lpi,                /**< LP interface structure */
1257   int                   firstcol,           /**< first column to get objective coefficient for */
1258   int                   lastcol,            /**< last column to get objective coefficient for */
1259   SCIP_Real*            vals                /**< array to store objective coefficients */
1260   )
1261{
1262   return (*lpiGetObj)(lpi, firstcol, lastcol, vals);
1263}
1264
1265/** gets current bounds from LP problem object */
1266SCIP_RETCODE SCIPlpiGetBounds(
1267   SCIP_LPI*             lpi,                /**< LP interface structure */
1268   int                   firstcol,           /**< first column to get bounds for */
1269   int                   lastcol,            /**< last column to get bounds for */
1270   SCIP_Real*            lbs,                /**< array to store lower bound values, or NULL */
1271   SCIP_Real*            ubs                 /**< array to store upper bound values, or NULL */
1272   )
1273{
1274   return (*lpiGetBounds)(lpi, firstcol, lastcol, lbs, ubs);
1275}
1276
1277/** gets current row sides from LP problem object */
1278SCIP_RETCODE SCIPlpiGetSides(
1279   SCIP_LPI*             lpi,                /**< LP interface structure */
1280   int                   firstrow,           /**< first row to get sides for */
1281   int                   lastrow,            /**< last row to get sides for */
1282   SCIP_Real*            lhss,               /**< array to store left hand side values, or NULL */
1283   SCIP_Real*            rhss                /**< array to store right hand side values, or NULL */
1284   )
1285{
1286   return (*lpiGetSides)(lpi, firstrow, lastrow, lhss, rhss);
1287}
1288
1289/** gets a single coefficient */
1290SCIP_RETCODE SCIPlpiGetCoef(
1291   SCIP_LPI*             lpi,                /**< LP interface structure */
1292   int                   row,                /**< row number of coefficient */
1293   int                   col,                /**< column number of coefficient */
1294   SCIP_Real*            val                 /**< pointer to store the value of the coefficient */
1295   )
1296{
1297   return (*lpiGetCoef)(lpi, row, col, val);
1298}
1299
1300/** calls primal simplex to solve the LP */
1301SCIP_RETCODE SCIPlpiSolvePrimal(
1302   SCIP_LPI*             lpi                 /**< LP interface structure */
1303   )
1304{
1305   return (*lpiSolvePrimal)(lpi);
1306}
1307
1308/** calls dual simplex to solve the LP */
1309SCIP_RETCODE SCIPlpiSolveDual(
1310   SCIP_LPI*             lpi                 /**< LP interface structure */
1311   )
1312{
1313   return (*lpiSolveDual)(lpi);
1314}
1315
1316/** calls barrier or interior point algorithm to solve the LP with crossover to simplex basis */
1317SCIP_RETCODE SCIPlpiSolveBarrier(
1318   SCIP_LPI*             lpi,                /**< LP interface structure */
1319   SCIP_Bool             crossover           /**< perform crossover */
1320   )
1321{
1322   return (*lpiSolveBarrier)(lpi, crossover);
1323}
1324
1325/** start strong branching - call before any strong branching */
1326SCIP_RETCODE SCIPlpiStartStrongbranch(
1327   SCIP_LPI*             lpi                 /**< LP interface structure */
1328   )
1329{
1330   return (*lpiStartStrongbranch)(lpi);
1331}
1332
1333/** end strong branching - call after any strong branching */
1334SCIP_RETCODE SCIPlpiEndStrongbranch(
1335   SCIP_LPI*             lpi                 /**< LP interface structure */
1336   )
1337{
1338   return (*lpiEndStrongbranch)(lpi);
1339}
1340
1341/** performs strong branching iterations on one @b fractional candidate */
1342SCIP_RETCODE SCIPlpiStrongbranchFrac(
1343   SCIP_LPI*             lpi,                /**< LP interface structure */
1344   int                   col,                /**< column to apply strong branching on */
1345   SCIP_Real             psol,               /**< fractional current primal solution value of column */
1346   int                   itlim,              /**< iteration limit for strong branchings */
1347   SCIP_Real*            down,               /**< stores dual bound after branching column down */
1348   SCIP_Real*            up,                 /**< stores dual bound after branching column up */
1349   SCIP_Bool*            downvalid,          /**< stores whether the returned down value is a valid dual bound;
1350                                              *   otherwise, it can only be used as an estimate value */
1351   SCIP_Bool*            upvalid,            /**< stores whether the returned up value is a valid dual bound;
1352                                              *   otherwise, it can only be used as an estimate value */
1353   int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
1354   )
1355{
1356   return (*lpiStrongbranchFrac)(lpi, col, psol, itlim, down, up, downvalid, upvalid, iter);
1357}
1358
1359/** performs strong branching iterations on given @b fractional candidates */
1360SCIP_RETCODE SCIPlpiStrongbranchesFrac(
1361   SCIP_LPI*             lpi,                /**< LP interface structure */
1362   int*                  cols,               /**< columns to apply strong branching on */
1363   int                   ncols,              /**< number of columns */
1364   SCIP_Real*            psols,              /**< fractional current primal solution values of columns */
1365   int                   itlim,              /**< iteration limit for strong branchings */
1366   SCIP_Real*            down,               /**< stores dual bounds after branching columns down */
1367   SCIP_Real*            up,                 /**< stores dual bounds after branching columns up */
1368   SCIP_Bool*            downvalid,          /**< stores whether the returned down values are valid dual bounds;
1369                                              *   otherwise, they can only be used as an estimate values */
1370   SCIP_Bool*            upvalid,            /**< stores whether the returned up values are a valid dual bounds;
1371                                              *   otherwise, they can only be used as an estimate values */
1372   int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
1373   )
1374{
1375   return (*lpiStrongbranchesFrac)(lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter);
1376}
1377
1378/** performs strong branching iterations on one candidate with @b integral value */
1379SCIP_RETCODE SCIPlpiStrongbranchInt(
1380   SCIP_LPI*             lpi,                /**< LP interface structure */
1381   int                   col,                /**< column to apply strong branching on */
1382   SCIP_Real             psol,               /**< current integral primal solution value of column */
1383   int                   itlim,              /**< iteration limit for strong branchings */
1384   SCIP_Real*            down,               /**< stores dual bound after branching column down */
1385   SCIP_Real*            up,                 /**< stores dual bound after branching column up */
1386   SCIP_Bool*            downvalid,          /**< stores whether the returned down value is a valid dual bound;
1387                                              *   otherwise, it can only be used as an estimate value */
1388   SCIP_Bool*            upvalid,            /**< stores whether the returned up value is a valid dual bound;
1389                                              *   otherwise, it can only be used as an estimate value */
1390   int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
1391   )
1392{
1393   return (*lpiStrongbranchInt)(lpi, col, psol, itlim, down, up, downvalid, upvalid, iter);
1394}
1395
1396/** performs strong branching iterations on given candidates with @b integral values */
1397SCIP_RETCODE SCIPlpiStrongbranchesInt(
1398   SCIP_LPI*             lpi,                /**< LP interface structure */
1399   int*                  cols,               /**< columns to apply strong branching on */
1400   int                   ncols,              /**< number of columns */
1401   SCIP_Real*            psols,              /**< current integral primal solution values of columns */
1402   int                   itlim,              /**< iteration limit for strong branchings */
1403   SCIP_Real*            down,               /**< stores dual bounds after branching columns down */
1404   SCIP_Real*            up,                 /**< stores dual bounds after branching columns up */
1405   SCIP_Bool*            downvalid,          /**< stores whether the returned down values are valid dual bounds;
1406                                              *   otherwise, they can only be used as an estimate values */
1407   SCIP_Bool*            upvalid,            /**< stores whether the returned up values are a valid dual bounds;
1408                                              *   otherwise, they can only be used as an estimate values */
1409   int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
1410   )
1411{
1412   return (*lpiStrongbranchesInt)(lpi, cols, ncols, psols, itlim, down, up, downvalid, upvalid, iter);
1413}
1414
1415/** returns whether a solve method was called after the last modification of the LP */
1416SCIP_Bool SCIPlpiWasSolved(
1417   SCIP_LPI*             lpi                 /**< LP interface structure */
1418   )
1419{
1420   return (*lpiWasSolved)(lpi);
1421}
1422
1423/** gets information about primal and dual feasibility of the current LP solution */
1424SCIP_RETCODE SCIPlpiGetSolFeasibility(
1425   SCIP_LPI*             lpi,                /**< LP interface structure */
1426   SCIP_Bool*            primalfeasible,     /**< stores primal feasibility status */
1427   SCIP_Bool*            dualfeasible        /**< stores dual feasibility status */
1428   )
1429{
1430   return (*lpiGetSolFeasibility)(lpi, primalfeasible, dualfeasible);
1431}
1432
1433/** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point);
1434 *  this does not necessarily mean, that the solver knows and can return the primal ray
1435 */
1436SCIP_Bool SCIPlpiExistsPrimalRay(
1437   SCIP_LPI*             lpi                 /**< LP interface structure */
1438   )
1439{
1440   return (*lpiExistsPrimalRay)(lpi);
1441}
1442
1443/** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point),
1444 *  and the solver knows and can return the primal ray
1445 */
1446SCIP_Bool SCIPlpiHasPrimalRay(
1447   SCIP_LPI*             lpi                 /**< LP interface structure */
1448   )
1449{
1450   return (*lpiHasPrimalRay)(lpi);
1451}
1452
1453/** returns TRUE iff LP is proven to be primal unbounded */
1454SCIP_Bool SCIPlpiIsPrimalUnbounded(
1455   SCIP_LPI*             lpi                 /**< LP interface structure */
1456   )
1457{
1458   return (*lpiIsPrimalUnbounded)(lpi);
1459}
1460
1461/** returns TRUE iff LP is proven to be primal infeasible */
1462SCIP_Bool SCIPlpiIsPrimalInfeasible(
1463   SCIP_LPI*             lpi                 /**< LP interface structure */
1464   )
1465{
1466   return (*lpiIsPrimalInfeasible)(lpi);
1467}
1468
1469/** returns TRUE iff LP is proven to be primal feasible */
1470SCIP_Bool SCIPlpiIsPrimalFeasible(
1471   SCIP_LPI*             lpi                 /**< LP interface structure */
1472   )
1473{
1474   return (*lpiIsPrimalFeasible)(lpi);
1475}
1476
1477/** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point);
1478 *  this does not necessarily mean, that the solver knows and can return the dual ray
1479 */
1480SCIP_Bool SCIPlpiExistsDualRay(
1481   SCIP_LPI*             lpi                 /**< LP interface structure */
1482   )
1483{
1484   return (*lpiExistsDualRay)(lpi);
1485}
1486
1487/** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point),
1488 *  and the solver knows and can return the dual ray
1489 */
1490SCIP_Bool SCIPlpiHasDualRay(
1491   SCIP_LPI*             lpi                 /**< LP interface structure */
1492   )
1493{
1494   return (*lpiHasDualRay)(lpi);
1495}
1496
1497/** returns TRUE iff LP is proven to be dual unbounded */
1498SCIP_Bool SCIPlpiIsDualUnbounded(
1499   SCIP_LPI*             lpi                 /**< LP interface structure */
1500   )
1501{
1502   return (*lpiIsDualUnbounded)(lpi);
1503}
1504
1505/** returns TRUE iff LP is proven to be dual infeasible */
1506SCIP_Bool SCIPlpiIsDualInfeasible(
1507   SCIP_LPI*             lpi                 /**< LP interface structure */
1508   )
1509{
1510   return (*lpiIsDualInfeasible)(lpi);
1511}
1512
1513/** returns TRUE iff LP is proven to be dual feasible */
1514SCIP_Bool SCIPlpiIsDualFeasible(
1515   SCIP_LPI*             lpi                 /**< LP interface structure */
1516   )
1517{
1518   return (*lpiIsDualFeasible)(lpi);
1519}
1520
1521/** returns TRUE iff LP was solved to optimality */
1522SCIP_Bool SCIPlpiIsOptimal(
1523   SCIP_LPI*             lpi                 /**< LP interface structure */
1524   )
1525{
1526   return (*lpiIsOptimal)(lpi);
1527}
1528
1529/** returns TRUE iff current LP basis is stable */
1530SCIP_Bool SCIPlpiIsStable(
1531   SCIP_LPI*             lpi                 /**< LP interface structure */
1532   )
1533{
1534   return (*lpiIsStable)(lpi);
1535}
1536
1537/** returns TRUE iff the objective limit was reached */
1538SCIP_Bool SCIPlpiIsObjlimExc(
1539   SCIP_LPI*             lpi                 /**< LP interface structure */
1540   )
1541{
1542   return (*lpiIsObjlimExc)(lpi);
1543}
1544
1545/** returns TRUE iff the iteration limit was reached */
1546SCIP_Bool SCIPlpiIsIterlimExc(
1547   SCIP_LPI*             lpi                 /**< LP interface structure */
1548   )
1549{
1550   return (*lpiIsIterlimExc)(lpi);
1551}
1552
1553/** returns TRUE iff the time limit was reached */
1554SCIP_Bool SCIPlpiIsTimelimExc(
1555   SCIP_LPI*             lpi                 /**< LP interface structure */
1556   )
1557{
1558   return (*lpiIsTimelimExc)(lpi);
1559}
1560
1561/** returns the internal solution status of the solver */
1562int SCIPlpiGetInternalStatus(
1563   SCIP_LPI*             lpi                 /**< LP interface structure */
1564   )
1565{
1566   return (*lpiGetInternalStatus)(lpi);
1567}
1568
1569/** tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call */
1570SCIP_RETCODE SCIPlpiIgnoreInstability(
1571   SCIP_LPI*             lpi,                /**< LP interface structure */
1572   SCIP_Bool*            success             /**< pointer to store, whether the instability could be ignored */
1573   )
1574{
1575   return (*lpiIgnoreInstability)(lpi, success);
1576}
1577
1578/** gets objective value of solution */
1579SCIP_RETCODE SCIPlpiGetObjval(
1580   SCIP_LPI*             lpi,                /**< LP interface structure */
1581   SCIP_Real*            objval              /**< stores the objective value */
1582   )
1583{
1584   return (*lpiGetObjval)(lpi, objval);
1585}
1586
1587/** gets primal and dual solution vectors for feasible LPs */
1588SCIP_RETCODE SCIPlpiGetSol(
1589   SCIP_LPI*             lpi,                /**< LP interface structure */
1590   SCIP_Real*            objval,             /**< stores the objective value, may be NULL if not needed */
1591   SCIP_Real*            primsol,            /**< primal solution vector, may be NULL if not needed */
1592   SCIP_Real*            dualsol,            /**< dual solution vector, may be NULL if not needed */
1593   SCIP_Real*            activity,           /**< row activity vector, may be NULL if not needed */
1594   SCIP_Real*            redcost             /**< reduced cost vector, may be NULL if not needed */
1595   )
1596{
1597   return (*lpiGetSol)(lpi, objval, primsol, dualsol, activity, redcost);
1598}
1599
1600/** gets primal ray for unbounded LPs */
1601SCIP_RETCODE SCIPlpiGetPrimalRay(
1602   SCIP_LPI*             lpi,                /**< LP interface structure */
1603   SCIP_Real*            ray                 /**< primal ray */
1604   )
1605{
1606   return (*lpiGetPrimalRay)(lpi, ray);
1607}
1608
1609/** gets dual Farkas proof for infeasibility */
1610SCIP_RETCODE SCIPlpiGetDualfarkas(
1611   SCIP_LPI*             lpi,                /**< LP interface structure */
1612   SCIP_Real*            dualfarkas          /**< dual Farkas row multipliers */
1613   )
1614{
1615   return (*lpiGetDualfarkas)(lpi, dualfarkas);
1616}
1617
1618/** gets the number of LP iterations of the last solve call */
1619SCIP_RETCODE SCIPlpiGetIterations(
1620   SCIP_LPI*             lpi,                /**< LP interface structure */
1621   int*                  iterations          /**< pointer to store the number of iterations of the last solve call */
1622   )
1623{
1624   return (*lpiGetIterations)(lpi, iterations);
1625}
1626
1627/** gets information about the quality of an LP solution
1628 *
1629 *  Such information is usually only available, if also a (maybe not optimal) solution is available.
1630 *  The LPI should return SCIP_INVALID for *quality, if the requested quantity is not available.
1631 */
1632SCIP_RETCODE SCIPlpiGetRealSolQuality(
1633   SCIP_LPI*             lpi,                /**< LP interface structure */
1634   SCIP_LPSOLQUALITY     qualityindicator,   /**< indicates which quality should be returned */
1635   SCIP_Real*            quality             /**< pointer to store quality number */
1636   )
1637{
1638   return (*lpiGetRealSolQuality)(lpi, qualityindicator, quality);
1639}
1640
1641/** gets current basis status for columns and rows; arrays must be large enough to store the basis status */
1642SCIP_RETCODE SCIPlpiGetBase(
1643   SCIP_LPI*             lpi,                /**< LP interface structure */
1644   int*                  cstat,              /**< array to store column basis status, or NULL */
1645   int*                  rstat               /**< array to store row basis status, or NULL */
1646   )
1647{
1648   return (*lpiGetBase)(lpi, cstat, rstat);
1649}
1650
1651/** sets current basis status for columns and rows */
1652SCIP_RETCODE SCIPlpiSetBase(
1653   SCIP_LPI*             lpi,                /**< LP interface structure */
1654   int*                  cstat,              /**< array with column basis status */
1655   int*                  rstat               /**< array with row basis status */
1656   )
1657{
1658   return (*lpiSetBase)(lpi, cstat, rstat);
1659}
1660
1661/** returns the indices of the basic columns and rows */
1662SCIP_RETCODE SCIPlpiGetBasisInd(
1663   SCIP_LPI*             lpi,                /**< LP interface structure */
1664   int*                  bind                /**< basic column n gives value n, basic row m gives value -1-m */
1665   )
1666{
1667   return (*lpiGetBasisInd)(lpi, bind);
1668}
1669
1670/** get dense row of inverse basis matrix B^-1 */
1671SCIP_RETCODE SCIPlpiGetBInvRow(
1672   SCIP_LPI*             lpi,                /**< LP interface structure */
1673   int                   r,                  /**< row number */
1674   SCIP_Real*            coef                /**< pointer to store the coefficients of the row */
1675   )
1676{
1677   return (*lpiGetBInvRow)(lpi, r, coef);
1678}
1679
1680/** get dense column of inverse basis matrix B^-1 */
1681SCIP_RETCODE SCIPlpiGetBInvCol(
1682   SCIP_LPI*             lpi,                /**< LP interface structure */
1683   int                   c,                  /**< column number of B^-1; this is NOT the number of the column in the LP;
1684                                              *   you have to call SCIPlpiGetBasisInd() to get the array which links the
1685                                              *   B^-1 column numbers to the row and column numbers of the LP!
1686                                              *   c must be between 0 and nrows-1, since the basis has the size
1687                                              *   nrows * nrows */
1688   SCIP_Real*            coef                /**< pointer to store the coefficients of the column */
1689   )
1690{
1691   return (*lpiGetBInvCol)(lpi, c, coef);
1692}
1693
1694/** get dense row of inverse basis matrix times constraint matrix B^-1 * A */
1695SCIP_RETCODE SCIPlpiGetBInvARow(
1696   SCIP_LPI*             lpi,                /**< LP interface structure */
1697   int                   r,                  /**< row number */
1698   const SCIP_Real*      binvrow,            /**< row in (A_B)^-1 from prior call to SCIPlpiGetBInvRow(), or NULL */
1699   SCIP_Real*            coef                /**< vector to return coefficients */
1700   )
1701{
1702   return (*lpiGetBInvARow)(lpi, r, binvrow, coef);
1703}
1704
1705/** get dense column of inverse basis matrix times constraint matrix B^-1 * A */
1706SCIP_RETCODE SCIPlpiGetBInvACol(
1707   SCIP_LPI*             lpi,                /**< LP interface structure */
1708   int                   c,                  /**< column number */
1709   SCIP_Real*            coef                /**< vector to return coefficients */
1710   )
1711{
1712   return (*lpiGetBInvACol)(lpi, c, coef);
1713}
1714
1715/** stores LPi state (like basis information) into lpistate object */
1716SCIP_RETCODE SCIPlpiGetState(
1717   SCIP_LPI*             lpi,                /**< LP interface structure */
1718   BMS_BLKMEM*           blkmem,             /**< block memory */
1719   SCIP_LPISTATE**       lpistate            /**< pointer to LPi state information (like basis information) */
1720   )
1721{
1722   return (*lpiGetState)(lpi, blkmem, lpistate);
1723}
1724
1725/** loads LPi state (like basis information) into solver; note that the LP might have been extended with additional
1726 *  columns and rows since the state was stored with SCIPlpiGetState()
1727 */
1728SCIP_RETCODE SCIPlpiSetState(
1729   SCIP_LPI*             lpi,                /**< LP interface structure */
1730   BMS_BLKMEM*           blkmem,             /**< block memory */
1731   SCIP_LPISTATE*        lpistate            /**< LPi state information (like basis information) */
1732   )
1733{
1734   return (*lpiSetState)(lpi, blkmem, lpistate);
1735}
1736
1737/** clears current LPi state (like basis information) of the solver */
1738SCIP_RETCODE SCIPlpiClearState(
1739   SCIP_LPI*             lpi                 /**< LP interface structure */
1740   )
1741{
1742   return (*lpiClearState)(lpi);
1743}
1744
1745/** frees LPi state information */
1746SCIP_RETCODE SCIPlpiFreeState(
1747   SCIP_LPI*             lpi,                /**< LP interface structure */
1748   BMS_BLKMEM*           blkmem,             /**< block memory */
1749   SCIP_LPISTATE**       lpistate            /**< pointer to LPi state information (like basis information) */
1750   )
1751{
1752   return (*lpiFreeState)(lpi, blkmem, lpistate);
1753}
1754
1755/** checks, whether the given LPi state contains simplex basis information */
1756SCIP_Bool SCIPlpiHasStateBasis(
1757   SCIP_LPI*             lpi,                /**< LP interface structure */
1758   SCIP_LPISTATE*        lpistate            /**< LPi state information (like basis information) */
1759   )
1760{
1761   return (*lpiHasStateBasis)(lpi, lpistate);
1762}
1763
1764/** reads LPi state (like basis information from a file */
1765SCIP_RETCODE SCIPlpiReadState(
1766   SCIP_LPI*             lpi,                /**< LP interface structure */
1767   const char*           fname               /**< file name */
1768   )
1769{
1770   return (*lpiReadState)(lpi, fname);
1771}
1772
1773/** writes LPi state (like basis information) to a file */
1774SCIP_RETCODE SCIPlpiWriteState(
1775   SCIP_LPI*             lpi,                /**< LP interface structure */
1776   const char*           fname               /**< file name */
1777   )
1778{
1779   return (*lpiWriteState)(lpi, fname);
1780}
1781
1782/** gets integer parameter of LP */
1783SCIP_RETCODE SCIPlpiGetIntpar(
1784   SCIP_LPI*             lpi,                /**< LP interface structure */
1785   SCIP_LPPARAM          type,               /**< parameter number */
1786   int*                  ival                /**< buffer to store the parameter value */
1787   )
1788{
1789   return (*lpiGetIntpar)(lpi, type, ival);
1790}
1791
1792/** sets integer parameter of LP */
1793SCIP_RETCODE SCIPlpiSetIntpar(
1794   SCIP_LPI*             lpi,                /**< LP interface structure */
1795   SCIP_LPPARAM          type,               /**< parameter number */
1796   int                   ival                /**< parameter value */
1797   )
1798{
1799   return (*lpiSetIntpar)(lpi, type, ival);
1800}
1801
1802/** gets floating point parameter of LP */
1803SCIP_RETCODE SCIPlpiGetRealpar(
1804   SCIP_LPI*             lpi,                /**< LP interface structure */
1805   SCIP_LPPARAM          type,               /**< parameter number */
1806   SCIP_Real*            dval                /**< buffer to store the parameter value */
1807   )
1808{
1809   return (*lpiGetRealpar)(lpi, type, dval);
1810}
1811
1812/** sets floating point parameter of LP */
1813SCIP_RETCODE SCIPlpiSetRealpar(
1814   SCIP_LPI*             lpi,                /**< LP interface structure */
1815   SCIP_LPPARAM          type,               /**< parameter number */
1816   SCIP_Real             dval                /**< parameter value */
1817   )
1818{
1819   return (*lpiSetRealpar)(lpi, type, dval);
1820}
1821
1822/** returns value treated as infinity in the LP solver */
1823SCIP_Real SCIPlpiInfinity(
1824   SCIP_LPI*             lpi                 /**< LP interface structure */
1825   )
1826{
1827   return (*lpiInfinity)(lpi);
1828}
1829
1830/** checks if given value is treated as infinity in the LP solver */
1831SCIP_Bool SCIPlpiIsInfinity(
1832   SCIP_LPI*             lpi,                /**< LP interface structure */
1833   SCIP_Real             val                 /**< value to be checked for infinity */
1834   )
1835{
1836   return (*lpiIsInfinity)(lpi, val);
1837}
1838
1839/** reads LP from a file */
1840SCIP_RETCODE SCIPlpiReadLP(
1841   SCIP_LPI*             lpi,                /**< LP interface structure */
1842   const char*           fname               /**< file name */
1843   )
1844{
1845   return (*lpiReadLP)(lpi, fname);
1846}
1847
1848/** writes LP to a file */
1849SCIP_RETCODE SCIPlpiWriteLP(
1850   SCIP_LPI*             lpi,                /**< LP interface structure */
1851   const char*           fname               /**< file name */
1852   )
1853{
1854   return (*lpiWriteLP)(lpi, fname);
1855}
Note: See TracBrowser for help on using the repository browser.