- ldconfig for solver libraries

[packages/CoinOsi.git] / Osi-glpk.patch

--- Osi-0.106.10/Osi/src/OsiGlpk/OsiGlpkSolverInterface.cpp.orig	2013-04-06 14:50:19.000000000 +0200
+++ Osi-0.106.10/Osi/src/OsiGlpk/OsiGlpkSolverInterface.cpp	2014-12-04 17:58:31.036909826 +0100
@@ -21,7 +21,7 @@
 //    In (much) earlier versions of GLPK, if an LPX_MIP problem was
 // changed back into a LPX_LP problem, then the MIP data was lost,
 // including which columns are integer.  However, LPX_MIP problems
-// still had access to LP information (like lpx_get_status).
+// still had access to LP information (like glp_get_status).
 //
 //    It appears that this behavior is no longer true in version 4.7.
 // Therefore it may be worthwhile to adjust the interface to change
@@ -166,26 +166,26 @@ void OGSI::initialSolve()
 /*
   Solve the lp.
 */
-  int err = lpx_simplex(model) ;
+  int err = glp_simplex(model, &simplexParams_) ;
 
   // for Glpk, a solve fails if the initial basis is invalid or singular
   // thus, we construct a (advanced) basis first and try again
-#ifdef LPX_E_BADB
-  if (err == LPX_E_BADB) {
-    lpx_adv_basis(model);
-    err = lpx_simplex(model) ;
+#ifdef GLP_EBADB
+  if (err == GLP_EBADB) {
+    glp_adv_basis(model, 0);
+    err = glp_simplex(model, &simplexParams_) ;
   } else
 #endif
-  if (err == LPX_E_SING || err == LPX_E_FAULT) {
-    lpx_adv_basis(model);
-    err = lpx_simplex(model) ;
+  if (err == GLP_ESING || err == GLP_EFAIL) {
+    glp_adv_basis(model, 0);
+    err = glp_simplex(model, &simplexParams_) ;
   }
 
-  iter_used_ = lpx_get_int_parm(model, LPX_K_ITCNT) ;
+  iter_used_ = glp_get_it_cnt(model) ;
 /*
   Sort out the various state indications.
 
-  When the presolver is turned on, lpx_simplex() will not be able to tell
+  When the presolver is turned on, glp_simplex() will not be able to tell
   whether the objective function has hit it's upper or lower limit, and does
   not return OBJLL or OBJUL. The code for these cases should be beefed up to
   check the objective against the limit.
@@ -204,39 +204,39 @@ void OGSI::initialSolve()
   isObjUpperLimitReached_ = false ;
 
   switch (err)
-  { case LPX_E_OK:
+  { case 0:
     { break ; }
-    case LPX_E_ITLIM:
+    case GLP_EITLIM:
     { isIterationLimitReached_ = true ;
       break ; }
-    case LPX_E_OBJLL:
+    case GLP_EOBJLL:
     { isObjLowerLimitReached_ = true ;
       break ; }
-    case LPX_E_OBJUL:
+    case GLP_EOBJUL:
     { isObjUpperLimitReached_ = true ;
       break ; }
-    case LPX_E_TMLIM:
+    case GLP_ETMLIM:
     { isTimeLimitReached_ = true ;
     } // no break here, so we still report abandoned
-    case LPX_E_FAULT:
-    case LPX_E_SING:
-#ifdef LPX_E_BADB
-    case LPX_E_BADB:
+    case GLP_EFAIL:
+    case GLP_ESING:
+#ifdef GLP_EBADB
+    case GLP_EBADB:
 #endif
     { isAbandoned_ = true ;
       break ; }
-    case LPX_E_NOPFS:
+    case GLP_ENOPFS:
     { isPrimInfeasible_ = true ;
       break ; }
-    case LPX_E_NODFS:
+    case GLP_ENODFS:
     { isDualInfeasible_ = true ;
       break ; }
     default:
     { assert(false) ; } }
     
-  switch (lpx_get_status(model))
-  { case LPX_OPT:
-  	case LPX_FEAS:
+  switch (glp_get_status(model))
+  { case GLP_OPT:
+  	case GLP_FEAS:
   	{ isFeasible_ = true ;
   		break ; }
   	default:
@@ -261,23 +261,23 @@ void OGSI::resolve()
   LPX *model = getMutableModelPtr() ;
   freeCachedData(OGSI::FREECACHED_RESULTS) ;
 
-  // lpx_simplex will use the current basis if possible
-  int err = lpx_simplex(model) ;
+  // glp_simplex will use the current basis if possible
+  int err = glp_simplex(model, &simplexParams_) ;
 
   // for Glpk, a solve fails if the initial basis is invalid or singular
   // thus, we construct a (advanced) basis first and try again
-#ifdef LPX_E_BADB
-  if (err == LPX_E_BADB) {
-    lpx_adv_basis(model);
-    err = lpx_simplex(model) ;
+#ifdef GLP_EBADB
+  if (err == GLP_EBADB) {
+    glp_adv_basis(model, 0);
+    err = glp_simplex(model, &simplexParams_) ;
   } else
 #endif
-  if (err == LPX_E_SING || err == LPX_E_FAULT) {
-    lpx_adv_basis(model);
-    err = lpx_simplex(model) ;
+  if (err == GLP_ESING || err == GLP_EFAIL) {
+    glp_adv_basis(model, 0);
+    err = glp_simplex(model, &simplexParams_) ;
   }
   
-  iter_used_ = lpx_get_int_parm(model,LPX_K_ITCNT) ;
+  iter_used_ = glp_get_it_cnt(model) ;
 
   isIterationLimitReached_ = false ;
   isTimeLimitReached_ = false ;
@@ -289,39 +289,39 @@ void OGSI::resolve()
   isFeasible_ = false ;
 
   switch (err)
-  { case LPX_E_OK:
+  { case 0:
     { break ; }
-    case LPX_E_ITLIM:
+    case GLP_EITLIM:
     { isIterationLimitReached_ = true ;
       break ; }
-    case LPX_E_OBJLL:
+    case GLP_EOBJLL:
     { isObjLowerLimitReached_ = true ;
       break ; }
-    case LPX_E_OBJUL:
+    case GLP_EOBJUL:
     { isObjUpperLimitReached_ = true ;
       break ; }
-    case LPX_E_TMLIM:
+    case GLP_ETMLIM:
     { isTimeLimitReached_ = true ;
     } // no break here, so we still report abandoned
-    case LPX_E_FAULT:
-    case LPX_E_SING:
-#ifdef LPX_E_BADB
-    case LPX_E_BADB:
+    case GLP_EFAIL:
+    case GLP_ESING:
+#ifdef GLP_EBADB
+    case GLP_EBADB:
 #endif
     { isAbandoned_ = true ;
       break ; }
-    case LPX_E_NOPFS:
+    case GLP_ENOPFS:
     { isPrimInfeasible_ = true ;
       break ; }
-    case LPX_E_NODFS:
+    case GLP_ENODFS:
     { isDualInfeasible_ = true ;
       break ; }
     default:
     { assert(false) ; } }
 
-  switch (lpx_get_status(model))
-  { case LPX_OPT:
-  	case LPX_FEAS:
+  switch (glp_get_status(model))
+  { case GLP_OPT:
+  	case GLP_FEAS:
   	{ isFeasible_ = true ;
   		break ; }
   	default:
@@ -337,7 +337,7 @@ void OGSI::resolve()
 
 /*
   Call glpk's built-in MIP solver. Any halfway recent version (from glpk 4.4,
-  at least) will have lpx_intopt, a branch-and-cut solver. The presence of cut
+  at least) will have glp_intopt, a branch-and-cut solver. The presence of cut
   generators is more recent.
 */
 void OGSI::branchAndBound ()
@@ -351,52 +351,46 @@ void OGSI::branchAndBound ()
   Assuming we have integer variables in the model, call the best MIP solver
   we can manage.
 
-  lpx_intopt does not require an optimal LP solution as a starting point, so
+  glp_intopt does not require an optimal LP solution as a starting point, so
   we can call it directly.
 
   lpx_integer needs an initial optimal solution to the relaxation.
 */
-  if (lpx_get_num_int(model))
-  { int err = LPX_E_FAULT ;
+  if (glp_get_num_int(model))
+  { int err = GLP_EFAIL ;
 
-#   ifdef GLPK_HAS_INTOPT
-    err = lpx_intopt(model) ;
-#   else
-    if (lpx_get_status(model) != LPX_OPT)
-    { initialSolve() ; }
-    err = lpx_integer(model) ;
-#   endif
+    err = glp_intopt(model, &intoptParams_) ;
 /*
   We have a result. What is it? Start with a positive attitude and revise as
-  needed. The various LPX_E_* and LPX_I_* defines are stable back as far as
-  glpk-4.4.
+  needed. The various GLP_E* and GLP_* defines are stable back as far as
+  glpk-4.5x.
 
-  When we get LPX_E_OK (MIP terminated normally), we need to look more
-  closely.  LPX_I_OPT indicates a proven optimal integer solution.
-  LPX_I_NOFEAS indicates that there is no integer feasible solution.
-  LPX_I_UNDEF says the MIP solution is undefined. LPX_I_FEAS says that in
+  When we get 0 (MIP terminated normally), we need to look more
+  closely.  GLP_OPT indicates a proven optimal integer solution.
+  GLP_NOFEAS indicates that there is no integer feasible solution.
+  GLP_UNDEF says the MIP solution is undefined. GLP_FEAS says that in
   integer feasible solution was found but not proven optimal (termination of
   search due to some limit is the common cause). It's not clear what to do
-  with LPX_I_UNDEF; currently, it is not really reflected in
-  termination status. LPX_I_FEAS is reflected by the OsiGlpk specific method
+  with GLP_UNDEF; currently, it is not really reflected in
+  termination status. GLP_FEAS is reflected by the OsiGlpk specific method
   isFeasible().
 
-  Various other codes are returned by lpx_intopt (lpx_integer returns a
-  subset of these).  LPX_E_NOPFS (LPX_E_NODFS) indicate no primal (dual)
+  Various other codes are returned by glp_intopt (lpx_integer returns a
+  subset of these).  GLP_ENOPFS (GLP_ENODFS) indicate no primal (dual)
   feasible solution; detected at the root, either by presolve or when
-  attempting the root relaxation. LPX_E_ITLIM (LPX_E_TMLIM) indicate
+  attempting the root relaxation. GLP_EITLIM (GLP_ETMLIM) indicate
   iteration (time) limit reached. Osi doesn't provide for time limit, so lump
   it in with iteration limit (an arguable choice, but seems better than the
   alternatives) and have extra method isTimeLimitReached().
-  LPX_E_SING (lp solver failed due to singular basis) is
-  legimately characterised as abandoned.  LPX_E_FAULT indicates a structural
+  GLP_ESING (lp solver failed due to singular basis) is
+  legimately characterised as abandoned.  GLP_EFAIL indicates a structural
   problem (problem not of class MIP, or an integer variable has a non-integer
   bound), which really translates into internal confusion in OsiGlpk.
 
   Previous comments expressed uncertainty about the iteration count. This
   should be checked at some point. -- lh, 070709 --
 */
-    iter_used_ = lpx_get_int_parm(model,LPX_K_ITCNT) ;
+    iter_used_ = glp_get_it_cnt(model) ;
     isIterationLimitReached_ = false ;
 		isTimeLimitReached_ = false ;
     isAbandoned_ = false ;
@@ -407,45 +401,45 @@ void OGSI::branchAndBound ()
     isObjUpperLimitReached_ = false ;
 
     switch (err)
-    { case LPX_E_OK:
-#ifdef LPX_E_MIPGAP
-    case LPX_E_MIPGAP:
+    { case 0:
+#ifdef GLP_EMIPGAP
+    case GLP_EMIPGAP:
 #endif
       { 
 	break ; }
-      case LPX_E_NOPFS:
+      case GLP_ENOPFS:
       { isPrimInfeasible_ = true ;
 	break ; }
-      case LPX_E_NODFS:
+      case GLP_ENODFS:
       { isDualInfeasible_ = true ;
 	break ; }
-      case LPX_E_TMLIM:
+      case GLP_ETMLIM:
       { isTimeLimitReached_ = true ; } // no break
-      case LPX_E_ITLIM:
+      case GLP_EITLIM:
       { isIterationLimitReached_ = true ;
 	break ; }
-      case LPX_E_SING:
+      case GLP_ESING:
       { isAbandoned_ = true ;
 	break ; }
-      case LPX_E_FAULT:
+      case GLP_EFAIL:
       { assert(false) ;
 	break ; }
       default:
       { assert(false) ;
 	break ; } }
 	
-	//check this also if err!=LPX_E_OPT, so we know about feasibility in case time/resource limit is reached  
-	int mip_status = lpx_mip_status(model) ;
+	//check this also if err!=GLP_OPT, so we know about feasibility in case time/resource limit is reached  
+	int mip_status = glp_mip_status(model) ;
 	switch (mip_status)
-	{ case LPX_I_OPT:
+	{ case GLP_OPT:
 	  { isFeasible_ = true ;
 	  	break ; }
-	  case LPX_I_NOFEAS:
+	  case GLP_NOFEAS:
 	  { isPrimInfeasible_ = true ;
 	    break ; }
-	  case LPX_I_UNDEF:
+	  case GLP_UNDEF:
 	  { break ; }
-	  case LPX_I_FEAS:
+	  case GLP_FEAS:
 	  { isFeasible_ = true ;
 	  	break ; }
 	  default:
@@ -458,7 +452,7 @@ void OGSI::branchAndBound ()
 /*
   Not a MIP (no integer variables). Call the LP solver. Since we can call
   branchAndBound with no initial LP solution, initialSolve is appropriate here.
-  (But for glpk, it actually makes no difference --- lpx_simplex makes the
+  (But for glpk, it actually makes no difference --- glp_simplex makes the
   decision on how to proceed.)
 */
   else
@@ -490,7 +484,7 @@ bool OGSI::setIntParam (OsiIntParam key,
   { case OsiMaxNumIteration:
     { if (value >= 0)
       { maxIteration_ = value ;
-	lpx_set_int_parm(lp_,LPX_K_ITLIM,value) ;
+	simplexParams_.it_lim = value ;
 	retval = true ; }
       else
       { retval = false ; }
@@ -531,24 +525,24 @@ bool OGSI::setDblParam (OsiDblParam key,
     // as of 4.7, GLPK only uses this if it does dual simplex
     { dualObjectiveLimit_ = value ;
       if (getObjSense() == 1)				// minimization
-      { lpx_set_real_parm(lp_,LPX_K_OBJUL,value) ; }
+      { simplexParams_.obj_ul = value ; }
       else              				// maximization
-      { lpx_set_real_parm(lp_,LPX_K_OBJLL,value) ; }
+      { simplexParams_.obj_ll = value ; }
       retval = true ; 
       break ; }
     case OsiPrimalObjectiveLimit:
     // as of 4.7, GLPK only uses this if it does dual simplex
     { primalObjectiveLimit_ = value ;
       if (getObjSense() == 1)
-      { lpx_set_real_parm(lp_,LPX_K_OBJLL,value) ; }
+      { simplexParams_.obj_ll = value ; }
       else
-      { lpx_set_real_parm(lp_,LPX_K_OBJUL,value) ; }
+      { simplexParams_.obj_ul = value ; }
       retval = true ; 
       break ; }
     case OsiDualTolerance:
     { if (value >= 0 && value <= .001)
       { dualTolerance_ = value;
-	lpx_set_real_parm(lp_,LPX_K_TOLDJ,value) ;
+	simplexParams_.tol_dj = value ;
 	retval = true ; }
       else
       { retval = false ; }
@@ -556,14 +550,14 @@ bool OGSI::setDblParam (OsiDblParam key,
     case OsiPrimalTolerance:
     { if (value >= 0 && value <= .001)
       { primalTolerance_ = value ;
-	lpx_set_real_parm(lp_,LPX_K_TOLBND,value) ;
+	simplexParams_.tol_bnd = value ;
 	retval = true ; }
       else
       { retval = false ; }
       break ; }
     case OsiObjOffset:
     { objOffset_ = value ;
-      lpx_set_obj_coef(lp_,0,value) ;
+      glp_set_obj_coef(lp_,0,value) ;
       retval = true ;
       break ; }
     case OsiLastDblParam:
@@ -583,7 +577,7 @@ bool OGSI::setStrParam (OsiStrParam key,
     { probName_ = value ;
       if (probName_.length() == 0)
         probName_ = "Pb";
-      lpx_set_prob_name(lp_,const_cast<char *>(value.c_str())) ;
+      glp_set_prob_name(lp_,const_cast<char *>(value.c_str())) ;
       retval = true ;
       break ; }
     case OsiSolverName:
@@ -665,18 +659,18 @@ bool OGSI::setHintParam (OsiHintParam ke
     case OsiDoPresolveInInitial:
     case OsiDoPresolveInResolve:
     { if (sense == false)
-      { if (strength >= OsiHintTry) lpx_set_int_parm(lp_,LPX_K_PRESOL,0) ; }
+      { if (strength >= OsiHintTry) simplexParams_.presolve = intoptParams_.presolve = 0 ; }
       else
-      { lpx_set_int_parm(lp_,LPX_K_PRESOL,1) ; }
+      { simplexParams_.presolve = intoptParams_.presolve = 1 ; }
       retval = true ;
       break ; }
     case OsiDoDualInInitial:
     case OsiDoDualInResolve:
     { unimp_hint(msgHdl,false,sense,strength,"exclusive use of dual simplex") ;
       if (sense == false)
-      { if (strength >= OsiHintDo) lpx_set_int_parm(lp_,LPX_K_DUAL,0) ; }
+      { if (strength >= OsiHintDo) simplexParams_.meth = GLP_PRIMAL ; }
       else
-      { lpx_set_int_parm(lp_,LPX_K_DUAL,1) ; }
+      { simplexParams_.meth = GLP_DUALP ; }
       retval = true ;
       break ; }
     case OsiDoCrash:
@@ -692,9 +686,10 @@ bool OGSI::setHintParam (OsiHintParam ke
 */
     case OsiDoScale:
     { if (sense == false)
-      { if (strength >= OsiHintTry) lpx_set_int_parm(lp_,LPX_K_SCALE,0) ; }
+      { if (strength >= OsiHintTry) scaleFlags_ = 0 ; }
       else
-      { lpx_set_int_parm(lp_,LPX_K_SCALE,3) ; }
+      { scaleFlags_ = GLP_SF_GM | GLP_SF_EQ ; }
+      glp_scale_prob(lp_, scaleFlags_);
       retval = true ;
       break ; }
 /*
@@ -704,15 +699,15 @@ bool OGSI::setHintParam (OsiHintParam ke
     case OsiDoReducePrint:
     { if (sense == true)
       { if (strength <= OsiHintTry)
-	{ lpx_set_int_parm(lp_,LPX_K_MSGLEV,1) ; }
+	{ simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_ERR ; }
 	else
-	{ lpx_set_int_parm(lp_,LPX_K_MSGLEV,0) ; } }
+	{ simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_OFF ; } }
       else
       { if (strength <= OsiHintTry)
-	{ lpx_set_int_parm(lp_,LPX_K_MSGLEV,2) ; }
+	{ simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_ON ; }
 	else
-	{ lpx_set_int_parm(lp_,LPX_K_MSGLEV,3) ; } }
-      int logLevel = lpx_get_int_parm(lp_,LPX_K_MSGLEV) ;
+	{ simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_ALL ; } }
+      int logLevel = simplexParams_.msg_lev ;
       messageHandler()->setLogLevel(logLevel) ;
       retval = true ;
       break ; }
@@ -787,7 +782,7 @@ OGSI::getDblParam( OsiDblParam key, doub
 		break;
 
     case OsiObjOffset:
-                value = lpx_get_obj_coef(getMutableModelPtr(),0);
+                value = glp_get_obj_coef(getMutableModelPtr(),0);
 		retval = true;
 		break;
 
@@ -805,7 +800,7 @@ OGSI::getStrParam(OsiStrParam key, std::
   //	bool retval = false;
   switch (key) {
   case OsiProbName:
-    value = lpx_get_prob_name( getMutableModelPtr() );
+    value = glp_get_prob_name( getMutableModelPtr() );
     break;
   case OsiSolverName:
     value = "glpk";
@@ -830,13 +825,13 @@ bool OGSI::isProvenOptimal() const
 
 	if( bbWasLast_ == 0 )
 	  {
-	    int stat = lpx_get_status( model );
-	    return stat == LPX_OPT;
+	    int stat = glp_get_status( model );
+	    return stat == GLP_OPT;
 	  }
 	else
 	  {
-	    int stat = lpx_mip_status( model );
-	    return stat == LPX_I_OPT;
+	    int stat = glp_mip_status( model );
+	    return stat == GLP_OPT;
 	  }
 }
 
@@ -848,9 +843,9 @@ bool OGSI::isProvenPrimalInfeasible() co
 		return true;
 
 	if( bbWasLast_ == 0 )
-		return lpx_get_prim_stat( model ) == LPX_P_NOFEAS;
+		return glp_get_prim_stat( model ) == GLP_NOFEAS;
 	else
-		return lpx_mip_status( model ) == LPX_I_NOFEAS;
+		return glp_mip_status( model ) == GLP_NOFEAS;
 }
 
 bool OGSI::isProvenDualInfeasible() const
@@ -861,7 +856,7 @@ bool OGSI::isProvenDualInfeasible() cons
 		return true;
 
 	if( bbWasLast_ == 0 )
-		return lpx_get_dual_stat( model ) == LPX_D_NOFEAS;
+		return glp_get_dual_stat( model ) == GLP_NOFEAS;
 	else
 	  // Not sure what to do for MIPs;  does it just mean unbounded?
 	  // ??? for now, return false
@@ -933,7 +928,7 @@ bool OGSI::isFeasible() const
 /*
   Return a warm start object matching the current state of the solver.
 
-  Nonbasic fixed variables (LPX_NS) are translated to CWSB::atLowerBound.
+  Nonbasic fixed variables (GLP_NS) are translated to CWSB::atLowerBound.
 */
 CoinWarmStart *OGSI::getWarmStart() const
 
@@ -953,19 +948,19 @@ CoinWarmStart *OGSI::getWarmStart() cons
    and  Glpk's at-upper-bound will be mapped to Osi's at-lower-bound. 
 */
   for (int i = 0 ; i < numrows ; i++)
-  { int stati = lpx_get_row_stat(lp_,i+1) ;
+  { int stati = glp_get_row_stat(lp_,i+1) ;
     switch (stati)
-    { case LPX_BS:
+    { case GLP_BS:
       { ws->setArtifStatus(i,CoinWarmStartBasis::basic) ;
 	break ; }
-      case LPX_NS:
-      case LPX_NL:
+      case GLP_NS:
+      case GLP_NL:
       { ws->setArtifStatus(i,CoinWarmStartBasis::atUpperBound) ;
 	break ; }
-      case LPX_NU:
+      case GLP_NU:
       { ws->setArtifStatus(i,CoinWarmStartBasis::atLowerBound) ;
 	break ; }
-      case LPX_NF:
+      case GLP_NF:
       { ws->setArtifStatus(i,CoinWarmStartBasis::isFree) ;
 	break ; }
       default:
@@ -975,19 +970,19 @@ CoinWarmStart *OGSI::getWarmStart() cons
   And repeat for the columns.
 */
   for (int j = 0 ; j < numcols ; j++)
-  { int statj = lpx_get_col_stat(lp_,j+1) ;
+  { int statj = glp_get_col_stat(lp_,j+1) ;
     switch (statj)
-    { case LPX_BS:
+    { case GLP_BS:
       { ws->setStructStatus(j,CoinWarmStartBasis::basic) ;
 	break ; }
-      case LPX_NS:
-      case LPX_NL:
+      case GLP_NS:
+      case GLP_NL:
       { ws->setStructStatus(j,CoinWarmStartBasis::atLowerBound) ;
 	break ; }
-      case LPX_NU:
+      case GLP_NU:
       { ws->setStructStatus(j,CoinWarmStartBasis::atUpperBound) ;
 	break ; }
-      case LPX_NF:
+      case GLP_NF:
       { ws->setStructStatus(j,CoinWarmStartBasis::isFree) ;
 	break ; }
       default:
@@ -1040,44 +1035,44 @@ bool OGSI::setWarmStart (const CoinWarmS
 
     switch (ws->getArtifStatus(i))
     { case CoinWarmStartBasis::basic:
-      { stati = LPX_BS ;
+      { stati = GLP_BS ;
 	break ; }
       case CoinWarmStartBasis::atLowerBound:
-      { stati = LPX_NU ;
+      { stati = GLP_NU ;
 	break ; }
       case CoinWarmStartBasis::atUpperBound:
-      { stati = LPX_NL ;
+      { stati = GLP_NL ;
 	break ; }
       case CoinWarmStartBasis::isFree:
-      { stati = LPX_NF ;
+      { stati = GLP_NF ;
 	break ; }
       default:
       { assert(false) ;
 	return (false) ; } }		
 
-    lpx_set_row_stat(lp_,i+1,stati) ; }
+    glp_set_row_stat(lp_,i+1,stati) ; }
   
   for (int j = 0 ; j < numcols ; j++)
   { int statj ;
 
     switch (ws->getStructStatus(j))
     { case CoinWarmStartBasis::basic:
-      { statj = LPX_BS ;
+      { statj = GLP_BS ;
 	break ; }
       case CoinWarmStartBasis::atLowerBound:
-      { statj = LPX_NL ;
+      { statj = GLP_NL ;
 	break ; }
       case CoinWarmStartBasis::atUpperBound:
-      { statj = LPX_NU ;
+      { statj = GLP_NU ;
 	break ; }
       case CoinWarmStartBasis::isFree:
-      { statj = LPX_NF ;
+      { statj = GLP_NF ;
 	break ; }
       default:
       { assert(false) ;
 	return (false) ; } }
 
-    lpx_set_col_stat(lp_,j+1,statj) ; }
+    glp_set_col_stat(lp_,j+1,statj) ; }
 
   return (true) ; }
 
@@ -1108,9 +1103,9 @@ void OGSI::markHotStart()
 		int stat;
 		double val;
 		double dualVal;
-		stat=lpx_get_col_stat(model,j);
-		val=lpx_get_col_prim(model,j);
-		dualVal=lpx_get_col_dual(model,j);
+		stat=glp_get_col_stat(model,j);
+		val=glp_get_col_prim(model,j);
+		dualVal=glp_get_col_dual(model,j);
 		hotStartCStat_[j] = stat;
 		hotStartCVal_[j] = val;
 		hotStartCDualVal_[j] = dualVal;
@@ -1131,9 +1126,9 @@ void OGSI::markHotStart()
 		int stat;
 		double val;
 		double dualVal;
-		stat=lpx_get_row_stat(model,i+1);
-		val=lpx_get_row_prim(model,i+1);
-		dualVal=lpx_get_row_dual(model,i+1);
+		stat=glp_get_row_stat(model,i+1);
+		val=glp_get_row_prim(model,i+1);
+		dualVal=glp_get_row_dual(model,i+1);
 		hotStartRStat_[i] = stat;
 		hotStartRVal_[i] = val;
 		hotStartRDualVal_[i] = dualVal;
@@ -1160,11 +1155,11 @@ void OGSI::solveFromHotStart()
 
 	int j;
 	for( j = 0; j < numcols; j++ ) {
-	  lpx_set_col_stat( model, j+1, hotStartCStat_[j]);
+	  glp_set_col_stat( model, j+1, hotStartCStat_[j]);
 	}
 	int i;
 	for( i = 0; i < numrows; i++ ) {
-	  lpx_set_row_stat( model, i+1, hotStartRStat_[i]);
+	  glp_set_row_stat( model, i+1, hotStartRStat_[i]);
 	}
 
 	freeCachedData( OGSI::FREECACHED_RESULTS );
@@ -1191,17 +1186,17 @@ void OGSI::unmarkHotStart()
 //-----------------------------------------------------------------------------
 int OGSI::getNumCols() const
 {
-	return lpx_get_num_cols( getMutableModelPtr() );
+	return glp_get_num_cols( getMutableModelPtr() );
 }
 
 int OGSI::getNumRows() const
 {
-	return lpx_get_num_rows( getMutableModelPtr() );
+	return glp_get_num_rows( getMutableModelPtr() );
 }
 
 int OGSI::getNumElements() const
 {
-	return lpx_get_num_nz( getMutableModelPtr() );
+	return glp_get_num_nz( getMutableModelPtr() );
 }
 
 //-----------------------------------------------------------------------------
@@ -1230,26 +1225,26 @@ const double * OGSI::getColLower() const
 			int type;
 			double lb;
 			double ub;
-			type=lpx_get_col_type(model,i+1);
-			lb=lpx_get_col_lb(model,i+1);
-			ub=lpx_get_col_ub(model,i+1);
+			type=glp_get_col_type(model,i+1);
+			lb=glp_get_col_lb(model,i+1);
+			ub=glp_get_col_ub(model,i+1);
 			switch ( type )
 			{
-			case LPX_FR:
+			case GLP_FR:
 				lb = -inf;
 				ub = inf;
 				break;
 
-			case LPX_LO:
+			case GLP_LO:
 				ub = inf;
 				break;
 
-			case LPX_UP:
+			case GLP_UP:
 				lb = -inf;
 				break;
 
-			case LPX_FX:
-			case LPX_DB:
+			case GLP_FX:
+			case GLP_DB:
 				break;
 
 			default:
@@ -1355,26 +1350,26 @@ const double * OGSI::getRowLower() const
 			int type;
 			double lb;
 			double ub;
-			type=lpx_get_row_type(model,i+1);
-			lb=lpx_get_row_lb(model,i+1);
-			ub=lpx_get_row_ub(model,i+1);
+			type=glp_get_row_type(model,i+1);
+			lb=glp_get_row_lb(model,i+1);
+			ub=glp_get_row_ub(model,i+1);
 			switch( type )
 			{
-			case LPX_FR:
+			case GLP_FR:
 				lb = -inf;
 				ub = inf;
 				break;
 
-			case LPX_LO:
+			case GLP_LO:
 				ub = inf;
 				break;
 
-			case LPX_UP:
+			case GLP_UP:
 				lb = -inf;
 				break;
 
-			case LPX_DB:
-			case LPX_FX:
+			case GLP_DB:
+			case GLP_FX:
 				break;
 
 			default:
@@ -1416,7 +1411,7 @@ const double * OGSI::getObjCoefficients(
 		int i;
 		for( i = 0; i < numcols; i++ )
 		{
-			obj_[i] = lpx_get_obj_coef( model, i + 1);
+			obj_[i] = glp_get_obj_coef( model, i + 1);
 		}
 	}
 	return obj_;
@@ -1426,10 +1421,10 @@ const double * OGSI::getObjCoefficients(
 
 double OGSI::getObjSense() const
 
-{ if (lpx_get_obj_dir(lp_) == LPX_MIN)
+{ if (glp_get_obj_dir(lp_) == GLP_MIN)
   { return (+1.0) ; }
   else
-  if (lpx_get_obj_dir(lp_) == LPX_MAX)
+  if (glp_get_obj_dir(lp_) == GLP_MAX)
   { return (-1.0) ; }
   else	// internal confusion
   { assert(false) ;
@@ -1441,7 +1436,7 @@ double OGSI::getObjSense() const
 
 bool OGSI::isContinuous( int colNumber ) const
 {
-  return lpx_get_col_kind( getMutableModelPtr(), colNumber+1 ) == LPX_CV;
+  return glp_get_col_kind( getMutableModelPtr(), colNumber+1 ) == GLP_CV;
 }
 
 //-----------------------------------------------------------------------------
@@ -1464,14 +1459,14 @@ const CoinPackedMatrix * OGSI::getMatrix
 		int i;
 		for( i = 0; i < getNumRows(); i++ )
 		{
-			int colsize = lpx_get_mat_row( model, i+1, colind, colelem);
+			int colsize = glp_get_mat_row( model, i+1, colind, colelem);
 			int j;
 			for( j = 1; j <= colsize; j++ )
 			{
 				--colind[j];
 			}
 
-			// Note:  lpx_get_mat_row apparently may return the
+			// Note:  glp_get_mat_row apparently may return the
 			// elements in decreasing order.  This differs from
 			// people's standard expectations but is not an error.
 
@@ -1502,7 +1497,7 @@ const CoinPackedMatrix * OGSI::getMatrix
 		int j;
 		for( j = 0; j < getNumCols(); j++ )
 		{
-			int rowsize = lpx_get_mat_col( model, j+1, rowind, rowelem);
+			int rowsize = glp_get_mat_col( model, j+1, rowind, rowelem);
 			int i;
 			for( i = 1; i <= rowsize; i++ )
 			{
@@ -1563,9 +1558,9 @@ const double *OGSI::getColSolution() con
 */
   int probStatus ;
   if (bbWasLast_)
-  { probStatus = lpx_mip_status(lp_) ; }
+  { probStatus = glp_mip_status(lp_) ; }
   else
-  { probStatus = lpx_get_status(lp_) ; }
+  { probStatus = glp_get_status(lp_) ; }
 /*
   If the problem hasn't been solved, glpk returns zeros, but OSI requires that
   the solution be within bound. getColLower() will ensure both upper and lower
@@ -1573,7 +1568,7 @@ const double *OGSI::getColSolution() con
   collower[j] < colupper[j]). Solution values will be 0.0 unless that's outside
   the bounds.
 */
-  if (probStatus == LPX_UNDEF || probStatus == LPX_I_UNDEF)
+  if (probStatus == GLP_UNDEF)
   { getColLower() ;
     int j ;
     for (j = 0 ; j < numcols ; j++)
@@ -1591,10 +1586,10 @@ const double *OGSI::getColSolution() con
   if (bbWasLast_ == 0)
   { int j ;
     for (j = 0 ; j < numcols ; j++)
-    { colsol_[j] = lpx_get_col_prim(lp_,j+1) ;
+    { colsol_[j] = glp_get_col_prim(lp_,j+1) ;
       if (fabs(colsol_[j]) < GlpkZeroTol)
       { colsol_[j] = 0.0 ; }
-      redcost_[j] = lpx_get_col_dual(lp_,j+1) ;
+      redcost_[j] = glp_get_col_dual(lp_,j+1) ;
       if (fabs(redcost_[j]) < GlpkZeroTol)
       { redcost_[j] = 0.0 ; } } }
 /*
@@ -1604,7 +1599,7 @@ const double *OGSI::getColSolution() con
   else
   { int j ;
     for (j = 0 ; j < numcols ; j++)
-    { colsol_[j] = lpx_mip_col_val(lp_,j+1) ;
+    { colsol_[j] = glp_mip_col_val(lp_,j+1) ;
       if (fabs(colsol_[j]) < GlpkZeroTol)
       { colsol_[j] = 0.0 ; }
       redcost_[j] = 0.0 ; } }
@@ -1641,7 +1636,7 @@ const double *OGSI::getRowPrice() const
   if (bbWasLast_ == 0)
   { int i ;
     for (i = 0 ; i < numrows; i++)
-    { rowsol_[i] = lpx_get_row_dual(lp_,i+1) ;
+    { rowsol_[i] = glp_get_row_dual(lp_,i+1) ;
       if (fabs(rowsol_[i]) < GlpkZeroTol)
       { rowsol_[i] = 0.0 ; } } }
   else
@@ -1658,7 +1653,7 @@ const double *OGSI::getRowPrice() const
   setRowPrice(), and it'd be nice to return reduced costs that agree with the
   duals.
 
-  To use glpk's routine (lpx_get_col_dual), the interface needs to track the
+  To use glpk's routine (glp_get_col_dual), the interface needs to track the
   origin of the dual (row price) values.
 */
 const double * OGSI::getReducedCost() const
@@ -1813,7 +1808,7 @@ void OGSI::setObjCoeff (int j, double cj
 /*
   Push the changed objective down to glpk.
 */
-  lpx_set_obj_coef(lp_,j+1,cj) ;
+  glp_set_obj_coef(lp_,j+1,cj) ;
 
   if (obj_)
   { obj_[j] = cj ; }
@@ -1830,15 +1825,15 @@ void OGSI::setColLower (int j, double lb
   infinite bound, so we need to check the status and possibly correct.
 */
   double inf = getInfinity() ;
-  int type = lpx_get_col_type(lp_,j+1) ;
-  double ubj = lpx_get_col_ub(lp_,j+1) ;
+  int type = glp_get_col_type(lp_,j+1) ;
+  double ubj = glp_get_col_ub(lp_,j+1) ;
   switch (type)
-  { case LPX_UP:
-    case LPX_DB:
-    case LPX_FX:
+  { case GLP_UP:
+    case GLP_DB:
+    case GLP_FX:
     { break ; }
-    case LPX_FR:
-    case LPX_LO:
+    case GLP_FR:
+    case GLP_LO:
     { ubj = inf ;
       break ; }
     default:
@@ -1875,15 +1870,15 @@ void OGSI::setColUpper (int j, double ub
   infinite bound, so we need to check the status and possibly correct.
 */
   double inf = getInfinity() ;
-  int type = lpx_get_col_type(lp_,j+1) ;
-  double lbj = lpx_get_col_lb(lp_,j+1) ;
+  int type = glp_get_col_type(lp_,j+1) ;
+  double lbj = glp_get_col_lb(lp_,j+1) ;
   switch (type)
-  { case LPX_LO:
-    case LPX_DB:
-    case LPX_FX:
+  { case GLP_LO:
+    case GLP_DB:
+    case GLP_FX:
     { break ; }
-    case LPX_FR:
-    case LPX_UP:
+    case GLP_FR:
+    case GLP_UP:
     { lbj = inf ;
       break ; }
     default:
@@ -1932,25 +1927,25 @@ void OGSI::setColBounds (int j, double l
   int type ;
 
   if (lower == upper)
-  { type = LPX_FX ; }
+  { type = GLP_FX ; }
   else
   if (lower > -inf && upper < inf)
-  { type = LPX_DB ; }
+  { type = GLP_DB ; }
   else
   if (lower > -inf)
-  { type = LPX_LO ; }
+  { type = GLP_LO ; }
   else
   if (upper < inf)
-  { type = LPX_UP ; }
+  { type = GLP_UP ; }
   else
-  { type = LPX_FR ; }
+  { type = GLP_FR ; }
 /*
   Push the bound change down into the solver. 1-based addressing.
 */
-  int statj = lpx_get_col_stat(lp_,j+1) ;
-  lpx_set_col_bnds(lp_,j+1,type,lower,upper) ;
-  lpx_set_col_stat(lp_,j+1,statj) ;
-  statj = lpx_get_col_stat(lp_,j+1) ;
+  int statj = glp_get_col_stat(lp_,j+1) ;
+  glp_set_col_bnds(lp_,j+1,type,lower,upper) ;
+  glp_set_col_stat(lp_,j+1,statj) ;
+  statj = glp_get_col_stat(lp_,j+1) ;
 /*
   Correct the cached upper and lower bound vectors, if present.
 */
@@ -1982,18 +1977,18 @@ OGSI::setRowLower( int elementIndex, dou
 	double lb;
 	double ub;
 
-	type=lpx_get_row_type(getMutableModelPtr(),elementIndex+1);
-	ub=lpx_get_row_ub(getMutableModelPtr(),elementIndex+1);
+	type=glp_get_row_type(getMutableModelPtr(),elementIndex+1);
+	ub=glp_get_row_ub(getMutableModelPtr(),elementIndex+1);
 	lb = elementValue;
 	switch( type )
 	{
-	case LPX_UP:
-	case LPX_DB:
-	case LPX_FX:
+	case GLP_UP:
+	case GLP_DB:
+	case GLP_FX:
 		break;
 
-	case LPX_FR:
-	case LPX_LO:
+	case GLP_FR:
+	case GLP_LO:
 		ub = inf;
 		break;
 
@@ -2014,18 +2009,18 @@ OGSI::setRowUpper( int elementIndex, dou
 	double lb;
 	double ub;
 
-	type=lpx_get_row_type(getMutableModelPtr(),elementIndex+1);
-	lb=lpx_get_row_lb(getMutableModelPtr(),elementIndex+1);
+	type=glp_get_row_type(getMutableModelPtr(),elementIndex+1);
+	lb=glp_get_row_lb(getMutableModelPtr(),elementIndex+1);
 	ub = elementValue;
 	switch( type )
 	{
-	case LPX_LO:
-	case LPX_DB:
-	case LPX_FX:
+	case GLP_LO:
+	case GLP_DB:
+	case GLP_FX:
 		break;
 
-	case LPX_FR:
-	case LPX_UP:
+	case GLP_FR:
+	case GLP_UP:
 		lb = -inf;
 		break;
 
@@ -2056,20 +2051,20 @@ void OGSI::setRowBounds (int i, double l
   int type ;
 
   if( lower == upper)
-  { type = LPX_FX ; }
+  { type = GLP_FX ; }
   else
   if (lower > -inf && upper < inf)
-  { type = LPX_DB ; }
+  { type = GLP_DB ; }
   else
   if (lower > -inf)
-  { type = LPX_LO ; }
+  { type = GLP_LO ; }
   else
   if (upper < inf)
-  { type = LPX_UP ; }
+  { type = GLP_UP ; }
   else
-  { type = LPX_FR ; }
+  { type = GLP_FR ; }
 
-  lpx_set_row_bnds(lp_,i+1,type,lower,upper) ;
+  glp_set_row_bnds(lp_,i+1,type,lower,upper) ;
 /*
   Update cached vectors, if they exist.
 */
@@ -2123,7 +2118,7 @@ OGSI::setContinuous(int index)
 {
         LPX *model = getMutableModelPtr();
 	freeCachedData( OGSI::FREECACHED_COLUMN );
-	lpx_set_col_kind( model, index+1, LPX_CV );
+	glp_set_col_kind( model, index+1, GLP_CV );
 }
 
 //-----------------------------------------------------------------------------
@@ -2132,7 +2127,7 @@ void OGSI::setInteger (int index)
 
 { LPX *model = getMutableModelPtr() ;
   freeCachedData(OGSI::FREECACHED_COLUMN) ;
-  lpx_set_col_kind(model,index+1,LPX_IV) ;
+  glp_set_col_kind(model,index+1,GLP_IV) ;
 /*
   Temporary hack to correct upper bounds on general integer variables.
   CoinMpsIO insists on forcing a bound of 1e30 for general integer variables
@@ -2184,9 +2179,9 @@ void OGSI::setObjSense(double s)
 { freeCachedData(OGSI::FREECACHED_RESULTS) ;
 
   if (s <= -1.0)
-  { lpx_set_obj_dir(lp_,LPX_MAX) ; }
+  { glp_set_obj_dir(lp_,GLP_MAX) ; }
   else
-  { lpx_set_obj_dir(lp_,LPX_MIN) ; }
+  { glp_set_obj_dir(lp_,GLP_MIN) ; }
 
   return ; }
 
@@ -2252,12 +2247,12 @@ void OGSI::addCol (const CoinPackedVecto
 		   const double collb, const double colub, const double obj)
 {
   // Note: GLPK expects only non-zero coefficients will be given in 
-  //   lpx_set_mat_col and will abort if there are any zeros.  So any
-  //   zeros must be removed prior to calling lpx_set_mat_col.
+  //   glp_set_mat_col and will abort if there are any zeros.  So any
+  //   zeros must be removed prior to calling glp_set_mat_col.
         LPX *model = getMutableModelPtr();
 	freeCachedData(OGSI::KEEPCACHED_ROW);
 
-	lpx_add_cols( model, 1 );
+	glp_add_cols( model, 1 );
 	int numcols = getNumCols();
 	setColBounds( numcols-1, collb, colub );
 	setObjCoeff( numcols-1, obj );
@@ -2276,7 +2271,7 @@ void OGSI::addCol (const CoinPackedVecto
 	  if (elements[i] != 0.0)
 	    {
 		if ( indices[i]+1 > numrows ) {
-			lpx_add_rows( model, indices[i]+1 - numrows );
+			glp_add_rows( model, indices[i]+1 - numrows );
 			numrows = indices[i]+1;
 			// ??? could do this more efficiently with a single call based on the max
 		}
@@ -2286,7 +2281,7 @@ void OGSI::addCol (const CoinPackedVecto
 		elements_adj[count] = elements[i];
 	    }
 	}
-	lpx_set_mat_col( model, numcols, count, indices_adj, elements_adj );
+	glp_set_mat_col( model, numcols, count, indices_adj, elements_adj );
 	delete [] indices_adj;
 	delete [] elements_adj;
 
@@ -2326,7 +2321,7 @@ OGSI::deleteCols(const int num, const in
 		columnIndicesPlus1[i+1]=columnIndices[i]+1;
 		deleteColNames(columnIndices[i],1);
 	}
-	lpx_del_cols(model,num,columnIndicesPlus1);
+	glp_del_cols(model,num,columnIndicesPlus1);
 	delete [] columnIndicesPlus1;
 
 # if OGSI_TRACK_FRESH > 0
@@ -2344,13 +2339,13 @@ OGSI::addRow (const CoinPackedVectorBase
 	      const double rowlb, const double rowub)
 {
   // Note: GLPK expects only non-zero coefficients will be given in 
-  //   lpx_set_mat_row and will abort if there are any zeros.  So any
-  //   zeros must be removed prior to calling lpx_set_mat_row.
+  //   glp_set_mat_row and will abort if there are any zeros.  So any
+  //   zeros must be removed prior to calling glp_set_mat_row.
 
         LPX *model = getMutableModelPtr();
 	freeCachedData( OGSI::KEEPCACHED_COLUMN );
 
-	lpx_add_rows( model, 1 );
+	glp_add_rows( model, 1 );
 	int numrows = getNumRows();
 	setRowBounds( numrows-1, rowlb, rowub );
 	int i;
@@ -2369,7 +2364,7 @@ OGSI::addRow (const CoinPackedVectorBase
 	    {
 		if ( indices[i]+1 > numcols ) {
 		  // ??? Could do this more efficiently with a single call
-			lpx_add_cols( model, indices[i]+1 - numcols );
+			glp_add_cols( model, indices[i]+1 - numcols );
 			numcols = indices[i]+1;
 		}
 		count++;
@@ -2377,7 +2372,7 @@ OGSI::addRow (const CoinPackedVectorBase
 		indices_adj[count] = indices[i] + 1;
 	    }
 	}
-	lpx_set_mat_row( model, numrows, count, indices_adj, elements_adj );
+	glp_set_mat_row( model, numrows, count, indices_adj, elements_adj );
 	delete [] indices_adj;
 	delete [] elements_adj;
 
@@ -2461,8 +2456,8 @@ void OGSI::deleteRows (const int num, co
   int notBasic = 0 ;
   for (ndx = 1 ; ndx <= num ; ndx++)
   { i = glpkIndices[ndx] ;
-    int stati = lpx_get_row_stat(lp_,i) ;
-    if (stati != LPX_BS)
+    int stati = glp_get_row_stat(lp_,i) ;
+    if (stati != GLP_BS)
     { notBasic++ ; } }
   if (notBasic)
   {
@@ -2476,7 +2471,7 @@ void OGSI::deleteRows (const int num, co
 /*
   Tell glpk to delete the rows.
 */
-  lpx_del_rows(lp_,num,glpkIndices) ;
+  glp_del_rows(lp_,num,glpkIndices) ;
 
   delete [] glpkIndices ;
 
@@ -2511,41 +2506,32 @@ void OGSI::loadProblem (const CoinPacked
   
   In any event, get rid of cached data in the OsiGlpk object.
 */
-  if (lpx_get_num_cols(lp_) != 0 || lpx_get_num_rows(lp_) != 0)
+  if (glp_get_num_cols(lp_) != 0 || glp_get_num_rows(lp_) != 0)
   { 
-    int presolVal = lpx_get_int_parm(lp_,LPX_K_PRESOL) ;
-    int usedualVal = lpx_get_int_parm(lp_,LPX_K_DUAL) ;
-    int scaleVal = lpx_get_int_parm(lp_,LPX_K_SCALE) ;
-    int logVal = lpx_get_int_parm(lp_,LPX_K_MSGLEV) ;
 #   if OGSI_TRACK_FRESH > 0
     std::cout
       << "    emptying LPX(" << std::hex << lp_ << std::dec << "), "
 #   endif
-    lpx_delete_prob(lp_) ;
-    lp_ = lpx_create_prob() ;
+    glp_delete_prob(lp_) ;
+    lp_ = glp_create_prob() ;
     assert(lp_) ;
 #   if OGSI_TRACK_FRESH > 0
     std::cout
       << "loading LPX(" << std::hex << lp_ << std::dec << ")."
       << std::endl ;
 #   endif
-    lpx_set_class(lp_,LPX_MIP) ;
-    lpx_set_int_parm(lp_,LPX_K_ITLIM,maxIteration_) ; 
+    
+    simplexParams_.it_lim = maxIteration_ ; 
     if (getObjSense() == 1)				// minimization
-    { lpx_set_real_parm(lp_,LPX_K_OBJUL,dualObjectiveLimit_) ;
-      lpx_set_real_parm(lp_,LPX_K_OBJLL,primalObjectiveLimit_) ; }
+    { simplexParams_.obj_ul = dualObjectiveLimit_ ;
+      simplexParams_.obj_ll = primalObjectiveLimit_ ; }
     else						// maximization
-    { lpx_set_real_parm(lp_,LPX_K_OBJLL,dualObjectiveLimit_) ;
-      lpx_set_real_parm(lp_,LPX_K_OBJUL,primalObjectiveLimit_) ; }
-    lpx_set_real_parm(lp_,LPX_K_TOLDJ,dualTolerance_) ;
-    lpx_set_real_parm(lp_,LPX_K_TOLBND,primalTolerance_) ;
-    lpx_set_obj_coef(lp_,0,objOffset_) ;
-    lpx_set_prob_name(lp_,const_cast<char *>(probName_.c_str())) ;
-    lpx_set_int_parm(lp_,LPX_K_PRESOL,presolVal) ;
-    lpx_set_int_parm(lp_,LPX_K_DUAL,usedualVal) ;
-    lpx_set_int_parm(lp_,LPX_K_SCALE,scaleVal) ;
-    lpx_set_int_parm(lp_,LPX_K_MSGLEV,logVal) ;
-    messageHandler()->setLogLevel(logVal) ; }
+    { simplexParams_.obj_ll = dualObjectiveLimit_ ;
+      simplexParams_.obj_ul = primalObjectiveLimit_ ; }
+    simplexParams_.tol_dj = dualTolerance_ ;
+    simplexParams_.tol_bnd = primalTolerance_ ;
+    glp_set_obj_coef(lp_,0,objOffset_) ;
+    glp_set_prob_name(lp_,const_cast<char *>(probName_.c_str())) ; }
 
   freeCachedData(OGSI::KEEPCACHED_NONE) ;
 
@@ -2617,7 +2603,7 @@ void OGSI::loadProblem (const CoinPacked
       addCol(reqdBySunCC,collb[j],colub[j],obj[j]) ; }
     // Make sure there are enough rows 
     if (m > getNumRows())
-    { lpx_add_rows(lp_,m-getNumRows()) ; }
+    { glp_add_rows(lp_,m-getNumRows()) ; }
     for (i = 0 ; i < m ; i++)
     { setRowBounds(i,rowlb[i],rowub[i]) ; } }
   else
@@ -2626,7 +2612,7 @@ void OGSI::loadProblem (const CoinPacked
       addRow(reqdBySunCC,rowlb[i],rowub[i]) ; }
     // Make sure there are enough columns
     if (n > getNumCols())
-    { lpx_add_cols(lp_,n-getNumCols()) ; }
+    { glp_add_cols(lp_,n-getNumCols()) ; }
     for (j = 0 ; j < n ; j++)
     { setColBounds(j,collb[j],colub[j]) ;
       setObjCoeff(j,obj[j]) ; } }
@@ -2731,11 +2717,11 @@ OGSI::loadProblem(const int numcols, con
   LPX *model = getMutableModelPtr();
   double inf = getInfinity();
 
-  // Can't send 0 to lpx_add_xxx
+  // Can't send 0 to glp_add_xxx
   if (numcols > 0)
-    lpx_add_cols( model, numcols );
+    glp_add_cols( model, numcols );
   if (numrows > 0)
-    lpx_add_rows( model, numrows );
+    glp_add_rows( model, numrows );
 
   // How many elements?  Column-major, so indices of start are columns
   int numelem = start[ numcols ];
@@ -2756,7 +2742,7 @@ OGSI::loadProblem(const int numcols, con
   {
 	setColBounds( i, collb ? collb[i]:0.0, 
 		    colub ? colub[i]:inf );
-	lpx_set_mat_col( model, i+1, start[i+1]-start[i], &(index_adj[start[i]]), &(value_adj[start[i]]) );
+	glp_set_mat_col( model, i+1, start[i+1]-start[i], &(index_adj[start[i]]), &(value_adj[start[i]]) );
     setObjCoeff( i, obj ? obj[i]:0.0 );
   }
   int j;
@@ -2823,7 +2809,7 @@ void OGSI::writeMps( const char * filena
 	std::string f( filename );
 	std::string e( extension );
 	std::string fullname = f + "." + e;
-	lpx_write_mps( getMutableModelPtr(), const_cast<char*>( fullname.c_str() ));
+	glp_write_mps( getMutableModelPtr(), GLP_MPS_FILE, NULL, const_cast<char*>( fullname.c_str() ));
 #else
 	// Fall back on native MPS writer.  
 	// These few lines of code haven't been tested. 2004/10/15
@@ -2996,17 +2982,17 @@ void OGSI::applyColCut( const OsiColCut
             // update cached version as well
             collower_[column] = lower;
             if( lower == upper )
-              type = LPX_FX;
+              type = GLP_FX;
             else if( lower > -inf && upper < inf )
-              type = LPX_DB;
+              type = GLP_DB;
             else if( lower > -inf )
-              type = LPX_LO;
+              type = GLP_LO;
             else if( upper < inf)
-              type = LPX_UP;
+              type = GLP_UP;
             else
-              type = LPX_FR;
+              type = GLP_FR;
             
-            lpx_set_col_bnds( getMutableModelPtr(), column+1, type, lower, upper );
+            glp_set_col_bnds( getMutableModelPtr(), column+1, type, lower, upper );
           }
         }
         // lower bounds
@@ -3018,17 +3004,17 @@ void OGSI::applyColCut( const OsiColCut
             // update cached version as well
             colupper_[column] = upper;
             if( lower == upper )
-              type = LPX_FX;
+              type = GLP_FX;
             else if( lower > -inf && upper < inf )
-              type = LPX_DB;
+              type = GLP_DB;
             else if( lower > -inf )
-              type = LPX_LO;
+              type = GLP_LO;
             else if( upper < inf)
-              type = LPX_UP;
+              type = GLP_UP;
             else
-              type = LPX_FR;
+              type = GLP_FR;
             
-            lpx_set_col_bnds( getMutableModelPtr(), column+1, type, lower, upper );
+            glp_set_col_bnds( getMutableModelPtr(), column+1, type, lower, upper );
           }
         }
 #endif
@@ -3095,25 +3081,24 @@ void OGSI::gutsOfCopy (const OsiGlpkSolv
   held up on the parent OSI object, so we don't need to worry about copying
   them.
 */
-  intParam = lpx_get_int_parm(srclpx,LPX_K_PRESOL) ;
-  lpx_set_int_parm(lpx,LPX_K_PRESOL,intParam) ;
-  intParam = lpx_get_int_parm(srclpx,LPX_K_DUAL) ;
-  lpx_set_int_parm(lpx,LPX_K_DUAL,intParam) ;
-  intParam = lpx_get_int_parm(srclpx,LPX_K_SCALE) ;
-  lpx_set_int_parm(lpx,LPX_K_SCALE,intParam) ;
+  intoptParams_.presolve = source.intoptParams_.presolve;
+  simplexParams_.presolve = source.simplexParams_.presolve;
+  simplexParams_.meth = source.simplexParams_.meth;
+  scaleFlags_ = source.scaleFlags_;
 /*
   Printing is a bit more complicated. Pull the parameter and set the log
   level in the message handler and set the print parameter in glpk.
 */
-  intParam = lpx_get_int_parm(srclpx,LPX_K_MSGLEV) ;
-  lpx_set_int_parm(lpx,LPX_K_MSGLEV,intParam) ;
-  messageHandler()->setLogLevel(intParam) ;
-
-# ifdef LPX_K_USECUTS
-  intParam=lpx_get_int_parm(lp_,LPX_K_USECUTS);
-  lpx_set_int_parm(lp_,LPX_K_USECUTS,intParam);
-# endif
+  simplexParams_.msg_lev = source.simplexParams_.msg_lev;
+  intoptParams_.msg_lev = source.intoptParams_.msg_lev;
+  messageHandler()->setLogLevel(simplexParams_.msg_lev) ;
+
+  intoptParams_.mir_cuts = source.intoptParams_.mir_cuts;
+  intoptParams_.gmi_cuts = source.intoptParams_.gmi_cuts;
+  intoptParams_.cov_cuts = source.intoptParams_.cov_cuts;
+  intoptParams_.clq_cuts = source.intoptParams_.clq_cuts;
   
+  glp_scale_prob(lp_, scaleFlags_);
 /*
   Now --- do we have a problem loaded? If not, we're done.
 */
@@ -3164,22 +3149,22 @@ void OGSI::gutsOfCopy (const OsiGlpkSolv
   nonsense, then don't bother. Once we've copied the status into the new lpx
   object, do the warm-up.
 */
-  if (lpx_get_status(srclpx) != LPX_UNDEF)
+  if (glp_get_status(srclpx) != GLP_UNDEF)
   { for (j = 1 ; j <= n ; j++)
-    { int statj = lpx_get_col_stat(srclpx,j) ;
-      lpx_set_col_stat(lpx,j,statj) ; }
+    { int statj = glp_get_col_stat(srclpx,j) ;
+      glp_set_col_stat(lpx,j,statj) ; }
     for (i = 1 ; i <= m ; i++)
-    { int stati = lpx_get_row_stat(srclpx,i) ;
-      lpx_set_row_stat(lpx,i,stati) ; }
+    { int stati = glp_get_row_stat(srclpx,i) ;
+      glp_set_row_stat(lpx,i,stati) ; }
 
 #ifndef NDEBUG
-    int retval = lpx_warm_up(lpx) ;
+    int retval = glp_warm_up(lpx) ;
 #endif
 #   if OGSI_TRACK_SOLVERS > 1
     std::cout
-      << "    lpx_warm_up returns " << retval << "." << std::endl ;
+      << "    glp_warm_up returns " << retval << "." << std::endl ;
 #   endif
-    assert(retval == LPX_E_OK) ; }
+    assert(retval == 0) ; }
 
   return ; }
 
@@ -3232,26 +3217,28 @@ void OGSI::gutsOfConstructor()
   isObjUpperLimitReached_ = false ;
   isFeasible_ = false;
 
-  lp_ = lpx_create_prob();
+  lp_ = glp_create_prob();
   assert( lp_ != NULL );
-  // Make all problems MIPs.  See note at top of file.
-  lpx_set_class( lp_, LPX_MIP );
 
+  glp_init_smcp(&simplexParams_);
+  glp_init_iocp(&intoptParams_);
+  scaleFlags_ = GLP_SF_EQ;
+  glp_scale_prob(lp_, scaleFlags_);
   // Push OSI parameters down into LPX object.
-  lpx_set_int_parm(lp_,LPX_K_ITLIM,maxIteration_) ; 
+  simplexParams_.it_lim = maxIteration_;
 
   if (getObjSense() == 1.0)				// minimization
-  { lpx_set_real_parm(lp_,LPX_K_OBJUL,dualObjectiveLimit_) ;
-    lpx_set_real_parm(lp_,LPX_K_OBJLL,primalObjectiveLimit_) ; }
+  { simplexParams_.obj_ul = dualObjectiveLimit_ ;
+    simplexParams_.obj_ll = primalObjectiveLimit_ ; }
   else						// maximization
-  { lpx_set_real_parm(lp_,LPX_K_OBJLL,dualObjectiveLimit_) ;
-    lpx_set_real_parm(lp_,LPX_K_OBJUL,-primalObjectiveLimit_) ; }
-  lpx_set_real_parm(lp_,LPX_K_TOLDJ,dualTolerance_) ;
-  lpx_set_real_parm(lp_,LPX_K_TOLBND,primalTolerance_) ;
+  { simplexParams_.obj_ll = dualObjectiveLimit_ ;
+    simplexParams_.obj_ul = -primalObjectiveLimit_ ; }
+  simplexParams_.tol_dj = dualTolerance_;
+  simplexParams_.tol_bnd = primalTolerance_;
 
-  lpx_set_obj_coef(lp_,0,objOffset_) ;
+  glp_set_obj_coef(lp_,0,objOffset_) ;
 
-  lpx_set_prob_name(lp_,const_cast<char *>(probName_.c_str())) ;
+  glp_set_prob_name(lp_,const_cast<char *>(probName_.c_str())) ;
 
 /* Stefan: with the new simplex algorithm in Glpk 4.31, some netlib instances (e.g., dfl001)
    take very long or get into a cycle.
@@ -3264,22 +3251,16 @@ void OGSI::gutsOfConstructor()
   Printing is a bit more complicated. Set the log level in the handler and set
   the print parameter in glpk.
 */
-  lpx_set_int_parm(lp_,LPX_K_MSGLEV,1) ;
-  messageHandler()->setLogLevel(1) ;
+  simplexParams_.msg_lev = intoptParams_.msg_lev = GLP_MSG_ERR ;
+  messageHandler()->setLogLevel(GLP_MSG_ERR) ;
   
 /*
-  Enable cuts if they're available. This is a bit of a pain,
-  as the interface has changed since it was first introduced in 4.9.
-  LPX_K_USECUTS appears in 4.9; the parameter value
-  appears to be unused in this version. LPX_C_ALL appears in 4.10.
-*/
-# ifdef LPX_K_USECUTS
-# ifdef LPX_C_ALL
-  lpx_set_int_parm(lp_,LPX_K_USECUTS,LPX_C_ALL) ;
-# else
-  lpx_set_int_parm(lp_,LPX_K_USECUTS,0) ;
-# endif
-# endif
+  Enable cuts if they're available.
+*/
+  intoptParams_.mir_cuts = GLP_ON;
+  intoptParams_.gmi_cuts = GLP_ON;
+  intoptParams_.cov_cuts = GLP_ON;
+  intoptParams_.clq_cuts = GLP_ON;
 }
 
 //-----------------------------------------------------------------------------
@@ -3288,7 +3269,7 @@ void OGSI::gutsOfDestructor()
 {
 	if( lp_ != NULL )
 	{
-		lpx_delete_prob( lp_ );
+		glp_delete_prob( lp_ );
 		lp_=NULL;
 		freeAllMemory();
 	}
@@ -3408,7 +3389,7 @@ void OGSI::freeAllMemory()
 void OGSI::setObjName (std::string name)
 
 { OsiSolverInterface::setObjName(name) ;
-  lpx_set_obj_name(lp_,const_cast<char *>(name.c_str())) ; }
+  glp_set_obj_name(lp_,const_cast<char *>(name.c_str())) ; }
 
 /*!
   Set a row name. Make sure both glpk and OSI see the same name.
@@ -3431,7 +3412,7 @@ void OGSI::setRowName (int ndx, std::str
   Set the name in the OSI base, then in the consys structure.
 */
   OsiSolverInterface::setRowName(ndx,name) ;
-  lpx_set_row_name(lp_,ndx+1,const_cast<char *>(name.c_str())) ;
+  glp_set_row_name(lp_,ndx+1,const_cast<char *>(name.c_str())) ;
 
   return ; }
 
@@ -3456,7 +3437,7 @@ void OGSI::setColName (int ndx, std::str
   Set the name in the OSI base, then in the consys structure.
 */
   OsiSolverInterface::setColName(ndx,name) ;
-  lpx_set_col_name(lp_,ndx+1,const_cast<char *>(name.c_str())) ;
+  glp_set_col_name(lp_,ndx+1,const_cast<char *>(name.c_str())) ;
 
   return ; }
 
--- Osi-0.106.10/Osi/src/OsiGlpk/OsiGlpkSolverInterface.hpp.orig	2013-04-06 14:50:19.000000000 +0200
+++ Osi-0.106.10/Osi/src/OsiGlpk/OsiGlpkSolverInterface.hpp	2014-12-03 20:33:20.066812529 +0100
@@ -768,6 +768,9 @@ private:
   //@{
   /// GPLK model represented by this class instance
   mutable LPX* lp_;
+  glp_iocp intoptParams_;
+  glp_smcp simplexParams_;
+  int scaleFlags_;
   
   /// number of GLPK instances currently in use (counts only those created by OsiGlpk) 
   static unsigned int numInstances_;