COIN-OR::LEMON - Graph Library

source: lemon-0.x/lemon/lp_glpk.cc @ 2441:d8d6ab871608

Last change on this file since 2441:d8d6ab871608 was 2441:d8d6ab871608, checked in by Balazs Dezso, 17 years ago

Conformity to new GLPK interface
Hacking Mip without integer variables

File size: 14.8 KB
RevLine 
[1261]1/* -*- C++ -*-
2 *
[1956]3 * This file is a part of LEMON, a generic C++ optimization library
4 *
[2391]5 * Copyright (C) 2003-2007
[1956]6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
[1359]7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
[1261]8 *
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
12 *
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
15 * purpose.
16 *
17 */
18
19///\file
20///\brief Implementation of the LEMON-GLPK lp solver interface.
21
[1305]22#include <lemon/lp_glpk.h>
[1473]23//#include <iostream>
[2441]24
25#if GLP_MAJOR_VERSION > 4 || (GLP_MAJOR_VERSION == 4 && GLP_MINOR_VERSION > 15)
26#define LEMON_glp(func) (glp_##func)
27#define LEMON_lpx(func) (lpx_##func)
28
29#define LEMON_GLP(def) (GLP_##def)
30#define LEMON_LPX(def) (LPX_##def)
31
32#else
33
34#define LEMON_glp(func) (lpx_##func)
35#define LEMON_lpx(func) (lpx_##func)
36
37#define LEMON_GLP(def) (LPX_##def)
38#define LEMON_LPX(def) (LPX_##def)
39
40#endif
41
[1261]42namespace lemon {
43
[2363]44  LpGlpk::LpGlpk() : Parent() {
[2441]45    solved = false;
[2363]46    rows = _lp_bits::LpId(1);
47    cols = _lp_bits::LpId(1);
[2441]48    lp = LEMON_glp(create_prob)();
49    LEMON_glp(create_index)(lp);
50    LEMON_lpx(set_int_parm)(lp, LEMON_LPX(K_DUAL), 1);
[1321]51    messageLevel(0);
52  }
53 
[2363]54  LpGlpk::LpGlpk(const LpGlpk &glp) : Parent() {
[2441]55    solved = false;
[2363]56    rows = _lp_bits::LpId(1);
57    cols = _lp_bits::LpId(1);
[2441]58    lp = LEMON_glp(create_prob)();
59    LEMON_glp(create_index)(lp);
[2363]60    ///\todo control function for this:
[2441]61    LEMON_lpx(set_int_parm)(lp, LEMON_LPX(K_DUAL), 1);
[2321]62    messageLevel(0);
63    //Coefficient matrix, row bounds
[2441]64    LEMON_glp(add_rows)(lp, LEMON_glp(get_num_rows)(glp.lp));
65    LEMON_glp(add_cols)(lp, LEMON_glp(get_num_cols)(glp.lp));
[2321]66    int len;
[2441]67    int ind[1+LEMON_glp(get_num_cols)(glp.lp)];
68    Value val[1+LEMON_glp(get_num_cols)(glp.lp)];
69    for (int i=1;i<=LEMON_glp(get_num_rows)(glp.lp);++i)
[2321]70      {
[2441]71        len=LEMON_glp(get_mat_row)(glp.lp,i,ind,val);
72        LEMON_glp(set_mat_row)(lp, i,len,ind,val);
73        LEMON_glp(set_row_bnds)(lp,i,
74                                LEMON_glp(get_row_type)(glp.lp,i),
75                                LEMON_glp(get_row_lb)(glp.lp,i),
76                                LEMON_glp(get_row_ub)(glp.lp,i));
[2321]77      }
78
79    //Objective function, coloumn bounds
[2441]80    LEMON_glp(set_obj_dir)(lp, LEMON_glp(get_obj_dir)(glp.lp));
[2321]81    //Objectif function's constant term treated separately
[2441]82    LEMON_glp(set_obj_coef)(lp,0,LEMON_glp(get_obj_coef)(glp.lp,0));
83    for (int i=1;i<=LEMON_glp(get_num_cols)(glp.lp);++i)
[2321]84      {
[2441]85        LEMON_glp(set_obj_coef)(lp,i,
86                                LEMON_glp(get_obj_coef)(glp.lp,i));
87        LEMON_glp(set_col_bnds)(lp,i,
88                                LEMON_glp(get_col_type)(glp.lp,i),
89                                LEMON_glp(get_col_lb)(glp.lp,i),
90                                LEMON_glp(get_col_ub)(glp.lp,i));
[2321]91      }
92  }
93 
[1321]94  LpGlpk::~LpGlpk() {
[2441]95    LEMON_glp(delete_prob)(lp);
[1321]96  }
97 
98  int LpGlpk::_addCol() {
[2441]99    int i=LEMON_glp(add_cols)(lp, 1);
100    LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FR), 0.0, 0.0);
101    solved = false;
[1321]102    return i;
103  }
104
[1436]105  ///\e
106
107
108  LpSolverBase &LpGlpk::_newLp()
109  {
[2321]110    LpGlpk* newlp=new LpGlpk;
[1436]111    return *newlp;
112  }
113 
114  ///\e
115
116  LpSolverBase &LpGlpk::_copyLp()
117  {
[2321]118    LpGlpk* newlp=new LpGlpk(*this);
[1436]119    return *newlp;
120  }
121
[1321]122  int LpGlpk::_addRow() {
[2441]123    int i=LEMON_glp(add_rows)(lp, 1);
124    solved = false;
[1321]125    return i;
126  }
127
128 
[1432]129  void LpGlpk::_eraseCol(int i) {
[2386]130    int ca[2];
131    ca[1]=i;
[2441]132    LEMON_glp(del_cols)(lp, 1, ca);
133    solved = false;
[1432]134  }
135 
136  void LpGlpk::_eraseRow(int i) {
[2386]137    int ra[2];
138    ra[1]=i;
[2441]139    LEMON_glp(del_rows)(lp, 1, ra);
140    solved = false;
[1432]141  }
142
[2386]143  void LpGlpk::_getColName(int c, std::string & name) const
[1895]144  {
145   
[2441]146    const char *n = LEMON_glp(get_col_name)(lp,c);
[1895]147    name = n?n:"";
148  }
149 
150 
[2386]151  void LpGlpk::_setColName(int c, const std::string & name)
[1895]152  {
[2441]153    LEMON_glp(set_col_name)(lp,c,const_cast<char*>(name.c_str()));
[2349]154
[1895]155  }
[2366]156
157  int LpGlpk::_colByName(const std::string& name) const
158  {
[2441]159    int k = LEMON_glp(find_col)(lp, const_cast<char*>(name.c_str()));
[2366]160    return k > 0 ? k : -1;
161  }
162
[1895]163 
[2364]164  void LpGlpk::_setRowCoeffs(int i, ConstRowIterator b, ConstRowIterator e)
[1321]165  {
[2312]166    std::vector<int> indices;
167    std::vector<Value> values;
168
169    indices.push_back(0);
170    values.push_back(0);
171
[2364]172    for(ConstRowIterator it=b; it!=e; ++it) {
[2312]173      indices.push_back(it->first);
174      values.push_back(it->second);
175    }
176
[2441]177    LEMON_glp(set_mat_row)(lp, i, values.size() - 1,
178                                &indices[0], &values[0]);
179
180    solved = false;
[1321]181  }
[2364]182
[2386]183  void LpGlpk::_getRowCoeffs(int ix, RowIterator b) const
[2364]184  {
[2441]185    int length = LEMON_glp(get_mat_row)(lp, ix, 0, 0);
[2364]186   
187    std::vector<int> indices(length + 1);
188    std::vector<Value> values(length + 1);
189   
[2441]190    LEMON_glp(get_mat_row)(lp, ix, &indices[0], &values[0]);
[2364]191   
192    for (int i = 1; i <= length; ++i) {
193      *b = std::make_pair(indices[i], values[i]);
194      ++b;
195    }
196  }
[1321]197 
[2386]198  void LpGlpk::_setColCoeffs(int ix, ConstColIterator b, ConstColIterator e) {
[2312]199
200    std::vector<int> indices;
201    std::vector<Value> values;
202
203    indices.push_back(0);
204    values.push_back(0);
205
[2364]206    for(ConstColIterator it=b; it!=e; ++it) {
[2312]207      indices.push_back(it->first);
208      values.push_back(it->second);
209    }
210   
[2441]211    LEMON_glp(set_mat_col)(lp, ix, values.size() - 1,
212                                &indices[0], &values[0]);
213
214    solved = false;
[1321]215  }
[1431]216
[2386]217  void LpGlpk::_getColCoeffs(int ix, ColIterator b) const
[2364]218  {
[2441]219    int length = LEMON_glp(get_mat_col)(lp, ix, 0, 0);
[2364]220   
221    std::vector<int> indices(length + 1);
222    std::vector<Value> values(length + 1);
223   
[2441]224    LEMON_glp(get_mat_col)(lp, ix, &indices[0], &values[0]);
[2364]225   
226    for (int i = 1; i <= length; ++i) {
227      *b = std::make_pair(indices[i], values[i]);
228      ++b;
229    }
230  }
[1431]231
[2386]232  void LpGlpk::_setCoeff(int ix, int jx, Value value)
[1431]233  {
[2312]234
[2441]235    if (LEMON_glp(get_num_cols)(lp) < LEMON_glp(get_num_rows)(lp)) {
[2312]236
[2441]237      int length=LEMON_glp(get_mat_row)(lp, ix, 0, 0);
[2312]238     
239      std::vector<int> indices(length + 2);
240      std::vector<Value> values(length + 2);
241     
[2441]242      LEMON_glp(get_mat_row)(lp, ix, &indices[0], &values[0]);
[2312]243     
244      //The following code does not suppose that the elements of the
245      //array indices are sorted
246      bool found=false;
247      for (int i = 1; i <= length; ++i) {
[2386]248        if (indices[i]==jx){
[2312]249          found=true;
250          values[i]=value;
251          break;
252        }
253      }
254      if (!found){
255        ++length;
[2386]256        indices[length]=jx;
[2312]257        values[length]=value;
258      }
[1431]259   
[2441]260      LEMON_glp(set_mat_row)(lp, ix, length, &indices[0], &values[0]);
[2312]261
262    } else {
263
[2441]264      int length=LEMON_glp(get_mat_col)(lp, jx, 0, 0);
[2312]265     
266      std::vector<int> indices(length + 2);
267      std::vector<Value> values(length + 2);
268     
[2441]269      LEMON_glp(get_mat_col)(lp, jx, &indices[0], &values[0]);
[2312]270     
271      //The following code does not suppose that the elements of the
272      //array indices are sorted
273      bool found=false;
274      for (int i = 1; i <= length; ++i) {
[2386]275        if (indices[i]==jx){
[2312]276          found=true;
277          values[i]=value;
278          break;
279        }
280      }
281      if (!found){
282        ++length;
[2386]283        indices[length]=ix;
[2312]284        values[length]=value;
285      }
[1431]286   
[2441]287      LEMON_glp(set_mat_col)(lp, jx, length, &indices[0], &values[0]);
[1431]288    }
[2441]289
290    solved = false;
[1431]291  }
292
[2386]293  LpGlpk::Value LpGlpk::_getCoeff(int ix, int jx) const
[2324]294  {
[2328]295
[2441]296    int length=LEMON_glp(get_mat_row)(lp, ix, 0, 0);
[2328]297   
[2364]298    std::vector<int> indices(length + 1);
299    std::vector<Value> values(length + 1);
[2328]300   
[2441]301    LEMON_glp(get_mat_row)(lp, ix, &indices[0], &values[0]);
[2328]302   
303    //The following code does not suppose that the elements of the
304    //array indices are sorted
305    for (int i = 1; i <= length; ++i) {
[2386]306      if (indices[i]==jx){
[2328]307        return values[i];
308      }
309    }
[2324]310    return 0;
[2328]311
[2324]312  }
313
314
[1321]315  void LpGlpk::_setColLowerBound(int i, Value lo)
316  {
317    if (lo==INF) {
318      //FIXME error
319    }
[2441]320    int b=LEMON_glp(get_col_type)(lp, i);
321    double up=LEMON_glp(get_col_ub)(lp, i);     
[1321]322    if (lo==-INF) {
323      switch (b) {
[2441]324      case LEMON_GLP(FR):
325      case LEMON_GLP(LO):
326        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FR), lo, up);
[1321]327        break;
[2441]328      case LEMON_GLP(UP):
[1321]329        break;
[2441]330      case LEMON_GLP(DB):
331      case LEMON_GLP(FX):
332        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(UP), lo, up);
[1321]333        break;
334      default: ;
335        //FIXME error
336      }
337    } else {
338      switch (b) {
[2441]339      case LEMON_GLP(FR):
340      case LEMON_GLP(LO):
341        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(LO), lo, up);
[1321]342        break;
[2441]343      case LEMON_GLP(UP):         
344      case LEMON_GLP(DB):
345      case LEMON_GLP(FX):
[1321]346        if (lo==up)
[2441]347          LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FX), lo, up);
[1321]348        else
[2441]349          LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(DB), lo, up);
[1321]350        break;
351      default: ;
352        //FIXME error
353      }
[1261]354    }
355
[2441]356    solved = false;
[1321]357  }
[2328]358
[2366]359  LpGlpk::Value LpGlpk::_getColLowerBound(int i) const
[2328]360  {
[2441]361    int b=LEMON_glp(get_col_type)(lp, i);
[2328]362      switch (b) {
[2441]363      case LEMON_GLP(LO):
364      case LEMON_GLP(DB):
365      case LEMON_GLP(FX):
366        return LEMON_glp(get_col_lb)(lp, i);   
[2328]367      default: ;
368        return -INF;
369      }
370  }
[1321]371 
372  void LpGlpk::_setColUpperBound(int i, Value up)
373  {
374    if (up==-INF) {
375      //FIXME error
[1261]376    }
[2441]377    int b=LEMON_glp(get_col_type)(lp, i);
378    double lo=LEMON_glp(get_col_lb)(lp, i);
[1321]379    if (up==INF) {
380      switch (b) {
[2441]381      case LEMON_GLP(FR):
382      case LEMON_GLP(LO):
[1321]383        break;
[2441]384      case LEMON_GLP(UP):
385        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FR), lo, up);
[1321]386        break;
[2441]387      case LEMON_GLP(DB):
388      case LEMON_GLP(FX):
389        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(LO), lo, up);
[1321]390        break;
391      default: ;
[1261]392        //FIXME error
393      }
[1321]394    } else {
395      switch (b) {
[2441]396      case LEMON_GLP(FR):
397        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(UP), lo, up);
[1321]398        break;
[2441]399      case LEMON_GLP(UP):
400        LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(UP), lo, up);
[1321]401        break;
[2441]402      case LEMON_GLP(LO):
403      case LEMON_GLP(DB):
404      case LEMON_GLP(FX):
[1321]405        if (lo==up)
[2441]406          LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(FX), lo, up);
[1321]407        else
[2441]408          LEMON_glp(set_col_bnds)(lp, i, LEMON_GLP(DB), lo, up);
[1321]409        break;
410      default: ;
[1261]411        //FIXME error
412      }
[1321]413    }
[2441]414
415    solved = false;
[1321]416  }
[2328]417
[2366]418  LpGlpk::Value LpGlpk::_getColUpperBound(int i) const
[2328]419  {
[2441]420    int b=LEMON_glp(get_col_type)(lp, i);
[2328]421      switch (b) {
[2441]422      case LEMON_GLP(UP):
423      case LEMON_GLP(DB):
424      case LEMON_GLP(FX):
425        return LEMON_glp(get_col_ub)(lp, i);   
[2328]426      default: ;
427        return INF;
428      }
429  }
[1321]430 
[1379]431  void LpGlpk::_setRowBounds(int i, Value lb, Value ub)
432  {
433    //Bad parameter
434    if (lb==INF || ub==-INF) {
435      //FIXME error
436    }
437
438    if (lb == -INF){
439      if (ub == INF){
[2441]440        LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(FR), lb, ub);
[1379]441      }
442      else{
[2441]443        LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(UP), lb, ub);
[1379]444      }
445    }
446    else{
447      if (ub==INF){
[2441]448        LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(LO), lb, ub);
[1379]449
450      }
451      else{
452        if (lb == ub){
[2441]453          LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(FX), lb, ub);
[1379]454        }
455        else{
[2441]456          LEMON_glp(set_row_bnds)(lp, i, LEMON_GLP(DB), lb, ub);
[1379]457        }
458      }
459    }
460
[2441]461    solved = false;
[1379]462  }
[2328]463
[2366]464  void LpGlpk::_getRowBounds(int i, Value &lb, Value &ub) const
[2328]465  {
466
[2441]467    int b=LEMON_glp(get_row_type)(lp, i);
[2328]468    switch (b) {
[2441]469    case LEMON_GLP(FR):
470    case LEMON_GLP(UP):
[2328]471      lb = -INF;
472        break;
473    default:
[2441]474      lb=LEMON_glp(get_row_lb)(lp, i);
[2328]475    }
476
477    switch (b) {
[2441]478    case LEMON_GLP(FR):
479    case LEMON_GLP(LO):
[2328]480      ub = INF;
481        break;
482    default:
[2441]483      ub=LEMON_glp(get_row_ub)(lp, i);
[2328]484    }
485   
486  }
[1261]487 
[1298]488  void LpGlpk::_setObjCoeff(int i, Value obj_coef)
489  {
[1376]490    //i=0 means the constant term (shift)
[2441]491    LEMON_glp(set_obj_coef)(lp, i, obj_coef);
492
493    solved = false;
[1298]494  }
[1261]495
[2366]496  LpGlpk::Value LpGlpk::_getObjCoeff(int i) const {
[2324]497    //i=0 means the constant term (shift)
[2441]498    return LEMON_glp(get_obj_coef)(lp, i);
[2324]499  }
500
[1377]501  void LpGlpk::_clearObj()
[1376]502  {
[2441]503    for (int i=0;i<=LEMON_glp(get_num_cols)(lp);++i){
504      LEMON_glp(set_obj_coef)(lp, i, 0);
[1376]505    }
[2441]506
507    solved = false;
[1376]508  }
[1263]509
[1303]510  LpGlpk::SolveExitStatus LpGlpk::_solve()
[1263]511  {
[2345]512    // A way to check the problem to be solved
[2441]513    //LEMON_glp(write_cpxlp(lp,"naittvan.cpx");   
[2345]514
[2441]515    LEMON_lpx(std_basis)(lp);
516    int i =  LEMON_lpx(simplex)(lp);
[2363]517   
[1298]518    switch (i) {
[2441]519    case LEMON_LPX(E_OK):
520      solved = true;
[1298]521      return SOLVED;
522    default:
523      return UNSOLVED;
524    }
[1263]525  }
526
[2366]527  LpGlpk::Value LpGlpk::_getPrimal(int i) const
[1263]528  {
[2441]529    return LEMON_glp(get_col_prim)(lp,i);
[1263]530  }
[1787]531
[2366]532  LpGlpk::Value LpGlpk::_getDual(int i) const
[1787]533  {
[2441]534    return LEMON_glp(get_row_dual)(lp,i);
[1787]535  }
[1263]536 
[2366]537  LpGlpk::Value LpGlpk::_getPrimalValue() const
[1312]538  {
[2441]539    return LEMON_glp(get_obj_val)(lp);
[1312]540  }
[2366]541  bool LpGlpk::_isBasicCol(int i) const
542  {
[2441]543    return (LEMON_glp(get_col_stat)(lp, i)==LEMON_GLP(BS));
[1840]544  }
[1312]545 
[1298]546 
[2366]547  LpGlpk::SolutionStatus LpGlpk::_getPrimalStatus() const
[1294]548  {
[2441]549    if (!solved) return UNDEFINED;
550    int stat=  LEMON_lpx(get_status)(lp);
[1298]551    switch (stat) {
[2441]552    case LEMON_LPX(UNDEF)://Undefined (no solve has been run yet)
[1298]553      return UNDEFINED;
[2441]554    case LEMON_LPX(NOFEAS)://There is no feasible solution (primal, I guess)
555    case LEMON_LPX(INFEAS)://Infeasible
[1458]556      return INFEASIBLE;
[2441]557    case LEMON_LPX(UNBND)://Unbounded
[1458]558      return INFINITE;
[2441]559    case LEMON_LPX(FEAS)://Feasible
[1458]560      return FEASIBLE;
[2441]561    case LEMON_LPX(OPT)://Feasible
[1458]562      return OPTIMAL;
563    default:
564      return UNDEFINED; //to avoid gcc warning
565      //FIXME error
566    }
567  }
568
[2366]569  LpGlpk::SolutionStatus LpGlpk::_getDualStatus() const
[1458]570  {
[2441]571    if (!solved) return UNDEFINED;
572    switch (LEMON_lpx(get_dual_stat)(lp)) {
573    case LEMON_LPX(D_UNDEF)://Undefined (no solve has been run yet)
[1458]574      return UNDEFINED;
[2441]575    case LEMON_LPX(D_NOFEAS)://There is no dual feasible solution
576//    case LEMON_LPX(D_INFEAS://Infeasible
[1458]577      return INFEASIBLE;
[2441]578    case LEMON_LPX(D_FEAS)://Feasible   
579      switch (LEMON_lpx(get_status)(lp)) {
580      case LEMON_LPX(NOFEAS):
[1458]581        return INFINITE;
[2441]582      case LEMON_LPX(OPT):
[1458]583        return OPTIMAL;
584      default:
585        return FEASIBLE;
586      }
587    default:
588      return UNDEFINED; //to avoid gcc warning
589      //FIXME error
590    }
591  }
592
[2366]593  LpGlpk::ProblemTypes LpGlpk::_getProblemType() const
[1458]594  {
[2441]595    if (!solved) return UNKNOWN;
596      //int stat=  LEMON_glp(get_status(lp);
597    int statp=  LEMON_lpx(get_prim_stat)(lp);
598    int statd=  LEMON_lpx(get_dual_stat)(lp);
599    if (statp==LEMON_LPX(P_FEAS) && statd==LEMON_LPX(D_FEAS))
[1460]600        return PRIMAL_DUAL_FEASIBLE;
[2441]601    if (statp==LEMON_LPX(P_FEAS) && statd==LEMON_LPX(D_NOFEAS))
[1460]602        return PRIMAL_FEASIBLE_DUAL_INFEASIBLE;
[2441]603    if (statp==LEMON_LPX(P_NOFEAS) && statd==LEMON_LPX(D_FEAS))
[1460]604        return PRIMAL_INFEASIBLE_DUAL_FEASIBLE;
[2441]605    if (statp==LEMON_LPX(P_NOFEAS) && statd==LEMON_LPX(D_NOFEAS))
[1460]606        return PRIMAL_DUAL_INFEASIBLE;
607    //In all other cases
608    return UNKNOWN;
[1294]609  }
[1263]610
[1312]611  void LpGlpk::_setMax()
612  {
[2441]613    solved = false;
614    LEMON_glp(set_obj_dir)(lp, LEMON_GLP(MAX));
[1321]615  }
616
[1312]617  void LpGlpk::_setMin()
618  {
[2441]619    solved = false;
620    LEMON_glp(set_obj_dir)(lp, LEMON_GLP(MIN));
[1321]621  }
622
[2366]623  bool LpGlpk::_isMax() const
[2324]624  {
[2441]625    return (LEMON_glp(get_obj_dir)(lp)==LEMON_GLP(MAX));
[2324]626  }
627
[1321]628 
[2324]629
[1321]630  void LpGlpk::messageLevel(int m)
631  {
[2441]632    LEMON_lpx(set_int_parm)(lp, LEMON_LPX(K_MSGLEV), m);
[1321]633  }
[1312]634
[1326]635  void LpGlpk::presolver(bool b)
636  {
[2441]637    LEMON_lpx(set_int_parm)(lp, LEMON_LPX(K_PRESOL), b);
[1326]638  }
639
[1312]640 
[1261]641} //END OF NAMESPACE LEMON
Note: See TracBrowser for help on using the repository browser.