]>
Commit | Line | Data |
---|---|---|
641d9ce6 JB |
1 | --- Osi-0.106.10/Osi/src/OsiGlpk/OsiGlpkSolverInterface.cpp.orig 2013-04-06 14:50:19.000000000 +0200 |
2 | +++ Osi-0.106.10/Osi/src/OsiGlpk/OsiGlpkSolverInterface.cpp 2014-12-04 17:58:31.036909826 +0100 | |
3 | @@ -21,7 +21,7 @@ | |
4 | // In (much) earlier versions of GLPK, if an LPX_MIP problem was | |
5 | // changed back into a LPX_LP problem, then the MIP data was lost, | |
6 | // including which columns are integer. However, LPX_MIP problems | |
7 | -// still had access to LP information (like lpx_get_status). | |
8 | +// still had access to LP information (like glp_get_status). | |
9 | // | |
10 | // It appears that this behavior is no longer true in version 4.7. | |
11 | // Therefore it may be worthwhile to adjust the interface to change | |
12 | @@ -166,26 +166,26 @@ void OGSI::initialSolve() | |
13 | /* | |
14 | Solve the lp. | |
15 | */ | |
16 | - int err = lpx_simplex(model) ; | |
17 | + int err = glp_simplex(model, &simplexParams_) ; | |
18 | ||
19 | // for Glpk, a solve fails if the initial basis is invalid or singular | |
20 | // thus, we construct a (advanced) basis first and try again | |
21 | -#ifdef LPX_E_BADB | |
22 | - if (err == LPX_E_BADB) { | |
23 | - lpx_adv_basis(model); | |
24 | - err = lpx_simplex(model) ; | |
25 | +#ifdef GLP_EBADB | |
26 | + if (err == GLP_EBADB) { | |
27 | + glp_adv_basis(model, 0); | |
28 | + err = glp_simplex(model, &simplexParams_) ; | |
29 | } else | |
30 | #endif | |
31 | - if (err == LPX_E_SING || err == LPX_E_FAULT) { | |
32 | - lpx_adv_basis(model); | |
33 | - err = lpx_simplex(model) ; | |
34 | + if (err == GLP_ESING || err == GLP_EFAIL) { | |
35 | + glp_adv_basis(model, 0); | |
36 | + err = glp_simplex(model, &simplexParams_) ; | |
37 | } | |
38 | ||
39 | - iter_used_ = lpx_get_int_parm(model, LPX_K_ITCNT) ; | |
40 | + iter_used_ = glp_get_it_cnt(model) ; | |
41 | /* | |
42 | Sort out the various state indications. | |
43 | ||
44 | - When the presolver is turned on, lpx_simplex() will not be able to tell | |
45 | + When the presolver is turned on, glp_simplex() will not be able to tell | |
46 | whether the objective function has hit it's upper or lower limit, and does | |
47 | not return OBJLL or OBJUL. The code for these cases should be beefed up to | |
48 | check the objective against the limit. | |
49 | @@ -204,39 +204,39 @@ void OGSI::initialSolve() | |
50 | isObjUpperLimitReached_ = false ; | |
51 | ||
52 | switch (err) | |
53 | - { case LPX_E_OK: | |
54 | + { case 0: | |
55 | { break ; } | |
56 | - case LPX_E_ITLIM: | |
57 | + case GLP_EITLIM: | |
58 | { isIterationLimitReached_ = true ; | |
59 | break ; } | |
60 | - case LPX_E_OBJLL: | |
61 | + case GLP_EOBJLL: | |
62 | { isObjLowerLimitReached_ = true ; | |
63 | break ; } | |
64 | - case LPX_E_OBJUL: | |
65 | + case GLP_EOBJUL: | |
66 | { isObjUpperLimitReached_ = true ; | |
67 | break ; } | |
68 | - case LPX_E_TMLIM: | |
69 | + case GLP_ETMLIM: | |
70 | { isTimeLimitReached_ = true ; | |
71 | } // no break here, so we still report abandoned | |
72 | - case LPX_E_FAULT: | |
73 | - case LPX_E_SING: | |
74 | -#ifdef LPX_E_BADB | |
75 | - case LPX_E_BADB: | |
76 | + case GLP_EFAIL: | |
77 | + case GLP_ESING: | |
78 | +#ifdef GLP_EBADB | |
79 | + case GLP_EBADB: | |
80 | #endif | |
81 | { isAbandoned_ = true ; | |
82 | break ; } | |
83 | - case LPX_E_NOPFS: | |
84 | + case GLP_ENOPFS: | |
85 | { isPrimInfeasible_ = true ; | |
86 | break ; } | |
87 | - case LPX_E_NODFS: | |
88 | + case GLP_ENODFS: | |
89 | { isDualInfeasible_ = true ; | |
90 | break ; } | |
91 | default: | |
92 | { assert(false) ; } } | |
93 | ||
94 | - switch (lpx_get_status(model)) | |
95 | - { case LPX_OPT: | |
96 | - case LPX_FEAS: | |
97 | + switch (glp_get_status(model)) | |
98 | + { case GLP_OPT: | |
99 | + case GLP_FEAS: | |
100 | { isFeasible_ = true ; | |
101 | break ; } | |
102 | default: | |
103 | @@ -261,23 +261,23 @@ void OGSI::resolve() | |
104 | LPX *model = getMutableModelPtr() ; | |
105 | freeCachedData(OGSI::FREECACHED_RESULTS) ; | |
106 | ||
107 | - // lpx_simplex will use the current basis if possible | |
108 | - int err = lpx_simplex(model) ; | |
109 | + // glp_simplex will use the current basis if possible | |
110 | + int err = glp_simplex(model, &simplexParams_) ; | |
111 | ||
112 | // for Glpk, a solve fails if the initial basis is invalid or singular | |
113 | // thus, we construct a (advanced) basis first and try again | |
114 | -#ifdef LPX_E_BADB | |
115 | - if (err == LPX_E_BADB) { | |
116 | - lpx_adv_basis(model); | |
117 | - err = lpx_simplex(model) ; | |
118 | +#ifdef GLP_EBADB | |
119 | + if (err == GLP_EBADB) { | |
120 | + glp_adv_basis(model, 0); | |
121 | + err = glp_simplex(model, &simplexParams_) ; | |
122 | } else | |
123 | #endif | |
124 | - if (err == LPX_E_SING || err == LPX_E_FAULT) { | |
125 | - lpx_adv_basis(model); | |
126 | - err = lpx_simplex(model) ; | |
127 | + if (err == GLP_ESING || err == GLP_EFAIL) { | |
128 | + glp_adv_basis(model, 0); | |
129 | + err = glp_simplex(model, &simplexParams_) ; | |
130 | } | |
131 | ||
132 | - iter_used_ = lpx_get_int_parm(model,LPX_K_ITCNT) ; | |
133 | + iter_used_ = glp_get_it_cnt(model) ; | |
134 | ||
135 | isIterationLimitReached_ = false ; | |
136 | isTimeLimitReached_ = false ; | |
137 | @@ -289,39 +289,39 @@ void OGSI::resolve() | |
138 | isFeasible_ = false ; | |
139 | ||
140 | switch (err) | |
141 | - { case LPX_E_OK: | |
142 | + { case 0: | |
143 | { break ; } | |
144 | - case LPX_E_ITLIM: | |
145 | + case GLP_EITLIM: | |
146 | { isIterationLimitReached_ = true ; | |
147 | break ; } | |
148 | - case LPX_E_OBJLL: | |
149 | + case GLP_EOBJLL: | |
150 | { isObjLowerLimitReached_ = true ; | |
151 | break ; } | |
152 | - case LPX_E_OBJUL: | |
153 | + case GLP_EOBJUL: | |
154 | { isObjUpperLimitReached_ = true ; | |
155 | break ; } | |
156 | - case LPX_E_TMLIM: | |
157 | + case GLP_ETMLIM: | |
158 | { isTimeLimitReached_ = true ; | |
159 | } // no break here, so we still report abandoned | |
160 | - case LPX_E_FAULT: | |
161 | - case LPX_E_SING: | |
162 | -#ifdef LPX_E_BADB | |
163 | - case LPX_E_BADB: | |
164 | + case GLP_EFAIL: | |
165 | + case GLP_ESING: | |
166 | +#ifdef GLP_EBADB | |
167 | + case GLP_EBADB: | |
168 | #endif | |
169 | { isAbandoned_ = true ; | |
170 | break ; } | |
171 | - case LPX_E_NOPFS: | |
172 | + case GLP_ENOPFS: | |
173 | { isPrimInfeasible_ = true ; | |
174 | break ; } | |
175 | - case LPX_E_NODFS: | |
176 | + case GLP_ENODFS: | |
177 | { isDualInfeasible_ = true ; | |
178 | break ; } | |
179 | default: | |
180 | { assert(false) ; } } | |
181 | ||
182 | - switch (lpx_get_status(model)) | |
183 | - { case LPX_OPT: | |
184 | - case LPX_FEAS: | |
185 | + switch (glp_get_status(model)) | |
186 | + { case GLP_OPT: | |
187 | + case GLP_FEAS: | |
188 | { isFeasible_ = true ; | |
189 | break ; } | |
190 | default: | |
191 | @@ -337,7 +337,7 @@ void OGSI::resolve() | |
192 | ||
193 | /* | |
194 | Call glpk's built-in MIP solver. Any halfway recent version (from glpk 4.4, | |
195 | - at least) will have lpx_intopt, a branch-and-cut solver. The presence of cut | |
196 | + at least) will have glp_intopt, a branch-and-cut solver. The presence of cut | |
197 | generators is more recent. | |
198 | */ | |
199 | void OGSI::branchAndBound () | |
200 | @@ -351,52 +351,46 @@ void OGSI::branchAndBound () | |
201 | Assuming we have integer variables in the model, call the best MIP solver | |
202 | we can manage. | |
203 | ||
204 | - lpx_intopt does not require an optimal LP solution as a starting point, so | |
205 | + glp_intopt does not require an optimal LP solution as a starting point, so | |
206 | we can call it directly. | |
207 | ||
208 | lpx_integer needs an initial optimal solution to the relaxation. | |
209 | */ | |
210 | - if (lpx_get_num_int(model)) | |
211 | - { int err = LPX_E_FAULT ; | |
212 | + if (glp_get_num_int(model)) | |
213 | + { int err = GLP_EFAIL ; | |
214 | ||
215 | -# ifdef GLPK_HAS_INTOPT | |
216 | - err = lpx_intopt(model) ; | |
217 | -# else | |
218 | - if (lpx_get_status(model) != LPX_OPT) | |
219 | - { initialSolve() ; } | |
220 | - err = lpx_integer(model) ; | |
221 | -# endif | |
222 | + err = glp_intopt(model, &intoptParams_) ; | |
223 | /* | |
224 | We have a result. What is it? Start with a positive attitude and revise as | |
225 | - needed. The various LPX_E_* and LPX_I_* defines are stable back as far as | |
226 | - glpk-4.4. | |
227 | + needed. The various GLP_E* and GLP_* defines are stable back as far as | |
228 | + glpk-4.5x. | |
229 | ||
230 | - When we get LPX_E_OK (MIP terminated normally), we need to look more | |
231 | - closely. LPX_I_OPT indicates a proven optimal integer solution. | |
232 | - LPX_I_NOFEAS indicates that there is no integer feasible solution. | |
233 | - LPX_I_UNDEF says the MIP solution is undefined. LPX_I_FEAS says that in | |
234 | + When we get 0 (MIP terminated normally), we need to look more | |
235 | + closely. GLP_OPT indicates a proven optimal integer solution. | |
236 | + GLP_NOFEAS indicates that there is no integer feasible solution. | |
237 | + GLP_UNDEF says the MIP solution is undefined. GLP_FEAS says that in | |
238 | integer feasible solution was found but not proven optimal (termination of | |
239 | search due to some limit is the common cause). It's not clear what to do | |
240 | - with LPX_I_UNDEF; currently, it is not really reflected in | |
241 | - termination status. LPX_I_FEAS is reflected by the OsiGlpk specific method | |
242 | + with GLP_UNDEF; currently, it is not really reflected in | |
243 | + termination status. GLP_FEAS is reflected by the OsiGlpk specific method | |
244 | isFeasible(). | |
245 | ||
246 | - Various other codes are returned by lpx_intopt (lpx_integer returns a | |
247 | - subset of these). LPX_E_NOPFS (LPX_E_NODFS) indicate no primal (dual) | |
248 | + Various other codes are returned by glp_intopt (lpx_integer returns a | |
249 | + subset of these). GLP_ENOPFS (GLP_ENODFS) indicate no primal (dual) | |
250 | feasible solution; detected at the root, either by presolve or when | |
251 | - attempting the root relaxation. LPX_E_ITLIM (LPX_E_TMLIM) indicate | |
252 | + attempting the root relaxation. GLP_EITLIM (GLP_ETMLIM) indicate | |
253 | iteration (time) limit reached. Osi doesn't provide for time limit, so lump | |
254 | it in with iteration limit (an arguable choice, but seems better than the | |
255 | alternatives) and have extra method isTimeLimitReached(). | |
256 | - LPX_E_SING (lp solver failed due to singular basis) is | |
257 | - legimately characterised as abandoned. LPX_E_FAULT indicates a structural | |
258 | + GLP_ESING (lp solver failed due to singular basis) is | |
259 | + legimately characterised as abandoned. GLP_EFAIL indicates a structural | |
260 | problem (problem not of class MIP, or an integer variable has a non-integer | |
261 | bound), which really translates into internal confusion in OsiGlpk. | |
262 | ||
263 | Previous comments expressed uncertainty about the iteration count. This | |
264 | should be checked at some point. -- lh, 070709 -- | |
265 | */ | |
266 | - iter_used_ = lpx_get_int_parm(model,LPX_K_ITCNT) ; | |
267 | + iter_used_ = glp_get_it_cnt(model) ; | |
268 | isIterationLimitReached_ = false ; | |
269 | isTimeLimitReached_ = false ; | |
270 | isAbandoned_ = false ; | |
271 | @@ -407,45 +401,45 @@ void OGSI::branchAndBound () | |
272 | isObjUpperLimitReached_ = false ; | |
273 | ||
274 | switch (err) | |
275 | - { case LPX_E_OK: | |
276 | -#ifdef LPX_E_MIPGAP | |
277 | - case LPX_E_MIPGAP: | |
278 | + { case 0: | |
279 | +#ifdef GLP_EMIPGAP | |
280 | + case GLP_EMIPGAP: | |
281 | #endif | |
282 | { | |
283 | break ; } | |
284 | - case LPX_E_NOPFS: | |
285 | + case GLP_ENOPFS: | |
286 | { isPrimInfeasible_ = true ; | |
287 | break ; } | |
288 | - case LPX_E_NODFS: | |
289 | + case GLP_ENODFS: | |
290 | { isDualInfeasible_ = true ; | |
291 | break ; } | |
292 | - case LPX_E_TMLIM: | |
293 | + case GLP_ETMLIM: | |
294 | { isTimeLimitReached_ = true ; } // no break | |
295 | - case LPX_E_ITLIM: | |
296 | + case GLP_EITLIM: | |
297 | { isIterationLimitReached_ = true ; | |
298 | break ; } | |
299 | - case LPX_E_SING: | |
300 | + case GLP_ESING: | |
301 | { isAbandoned_ = true ; | |
302 | break ; } | |
303 | - case LPX_E_FAULT: | |
304 | + case GLP_EFAIL: | |
305 | { assert(false) ; | |
306 | break ; } | |
307 | default: | |
308 | { assert(false) ; | |
309 | break ; } } | |
310 | ||
311 | - //check this also if err!=LPX_E_OPT, so we know about feasibility in case time/resource limit is reached | |
312 | - int mip_status = lpx_mip_status(model) ; | |
313 | + //check this also if err!=GLP_OPT, so we know about feasibility in case time/resource limit is reached | |
314 | + int mip_status = glp_mip_status(model) ; | |
315 | switch (mip_status) | |
316 | - { case LPX_I_OPT: | |
317 | + { case GLP_OPT: | |
318 | { isFeasible_ = true ; | |
319 | break ; } | |
320 | - case LPX_I_NOFEAS: | |
321 | + case GLP_NOFEAS: | |
322 | { isPrimInfeasible_ = true ; | |
323 | break ; } | |
324 | - case LPX_I_UNDEF: | |
325 | + case GLP_UNDEF: | |
326 | { break ; } | |
327 | - case LPX_I_FEAS: | |
328 | + case GLP_FEAS: | |
329 | { isFeasible_ = true ; | |
330 | break ; } | |
331 | default: | |
332 | @@ -458,7 +452,7 @@ void OGSI::branchAndBound () | |
333 | /* | |
334 | Not a MIP (no integer variables). Call the LP solver. Since we can call | |
335 | branchAndBound with no initial LP solution, initialSolve is appropriate here. | |
336 | - (But for glpk, it actually makes no difference --- lpx_simplex makes the | |
337 | + (But for glpk, it actually makes no difference --- glp_simplex makes the | |
338 | decision on how to proceed.) | |
339 | */ | |
340 | else | |
341 | @@ -490,7 +484,7 @@ bool OGSI::setIntParam (OsiIntParam key, | |
342 | { case OsiMaxNumIteration: | |
343 | { if (value >= 0) | |
344 | { maxIteration_ = value ; | |
345 | - lpx_set_int_parm(lp_,LPX_K_ITLIM,value) ; | |
346 | + simplexParams_.it_lim = value ; | |
347 | retval = true ; } | |
348 | else | |
349 | { retval = false ; } | |
350 | @@ -531,24 +525,24 @@ bool OGSI::setDblParam (OsiDblParam key, | |
351 | // as of 4.7, GLPK only uses this if it does dual simplex | |
352 | { dualObjectiveLimit_ = value ; | |
353 | if (getObjSense() == 1) // minimization | |
354 | - { lpx_set_real_parm(lp_,LPX_K_OBJUL,value) ; } | |
355 | + { simplexParams_.obj_ul = value ; } | |
356 | else // maximization | |
357 | - { lpx_set_real_parm(lp_,LPX_K_OBJLL,value) ; } | |
358 | + { simplexParams_.obj_ll = value ; } | |
359 | retval = true ; | |
360 | break ; } | |
361 | case OsiPrimalObjectiveLimit: | |
362 | // as of 4.7, GLPK only uses this if it does dual simplex | |
363 | { primalObjectiveLimit_ = value ; | |
364 | if (getObjSense() == 1) | |
365 | - { lpx_set_real_parm(lp_,LPX_K_OBJLL,value) ; } | |
366 | + { simplexParams_.obj_ll = value ; } | |
367 | else | |
368 | - { lpx_set_real_parm(lp_,LPX_K_OBJUL,value) ; } | |
369 | + { simplexParams_.obj_ul = value ; } | |
370 | retval = true ; | |
371 | break ; } | |
372 | case OsiDualTolerance: | |
373 | { if (value >= 0 && value <= .001) | |
374 | { dualTolerance_ = value; | |
375 | - lpx_set_real_parm(lp_,LPX_K_TOLDJ,value) ; | |
376 | + simplexParams_.tol_dj = value ; | |
377 | retval = true ; } | |
378 | else | |
379 | { retval = false ; } | |
380 | @@ -556,14 +550,14 @@ bool OGSI::setDblParam (OsiDblParam key, | |
381 | case OsiPrimalTolerance: | |
382 | { if (value >= 0 && value <= .001) | |
383 | { primalTolerance_ = value ; | |
384 | - lpx_set_real_parm(lp_,LPX_K_TOLBND,value) ; | |
385 | + simplexParams_.tol_bnd = value ; | |
386 | retval = true ; } | |
387 | else | |
388 | { retval = false ; } | |
389 | break ; } | |
390 | case OsiObjOffset: | |
391 | { objOffset_ = value ; | |
392 | - lpx_set_obj_coef(lp_,0,value) ; | |
393 | + glp_set_obj_coef(lp_,0,value) ; | |
394 | retval = true ; | |
395 | break ; } | |
396 | case OsiLastDblParam: | |
397 | @@ -583,7 +577,7 @@ bool OGSI::setStrParam (OsiStrParam key, | |
398 | { probName_ = value ; | |
399 | if (probName_.length() == 0) | |
400 | probName_ = "Pb"; | |
401 | - lpx_set_prob_name(lp_,const_cast<char *>(value.c_str())) ; | |
402 | + glp_set_prob_name(lp_,const_cast<char *>(value.c_str())) ; | |
403 | retval = true ; | |
404 | break ; } | |
405 | case OsiSolverName: | |
406 | @@ -665,18 +659,18 @@ bool OGSI::setHintParam (OsiHintParam ke | |
407 | case OsiDoPresolveInInitial: | |
408 | case OsiDoPresolveInResolve: | |
409 | { if (sense == false) | |
410 | - { if (strength >= OsiHintTry) lpx_set_int_parm(lp_,LPX_K_PRESOL,0) ; } | |
411 | + { if (strength >= OsiHintTry) simplexParams_.presolve = intoptParams_.presolve = 0 ; } | |
412 | else | |
413 | - { lpx_set_int_parm(lp_,LPX_K_PRESOL,1) ; } | |
414 | + { simplexParams_.presolve = intoptParams_.presolve = 1 ; } | |
415 | retval = true ; | |
416 | break ; } | |
417 | case OsiDoDualInInitial: | |
418 | case OsiDoDualInResolve: | |
419 | { unimp_hint(msgHdl,false,sense,strength,"exclusive use of dual simplex") ; | |
420 | if (sense == false) | |
421 | - { if (strength >= OsiHintDo) lpx_set_int_parm(lp_,LPX_K_DUAL,0) ; } | |
422 | + { if (strength >= OsiHintDo) simplexParams_.meth = GLP_PRIMAL ; } | |
423 | else | |
424 | - { lpx_set_int_parm(lp_,LPX_K_DUAL,1) ; } | |
425 | + { simplexParams_.meth = GLP_DUALP ; } | |
426 | retval = true ; | |
427 | break ; } | |
428 | case OsiDoCrash: | |
429 | @@ -692,9 +686,10 @@ bool OGSI::setHintParam (OsiHintParam ke | |
430 | */ | |
431 | case OsiDoScale: | |
432 | { if (sense == false) | |
433 | - { if (strength >= OsiHintTry) lpx_set_int_parm(lp_,LPX_K_SCALE,0) ; } | |
434 | + { if (strength >= OsiHintTry) scaleFlags_ = 0 ; } | |
435 | else | |
436 | - { lpx_set_int_parm(lp_,LPX_K_SCALE,3) ; } | |
437 | + { scaleFlags_ = GLP_SF_GM | GLP_SF_EQ ; } | |
438 | + glp_scale_prob(lp_, scaleFlags_); | |
439 | retval = true ; | |
440 | break ; } | |
441 | /* | |
442 | @@ -704,15 +699,15 @@ bool OGSI::setHintParam (OsiHintParam ke | |
443 | case OsiDoReducePrint: | |
444 | { if (sense == true) | |
445 | { if (strength <= OsiHintTry) | |
446 | - { lpx_set_int_parm(lp_,LPX_K_MSGLEV,1) ; } | |
447 | + { simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_ERR ; } | |
448 | else | |
449 | - { lpx_set_int_parm(lp_,LPX_K_MSGLEV,0) ; } } | |
450 | + { simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_OFF ; } } | |
451 | else | |
452 | { if (strength <= OsiHintTry) | |
453 | - { lpx_set_int_parm(lp_,LPX_K_MSGLEV,2) ; } | |
454 | + { simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_ON ; } | |
455 | else | |
456 | - { lpx_set_int_parm(lp_,LPX_K_MSGLEV,3) ; } } | |
457 | - int logLevel = lpx_get_int_parm(lp_,LPX_K_MSGLEV) ; | |
458 | + { simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_ALL ; } } | |
459 | + int logLevel = simplexParams_.msg_lev ; | |
460 | messageHandler()->setLogLevel(logLevel) ; | |
461 | retval = true ; | |
462 | break ; } | |
463 | @@ -787,7 +782,7 @@ OGSI::getDblParam( OsiDblParam key, doub | |
464 | break; | |
465 | ||
466 | case OsiObjOffset: | |
467 | - value = lpx_get_obj_coef(getMutableModelPtr(),0); | |
468 | + value = glp_get_obj_coef(getMutableModelPtr(),0); | |
469 | retval = true; | |
470 | break; | |
471 | ||
472 | @@ -805,7 +800,7 @@ OGSI::getStrParam(OsiStrParam key, std:: | |
473 | // bool retval = false; | |
474 | switch (key) { | |
475 | case OsiProbName: | |
476 | - value = lpx_get_prob_name( getMutableModelPtr() ); | |
477 | + value = glp_get_prob_name( getMutableModelPtr() ); | |
478 | break; | |
479 | case OsiSolverName: | |
480 | value = "glpk"; | |
481 | @@ -830,13 +825,13 @@ bool OGSI::isProvenOptimal() const | |
482 | ||
483 | if( bbWasLast_ == 0 ) | |
484 | { | |
485 | - int stat = lpx_get_status( model ); | |
486 | - return stat == LPX_OPT; | |
487 | + int stat = glp_get_status( model ); | |
488 | + return stat == GLP_OPT; | |
489 | } | |
490 | else | |
491 | { | |
492 | - int stat = lpx_mip_status( model ); | |
493 | - return stat == LPX_I_OPT; | |
494 | + int stat = glp_mip_status( model ); | |
495 | + return stat == GLP_OPT; | |
496 | } | |
497 | } | |
498 | ||
499 | @@ -848,9 +843,9 @@ bool OGSI::isProvenPrimalInfeasible() co | |
500 | return true; | |
501 | ||
502 | if( bbWasLast_ == 0 ) | |
503 | - return lpx_get_prim_stat( model ) == LPX_P_NOFEAS; | |
504 | + return glp_get_prim_stat( model ) == GLP_NOFEAS; | |
505 | else | |
506 | - return lpx_mip_status( model ) == LPX_I_NOFEAS; | |
507 | + return glp_mip_status( model ) == GLP_NOFEAS; | |
508 | } | |
509 | ||
510 | bool OGSI::isProvenDualInfeasible() const | |
511 | @@ -861,7 +856,7 @@ bool OGSI::isProvenDualInfeasible() cons | |
512 | return true; | |
513 | ||
514 | if( bbWasLast_ == 0 ) | |
515 | - return lpx_get_dual_stat( model ) == LPX_D_NOFEAS; | |
516 | + return glp_get_dual_stat( model ) == GLP_NOFEAS; | |
517 | else | |
518 | // Not sure what to do for MIPs; does it just mean unbounded? | |
519 | // ??? for now, return false | |
520 | @@ -933,7 +928,7 @@ bool OGSI::isFeasible() const | |
521 | /* | |
522 | Return a warm start object matching the current state of the solver. | |
523 | ||
524 | - Nonbasic fixed variables (LPX_NS) are translated to CWSB::atLowerBound. | |
525 | + Nonbasic fixed variables (GLP_NS) are translated to CWSB::atLowerBound. | |
526 | */ | |
527 | CoinWarmStart *OGSI::getWarmStart() const | |
528 | ||
529 | @@ -953,19 +948,19 @@ CoinWarmStart *OGSI::getWarmStart() cons | |
530 | and Glpk's at-upper-bound will be mapped to Osi's at-lower-bound. | |
531 | */ | |
532 | for (int i = 0 ; i < numrows ; i++) | |
533 | - { int stati = lpx_get_row_stat(lp_,i+1) ; | |
534 | + { int stati = glp_get_row_stat(lp_,i+1) ; | |
535 | switch (stati) | |
536 | - { case LPX_BS: | |
537 | + { case GLP_BS: | |
538 | { ws->setArtifStatus(i,CoinWarmStartBasis::basic) ; | |
539 | break ; } | |
540 | - case LPX_NS: | |
541 | - case LPX_NL: | |
542 | + case GLP_NS: | |
543 | + case GLP_NL: | |
544 | { ws->setArtifStatus(i,CoinWarmStartBasis::atUpperBound) ; | |
545 | break ; } | |
546 | - case LPX_NU: | |
547 | + case GLP_NU: | |
548 | { ws->setArtifStatus(i,CoinWarmStartBasis::atLowerBound) ; | |
549 | break ; } | |
550 | - case LPX_NF: | |
551 | + case GLP_NF: | |
552 | { ws->setArtifStatus(i,CoinWarmStartBasis::isFree) ; | |
553 | break ; } | |
554 | default: | |
555 | @@ -975,19 +970,19 @@ CoinWarmStart *OGSI::getWarmStart() cons | |
556 | And repeat for the columns. | |
557 | */ | |
558 | for (int j = 0 ; j < numcols ; j++) | |
559 | - { int statj = lpx_get_col_stat(lp_,j+1) ; | |
560 | + { int statj = glp_get_col_stat(lp_,j+1) ; | |
561 | switch (statj) | |
562 | - { case LPX_BS: | |
563 | + { case GLP_BS: | |
564 | { ws->setStructStatus(j,CoinWarmStartBasis::basic) ; | |
565 | break ; } | |
566 | - case LPX_NS: | |
567 | - case LPX_NL: | |
568 | + case GLP_NS: | |
569 | + case GLP_NL: | |
570 | { ws->setStructStatus(j,CoinWarmStartBasis::atLowerBound) ; | |
571 | break ; } | |
572 | - case LPX_NU: | |
573 | + case GLP_NU: | |
574 | { ws->setStructStatus(j,CoinWarmStartBasis::atUpperBound) ; | |
575 | break ; } | |
576 | - case LPX_NF: | |
577 | + case GLP_NF: | |
578 | { ws->setStructStatus(j,CoinWarmStartBasis::isFree) ; | |
579 | break ; } | |
580 | default: | |
581 | @@ -1040,44 +1035,44 @@ bool OGSI::setWarmStart (const CoinWarmS | |
582 | ||
583 | switch (ws->getArtifStatus(i)) | |
584 | { case CoinWarmStartBasis::basic: | |
585 | - { stati = LPX_BS ; | |
586 | + { stati = GLP_BS ; | |
587 | break ; } | |
588 | case CoinWarmStartBasis::atLowerBound: | |
589 | - { stati = LPX_NU ; | |
590 | + { stati = GLP_NU ; | |
591 | break ; } | |
592 | case CoinWarmStartBasis::atUpperBound: | |
593 | - { stati = LPX_NL ; | |
594 | + { stati = GLP_NL ; | |
595 | break ; } | |
596 | case CoinWarmStartBasis::isFree: | |
597 | - { stati = LPX_NF ; | |
598 | + { stati = GLP_NF ; | |
599 | break ; } | |
600 | default: | |
601 | { assert(false) ; | |
602 | return (false) ; } } | |
603 | ||
604 | - lpx_set_row_stat(lp_,i+1,stati) ; } | |
605 | + glp_set_row_stat(lp_,i+1,stati) ; } | |
606 | ||
607 | for (int j = 0 ; j < numcols ; j++) | |
608 | { int statj ; | |
609 | ||
610 | switch (ws->getStructStatus(j)) | |
611 | { case CoinWarmStartBasis::basic: | |
612 | - { statj = LPX_BS ; | |
613 | + { statj = GLP_BS ; | |
614 | break ; } | |
615 | case CoinWarmStartBasis::atLowerBound: | |
616 | - { statj = LPX_NL ; | |
617 | + { statj = GLP_NL ; | |
618 | break ; } | |
619 | case CoinWarmStartBasis::atUpperBound: | |
620 | - { statj = LPX_NU ; | |
621 | + { statj = GLP_NU ; | |
622 | break ; } | |
623 | case CoinWarmStartBasis::isFree: | |
624 | - { statj = LPX_NF ; | |
625 | + { statj = GLP_NF ; | |
626 | break ; } | |
627 | default: | |
628 | { assert(false) ; | |
629 | return (false) ; } } | |
630 | ||
631 | - lpx_set_col_stat(lp_,j+1,statj) ; } | |
632 | + glp_set_col_stat(lp_,j+1,statj) ; } | |
633 | ||
634 | return (true) ; } | |
635 | ||
636 | @@ -1108,9 +1103,9 @@ void OGSI::markHotStart() | |
637 | int stat; | |
638 | double val; | |
639 | double dualVal; | |
640 | - stat=lpx_get_col_stat(model,j); | |
641 | - val=lpx_get_col_prim(model,j); | |
642 | - dualVal=lpx_get_col_dual(model,j); | |
643 | + stat=glp_get_col_stat(model,j); | |
644 | + val=glp_get_col_prim(model,j); | |
645 | + dualVal=glp_get_col_dual(model,j); | |
646 | hotStartCStat_[j] = stat; | |
647 | hotStartCVal_[j] = val; | |
648 | hotStartCDualVal_[j] = dualVal; | |
649 | @@ -1131,9 +1126,9 @@ void OGSI::markHotStart() | |
650 | int stat; | |
651 | double val; | |
652 | double dualVal; | |
653 | - stat=lpx_get_row_stat(model,i+1); | |
654 | - val=lpx_get_row_prim(model,i+1); | |
655 | - dualVal=lpx_get_row_dual(model,i+1); | |
656 | + stat=glp_get_row_stat(model,i+1); | |
657 | + val=glp_get_row_prim(model,i+1); | |
658 | + dualVal=glp_get_row_dual(model,i+1); | |
659 | hotStartRStat_[i] = stat; | |
660 | hotStartRVal_[i] = val; | |
661 | hotStartRDualVal_[i] = dualVal; | |
662 | @@ -1160,11 +1155,11 @@ void OGSI::solveFromHotStart() | |
663 | ||
664 | int j; | |
665 | for( j = 0; j < numcols; j++ ) { | |
666 | - lpx_set_col_stat( model, j+1, hotStartCStat_[j]); | |
667 | + glp_set_col_stat( model, j+1, hotStartCStat_[j]); | |
668 | } | |
669 | int i; | |
670 | for( i = 0; i < numrows; i++ ) { | |
671 | - lpx_set_row_stat( model, i+1, hotStartRStat_[i]); | |
672 | + glp_set_row_stat( model, i+1, hotStartRStat_[i]); | |
673 | } | |
674 | ||
675 | freeCachedData( OGSI::FREECACHED_RESULTS ); | |
676 | @@ -1191,17 +1186,17 @@ void OGSI::unmarkHotStart() | |
677 | //----------------------------------------------------------------------------- | |
678 | int OGSI::getNumCols() const | |
679 | { | |
680 | - return lpx_get_num_cols( getMutableModelPtr() ); | |
681 | + return glp_get_num_cols( getMutableModelPtr() ); | |
682 | } | |
683 | ||
684 | int OGSI::getNumRows() const | |
685 | { | |
686 | - return lpx_get_num_rows( getMutableModelPtr() ); | |
687 | + return glp_get_num_rows( getMutableModelPtr() ); | |
688 | } | |
689 | ||
690 | int OGSI::getNumElements() const | |
691 | { | |
692 | - return lpx_get_num_nz( getMutableModelPtr() ); | |
693 | + return glp_get_num_nz( getMutableModelPtr() ); | |
694 | } | |
695 | ||
696 | //----------------------------------------------------------------------------- | |
697 | @@ -1230,26 +1225,26 @@ const double * OGSI::getColLower() const | |
698 | int type; | |
699 | double lb; | |
700 | double ub; | |
701 | - type=lpx_get_col_type(model,i+1); | |
702 | - lb=lpx_get_col_lb(model,i+1); | |
703 | - ub=lpx_get_col_ub(model,i+1); | |
704 | + type=glp_get_col_type(model,i+1); | |
705 | + lb=glp_get_col_lb(model,i+1); | |
706 | + ub=glp_get_col_ub(model,i+1); | |
707 | switch ( type ) | |
708 | { | |
709 | - case LPX_FR: | |
710 | + case GLP_FR: | |
711 | lb = -inf; | |
712 | ub = inf; | |
713 | break; | |
714 | ||
715 | - case LPX_LO: | |
716 | + case GLP_LO: | |
717 | ub = inf; | |
718 | break; | |
719 | ||
720 | - case LPX_UP: | |
721 | + case GLP_UP: | |
722 | lb = -inf; | |
723 | break; | |
724 | ||
725 | - case LPX_FX: | |
726 | - case LPX_DB: | |
727 | + case GLP_FX: | |
728 | + case GLP_DB: | |
729 | break; | |
730 | ||
731 | default: | |
732 | @@ -1355,26 +1350,26 @@ const double * OGSI::getRowLower() const | |
733 | int type; | |
734 | double lb; | |
735 | double ub; | |
736 | - type=lpx_get_row_type(model,i+1); | |
737 | - lb=lpx_get_row_lb(model,i+1); | |
738 | - ub=lpx_get_row_ub(model,i+1); | |
739 | + type=glp_get_row_type(model,i+1); | |
740 | + lb=glp_get_row_lb(model,i+1); | |
741 | + ub=glp_get_row_ub(model,i+1); | |
742 | switch( type ) | |
743 | { | |
744 | - case LPX_FR: | |
745 | + case GLP_FR: | |
746 | lb = -inf; | |
747 | ub = inf; | |
748 | break; | |
749 | ||
750 | - case LPX_LO: | |
751 | + case GLP_LO: | |
752 | ub = inf; | |
753 | break; | |
754 | ||
755 | - case LPX_UP: | |
756 | + case GLP_UP: | |
757 | lb = -inf; | |
758 | break; | |
759 | ||
760 | - case LPX_DB: | |
761 | - case LPX_FX: | |
762 | + case GLP_DB: | |
763 | + case GLP_FX: | |
764 | break; | |
765 | ||
766 | default: | |
767 | @@ -1416,7 +1411,7 @@ const double * OGSI::getObjCoefficients( | |
768 | int i; | |
769 | for( i = 0; i < numcols; i++ ) | |
770 | { | |
771 | - obj_[i] = lpx_get_obj_coef( model, i + 1); | |
772 | + obj_[i] = glp_get_obj_coef( model, i + 1); | |
773 | } | |
774 | } | |
775 | return obj_; | |
776 | @@ -1426,10 +1421,10 @@ const double * OGSI::getObjCoefficients( | |
777 | ||
778 | double OGSI::getObjSense() const | |
779 | ||
780 | -{ if (lpx_get_obj_dir(lp_) == LPX_MIN) | |
781 | +{ if (glp_get_obj_dir(lp_) == GLP_MIN) | |
782 | { return (+1.0) ; } | |
783 | else | |
784 | - if (lpx_get_obj_dir(lp_) == LPX_MAX) | |
785 | + if (glp_get_obj_dir(lp_) == GLP_MAX) | |
786 | { return (-1.0) ; } | |
787 | else // internal confusion | |
788 | { assert(false) ; | |
789 | @@ -1441,7 +1436,7 @@ double OGSI::getObjSense() const | |
790 | ||
791 | bool OGSI::isContinuous( int colNumber ) const | |
792 | { | |
793 | - return lpx_get_col_kind( getMutableModelPtr(), colNumber+1 ) == LPX_CV; | |
794 | + return glp_get_col_kind( getMutableModelPtr(), colNumber+1 ) == GLP_CV; | |
795 | } | |
796 | ||
797 | //----------------------------------------------------------------------------- | |
798 | @@ -1464,14 +1459,14 @@ const CoinPackedMatrix * OGSI::getMatrix | |
799 | int i; | |
800 | for( i = 0; i < getNumRows(); i++ ) | |
801 | { | |
802 | - int colsize = lpx_get_mat_row( model, i+1, colind, colelem); | |
803 | + int colsize = glp_get_mat_row( model, i+1, colind, colelem); | |
804 | int j; | |
805 | for( j = 1; j <= colsize; j++ ) | |
806 | { | |
807 | --colind[j]; | |
808 | } | |
809 | ||
810 | - // Note: lpx_get_mat_row apparently may return the | |
811 | + // Note: glp_get_mat_row apparently may return the | |
812 | // elements in decreasing order. This differs from | |
813 | // people's standard expectations but is not an error. | |
814 | ||
815 | @@ -1502,7 +1497,7 @@ const CoinPackedMatrix * OGSI::getMatrix | |
816 | int j; | |
817 | for( j = 0; j < getNumCols(); j++ ) | |
818 | { | |
819 | - int rowsize = lpx_get_mat_col( model, j+1, rowind, rowelem); | |
820 | + int rowsize = glp_get_mat_col( model, j+1, rowind, rowelem); | |
821 | int i; | |
822 | for( i = 1; i <= rowsize; i++ ) | |
823 | { | |
824 | @@ -1563,9 +1558,9 @@ const double *OGSI::getColSolution() con | |
825 | */ | |
826 | int probStatus ; | |
827 | if (bbWasLast_) | |
828 | - { probStatus = lpx_mip_status(lp_) ; } | |
829 | + { probStatus = glp_mip_status(lp_) ; } | |
830 | else | |
831 | - { probStatus = lpx_get_status(lp_) ; } | |
832 | + { probStatus = glp_get_status(lp_) ; } | |
833 | /* | |
834 | If the problem hasn't been solved, glpk returns zeros, but OSI requires that | |
835 | the solution be within bound. getColLower() will ensure both upper and lower | |
836 | @@ -1573,7 +1568,7 @@ const double *OGSI::getColSolution() con | |
837 | collower[j] < colupper[j]). Solution values will be 0.0 unless that's outside | |
838 | the bounds. | |
839 | */ | |
840 | - if (probStatus == LPX_UNDEF || probStatus == LPX_I_UNDEF) | |
841 | + if (probStatus == GLP_UNDEF) | |
842 | { getColLower() ; | |
843 | int j ; | |
844 | for (j = 0 ; j < numcols ; j++) | |
845 | @@ -1591,10 +1586,10 @@ const double *OGSI::getColSolution() con | |
846 | if (bbWasLast_ == 0) | |
847 | { int j ; | |
848 | for (j = 0 ; j < numcols ; j++) | |
849 | - { colsol_[j] = lpx_get_col_prim(lp_,j+1) ; | |
850 | + { colsol_[j] = glp_get_col_prim(lp_,j+1) ; | |
851 | if (fabs(colsol_[j]) < GlpkZeroTol) | |
852 | { colsol_[j] = 0.0 ; } | |
853 | - redcost_[j] = lpx_get_col_dual(lp_,j+1) ; | |
854 | + redcost_[j] = glp_get_col_dual(lp_,j+1) ; | |
855 | if (fabs(redcost_[j]) < GlpkZeroTol) | |
856 | { redcost_[j] = 0.0 ; } } } | |
857 | /* | |
858 | @@ -1604,7 +1599,7 @@ const double *OGSI::getColSolution() con | |
859 | else | |
860 | { int j ; | |
861 | for (j = 0 ; j < numcols ; j++) | |
862 | - { colsol_[j] = lpx_mip_col_val(lp_,j+1) ; | |
863 | + { colsol_[j] = glp_mip_col_val(lp_,j+1) ; | |
864 | if (fabs(colsol_[j]) < GlpkZeroTol) | |
865 | { colsol_[j] = 0.0 ; } | |
866 | redcost_[j] = 0.0 ; } } | |
867 | @@ -1641,7 +1636,7 @@ const double *OGSI::getRowPrice() const | |
868 | if (bbWasLast_ == 0) | |
869 | { int i ; | |
870 | for (i = 0 ; i < numrows; i++) | |
871 | - { rowsol_[i] = lpx_get_row_dual(lp_,i+1) ; | |
872 | + { rowsol_[i] = glp_get_row_dual(lp_,i+1) ; | |
873 | if (fabs(rowsol_[i]) < GlpkZeroTol) | |
874 | { rowsol_[i] = 0.0 ; } } } | |
875 | else | |
876 | @@ -1658,7 +1653,7 @@ const double *OGSI::getRowPrice() const | |
877 | setRowPrice(), and it'd be nice to return reduced costs that agree with the | |
878 | duals. | |
879 | ||
880 | - To use glpk's routine (lpx_get_col_dual), the interface needs to track the | |
881 | + To use glpk's routine (glp_get_col_dual), the interface needs to track the | |
882 | origin of the dual (row price) values. | |
883 | */ | |
884 | const double * OGSI::getReducedCost() const | |
885 | @@ -1813,7 +1808,7 @@ void OGSI::setObjCoeff (int j, double cj | |
886 | /* | |
887 | Push the changed objective down to glpk. | |
888 | */ | |
889 | - lpx_set_obj_coef(lp_,j+1,cj) ; | |
890 | + glp_set_obj_coef(lp_,j+1,cj) ; | |
891 | ||
892 | if (obj_) | |
893 | { obj_[j] = cj ; } | |
894 | @@ -1830,15 +1825,15 @@ void OGSI::setColLower (int j, double lb | |
895 | infinite bound, so we need to check the status and possibly correct. | |
896 | */ | |
897 | double inf = getInfinity() ; | |
898 | - int type = lpx_get_col_type(lp_,j+1) ; | |
899 | - double ubj = lpx_get_col_ub(lp_,j+1) ; | |
900 | + int type = glp_get_col_type(lp_,j+1) ; | |
901 | + double ubj = glp_get_col_ub(lp_,j+1) ; | |
902 | switch (type) | |
903 | - { case LPX_UP: | |
904 | - case LPX_DB: | |
905 | - case LPX_FX: | |
906 | + { case GLP_UP: | |
907 | + case GLP_DB: | |
908 | + case GLP_FX: | |
909 | { break ; } | |
910 | - case LPX_FR: | |
911 | - case LPX_LO: | |
912 | + case GLP_FR: | |
913 | + case GLP_LO: | |
914 | { ubj = inf ; | |
915 | break ; } | |
916 | default: | |
917 | @@ -1875,15 +1870,15 @@ void OGSI::setColUpper (int j, double ub | |
918 | infinite bound, so we need to check the status and possibly correct. | |
919 | */ | |
920 | double inf = getInfinity() ; | |
921 | - int type = lpx_get_col_type(lp_,j+1) ; | |
922 | - double lbj = lpx_get_col_lb(lp_,j+1) ; | |
923 | + int type = glp_get_col_type(lp_,j+1) ; | |
924 | + double lbj = glp_get_col_lb(lp_,j+1) ; | |
925 | switch (type) | |
926 | - { case LPX_LO: | |
927 | - case LPX_DB: | |
928 | - case LPX_FX: | |
929 | + { case GLP_LO: | |
930 | + case GLP_DB: | |
931 | + case GLP_FX: | |
932 | { break ; } | |
933 | - case LPX_FR: | |
934 | - case LPX_UP: | |
935 | + case GLP_FR: | |
936 | + case GLP_UP: | |
937 | { lbj = inf ; | |
938 | break ; } | |
939 | default: | |
940 | @@ -1932,25 +1927,25 @@ void OGSI::setColBounds (int j, double l | |
941 | int type ; | |
942 | ||
943 | if (lower == upper) | |
944 | - { type = LPX_FX ; } | |
945 | + { type = GLP_FX ; } | |
946 | else | |
947 | if (lower > -inf && upper < inf) | |
948 | - { type = LPX_DB ; } | |
949 | + { type = GLP_DB ; } | |
950 | else | |
951 | if (lower > -inf) | |
952 | - { type = LPX_LO ; } | |
953 | + { type = GLP_LO ; } | |
954 | else | |
955 | if (upper < inf) | |
956 | - { type = LPX_UP ; } | |
957 | + { type = GLP_UP ; } | |
958 | else | |
959 | - { type = LPX_FR ; } | |
960 | + { type = GLP_FR ; } | |
961 | /* | |
962 | Push the bound change down into the solver. 1-based addressing. | |
963 | */ | |
964 | - int statj = lpx_get_col_stat(lp_,j+1) ; | |
965 | - lpx_set_col_bnds(lp_,j+1,type,lower,upper) ; | |
966 | - lpx_set_col_stat(lp_,j+1,statj) ; | |
967 | - statj = lpx_get_col_stat(lp_,j+1) ; | |
968 | + int statj = glp_get_col_stat(lp_,j+1) ; | |
969 | + glp_set_col_bnds(lp_,j+1,type,lower,upper) ; | |
970 | + glp_set_col_stat(lp_,j+1,statj) ; | |
971 | + statj = glp_get_col_stat(lp_,j+1) ; | |
972 | /* | |
973 | Correct the cached upper and lower bound vectors, if present. | |
974 | */ | |
975 | @@ -1982,18 +1977,18 @@ OGSI::setRowLower( int elementIndex, dou | |
976 | double lb; | |
977 | double ub; | |
978 | ||
979 | - type=lpx_get_row_type(getMutableModelPtr(),elementIndex+1); | |
980 | - ub=lpx_get_row_ub(getMutableModelPtr(),elementIndex+1); | |
981 | + type=glp_get_row_type(getMutableModelPtr(),elementIndex+1); | |
982 | + ub=glp_get_row_ub(getMutableModelPtr(),elementIndex+1); | |
983 | lb = elementValue; | |
984 | switch( type ) | |
985 | { | |
986 | - case LPX_UP: | |
987 | - case LPX_DB: | |
988 | - case LPX_FX: | |
989 | + case GLP_UP: | |
990 | + case GLP_DB: | |
991 | + case GLP_FX: | |
992 | break; | |
993 | ||
994 | - case LPX_FR: | |
995 | - case LPX_LO: | |
996 | + case GLP_FR: | |
997 | + case GLP_LO: | |
998 | ub = inf; | |
999 | break; | |
1000 | ||
1001 | @@ -2014,18 +2009,18 @@ OGSI::setRowUpper( int elementIndex, dou | |
1002 | double lb; | |
1003 | double ub; | |
1004 | ||
1005 | - type=lpx_get_row_type(getMutableModelPtr(),elementIndex+1); | |
1006 | - lb=lpx_get_row_lb(getMutableModelPtr(),elementIndex+1); | |
1007 | + type=glp_get_row_type(getMutableModelPtr(),elementIndex+1); | |
1008 | + lb=glp_get_row_lb(getMutableModelPtr(),elementIndex+1); | |
1009 | ub = elementValue; | |
1010 | switch( type ) | |
1011 | { | |
1012 | - case LPX_LO: | |
1013 | - case LPX_DB: | |
1014 | - case LPX_FX: | |
1015 | + case GLP_LO: | |
1016 | + case GLP_DB: | |
1017 | + case GLP_FX: | |
1018 | break; | |
1019 | ||
1020 | - case LPX_FR: | |
1021 | - case LPX_UP: | |
1022 | + case GLP_FR: | |
1023 | + case GLP_UP: | |
1024 | lb = -inf; | |
1025 | break; | |
1026 | ||
1027 | @@ -2056,20 +2051,20 @@ void OGSI::setRowBounds (int i, double l | |
1028 | int type ; | |
1029 | ||
1030 | if( lower == upper) | |
1031 | - { type = LPX_FX ; } | |
1032 | + { type = GLP_FX ; } | |
1033 | else | |
1034 | if (lower > -inf && upper < inf) | |
1035 | - { type = LPX_DB ; } | |
1036 | + { type = GLP_DB ; } | |
1037 | else | |
1038 | if (lower > -inf) | |
1039 | - { type = LPX_LO ; } | |
1040 | + { type = GLP_LO ; } | |
1041 | else | |
1042 | if (upper < inf) | |
1043 | - { type = LPX_UP ; } | |
1044 | + { type = GLP_UP ; } | |
1045 | else | |
1046 | - { type = LPX_FR ; } | |
1047 | + { type = GLP_FR ; } | |
1048 | ||
1049 | - lpx_set_row_bnds(lp_,i+1,type,lower,upper) ; | |
1050 | + glp_set_row_bnds(lp_,i+1,type,lower,upper) ; | |
1051 | /* | |
1052 | Update cached vectors, if they exist. | |
1053 | */ | |
1054 | @@ -2123,7 +2118,7 @@ OGSI::setContinuous(int index) | |
1055 | { | |
1056 | LPX *model = getMutableModelPtr(); | |
1057 | freeCachedData( OGSI::FREECACHED_COLUMN ); | |
1058 | - lpx_set_col_kind( model, index+1, LPX_CV ); | |
1059 | + glp_set_col_kind( model, index+1, GLP_CV ); | |
1060 | } | |
1061 | ||
1062 | //----------------------------------------------------------------------------- | |
1063 | @@ -2132,7 +2127,7 @@ void OGSI::setInteger (int index) | |
1064 | ||
1065 | { LPX *model = getMutableModelPtr() ; | |
1066 | freeCachedData(OGSI::FREECACHED_COLUMN) ; | |
1067 | - lpx_set_col_kind(model,index+1,LPX_IV) ; | |
1068 | + glp_set_col_kind(model,index+1,GLP_IV) ; | |
1069 | /* | |
1070 | Temporary hack to correct upper bounds on general integer variables. | |
1071 | CoinMpsIO insists on forcing a bound of 1e30 for general integer variables | |
1072 | @@ -2184,9 +2179,9 @@ void OGSI::setObjSense(double s) | |
1073 | { freeCachedData(OGSI::FREECACHED_RESULTS) ; | |
1074 | ||
1075 | if (s <= -1.0) | |
1076 | - { lpx_set_obj_dir(lp_,LPX_MAX) ; } | |
1077 | + { glp_set_obj_dir(lp_,GLP_MAX) ; } | |
1078 | else | |
1079 | - { lpx_set_obj_dir(lp_,LPX_MIN) ; } | |
1080 | + { glp_set_obj_dir(lp_,GLP_MIN) ; } | |
1081 | ||
1082 | return ; } | |
1083 | ||
1084 | @@ -2252,12 +2247,12 @@ void OGSI::addCol (const CoinPackedVecto | |
1085 | const double collb, const double colub, const double obj) | |
1086 | { | |
1087 | // Note: GLPK expects only non-zero coefficients will be given in | |
1088 | - // lpx_set_mat_col and will abort if there are any zeros. So any | |
1089 | - // zeros must be removed prior to calling lpx_set_mat_col. | |
1090 | + // glp_set_mat_col and will abort if there are any zeros. So any | |
1091 | + // zeros must be removed prior to calling glp_set_mat_col. | |
1092 | LPX *model = getMutableModelPtr(); | |
1093 | freeCachedData(OGSI::KEEPCACHED_ROW); | |
1094 | ||
1095 | - lpx_add_cols( model, 1 ); | |
1096 | + glp_add_cols( model, 1 ); | |
1097 | int numcols = getNumCols(); | |
1098 | setColBounds( numcols-1, collb, colub ); | |
1099 | setObjCoeff( numcols-1, obj ); | |
1100 | @@ -2276,7 +2271,7 @@ void OGSI::addCol (const CoinPackedVecto | |
1101 | if (elements[i] != 0.0) | |
1102 | { | |
1103 | if ( indices[i]+1 > numrows ) { | |
1104 | - lpx_add_rows( model, indices[i]+1 - numrows ); | |
1105 | + glp_add_rows( model, indices[i]+1 - numrows ); | |
1106 | numrows = indices[i]+1; | |
1107 | // ??? could do this more efficiently with a single call based on the max | |
1108 | } | |
1109 | @@ -2286,7 +2281,7 @@ void OGSI::addCol (const CoinPackedVecto | |
1110 | elements_adj[count] = elements[i]; | |
1111 | } | |
1112 | } | |
1113 | - lpx_set_mat_col( model, numcols, count, indices_adj, elements_adj ); | |
1114 | + glp_set_mat_col( model, numcols, count, indices_adj, elements_adj ); | |
1115 | delete [] indices_adj; | |
1116 | delete [] elements_adj; | |
1117 | ||
1118 | @@ -2326,7 +2321,7 @@ OGSI::deleteCols(const int num, const in | |
1119 | columnIndicesPlus1[i+1]=columnIndices[i]+1; | |
1120 | deleteColNames(columnIndices[i],1); | |
1121 | } | |
1122 | - lpx_del_cols(model,num,columnIndicesPlus1); | |
1123 | + glp_del_cols(model,num,columnIndicesPlus1); | |
1124 | delete [] columnIndicesPlus1; | |
1125 | ||
1126 | # if OGSI_TRACK_FRESH > 0 | |
1127 | @@ -2344,13 +2339,13 @@ OGSI::addRow (const CoinPackedVectorBase | |
1128 | const double rowlb, const double rowub) | |
1129 | { | |
1130 | // Note: GLPK expects only non-zero coefficients will be given in | |
1131 | - // lpx_set_mat_row and will abort if there are any zeros. So any | |
1132 | - // zeros must be removed prior to calling lpx_set_mat_row. | |
1133 | + // glp_set_mat_row and will abort if there are any zeros. So any | |
1134 | + // zeros must be removed prior to calling glp_set_mat_row. | |
1135 | ||
1136 | LPX *model = getMutableModelPtr(); | |
1137 | freeCachedData( OGSI::KEEPCACHED_COLUMN ); | |
1138 | ||
1139 | - lpx_add_rows( model, 1 ); | |
1140 | + glp_add_rows( model, 1 ); | |
1141 | int numrows = getNumRows(); | |
1142 | setRowBounds( numrows-1, rowlb, rowub ); | |
1143 | int i; | |
1144 | @@ -2369,7 +2364,7 @@ OGSI::addRow (const CoinPackedVectorBase | |
1145 | { | |
1146 | if ( indices[i]+1 > numcols ) { | |
1147 | // ??? Could do this more efficiently with a single call | |
1148 | - lpx_add_cols( model, indices[i]+1 - numcols ); | |
1149 | + glp_add_cols( model, indices[i]+1 - numcols ); | |
1150 | numcols = indices[i]+1; | |
1151 | } | |
1152 | count++; | |
1153 | @@ -2377,7 +2372,7 @@ OGSI::addRow (const CoinPackedVectorBase | |
1154 | indices_adj[count] = indices[i] + 1; | |
1155 | } | |
1156 | } | |
1157 | - lpx_set_mat_row( model, numrows, count, indices_adj, elements_adj ); | |
1158 | + glp_set_mat_row( model, numrows, count, indices_adj, elements_adj ); | |
1159 | delete [] indices_adj; | |
1160 | delete [] elements_adj; | |
1161 | ||
1162 | @@ -2461,8 +2456,8 @@ void OGSI::deleteRows (const int num, co | |
1163 | int notBasic = 0 ; | |
1164 | for (ndx = 1 ; ndx <= num ; ndx++) | |
1165 | { i = glpkIndices[ndx] ; | |
1166 | - int stati = lpx_get_row_stat(lp_,i) ; | |
1167 | - if (stati != LPX_BS) | |
1168 | + int stati = glp_get_row_stat(lp_,i) ; | |
1169 | + if (stati != GLP_BS) | |
1170 | { notBasic++ ; } } | |
1171 | if (notBasic) | |
1172 | { | |
1173 | @@ -2476,7 +2471,7 @@ void OGSI::deleteRows (const int num, co | |
1174 | /* | |
1175 | Tell glpk to delete the rows. | |
1176 | */ | |
1177 | - lpx_del_rows(lp_,num,glpkIndices) ; | |
1178 | + glp_del_rows(lp_,num,glpkIndices) ; | |
1179 | ||
1180 | delete [] glpkIndices ; | |
1181 | ||
1182 | @@ -2511,41 +2506,32 @@ void OGSI::loadProblem (const CoinPacked | |
1183 | ||
1184 | In any event, get rid of cached data in the OsiGlpk object. | |
1185 | */ | |
1186 | - if (lpx_get_num_cols(lp_) != 0 || lpx_get_num_rows(lp_) != 0) | |
1187 | + if (glp_get_num_cols(lp_) != 0 || glp_get_num_rows(lp_) != 0) | |
1188 | { | |
1189 | - int presolVal = lpx_get_int_parm(lp_,LPX_K_PRESOL) ; | |
1190 | - int usedualVal = lpx_get_int_parm(lp_,LPX_K_DUAL) ; | |
1191 | - int scaleVal = lpx_get_int_parm(lp_,LPX_K_SCALE) ; | |
1192 | - int logVal = lpx_get_int_parm(lp_,LPX_K_MSGLEV) ; | |
1193 | # if OGSI_TRACK_FRESH > 0 | |
1194 | std::cout | |
1195 | << " emptying LPX(" << std::hex << lp_ << std::dec << "), " | |
1196 | # endif | |
1197 | - lpx_delete_prob(lp_) ; | |
1198 | - lp_ = lpx_create_prob() ; | |
1199 | + glp_delete_prob(lp_) ; | |
1200 | + lp_ = glp_create_prob() ; | |
1201 | assert(lp_) ; | |
1202 | # if OGSI_TRACK_FRESH > 0 | |
1203 | std::cout | |
1204 | << "loading LPX(" << std::hex << lp_ << std::dec << ")." | |
1205 | << std::endl ; | |
1206 | # endif | |
1207 | - lpx_set_class(lp_,LPX_MIP) ; | |
1208 | - lpx_set_int_parm(lp_,LPX_K_ITLIM,maxIteration_) ; | |
1209 | + | |
1210 | + simplexParams_.it_lim = maxIteration_ ; | |
1211 | if (getObjSense() == 1) // minimization | |
1212 | - { lpx_set_real_parm(lp_,LPX_K_OBJUL,dualObjectiveLimit_) ; | |
1213 | - lpx_set_real_parm(lp_,LPX_K_OBJLL,primalObjectiveLimit_) ; } | |
1214 | + { simplexParams_.obj_ul = dualObjectiveLimit_ ; | |
1215 | + simplexParams_.obj_ll = primalObjectiveLimit_ ; } | |
1216 | else // maximization | |
1217 | - { lpx_set_real_parm(lp_,LPX_K_OBJLL,dualObjectiveLimit_) ; | |
1218 | - lpx_set_real_parm(lp_,LPX_K_OBJUL,primalObjectiveLimit_) ; } | |
1219 | - lpx_set_real_parm(lp_,LPX_K_TOLDJ,dualTolerance_) ; | |
1220 | - lpx_set_real_parm(lp_,LPX_K_TOLBND,primalTolerance_) ; | |
1221 | - lpx_set_obj_coef(lp_,0,objOffset_) ; | |
1222 | - lpx_set_prob_name(lp_,const_cast<char *>(probName_.c_str())) ; | |
1223 | - lpx_set_int_parm(lp_,LPX_K_PRESOL,presolVal) ; | |
1224 | - lpx_set_int_parm(lp_,LPX_K_DUAL,usedualVal) ; | |
1225 | - lpx_set_int_parm(lp_,LPX_K_SCALE,scaleVal) ; | |
1226 | - lpx_set_int_parm(lp_,LPX_K_MSGLEV,logVal) ; | |
1227 | - messageHandler()->setLogLevel(logVal) ; } | |
1228 | + { simplexParams_.obj_ll = dualObjectiveLimit_ ; | |
1229 | + simplexParams_.obj_ul = primalObjectiveLimit_ ; } | |
1230 | + simplexParams_.tol_dj = dualTolerance_ ; | |
1231 | + simplexParams_.tol_bnd = primalTolerance_ ; | |
1232 | + glp_set_obj_coef(lp_,0,objOffset_) ; | |
1233 | + glp_set_prob_name(lp_,const_cast<char *>(probName_.c_str())) ; } | |
1234 | ||
1235 | freeCachedData(OGSI::KEEPCACHED_NONE) ; | |
1236 | ||
1237 | @@ -2617,7 +2603,7 @@ void OGSI::loadProblem (const CoinPacked | |
1238 | addCol(reqdBySunCC,collb[j],colub[j],obj[j]) ; } | |
1239 | // Make sure there are enough rows | |
1240 | if (m > getNumRows()) | |
1241 | - { lpx_add_rows(lp_,m-getNumRows()) ; } | |
1242 | + { glp_add_rows(lp_,m-getNumRows()) ; } | |
1243 | for (i = 0 ; i < m ; i++) | |
1244 | { setRowBounds(i,rowlb[i],rowub[i]) ; } } | |
1245 | else | |
1246 | @@ -2626,7 +2612,7 @@ void OGSI::loadProblem (const CoinPacked | |
1247 | addRow(reqdBySunCC,rowlb[i],rowub[i]) ; } | |
1248 | // Make sure there are enough columns | |
1249 | if (n > getNumCols()) | |
1250 | - { lpx_add_cols(lp_,n-getNumCols()) ; } | |
1251 | + { glp_add_cols(lp_,n-getNumCols()) ; } | |
1252 | for (j = 0 ; j < n ; j++) | |
1253 | { setColBounds(j,collb[j],colub[j]) ; | |
1254 | setObjCoeff(j,obj[j]) ; } } | |
1255 | @@ -2731,11 +2717,11 @@ OGSI::loadProblem(const int numcols, con | |
1256 | LPX *model = getMutableModelPtr(); | |
1257 | double inf = getInfinity(); | |
1258 | ||
1259 | - // Can't send 0 to lpx_add_xxx | |
1260 | + // Can't send 0 to glp_add_xxx | |
1261 | if (numcols > 0) | |
1262 | - lpx_add_cols( model, numcols ); | |
1263 | + glp_add_cols( model, numcols ); | |
1264 | if (numrows > 0) | |
1265 | - lpx_add_rows( model, numrows ); | |
1266 | + glp_add_rows( model, numrows ); | |
1267 | ||
1268 | // How many elements? Column-major, so indices of start are columns | |
1269 | int numelem = start[ numcols ]; | |
1270 | @@ -2756,7 +2742,7 @@ OGSI::loadProblem(const int numcols, con | |
1271 | { | |
1272 | setColBounds( i, collb ? collb[i]:0.0, | |
1273 | colub ? colub[i]:inf ); | |
1274 | - lpx_set_mat_col( model, i+1, start[i+1]-start[i], &(index_adj[start[i]]), &(value_adj[start[i]]) ); | |
1275 | + glp_set_mat_col( model, i+1, start[i+1]-start[i], &(index_adj[start[i]]), &(value_adj[start[i]]) ); | |
1276 | setObjCoeff( i, obj ? obj[i]:0.0 ); | |
1277 | } | |
1278 | int j; | |
1279 | @@ -2823,7 +2809,7 @@ void OGSI::writeMps( const char * filena | |
1280 | std::string f( filename ); | |
1281 | std::string e( extension ); | |
1282 | std::string fullname = f + "." + e; | |
1283 | - lpx_write_mps( getMutableModelPtr(), const_cast<char*>( fullname.c_str() )); | |
1284 | + glp_write_mps( getMutableModelPtr(), GLP_MPS_FILE, NULL, const_cast<char*>( fullname.c_str() )); | |
1285 | #else | |
1286 | // Fall back on native MPS writer. | |
1287 | // These few lines of code haven't been tested. 2004/10/15 | |
1288 | @@ -2996,17 +2982,17 @@ void OGSI::applyColCut( const OsiColCut | |
1289 | // update cached version as well | |
1290 | collower_[column] = lower; | |
1291 | if( lower == upper ) | |
1292 | - type = LPX_FX; | |
1293 | + type = GLP_FX; | |
1294 | else if( lower > -inf && upper < inf ) | |
1295 | - type = LPX_DB; | |
1296 | + type = GLP_DB; | |
1297 | else if( lower > -inf ) | |
1298 | - type = LPX_LO; | |
1299 | + type = GLP_LO; | |
1300 | else if( upper < inf) | |
1301 | - type = LPX_UP; | |
1302 | + type = GLP_UP; | |
1303 | else | |
1304 | - type = LPX_FR; | |
1305 | + type = GLP_FR; | |
1306 | ||
1307 | - lpx_set_col_bnds( getMutableModelPtr(), column+1, type, lower, upper ); | |
1308 | + glp_set_col_bnds( getMutableModelPtr(), column+1, type, lower, upper ); | |
1309 | } | |
1310 | } | |
1311 | // lower bounds | |
1312 | @@ -3018,17 +3004,17 @@ void OGSI::applyColCut( const OsiColCut | |
1313 | // update cached version as well | |
1314 | colupper_[column] = upper; | |
1315 | if( lower == upper ) | |
1316 | - type = LPX_FX; | |
1317 | + type = GLP_FX; | |
1318 | else if( lower > -inf && upper < inf ) | |
1319 | - type = LPX_DB; | |
1320 | + type = GLP_DB; | |
1321 | else if( lower > -inf ) | |
1322 | - type = LPX_LO; | |
1323 | + type = GLP_LO; | |
1324 | else if( upper < inf) | |
1325 | - type = LPX_UP; | |
1326 | + type = GLP_UP; | |
1327 | else | |
1328 | - type = LPX_FR; | |
1329 | + type = GLP_FR; | |
1330 | ||
1331 | - lpx_set_col_bnds( getMutableModelPtr(), column+1, type, lower, upper ); | |
1332 | + glp_set_col_bnds( getMutableModelPtr(), column+1, type, lower, upper ); | |
1333 | } | |
1334 | } | |
1335 | #endif | |
1336 | @@ -3095,25 +3081,24 @@ void OGSI::gutsOfCopy (const OsiGlpkSolv | |
1337 | held up on the parent OSI object, so we don't need to worry about copying | |
1338 | them. | |
1339 | */ | |
1340 | - intParam = lpx_get_int_parm(srclpx,LPX_K_PRESOL) ; | |
1341 | - lpx_set_int_parm(lpx,LPX_K_PRESOL,intParam) ; | |
1342 | - intParam = lpx_get_int_parm(srclpx,LPX_K_DUAL) ; | |
1343 | - lpx_set_int_parm(lpx,LPX_K_DUAL,intParam) ; | |
1344 | - intParam = lpx_get_int_parm(srclpx,LPX_K_SCALE) ; | |
1345 | - lpx_set_int_parm(lpx,LPX_K_SCALE,intParam) ; | |
1346 | + intoptParams_.presolve = source.intoptParams_.presolve; | |
1347 | + simplexParams_.presolve = source.simplexParams_.presolve; | |
1348 | + simplexParams_.meth = source.simplexParams_.meth; | |
1349 | + scaleFlags_ = source.scaleFlags_; | |
1350 | /* | |
1351 | Printing is a bit more complicated. Pull the parameter and set the log | |
1352 | level in the message handler and set the print parameter in glpk. | |
1353 | */ | |
1354 | - intParam = lpx_get_int_parm(srclpx,LPX_K_MSGLEV) ; | |
1355 | - lpx_set_int_parm(lpx,LPX_K_MSGLEV,intParam) ; | |
1356 | - messageHandler()->setLogLevel(intParam) ; | |
1357 | - | |
1358 | -# ifdef LPX_K_USECUTS | |
1359 | - intParam=lpx_get_int_parm(lp_,LPX_K_USECUTS); | |
1360 | - lpx_set_int_parm(lp_,LPX_K_USECUTS,intParam); | |
1361 | -# endif | |
1362 | + simplexParams_.msg_lev = source.simplexParams_.msg_lev; | |
1363 | + intoptParams_.msg_lev = source.intoptParams_.msg_lev; | |
1364 | + messageHandler()->setLogLevel(simplexParams_.msg_lev) ; | |
1365 | + | |
1366 | + intoptParams_.mir_cuts = source.intoptParams_.mir_cuts; | |
1367 | + intoptParams_.gmi_cuts = source.intoptParams_.gmi_cuts; | |
1368 | + intoptParams_.cov_cuts = source.intoptParams_.cov_cuts; | |
1369 | + intoptParams_.clq_cuts = source.intoptParams_.clq_cuts; | |
1370 | ||
1371 | + glp_scale_prob(lp_, scaleFlags_); | |
1372 | /* | |
1373 | Now --- do we have a problem loaded? If not, we're done. | |
1374 | */ | |
1375 | @@ -3164,22 +3149,22 @@ void OGSI::gutsOfCopy (const OsiGlpkSolv | |
1376 | nonsense, then don't bother. Once we've copied the status into the new lpx | |
1377 | object, do the warm-up. | |
1378 | */ | |
1379 | - if (lpx_get_status(srclpx) != LPX_UNDEF) | |
1380 | + if (glp_get_status(srclpx) != GLP_UNDEF) | |
1381 | { for (j = 1 ; j <= n ; j++) | |
1382 | - { int statj = lpx_get_col_stat(srclpx,j) ; | |
1383 | - lpx_set_col_stat(lpx,j,statj) ; } | |
1384 | + { int statj = glp_get_col_stat(srclpx,j) ; | |
1385 | + glp_set_col_stat(lpx,j,statj) ; } | |
1386 | for (i = 1 ; i <= m ; i++) | |
1387 | - { int stati = lpx_get_row_stat(srclpx,i) ; | |
1388 | - lpx_set_row_stat(lpx,i,stati) ; } | |
1389 | + { int stati = glp_get_row_stat(srclpx,i) ; | |
1390 | + glp_set_row_stat(lpx,i,stati) ; } | |
1391 | ||
1392 | #ifndef NDEBUG | |
1393 | - int retval = lpx_warm_up(lpx) ; | |
1394 | + int retval = glp_warm_up(lpx) ; | |
1395 | #endif | |
1396 | # if OGSI_TRACK_SOLVERS > 1 | |
1397 | std::cout | |
1398 | - << " lpx_warm_up returns " << retval << "." << std::endl ; | |
1399 | + << " glp_warm_up returns " << retval << "." << std::endl ; | |
1400 | # endif | |
1401 | - assert(retval == LPX_E_OK) ; } | |
1402 | + assert(retval == 0) ; } | |
1403 | ||
1404 | return ; } | |
1405 | ||
1406 | @@ -3232,26 +3217,28 @@ void OGSI::gutsOfConstructor() | |
1407 | isObjUpperLimitReached_ = false ; | |
1408 | isFeasible_ = false; | |
1409 | ||
1410 | - lp_ = lpx_create_prob(); | |
1411 | + lp_ = glp_create_prob(); | |
1412 | assert( lp_ != NULL ); | |
1413 | - // Make all problems MIPs. See note at top of file. | |
1414 | - lpx_set_class( lp_, LPX_MIP ); | |
1415 | ||
1416 | + glp_init_smcp(&simplexParams_); | |
1417 | + glp_init_iocp(&intoptParams_); | |
1418 | + scaleFlags_ = GLP_SF_EQ; | |
1419 | + glp_scale_prob(lp_, scaleFlags_); | |
1420 | // Push OSI parameters down into LPX object. | |
1421 | - lpx_set_int_parm(lp_,LPX_K_ITLIM,maxIteration_) ; | |
1422 | + simplexParams_.it_lim = maxIteration_; | |
1423 | ||
1424 | if (getObjSense() == 1.0) // minimization | |
1425 | - { lpx_set_real_parm(lp_,LPX_K_OBJUL,dualObjectiveLimit_) ; | |
1426 | - lpx_set_real_parm(lp_,LPX_K_OBJLL,primalObjectiveLimit_) ; } | |
1427 | + { simplexParams_.obj_ul = dualObjectiveLimit_ ; | |
1428 | + simplexParams_.obj_ll = primalObjectiveLimit_ ; } | |
1429 | else // maximization | |
1430 | - { lpx_set_real_parm(lp_,LPX_K_OBJLL,dualObjectiveLimit_) ; | |
1431 | - lpx_set_real_parm(lp_,LPX_K_OBJUL,-primalObjectiveLimit_) ; } | |
1432 | - lpx_set_real_parm(lp_,LPX_K_TOLDJ,dualTolerance_) ; | |
1433 | - lpx_set_real_parm(lp_,LPX_K_TOLBND,primalTolerance_) ; | |
1434 | + { simplexParams_.obj_ll = dualObjectiveLimit_ ; | |
1435 | + simplexParams_.obj_ul = -primalObjectiveLimit_ ; } | |
1436 | + simplexParams_.tol_dj = dualTolerance_; | |
1437 | + simplexParams_.tol_bnd = primalTolerance_; | |
1438 | ||
1439 | - lpx_set_obj_coef(lp_,0,objOffset_) ; | |
1440 | + glp_set_obj_coef(lp_,0,objOffset_) ; | |
1441 | ||
1442 | - lpx_set_prob_name(lp_,const_cast<char *>(probName_.c_str())) ; | |
1443 | + glp_set_prob_name(lp_,const_cast<char *>(probName_.c_str())) ; | |
1444 | ||
1445 | /* Stefan: with the new simplex algorithm in Glpk 4.31, some netlib instances (e.g., dfl001) | |
1446 | take very long or get into a cycle. | |
1447 | @@ -3264,22 +3251,16 @@ void OGSI::gutsOfConstructor() | |
1448 | Printing is a bit more complicated. Set the log level in the handler and set | |
1449 | the print parameter in glpk. | |
1450 | */ | |
1451 | - lpx_set_int_parm(lp_,LPX_K_MSGLEV,1) ; | |
1452 | - messageHandler()->setLogLevel(1) ; | |
1453 | + simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_ERR ; | |
1454 | + messageHandler()->setLogLevel(GLP_MSG_ERR) ; | |
1455 | ||
1456 | /* | |
1457 | - Enable cuts if they're available. This is a bit of a pain, | |
1458 | - as the interface has changed since it was first introduced in 4.9. | |
1459 | - LPX_K_USECUTS appears in 4.9; the parameter value | |
1460 | - appears to be unused in this version. LPX_C_ALL appears in 4.10. | |
1461 | -*/ | |
1462 | -# ifdef LPX_K_USECUTS | |
1463 | -# ifdef LPX_C_ALL | |
1464 | - lpx_set_int_parm(lp_,LPX_K_USECUTS,LPX_C_ALL) ; | |
1465 | -# else | |
1466 | - lpx_set_int_parm(lp_,LPX_K_USECUTS,0) ; | |
1467 | -# endif | |
1468 | -# endif | |
1469 | + Enable cuts if they're available. | |
1470 | +*/ | |
1471 | + intoptParams_.mir_cuts = GLP_ON; | |
1472 | + intoptParams_.gmi_cuts = GLP_ON; | |
1473 | + intoptParams_.cov_cuts = GLP_ON; | |
1474 | + intoptParams_.clq_cuts = GLP_ON; | |
1475 | } | |
1476 | ||
1477 | //----------------------------------------------------------------------------- | |
1478 | @@ -3288,7 +3269,7 @@ void OGSI::gutsOfDestructor() | |
1479 | { | |
1480 | if( lp_ != NULL ) | |
1481 | { | |
1482 | - lpx_delete_prob( lp_ ); | |
1483 | + glp_delete_prob( lp_ ); | |
1484 | lp_=NULL; | |
1485 | freeAllMemory(); | |
1486 | } | |
1487 | @@ -3408,7 +3389,7 @@ void OGSI::freeAllMemory() | |
1488 | void OGSI::setObjName (std::string name) | |
1489 | ||
1490 | { OsiSolverInterface::setObjName(name) ; | |
1491 | - lpx_set_obj_name(lp_,const_cast<char *>(name.c_str())) ; } | |
1492 | + glp_set_obj_name(lp_,const_cast<char *>(name.c_str())) ; } | |
1493 | ||
1494 | /*! | |
1495 | Set a row name. Make sure both glpk and OSI see the same name. | |
1496 | @@ -3431,7 +3412,7 @@ void OGSI::setRowName (int ndx, std::str | |
1497 | Set the name in the OSI base, then in the consys structure. | |
1498 | */ | |
1499 | OsiSolverInterface::setRowName(ndx,name) ; | |
1500 | - lpx_set_row_name(lp_,ndx+1,const_cast<char *>(name.c_str())) ; | |
1501 | + glp_set_row_name(lp_,ndx+1,const_cast<char *>(name.c_str())) ; | |
1502 | ||
1503 | return ; } | |
1504 | ||
1505 | @@ -3456,7 +3437,7 @@ void OGSI::setColName (int ndx, std::str | |
1506 | Set the name in the OSI base, then in the consys structure. | |
1507 | */ | |
1508 | OsiSolverInterface::setColName(ndx,name) ; | |
1509 | - lpx_set_col_name(lp_,ndx+1,const_cast<char *>(name.c_str())) ; | |
1510 | + glp_set_col_name(lp_,ndx+1,const_cast<char *>(name.c_str())) ; | |
1511 | ||
1512 | return ; } | |
1513 | ||
1514 | --- Osi-0.106.10/Osi/src/OsiGlpk/OsiGlpkSolverInterface.hpp.orig 2013-04-06 14:50:19.000000000 +0200 | |
1515 | +++ Osi-0.106.10/Osi/src/OsiGlpk/OsiGlpkSolverInterface.hpp 2014-12-03 20:33:20.066812529 +0100 | |
1516 | @@ -768,6 +768,9 @@ private: | |
1517 | //@{ | |
1518 | /// GPLK model represented by this class instance | |
1519 | mutable LPX* lp_; | |
1520 | + glp_iocp intoptParams_; | |
1521 | + glp_smcp simplexParams_; | |
1522 | + int scaleFlags_; | |
1523 | ||
1524 | /// number of GLPK instances currently in use (counts only those created by OsiGlpk) | |
1525 | static unsigned int numInstances_; |