diff --git a/DESCRIPTION b/DESCRIPTION
new file mode 100644
index 0000000000000000000000000000000000000000..75c2b60a064e7d30b02a62a09415b9f3f204f458
--- /dev/null
+++ b/DESCRIPTION
@@ -0,0 +1,19 @@
+Package: glpkAPI
+Type: Package
+Title: R Interface to C API of GLPK
+Version: 1.2.11
+Date: 2014-11-16
+Authors@R: c(person("Gabriel", "Gelius-Dietrich", role = c("aut", "cre"), email = "geliudie@uni-duesseldorf.de"))
+Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+Depends: R (>= 2.6.0)
+Imports: methods
+Description: R Interface to C API of GLPK, needs GLPK Version >= 4.42
+SystemRequirements: GLPK (>= 4.42)
+License: GPL-3
+LazyLoad: yes
+Collate: generics.R glpk_ptrClass.R glpk.R glpkAPI.R zzz.R
+Packaged: 2014-11-16 17:16:33 UTC; gabriel
+Author: Gabriel Gelius-Dietrich [aut, cre]
+NeedsCompilation: yes
+Repository: CRAN
+Date/Publication: 2014-11-16 22:12:16
diff --git a/NAMESPACE b/NAMESPACE
new file mode 100644
index 0000000000000000000000000000000000000000..662f82614c5ebee40699e33b4ad9dbfab0e5f8b1
--- /dev/null
+++ b/NAMESPACE
@@ -0,0 +1,318 @@
+useDynLib(glpkAPI)
+
+import(methods)
+
+exportClass("glpkPtr")
+
+export(
+# methods
+"glpkPointer",
+"glpkPtrType",
+"glpkPtrType<-",
+"isNULLpointerGLPK",
+"isGLPKpointer",
+"isTRWKSpointer",
+# function names
+addColsGLPK,
+addRowsGLPK,
+advBasisGLPK,
+bfExistsGLPK,
+bfUpdatedGLPK,
+checkDupGLPK,
+copyProbGLPK,
+cpxBasisGLPK,
+createIndexGLPK,
+delColsGLPK,
+deleteIndexGLPK,
+delProbGLPK,
+delRowsGLPK,
+eraseProbGLPK,
+factorizeGLPK,
+findColGLPK,
+findRowGLPK,
+getBfcpGLPK,
+getBheadGLPK,
+getCbindGLPK,
+getColDualGLPK,
+getColDualIptGLPK,
+getColKindGLPK,
+getColLowBndGLPK,
+getColNameGLPK,
+getColPrimGLPK,
+getColPrimIptGLPK,
+getColsDualGLPK,
+getColsDualIptGLPK,
+getColsKindGLPK,
+getColsLowBndsGLPK,
+getColsPrimGLPK,
+getColsPrimIptGLPK,
+getColsStatGLPK,
+getColStatGLPK,
+getColsUppBndsGLPK,
+getColTypeGLPK,
+getColUppBndGLPK,
+getDualStatGLPK,
+getInteriorParmGLPK,
+getMatColGLPK,
+getMatRowGLPK,
+getMIPParmGLPK,
+getNumBinGLPK,
+getNumColsGLPK,
+getNumIntGLPK,
+getNumNnzGLPK,
+getNumRowsGLPK,
+getObjCoefGLPK,
+getObjCoefsGLPK,
+getObjDirGLPK,
+getObjNameGLPK,
+getObjValGLPK,
+getObjValIptGLPK,
+getPrimStatGLPK,
+getProbNameGLPK,
+getRbindGLPK,
+getRiiGLPK,
+getRowDualGLPK,
+getRowDualIptGLPK,
+getRowLowBndGLPK,
+getRowNameGLPK,
+getRowPrimGLPK,
+getRowPrimIptGLPK,
+getRowsDualGLPK,
+getRowsDualIptGLPK,
+getRowsLowBndsGLPK,
+getRowsPrimGLPK,
+getRowsPrimIptGLPK,
+getRowsStatGLPK,
+getRowStatGLPK,
+getRowsTypesGLPK,
+getRowsUppBndsGLPK,
+getRowTypeGLPK,
+getRowUppBndGLPK,
+getSimplexParmGLPK,
+getSjjGLPK,
+getSolStatGLPK,
+getSolStatIptGLPK,
+getUnbndRayGLPK,
+initProbGLPK,
+loadMatrixGLPK,
+mipColsValGLPK,
+mipColValGLPK,
+mipObjValGLPK,
+mipRowsValGLPK,
+mipRowValGLPK,
+mipStatusGLPK,
+mplAllocWkspGLPK,
+mplBuildProbGLPK,
+mplFreeWkspGLPK,
+mplGenerateGLPK,
+mplPostsolveGLPK,
+mplReadDataGLPK,
+mplReadModelGLPK,
+printIptGLPK,
+printMIPGLPK,
+printRangesGLPK,
+printSolGLPK,
+readIptGLPK,
+readLPGLPK,
+readMIPGLPK,
+readMPSGLPK,
+readProbGLPK,
+readSolGLPK,
+return_codeGLPK,
+scaleProbGLPK,
+setBfcpGLPK,
+setColBndGLPK,
+setColKindGLPK,
+setColNameGLPK,
+setColsBndsGLPK,
+setColsBndsObjCoefsGLPK,
+setColsKindGLPK,
+setColsNamesGLPK,
+setColStatGLPK,
+setDefaultIptParmGLPK,
+setDefaultMIPParmGLPK,
+setDefaultSmpParmGLPK,
+setInteriorParmGLPK,
+setMatColGLPK,
+setMatRowGLPK,
+setMIPParmGLPK,
+setObjCoefGLPK,
+setObjCoefsGLPK,
+setObjDirGLPK,
+setObjNameGLPK,
+setProbNameGLPK,
+setRhsZeroGLPK,
+setRiiGLPK,
+setRowBndGLPK,
+setRowNameGLPK,
+setRowsBndsGLPK,
+setRowsNamesGLPK,
+setRowStatGLPK,
+setSimplexParmGLPK,
+setSjjGLPK,
+solveInteriorGLPK,
+solveMIPGLPK,
+solveSimplexExactGLPK,
+solveSimplexGLPK,
+sortMatrixGLPK,
+status_codeGLPK,
+stdBasisGLPK,
+termOutGLPK,
+unscaleProbGLPK,
+versionGLPK,
+warmUpGLPK,
+writeIptGLPK,
+writeLPGLPK,
+writeMIPGLPK,
+writeMPSGLPK,
+writeProbGLPK,
+writeSolGLPK,
+# parameter variable names
+BINARIZE,
+BR_TECH,
+BT_TECH,
+CB_SIZE,
+CLQ_CUTS,
+COV_CUTS,
+EPS_TOL,
+FP_HEUR,
+GLP_BF_BG,
+GLP_BF_FT,
+GLP_BF_GR,
+GLP_BR_DTH,
+GLP_BR_FFV,
+GLP_BR_LFV,
+GLP_BR_MFV,
+GLP_BR_PCH,
+GLP_BS,
+GLP_BT_BFS,
+GLP_BT_BLB,
+GLP_BT_BPH,
+GLP_BT_DFS,
+GLP_BV,
+GLP_CV,
+GLP_DB,
+GLP_DN_BRNCH,
+GLP_DUAL,
+GLP_DUALP,
+GLP_EBADB,
+GLP_EBOUND,
+GLP_ECOND,
+GLP_EDATA,
+GLP_EFAIL,
+GLP_EINSTAB,
+GLP_EITLIM,
+GLP_EMIPGAP,
+GLP_ENOCVG,
+GLP_ENODFS,
+GLP_ENOFEAS,
+GLP_ENOPFS,
+GLP_EOBJLL,
+GLP_EOBJUL,
+GLP_ERANGE,
+GLP_EROOT,
+GLP_ESING,
+GLP_ESTOP,
+GLP_ETMLIM,
+GLP_FEAS,
+GLP_FR,
+GLP_FX,
+GLP_IBINGO,
+GLP_IBRANCH,
+GLP_ICUTGEN,
+GLP_IHEUR,
+GLP_INFEAS,
+GLP_IPREPRO,
+GLP_IPT,
+GLP_IROWGEN,
+GLP_ISELECT,
+GLP_IV,
+GLP_KKT_CS,
+GLP_KKT_DB,
+GLP_KKT_DE,
+GLP_KKT_PB,
+GLP_KKT_PE,
+GLP_LO,
+GLP_MAX,
+GLP_MIN,
+GLP_MIP,
+GLP_MPS_DECK,
+GLP_MPS_FILE,
+GLP_MSG_ALL,
+GLP_MSG_DBG,
+GLP_MSG_ERR,
+GLP_MSG_OFF,
+GLP_MSG_ON,
+GLP_NF,
+GLP_NL,
+GLP_NO_BRNCH,
+GLP_NOFEAS,
+GLP_NS,
+GLP_NU,
+GLP_OFF,
+GLP_ON,
+GLP_OPT,
+GLP_ORD_AMD,
+GLP_ORD_NONE,
+GLP_ORD_QMD,
+GLP_ORD_SYMAMD,
+GLP_PP_ALL,
+GLP_PP_NONE,
+GLP_PP_ROOT,
+GLP_PRIMAL,
+GLP_PT_PSE,
+GLP_PT_STD,
+GLP_RF_CLQ,
+GLP_RF_COV,
+GLP_RF_CUT,
+GLP_RF_GMI,
+GLP_RF_LAZY,
+GLP_RF_MIR,
+GLP_RF_REG,
+GLP_RT_HAR,
+GLP_RT_STD,
+GLP_SF_2N,
+GLP_SF_AUTO,
+GLP_SF_EQ,
+GLP_SF_GM,
+GLP_SF_SKIP,
+GLP_SOL,
+GLP_UNBND,
+GLP_UNDEF,
+GLP_UP_BRNCH,
+GLP_UP,
+CB_FUNC,
+GMI_CUTS,
+IT_LIM,
+LU_SIZE,
+MAX_GRO,
+METH,
+MIP_GAP,
+MIR_CUTS,
+MSG_LEV,
+NFS_MAX,
+NRS_MAX,
+OBJ_LL,
+OBJ_UL,
+ORD_ALG,
+OUT_DLY,
+OUT_FRQ,
+PIV_LIM,
+PIV_TOL,
+PP_TECH,
+PRESOLVE,
+PRICING,
+R_TEST,
+RS_SIZE,
+SUHL,
+TM_LIM,
+TOL_BND,
+TOL_DJ,
+TOL_INT,
+TOL_OBJ,
+TOL_PIV,
+TYPE,
+UPD_TOL
+)
+
+
diff --git a/R/generics.R b/R/generics.R
new file mode 100644
index 0000000000000000000000000000000000000000..0f30659b425d93d2632d24fa5e8832aeef1f403f
--- /dev/null
+++ b/R/generics.R
@@ -0,0 +1,54 @@
+#------------------------------------------------------------------------------#
+#                             R interface to GLPK                              #
+#------------------------------------------------------------------------------#
+
+#  generics.R
+#  R interface to GLPK.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of glpkAPI.
+#
+#  GlpkAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  GlpkAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with glpkAPI  If not, see <http://www.gnu.org/licenses/>.
+
+
+#------------------------------------------------------------------------------#
+#                                   generics                                   #
+#------------------------------------------------------------------------------#
+
+setGeneric(name = "glpkPointer",
+           def  = function(object) { standardGeneric("glpkPointer") }
+)
+
+setGeneric(name = "glpkPtrType",
+           def  = function(object) { standardGeneric("glpkPtrType") }
+)
+setGeneric(name = "glpkPtrType<-",
+           def  = function(object, value) { standardGeneric("glpkPtrType<-") }
+)
+
+setGeneric(name = "isNULLpointerGLPK",
+           def  = function(object) { standardGeneric("isNULLpointerGLPK") }
+)
+
+setGeneric(name = "isGLPKpointer",
+           def  = function(object) { standardGeneric("isGLPKpointer") }
+)
+
+setGeneric(name = "isTRWKSpointer",
+           def  = function(object) { standardGeneric("isTRWKSpointer") }
+)
diff --git a/R/glpk.R b/R/glpk.R
new file mode 100644
index 0000000000000000000000000000000000000000..5efe87d5e31afea727dbc65f8befc60c9d36842d
--- /dev/null
+++ b/R/glpk.R
@@ -0,0 +1,315 @@
+#------------------------------------------------------------------------------#
+#                             R interface to GLPK                              #
+#------------------------------------------------------------------------------#
+
+#  glpk.R
+#  R interface to GLPK.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of glpkAPI.
+#
+#  GlpkAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  GlpkAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with glpkAPI  If not, see <http://www.gnu.org/licenses/>.
+
+
+#------------------------------------------------------------------------------#
+#                       global variables (from glpk.h [4.42])                  #
+#------------------------------------------------------------------------------#
+
+
+# simplex integer parameters (not from glpk.h, self defined)
+MSG_LEV  <- 101
+METH     <- 102
+PRICING  <- 103
+R_TEST   <- 104
+IT_LIM   <- 105
+TM_LIM   <- 106
+OUT_FRQ  <- 107
+OUT_DLY  <- 108
+PRESOLVE <- 109
+
+# simplex double parameters (not from glpk.h, self defined)
+TOL_BND  <- 201
+TOL_DJ   <- 202
+TOL_PIV  <- 203
+OBJ_LL   <- 204
+OBJ_UL   <- 205
+
+# additional interior integer parameters (not from glpk.h, self defined)
+ORD_ALG  <- 301
+
+# basis factorization integer control parameters (not from glpk.h, self defined)
+TYPE     <- 401
+LU_SIZE  <- 402
+PIV_LIM  <- 403
+SUHL     <- 404
+NFS_MAX  <- 405
+NRS_MAX  <- 406
+RS_SIZE  <- 407
+
+# basis factorization double control parameters (not from glpk.h, self defined)
+PIV_TOL  <- 501
+EPS_TOL  <- 502
+MAX_GRO  <- 503
+UPD_TOL  <- 504
+
+# MIP integer parameters (not from glpk.h, self defined)
+BR_TECH  <- 601
+BT_TECH  <- 602
+PP_TECH  <- 603
+FP_HEUR  <- 604
+GMI_CUTS <- 605
+MIR_CUTS <- 606
+COV_CUTS <- 607
+CLQ_CUTS <- 608
+CB_SIZE  <- 609
+BINARIZE <- 610
+
+# MIP double parameters (not from glpk.h, self defined)
+TOL_INT  <- 701
+TOL_OBJ  <- 702
+MIP_GAP  <- 703
+
+# use callback routine glpkCallback in MIP
+CB_FUNC  <- 651
+
+
+#------------------------------------------------------------------------------#
+
+# LP/MIP problem object
+# optimization direction flag:
+GLP_MIN <- 1  # minimization
+GLP_MAX <- 2  # maximization
+
+# kind of structural variable:
+GLP_CV <- 1  # continuous variable
+GLP_IV <- 2  # integer variable
+GLP_BV <- 3  # binary variable
+
+# type of auxiliary/structural variable:
+GLP_FR <- 1  # free variable
+GLP_LO <- 2  # variable with lower bound
+GLP_UP <- 3  # variable with upper bound
+GLP_DB <- 4  # double-bounded variable
+GLP_FX <- 5  # fixed variable
+
+# status of auxiliary/structural variable:
+GLP_BS <- 1  # basic variable
+GLP_NL <- 2  # non-basic variable on lower bound
+GLP_NU <- 3  # non-basic variable on upper bound
+GLP_NF <- 4  # non-basic free variable
+GLP_NS <- 5  # non-basic fixed variable
+
+# scaling options:
+GLP_SF_GM   <- 0x01  # perform geometric mean scaling
+GLP_SF_EQ   <- 0x10  # perform equilibration scaling
+GLP_SF_2N   <- 0x20  # round scale factors to power of two
+GLP_SF_SKIP <- 0x40  # skip if problem is well scaled
+GLP_SF_AUTO <- 0x80  # choose scaling options automatically
+
+# solution indicator:
+GLP_SOL <- 1  # basic solution
+GLP_IPT <- 2  # interior-point solution
+GLP_MIP <- 3  # mixed integer solution
+
+# solution status:
+GLP_UNDEF  <- 1  # solution is undefined
+GLP_FEAS   <- 2  # solution is feasible
+GLP_INFEAS <- 3  # solution is infeasible
+GLP_NOFEAS <- 4  # no feasible solution exists
+GLP_OPT    <- 5  # solution is optimal
+GLP_UNBND  <- 6  # solution is unbounded
+
+
+#------------------------------------------------------------------------------#
+# basis factorization control parameters
+# type
+GLP_BF_FT  <- 0x01  # LUF + Forrest-Tomlin
+GLP_BF_BG  <- 0x02  # LUF + Schur compl. + Bartels-Golub
+GLP_BF_GR  <- 0x03  # LUF + Schur compl. + Givens rotation
+GLP_BF_LUF <- 0x00  # plain LU-factorization
+GLP_BF_BTF <- 0x10  # block triangular LU-factorization
+
+#------------------------------------------------------------------------------#
+# simplex method control parameters
+# msg_lev           # message level:
+GLP_MSG_OFF <- 0    # no output
+GLP_MSG_ERR <- 1    # warning and error messages only
+GLP_MSG_ON  <- 2    # normal output
+GLP_MSG_ALL <- 3    # full output
+GLP_MSG_DBG <- 4    # debug output
+
+# meth              # simplex method option:
+GLP_PRIMAL <- 1     # use primal simplex
+GLP_DUALP  <- 2     # use dual; if it fails, use primal
+GLP_DUAL   <- 3     # use dual simplex
+
+# pricing           # pricing technique:
+GLP_PT_STD <- 0x11  # standard (Dantzig rule)
+GLP_PT_PSE <- 0x22  # projected steepest edge
+
+# r_test            # ratio test technique:
+GLP_RT_STD <- 0x11  # standard (textbook)
+GLP_RT_HAR <- 0x22  # two-pass Harris' ratio test
+
+
+#------------------------------------------------------------------------------#
+# interior-point solver control parameters
+# ord_alg            # ordering algorithm:
+GLP_ORD_NONE   <- 0  # natural (original) ordering
+GLP_ORD_QMD    <- 1  # quotient minimum degree (QMD)
+GLP_ORD_AMD    <- 2  # approx. minimum degree (AMD)
+GLP_ORD_SYMAMD <- 3  # approx. minimum degree (SYMAMD)
+
+
+#------------------------------------------------------------------------------#
+# integer optimizer control parameters
+# br_tech        # branching technique:
+GLP_BR_FFV <- 1  # first fractional variable
+GLP_BR_LFV <- 2  # last fractional variable
+GLP_BR_MFV <- 3  # most fractional variable
+GLP_BR_DTH <- 4  # heuristic by Driebeck and Tomlin
+GLP_BR_PCH <- 5  # hybrid pseudocost heuristic
+
+# bt_tech        # backtracking technique:
+GLP_BT_DFS <- 1  # depth first search
+GLP_BT_BFS <- 2  # breadth first search
+GLP_BT_BLB <- 3  # best local bound
+GLP_BT_BPH <- 4  # best projection heuristic
+
+# pp_tech         # preprocessing technique:
+GLP_PP_NONE <- 0  # disable preprocessing
+GLP_PP_ROOT <- 1  # preprocessing only on root level
+GLP_PP_ALL  <- 2  # preprocessing on all levels
+
+
+#------------------------------------------------------------------------------#
+# additional row attributes
+# the row origin flag:
+GLP_RF_REG  <- 0  # regular constraint
+GLP_RF_LAZY <- 1  # "lazy" constraint
+GLP_RF_CUT  <- 2  # cutting plane constraint
+
+# the row class descriptor:
+# klass
+GLP_RF_GMI <- 1  # Gomory's mixed integer cut
+GLP_RF_MIR <- 2  # mixed integer rounding cut
+GLP_RF_COV <- 3  # mixed cover cut
+GLP_RF_CLQ <- 4  # clique cut
+
+
+#------------------------------------------------------------------------------#
+# enable/disable flag:
+GLP_ON  <- 1  # enable something
+GLP_OFF <- 0  # disable something
+
+
+#------------------------------------------------------------------------------#
+# reason codes:
+GLP_IROWGEN <- 0x01  # request for row generation
+GLP_IBINGO  <- 0x02  # better integer solution found
+GLP_IHEUR   <- 0x03  # request for heuristic solution
+GLP_ICUTGEN <- 0x04  # request for cut generation
+GLP_IBRANCH <- 0x05  # request for branching
+GLP_ISELECT <- 0x06  # request for subproblem selection
+GLP_IPREPRO <- 0x07  # request for preprocessing
+
+
+#------------------------------------------------------------------------------#
+# branch selection indicator:
+GLP_NO_BRNCH <- 0  # select no branch
+GLP_DN_BRNCH <- 1  # select down-branch
+GLP_UP_BRNCH <- 2  # select up-branch
+
+
+#------------------------------------------------------------------------------#
+# return codes:
+GLP_EBADB   <- 0x01  # invalid basis
+GLP_ESING   <- 0x02  # singular matrix
+GLP_ECOND   <- 0x03  # ill-conditioned matrix
+GLP_EBOUND  <- 0x04  # invalid bounds
+GLP_EFAIL   <- 0x05  # solver failed
+GLP_EOBJLL  <- 0x06  # objective lower limit reached
+GLP_EOBJUL  <- 0x07  # objective upper limit reached
+GLP_EITLIM  <- 0x08  # iteration limit exceeded
+GLP_ETMLIM  <- 0x09  # time limit exceeded
+GLP_ENOPFS  <- 0x0A  # no primal feasible solution
+GLP_ENODFS  <- 0x0B  # no dual feasible solution
+GLP_EROOT   <- 0x0C  # root LP optimum not provided
+GLP_ESTOP   <- 0x0D  # search terminated by application
+GLP_EMIPGAP <- 0x0E  # relative mip gap tolerance reached
+GLP_ENOFEAS <- 0x0F  # no primal/dual feasible solution
+GLP_ENOCVG  <- 0x10  # no convergence
+GLP_EINSTAB <- 0x11  # numerical instability
+GLP_EDATA   <- 0x12  # invalid data
+GLP_ERANGE  <- 0x13  # result out of range
+
+
+#------------------------------------------------------------------------------#
+# condition indicator:
+GLP_KKT_PE <- 1  # primal equalities
+GLP_KKT_PB <- 2  # primal bounds
+GLP_KKT_DE <- 3  # dual equalities
+GLP_KKT_DB <- 4  # dual bounds
+GLP_KKT_CS <- 5  # complementary slackness
+
+
+#------------------------------------------------------------------------------#
+# MPS file format:
+GLP_MPS_DECK <- 1  # fixed (ancient)
+GLP_MPS_FILE <- 2  # free (modern)
+
+
+#------------------------------------------------------------------------------#
+
+# return codes of glpk optimizations
+return_codeGLPK <- function(code) {
+    if (code == 0)                { return( "solution process was successful" ) }
+    else if (code == GLP_EBADB)   { return( "invalid basis" ) }
+    else if (code == GLP_ESING)   { return( "singular matrix" ) }
+    else if (code == GLP_ECOND)   { return( "ill-conditioned matrix" ) }
+    else if (code == GLP_EBOUND)  { return( "invalid bounds" ) }
+    else if (code == GLP_EFAIL)   { return( "solver failed" ) }
+    else if (code == GLP_EOBJLL)  { return( "objective lower limit reached" ) }
+    else if (code == GLP_EOBJUL)  { return( "objective upper limit reached" ) }
+    else if (code == GLP_EITLIM)  { return( "iteration limit exceeded" ) }
+    else if (code == GLP_ETMLIM)  { return( "time limit exceeded" ) }
+    else if (code == GLP_ENOPFS)  { return( "no primal feasible solution" ) }
+    else if (code == GLP_ENODFS)  { return( "no dual feasible solution" ) }
+    else if (code == GLP_EROOT)   { return( "root LP optimum not provided" ) }
+    else if (code == GLP_ESTOP)   { return( "search terminated by application" ) }
+    else if (code == GLP_EMIPGAP) { return( "relative mip gap tolerance reached" ) }
+    else if (code == GLP_ENOFEAS) { return( "no primal/dual feasible solution" ) }
+    else if (code == GLP_ENOCVG)  { return( "no convergence" ) }
+    else if (code == GLP_EINSTAB) { return( "numerical instability" ) }
+    else if (code == GLP_EDATA)   { return( "invalid data" ) }
+    else if (code == GLP_ERANGE)  { return( "result out of range" ) }
+    else { return(paste("Failed to obtain solution, unknown error code:", code)) }
+}
+
+
+# solution status codes of glpk optimizations
+status_codeGLPK <- function(code) {
+    if (code == GLP_OPT)         { return( "solution is optimal" ) }
+    else if (code == GLP_UNDEF)  { return( "solution is undefined" ) }
+    else if (code == GLP_FEAS)   { return( "solution is feasible" ) }
+    else if (code == GLP_INFEAS) { return( "solution is infeasible" ) }
+    else if (code == GLP_NOFEAS) { return( "no feasible solution exists" ) }
+    else if (code == GLP_UNBND)  { return( "solution is unbounded" ) }
+    else { return(paste("unknown status code:", code)) }
+}
+
diff --git a/R/glpkAPI.R b/R/glpkAPI.R
new file mode 100644
index 0000000000000000000000000000000000000000..4aedd1889294338be00d8dff0d6eebc9e18c838f
--- /dev/null
+++ b/R/glpkAPI.R
@@ -0,0 +1,2291 @@
+#------------------------------------------------------------------------------#
+#                             R interface to GLPK                              #
+#------------------------------------------------------------------------------#
+
+#  glpkAPI.R
+#  R interface to GLPK.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of glpkAPI.
+#
+#  GlpkAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  GlpkAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with glpkAPI  If not, see <http://www.gnu.org/licenses/>.
+
+
+#------------------------------------------------------------------------------#
+#                              the interface                                   #
+#------------------------------------------------------------------------------#
+
+
+delProbGLPK <- function(lp) {
+
+    invisible(
+        .Call("delProb", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+eraseProbGLPK <- function(lp) {
+
+    invisible(
+        .Call("eraseProb", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+copyProbGLPK <- function(lp, clp, name = GLP_OFF) {
+
+    invisible(
+        .Call("copyProb", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              glpkPointer(clp),
+              as.integer(name)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+initProbGLPK <- function(ptrtype = "glpk_prob") {
+
+    lp <- .Call("initProb", PACKAGE = "glpkAPI",
+                as.character(ptrtype)
+          )
+
+    lpP <- glpk_Pointer(lp)
+
+    return(lpP)
+}
+
+
+#------------------------------------------------------------------------------#
+
+setProbNameGLPK <- function(lp, pname = NULL) {
+
+    if (is.null(pname)) {
+        Cpname <- as.null(pname)
+    }
+    else {
+        Cpname <- as.character(pname)
+    }
+
+    invisible(
+        .Call("setProbName", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              Cpname
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getProbNameGLPK <- function(lp) {
+
+    pname <- .Call("getProbName", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)
+             )
+
+    return(pname)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setObjNameGLPK <- function(lp, oname = NULL) {
+
+    if (is.null(oname)) {
+        Coname <- as.null(oname)
+    }
+    else {
+        Coname <- as.character(oname)
+    }
+
+    invisible(
+        .Call("setObjName", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              Coname
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getObjNameGLPK <- function(lp) {
+
+    oname <- .Call("getObjName", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)
+             )
+
+    return(oname)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+createIndexGLPK <- function(lp) {
+
+    invisible(
+        .Call("createIndex", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+deleteIndexGLPK <- function(lp) {
+
+    invisible(
+        .Call("deleteIndex", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setDefaultSmpParmGLPK <- function() {
+
+    invisible(.Call("setDefaultSmpParm", PACKAGE = "glpkAPI"))
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setDefaultIptParmGLPK <- function() {
+
+    invisible(.Call("setDefaultIptParm", PACKAGE = "glpkAPI"))
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setDefaultMIPParmGLPK <- function() {
+
+    invisible(.Call("setDefaultMIPParm", PACKAGE = "glpkAPI"))
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setSimplexParmGLPK <- function(parm, val) {
+
+    if (!identical(length(parm), length(val))) {
+        stop("Arguments 'parm' and 'val' must have the same length!")
+    }
+
+    indi <- which(parm > 100 & parm < 200)
+    indd <- which(parm > 200 & parm < 300)
+
+    npari <- length(indi)
+    npard <- length(indd)
+
+    if (npari == 0) {
+        parmi <- as.null(parm)
+        vali  <- as.null(val)
+    }
+    else {
+        parmi <- as.integer(parm[indi])
+        vali  <- as.integer(val[indi])
+    }
+
+    if (npard == 0) {
+        parmd <- as.null(parm)
+        vald  <- as.null(val)
+    }
+    else {
+        parmd <- as.integer(parm[indd])
+        vald  <- as.numeric(val[indd])
+    }
+
+    invisible(
+        .Call("setSimplexParm", PACKAGE = "glpkAPI",
+              as.integer(npari),
+              parmi,
+              vali,
+              as.integer(npard),
+              parmd,
+              vald
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setInteriorParmGLPK <- function(parm, val) {
+
+    if (!identical(length(parm), length(val))) {
+        stop("Arguments 'parm' and 'val' must have the same length!")
+    }
+
+    nparm <- length(parm)
+
+    invisible(
+        .Call("setInteriorParm", PACKAGE = "glpkAPI",
+              as.integer(nparm),
+              as.integer(parm),
+              as.integer(val)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setMIPParmGLPK <- function(parm, val) {
+
+    if (!identical(length(parm), length(val))) {
+        stop("Arguments 'parm' and 'val' must have the same length!")
+    }
+
+    indi <- which( (parm > 100 & parm < 200) | (parm > 600 & parm < 700) )
+    indd <- which(parm > 700 & parm < 800)
+
+    npari <- length(indi)
+    npard <- length(indd)
+
+    if (npari == 0) {
+        parmi <- as.null(parm)
+        vali  <- as.null(val)
+    }
+    else {
+        parmi <- as.integer(parm[indi])
+        vali  <- as.integer(val[indi])
+    }
+
+    if (npard == 0) {
+        parmd <- as.null(parm)
+        vald  <- as.null(val)
+    }
+    else {
+        parmd <- as.integer(parm[indd])
+        vald  <- as.numeric(val[indd])
+    }
+
+    invisible(
+        .Call("setMIPParm", PACKAGE = "glpkAPI",
+              as.integer(npari),
+              parmi,
+              vali,
+              as.integer(npard),
+              parmd,
+              vald
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getSimplexParmGLPK <- function() {
+
+    parmS <- .Call("getSimplexParm", PACKAGE = "glpkAPI")
+
+    return(parmS)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getInteriorParmGLPK <- function() {
+
+    parmI <- .Call("getInteriorParm", PACKAGE = "glpkAPI")
+
+    return(parmI)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getMIPParmGLPK <- function() {
+
+    parmM <- .Call("getMIPParm", PACKAGE = "glpkAPI")
+
+    return(parmM)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setObjDirGLPK <- function(lp, lpdir) {
+
+    invisible(
+        .Call("setObjDir", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(lpdir)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getObjDirGLPK <- function(lp) {
+
+    lpdir <- .Call("getObjDir", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)
+                  )
+    return(lpdir)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+addRowsGLPK <- function(lp, nrows) {
+
+    frow <- .Call("addRows", PACKAGE = "glpkAPI",
+                  glpkPointer(lp),
+                  as.integer(nrows)
+             )
+    return(frow)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setRowNameGLPK <- function(lp, i, rname = NULL) {
+
+    if (is.null(rname)) {
+        Crname <- as.null(rname)
+    }
+    else {
+        Crname <- as.character(rname)
+    }
+
+    invisible(
+        .Call("setRowName", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i),
+              Crname
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setRowsNamesGLPK <- function(lp, i, rnames = NULL) {
+
+    if (is.null(rnames)) {
+        Crnames <- as.null(rnames)
+    }
+    else {
+        Crnames <- as.character(rnames)
+    }
+
+    invisible(
+        .Call("setRowsNames", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i),
+              Crnames
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowNameGLPK <- function(lp, i) {
+
+    rname <- .Call("getRowName", PACKAGE = "glpkAPI",
+                   glpkPointer(lp),
+                   as.integer(i)
+             )
+
+    return(rname)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+findRowGLPK <- function(lp, rname) {
+
+    rind <- .Call("findRow", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(rname)
+        )
+
+    return(rind)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+addColsGLPK <- function(lp, ncols) {
+
+    fcol <- .Call("addCols", PACKAGE = "glpkAPI",
+                  glpkPointer(lp),
+                  as.integer(ncols)
+             )
+
+    return(fcol)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setColNameGLPK <- function(lp, j, cname = NULL) {
+
+    if (is.null(cname)) {
+        Ccname <- as.null(cname)
+    }
+    else {
+        Ccname <- as.character(cname)
+    }
+
+    invisible(
+        .Call("setColName", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              Ccname
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setColsNamesGLPK <- function(lp, j, cnames = NULL) {
+
+    if (is.null(cnames)) {
+        Ccnames <- as.null(cnames)
+    }
+    else {
+        Ccnames <- as.character(cnames)
+    }
+
+    invisible(
+        .Call("setColsNames", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              Ccnames
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColNameGLPK <- function(lp, j) {
+
+    cname <- .Call("getColName", PACKAGE = "glpkAPI",
+                   glpkPointer(lp),
+                   as.integer(j)
+             )
+
+    return(cname)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+findColGLPK <- function(lp, cname) {
+
+    cind <- .Call("findCol", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(cname)
+        )
+
+    return(cind)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getNumRowsGLPK <- function(lp) {
+
+    nrows <- .Call("getNumRows", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)
+             )
+    return(nrows)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getNumColsGLPK <- function(lp) {
+
+    ncols <- .Call("getNumCols", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)
+                  )
+    return(ncols)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setColsBndsGLPK <- function(lp, j, lb, ub, type = NULL) {
+
+    if (is.null(type)) {
+        Ctype <- as.null(type)
+    }
+    else {
+        Ctype <- as.integer(type)
+    }
+
+    invisible(
+        .Call("setColsBnds", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              Ctype,
+              as.numeric(lb),
+              as.numeric(ub)
+        )
+    )
+
+}
+
+
+
+#------------------------------------------------------------------------------#
+
+setColsBndsObjCoefsGLPK <- function(lp, j, lb, ub, obj_coef, type = NULL) {
+
+    if (is.null(type)) {
+        Ctype <- as.null(type)
+    }
+    else {
+        Ctype <- as.integer(type)
+    }
+
+    invisible(
+        .Call("setColsBndsObjCoefs", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              Ctype,
+              as.numeric(lb),
+              as.numeric(ub),
+              as.numeric(obj_coef)
+        )
+    )
+
+}
+
+#------------------------------------------------------------------------------#
+
+setColBndGLPK <- function(lp, j, type, lb, ub) {
+
+    invisible(
+        .Call("setColBnd", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              as.integer(type),
+              as.numeric(lb),
+              as.numeric(ub)
+        )
+    )
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColsLowBndsGLPK <- function(lp, j) {
+
+    lowbnd <- .Call("getColsLowBnds", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+
+    return(lowbnd)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColLowBndGLPK <- function(lp, j) {
+
+    lowbnd <- .Call("getColLowBnd", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+    return(lowbnd)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColsUppBndsGLPK <- function(lp, j) {
+
+    uppbnd <- .Call("getColsUppBnds", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+
+    return(uppbnd)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColUppBndGLPK <- function(lp, j) {
+
+    uppbnd <- .Call("getColUppBnd", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+
+    return(uppbnd)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setColKindGLPK <- function(lp, j, kind) {
+
+    invisible(
+        .Call("setColKind", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              as.integer(kind)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setColsKindGLPK <- function(lp, j, kind) {
+
+    invisible(
+        .Call("setColsKind", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              as.integer(kind)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColKindGLPK <- function(lp, j) {
+
+    kind <- .Call("getColKind", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+
+    return(kind)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColsKindGLPK <- function(lp, j) {
+
+    kind <- .Call("getColsKind", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+
+    return(kind)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getNumIntGLPK <- function(lp) {
+
+    num <- .Call("getNumInt", PACKAGE = "glpkAPI",
+                 glpkPointer(lp)
+            )
+
+    return(num)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getNumBinGLPK <- function(lp) {
+
+    num <- .Call("getNumBin", PACKAGE = "glpkAPI",
+                 glpkPointer(lp)
+            )
+
+    return(num)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setRowsBndsGLPK <- function(lp, i, lb, ub, type = NULL) {
+
+    if (is.null(type)) {
+        Ctype <- as.null(type)
+    }
+    else {
+        Ctype <- as.integer(type)
+    }
+
+    invisible(
+        .Call("setRowsBnds", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i),
+              Ctype,
+              as.numeric(lb),
+              as.numeric(ub)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setRhsZeroGLPK <- function(lp) {
+
+    invisible(
+        .Call("setRhsZero", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setRowBndGLPK <- function(lp, i, type, lb, ub) {
+
+    invisible(
+        .Call("setRowBnd", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i),
+              as.integer(type),
+              as.numeric(lb),
+              as.numeric(ub)
+        )
+    )
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowsLowBndsGLPK <- function(lp, i) {
+
+    lowbnd <- .Call("getRowsLowBnds", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i)
+        )
+
+    return(lowbnd)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowLowBndGLPK <- function(lp, i) {
+
+    lowbnd <- .Call("getRowLowBnd", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i)
+        )
+    return(lowbnd)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowsUppBndsGLPK <- function(lp, i) {
+
+    uppbnd <- .Call("getRowsUppBnds", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i)
+        )
+
+    return(uppbnd)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowUppBndGLPK <- function(lp, i) {
+
+    uppbnd <- .Call("getRowUppBnd", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i)
+        )
+    return(uppbnd)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowTypeGLPK <- function(lp, i) {
+
+    type <- .Call("getRowType", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i)
+        )
+
+    return(type)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowsTypesGLPK <- function(lp, i) {
+
+    type <- .Call("getRowsTypes", PACKAGE = "glpkAPI",
+                  glpkPointer(lp),
+                  as.integer(i)
+        )
+
+    return(type)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColTypeGLPK <- function(lp, j) {
+
+    type <- .Call("getColType", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+
+    return(type)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setObjCoefsGLPK <- function(lp, j, obj_coef) {
+
+    invisible(
+        .Call("setObjCoefs", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              as.numeric(obj_coef)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setObjCoefGLPK <- function(lp, j, obj_coef) {
+
+    invisible(
+        .Call("setObjCoef", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              as.numeric(obj_coef)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getObjCoefsGLPK <- function(lp, j) {
+
+    obj_coef <- .Call("getObjCoefs", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+
+    return(obj_coef)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getObjCoefGLPK <- function(lp, j) {
+
+    obj_coef <- .Call("getObjCoef", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+    return(obj_coef)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+loadMatrixGLPK <- function(lp, ne, ia, ja, ra) {
+
+    invisible(
+        .Call("loadMatrix", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(ne),
+              as.integer(ia),
+              as.integer(ja),
+              as.numeric(ra)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+checkDupGLPK <- function(m, n, ne, ia, ja) {
+
+    dup <- .Call("checkDup", PACKAGE = "glpkAPI",
+                 as.integer(m),
+                 as.integer(n),
+                 as.integer(ne),
+                 as.integer(ia),
+                 as.integer(ja)
+    )
+
+    return(dup)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+sortMatrixGLPK <- function(lp) {
+
+    invisible(
+        .Call("sortMatrix", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+delRowsGLPK <- function(lp, nrows, i) {
+
+    if (i[1] != 0) {
+        Ci <- as.integer(append(i, 0, 0))
+    }
+    else {
+        Ci <- as.integer(i)
+    }
+
+    invisible(
+        .Call("delRows", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(nrows),
+              Ci
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+delColsGLPK <- function(lp, ncols, j) {
+
+
+    if (j[1] != 0) {
+        Cj <- as.integer(append(j, 0, 0))
+    }
+    else {
+        Cj <- as.integer(j)
+   }
+
+    invisible(
+        .Call("delCols", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(ncols),
+              Cj
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setRiiGLPK <- function(lp, i, rii) {
+
+    invisible(
+        .Call("setRii", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i),
+              as.numeric(rii)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setSjjGLPK <- function(lp, j, sjj) {
+
+    invisible(
+        .Call("setSjj", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              as.numeric(sjj)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRiiGLPK <- function(lp, i) {
+
+    rii <- .Call("getRii", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i)
+        )
+    return(rii)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getSjjGLPK <- function(lp, j) {
+
+    sjj <- .Call("getSjj", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j)
+        )
+    return(sjj)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+scaleProbGLPK <- function(lp, opt) {
+
+    invisible(
+        .Call("scaleProb", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(opt)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+unscaleProbGLPK <- function(lp) {
+
+    invisible(
+        .Call("unscaleProb", PACKAGE = "glpkAPI",
+            glpkPointer(lp)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setRowStatGLPK <- function(lp, i, stat) {
+
+    invisible(
+        .Call("setRowStat", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i),
+              as.integer(stat)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+setColStatGLPK <- function(lp, j, stat) {
+
+    invisible(
+        .Call("setColStat", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              as.integer(stat)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+stdBasisGLPK <- function(lp) {
+
+    invisible(
+        .Call("stdBasis", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+advBasisGLPK <- function(lp) {
+
+    invisible(
+        .Call("advBasis", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+}
+
+
+#------------------------------------------------------------------------------#
+
+cpxBasisGLPK <- function(lp) {
+
+    invisible(
+        .Call("cpxBasis", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+    )
+}
+
+
+#------------------------------------------------------------------------------#
+
+warmUpGLPK <- function(lp) {
+
+    wup <- .Call("warmUp", PACKAGE = "glpkAPI",
+                 glpkPointer(lp)
+    )
+
+    return(wup)
+}
+
+
+# ------------------------------------------------------------------------------
+
+termOutGLPK <- function(flag) {
+
+    fl <- .Call("termOut", PACKAGE = "glpkAPI",
+                as.integer(flag)
+    )
+
+    return(fl)
+}
+
+
+#------------------------------------------------------------------------------#
+
+solveSimplexGLPK <- function(lp) {
+
+    ret <- .Call("solveSimplex", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+           )
+
+    return(ret)
+}
+
+
+#------------------------------------------------------------------------------#
+
+solveSimplexExactGLPK <- function(lp) {
+
+    ret <- .Call("solveSimplexExact", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+           )
+
+    return(ret)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getObjValGLPK <- function(lp) {
+
+    obj <- .Call("getObjVal", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+           )
+
+    return(obj)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getSolStatGLPK <- function(lp) {
+
+    stat <- .Call("getSolStat", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+            )
+
+    return(stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColsPrimGLPK <- function(lp) {
+
+    col_prim <- .Call("getColsPrim", PACKAGE = "glpkAPI",
+                      glpkPointer(lp)
+                )
+
+    return(col_prim)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColPrimGLPK <- function(lp, j) {
+
+    col_prim <- .Call("getColPrim", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(j)
+                )
+
+    return(col_prim)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getPrimStatGLPK <- function(lp) {
+
+    prim_stat <- .Call("getPrimStat", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                  )
+
+    return(prim_stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getDualStatGLPK <- function(lp) {
+
+    dual_stat <- .Call("getDualStat", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                 )
+
+    return(dual_stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowStatGLPK <- function(lp, i) {
+
+    row_stat <- .Call("getRowStat", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(i)
+                )
+
+    return(row_stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowsStatGLPK <- function(lp) {
+
+    rows_stat <- .Call("getRowsStat", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                 )
+
+    return(rows_stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowPrimGLPK <- function(lp, i) {
+
+    row_prim <- .Call("getRowPrim", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(i)
+                )
+
+    return(row_prim)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowsPrimGLPK <- function(lp) {
+
+    rows_prim <- .Call("getRowsPrim", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                 )
+
+    return(rows_prim)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowDualGLPK <- function(lp, i) {
+
+    row_dual <- .Call("getRowDual", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(i)
+                )
+
+    return(row_dual)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowsDualGLPK <- function(lp) {
+
+    rows_dual <- .Call("getRowsDual", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+        )
+
+    return(rows_dual)
+}
+
+#------------------------------------------------------------------------------#
+
+getColStatGLPK <- function(lp, j) {
+
+    col_stat <- .Call("getColStat", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(j)
+                )
+
+    return(col_stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColsStatGLPK <- function(lp) {
+
+    cols_stat <- .Call("getColsStat", PACKAGE = "glpkAPI",
+                      glpkPointer(lp) 
+                 )
+
+    return(cols_stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColDualGLPK <- function(lp, j) {
+
+    col_dual <- .Call("getColDual", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(j)
+                )
+
+    return(col_dual)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColsDualGLPK <- function(lp) {
+
+    cols_dual <- .Call("getColsDual", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                 )
+
+    return(cols_dual)
+}
+
+#------------------------------------------------------------------------------#
+
+getUnbndRayGLPK <- function(lp) {
+
+    unbnd <- .Call("getUnbndRay", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)
+             )
+
+    return(unbnd)
+}
+
+
+#------------------------------------------------------------------------------#
+
+solveInteriorGLPK <- function(lp) {
+
+    ret <- .Call("solveInterior", PACKAGE = "glpkAPI",
+              glpkPointer(lp)
+           )
+
+    return(ret)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getObjValIptGLPK <- function(lp) {
+
+    obj <- .Call("getObjValIpt", PACKAGE = "glpkAPI",
+                 glpkPointer(lp)
+           )
+
+    return(obj)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getSolStatIptGLPK <- function(lp) {
+
+    stat <- .Call("getSolStatIpt", PACKAGE = "glpkAPI",
+                  glpkPointer(lp)
+            )
+
+    return(stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColsPrimIptGLPK <- function(lp) {
+
+    cols_prim <- .Call("getColsPrimIpt", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                 )
+
+    return(cols_prim)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColPrimIptGLPK <- function(lp, j) {
+
+    col_prim <- .Call("getColPrimIpt", PACKAGE = "glpkAPI",
+                       glpkPointer(lp),
+                       as.integer(j)
+                 )
+
+    return(col_prim)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowPrimIptGLPK <- function(lp, i) {
+
+    row_prim <- .Call("getRowPrimIpt", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(i)
+                )
+
+    return(row_prim)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowsPrimIptGLPK <- function(lp) {
+
+    rows_prim <- .Call("getRowsPrimIpt", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                 )
+
+    return(rows_prim)
+
+}
+
+#------------------------------------------------------------------------------#
+
+getRowDualIptGLPK <- function(lp, i) {
+
+    row_dual <- .Call("getRowDualIpt", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(i)
+                )
+
+    return(row_dual)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRowsDualIptGLPK <- function(lp) {
+
+    rows_dual <- .Call("getRowsDualIpt", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                 )
+
+    return(rows_dual)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColDualIptGLPK <- function(lp, j) {
+
+    col_dual <- .Call("getColDualIpt", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(j)
+                )
+
+    return(col_dual)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getColsDualIptGLPK <- function(lp) {
+
+    cols_dual <- .Call("getColsDualIpt", PACKAGE = "glpkAPI",
+                       glpkPointer(lp)
+                 )
+
+    return(cols_dual)
+}
+
+
+#------------------------------------------------------------------------------#
+
+solveMIPGLPK <- function(lp) {
+
+    ret <- .Call("solveMIP", PACKAGE = "glpkAPI",
+                 glpkPointer(lp)
+           )
+
+    return(ret)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mipStatusGLPK <- function(lp) {
+
+    stat <- .Call("mipStatus", PACKAGE = "glpkAPI",
+                  glpkPointer(lp)
+            )
+
+    return(stat)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mipObjValGLPK <- function(lp) {
+
+    obj_val <- .Call("mipObjVal", PACKAGE = "glpkAPI",
+                     glpkPointer(lp)
+               )
+
+    return(obj_val)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mipRowValGLPK <- function(lp, i) {
+
+    row_val <- .Call("mipRowVal", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(i)
+                )
+
+    return(row_val)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mipRowsValGLPK <- function(lp) {
+
+    row_val <- .Call("mipRowsVal", PACKAGE = "glpkAPI",
+                     glpkPointer(lp)
+               )
+
+    return(row_val)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mipColValGLPK <- function(lp, j) {
+
+    col_val <- .Call("mipColVal", PACKAGE = "glpkAPI",
+                      glpkPointer(lp),
+                      as.integer(j)
+                )
+
+    return(col_val)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mipColsValGLPK <- function(lp) {
+
+    col_val <- .Call("mipColsVal", PACKAGE = "glpkAPI",
+                     glpkPointer(lp)
+               )
+
+    return(col_val)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getNumNnzGLPK <- function(lp) {
+
+    nnz <- .Call("getNumNnz", PACKAGE = "glpkAPI",
+                 glpkPointer(lp)
+           )
+
+    return(nnz)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getMatRowGLPK <- function(lp, i) {
+
+    row_val <- .Call("getMatRow", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i)
+        )
+
+    return(row_val)
+}
+
+
+#------------------------------------------------------------------------------#
+
+setMatRowGLPK <- function(lp, i, len, ind, val) {
+
+    if ( (len == 0) && (is.null(ind)) ) {
+        Cind <- as.null(ind)
+    }
+    else {
+        if (ind[1] != 0) {
+            Cind <- as.integer(append(ind, 0, 0))
+        }
+        else {
+            Cind <- as.integer(ind)
+        }
+    }
+
+    if ( (len == 0) && (is.null(val)) ) {
+        Cval <- as.null(val)
+    }
+    else {
+        if (val[1] != 0) {
+            Cval <- as.numeric(append(val, 0, 0))
+        }
+        else {
+            Cval <- as.numeric(val)
+        }
+    }
+
+    check <- .Call("setMatRow", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(i),
+              as.integer(len),
+              Cind,
+              Cval
+    )
+
+    return(check)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getMatColGLPK <- function(lp, j) {
+
+    row_val <- .Call("getMatCol", PACKAGE = "glpkAPI",
+                     glpkPointer(lp),
+                     as.integer(j)
+               )
+
+    return(row_val)
+}
+
+
+#------------------------------------------------------------------------------#
+
+setMatColGLPK <- function(lp, j, len, ind, val) {
+
+    if ( (len == 0) && (is.null(ind)) ) {
+        Cind <- as.null(ind)
+    }
+    else {
+        if (ind[1] != 0) {
+            Cind <- as.integer(append(ind, 0, 0))
+        }
+        else {
+            Cind <- as.integer(ind)
+        }
+    }
+
+    if ( (len == 0) && (is.null(val)) ) {
+        Cval <- as.null(val)
+    }
+    else {
+        if (val[1] != 0) {
+            Cval <- as.numeric(append(val, 0, 0))
+        }
+        else {
+            Cval <- as.numeric(val)
+        }
+    }
+
+    check <- .Call("setMatCol", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(j),
+              as.integer(len),
+              Cind,
+              Cval
+    )
+
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+readMPSGLPK <- function(lp, fmt, fname) {
+
+    check <- .Call("readMPS", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(fmt),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+readLPGLPK <- function(lp, fname) {
+
+    check <- .Call("readLP", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+readProbGLPK <- function(lp, fname) {
+
+    check <- .Call("readProb", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+writeMPSGLPK <- function(lp, fmt, fname) {
+
+    check <- .Call("writeMPS", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(fmt),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+writeLPGLPK <- function(lp, fname) {
+
+    check <- .Call("writeLP", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+writeProbGLPK <- function(lp, fname) {
+
+    check <- .Call("writeProb", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+printSolGLPK <- function(lp, fname) {
+
+    check <- .Call("printSol", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+readSolGLPK <- function(lp, fname) {
+
+    check <- .Call("readSol", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+writeSolGLPK <- function(lp, fname) {
+
+    check <- .Call("writeSol", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+printIptGLPK <- function(lp, fname) {
+
+    check <- .Call("printIpt", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+readIptGLPK <- function(lp, fname) {
+
+    check <- .Call("readIpt", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+writeIptGLPK <- function(lp, fname) {
+
+    check <- .Call("writeIpt", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+printMIPGLPK <- function(lp, fname) {
+
+    check <- .Call("printMIP", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+readMIPGLPK <- function(lp, fname) {
+
+    check <- .Call("readMIP", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+writeMIPGLPK <- function(lp, fname) {
+
+    check <- .Call("writeMIP", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.character(fname)
+        )
+    return(check)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+versionGLPK <- function() {
+
+    version <- .Call("version", PACKAGE = "glpkAPI")
+    return(version)
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+bfExistsGLPK <- function(lp) {
+
+    check <- .Call("bfExists", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)
+             )
+
+    return(check)
+}
+
+
+#------------------------------------------------------------------------------#
+
+factorizeGLPK <- function(lp) {
+
+    check <- .Call("factorize", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)    
+             )
+
+    return(check)
+}
+
+
+#------------------------------------------------------------------------------#
+
+bfUpdatedGLPK <- function(lp) {
+
+    check <- .Call("bfUpdated", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)    
+             )
+
+    return(check)
+}
+
+
+#------------------------------------------------------------------------------#
+
+setBfcpGLPK <- function(lp, parm, val) {
+
+    if (!identical(length(parm), length(val))) {
+        stop("Arguments 'parm' and 'val' must have the same length!")
+    }
+
+    indi <- which(parm > 400 & parm < 500)
+    indd <- which(parm > 500 & parm < 600)
+
+    npari <- length(indi)
+    npard <- length(indd)
+
+    if (npari == 0) {
+        parmi <- as.null(parm)
+        vali  <- as.null(val)
+    }
+    else {
+        parmi <- as.integer(parm[indi])
+        vali  <- as.integer(val[indi])
+    }
+
+    if (npard == 0) {
+        parmd <- as.null(parm)
+        vald  <- as.null(val)
+    }
+    else {
+        parmd <- as.integer(parm[indd])
+        vald  <- as.numeric(val[indd])
+    }
+
+    invisible(
+        .Call("setBfcp", PACKAGE = "glpkAPI",
+              glpkPointer(lp),
+              as.integer(npari),
+              parmi,
+              vali,
+              as.integer(npard),
+              parmd,
+              vald
+        )
+    )
+}
+
+
+#------------------------------------------------------------------------------#
+
+getBfcpGLPK <- function(lp) {
+
+    parmB <- .Call("getBfcp", PACKAGE = "glpkAPI",
+                   glpkPointer(lp)
+             )
+
+    return(parmB)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getBheadGLPK <- function(lp, k) {
+
+    bh <- .Call("getBhead", PACKAGE = "glpkAPI",
+                glpkPointer(lp),
+                as.integer(k)
+    )
+
+    return(bh)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getRbindGLPK <- function(lp, i) {
+
+    rh <- .Call("getRbind", PACKAGE = "glpkAPI",
+                glpkPointer(lp),
+                as.integer(i)
+    )
+
+    return(rh)
+}
+
+
+#------------------------------------------------------------------------------#
+
+getCbindGLPK <- function(lp, j) {
+
+    ch <- .Call("getCbind", PACKAGE = "glpkAPI",
+                glpkPointer(lp),
+                as.integer(j)
+    )
+
+    return(ch)
+}
+
+
+#------------------------------------------------------------------------------#
+
+printRangesGLPK <- function(lp, numrc = 0, rowcol = NULL, fname = "sar.txt") {
+
+    if ( (numrc == 0) || (is.null(rowcol)) ) {
+        Crowcol <- as.null(rowcol)
+    }
+    else {
+        Crowcol <- as.integer(c(0, rowcol))
+    }
+
+    sensit <- .Call("printRanges", PACKAGE = "glpkAPI",
+                    glpkPointer(lp),
+                    as.integer(numrc),
+                    Crowcol,
+                    as.character(fname)
+              )
+
+    return(sensit)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mplAllocWkspGLPK <- function(ptrtype = "tr_wksp") {
+
+    wk <- .Call("mplAllocWksp", PACKAGE = "glpkAPI",
+                as.character(ptrtype)
+          )
+
+    wkP <- trwks_Pointer(wk)
+
+    return(wkP)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mplFreeWkspGLPK <- function(wk) {
+
+    invisible(
+        .Call("mplFreeWksp", PACKAGE = "glpkAPI",
+              glpkPointer(wk)
+        )
+    )
+
+}
+
+
+#------------------------------------------------------------------------------#
+
+mplReadModelGLPK <- function(wk, fname, skip) {
+
+    check <- .Call("mplReadModel", PACKAGE = "glpkAPI",
+              glpkPointer(wk),
+              as.character(fname),
+              as.integer(skip)
+        )
+
+    return(check)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mplReadDataGLPK <- function(wk, fname) {
+
+    check <- .Call("mplReadData", PACKAGE = "glpkAPI",
+              glpkPointer(wk),
+              as.character(fname)
+        )
+
+    return(check)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mplGenerateGLPK <- function(wk, fname = NULL) {
+
+    if (is.null(fname)) {
+        Cfname <- as.null(fname)
+    }
+    else {
+        Cfname <- as.character(fname)
+    }
+
+    check <- .Call("mplGenerate", PACKAGE = "glpkAPI",
+              glpkPointer(wk),
+              Cfname
+        )
+
+    return(check)
+}
+
+
+#------------------------------------------------------------------------------#
+
+mplBuildProbGLPK <- function(wk, lp) {
+
+    invisible(
+        .Call("mplBuildProb", PACKAGE = "glpkAPI",
+              glpkPointer(wk),
+              glpkPointer(lp)
+        )
+    )
+}
+
+
+#------------------------------------------------------------------------------#
+
+mplPostsolveGLPK <- function(wk, lp, sol) {
+
+    check <- .Call("mplPostsolve", PACKAGE = "glpkAPI",
+              glpkPointer(wk),
+              glpkPointer(lp),
+              as.integer(sol)
+        )
+
+    return(check)
+}
+
+
diff --git a/R/glpk_ptrClass.R b/R/glpk_ptrClass.R
new file mode 100644
index 0000000000000000000000000000000000000000..1a30c4e792819cb79d4e904e9f1ed07ebd81f8bc
--- /dev/null
+++ b/R/glpk_ptrClass.R
@@ -0,0 +1,194 @@
+#------------------------------------------------------------------------------#
+#                             R interface to GLPK                              #
+#------------------------------------------------------------------------------#
+
+#  glpk_ptrClass.R
+#  R interface to GLPK.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of glpkAPI.
+#
+#  GlpkAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  GlpkAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with glpkAPI  If not, see <http://www.gnu.org/licenses/>.
+
+
+#------------------------------------------------------------------------------#
+#                          definition of class glpkPtr                         #
+#------------------------------------------------------------------------------#
+
+
+# representation of class glpkPtr
+setClass(Class = "glpkPtr",
+         representation(
+              glpkPtrType = "character",
+              glpkPointer = "externalptr"
+#              ,
+#              glpkParmSim = "externalptr",
+#              glpkParmInt = "externalptr",
+#              glpkParmMip = "externalptr"
+         )
+         #, contains = "externalptr"
+)
+
+
+#------------------------------------------------------------------------------#
+
+# contructor for class glpkPtr
+setMethod(f = "initialize",
+          signature = "glpkPtr",
+          definition = function(.Object, p, w) {
+
+              .Object@glpkPointer <- attr(p, which = w, exact = TRUE)
+              .Object@glpkPtrType <- as.character(p)
+
+#              .Object@glpkParm    <- "parameter"
+#              .Object@glpkParmSim <- attr(p, which = "simplex", exact = TRUE)
+#              .Object@glpkParmInt <- attr(p, which = "interior", exact = TRUE)
+#              .Object@glpkParmMip <- attr(p, which = "mip", exact = TRUE)
+              
+              return(.Object)
+          
+          }
+)
+
+
+# contructor for pointers to glpk problem structures
+glpk_Pointer <- function(pointer) {
+
+    if (is(pointer, "glpk_ptr")) {
+        pObj <- new("glpkPtr",
+                    p = pointer,
+                    w = as.character("glpk_ptr"))
+    }
+    else {
+        pObj <- pointer
+    }
+
+    return(pObj)
+}
+
+# contructor for pointers to translator workspace
+trwks_Pointer <- function(pointer) {
+
+    if (is(pointer, "trwks_ptr")) {
+        pObj <- new("glpkPtr",
+                    p = pointer,
+                    w = as.character("trwks_ptr"))
+    }
+    else {
+        pObj <- pointer
+    }
+
+    return(pObj)
+}
+
+
+#------------------------------------------------------------------------------#
+
+# glpkPtrType
+setMethod("glpkPtrType", signature(object = "glpkPtr"),
+          function(object) {
+              return(object@glpkPtrType)
+          }
+)
+
+setReplaceMethod("glpkPtrType", signature = (object = "glpkPtr"),
+                 function(object, value) {
+                     object@glpkPtrType <- value
+                     return(object)
+                 }
+)
+
+
+# glpkPointer
+setMethod("glpkPointer", signature(object = "glpkPtr"),
+          function(object) {
+              return(object@glpkPointer)
+          }
+)
+
+
+#------------------------------------------------------------------------------#
+
+setMethod("isNULLpointerGLPK", signature(object = "glpkPtr"),
+    function(object) {
+        return(.Call("isNULLptr", PACKAGE = "glpkAPI", glpkPointer(object)))
+    }
+)
+
+setMethod("isGLPKpointer", signature(object = "glpkPtr"),
+    function(object) {
+        return(.Call("isGLPKptr", PACKAGE = "glpkAPI", glpkPointer(object)))
+    }
+)
+
+setMethod("isTRWKSpointer", signature(object = "glpkPtr"),
+    function(object) {
+        return(.Call("isTRWKSptr", PACKAGE = "glpkAPI", glpkPointer(object)))
+    }
+)
+
+
+#------------------------------------------------------------------------------#
+
+setMethod("show", signature(object = "glpkPtr"),
+    function(object) {
+    
+        nc <- NA
+        
+        if (isNULLpointerGLPK(object)) {
+            ptrtype <- "NULL"
+        }
+        else {
+            if (isGLPKpointer(object)) {
+                ptrtype <- "GLPK problem object"
+                nc <- getNumColsGLPK(object)
+            }
+            else if (isTRWKSpointer(object)) {
+                ptrtype <- "MathProg translator workspace"
+            }
+            else {
+                ptrtype <- "unknown"
+            }
+        }
+
+        cat("object of class ", dQuote("glpkPtr"),
+            ": pointer to ", ptrtype, ".\n", sep = "")
+
+        if (!is.na(nc)) {
+            if ( (nc < 1) || (nc > 10) ) {
+                cat(paste("Number of variables:  ",
+                          getNumColsGLPK(object), "\n"))
+                cat(paste("Number of constraints:",
+                          getNumRowsGLPK(object), "\n"))
+            }
+            else {
+                # make a more illustrative method here
+                cat(paste("Number of variables:  ",
+                          getNumColsGLPK(object), "\n"))
+                cat(paste("Number of constraints:",
+                          getNumRowsGLPK(object), "\n"))
+            }
+        }
+        
+        cat(paste("Slot ",
+                  dQuote("glpkPtrType"), ": ",
+                  glpkPtrType(object), "\n", sep = ""))
+        cat(paste("Slot ", dQuote("glpkPointer"), ": ", sep = ""))
+        print(slot(object, "glpkPointer"), sep = "")
+    }
+)
diff --git a/R/zzz.R b/R/zzz.R
new file mode 100644
index 0000000000000000000000000000000000000000..d0c462fd33e9bf59696b9ad5f0b999311c851fe1
--- /dev/null
+++ b/R/zzz.R
@@ -0,0 +1,37 @@
+#------------------------------------------------------------------------------#
+#                             R interface to GLPK                              #
+#------------------------------------------------------------------------------#
+
+#  zzz.R
+#  R interface to GLPK.
+#
+#  Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+#  Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+#  All right reserved.
+#  Email: geliudie@uni-duesseldorf.de
+#
+#  This file is part of glpkAPI.
+#
+#  GlpkAPI is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  GlpkAPI is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with glpkAPI  If not, see <http://www.gnu.org/licenses/>.
+
+
+.packageName <- "glpkAPI"
+
+.onLoad <- function(libname, pkgname) {
+    .Call("initGLPK", PACKAGE = "glpkAPI")
+}
+
+.onAttach <- function(libname, pkgname) {
+    packageStartupMessage("using GLPK version ", versionGLPK())
+}
diff --git a/cleanup b/cleanup
new file mode 100755
index 0000000000000000000000000000000000000000..207460ca878b52184f76155ddf59d2ef6e496bce
--- /dev/null
+++ b/cleanup
@@ -0,0 +1,4 @@
+#! /bin/sh
+
+rm -rf config.* autom4te.cache src/Makevars src/config.h src/*.o
+exit 0
diff --git a/configure b/configure
new file mode 100755
index 0000000000000000000000000000000000000000..a6599ebf91db2bab0497e342c471a84fecdef49d
--- /dev/null
+++ b/configure
@@ -0,0 +1,4936 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.69 for glpkAPI 1.2.12.
+#
+# Report bugs to <geliudie@uni-duesseldorf.de>.
+#
+#
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
+#
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    $as_echo "$0: Please tell bug-autoconf@gnu.org and
+$0: geliudie@uni-duesseldorf.de about your system,
+$0: including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME='glpkAPI'
+PACKAGE_TARNAME='glpkapi'
+PACKAGE_VERSION='1.2.12'
+PACKAGE_STRING='glpkAPI 1.2.12'
+PACKAGE_BUGREPORT='geliudie@uni-duesseldorf.de'
+PACKAGE_URL=''
+
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='LTLIBOBJS
+LIBOBJS
+PKG_CPPFLAGS
+PKG_LIBS
+PKG_CFLAGS
+EGREP
+GREP
+ac_prefix_program
+CPP
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+with_glpk_include
+with_glpk_lib
+enable_gmp
+enable_chkargs
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CPP'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures glpkAPI 1.2.12 to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking ...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/glpkapi]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+  case $ac_init_help in
+     short | recursive ) echo "Configuration of glpkAPI 1.2.12:";;
+   esac
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-gmp=yes|no     link to GNU bignum library libgmp [[yes]]
+  --enable-chkargs=yes|no check arguments to GLPK [[yes]]
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-glpk-include=PATH
+                          location of glpk include directory
+                          [[/usr/local/include]]
+  --with-glpk-lib=PATH    location of GLPK callable library [[/usr/local/lib]]
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to <geliudie@uni-duesseldorf.de>.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+glpkAPI configure 1.2.12
+generated by GNU Autoconf 2.69
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+
+# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+# the include files in INCLUDES and setting the cache variable VAR
+# accordingly.
+ac_fn_c_check_header_mongrel ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if eval \${$3+:} false; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+else
+  # Is the header compilable?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+$as_echo_n "checking $2 usability... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_header_compiler=yes
+else
+  ac_header_compiler=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+$as_echo "$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+$as_echo_n "checking $2 presence... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$2>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  ac_header_preproc=yes
+else
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+$as_echo "$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
+  yes:no: )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+  no:yes:* )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+( $as_echo "## ------------------------------------------ ##
+## Report this to geliudie@uni-duesseldorf.de ##
+## ------------------------------------------ ##"
+     ) | sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=\$ac_header_compiler"
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_mongrel
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
+
+# ac_fn_c_check_func LINENO FUNC VAR
+# ----------------------------------
+# Tests whether FUNC exists, setting the cache variable VAR accordingly
+ac_fn_c_check_func ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $2 (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main ()
+{
+return $2 ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_func
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by glpkAPI $as_me 1.2.12, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    $as_echo "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    $as_echo "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      $as_echo "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  # We do not want a PATH search for config.site.
+  case $CONFIG_SITE in #((
+    -*)  ac_site_file1=./$CONFIG_SITE;;
+    */*) ac_site_file1=$CONFIG_SITE;;
+    *)   ac_site_file1=./$CONFIG_SITE;;
+  esac
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file" \
+      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+
+: ${R_HOME=`R RHOME`}
+if test -z "${R_HOME}"; then
+    echo "could not determine R_HOME"
+    exit 1
+fi
+
+CC=`"${R_HOME}/bin/R" CMD config CC`
+CPP=`"${R_HOME}/bin/R" CMD config CPP`
+CFLAGS=`"${R_HOME}/bin/R" CMD config CFLAGS`
+CPPFLAGS=`"${R_HOME}/bin/R" CMD config CPPFLAGS`
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if ${ac_cv_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+else
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if ${ac_cv_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+ac_config_headers="$ac_config_headers src/config.h"
+
+
+
+
+ARGS_OK="FALSE"
+
+if test  -n "$PKG_CPPFLAGS" -a -n "$PKG_LIBS"  ; then
+    ARGS_OK="TRUE"
+else
+    if test  -n "$PKG_CPPFLAGS" -o -n "$PKG_LIBS"  ; then
+        as_fn_error $? "Please set both variables: PKG_CPPFLAGS AND PKG_LIBS" "$LINENO" 5
+    fi
+fi
+
+
+
+
+# Check whether --with-glpk-include was given.
+if test "${with_glpk_include+set}" = set; then :
+  withval=$with_glpk_include; GLPK_INCLUDE=$withval
+else
+  GLPK_INCLUDE=""
+fi
+
+
+
+# Check whether --with-glpk-lib was given.
+if test "${with_glpk_lib+set}" = set; then :
+  withval=$with_glpk_lib; GLPK_LIB=$withval
+else
+  GLPK_LIB=""
+fi
+
+
+# Check whether --enable-gmp was given.
+if test "${enable_gmp+set}" = set; then :
+  enableval=$enable_gmp; GMP=$enableval
+else
+  GMP="yes"
+fi
+
+
+# Check whether --enable-chkargs was given.
+if test "${enable_chkargs+set}" = set; then :
+  enableval=$enable_chkargs; CHKARGS=$enableval
+else
+  CHKARGS="yes"
+fi
+
+
+
+
+if test  "$ARGS_OK" = "FALSE"  ; then
+
+    if test  -n "$GLPK_INCLUDE" -a -n "$GLPK_LIB"  ; then
+
+        if test  -d "$GLPK_INCLUDE"  ; then
+            PKG_CPPFLAGS="-I${GLPK_INCLUDE}"
+        else
+            as_fn_error $? "directory $GLPK_INCLUDE does not exist" "$LINENO" 5
+        fi
+
+        if test  -d "$GLPK_LIB"  ; then
+            PKG_LIBS="-L${GLPK_LIB}"
+            # PKG_LIBS="-L${GLPK_LIB} -Wl,-rpath ${GLPK_LIB}"
+        else
+            as_fn_error $? "directory $GLPK_LIB does not exist" "$LINENO" 5
+        fi
+
+    else
+
+
+        if test "x$prefix" = xNONE; then
+  $as_echo_n "checking for prefix by " >&6
+  # Extract the first word of "glpsol", so it can be a program name with args.
+set dummy glpsol; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_ac_prefix_program+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $ac_prefix_program in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_ac_prefix_program="$ac_prefix_program" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_ac_prefix_program="$as_dir/$ac_word$ac_exec_ext"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+ac_prefix_program=$ac_cv_path_ac_prefix_program
+if test -n "$ac_prefix_program"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_prefix_program" >&5
+$as_echo "$ac_prefix_program" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  if test -n "$ac_prefix_program"; then
+    prefix=`$as_dirname -- "$ac_prefix_program" ||
+$as_expr X"$ac_prefix_program" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_prefix_program" : 'X\(//\)[^/]' \| \
+	 X"$ac_prefix_program" : 'X\(//\)$' \| \
+	 X"$ac_prefix_program" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_prefix_program" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    prefix=`$as_dirname -- "$prefix" ||
+$as_expr X"$prefix" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$prefix" : 'X\(//\)[^/]' \| \
+	 X"$prefix" : 'X\(//\)$' \| \
+	 X"$prefix" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$prefix" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  fi
+fi
+
+
+        if test  "$prefix" = "NONE"  ; then
+
+            { $as_echo "$as_me:${as_lineno-$LINENO}: No prefix given, trying /usr and /usr/local" >&5
+$as_echo "$as_me: No prefix given, trying /usr and /usr/local" >&6;}
+
+            if test  -d "/usr/include" -o -d "/usr/local/include"  ; then
+                PKG_CPPFLAGS="-I/usr/include -I/usr/local/include"
+            else
+                as_fn_error $? "directories /usr/include and /usr/local/include do not exist" "$LINENO" 5
+            fi
+
+            if test  -d "/usr/local/lib" -o -d "/usr/local/lib64" -o -d "/usr/lib" -o -d "/usr/lib64" ; then
+                PKG_LIBS=""
+                if test  -d "/usr/local/lib"  ; then
+                    PKG_LIBS="$PKG_LIBS -L/usr/local/lib"
+                fi
+                if test  -d "/usr/local/lib64"  ; then
+                    PKG_LIBS="$PKG_LIBS -L/usr/local/lib64"
+                fi
+                if test  -d "/usr/lib"  ; then
+                    PKG_LIBS="$PKG_LIBS -L/usr/lib"
+                fi
+                if test  -d "/usr/lib64"  ; then
+                    PKG_LIBS="$PKG_LIBS -L/usr/lib64"
+                fi
+                # PKG_LIBS="-L/usr/local/lib -Wl,-rpath /usr/local/lib"
+            else
+                as_fn_error $? "none of the directories /usr/local/lib, /usr/local/lib64, /usr/lib of /usr/lib64 exists" "$LINENO" 5
+            fi
+
+        else
+
+            { $as_echo "$as_me:${as_lineno-$LINENO}: found executable glpsol in $prefix" >&5
+$as_echo "$as_me: found executable glpsol in $prefix" >&6;}
+
+            if test  -d "$prefix/include"  ; then
+                PKG_CPPFLAGS="-I$prefix/include"
+            else
+                as_fn_error $? "directory $prefix/include does not exist" "$LINENO" 5
+            fi
+
+            if test  -d "$prefix/lib" -o -d "$prefix/lib64"  ; then
+                PKG_LIBS=""
+                if test  -d "$prefix/lib"  ; then
+                    PKG_LIBS="$PKG_LIBS -L$prefix/lib"
+                fi
+                if test  -d "$prefix/lib64"  ; then
+                    PKG_LIBS="$PKG_LIBS -L$prefix/lib64"
+                fi
+            else
+                as_fn_error $? "neither $prefix/lib nor $prefix/lib64 exist" "$LINENO" 5
+            fi
+
+
+        fi
+    fi
+
+    if test  "${GMP}" != "no"  ; then
+                LINK="-lglpk -lgmp"
+
+$as_echo "#define USE_GMP 1" >>confdefs.h
+
+    else
+        LINK="-lglpk"
+    fi
+
+    PKG_LIBS="${PKG_LIBS} ${LINK}"
+    ARGS_OK="TRUE"
+fi
+
+
+if test  "${CHKARGS}" != "no"  ; then
+
+$as_echo "#define CHECK_GLPK_ARGS 1" >>confdefs.h
+
+    PKG_CPPFLAGS="-DHAVE_CONFIG_H ${PKG_CPPFLAGS}"
+fi
+
+
+
+if test  -z "$PKG_CFLAGS"  ; then
+    if test  "${R_ARCH}" = "/x86_64"  ; then
+        PKG_CFLAGS="-m64"
+    elif test  "${R_ARCH}" = "/i386"  ; then
+        PKG_CFLAGS="-m32"
+    else
+        PKG_CFLAGS=""
+    fi
+fi
+
+
+
+LIBS="${PKG_LIBS}"
+CFLAGS="${CFLAGS} ${PKG_CFLAGS}"
+CPPFLAGS="${CPPFLAGS} ${PKG_CPPFLAGS}"
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if ${ac_cv_path_EGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in egrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if ${ac_cv_header_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_stdc=yes
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then :
+  :
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+ac_fn_c_check_header_mongrel "$LINENO" "glpk.h" "ac_cv_header_glpk_h" "$ac_includes_default"
+if test "x$ac_cv_header_glpk_h" = xyes; then :
+
+else
+  as_fn_error $? "Could not find glpk.h:
+      glpkAPI requires GLPK from http://www.gnu.org/software/glpk/
+      use --with-glpk-include or GLPK_INCLUDE to specify the include path." "$LINENO" 5
+fi
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing glp_create_prob" >&5
+$as_echo_n "checking for library containing glp_create_prob... " >&6; }
+if ${ac_cv_search_glp_create_prob+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_func_search_save_LIBS=$LIBS
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char glp_create_prob ();
+int
+main ()
+{
+return glp_create_prob ();
+  ;
+  return 0;
+}
+_ACEOF
+for ac_lib in '' glpk; do
+  if test -z "$ac_lib"; then
+    ac_res="none required"
+  else
+    ac_res=-l$ac_lib
+    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
+  fi
+  if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_search_glp_create_prob=$ac_res
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext
+  if ${ac_cv_search_glp_create_prob+:} false; then :
+  break
+fi
+done
+if ${ac_cv_search_glp_create_prob+:} false; then :
+
+else
+  ac_cv_search_glp_create_prob=no
+fi
+rm conftest.$ac_ext
+LIBS=$ac_func_search_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_glp_create_prob" >&5
+$as_echo "$ac_cv_search_glp_create_prob" >&6; }
+ac_res=$ac_cv_search_glp_create_prob
+if test "$ac_res" != no; then :
+  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
+
+else
+  as_fn_error $? "Could not link to GLPK:
+      use --with-glpk-lib or GLPK_LIB to specify the lib path.
+      Maybe you want to set --enable-gmp=no" "$LINENO" 5
+fi
+
+
+ac_fn_c_check_func "$LINENO" "glp_print_ranges" "ac_cv_func_glp_print_ranges"
+if test "x$ac_cv_func_glp_print_ranges" = xyes; then :
+
+else
+  as_fn_error $? "GLPK version must be >= 4.42." "$LINENO" 5
+fi
+
+
+
+
+
+
+
+ac_config_files="$ac_config_files src/Makevars"
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by glpkAPI $as_me 1.2.12, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+case $ac_config_headers in *"
+"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
+esac
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 [OPTION]... [TAG]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
+      --header=FILE[:TEMPLATE]
+                   instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Report bugs to <geliudie@uni-duesseldorf.de>."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
+ac_cs_version="\\
+glpkAPI config.status 1.2.12
+configured by $0, generated by GNU Autoconf 2.69,
+  with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=?*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    $as_echo "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h)
+    # Conflict between --help and --header
+    as_fn_error $? "ambiguous option: \`$1'
+Try \`$0 --help' for more information.";;
+  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "src/config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
+    "src/Makevars") CONFIG_FILES="$CONFIG_FILES src/Makevars" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\)..*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\)..*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
+h
+s///
+s/^/:/
+s/[	 ]*$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/\(=[	 ]*\).*/\1/
+G
+s/\n//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+# Set up the scripts for CONFIG_HEADERS section.
+# No need to generate them if there are no CONFIG_HEADERS.
+# This happens for instance with `./config.status Makefile'.
+if test -n "$CONFIG_HEADERS"; then
+cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
+BEGIN {
+_ACEOF
+
+# Transform confdefs.h into an awk script `defines.awk', embedded as
+# here-document in config.status, that substitutes the proper values into
+# config.h.in to produce config.h.
+
+# Create a delimiter string that does not exist in confdefs.h, to ease
+# handling of long lines.
+ac_delim='%!_!# '
+for ac_last_try in false false :; do
+  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
+  if test -z "$ac_tt"; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+
+# For the awk script, D is an array of macro values keyed by name,
+# likewise P contains macro parameters if any.  Preserve backslash
+# newline sequences.
+
+ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
+sed -n '
+s/.\{148\}/&'"$ac_delim"'/g
+t rset
+:rset
+s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
+t def
+d
+:def
+s/\\$//
+t bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3"/p
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
+d
+:bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3\\\\\\n"\\/p
+t cont
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
+t cont
+d
+:cont
+n
+s/.\{148\}/&'"$ac_delim"'/g
+t clear
+:clear
+s/\\$//
+t bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/"/p
+d
+:bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
+b cont
+' <confdefs.h | sed '
+s/'"$ac_delim"'/"\\\
+"/g' >>$CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  for (key in D) D_is_set[key] = 1
+  FS = ""
+}
+/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
+  line = \$ 0
+  split(line, arg, " ")
+  if (arg[1] == "#") {
+    defundef = arg[2]
+    mac1 = arg[3]
+  } else {
+    defundef = substr(arg[1], 2)
+    mac1 = arg[2]
+  }
+  split(mac1, mac2, "(") #)
+  macro = mac2[1]
+  prefix = substr(line, 1, index(line, defundef) - 1)
+  if (D_is_set[macro]) {
+    # Preserve the white space surrounding the "#".
+    print prefix "define", macro P[macro] D[macro]
+    next
+  } else {
+    # Replace #undef with comments.  This is necessary, for example,
+    # in the case of _POSIX_SOURCE, which is predefined and required
+    # on some systems where configure will not decide to define it.
+    if (defundef == "undef") {
+      print "/*", prefix defundef, macro, "*/"
+      next
+    }
+  }
+}
+{ print }
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
+fi # test -n "$CONFIG_HEADERS"
+
+
+eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    "
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+  :H)
+  #
+  # CONFIG_HEADER
+  #
+  if test x"$ac_file" != x-; then
+    {
+      $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
+    } >"$ac_tmp/config.h" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+$as_echo "$as_me: $ac_file is unchanged" >&6;}
+    else
+      rm -f "$ac_file"
+      mv "$ac_tmp/config.h" "$ac_file" \
+	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    fi
+  else
+    $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
+      || as_fn_error $? "could not create -" "$LINENO" 5
+  fi
+ ;;
+
+
+  esac
+
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
+
+exit 0
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000000000000000000000000000000000000..2077c28b35fb66a34546810099220c264a7ca99c
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,244 @@
+AC_INIT([glpkAPI], [1.2.12], [geliudie@uni-duesseldorf.de])
+
+
+dnl # --------------------------------------------------------------------
+dnl # global (environment) variables
+dnl # --------------------------------------------------------------------
+dnl
+dnl # PKG_CPPFLAGS       C preprocessor flags -I...
+dnl # PKG_CFLAGS         C compiler flags
+dnl # PKG_LIBS           libraries -l...
+
+
+dnl # --------------------------------------------------------------------
+dnl # R compiler and flags
+dnl # --------------------------------------------------------------------
+
+: ${R_HOME=`R RHOME`}
+if test -z "${R_HOME}"; then
+    echo "could not determine R_HOME"
+    exit 1
+fi
+
+dnl # GNU R default settings
+CC=`"${R_HOME}/bin/R" CMD config CC`
+CPP=`"${R_HOME}/bin/R" CMD config CPP`
+CFLAGS=`"${R_HOME}/bin/R" CMD config CFLAGS`
+CPPFLAGS=`"${R_HOME}/bin/R" CMD config CPPFLAGS`
+AC_PROG_CC
+AC_PROG_CPP
+
+
+dnl # --------------------------------------------------------------------
+dnl # template config.h.in
+dnl # --------------------------------------------------------------------
+
+AC_CONFIG_HEADERS([src/config.h])
+
+
+dnl # --------------------------------------------------------------------
+dnl # test for global variables
+dnl # --------------------------------------------------------------------
+
+ARGS_OK="FALSE"
+
+if test [ -n "$PKG_CPPFLAGS" -a -n "$PKG_LIBS" ] ; then
+    ARGS_OK="TRUE"
+else
+    if test [ -n "$PKG_CPPFLAGS" -o -n "$PKG_LIBS" ] ; then
+        AC_MSG_ERROR([Please set both variables: PKG_CPPFLAGS AND PKG_LIBS])
+    fi
+fi
+
+
+dnl # --------------------------------------------------------------------
+dnl # get arguments
+dnl # --------------------------------------------------------------------
+
+AC_ARG_WITH(glpk-include,
+            AC_HELP_STRING([--with-glpk-include=PATH],
+                           [location of glpk include directory [[/usr/local/include]]]
+                          ),
+            [GLPK_INCLUDE=$withval],
+            [GLPK_INCLUDE=""])
+
+AC_ARG_WITH(glpk-lib,
+            AC_HELP_STRING([--with-glpk-lib=PATH],
+                           [location of GLPK callable library [[/usr/local/lib]]]
+                          ),
+            [GLPK_LIB=$withval],
+            [GLPK_LIB=""])
+
+AC_ARG_ENABLE(gmp,
+              AC_HELP_STRING([--enable-gmp[=yes|no]],
+                             [link to GNU bignum library libgmp [[yes]]]
+                            ),
+              [GMP=$enableval], [GMP="yes"])
+
+AC_ARG_ENABLE(chkargs,
+              AC_HELP_STRING([--enable-chkargs[=yes|no]],
+                             [check arguments to GLPK [[yes]]]
+                            ),
+              [CHKARGS=$enableval], [CHKARGS="yes"])
+
+
+dnl # --------------------------------------------------------------------
+dnl # test arguments
+dnl # --------------------------------------------------------------------
+
+dnl # include and library directories
+if test [ "$ARGS_OK" = "FALSE" ] ; then
+
+    if test [ -n "$GLPK_INCLUDE" -a -n "$GLPK_LIB" ] ; then
+    
+        if test [ -d "$GLPK_INCLUDE" ] ; then
+            PKG_CPPFLAGS="-I${GLPK_INCLUDE}"
+        else
+            AC_MSG_ERROR([directory $GLPK_INCLUDE does not exist])
+        fi
+    
+        if test [ -d "$GLPK_LIB" ] ; then
+            PKG_LIBS="-L${GLPK_LIB}"
+            # PKG_LIBS="-L${GLPK_LIB} -Wl,-rpath ${GLPK_LIB}"
+        else
+            AC_MSG_ERROR([directory $GLPK_LIB does not exist])
+        fi
+    
+    else
+    
+    dnl # if no arguments are given, try to find the glpsol executable. If is not
+    dnl # found, use /usr/local and /usr
+    
+        AC_PREFIX_PROGRAM(glpsol)
+    
+        if test [ "$prefix" = "NONE" ] ; then
+    
+            AC_MSG_NOTICE([No prefix given, trying /usr and /usr/local])
+    
+            if test [ -d "/usr/include" -o -d "/usr/local/include" ] ; then
+                PKG_CPPFLAGS="-I/usr/include -I/usr/local/include"
+            else
+                AC_MSG_ERROR([directories /usr/include and /usr/local/include do not exist])
+            fi
+    
+            if test [ -d "/usr/local/lib" -o -d "/usr/local/lib64" -o -d "/usr/lib" -o -d "/usr/lib64"] ; then
+                PKG_LIBS=""
+                if test [ -d "/usr/local/lib" ] ; then
+                    PKG_LIBS="$PKG_LIBS -L/usr/local/lib"
+                fi
+                if test [ -d "/usr/local/lib64" ] ; then
+                    PKG_LIBS="$PKG_LIBS -L/usr/local/lib64"
+                fi
+                if test [ -d "/usr/lib" ] ; then
+                    PKG_LIBS="$PKG_LIBS -L/usr/lib"
+                fi
+                if test [ -d "/usr/lib64" ] ; then
+                    PKG_LIBS="$PKG_LIBS -L/usr/lib64"
+                fi
+                # PKG_LIBS="-L/usr/local/lib -Wl,-rpath /usr/local/lib"
+            else
+                AC_MSG_ERROR([none of the directories /usr/local/lib, /usr/local/lib64, /usr/lib of /usr/lib64 exists])
+            fi
+    
+        else
+    
+            AC_MSG_NOTICE([found executable glpsol in $prefix])
+            
+            if test [ -d "$prefix/include" ] ; then
+                PKG_CPPFLAGS="-I$prefix/include"
+            else
+                AC_MSG_ERROR([directory $prefix/include does not exist])
+            fi
+    
+            if test [ -d "$prefix/lib" -o -d "$prefix/lib64" ] ; then
+                PKG_LIBS=""
+                if test [ -d "$prefix/lib" ] ; then
+                    PKG_LIBS="$PKG_LIBS -L$prefix/lib"
+                fi
+                if test [ -d "$prefix/lib64" ] ; then
+                    PKG_LIBS="$PKG_LIBS -L$prefix/lib64"
+                fi
+            else
+                AC_MSG_ERROR([neither $prefix/lib nor $prefix/lib64 exist])
+            fi
+
+dnl #            if test [ -d "$prefix/include" -a -d "$prefix/lib" ] ; then
+dnl #                PKG_CPPFLAGS="-I$prefix/include"
+dnl #                PKG_LIBS="-L$prefix/lib"
+dnl #                # PKG_LIBS="-L$prefix/lib -Wl,-rpath $prefix/lib"
+dnl #            else
+dnl #                AC_MSG_ERROR([directories $prefix/include and $prefix/lib do not exist])
+dnl #            fi
+
+        fi
+    fi
+
+    if test [ "${GMP}" != "no" ] ; then
+        dnl # AC_CHECK_HEADER([gmp.h], INCL="$INCL -lgmp", AC_MSG_NOTICE([Could not link to gmp.]))
+        LINK="-lglpk -lgmp"
+        AC_DEFINE([USE_GMP], [1], [defined, if gnu bignum is used])
+    else
+        LINK="-lglpk"
+    fi
+    
+    PKG_LIBS="${PKG_LIBS} ${LINK}"
+    ARGS_OK="TRUE"
+fi
+
+
+dnl # check arguments to CPLEX
+if test [ "${CHKARGS}" != "no" ] ; then
+    AC_DEFINE([CHECK_GLPK_ARGS], [1], [defined, if check arguments to GLPK])
+    PKG_CPPFLAGS="-DHAVE_CONFIG_H ${PKG_CPPFLAGS}"
+fi
+
+
+dnl # --------------------------------------------------------------------
+dnl # CFLAGS
+dnl # --------------------------------------------------------------------
+
+if test [ -z "$PKG_CFLAGS" ] ; then
+    if test [ "${R_ARCH}" = "/x86_64" ] ; then
+        PKG_CFLAGS="-m64"
+    elif test [ "${R_ARCH}" = "/i386" ] ; then
+        PKG_CFLAGS="-m32"
+    else
+        PKG_CFLAGS=""
+    fi
+fi
+
+
+dnl # --------------------------------------------------------------------
+dnl # check header and library
+dnl # --------------------------------------------------------------------
+
+LIBS="${PKG_LIBS}"
+CFLAGS="${CFLAGS} ${PKG_CFLAGS}"
+CPPFLAGS="${CPPFLAGS} ${PKG_CPPFLAGS}"
+
+AC_CHECK_HEADER([glpk.h],,
+    AC_MSG_ERROR([Could not find glpk.h:
+      glpkAPI requires GLPK from http://www.gnu.org/software/glpk/
+      use --with-glpk-include or GLPK_INCLUDE to specify the include path.]))
+
+
+AC_SEARCH_LIBS([glp_create_prob], [glpk], ,
+    AC_MSG_ERROR([Could not link to GLPK:
+      use --with-glpk-lib or GLPK_LIB to specify the lib path.
+      Maybe you want to set --enable-gmp=no]))
+
+dnl # GLPK version
+AC_CHECK_FUNC([glp_print_ranges], ,
+    AC_MSG_ERROR([GLPK version must be >= 4.42.]))
+
+
+dnl # --------------------------------------------------------------------
+dnl # substitute src/Makevars
+dnl # --------------------------------------------------------------------
+
+AC_SUBST(PKG_CFLAGS)
+AC_SUBST(PKG_LIBS)
+AC_SUBST(PKG_CPPFLAGS)
+AC_OUTPUT(src/Makevars)
+
+exit 0
diff --git a/configure.win b/configure.win
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/configure.win
@@ -0,0 +1 @@
+
diff --git a/inst/INSTALL b/inst/INSTALL
new file mode 100644
index 0000000000000000000000000000000000000000..0248f0dae009345d6761822bca93e2bfa1ef911d
--- /dev/null
+++ b/inst/INSTALL
@@ -0,0 +1,71 @@
+GNU R package glpkAPI: R Interface to C API of GLPK
+
+
+The installation procedure for the glpkAPI package needs to know where to
+find the GLPK include directory and where to find the callable library.
+
+
+# ---------------------------------------------------------------------------- #
+# Linux and MacOS X installation
+# ---------------------------------------------------------------------------- #
+
+There are basically three different ways of installing the glpkAPI package:
+
+1) Use --with-glpk-<ARG>
+
+   --with-glpk-include=PATH     with PATH being the include directory of GLPK
+
+   --with-glpk-lib=PATH         with PATH being the directory containing the
+                                callable library.
+
+   R CMD INSTALL --configure-args=" \
+       --with-glpk-include=/path/to/include/dir \
+       --with-glpk-lib=/path/to/lib/dir" glpkAPI_X.X.X.tar.gz
+
+
+   When using --with-glpk-<ARG>, both arguments must be given.
+
+2) Use of environment variables
+
+   PKG_CPPFLAGS                giving the PATH to the include directory of GLPK
+   PKG_LIBS                    giving the PATH to the directory containing the
+                               callable library and the libraries to link to.
+
+3) Use --prefix
+
+   --prefix=PATH               with path being the installation directory of
+                               GLPK. The include directory is assumed to be
+                               PATH/include and the callable library should be
+                               in PATH/lib.
+
+   If either --with-glpk-<ARG> nor --prefix is given, it is checked wether
+   glpsol is in the PATH. If yes, PATH is used as prefix. If not,
+   /usr/local/include and /usr/local/lib[64] and /usr/include and /usr/lib[64]
+   are tested.
+
+
+If one wants to use GNU BIGNUM in order to use glp_exact, use --enable-gmp
+(default is set to yes).
+
+The argument --enable-chkargs enables a mechanism checking column and row
+indices, variable types and kinds given as arguments to glpkAPI functions.
+If e.g. a desired column index does not exist, glpk will terminate abnormally,
+which also will close the running R session. The --enable-chkarg options will
+cause an overhead to the functions needing an index, because it checks if that
+index is valid. This option is enabled by default.
+
+
+# ---------------------------------------------------------------------------- #
+# Windows installation
+# ---------------------------------------------------------------------------- #
+
+For the installation on Windows systems the file Makewars.win in src/ is
+required. The file looks like this:
+
+PKG_CPPFLAGS=-g -D_R_=1 -DUSE_R=1 -I${GLPK_HOME}/include -DCHECK_GLPK_ARGS
+PKG_LIBS=-L${GLPK_HOME}/lib -lglpk -lgmp
+
+with the environment variable GLPK_HOME being the installation directory
+of GLPK and GNU BIGNUM.
+
+
diff --git a/inst/NEWS.Rd b/inst/NEWS.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..72a3e559746366c88a6734a9856a2a2feb28beab
--- /dev/null
+++ b/inst/NEWS.Rd
@@ -0,0 +1,352 @@
+%% glpkAPI Version History
+
+\name{NEWS}
+\title{glpkAPI News}
+\encoding{UTF-8}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.11 2014-11-16}{
+  \itemize{
+    \item added bsais factorization control parameters: \code{GLP_BF_LUF}
+          and \code{GLP_BF_BTF}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.10 2014-01-08}{
+  \itemize{
+    \item wring column or row indices to \code{setMatRowGLPK} and
+          \code{setMatColGLPK} will not longer stop the running R session
+    \item fixed a bug in functions \code{delRowsGLPK} and \code{delColsGLPK}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.9 2013-07-27}{
+  \itemize{
+    \item fixed a bug in \code{loadMatrixGLPK}: symbol \code{R_orderVector} is
+          first available in R version 3.0.0
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.8 2013-07-16}{
+  \itemize{
+    \item duplicate entries in inputs to \code{loadMatrixGLPK} will not longer
+          stop the running R session
+    \item added function \code{getRowsTypesGLPK}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.7 2013-05-23}{
+  \itemize{
+    \item a minor change in file \file{Makevars.win} so that the Windows version
+          will be compiled using --enable-chkargs
+    \item added functions \code{setColsNamesGLPK()}, \code{setRowsNamesGLPK()}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.6 2013-02-12}{
+  \itemize{
+    \item prints the version number of GLPK on startup
+    \item removed argument \code{check} from function \code{loadMatrixGLPK}
+    \item if compiled with --enable-chkargs [which is the default]), arguments
+          to GLPK API functions containing GLPK constants or row and column
+          indices are checked more carefully
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.5 2012-11-14}{
+  \itemize{
+    \item very basic support for the GLPK callback routine
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.4 2012-07-06}{
+  \itemize{
+    \item inconsistent inputs to \code{loadMatrixGLPK} will not longer stop
+          the running R session
+    \item new argument \code{check} to function \code{loadMatrixGLPK}:
+          if set to \code{TRUE} (and \pkg{glpkAPI} compiled with
+          --enable-chkargs [which is the default]), other arguments to
+          \code{loadMatrixGLPK} will be reviewed in terms of vector length and
+          valid row and column indices, before changing the problem object
+    \item functions \code{setMatRowGLPK} and \code{getMatRowGLPK} can use
+          vectors returned by \code{getMatRowGLPK} and \code{getMatColGLPK}
+          respectively
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.3 2012-04-20}{
+  \itemize{
+    \item bugfix in \file{configure.ac} when compiling with \command{R32}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.2 2012-03-27}{
+  \itemize{
+    \item renamed \code{glpkPtr} method \code{isNULLpointer} to
+          \code{isNULLpointerGLPK}
+
+    \item renamed \code{glpkPtr} method \code{pType} to \code{glpkPtrType}
+
+    \item renamed \code{glpkPtr} method \code{ptr} to \code{glpkPointer}
+
+    \item renamed \code{glpkPtr} slot \code{pType} to \code{glpkPtrType}
+
+    \item renamed \code{glpkPtr} slot \code{ptr} to \code{glpkPointer}
+
+    \item updated \file{configure.ac} script
+
+    \item file \file{NEWS} is now in \file{inst/NEWS.Rd}
+
+    \item fixed a bug in \code{getCbindGLPK}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.1 2012-03-15}{
+  \itemize{
+    \item class \code{glpkPtr} does not extend \code{externalptr} (not allowed
+          in R version <= 2.14)
+
+    \item method show for objects of class \code{glpkPtr}
+
+    \item fixed a bug in \file{init.c}: number of arguments to
+          \code{mplAllocWksp} was wrong
+
+    \item added methods \code{isGLPKpointer}, \code{isNULLpointer} and
+          \code{isTRWKSpointer} for objects of class \code{glpkPtr}
+
+    \item make use of \code{glp_error_hook} in \file{glpkAPI.c} in order to
+          prevent GLPK exiting abnormal and so terminating the running R session
+
+    \item check arguments for row and column indices (\code{i} and \code{j}) if
+          they fit to the given problem object (again: prevent GLPK from
+          terminating the running R session)
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.2.0 2012-02-14}{
+  \itemize{
+    \item exported API-functions are registered
+
+    \item class \code{glpkPtr} extends \code{externalptr}
+
+    \item file \file{c2r.map} in \file{inst/}: mapping of filenames between
+          C API and \pkg{glpkAPI}, run
+      \preformatted{
+c2r <- system.file(package = "glpkAPI", "c2r.map")
+source(c2r)
+      }
+      in order to use original function names of the GLPK C API.
+
+    \item fixed a bug in \code{copyProbGLPK()}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.9 2012-02-13}{
+  \itemize{
+    \item added finalizers for GLPK problem objects and MathProg
+          translator workspace objects
+
+    \item Functions \code{initProbGLPK()} and \code{mplAllocWkspGLPK()} return
+          instances of class \code{glpkPtr}. This class has two data slots:
+    \tabular{ll}{
+      pType \tab a character string giving the pointer type and \cr
+      ptr   \tab a pointer to a C structure                     \cr
+    }
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.8 2012-02-07}{
+  \itemize{
+    \item added MathProg support:
+          \code{mplAllocWkspGLPK()},
+          \code{mplBuildProbGLPK()},
+          \code{mplFreeWkspGLPK()},
+          \code{mplGenerateGLPK()},
+          \code{mplPostsolveGLPK()},
+          \code{mplReadDataGLPK()} and
+          \code{mplReadModelGLPK()}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.7 2012-01-10}{
+  \itemize{
+    \item some minor changes in \file{configure.ac}
+    \item empty \file{configure.win} file and some finetuning in
+          \file{Makevars.win}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.6 2012-01-09}{
+  \itemize{
+    \item some minor changes in \file{configure.ac}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.5 2011-07-28}{
+  \itemize{
+    \item added \file{NAMESPACE}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.4 2011-07-27}{
+  \itemize{
+    \item removed file \file{COPYING}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.3 2011-07-27}{
+  \itemize{
+    \item updated \file{configure.ac} script
+    \item updated package vignette
+    \item added files \file{INSTALL} and \file{README}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.2 2011-07-12}{
+  \itemize{
+    \item renamed from sybilGLPK to \pkg{glpkAPI}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.1 2011-06-14}{
+  \itemize{
+    \item fixed a bug in \code{getColsKind()}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.1.0 2011-05-17}{
+  \itemize{
+    \item updated documentation
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.0.4 2011-05-09}{
+  \itemize{
+    \item renamed functions \code{getFluxDistGLPK()} and
+          \code{getFluxDistIptGLPK()} to \code{getColsPrimGLPK()} and
+          \code{getColsPrimIptGLPK()} respectively
+
+    \item added functions \code{getColKindGLPK()},
+                          \code{getColsDualGLPK()},
+                          \code{getColsDualIptGLPK()},
+                          \code{getColsKindGLPK()},
+                          \code{getColsStatGLPK()},
+                          \code{getMIPParmGLPK()},
+                          \code{getNumBinGLPK()},
+                          \code{getNumIntGLPK()},
+                          \code{getRowsDualGLPK()},
+                          \code{getRowsDualIptGLPK()},
+                          \code{getRowsPrimGLPK()},
+                          \code{getRowsPrimIptGLPK()},
+                          \code{getRowsStatGLPK()},
+                          \code{mipColValGLPK()},
+                          \code{mipColsValGLPK()},
+                          \code{mipObjValGLPK()},
+                          \code{mipRowValGLPK()},
+                          \code{mipRowsValGLPK()},
+                          \code{mipStatusGLPK()},
+                          \code{printIptGLPK()},
+                          \code{printMIPGLPK()},
+                          \code{printSolGLPK()},
+                          \code{readIptGLPK()},
+                          \code{readMIPGLPK()},
+                          \code{readSolGLPK()},
+                          \code{setColKindGLPK()},
+                          \code{setColsKindGLPK()},
+                          \code{setDefaultMIPParmGLPK()},
+                          \code{setMIPParmGLPK()},
+                          \code{solveMIPGLPK()},
+                          \code{writeIptGLPK()},
+                          \code{writeMIPGLPK()} and
+                          \code{writeSolGLPK()}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.0.3 2011-03-08}{
+  \itemize{
+    \item fixed a bug in \code{findColGLPK()}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.0.2 2011-02-15}{
+  \itemize{
+    \item added functions \code{checkDupGLPK()},
+                          \code{sortMatrixGLPK()},
+                          \code{delRowsGLPK()},
+                          \code{delColsGLPK()},
+                          \code{setBfcpGLPK()},
+                          \code{getBfcpGLPK()},
+                          \code{readProbGLPK()},
+                          \code{writeProbGLPK()},
+                          \code{getBheadGLPK()},
+                          \code{getRbindGLPK()} and
+                          \code{getCbindGLPK()}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.0.1 2010-11-04}{
+  \itemize{
+    \item added functions \file{setMatRowGLPK()} and \file{setMatColGLPK()}
+  }
+}
+
+
+% ---------------------------------------------------------------------------- %
+\section{Changes in version 1.0.0 2010-08-19}{
+  \itemize{
+    \item initial public release
+  }
+}
+
+
diff --git a/inst/README b/inst/README
new file mode 100644
index 0000000000000000000000000000000000000000..b2cebd2d15f20c04afe1094948efcb055603616a
--- /dev/null
+++ b/inst/README
@@ -0,0 +1,4 @@
+GNU R package glpkAPI: R Interface to C API of GLPK
+
+The package glpkAPI requires a working installation of GLPK (in particular
+libraries and header files).
diff --git a/inst/c2r.map b/inst/c2r.map
new file mode 100644
index 0000000000000000000000000000000000000000..7764fa35e2016ca5f8aa135619bc6e53999239d2
--- /dev/null
+++ b/inst/c2r.map
@@ -0,0 +1,124 @@
+#------------------------------------------------------------------------------#
+#             map GLPK function names to glpkAPI function names                #
+#------------------------------------------------------------------------------#
+
+# GLPK                # glpkAPI
+
+glp_add_cols       <- glpkAPI::addColsGLPK
+glp_add_rows       <- glpkAPI::addRowsGLPK
+glp_adv_basis      <- glpkAPI::advBasisGLPK
+glp_bf_exists      <- glpkAPI::bfExistsGLPK
+glp_bf_updated     <- glpkAPI::bfUpdatedGLPK
+glp_check_dup      <- glpkAPI::checkDupGLPK
+glp_copy_prob      <- glpkAPI::copyProbGLPK
+glp_cpx_basis      <- glpkAPI::cpxBasisGLPK
+glp_create_index   <- glpkAPI::createIndexGLPK
+glp_create_prob    <- glpkAPI::initProbGLPK
+glp_del_cols       <- glpkAPI::delColsGLPK
+glp_del_rows       <- glpkAPI::delRowsGLPK
+glp_delete_index   <- glpkAPI::deleteIndexGLPK
+glp_delete_prob    <- glpkAPI::delProbGLPK
+glp_erase_prob     <- glpkAPI::eraseProbGLPK
+glp_exact          <- glpkAPI::solveSimplexExactGLPK
+glp_factorize      <- glpkAPI::factorizeGLPK
+glp_find_col       <- glpkAPI::findColGLPK
+glp_find_row       <- glpkAPI::findRowGLPK
+glp_get_bfcp       <- glpkAPI::getBfcpGLPK
+glp_get_bhead      <- glpkAPI::getBheadGLPK
+glp_get_col_bind   <- glpkAPI::getCbindGLPK
+glp_get_col_dual   <- glpkAPI::getColDualGLPK
+glp_get_col_kind   <- glpkAPI::getColKindGLPK
+glp_get_col_lb     <- glpkAPI::getColLowBndGLPK
+glp_get_col_name   <- glpkAPI::getColNameGLPK
+glp_get_col_prim   <- glpkAPI::getColPrimGLPK
+glp_get_col_stat   <- glpkAPI::getColStatGLPK
+glp_get_col_type   <- glpkAPI::getColTypeGLPK
+glp_get_col_ub     <- glpkAPI::getColUppBndGLPK
+glp_get_dual_stat  <- glpkAPI::getDualStatGLPK
+glp_get_mat_col    <- glpkAPI::getMatColGLPK
+glp_get_mat_row    <- glpkAPI::getMatRowGLPK
+glp_get_num_bin    <- glpkAPI::getNumBinGLPK
+glp_get_num_cols   <- glpkAPI::getNumColsGLPK
+glp_get_num_int    <- glpkAPI::getNumIntGLPK
+glp_get_num_nz     <- glpkAPI::getNumNnzGLPK
+glp_get_num_rows   <- glpkAPI::getNumRowsGLPK
+glp_get_obj_coef   <- glpkAPI::getObjCoefGLPK
+glp_get_obj_dir    <- glpkAPI::getObjDirGLPK
+glp_get_obj_name   <- glpkAPI::getObjNameGLPK
+glp_get_obj_val    <- glpkAPI::getObjValGLPK
+glp_get_prim_stat  <- glpkAPI::getPrimStatGLPK
+glp_get_prob_name  <- glpkAPI::getProbNameGLPK
+glp_get_rii        <- glpkAPI::getRiiGLPK
+glp_get_row_bind   <- glpkAPI::getRbindGLPK
+glp_get_row_dual   <- glpkAPI::getRowDualGLPK
+glp_get_row_lb     <- glpkAPI::getRowLowBndGLPK
+glp_get_row_name   <- glpkAPI::getRowNameGLPK
+glp_get_row_prim   <- glpkAPI::getRowPrimGLPK
+glp_get_row_stat   <- glpkAPI::getRowStatGLPK
+glp_get_row_type   <- glpkAPI::getRowTypeGLPK
+glp_get_row_ub     <- glpkAPI::getRowUppBndGLPK
+glp_get_sjj        <- glpkAPI::getSjjGLPK
+glp_get_status     <- glpkAPI::getSolStatGLPK
+glp_get_unbnd_ray  <- glpkAPI::getUnbndRayGLPK
+glp_init_iocp      <- glpkAPI::setDefaultMIPParmGLPK
+glp_init_iptcp     <- glpkAPI::setDefaultIptParmGLPK
+glp_interior       <- glpkAPI::solveInteriorGLPK
+glp_intopt         <- glpkAPI::solveMIPGLPK
+glp_ipt_col_dual   <- glpkAPI::getColDualIptGLPK
+glp_ipt_col_prim   <- glpkAPI::getColPrimIptGLPK
+glp_ipt_obj_val    <- glpkAPI::getObjValIptGLPK
+glp_ipt_row_dual   <- glpkAPI::getRowDualIptGLPK
+glp_ipt_row_prim   <- glpkAPI::getRowPrimIptGLPK
+glp_ipt_status     <- glpkAPI::getSolStatIptGLPK
+glp_load_matrix    <- glpkAPI::loadMatrixGLPK
+glp_mip_col_val    <- glpkAPI::mipColValGLPK
+glp_mip_obj_val    <- glpkAPI::mipObjValGLPK
+glp_mip_row_val    <- glpkAPI::mipRowValGLPK
+glp_mip_status     <- glpkAPI::mipStatusGLPK
+glp_mpl_alloc_wksp <- glpkAPI::mplAllocWkspGLPK
+glp_mpl_build_prob <- glpkAPI::mplBuildProbGLPK
+glp_mpl_free_wksp  <- glpkAPI::mplFreeWkspGLPK
+glp_mpl_generate   <- glpkAPI::mplGenerateGLPK
+glp_mpl_postsolve  <- glpkAPI::mplPostsolveGLPK
+glp_mpl_read_data  <- glpkAPI::mplReadDataGLPK
+glp_mpl_read_model <- glpkAPI::mplReadModelGLPK
+glp_print_ipt      <- glpkAPI::printIptGLPK
+glp_print_mip      <- glpkAPI::printMIPGLPK
+glp_print_ranges   <- glpkAPI::printRangesGLPK
+glp_print_sol      <- glpkAPI::printSolGLPK
+glp_read_ipt       <- glpkAPI::readIptGLPK
+glp_read_lp        <- glpkAPI::readLPGLPK
+glp_read_mip       <- glpkAPI::readMIPGLPK
+glp_read_mps       <- glpkAPI::readMPSGLPK
+glp_read_prob      <- glpkAPI::readProbGLPK
+glp_read_sol       <- glpkAPI::readSolGLPK
+glp_scale_prob     <- glpkAPI::scaleProbGLPK
+glp_set_bfcp       <- glpkAPI::setBfcpGLPK
+glp_set_col_bnds   <- glpkAPI::setColBndGLPK
+glp_set_col_kind   <- glpkAPI::setColKindGLPK
+glp_set_col_name   <- glpkAPI::setColNameGLPK
+glp_set_col_stat   <- glpkAPI::setColStatGLPK
+glp_set_mat_col    <- glpkAPI::setMatColGLPK
+glp_set_mat_row    <- glpkAPI::setMatRowGLPK
+glp_set_obj_coef   <- glpkAPI::setObjCoefGLPK
+glp_set_obj_dir    <- glpkAPI::setObjDirGLPK
+glp_set_obj_name   <- glpkAPI::setObjNameGLPK
+glp_set_prob_name  <- glpkAPI::setProbNameGLPK
+glp_set_rii        <- glpkAPI::setRiiGLPK
+glp_set_row_bnds   <- glpkAPI::setRowBndGLPK
+glp_set_row_name   <- glpkAPI::setRowNameGLPK
+glp_set_row_stat   <- glpkAPI::setRowStatGLPK
+glp_set_sjj        <- glpkAPI::setSjjGLPK
+glp_simplex        <- glpkAPI::solveSimplexGLPK
+glp_sort_matrix    <- glpkAPI::sortMatrixGLPK
+glp_std_basis      <- glpkAPI::stdBasisGLPK
+glp_term_out       <- glpkAPI::termOutGLPK
+glp_unscale_prob   <- glpkAPI::unscaleProbGLPK
+glp_version        <- glpkAPI::versionGLPK
+glp_warm_up        <- glpkAPI::warmUpGLPK
+glp_write_ipt      <- glpkAPI::writeIptGLPK
+glp_write_lp       <- glpkAPI::writeLPGLPK
+glp_write_mip      <- glpkAPI::writeMIPGLPK
+glp_write_mps      <- glpkAPI::writeMPSGLPK
+glp_write_prob     <- glpkAPI::writeProbGLPK
+glp_write_sol      <- glpkAPI::writeSolGLPK
diff --git a/man/addColsGLPK.Rd b/man/addColsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..dd4842a54c1b7d81762abb4b4bb0ba83924bc276
--- /dev/null
+++ b/man/addColsGLPK.Rd
@@ -0,0 +1,52 @@
+\name{addColsGLPK}
+\alias{addColsGLPK}
+\alias{glp_add_cols}
+
+\title{
+  Add Columns to a GLPK Problem Object
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_add_cols}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  addColsGLPK(lp, ncols)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{ncols}{
+    The number of columns to add.
+  }
+}
+
+\details{
+  Interface to the C function \code{addCols} which calls the GLPK
+  function \code{glp_add_cols}.
+}
+
+\value{
+ The ordinal number of the first new column added to the
+ problem object is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/addRowsGLPK.Rd b/man/addRowsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..b90a291ec076b9a14c1ac32cef74d48bee28a454
--- /dev/null
+++ b/man/addRowsGLPK.Rd
@@ -0,0 +1,52 @@
+\name{addRowsGLPK}
+\alias{addRowsGLPK}
+\alias{glp_add_rows}
+
+\title{
+  Add Rows to a GLPK Problem Object
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_add_rows}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  addRowsGLPK(lp, nrows)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{nrows}{
+    The number of rows to add.
+  }
+}
+
+\details{
+  Interface to the C function \code{addRows} which calls the GLPK
+  function \code{glp_add_rows}.
+}
+
+\value{
+ The ordinal number of the first new row added to the
+ problem object is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/advBasisGLPK.Rd b/man/advBasisGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..20a42605fc190fae18b87a89837e5fa6fd6c38bf
--- /dev/null
+++ b/man/advBasisGLPK.Rd
@@ -0,0 +1,48 @@
+\name{advBasisGLPK}
+\alias{advBasisGLPK}
+\alias{glp_adv_basis}
+
+\title{
+  Contruct Advanced Initial LP Basis
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_adv_basis}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  advBasisGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{advBasis} which calls the GLPK
+  function \code{glp_adv_basis}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/bfExistsGLPK.Rd b/man/bfExistsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..bcadf909ca625ac2ce8401f2d8df04af3b4cf8ec
--- /dev/null
+++ b/man/bfExistsGLPK.Rd
@@ -0,0 +1,48 @@
+\name{bfExistsGLPK}
+\alias{bfExistsGLPK}
+\alias{glp_bf_exists}
+
+\title{
+  Check if the basis factorization exists
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_bf_exists}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  bfExistsGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{bfExists} which calls the GLPK
+  function \code{glp_bf_exists}.
+}
+
+\value{
+  Returns non-zero if the basis factorization for the specified problem object
+  exists. Otherwise the routine returns zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/bfUpdatedGLPK.Rd b/man/bfUpdatedGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..f8c6ee99dd49a76e4a53131f539dfbdd1b702ece
--- /dev/null
+++ b/man/bfUpdatedGLPK.Rd
@@ -0,0 +1,48 @@
+\name{bfUpdatedGLPK}
+\alias{bfUpdatedGLPK}
+\alias{glp_bf_updated}
+
+\title{
+  Check if the basis factorization has been updated
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_bf_updated}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  bfUpdatedGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{bfUpdated} which calls the GLPK
+  function \code{glp_bf_updated}.
+}
+
+\value{
+  Returns non-zero if the basis factorization has been updated at least once.
+  Otherwise the routine returns zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/checkDupGLPK.Rd b/man/checkDupGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..02cd95c2f4ca02593fa0ad9c945fc49c62ce28aa
--- /dev/null
+++ b/man/checkDupGLPK.Rd
@@ -0,0 +1,61 @@
+\name{checkDupGLPK}
+\alias{checkDupGLPK}
+\alias{glp_check_dup}
+
+\title{
+  Check for Duplicate Elements in Sparse Matrix
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_check_dup}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  checkDupGLPK(m, n, ne, ia, ja)
+}
+
+\arguments{
+  \item{m}{
+    Number of rows in the matrix.
+  }
+  \item{n}{
+    Number of columns in the matrix.
+  }
+  \item{ne}{
+    Number of non-zero elements in the matrix.
+  }
+  \item{ia}{
+    Row indices of the non-zero elements.
+  }
+  \item{ja}{
+    Column indices of the non-zero elements.
+  }
+}
+
+\details{
+  Interface to the C function \code{checkDup} which calls the GLPK
+  function \code{glp_check_dup}.
+}
+
+\value{
+ Returns one of the following values:
+ \item{\code{0}  }{No duplikate elements.}
+ \item{\code{-k} }{Indices \code{ia[k]} or \code{ja[k]} are out of range.}
+ \item{\code{+k} }{Element \code{(ia[k], ja[k])} is duplicate.}
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/copyProbGLPK.Rd b/man/copyProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..778a0cbcea4411528be76c8174da961af324f31d
--- /dev/null
+++ b/man/copyProbGLPK.Rd
@@ -0,0 +1,58 @@
+\name{copyProbGLPK}
+\alias{copyProbGLPK}
+\alias{glp_copy_prob}
+
+\title{
+  Copy problem object content
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_copy_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  copyProbGLPK(lp, clp, name = GLP_OFF)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{clp}{
+    A pointer to a GLPK problem object (destination).
+  }
+  \item{name}{
+    If set to \code{GLP_ON}, the routine copies all symbolic names;
+    otherwise (\code{GLP_OFF}) not.
+  }
+}
+
+\details{
+  Interface to the C function \code{copyProb} which calls the GLPK
+  function \code{glp_copy_prob}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{enable/disable flag}.
+}
+
+\keyword{ optimize }
diff --git a/man/cpxBasisGLPK.Rd b/man/cpxBasisGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..bab3ad86169515127ab4d099caeb122fe1568161
--- /dev/null
+++ b/man/cpxBasisGLPK.Rd
@@ -0,0 +1,47 @@
+\name{cpxBasisGLPK}
+\alias{cpxBasisGLPK}
+\alias{glp_cpx_basis}
+
+\title{
+  Construct Bixby's initial LP basis
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_cpx_basis}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  cpxBasisGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{cpxBasis} which calls the GLPK
+  function \code{glp_cpx_basis}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/createIndexGLPK.Rd b/man/createIndexGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ec13b131ac5b5cb59e6035f288797a0d5d1a6ed9
--- /dev/null
+++ b/man/createIndexGLPK.Rd
@@ -0,0 +1,48 @@
+\name{createIndexGLPK}
+\alias{createIndexGLPK}
+\alias{glp_create_index}
+
+\title{
+  Create the Name Index
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_create_index}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  createIndexGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{createIndex} which calls the GLPK
+  function \code{glp_create_index}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/delColsGLPK.Rd b/man/delColsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..af606ce6c1755124769c970c2f2a4aec76b24b47
--- /dev/null
+++ b/man/delColsGLPK.Rd
@@ -0,0 +1,53 @@
+\name{delColsGLPK}
+\alias{delColsGLPK}
+\alias{glp_del_cols}
+
+\title{
+  Delete Columns from Problem Object
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_del_cols}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  delColsGLPK(lp, ncols, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{ncols}{
+    Number of columns to delete.
+  }
+  \item{j}{
+    Ordinal numbers of columns to delete.
+  }
+}
+
+\details{
+  Interface to the C function \code{delCols} which calls the GLPK
+  function \code{glp_del_cols}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/delProbGLPK.Rd b/man/delProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ee4764becf64503674bef489091effff5b6ffa86
--- /dev/null
+++ b/man/delProbGLPK.Rd
@@ -0,0 +1,48 @@
+\name{delProbGLPK}
+\alias{delProbGLPK}
+\alias{glp_delete_prob}
+
+\title{
+  Delete Problem Object
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_delete_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  delProbGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{delProb} which calls the GLPK
+  function \code{glp_delete_prob}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/delRowsGLPK.Rd b/man/delRowsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..e827306cef7da5463171f8827381f6a360a79ad7
--- /dev/null
+++ b/man/delRowsGLPK.Rd
@@ -0,0 +1,53 @@
+\name{delRowsGLPK}
+\alias{delRowsGLPK}
+\alias{glp_del_rows}
+
+\title{
+  Delete Rows from Problem Object
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_del_rows}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  delRowsGLPK(lp, nrows, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{nrows}{
+    Number of rows to delete.
+  }
+  \item{i}{
+    Ordinal numbers of rows to delete.
+  }
+}
+
+\details{
+  Interface to the C function \code{delRows} which calls the GLPK
+  function \code{glp_del_rows}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/deleteIndexGLPK.Rd b/man/deleteIndexGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..bc9c4c39107bf52447228b4b7c26f18114b97153
--- /dev/null
+++ b/man/deleteIndexGLPK.Rd
@@ -0,0 +1,48 @@
+\name{deleteIndexGLPK}
+\alias{deleteIndexGLPK}
+\alias{glp_delete_index}
+
+\title{
+  Delete the Name Index
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_delete_index}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  deleteIndexGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{deleteIndex} which calls the GLPK
+  function \code{glp_delete_index}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/eraseProbGLPK.Rd b/man/eraseProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..cf83e1cd9419e45e5c81d2201bcf6359c51810fd
--- /dev/null
+++ b/man/eraseProbGLPK.Rd
@@ -0,0 +1,47 @@
+\name{eraseProbGLPK}
+\alias{eraseProbGLPK}
+\alias{glp_erase_prob}
+
+\title{
+  Erase problem object content
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_erase_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  eraseProbGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{eraseProb} which calls the GLPK
+  function \code{glp_erase_prob}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/factorizeGLPK.Rd b/man/factorizeGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..4cca81e8d3c4d445bd939f136fdb284602a038cd
--- /dev/null
+++ b/man/factorizeGLPK.Rd
@@ -0,0 +1,52 @@
+\name{factorizeGLPK}
+\alias{factorizeGLPK}
+\alias{glp_factorize}
+
+\title{
+  Compute the basis factorization
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_factorize}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  factorizeGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{factorize} which calls the GLPK
+  function \code{glp_factorize}.
+}
+
+\value{
+  Returns zero if the basis factorization has been successfully computed.
+  Otherwise the routine returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{return codes}.
+}
+
+\keyword{ optimize }
diff --git a/man/findColGLPK.Rd b/man/findColGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..49573a6a4addbf4b30087357f79393083e8e6384
--- /dev/null
+++ b/man/findColGLPK.Rd
@@ -0,0 +1,57 @@
+\name{findColGLPK}
+\alias{findColGLPK}
+\alias{glp_find_col}
+
+\title{
+  Find Column by its Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_find_col}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  findColGLPK(lp, cname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{cname}{
+    A column name.
+  }
+}
+
+\details{
+  Interface to the C function \code{findCol} which calls the GLPK
+  function \code{glp_find_column}.
+}
+
+\value{
+  Returns the ordinal number of a column, which is assigned the specified cname.
+}
+
+\note{
+  Before calling \code{findColGLPK} for the first time on a problem object
+  \code{lp}, an index has to created via a call to
+  \code{\link{createIndexGLPK}}.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/findRowGLPK.Rd b/man/findRowGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..fa91da1cb95a74909da2bcae8d5272063621461f
--- /dev/null
+++ b/man/findRowGLPK.Rd
@@ -0,0 +1,57 @@
+\name{findRowGLPK}
+\alias{findRowGLPK}
+\alias{glp_find_row}
+
+\title{
+  Find Row by its Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_find_row}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  findRowGLPK(lp, rname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{rname}{
+    A row name.
+  }
+}
+
+\details{
+  Interface to the C function \code{findRow} which calls the GLPK
+  function \code{glp_find_row}.
+}
+
+\value{
+  Returns the ordinal number of a row, which is assigned the specified rname.
+}
+
+\note{
+  Before calling \code{findRowGLPK} for the first time on a problem object
+  \code{lp}, an index has to created via a call to
+  \code{\link{createIndexGLPK}}.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getBfcpGLPK.Rd b/man/getBfcpGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..0be484ddd4ac1166b2132b611fe83e631078761c
--- /dev/null
+++ b/man/getBfcpGLPK.Rd
@@ -0,0 +1,56 @@
+\name{getBfcpGLPK}
+\alias{getBfcpGLPK}
+\alias{glp_get_bfcp}
+
+\title{
+  Retrieve Basis Factorization Control parameters
+}
+
+\description{
+  Returns the names and values of members in the structure
+  \code{glp_bfcp}. Consult the GLPK documentation for
+  more detailed information.
+}
+
+\usage{
+  getBfcpGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getBfcp}.
+}
+
+\value{
+  The function returns a list.
+    \item{integer}{The names and corresponding values of all integer
+                   control parameters in \code{glp_bfcp}.}
+    \item{double}{The names and corresponding values of all double
+                  control parameters in \code{glp_bfcp}.}
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{Control Parameters}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getBheadGLPK.Rd b/man/getBheadGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..cfbc842d697cce92354f3702647f23f560e3e5f6
--- /dev/null
+++ b/man/getBheadGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getBheadGLPK}
+\alias{getBheadGLPK}
+\alias{glp_get_bhead}
+
+\title{
+  Retrieve Basis Header Information
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_bhead}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getBheadGLPK(lp, k)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{k}{
+    Index of the basic variable.
+  }
+}
+
+\details{
+  Interface to the C function \code{getBhead} which calls the GLPK
+  function \code{glp_get_bhead}.
+}
+
+\value{
+    Index of the auxiliary/structural variable.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getCbindGLPK.Rd b/man/getCbindGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..649dd333b74332f61aafb5dede713ad1500724eb
--- /dev/null
+++ b/man/getCbindGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getCbindGLPK}
+\alias{getCbindGLPK}
+\alias{glp_get_col_bind}
+
+\title{
+  Retrieve Column Index in the Basis Header
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_bind}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getCbindGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Structural variable \code{j}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getCbind} which calls the GLPK
+  function \code{glp_get_col_bind}.
+}
+
+\value{
+  Index of the basic variable.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getColDualGLPK.Rd b/man/getColDualGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..75905e0604a41119f69d7ee2c24c7d390aa12464
--- /dev/null
+++ b/man/getColDualGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getColDualGLPK}
+\alias{getColDualGLPK}
+\alias{glp_get_col_dual}
+
+\title{
+  Retrieve Column Dual Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_dual}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColDualGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number \code{j}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColDual} which calls the GLPK
+  function \code{glp_get_col_dual}.
+}
+
+\value{
+  Column dual value
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getColDualIptGLPK.Rd b/man/getColDualIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..a151023e940fef453f6d38b9e6619b3fc5886aaa
--- /dev/null
+++ b/man/getColDualIptGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getColDualIptGLPK}
+\alias{getColDualIptGLPK}
+\alias{glp_ipt_col_dual}
+
+\title{
+  Retrieve Column Dual Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_ipt_col_dual}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColDualIptGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number \code{j}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColDualIpt} which calls the GLPK
+  function \code{glp_ipt_col_dual}.
+}
+
+\value{
+  Column dual value
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getColKindGLPK.Rd b/man/getColKindGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..89cfcdbff930d8de006a7ac7fbb2ae29d1cd20e8
--- /dev/null
+++ b/man/getColKindGLPK.Rd
@@ -0,0 +1,49 @@
+\name{getColKindGLPK}
+\alias{getColKindGLPK}
+\alias{glp_get_col_kind}
+
+\title{
+  Retrieve Column Kind
+}
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_kind}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColKindGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number \code{j}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColKind} which calls the GLPK
+  function \code{glp_get_col_kind}.
+}
+
+\value{
+  Column Kind
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getColLowBndGLPK.Rd b/man/getColLowBndGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..1acceb1c19cc39c4a61d9dda817f3b5c574c540f
--- /dev/null
+++ b/man/getColLowBndGLPK.Rd
@@ -0,0 +1,52 @@
+\name{getColLowBndGLPK}
+\alias{getColLowBndGLPK}
+\alias{glp_get_col_lb}
+
+\title{
+  Retrieve Column Lower Bound
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_lb}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColLowBndGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColLowBnd} which calls the GLPK
+  function \code{glp_get_col_lb}.
+}
+
+\value{
+  The lower bound of the \code{j}-th column (the corresponding structural
+  variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColNameGLPK.Rd b/man/getColNameGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..283475ad3af5926f529f38c600db058d62ee3de1
--- /dev/null
+++ b/man/getColNameGLPK.Rd
@@ -0,0 +1,51 @@
+\name{getColNameGLPK}
+\alias{getColNameGLPK}
+\alias{glp_get_col_name}
+
+\title{
+  Retrieve Column Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_name}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColNameGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColName} which calls the GLPK
+  function \code{glp_get_col_name}.
+}
+
+\value{
+  The assigned name of the \code{j}-th column is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColPrimGLPK.Rd b/man/getColPrimGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..273c5af3ffd68667f27a8421b27029714d07a80c
--- /dev/null
+++ b/man/getColPrimGLPK.Rd
@@ -0,0 +1,52 @@
+\name{getColPrimGLPK}
+\alias{getColPrimGLPK}
+\alias{glp_get_col_prim}
+
+\title{
+  Retrieve Column Primal Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_prim}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColPrimGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColPrim} which calls the GLPK
+  function \code{glp_get_col_prim}.
+}
+
+\value{
+  The primal value of the \code{j}-th column (the corresponding structural
+  variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColPrimIptGLPK.Rd b/man/getColPrimIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..8bed91d4b6031f0a4f40d48de7925f2268f2d232
--- /dev/null
+++ b/man/getColPrimIptGLPK.Rd
@@ -0,0 +1,52 @@
+\name{getColPrimIptGLPK}
+\alias{getColPrimIptGLPK}
+\alias{glp_ipt_col_prim}
+
+\title{
+  Retrieve Column Primal Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_ipt_col_prim}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColPrimIptGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColPrimIpt} which calls the GLPK
+  function \code{glp_ipt_col_prim}.
+}
+
+\value{
+  The primal value of the \code{j}-th column (the corresponding structural
+  variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColStatGLPK.Rd b/man/getColStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..f82250fe7e72ec7c7079464163d7c775e2d91dbe
--- /dev/null
+++ b/man/getColStatGLPK.Rd
@@ -0,0 +1,53 @@
+\name{getColStatGLPK}
+\alias{getColStatGLPK}
+\alias{glp_get_col_stat}
+
+\title{
+  Retrieve Column Status
+}
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_stat}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColStatGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number \code{j}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColStat} which calls the GLPK
+  function \code{glp_get_col_stat}.
+}
+
+\value{
+  Column status
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
diff --git a/man/getColTypeGLPK.Rd b/man/getColTypeGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..27c45ae21c553a2f414526993d58f7d82bc19956
--- /dev/null
+++ b/man/getColTypeGLPK.Rd
@@ -0,0 +1,56 @@
+\name{getColTypeGLPK}
+\alias{getColTypeGLPK}
+\alias{glp_get_col_type}
+
+\title{
+  Retrieve Column Type
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_type}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColTypeGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColType} which calls the GLPK
+  function \code{glp_get_col_type}.
+}
+
+\value{
+  The type of the \code{j}-th column (the corresponding structural
+  variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColUppBndGLPK.Rd b/man/getColUppBndGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..5b6d611166124f114739844afe79e3bfe778988e
--- /dev/null
+++ b/man/getColUppBndGLPK.Rd
@@ -0,0 +1,52 @@
+\name{getColUppBndGLPK}
+\alias{getColUppBndGLPK}
+\alias{glp_get_col_ub}
+
+\title{
+  Retrieve Column Upper Bound
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_col_ub}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getColUppBndGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColUppBnd} which calls the GLPK
+  function \code{glp_get_col_ub}.
+}
+
+\value{
+  The upper bound of the \code{j}-th column (the corresponding structural
+  variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColsDualGLPK.Rd b/man/getColsDualGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..5bf5ea00df3c3b974a57c4ad3a636bdff14f2afa
--- /dev/null
+++ b/man/getColsDualGLPK.Rd
@@ -0,0 +1,45 @@
+\name{getColsDualGLPK}
+\alias{getColsDualGLPK}
+
+\title{
+  Retrieve Column Dual Value of all Columns
+}
+\description{
+  This is an advanced version of \code{\link{getColDualGLPK}}.
+}
+
+\usage{
+  getColsDualGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColsDual} which calls the GLPK
+  function \code{glp_get_col_dual}.
+}
+
+\value{
+  The column dual values of all columns (structural variables) are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColsDualIptGLPK.Rd b/man/getColsDualIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..1ae77b390c723797b18e7cb6658b63f3be3b6421
--- /dev/null
+++ b/man/getColsDualIptGLPK.Rd
@@ -0,0 +1,44 @@
+\name{getColsDualIptGLPK}
+\alias{getColsDualIptGLPK}
+
+\title{
+  Retrieve Column Dual Value of all Columns
+}
+\description{
+  This is an advanced version of \code{\link{getColDualIptGLPK}}.
+}
+\usage{
+  getColsDualIptGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColDualIpt} which calls the GLPK
+  function \code{glp_ipt_col_dual}.
+}
+
+\value{
+  The column dual values of all columns are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColsKindGLPK.Rd b/man/getColsKindGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..37757530733cd3246b333e38ea22a4854d2dd480
--- /dev/null
+++ b/man/getColsKindGLPK.Rd
@@ -0,0 +1,49 @@
+\name{getColsKindGLPK}
+\alias{getColsKindGLPK}
+
+\title{
+  Retrieve Column Kind
+}
+
+\description{
+  This is an advanced version of \code{\link{getColKindGLPK}}.
+}
+
+\usage{
+  getColsKindGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Vector of column numbers.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColsKind} which calls the GLPK
+  function \code{glp_get_col_ub}.
+}
+
+\value{
+  The column kinds of all specified columns (\code{j}) are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColsLowBndsGLPK.Rd b/man/getColsLowBndsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..2776f8340b777a3c0091e80ccf4564c1f96052bb
--- /dev/null
+++ b/man/getColsLowBndsGLPK.Rd
@@ -0,0 +1,51 @@
+\name{getColsLowBndsGLPK}
+\alias{getColsLowBndsGLPK}
+
+\title{
+  Retrieve Lower Bounds of Specified Columns
+}
+
+\description{
+  This is an advanced version of \code{\link{getColLowBndGLPK}}.
+  Here, \code{j} can be an integer vector.
+}
+
+\usage{
+  getColsLowBndsGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Vector of column numbers.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColsLowBnds} which calls the GLPK
+  function \code{glp_get_col_lb}.
+}
+
+\value{
+  The lower bounds of all specified columns (\code{j}) (the
+  corresponding structural variables) are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColsPrimGLPK.Rd b/man/getColsPrimGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ee874398bfd885a22ae7b7736770c62ebf90743d
--- /dev/null
+++ b/man/getColsPrimGLPK.Rd
@@ -0,0 +1,46 @@
+\name{getColsPrimGLPK}
+\alias{getColsPrimGLPK}
+
+\title{
+  Retrieve all Column Primal Values
+}
+
+\description{
+  This is an advanced version of \code{\link{getColPrimGLPK}}.
+}
+
+\usage{
+  getColsPrimGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColsPrim} which calls the GLPK
+  functions \code{glp_get_col_prim} and \code{glp_get_num_cols}.
+}
+
+\value{
+  Returns all values of the stuctural variables as a numeric vector.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColsPrimIptGLPK.Rd b/man/getColsPrimIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ee1d29b53701229f16ff006ae56c09fcf654b06a
--- /dev/null
+++ b/man/getColsPrimIptGLPK.Rd
@@ -0,0 +1,46 @@
+\name{getColsPrimIptGLPK}
+\alias{getColsPrimIptGLPK}
+
+\title{
+  Retrieve all Column Primal Values
+}
+
+\description{
+  This is an advanced version of \code{\link{getColPrimGLPK}}.
+}
+
+\usage{
+  getColsPrimIptGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColsPrimIpt} which calls the GLPK
+  functions \code{glp_ipt_col_prim} and \code{glp_get_num_cols}.
+}
+
+\value{
+  Returns all values of the stuctural variables as a numeric vector.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColsStatGLPK.Rd b/man/getColsStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..0cc203a3ff65621ec9afbe29707522f610320cd0
--- /dev/null
+++ b/man/getColsStatGLPK.Rd
@@ -0,0 +1,46 @@
+\name{getColsStatGLPK}
+\alias{getColsStatGLPK}
+
+\title{
+  Retrieve Column Status of all Columns
+}
+
+\description{
+  This is an advanced version of \code{\link{getColStatGLPK}}.
+}
+
+\usage{
+  getColsStatGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColsStat} which calls the GLPK
+  function \code{glp_get_col_stat}.
+}
+
+\value{
+  The column status of all columns are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getColsUppBndsGLPK.Rd b/man/getColsUppBndsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..06373dd1892e0bd63745d6c7ec17237c66d7030d
--- /dev/null
+++ b/man/getColsUppBndsGLPK.Rd
@@ -0,0 +1,51 @@
+\name{getColsUppBndsGLPK}
+\alias{getColsUppBndsGLPK}
+
+\title{
+  Retrieve Upper Bounds of Specified Columns
+}
+
+\description{
+  This is an advanced version of \code{\link{getColUppBndGLPK}}.
+  Here, \code{j} can be an integer vector.
+}
+
+\usage{
+  getColsUppBndsGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Vector of column numbers.
+  }
+}
+
+\details{
+  Interface to the C function \code{getColsUppBnds} which calls the GLPK
+  function \code{glp_get_col_ub}.
+}
+
+\value{
+  The upper bounds of all specified columns (\code{j}) (the
+  corresponding structural variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getDualStatGLPK.Rd b/man/getDualStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..3191dfc83fd5bbd1dcfd0c8eae853a1927042c60
--- /dev/null
+++ b/man/getDualStatGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getDualStatGLPK}
+\alias{getDualStatGLPK}
+\alias{glp_get_dual_stat}
+
+\title{
+  Retrieve Status of Dual Basic Solution
+}
+\description{
+  Low level interface function to the GLPK function \code{glp_get_dual_stat}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getDualStatGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getDualStat} which calls the GLPK
+  function \code{glp_get_dual_stat}.
+}
+
+\value{
+  Status of dual basic solution
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
diff --git a/man/getInteriorParmGLPK.Rd b/man/getInteriorParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..4838f69a7108a39ee56637d0c23dee7e6db79b25
--- /dev/null
+++ b/man/getInteriorParmGLPK.Rd
@@ -0,0 +1,45 @@
+\name{getInteriorParmGLPK}
+\alias{getInteriorParmGLPK}
+
+\title{
+  Retrives the Control Parameters for the Interior-point Method.
+}
+
+\description{
+  Returns the names and values of members in the structure
+  \code{glp_iptcp}. Consult the GLPK documentation for
+  more detailed information.
+}
+
+\usage{
+  getInteriorParmGLPK()
+}
+
+\details{
+  Interface to the C function \code{getInteriorParm}.
+}
+
+\value{
+  The function returns a list.
+    \item{integer}{The names and corresponding values of all integer
+                   control parameters in \code{glp_iptcp}.}
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{Control Parameters}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getMIPParmGLPK.Rd b/man/getMIPParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..f5eed15e95ecf3c96c21e19cb5d6600382579252
--- /dev/null
+++ b/man/getMIPParmGLPK.Rd
@@ -0,0 +1,47 @@
+\name{getMIPParmGLPK}
+\alias{getMIPParmGLPK}
+
+\title{
+  Retrives the Control Parameters for MIP.
+}
+
+\description{
+  Returns the names and values of members in the structure
+  \code{glp_iocp}. Consult the GLPK documentation for
+  more detailed information.
+}
+
+\usage{
+  getMIPParmGLPK()
+}
+
+\details{
+  Interface to the C function \code{getMIPParm}.
+}
+
+\value{
+  The function returns a list.
+    \item{integer}{The names and corresponding values of all integer
+                   control parameters in \code{glp_iocp}.}
+    \item{double}{The names and corresponding values of all double
+                   control parameters in \code{glp_iocp}.}
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{Control Parameters}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getMatColGLPK.Rd b/man/getMatColGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..c9483976d00ae0f8b1ec2c4654d16d29c33d02a6
--- /dev/null
+++ b/man/getMatColGLPK.Rd
@@ -0,0 +1,54 @@
+\name{getMatColGLPK}
+\alias{getMatColGLPK}
+\alias{glp_get_mat_col}
+
+\title{
+  Retrieves Column j of the Constraint Matrix.
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_mat_col}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getMatColGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getMatCol} which calls the GLPK
+  functions \code{glp_get_num_rows} and \code{glp_get_mat_col}.
+}
+
+\value{
+  Returns NULL or a list containing the non zero elements of column j:
+  \item{nnz}{number of non zero elements in column j}
+  \item{index}{row indices of the non zero elements in column j}
+  \item{value}{numerical values of the non zero elements in column j}
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getMatRowGLPK.Rd b/man/getMatRowGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ee7dd6d8c771f44eb48a75209dc0f0dbdd18cb1d
--- /dev/null
+++ b/man/getMatRowGLPK.Rd
@@ -0,0 +1,54 @@
+\name{getMatRowGLPK}
+\alias{getMatRowGLPK}
+\alias{glp_get_mat_row}
+
+\title{
+  Retrieves Row i of the Constraint Matrix.
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_mat_row}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getMatRowGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+}
+
+\details{
+  Interface to the C function \code{getMatRow} which calls the GLPK
+  functions \code{glp_get_num_cols} and \code{glp_get_mat_row}.
+}
+
+\value{
+  Returns NULL or a list containing the non zero elements of row i:
+  \item{nnz}{number of non zero elements in row i}
+  \item{index}{column indices of the non zero elements in row i}
+  \item{value}{numerical values of the non zero elements in row i}
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getNumBinGLPK.Rd b/man/getNumBinGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ba5ffdd0b8a5ef6066efc35d2ad378c92f9a544b
--- /dev/null
+++ b/man/getNumBinGLPK.Rd
@@ -0,0 +1,47 @@
+\name{getNumBinGLPK}
+\alias{getNumBinGLPK}
+\alias{glp_get_num_bin}
+
+\title{
+  Retrieve Number of Binary Columns
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_num_bin}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getNumBinGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getNumBin} which calls the GLPK
+  function \code{glp_get_num_bin}.
+}
+
+\value{
+  Number of binary columns.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getNumColsGLPK.Rd b/man/getNumColsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..8b9662c5a0602982503ac1c9a74fa9a22d2d16e3
--- /dev/null
+++ b/man/getNumColsGLPK.Rd
@@ -0,0 +1,49 @@
+\name{getNumColsGLPK}
+\alias{getNumColsGLPK}
+\alias{glp_get_num_cols}
+
+\title{
+  Retrieve Number of Columns
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_num_cols}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getNumColsGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getNumCols} which calls the GLPK
+  function \code{glp_get_num_cols}.
+}
+
+\value{
+  Returns the current number of columns in the specified
+  problem object.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getNumIntGLPK.Rd b/man/getNumIntGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..10abbb765282cefc7af3a0785f70df5a3eb9efec
--- /dev/null
+++ b/man/getNumIntGLPK.Rd
@@ -0,0 +1,47 @@
+\name{getNumIntGLPK}
+\alias{getNumIntGLPK}
+\alias{glp_get_num_int}
+
+\title{
+  Retrieve Number of Integer Columns
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_num_int}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getNumIntGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getNumInt} which calls the GLPK
+  function \code{glp_get_num_int}.
+}
+
+\value{
+  Number of integer columns.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getNumNnzGLPK.Rd b/man/getNumNnzGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..66af466d4d87a5fdd9be97099f17c967bdf5e620
--- /dev/null
+++ b/man/getNumNnzGLPK.Rd
@@ -0,0 +1,49 @@
+\name{getNumNnzGLPK}
+\alias{getNumNnzGLPK}
+\alias{glp_get_num_nz}
+
+\title{
+  Retrieve the Number of Constraint Coefficients
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_num_nz}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getNumNnzGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getNumNnz} which calls the GLPK
+  function \code{glp_get_num_nz}.
+}
+
+\value{
+  Returns the number of non-zero elements in the constraint
+  matrix of the specified problem object.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getNumRowsGLPK.Rd b/man/getNumRowsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..c4f25cbc410ed84bfc0322e847d4d841a4906416
--- /dev/null
+++ b/man/getNumRowsGLPK.Rd
@@ -0,0 +1,49 @@
+\name{getNumRowsGLPK}
+\alias{getNumRowsGLPK}
+\alias{glp_get_num_rows}
+
+\title{
+  Retrieve Number of Rows
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_num_rows}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getNumRowsGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getNumRows} which calls the GLPK
+  function \code{glp_get_num_rows}.
+}
+
+\value{
+  Returns the current number of rows in the specified
+  problem object.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getObjCoefGLPK.Rd b/man/getObjCoefGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..de3bf92c758706597fe8833004fa49336ddccb80
--- /dev/null
+++ b/man/getObjCoefGLPK.Rd
@@ -0,0 +1,54 @@
+\name{getObjCoefGLPK}
+\alias{getObjCoefGLPK}
+\alias{glp_get_obj_coef}
+
+\title{
+  Retrieve Objective Coefficient or Constant Term
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_obj_coef}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getObjCoefGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getObjCoef} which calls the GLPK
+  function \code{glp_get_obj_coef}.
+}
+
+\value{
+  The objective coefficient at the \code{j}-th column (the
+  corresponding   structural variable) is returned. If \code{j}
+  is \code{0}, the constant term \dQuote{shift} of the
+  objective function is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getObjCoefsGLPK.Rd b/man/getObjCoefsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..cd008be2cf71cf93fbe5448d81e71fb0a084f935
--- /dev/null
+++ b/man/getObjCoefsGLPK.Rd
@@ -0,0 +1,53 @@
+\name{getObjCoefsGLPK}
+\alias{getObjCoefsGLPK}
+
+\title{
+  Retrieve Objective Coefficients at Specified Columns and/or Constant Term
+}
+
+\description{
+  This is an advanced version of \code{\link{getObjCoefGLPK}}.
+  Here, \code{j} can be an integer vector.
+}
+
+\usage{
+  getObjCoefsGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Vector of column numbers.
+  }
+}
+
+\details{
+  Interface to the C function \code{getObjCoef} which calls the GLPK
+  function \code{glp_get_obj_coef}.
+}
+
+\value{
+  The objective coefficient at all specified columns (\code{j})
+  (the corresponding structural variable) is returned. If
+  \code{j} is \code{0}, the constant term \dQuote{shift} of the
+  objective function is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getObjDirGLPK.Rd b/man/getObjDirGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..e3c37dfb429e58e996c35fb8e4a0d6e9f57ddc9b
--- /dev/null
+++ b/man/getObjDirGLPK.Rd
@@ -0,0 +1,52 @@
+\name{getObjDirGLPK}
+\alias{getObjDirGLPK}
+\alias{glp_get_obj_dir}
+
+\title{
+  Retrieve Optimization Direction Flag
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_obj_dir}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getObjDirGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getObjDir} which calls the GLPK
+  function \code{glp_get_obj_dir}.
+}
+
+\value{
+  Returns the optimization direction flag.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getObjNameGLPK.Rd b/man/getObjNameGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..998a76449bb31425c903b6a5a6027f5500f3d18d
--- /dev/null
+++ b/man/getObjNameGLPK.Rd
@@ -0,0 +1,48 @@
+\name{getObjNameGLPK}
+\alias{getObjNameGLPK}
+\alias{glp_get_obj_name}
+
+\title{
+  Retrieve Objective Function Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_obj_name}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getObjNameGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getObjName} which calls the GLPK
+  function \code{glp_get_obj_name}.
+}
+
+\value{
+  The assigned name of the objective function is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getObjValGLPK.Rd b/man/getObjValGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..9e2435dde5f5c46bbbf08597916c29419c4e67e7
--- /dev/null
+++ b/man/getObjValGLPK.Rd
@@ -0,0 +1,48 @@
+\name{getObjValGLPK}
+\alias{getObjValGLPK}
+\alias{glp_get_obj_val}
+
+\title{
+  Retrieve Objective Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_obj_val}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getObjValGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getObjVal} which calls the GLPK
+  function \code{glp_get_obj_val}.
+}
+
+\value{
+  Returns the current value of the objective function.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getObjValIptGLPK.Rd b/man/getObjValIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..1e2f29039d5045dba21408b020cd8436dcf62c25
--- /dev/null
+++ b/man/getObjValIptGLPK.Rd
@@ -0,0 +1,48 @@
+\name{getObjValIptGLPK}
+\alias{getObjValIptGLPK}
+\alias{glp_ipt_obj_val}
+
+\title{
+  Retrieve Objective Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_ipt_obj_val}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getObjValIptGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getObjValIpt} which calls the GLPK
+  function \code{glp_ipt_obj_val}.
+}
+
+\value{
+  Returns the current value of the objective function.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getPrimStatGLPK.Rd b/man/getPrimStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..b5963311ef89813e961c6257952af94402639c59
--- /dev/null
+++ b/man/getPrimStatGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getPrimStatGLPK}
+\alias{getPrimStatGLPK}
+\alias{glp_get_prim_stat}
+
+\title{
+  Retrieve Status of Primal Basic Solution
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_prim_stat}.
+  Consult the GLPK documentation for more detailed information.
+}
+\usage{
+  getPrimStatGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getPrimStat} which calls the GLPK
+  function \code{glp_get_prim_stat}.
+}
+
+\value{
+  Status of primal basic solution
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
diff --git a/man/getProbNameGLPK.Rd b/man/getProbNameGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..0acfcf5b4476c83eafb2eda3931fac6759638b98
--- /dev/null
+++ b/man/getProbNameGLPK.Rd
@@ -0,0 +1,48 @@
+\name{getProbNameGLPK}
+\alias{getProbNameGLPK}
+\alias{glp_get_prob_name}
+
+\title{
+  Retrieve Problem Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_prob_name}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getProbNameGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getProbName} which calls the GLPK
+  function \code{glp_get_prob_name}.
+}
+
+\value{
+  The assigned name of the problem is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRbindGLPK.Rd b/man/getRbindGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..e7bb496198df0e3756aa4a145a6f731b3e149cb3
--- /dev/null
+++ b/man/getRbindGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getRbindGLPK}
+\alias{getRbindGLPK}
+\alias{glp_get_row_bind}
+
+\title{
+  Retrieve Row Index in the Basis Header
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_row_bind}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRbindGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Auxiliary variable \code{i}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRbind} which calls the GLPK
+  function \code{glp_get_row_bind}.
+}
+
+\value{
+  Index of the basic variable.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getRiiGLPK.Rd b/man/getRiiGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..17a61ca79e08b70a8b5372bde8b86418e791ee02
--- /dev/null
+++ b/man/getRiiGLPK.Rd
@@ -0,0 +1,51 @@
+\name{getRiiGLPK}
+\alias{getRiiGLPK}
+\alias{glp_get_rii}
+
+\title{
+  Retrieve row scale factor
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_rii}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRiiGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRii} which calls the GLPK
+  function \code{glp_get_rii}.
+}
+
+\value{
+  Returns the current scale factor $r_{ii}$ for row \code{i} of the specified
+  problem object.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getRowDualGLPK.Rd b/man/getRowDualGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..073be31376e12e6eec61fbb443b57f752b390e36
--- /dev/null
+++ b/man/getRowDualGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getRowDualGLPK}
+\alias{getRowDualGLPK}
+\alias{glp_get_row_dual}
+
+\title{
+  Retrieve Row Dual Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_row_dual}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowDualGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number \code{i}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowDual} which calls the GLPK
+  function \code{glp_get_row_dual}.
+}
+
+\value{
+  Row dual value
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getRowDualIptGLPK.Rd b/man/getRowDualIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..e4f8d7bf1e20e617569c6e7a48535fe0840c9372
--- /dev/null
+++ b/man/getRowDualIptGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getRowDualIptGLPK}
+\alias{getRowDualIptGLPK}
+\alias{glp_ipt_row_dual}
+
+\title{
+  Retrieve Row Dual Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_ipt_row_dual}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowDualIptGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number \code{i}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowDualIpt} which calls the GLPK
+  function \code{glp_ipt_row_dual}.
+}
+
+\value{
+  Row dual value
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getRowLowBndGLPK.Rd b/man/getRowLowBndGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..bdebd24683438260263ed18622aa9352bfe132c2
--- /dev/null
+++ b/man/getRowLowBndGLPK.Rd
@@ -0,0 +1,52 @@
+\name{getRowLowBndGLPK}
+\alias{getRowLowBndGLPK}
+\alias{glp_get_row_lb}
+
+\title{
+  Retrieve Row Lower Bound
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_row_lb}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowLowBndGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowLowBnd} which calls the GLPK
+  function \code{glp_get_row_lb}.
+}
+
+\value{
+  The lower bound of the \code{i}-th row (the corresponding auxiliary
+  variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowNameGLPK.Rd b/man/getRowNameGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..72fb7b74ff6dabbfb0da7635197797f7c95f6b03
--- /dev/null
+++ b/man/getRowNameGLPK.Rd
@@ -0,0 +1,51 @@
+\name{getRowNameGLPK}
+\alias{getRowNameGLPK}
+\alias{glp_get_row_name}
+
+\title{
+  Retrieve Row Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_row_name}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowNameGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowName} which calls the GLPK
+  function \code{glp_get_row_name}.
+}
+
+\value{
+  The assigned name of the \code{i}-th row is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowPrimGLPK.Rd b/man/getRowPrimGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..908eba7fa14c5a35c8be2a4fa27fa0053f263d5b
--- /dev/null
+++ b/man/getRowPrimGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getRowPrimGLPK}
+\alias{getRowPrimGLPK}
+\alias{glp_get_row_prim}
+
+\title{
+  Retrieve Row Primal Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_row_prim}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowPrimGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number \code{i}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowPrim} which calls the GLPK
+  function \code{glp_get_row_prim}.
+}
+
+\value{
+  Row primal value
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getRowPrimIptGLPK.Rd b/man/getRowPrimIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..6fdb517734e9e8136b20c5a283df4d21f5e22264
--- /dev/null
+++ b/man/getRowPrimIptGLPK.Rd
@@ -0,0 +1,50 @@
+\name{getRowPrimIptGLPK}
+\alias{getRowPrimIptGLPK}
+\alias{glp_ipt_row_prim}
+
+\title{
+  Retrieve Row Primal Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_ipt_row_prim}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowPrimIptGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number \code{i}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowPrimIpt} which calls the GLPK
+  function \code{glp_ipt_row_prim}.
+}
+
+\value{
+  Row primal value
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getRowStatGLPK.Rd b/man/getRowStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..3f5defa20d7455fd2c74c2f168f4077b7891093a
--- /dev/null
+++ b/man/getRowStatGLPK.Rd
@@ -0,0 +1,54 @@
+\name{getRowStatGLPK}
+\alias{getRowStatGLPK}
+\alias{glp_get_row_stat}
+
+\title{
+  Retrieve Row Status
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_row_stat}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowStatGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number \code{i}.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowStat} which calls the GLPK
+  function \code{glp_get_row_stat}.
+}
+
+\value{
+  Row status
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
diff --git a/man/getRowTypeGLPK.Rd b/man/getRowTypeGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..70522a32e7e1c556059bddd65c12fad13b4398e8
--- /dev/null
+++ b/man/getRowTypeGLPK.Rd
@@ -0,0 +1,56 @@
+\name{getRowTypeGLPK}
+\alias{getRowTypeGLPK}
+\alias{glp_get_row_type}
+
+\title{
+  Retrieve Row Type
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_row_type}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowTypeGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowType} which calls the GLPK
+  function \code{glp_get_row_type}.
+}
+
+\value{
+  The type of the \code{i}-th row (the corresponding auxiliary
+  variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowUppBndGLPK.Rd b/man/getRowUppBndGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..8da5d8f88dc0dfd1de047d7c1ffd2ee9edb2c63a
--- /dev/null
+++ b/man/getRowUppBndGLPK.Rd
@@ -0,0 +1,52 @@
+\name{getRowUppBndGLPK}
+\alias{getRowUppBndGLPK}
+\alias{glp_get_row_ub}
+
+\title{
+  Retrieve Row Upper Bound
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_row_ub}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getRowUppBndGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowUppBnd} which calls the GLPK
+  function \code{glp_get_row_ub}.
+}
+
+\value{
+  The upper bound of the \code{i}-th row (the corresponding auxiliary
+  variable) is returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowsDualGLPK.Rd b/man/getRowsDualGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..73fd08c929ec90bfedbe611fa50e9d6c680f84bc
--- /dev/null
+++ b/man/getRowsDualGLPK.Rd
@@ -0,0 +1,46 @@
+\name{getRowsDualGLPK}
+\alias{getRowsDualGLPK}
+
+\title{
+  Retrieve Row Dual Values of all Rows
+}
+
+\description{
+  This is an advanced version of \code{\link{getRowDualGLPK}}.
+}
+
+\usage{
+  getRowsDualGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowsDual} which calls the GLPK
+  function \code{glp_get_row_stat}.
+}
+
+\value{
+  The row dual values of all rows are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowsDualIptGLPK.Rd b/man/getRowsDualIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..a4a8e4a05d1154a9a6d9ce0f58986d05c85330c2
--- /dev/null
+++ b/man/getRowsDualIptGLPK.Rd
@@ -0,0 +1,44 @@
+\name{getRowsDualIptGLPK}
+\alias{getRowsDualIptGLPK}
+
+\title{
+  Retrieve Row Dual Value of all Rows
+}
+\description{
+  This is an advanced version of \code{\link{getRowDualIptGLPK}}.
+}
+\usage{
+  getRowsDualIptGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowsDualIpt} which calls the GLPK
+  function \code{glp_ipt_row_dual}.
+}
+
+\value{
+  The row dual values of all rows are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowsLowBndsGLPK.Rd b/man/getRowsLowBndsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..fc35a4a559cac153a5500cfc0c407179e46ccbce
--- /dev/null
+++ b/man/getRowsLowBndsGLPK.Rd
@@ -0,0 +1,51 @@
+\name{getRowsLowBndsGLPK}
+\alias{getRowsLowBndsGLPK}
+
+\title{
+  Retrieve Lower Bounds of Specified Rows
+}
+
+\description{
+  This is an advanced version of \code{\link{getRowLowBndGLPK}}.
+  Here, \code{i} can be an integer vector.
+}
+
+\usage{
+  getRowsLowBndsGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Vector of row numbers.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowsLowBnds} which calls the GLPK
+  function \code{glp_get_row_lb}.
+}
+
+\value{
+  The lower bounds of all specified columns (\code{i}) (the
+  corresponding auxiliary variables) are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowsPrimGLPK.Rd b/man/getRowsPrimGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ee15f0f71dc56446bc9aa7655a8a566e7f72cfa0
--- /dev/null
+++ b/man/getRowsPrimGLPK.Rd
@@ -0,0 +1,45 @@
+\name{getRowsPrimGLPK}
+\alias{getRowsPrimGLPK}
+
+\title{
+  Retrieve Row Primal Value of all Rows
+}
+
+\description{
+  This is an advanced version of \code{\link{getRowPrimGLPK}}.
+}
+\usage{
+  getRowsPrimGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowsPrim} which calls the GLPK
+  function \code{glp_get_row_prim}.
+}
+
+\value{
+  The row primal values for all rows are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowsPrimIptGLPK.Rd b/man/getRowsPrimIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..71288a4d3671d6c659085069fbf8a695bdc2ea39
--- /dev/null
+++ b/man/getRowsPrimIptGLPK.Rd
@@ -0,0 +1,46 @@
+\name{getRowsPrimIptGLPK}
+\alias{getRowsPrimIptGLPK}
+
+\title{
+  Retrieve Row Primal Value of all Rows
+}
+
+\description{
+  This is an advanced version of \code{\link{getRowPrimIptGLPK}}.
+}
+
+\usage{
+  getRowsPrimIptGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowsPrimIpt} which calls the GLPK
+  function \code{glp_ipt_row_prim}.
+}
+
+\value{
+  The row primal values of all rows are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowsStatGLPK.Rd b/man/getRowsStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..edc1df10fb9d2b45555a4624c6db800ef0b6fa1f
--- /dev/null
+++ b/man/getRowsStatGLPK.Rd
@@ -0,0 +1,46 @@
+\name{getRowsStatGLPK}
+\alias{getRowsStatGLPK}
+
+\title{
+  Retrieve Row Status of all Rows
+}
+
+\description{
+  This is an advanced version of \code{\link{getRowStatGLPK}}.
+}
+
+\usage{
+  getRowsStatGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowsStat} which calls the GLPK
+  function \code{glp_get_row_stat}.
+}
+
+\value{
+  The row status values of all rows are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getRowsTypesGLPK.Rd b/man/getRowsTypesGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..a8e8bd55cf2dbb9f4d1fb25e2ada86cee16c1628
--- /dev/null
+++ b/man/getRowsTypesGLPK.Rd
@@ -0,0 +1,55 @@
+\name{getRowsTypesGLPK}
+\alias{getRowsTypesGLPK}
+
+\title{
+  Retrieve Types of Specified Constraints (Rows)
+}
+
+\description{
+  This is an advanced version of \code{\link{getRowTypeGLPK}}.
+  Here, \code{i} can be an integer vector.
+}
+
+\usage{
+  getRowsTypesGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Vector of row numbers.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowsTypes} which calls the GLPK
+  function \code{glp_get_row_type}.
+}
+
+\value{
+  A numeric vector of the same length as \code{i} giving the constraint type
+  of the specified rows.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section
+  \sQuote{type of auxiliary/structural variable}.
+}
+
+\keyword{ optimize }
diff --git a/man/getRowsUppBndsGLPK.Rd b/man/getRowsUppBndsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..67e593ee343892c80dcb08d15934ee208ede417b
--- /dev/null
+++ b/man/getRowsUppBndsGLPK.Rd
@@ -0,0 +1,51 @@
+\name{getRowsUppBndsGLPK}
+\alias{getRowsUppBndsGLPK}
+
+\title{
+  Retrieve Upper Bounds of Specified Rows
+}
+
+\description{
+  This is an advanced version of \code{\link{getRowUppBndGLPK}}.
+  Here, \code{i} can be an integer vector.
+}
+
+\usage{
+  getRowsUppBndsGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Vector of row numbers.
+  }
+}
+
+\details{
+  Interface to the C function \code{getRowsUppBnds} which calls the GLPK
+  function \code{glp_get_row_ub}.
+}
+
+\value{
+  The upper bounds of all specified columns (\code{i}) (the
+  corresponding auxiliary variables) are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/getSimplexParmGLPK.Rd b/man/getSimplexParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..426d1c99222b888140be2dc62ec0d4cc3b652314
--- /dev/null
+++ b/man/getSimplexParmGLPK.Rd
@@ -0,0 +1,47 @@
+\name{getSimplexParmGLPK}
+\alias{getSimplexParmGLPK}
+
+\title{
+  Retrives the Control Parameters for the Simplex Method.
+}
+
+\description{
+  Returns the names and values of members in the structure
+  \code{glp_smcp}. Consult the GLPK documentation for
+  more detailed information.
+}
+
+\usage{
+  getSimplexParmGLPK()
+}
+
+\details{
+  Interface to the C function \code{getSimplexParm}.
+}
+
+\value{
+  The function returns a list.
+    \item{integer}{The names and corresponding values of all integer
+                   control parameters in \code{glp_smcp}.}
+    \item{double}{The names and corresponding values of all double
+                  control parameters in \code{glp_smcp}.}
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{Control Parameters}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getSjjGLPK.Rd b/man/getSjjGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..6b17f5a23c963eda843114f90d57a8ca97351814
--- /dev/null
+++ b/man/getSjjGLPK.Rd
@@ -0,0 +1,51 @@
+\name{getSjjGLPK}
+\alias{getSjjGLPK}
+\alias{glp_get_sjj}
+
+\title{
+  Retrieve column scale factor
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_sjj}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getSjjGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+}
+
+\details{
+  Interface to the C function \code{getSjj} which calls the GLPK
+  function \code{glp_get_sjj}.
+}
+
+\value{
+  Returns the current scale factor $s_{jj}$ for column \code{j} of the
+  specified problem object.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/getSolStatGLPK.Rd b/man/getSolStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..4845005b3b89f9972172081ee194c48c8236d5d9
--- /dev/null
+++ b/man/getSolStatGLPK.Rd
@@ -0,0 +1,53 @@
+\name{getSolStatGLPK}
+\alias{getSolStatGLPK}
+\alias{glp_get_status}
+
+\title{
+  Determine Generic Status of the Basic Soluton
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_status}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getSolStatGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getSolStat} which calls the GLPK
+  function \code{glp_get_status}.
+}
+
+\value{
+  Returns the generic status of the current basic solution for
+  the specified problem object.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getSolStatIptGLPK.Rd b/man/getSolStatIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..4f2123f251c22d15b2d6afd8381aeff5a85fedf8
--- /dev/null
+++ b/man/getSolStatIptGLPK.Rd
@@ -0,0 +1,53 @@
+\name{getSolStatIptGLPK}
+\alias{getSolStatIptGLPK}
+\alias{glp_ipt_status}
+
+\title{
+  Determine Solution Status
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_ipt_status}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getSolStatIptGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getSolStatIpt} which calls the GLPK
+  function \code{glp_ipt_status}.
+}
+
+\value{
+  Returns the generic status of the current basic solution for
+  the specified problem object.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/getUnbndRayGLPK.Rd b/man/getUnbndRayGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..b787c3db5019f17ecf8a393d6f6ae42286cefbf7
--- /dev/null
+++ b/man/getUnbndRayGLPK.Rd
@@ -0,0 +1,47 @@
+\name{getUnbndRayGLPK}
+\alias{getUnbndRayGLPK}
+\alias{glp_get_unbnd_ray}
+
+\title{
+  Determine Variable Causing Unboundedness
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_get_unbnd_ray}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  getUnbndRayGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{getUnbndRay} which calls the GLPK
+  function \code{glp_get_unbnd_ray}.
+}
+
+\value{
+  Returns the number k of a variable, which causes primal or dual unboundedness.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/glpkAPI-package.Rd b/man/glpkAPI-package.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..82eba328517c454327db51f72af5f0a05e5966bb
--- /dev/null
+++ b/man/glpkAPI-package.Rd
@@ -0,0 +1,90 @@
+\name{glpkAPI-package}
+
+\alias{glpkAPI-package}
+\alias{glpkAPI}
+
+\docType{package}
+
+\title{
+  R Interface to C API of GLPK
+}
+
+\description{
+  A low level interface to the GNU Linear Programming Kit (GLPK).
+}
+
+\details{
+  The package \code{glpkAPI} provides access to the callable library
+  of the GNU Linear Programming Kit from within R.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+    Gabriel Gelius-Dietrich
+
+    Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ package }
+\keyword{ optimize}
+
+\examples{
+# load package
+library(glpkAPI)
+
+# preparing the model
+lp <- initProbGLPK()
+
+# model data
+nrows  <- 5
+ncols  <- 8
+
+# constraint matrix
+ne <- 14
+ia <- c(1, 5, 1, 2, 2, 3, 1, 4, 1, 5, 3, 4, 1, 5)
+ja <- c(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 8)
+ar <- c(3.0, 5.6, 1.0, 2.0, 1.1, 1.0, -2.0, 2.8,
+        -1.0, 1.0, 1.0, -1.2, -1.0, 1.9)
+
+# objective function
+obj <- c(1, 0, 0, 0, 2, 0, 0, -1)
+
+# upper and lower bounds of the rows
+rlower <- c(2.5, -1000, 4, 1.8, 3)
+rupper <- c(1000, 2.1, 4, 5, 15)
+
+# upper and lower bounds of the columns
+clower <- c(2.5, 0, 0, 0, 0.5, 0, 0, 0)
+cupper <- c(1000, 4.1, 1, 1, 4, 1000, 1000, 4.3)
+
+# direction of optimization
+setObjDirGLPK(lp, GLP_MIN)
+
+# add rows and columns
+addRowsGLPK(lp, nrows)
+addColsGLPK(lp, ncols)
+
+setColsBndsObjCoefsGLPK(lp, c(1:ncols), clower, cupper, obj)
+setRowsBndsGLPK(lp, c(1:nrows), rlower, rupper)
+
+# load constraint matrix
+loadMatrixGLPK(lp, ne, ia, ja, ar)
+
+# solve lp problem
+solveSimplexGLPK(lp)
+
+# retrieve the results
+getSolStatGLPK(lp)
+getObjValGLPK(lp)
+getColsPrimGLPK(lp)
+
+# remove problem object
+delProbGLPK(lp)
+}
+
+
diff --git a/man/glpkConstants.Rd b/man/glpkConstants.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..84518936fdfd8ebf9c5e1a87f4afc911fb23e037
--- /dev/null
+++ b/man/glpkConstants.Rd
@@ -0,0 +1,497 @@
+\name{glpkConstants}
+\alias{glpkConstants}
+\alias{glpk_Constants}
+\alias{constantsGLPK}
+
+\alias{BINARIZE}
+\alias{BR_TECH}
+\alias{BT_TECH}
+\alias{CB_FUNC}
+\alias{CB_SIZE}
+\alias{CLQ_CUTS}
+\alias{COV_CUTS}
+\alias{EPS_TOL}
+\alias{FP_HEUR}
+\alias{GMI_CUTS}
+\alias{IT_LIM}
+\alias{LU_SIZE}
+\alias{MAX_GRO}
+\alias{METH}
+\alias{MIP_GAP}
+\alias{MIR_CUTS}
+\alias{MSG_LEV}
+\alias{NFS_MAX}
+\alias{NRS_MAX}
+\alias{OBJ_LL}
+\alias{OBJ_UL}
+\alias{ORD_ALG}
+\alias{OUT_DLY}
+\alias{OUT_FRQ}
+\alias{PIV_LIM}
+\alias{PIV_TOL}
+\alias{PP_TECH}
+\alias{PRESOLVE}
+\alias{PRICING}
+\alias{R_TEST}
+\alias{RS_SIZE}
+\alias{SUHL}
+\alias{TM_LIM}
+\alias{TOL_BND}
+\alias{TOL_DJ}
+\alias{TOL_INT}
+\alias{TOL_OBJ}
+\alias{TOL_PIV}
+\alias{TYPE}
+\alias{UPD_TOL}
+
+\alias{GLP_MIN}
+\alias{GLP_MAX}
+\alias{GLP_CV}
+\alias{GLP_IV}
+\alias{GLP_BV}
+\alias{GLP_FR}
+\alias{GLP_LO}
+\alias{GLP_UP}
+\alias{GLP_DB}
+\alias{GLP_FX}
+\alias{GLP_BS}
+\alias{GLP_NL}
+\alias{GLP_NU}
+\alias{GLP_NF}
+\alias{GLP_NS}
+\alias{GLP_SF_GM}
+\alias{GLP_SF_EQ}
+\alias{GLP_SF_2N}
+\alias{GLP_SF_SKIP}
+\alias{GLP_SF_AUTO}
+\alias{GLP_SOL}
+\alias{GLP_IPT}
+\alias{GLP_MIP}
+\alias{GLP_UNDEF}
+\alias{GLP_FEAS}
+\alias{GLP_INFEAS}
+\alias{GLP_NOFEAS}
+\alias{GLP_OPT}
+\alias{GLP_UNBND}
+\alias{GLP_BF_FT}
+\alias{GLP_BF_BG}
+\alias{GLP_BF_GR}
+\alias{GLP_BF_LUF}
+\alias{GLP_BF_BTF}
+\alias{GLP_MSG_OFF}
+\alias{GLP_MSG_ERR}
+\alias{GLP_MSG_ON}
+\alias{GLP_MSG_ALL}
+\alias{GLP_MSG_DBG}
+\alias{GLP_PRIMAL}
+\alias{GLP_DUALP}
+\alias{GLP_DUAL}
+\alias{GLP_PT_STD}
+\alias{GLP_PT_PSE}
+\alias{GLP_RT_STD}
+\alias{GLP_RT_HAR}
+\alias{GLP_ORD_NONE}
+\alias{GLP_ORD_QMD}
+\alias{GLP_ORD_AMD}
+\alias{GLP_ORD_SYMAMD}
+\alias{GLP_BR_FFV}
+\alias{GLP_BR_LFV}
+\alias{GLP_BR_MFV}
+\alias{GLP_BR_DTH}
+\alias{GLP_BR_PCH}
+\alias{GLP_BT_DFS}
+\alias{GLP_BT_BFS}
+\alias{GLP_BT_BLB}
+\alias{GLP_BT_BPH}
+\alias{GLP_PP_NONE}
+\alias{GLP_PP_ROOT}
+\alias{GLP_PP_ALL}
+\alias{GLP_RF_REG}
+\alias{GLP_RF_LAZY}
+\alias{GLP_RF_CUT}
+\alias{GLP_RF_GMI}
+\alias{GLP_RF_MIR}
+\alias{GLP_RF_COV}
+\alias{GLP_RF_CLQ}
+\alias{GLP_ON}
+\alias{GLP_OFF}
+\alias{GLP_IROWGEN}
+\alias{GLP_IBINGO}
+\alias{GLP_IHEUR}
+\alias{GLP_ICUTGEN}
+\alias{GLP_IBRANCH}
+\alias{GLP_ISELECT}
+\alias{GLP_IPREPRO}
+\alias{GLP_NO_BRNCH}
+\alias{GLP_DN_BRNCH}
+\alias{GLP_UP_BRNCH}
+\alias{GLP_EBADB}
+\alias{GLP_ESING}
+\alias{GLP_ECOND}
+\alias{GLP_EBOUND}
+\alias{GLP_EFAIL}
+\alias{GLP_EOBJLL}
+\alias{GLP_EOBJUL}
+\alias{GLP_EITLIM}
+\alias{GLP_ETMLIM}
+\alias{GLP_ENOPFS}
+\alias{GLP_ENODFS}
+\alias{GLP_EROOT}
+\alias{GLP_ESTOP}
+\alias{GLP_EMIPGAP}
+\alias{GLP_ENOFEAS}
+\alias{GLP_ENOCVG}
+\alias{GLP_EINSTAB}
+\alias{GLP_EDATA}
+\alias{GLP_ERANGE}
+\alias{GLP_KKT_PE}
+\alias{GLP_KKT_PB}
+\alias{GLP_KKT_DE}
+\alias{GLP_KKT_DB}
+\alias{GLP_KKT_CS}
+\alias{GLP_MPS_DECK}
+\alias{GLP_MPS_FILE}
+
+\title{
+  Constants, Return and Status Codes of GLPK
+}
+
+\description{
+  This is a list containing constants used by GLPK. Cunsult the glpk manual
+  for more information, in praticular for the control parameters.
+}
+
+%------------------------------------------------------------------------------
+\section{Control Parameters}{
+
+  \emph{Simplex}
+  \tabular{ll}{
+    \code{MSG_LEV  <- 101} \tab Message level for terminal output (default: \code{GLP_MSG_ALL}). \cr
+    \code{METH     <- 102} \tab Simplex method option (default: \code{GLP_PRIMAL}). \cr
+    \code{PRICING  <- 103} \tab Pricing technique (default: \code{GLP_PT_PSE}). \cr
+    \code{R_TEST   <- 104} \tab Ratio test technique (default: \code{GLP_RT_HAR}). \cr
+    \code{IT_LIM   <- 105} \tab Simplex iteration limit (default: \code{INT_MAX}). \cr
+    \code{TM_LIM   <- 106} \tab Searching time limit, in milliseconds (default: \code{INT_MAX}). \cr
+    \code{OUT_FRQ  <- 107} \tab Output frequency, in iterations (default: \code{500}). \cr
+    \code{OUT_DLY  <- 108} \tab Output delay, in milliseconds (default: \code{0}). \cr
+    \code{PRESOLVE <- 109} \tab LP presolver option (default: \code{GLP_OFF}). \cr
+    \code{TOL_BND  <- 201} \tab Tolerance used to check if the basic solution is primal feasible (default: \code{1e-7}). \cr
+    \code{TOL_DJ   <- 202} \tab Tolerance used to check if the basic solution is dual feasible (default: \code{1e-7}). \cr
+    \code{TOL_PIV  <- 203} \tab Tolerance used to choose eligble pivotal elements of the simplex table (default: \code{1e-10}). \cr
+    \code{OBJ_LL   <- 204} \tab Lower limit of the objective function (default: \code{-DBL_MAX}). \cr
+    \code{OBJ_UL   <- 205} \tab Upper limit of the objective function (default: \code{DBL_MAX}). \cr
+  }
+
+  The exact simplex method uses only the parameters \code{IT_LIM} and \code{TM_LIM}.
+
+  \emph{Interior}
+  \tabular{ll}{
+    \code{MSG_LEV  <- 101} \tab Message level for terminal output (default: \code{GLP_MSG_ALL}). \cr
+    \code{ORD_ALG  <- 301} \tab Ordering algorithm used prior to Cholesky factorization (default: \code{GLP_ORD_AMD}). \cr
+  }
+
+  \emph{MIP}
+  \tabular{ll}{
+    \code{MSG_LEV  <- 101} \tab Message level for terminal output (default: \code{GLP_MSG_ALL}). \cr
+    \code{TM_LIM   <- 106} \tab Searching time limit, in milliseconds (default: \code{INT_MAX}). \cr
+    \code{OUT_FRQ  <- 107} \tab Output frequency, in iterations (default: \code{5000}). \cr
+    \code{OUT_DLY  <- 108} \tab Output delay, in milliseconds (default: \code{10000}). \cr
+    \code{PRESOLVE <- 109} \tab MIP presolver option (default: \code{GLP_OFF}). \cr
+    \code{BR_TECH  <- 601} \tab Branching technique option (default: \code{GLP_BR_DTH}). \cr
+    \code{BT_TECH  <- 602} \tab Backtracking technique option (default: \code{GLP_BT_BLB}). \cr
+    \code{PP_TECH  <- 603} \tab Preprocessing technique option (default: \code{GLP_PP_ALL}). \cr
+    \code{FP_HEUR  <- 604} \tab Feasibility pump heuristic option (default: \code{GLP_OFF}). \cr
+    \code{GMI_CUTS <- 605} \tab Gomory's mixed integer cut option (default: \code{GLP_OFF}). \cr
+    \code{MIR_CUTS <- 606} \tab Mixed integer rounding (MIR) cut option (default: \code{GLP_OFF}). \cr
+    \code{COV_CUTS <- 607} \tab Mixed cover cut option (default: \code{GLP_OFF}). \cr
+    \code{CLQ_CUTS <- 608} \tab Clique cut option (default: \code{GLP_OFF}). \cr
+    \code{CB_SIZE  <- 609} \tab The number of extra (up to 256) bytes allocated for each node of the branch-and-bound tree to store application-specific data. On creating a node these bytes are initialized by binary zeros (default: \code{0}). \cr
+    \code{BINARIZE <- 610} \tab LP presolver option (default: \code{GLP_OFF}). \cr
+    \code{CB_FUNC  <- 651} \tab Use a user defined callback routine \code{glpkCallback} which is written in the file \file{glpkCallback.c}. This file should be edited according to the users requirements. If set to \code{GLP_ON}, the callback routine defined there is used (default: \code{NULL}). \cr
+    \code{TOL_INT  <- 701} \tab Absolute tolerance used to check if optimal solution to the current LP relaxation is integer feasible (default: \code{1e-5}). \cr
+    \code{TOL_OBJ  <- 702} \tab Relative tolerance used to check if the objective value in optimal solution to the current LP relaxation is not better than in the best known inte- ger feasible solution (default: \code{1e-7}). \cr
+    \code{MIP_GAP  <- 703} \tab The relative mip gap tolerance. If the relative mip gap for currently known best integer feasible solution falls below this tolerance, the solver terminates the search. This allows obtainig suboptimal integer feasible solutions if solving the problem to optimality takes too long time (default: \code{0.0}). \cr
+  }
+
+  \emph{Basis Factorization}
+  \tabular{ll}{
+    \code{TYPE     <- 401} \tab Basis factorization type (default: \code{GLP_BF_FT}). \cr
+    \code{LU_SIZE  <- 402} \tab Initial size of the Sparse Vector Area (default: \code{0}). \cr
+    \code{PIV_LIM  <- 403} \tab computing LU-factorization of the basis matrix (default: \code{4}). \cr
+    \code{SUHL     <- 404} \tab computing LU-factorization of the basis matrix (default: \code{GLP_ON}). \cr
+    \code{NFS_MAX  <- 405} \tab Maximal number of additional row-like factors (default: \code{100}). \cr
+    \code{NRS_MAX  <- 406} \tab Maximal number of additional rows and columns (default: \code{100}). \cr
+    \code{RS_SIZE  <- 407} \tab Initial size of the Sparse Vector Area (default: \code{0}). \cr
+    \code{PIV_TOL  <- 501} \tab Threshold pivoting (Markowitz) tolerance (default: \code{0.10}). \cr
+    \code{EPS_TOL  <- 502} \tab Epsilon tolerance (default: \code{1e-15}). \cr
+    \code{MAX_GRO  <- 503} \tab Maximal growth of elements of factor U (default: \code{1e+10}). \cr
+    \code{UPD_TOL  <- 504} \tab Update tolerance (default: \code{1e-6}). \cr
+  }
+
+}
+
+
+%------------------------------------------------------------------------------
+\section{LP/MIP problem object}{
+
+  \emph{optimization direction flag}
+  \tabular{ll}{
+    \code{GLP_MIN <- 1} \tab minimization \cr
+    \code{GLP_MAX <- 2} \tab maximization \cr
+  }
+
+  \emph{kind of structural variable}
+  \tabular{ll}{
+    \code{GLP_CV <- 1} \tab continuous variable \cr
+    \code{GLP_IV <- 2} \tab integer variable \cr
+    \code{GLP_BV <- 3} \tab binary variable \cr
+  }
+  
+  \emph{type of auxiliary/structural variable}
+  \tabular{ll}{
+    \code{GLP_FR <- 1} \tab free variable \cr
+    \code{GLP_LO <- 2} \tab variable with lower bound \cr
+    \code{GLP_UP <- 3} \tab variable with upper bound \cr
+    \code{GLP_DB <- 4} \tab double-bounded variable \cr
+    \code{GLP_FX <- 5} \tab fixed variable \cr
+  }
+  
+  \emph{status of auxiliary/structural variable}
+  \tabular{ll}{
+    \code{GLP_BS <- 1} \tab basic variable \cr
+    \code{GLP_NL <- 2} \tab non-basic variable on lower bound \cr
+    \code{GLP_NU <- 3} \tab non-basic variable on upper bound \cr
+    \code{GLP_NF <- 4} \tab non-basic free variable \cr
+    \code{GLP_NS <- 5} \tab non-basic fixed variable \cr
+  }
+  
+  \emph{scaling options}
+  \tabular{ll}{
+    \code{GLP_SF_GM   <- 0x01} \tab perform geometric mean scaling \cr
+    \code{GLP_SF_EQ   <- 0x10} \tab perform equilibration scaling \cr
+    \code{GLP_SF_2N   <- 0x20} \tab round scale factors to power of two \cr
+    \code{GLP_SF_SKIP <- 0x40} \tab skip if problem is well scaled \cr
+    \code{GLP_SF_AUTO <- 0x80} \tab choose scaling options automatically \cr
+  }
+  
+  \emph{solution indicator}
+  \tabular{ll}{
+    \code{GLP_SOL <- 1} \tab basic solution \cr
+    \code{GLP_IPT <- 2} \tab interior-point solution \cr
+    \code{GLP_MIP <- 3} \tab mixed integer solution \cr
+  }
+  
+  \emph{solution status}
+  \tabular{ll}{
+    \code{GLP_UNDEF  <- 1} \tab solution is undefined \cr
+    \code{GLP_FEAS   <- 2} \tab solution is feasible \cr
+    \code{GLP_INFEAS <- 3} \tab solution is infeasible \cr
+    \code{GLP_NOFEAS <- 4} \tab no feasible solution exists \cr
+    \code{GLP_OPT    <- 5} \tab solution is optimal \cr
+    \code{GLP_UNBND  <- 6} \tab solution is unbounded \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{basis factorization control parameters}{
+
+  \emph{type}
+  \tabular{ll}{
+    \code{GLP_BF_FT <-  0x01} \tab LUF + Forrest-Tomlin \cr
+    \code{GLP_BF_BG <-  0x02} \tab LUF + Schur compl. + Bartels-Golub \cr
+    \code{GLP_BF_GR <-  0x03} \tab LUF + Schur compl. + Givens rotation \cr
+    \code{GLP_BF_LUF <- 0x00} \tab plain LU-factorization \cr
+    \code{GLP_BF_BTF <- 0x10} \tab block triangular LU-factorization \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{simplex method control parameters}{
+
+  \emph{msg_lev} message level:
+  \tabular{ll}{
+    \code{GLP_MSG_OFF <- 0} \tab no output \cr
+    \code{GLP_MSG_ERR <- 1} \tab warning and error messages only \cr
+    \code{GLP_MSG_ON  <- 2} \tab normal output \cr
+    \code{GLP_MSG_ALL <- 3} \tab full output \cr
+    \code{GLP_MSG_DBG <- 4} \tab debug output \cr
+  }
+
+  \emph{meth} simplex method option:
+  \tabular{ll}{
+    \code{GLP_PRIMAL <- 1} \tab use primal simplex \cr
+    \code{GLP_DUALP  <- 2} \tab use dual; if it fails, use primal \cr
+    \code{GLP_DUAL   <- 3} \tab use dual simplex \cr
+  }
+
+  \emph{pricing} pricing technique:
+  \tabular{ll}{
+    \code{GLP_PT_STD <- 0x11} \tab standard (Dantzig rule) \cr
+    \code{GLP_PT_PSE <- 0x22} \tab projected steepest edge \cr
+  }
+
+  \emph{r_test} ratio test technique:
+  \tabular{ll}{
+    \code{GLP_RT_STD <- 0x11} \tab standard (textbook) \cr
+    \code{GLP_RT_HAR <- 0x22} \tab two-pass Harris' ratio test \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{interior-point solver control parameters}{
+
+  \emph{ord_alg} ordering algorithm:
+  \tabular{ll}{
+    \code{GLP_ORD_NONE   <- 0} \tab natural (original) ordering \cr
+    \code{GLP_ORD_QMD    <- 1} \tab quotient minimum degree (QMD) \cr
+    \code{GLP_ORD_AMD    <- 2} \tab approx. minimum degree (AMD) \cr
+    \code{GLP_ORD_SYMAMD <- 3} \tab approx. minimum degree (SYMAMD) \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{integer optimizer control parameters}{
+
+  \emph{br_tech} branching technique:
+  \tabular{ll}{
+    \code{GLP_BR_FFV <- 1} \tab first fractional variable \cr
+    \code{GLP_BR_LFV <- 2} \tab last fractional variable \cr
+    \code{GLP_BR_MFV <- 3} \tab most fractional variable \cr
+    \code{GLP_BR_DTH <- 4} \tab heuristic by Driebeck and Tomlin \cr
+    \code{GLP_BR_HPC <- 5} \tab hybrid pseudocost \cr
+  }
+
+  \emph{bt_tech} backtracking technique:
+  \tabular{ll}{
+    \code{GLP_BT_DFS <- 1} \tab depth first search \cr
+    \code{GLP_BT_BFS <- 2} \tab breadth first search \cr
+    \code{GLP_BT_BLB <- 3} \tab best local bound \cr
+    \code{GLP_BT_BPH <- 4} \tab best projection heuristic \cr
+  }
+
+  \emph{pp_tech} preprocessing technique:
+  \tabular{ll}{
+    \code{GLP_PP_NONE <- 0} \tab disable preprocessing \cr
+    \code{GLP_PP_ROOT <- 1} \tab preprocessing only on root level \cr
+    \code{GLP_PP_ALL  <- 2} \tab preprocessing on all levels \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{additional row attributes}{
+
+  \emph{the row origin flag}
+  \tabular{ll}{
+    \code{GLP_RF_REG  <- 0} \tab regular constraint \cr
+    \code{GLP_RF_LAZY <- 1} \tab "lazy" constraint \cr
+    \code{GLP_RF_CUT  <- 2} \tab cutting plane constraint \cr
+  }
+
+  \emph{the row class descriptor} klass
+  \tabular{ll}{
+    \code{GLP_RF_GMI <- 1} \tab Gomory's mixed integer cut \cr
+    \code{GLP_RF_MIR <- 2} \tab mixed integer rounding cut \cr
+    \code{GLP_RF_COV <- 3} \tab mixed cover cut \cr
+    \code{GLP_RF_CLQ <- 4} \tab clique cut \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{enable/disable flag}{
+
+  \tabular{ll}{
+    \code{GLP_ON  <- 1} \tab enable something \cr
+    \code{GLP_OFF <- 0} \tab disable something \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{reason codes}{
+  \tabular{ll}{
+    \code{GLP_IROWGEN <- 0x01} \tab request for row generation \cr
+    \code{GLP_IBINGO  <- 0x02} \tab better integer solution found \cr
+    \code{GLP_IHEUR   <- 0x03} \tab request for heuristic solution \cr
+    \code{GLP_ICUTGEN <- 0x04} \tab request for cut generation \cr
+    \code{GLP_IBRANCH <- 0x05} \tab request for branching \cr
+    \code{GLP_ISELECT <- 0x06} \tab request for subproblem selection \cr
+    \code{GLP_IPREPRO <- 0x07} \tab request for preprocessing \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{branch selection indicator}{
+
+  \tabular{ll}{
+    \code{GLP_NO_BRNCH <- 0} \tab select no branch \cr
+    \code{GLP_DN_BRNCH <- 1} \tab select down-branch \cr
+    \code{GLP_UP_BRNCH <- 2} \tab select up-branch \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{return codes}{
+
+  \tabular{ll}{
+    \code{GLP_EBADB   <- 0x01} \tab invalid basis \cr
+    \code{GLP_ESING   <- 0x02} \tab singular matrix \cr
+    \code{GLP_ECOND   <- 0x03} \tab ill-conditioned matrix \cr
+    \code{GLP_EBOUND  <- 0x04} \tab invalid bounds \cr
+    \code{GLP_EFAIL   <- 0x05} \tab solver failed \cr
+    \code{GLP_EOBJLL  <- 0x06} \tab objective lower limit reached \cr
+    \code{GLP_EOBJUL  <- 0x07} \tab objective upper limit reached \cr
+    \code{GLP_EITLIM  <- 0x08} \tab iteration limit exceeded \cr
+    \code{GLP_ETMLIM  <- 0x09} \tab time limit exceeded \cr
+    \code{GLP_ENOPFS  <- 0x0A} \tab no primal feasible solution \cr
+    \code{GLP_ENODFS  <- 0x0B} \tab no dual feasible solution \cr
+    \code{GLP_EROOT   <- 0x0C} \tab root LP optimum not provided \cr
+    \code{GLP_ESTOP   <- 0x0D} \tab search terminated by application \cr
+    \code{GLP_EMIPGAP <- 0x0E} \tab relative mip gap tolerance reached \cr
+    \code{GLP_ENOFEAS <- 0x0F} \tab no primal/dual feasible solution \cr
+    \code{GLP_ENOCVG  <- 0x10} \tab no convergence \cr
+    \code{GLP_EINSTAB <- 0x11} \tab numerical instability \cr
+    \code{GLP_EDATA   <- 0x12} \tab invalid data \cr
+    \code{GLP_ERANGE  <- 0x13} \tab result out of range \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{condition indicator}{
+
+  \tabular{ll}{
+    \code{GLP_KKT_PE <- 1} \tab primal equalities \cr
+    \code{GLP_KKT_PB <- 2} \tab primal bounds \cr
+    \code{GLP_KKT_DE <- 3} \tab dual equalities \cr
+    \code{GLP_KKT_DB <- 4} \tab dual bounds \cr
+    \code{GLP_KKT_CS <- 5} \tab complementary slackness \cr
+  }
+}
+
+%------------------------------------------------------------------------------
+\section{MPS file format}{
+
+  \tabular{ll}{
+    \code{GLP_MPS_DECK <- 1} \tab fixed (ancient) \cr
+    \code{GLP_MPS_FILE <- 2} \tab free (modern) \cr
+  }
+}
+
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{status_codeGLPK}}, \code{\link{return_codeGLPK}}
+}
+
+\keyword{ optimize }
+
+
diff --git a/man/glpkPtr-class.Rd b/man/glpkPtr-class.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..69b165210967a8cdd16a14b5d3a3620dcea4a8f4
--- /dev/null
+++ b/man/glpkPtr-class.Rd
@@ -0,0 +1,93 @@
+\name{glpkPtr-class}
+
+\Rdversion{1.1}
+\docType{class}
+
+\alias{glpkPtr-class}
+\alias{glpkPtr}
+\alias{isGLPKpointer,glpkPtr-method}
+\alias{isNULLpointerGLPK,glpkPtr-method}
+\alias{isTRWKSpointer,glpkPtr-method}
+\alias{glpkPointer,glpkPtr-method}
+\alias{glpkPtrType,glpkPtr-method}
+\alias{glpkPtrType<-,glpkPtr-method}
+\alias{isGLPKpointer}
+\alias{isNULLpointerGLPK}
+\alias{isTRWKSpointer}
+\alias{glpkPointer}
+\alias{glpkPtrType}
+\alias{glpkPtrType<-}
+
+\title{Class \code{"glpkPtr"}}
+
+\description{
+  Structure of the class \code{"glpkPtr"}. Objects of that class are
+  used to hold pointers to C structures used by GLPK.
+}
+
+\section{Objects from the Class}{
+    Objects can be created by calls of the form\cr
+    \code{test <- initProbGLPK()} or\cr
+    \code{test <- mplAllocWkspGLPK()}.
+}
+
+\section{Slots}{
+  \describe{
+    \item{\code{glpkPtrType}:}{
+        Object of class \code{"character"} giving the pointer type.
+    }
+    \item{\code{glpkPointer}:}{
+        Object of class \code{"externalptr"} containig the pointer to a
+        C structure.
+    }
+  }
+}
+
+\section{Methods}{
+  \describe{
+    \item{isGLPKpointer}{\code{signature(object = "glpkPtr")}:
+        returns \code{TRUE} if \code{glpkPointer(object)} is a pointer to a
+        GLPK problem object, otherwise \code{FALSE}.
+    }
+    \item{isNULLpointerGLPK}{\code{signature(object = "glpkPtr")}:
+        returns \code{TRUE} if \code{glpkPointer(object)} is a NULL pointer,
+        otherwise \code{FALSE}.
+    }
+    \item{isTRWKSpointer}{\code{signature(object = "glpkPtr")}:
+        returns \code{TRUE} if \code{glpkPointer(object)} is a pointer to a
+        MathProg translator workspace, otherwise \code{FALSE}.
+    }
+    \item{glpkPointer}{\code{signature(object = "glpkPtr")}:
+        gets the \code{glpkPointer} slot.
+    }
+    \item{glpkPtrType}{\code{signature(object = "glpkPtr")}:
+        gets the \code{glpkPtrType} slot.
+    }
+    \item{glpkPtrType<-}{\code{signature(object = "glpkPtr")}:
+        sets the \code{glpkPtrType} slot.
+    }
+  }
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{mplAllocWkspGLPK}} and \code{\link{initProbGLPK}}.
+}
+
+\examples{
+    showClass("glpkPtr")
+}
+
+\keyword{ optimize }
+
diff --git a/man/initProbGLPK.Rd b/man/initProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..65dce1c5637b24ff701ccda736da7d5794ce65b5
--- /dev/null
+++ b/man/initProbGLPK.Rd
@@ -0,0 +1,50 @@
+\name{initProbGLPK}
+\alias{initProbGLPK}
+\alias{glp_create_prob}
+
+\title{
+  Create a GLPK Problem Object
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_create_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  initProbGLPK(ptrtype = "glpk_prob")
+}
+
+\arguments{
+  \item{ptrtype}{
+    A name for the pointer to a GLPK problem object.
+  }
+}
+
+\details{
+  Interface to the C function \code{initProb} which calls the GLPK
+  function \code{glp_create_prob}.
+}
+
+\value{
+  An instance of class \code{"\linkS4class{glpkPtr}"}.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{"\linkS4class{glpkPtr}"}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/loadMatrixGLPK.Rd b/man/loadMatrixGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..cd1681a90e9f3de0034e7a28e8c5d7faaa61b9cc
--- /dev/null
+++ b/man/loadMatrixGLPK.Rd
@@ -0,0 +1,60 @@
+\name{loadMatrixGLPK}
+\alias{loadMatrixGLPK}
+\alias{glp_load_matrix}
+
+\title{
+  Load/Replace the Whole Constraint Matrix
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_load_matrix}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  loadMatrixGLPK(lp, ne, ia, ja, ra)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{ne}{
+    Number of non-zero elements.
+  }
+  \item{ia}{
+    Row indices of the non-zero elements.
+  }
+  \item{ja}{
+    Colunm indices of the non-zero elements.
+  }
+  \item{ra}{
+    The numeric values of the constraint coefficients.
+  }
+}
+
+\details{
+  Interface to the C function \code{loadMatrix} which calls the GLPK
+  function \code{glp_load_matrix}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/mipColValGLPK.Rd b/man/mipColValGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..870ec5bb67c01fd70f7494e6717bada068fdc735
--- /dev/null
+++ b/man/mipColValGLPK.Rd
@@ -0,0 +1,50 @@
+\name{mipColValGLPK}
+\alias{mipColValGLPK}
+\alias{glp_mip_col_val}
+
+\title{
+  Retrieve Column Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mip_col_val}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mipColValGLPK(lp, j)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number \code{j}.
+  }
+}
+
+\details{
+  Interface to the C function \code{mipColVal} which calls the GLPK
+  function \code{glp_mip_col_val}.
+}
+
+\value{
+  Column value of column \code{j}.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/mipColsValGLPK.Rd b/man/mipColsValGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..fdf641a3ce5393f35568a506586bf765d028834f
--- /dev/null
+++ b/man/mipColsValGLPK.Rd
@@ -0,0 +1,46 @@
+\name{mipColsValGLPK}
+\alias{mipColsValGLPK}
+
+\title{
+  Retrieve Column Value of all Columns
+}
+
+\description{
+  This is an advanced version of \code{\link{mipColValGLPK}}.
+}
+
+\usage{
+  mipColsValGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{mipColsVal} which calls the GLPK
+  function \code{glp_mip_col_val}.
+}
+
+\value{
+  The column values of all columns are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/mipObjValGLPK.Rd b/man/mipObjValGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..14d776450b271fd1b9b799e4bf0c5ec1b399ba4c
--- /dev/null
+++ b/man/mipObjValGLPK.Rd
@@ -0,0 +1,47 @@
+\name{mipObjValGLPK}
+\alias{mipObjValGLPK}
+\alias{glp_mip_obj_val}
+
+\title{
+  Retrieve Objective Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mip_obj_val}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mipObjValGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{mipObjVal} which calls the GLPK
+  function \code{glp_mip_obj_val}.
+}
+
+\value{
+  Objective value.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/mipRowValGLPK.Rd b/man/mipRowValGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..87b6e7d7eb39db460969262577ea4fcf79e633e1
--- /dev/null
+++ b/man/mipRowValGLPK.Rd
@@ -0,0 +1,50 @@
+\name{mipRowValGLPK}
+\alias{mipRowValGLPK}
+\alias{glp_mip_row_val}
+
+\title{
+  Retrieve Row Value
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mip_row_val}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mipRowValGLPK(lp, i)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number \code{i}.
+  }
+}
+
+\details{
+  Interface to the C function \code{mipRowVal} which calls the GLPK
+  function \code{glp_mip_row_val}.
+}
+
+\value{
+  Row value of row \code{i}.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/mipRowsValGLPK.Rd b/man/mipRowsValGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..22546c3a4d75b480233d1f69e3f7c3a17192d3f6
--- /dev/null
+++ b/man/mipRowsValGLPK.Rd
@@ -0,0 +1,46 @@
+\name{mipRowsValGLPK}
+\alias{mipRowsValGLPK}
+
+\title{
+  Retrieve Row Value of all Rows
+}
+
+\description{
+  This is an advanced version of \code{\link{mipRowValGLPK}}.
+}
+
+\usage{
+  mipRowsValGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{mipRowsVal} which calls the GLPK
+  function \code{glp_mip_row_val}.
+}
+
+\value{
+  The row values of all rows are returned.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/mipStatusGLPK.Rd b/man/mipStatusGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..a7c6bc241292ef8ac3874819ca2d450f88d4a925
--- /dev/null
+++ b/man/mipStatusGLPK.Rd
@@ -0,0 +1,47 @@
+\name{mipStatusGLPK}
+\alias{mipStatusGLPK}
+\alias{glp_mip_status}
+
+\title{
+  Determine Status of MIP Solution
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mip_status}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mipStatusGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{mipStatus} which calls the GLPK
+  function \code{glp_mip_status}.
+}
+
+\value{
+  Status of MIP Solution.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/mplAllocWkspGLPK.Rd b/man/mplAllocWkspGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..12739d3fa096ba54eb0b5abc1255dc2ab0bdc9d1
--- /dev/null
+++ b/man/mplAllocWkspGLPK.Rd
@@ -0,0 +1,50 @@
+\name{mplAllocWkspGLPK}
+\alias{mplAllocWkspGLPK}
+\alias{glp_mpl_alloc_wksp}
+
+\title{
+  Allocate Translator Workspace
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mpl_alloc_wksp}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mplAllocWkspGLPK(ptrtype = "tr_wksp")
+}
+
+\arguments{
+  \item{ptrtype}{
+    A name for the pointer to a translator workspace.
+  }
+}
+
+\details{
+  Interface to the C function \code{mplAllocWksp} which calls the GLPK
+  function \code{glp_mpl_alloc_wksp}.
+}
+
+\value{
+  An instance of class \code{"\linkS4class{glpkPtr}"}.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{"\linkS4class{glpkPtr}"}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/mplBuildProbGLPK.Rd b/man/mplBuildProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..de57a122002471d24fc9e87659979b2291bbb65c
--- /dev/null
+++ b/man/mplBuildProbGLPK.Rd
@@ -0,0 +1,60 @@
+\name{mplBuildProbGLPK}
+\alias{mplBuildProbGLPK}
+\alias{glp_mpl_build_prob}
+
+\title{
+  Build Problem Instance From Model
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mpl_build_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mplBuildProbGLPK(wk, lp)
+}
+
+\arguments{
+  \item{wk}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{mplAllocWkspGLPK}}. This is basically a pointer to a GLPK
+    translocator workspace.
+  }
+  \item{lp}{
+    A pointer to a GLPK problem object.
+  }
+}
+
+\details{
+  Interface to the C function \code{mplBuildProb} which calls the GLPK
+  function \code{glp_mpl_build_prob}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{mplAllocWkspGLPK}},
+  \code{\link{mplFreeWkspGLPK}},
+  \code{\link{mplGenerateGLPK}},
+  \code{\link{mplPostsolveGLPK}},
+  \code{\link{mplReadDataGLPK}} and
+  \code{\link{mplReadModelGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/mplFreeWkspGLPK.Rd b/man/mplFreeWkspGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..0171355339172cb0fde90c77753abfbfb9648fff
--- /dev/null
+++ b/man/mplFreeWkspGLPK.Rd
@@ -0,0 +1,57 @@
+\name{mplFreeWkspGLPK}
+\alias{mplFreeWkspGLPK}
+\alias{glp_mpl_free_wksp}
+
+\title{
+  Free Translator Workspace
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mpl_free_wksp}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mplFreeWkspGLPK(wk)
+}
+
+\arguments{
+  \item{wk}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{mplAllocWkspGLPK}}. This is basically a pointer to a GLPK
+    translocator workspace.
+  }
+}
+
+\details{
+  Interface to the C function \code{mplFreeWksp} which calls the GLPK
+  function \code{glp_mpl_free_wksp}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{mplAllocWkspGLPK}},
+  \code{\link{mplBuildProbGLPK}},
+  \code{\link{mplGenerateGLPK}},
+  \code{\link{mplPostsolveGLPK}},
+  \code{\link{mplReadDataGLPK}} and
+  \code{\link{mplReadModelGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/mplGenerateGLPK.Rd b/man/mplGenerateGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..168241f406e950b1a084f85131755baffd33e153
--- /dev/null
+++ b/man/mplGenerateGLPK.Rd
@@ -0,0 +1,60 @@
+\name{mplGenerateGLPK}
+\alias{mplGenerateGLPK}
+\alias{glp_mpl_generate}
+
+\title{
+  Generate the Model
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mpl_generate}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mplGenerateGLPK(wk, fname = NULL)
+}
+
+\arguments{
+  \item{wk}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{mplAllocWkspGLPK}}. This is basically a pointer to a GLPK
+    translocator workspace.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{mplGenerate} which calls the GLPK
+  function \code{glp_mpl_generate}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{mplAllocWkspGLPK}},
+  \code{\link{mplBuildProbGLPK}},
+  \code{\link{mplFreeWkspGLPK}},
+  \code{\link{mplPostsolveGLPK}},
+  \code{\link{mplReadDataGLPK}} and
+  \code{\link{mplReadModelGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/mplPostsolveGLPK.Rd b/man/mplPostsolveGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..09eb04e636965303f6d0242a9e36c5bc76d11808
--- /dev/null
+++ b/man/mplPostsolveGLPK.Rd
@@ -0,0 +1,65 @@
+\name{mplPostsolveGLPK}
+\alias{mplPostsolveGLPK}
+\alias{glp_mpl_postsolve}
+
+\title{
+  Postsolve Model
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mpl_postsolve}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mplPostsolveGLPK(wk, lp, sol)
+}
+
+\arguments{
+  \item{wk}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{mplAllocWkspGLPK}}. This is basically a pointer to a GLPK
+    translocator workspace.
+  }
+  \item{lp}{
+    A pointer to a GLPK problem object.
+  }
+  \item{sol}{
+    Type of solution to be copied to the translator workspace, for possible
+    values, see \code{\link{glpkConstants}}, section
+    \sQuote{LP/MIP problem object}.
+  }
+}
+
+\details{
+  Interface to the C function \code{mplPostsolve} which calls the GLPK
+  function \code{glp_mpl_postsolve}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{mplAllocWkspGLPK}},
+  \code{\link{mplBuildProbGLPK}},
+  \code{\link{mplFreeWkspGLPK}},
+  \code{\link{mplGenerateGLPK}},
+  \code{\link{mplReadDataGLPK}} and
+  \code{\link{mplReadModelGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/mplReadDataGLPK.Rd b/man/mplReadDataGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..19d638293fc510cd7d394406c618c5a4aae3e454
--- /dev/null
+++ b/man/mplReadDataGLPK.Rd
@@ -0,0 +1,60 @@
+\name{mplReadDataGLPK}
+\alias{mplReadDataGLPK}
+\alias{glp_mpl_read_data}
+
+\title{
+  Read and Translate Data Section
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mpl_read_data}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mplReadDataGLPK(wk, fname)
+}
+
+\arguments{
+  \item{wk}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{mplAllocWkspGLPK}}. This is basically a pointer to a GLPK
+    translocator workspace.
+  }
+  \item{fname}{
+    The name of the data file to be read in.
+  }
+}
+
+\details{
+  Interface to the C function \code{mplReadData} which calls the GLPK
+  function \code{glp_mpl_read_data}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{mplAllocWkspGLPK}},
+  \code{\link{mplBuildProbGLPK}},
+  \code{\link{mplFreeWkspGLPK}},
+  \code{\link{mplGenerateGLPK}},
+  \code{\link{mplPostsolveGLPK}} and
+  \code{\link{mplReadModelGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/mplReadModelGLPK.Rd b/man/mplReadModelGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..df96f0b3fa8fc3b16cc24ff93cb0a491cbd64324
--- /dev/null
+++ b/man/mplReadModelGLPK.Rd
@@ -0,0 +1,63 @@
+\name{mplReadModelGLPK}
+\alias{mplReadModelGLPK}
+\alias{glp_mpl_read_model}
+
+\title{
+  Read and Translate Model Section
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_mpl_read_model}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  mplReadModelGLPK(wk, fname, skip)
+}
+
+\arguments{
+  \item{wk}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{mplAllocWkspGLPK}}. This is basically a pointer to a GLPK
+    translocator workspace.
+  }
+  \item{fname}{
+    The name of the model file to be read in.
+  }
+  \item{skip}{
+    Flag, how to treat the data section.
+  }
+}
+
+\details{
+  Interface to the C function \code{mplReadModel} which calls the GLPK
+  function \code{glp_mpl_read_model}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{mplAllocWkspGLPK}},
+  \code{\link{mplBuildProbGLPK}},
+  \code{\link{mplFreeWkspGLPK}},
+  \code{\link{mplGenerateGLPK}},
+  \code{\link{mplPostsolveGLPK}} and
+  \code{\link{mplReadDataGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/printIptGLPK.Rd b/man/printIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..135dacdff3ee981ae4bb9a11fa99f13cb6638aa3
--- /dev/null
+++ b/man/printIptGLPK.Rd
@@ -0,0 +1,59 @@
+\name{printIptGLPK}
+\alias{printIptGLPK}
+\alias{glp_print_ipt}
+
+\title{
+  Write Interior-Point Solution in Printable Format
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_print_ipt}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  printIptGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{printIpt} which calls the GLPK
+  function \code{glp_print_ipt}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero and prints an
+  error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{printSolGLPK}}, \code{\link{readSolGLPK}},
+  \code{\link{writeSolGLPK}}, \code{\link{readIptGLPK}},
+  \code{\link{writeIptGLPK}}, \code{\link{printMIPGLPK}},
+  \code{\link{readMIPGLPK}} and \code{\link{writeMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/printMIPGLPK.Rd b/man/printMIPGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..4f63bc3bb7efdf046f09f46ee006b167948bcb80
--- /dev/null
+++ b/man/printMIPGLPK.Rd
@@ -0,0 +1,59 @@
+\name{printMIPGLPK}
+\alias{printMIPGLPK}
+\alias{glp_print_mip}
+
+\title{
+  Write Interior-Point Solution in Printable Format
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_print_mip}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  printMIPGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{printMIP} which calls the GLPK
+  function \code{glp_print_mip}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero and prints an
+  error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{printSolGLPK}}, \code{\link{readSolGLPK}},
+  \code{\link{writeSolGLPK}}, \code{\link{printIptGLPK}},
+  \code{\link{readIptGLPK}}, \code{\link{writeIptGLPK}},
+  \code{\link{readMIPGLPK}} and \code{\link{writeMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/printRangesGLPK.Rd b/man/printRangesGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..c0fde034317446bcb4c3408cb21b01f891ebf96f
--- /dev/null
+++ b/man/printRangesGLPK.Rd
@@ -0,0 +1,56 @@
+\name{printRangesGLPK}
+\alias{printRangesGLPK}
+\alias{glp_print_ranges}
+
+\title{
+  Print Sensitivity Analysis Report
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_print_ranges}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  printRangesGLPK(lp, numrc = 0, rowcol = NULL, fname = "sar.txt")
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{numrc}{
+    Length of the row/column list (argument \code{rowcol}).
+  }
+  \item{rowcol}{
+    Ordinal numbers of rows and columns to be analyzed.
+  }
+  \item{fname}{
+    A filename.
+  }
+}
+
+\details{
+  Interface to the C function \code{printRanges} which calls the GLPK
+  function \code{glp_print_ranges}.
+}
+
+\value{
+  Zero on success, otherwise non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/printSolGLPK.Rd b/man/printSolGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..0625693bc6df3c919715053bb9f82f9ac9ddd124
--- /dev/null
+++ b/man/printSolGLPK.Rd
@@ -0,0 +1,59 @@
+\name{printSolGLPK}
+\alias{printSolGLPK}
+\alias{glp_print_sol}
+
+\title{
+  Write Basic Solution in Printable Format
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_print_sol}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  printSolGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{printSol} which calls the GLPK
+  function \code{glp_print_sol}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero and prints an
+  error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{readSolGLPK}}, \code{\link{writeSolGLPK}},
+  \code{\link{printIptGLPK}}, \code{\link{readIptGLPK}},
+  \code{\link{writeIptGLPK}}, \code{\link{printMIPGLPK}},
+  \code{\link{readMIPGLPK}} and \code{\link{writeMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/readIptGLPK.Rd b/man/readIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..468c1db3be7c95705f8682c661d296122ad93ec1
--- /dev/null
+++ b/man/readIptGLPK.Rd
@@ -0,0 +1,58 @@
+\name{readIptGLPK}
+\alias{readIptGLPK}
+\alias{glp_read_ipt}
+
+\title{
+  Read Interior-Point Solution From Text File
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_read_ipt}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  readIptGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be read in.
+  }
+}
+
+\details{
+  Interface to the C function \code{readIpt} which calls the GLPK
+  function \code{glp_read_ipt}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{printSolGLPK}}, \code{\link{readSolGLPK}},
+  \code{\link{writeSolGLPK}}, \code{\link{printIptGLPK}},
+  \code{\link{writeIptGLPK}}, \code{\link{printMIPGLPK}},
+  \code{\link{readMIPGLPK}} and \code{\link{writeMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/readLPGLPK.Rd b/man/readLPGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..796c67f1046944dd82c1e06e6d2da11cb65207dc
--- /dev/null
+++ b/man/readLPGLPK.Rd
@@ -0,0 +1,58 @@
+\name{readLPGLPK}
+\alias{readLPGLPK}
+\alias{glp_read_lp}
+
+\title{
+  Read Problem Data in CPLEX LP Format
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_read_lp}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  readLPGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be read in.
+  }
+}
+
+\details{
+  Interface to the C function \code{readLP} which calls the GLPK
+  function \code{glp_read_lp}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero
+  and prints an error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{readMPSGLPK}}, \code{\link{readProbGLPK}}, 
+  \code{\link{writeMPSGLPK}}, \code{\link{writeLPGLPK}} and
+  \code{\link{writeProbGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/readMIPGLPK.Rd b/man/readMIPGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..307bf4d412eea16244d2dd6c1e50b41403ea6a11
--- /dev/null
+++ b/man/readMIPGLPK.Rd
@@ -0,0 +1,58 @@
+\name{readMIPGLPK}
+\alias{readMIPGLPK}
+\alias{glp_read_mip}
+
+\title{
+  Read MIP Solution From Text File
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_read_mip}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  readMIPGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be read in.
+  }
+}
+
+\details{
+  Interface to the C function \code{readMIP} which calls the GLPK
+  function \code{glp_read_mip}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{printSolGLPK}}, \code{\link{readSolGLPK}},
+  \code{\link{writeSolGLPK}}, \code{\link{printIptGLPK}},
+  \code{\link{readIptGLPK}}, \code{\link{writeIptGLPK}},
+  \code{\link{printMIPGLPK}} and \code{\link{writeMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/readMPSGLPK.Rd b/man/readMPSGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..552025bdb0abf4ae8c759966ef5a77d0181533d2
--- /dev/null
+++ b/man/readMPSGLPK.Rd
@@ -0,0 +1,62 @@
+\name{readMPSGLPK}
+\alias{readMPSGLPK}
+\alias{glp_read_mps}
+
+\title{
+  Read Problem Data in MPS Format
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_read_mps}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  readMPSGLPK(lp, fmt, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fmt}{
+    MPS format. See \code{\link{glpkConstants}}, section
+    \sQuote{MPS file formats}.
+  }
+  \item{fname}{
+    The name of the text file to be read in.
+  }
+}
+
+\details{
+  Interface to the C function \code{readMPS} which calls the GLPK
+  function \code{glp_read_mps}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero
+  and prints an error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{readLPGLPK}}, \code{\link{readProbGLPK}}, 
+  \code{\link{writeMPSGLPK}}, \code{\link{writeLPGLPK}},
+  \code{\link{writeProbGLPK}} and \code{\link{glpkConstants}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/readProbGLPK.Rd b/man/readProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..963a2b5169faa829d6839f9752d6ef1bd1a067b2
--- /dev/null
+++ b/man/readProbGLPK.Rd
@@ -0,0 +1,59 @@
+\name{readProbGLPK}
+\alias{readProbGLPK}
+\alias{glp_read_prob}
+
+\title{
+  Read Problem Data in GLPK F
+  ormat
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_read_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  readProbGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be read in.
+  }
+}
+
+\details{
+  Interface to the C function \code{readProb} which calls the GLPK
+  function \code{glp_read_prob}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero
+  and prints an error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{readMPSGLPK}}, \code{\link{readLPGLPK}}, 
+  \code{\link{writeMPSGLPK}}, \code{\link{writeLPGLPK}} and
+  \code{\link{writeProbGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/readSolGLPK.Rd b/man/readSolGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..a83318118232cf961b06ac3aa99a39f43d5a8f2b
--- /dev/null
+++ b/man/readSolGLPK.Rd
@@ -0,0 +1,58 @@
+\name{readSolGLPK}
+\alias{readSolGLPK}
+\alias{glp_read_sol}
+
+\title{
+  Read Basic Solution From Text File
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_read_sol}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  readSolGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be read in.
+  }
+}
+
+\details{
+  Interface to the C function \code{readSol} which calls the GLPK
+  function \code{glp_read_sol}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{printSolGLPK}}, \code{\link{writeSolGLPK}}, 
+  \code{\link{printIptGLPK}}, \code{\link{readIptGLPK}},
+  \code{\link{writeIptGLPK}}, \code{\link{printMIPGLPK}},
+  \code{\link{readMIPGLPK}} and \code{\link{writeMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/return_codeGLPK.Rd b/man/return_codeGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..bcc00a89deeb3ba9b3de9bd0c5c082877e184ca6
--- /dev/null
+++ b/man/return_codeGLPK.Rd
@@ -0,0 +1,43 @@
+\name{return_codeGLPK}
+\alias{return_codeGLPK}
+
+\title{
+  Translates a GLPK Return Code into a Human Readable String
+}
+
+\description{
+  Translates a GLPK return code into a human readable string.
+}
+
+\usage{
+  return_codeGLPK(code)
+}
+
+\arguments{
+  \item{code}{
+    Return code from GLPK.
+  }
+}
+
+\value{
+  A character string associated with the GLPK return code.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{return codes}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/scaleProbGLPK.Rd b/man/scaleProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..0046968ff94d195eef5db426454ea407b50b74d0
--- /dev/null
+++ b/man/scaleProbGLPK.Rd
@@ -0,0 +1,55 @@
+\name{scaleProbGLPK}
+\alias{scaleProbGLPK}
+\alias{glp_scale_prob}
+
+\title{
+  Scale Problem Data
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_scale_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  scaleProbGLPK(lp, opt)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{opt}{
+    Scaling option, see \code{\link{glpkConstants}}, section
+    \sQuote{LP/MIP problem object} for possible values.
+  }
+}
+
+\details{
+  Interface to the C function \code{scaleProb} which calls the GLPK
+  function \code{glp_scale_prob}.
+}
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setBfcpGLPK.Rd b/man/setBfcpGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..eafe310b51c82b56c3c505c23ffdcc6be2318dc3
--- /dev/null
+++ b/man/setBfcpGLPK.Rd
@@ -0,0 +1,62 @@
+\name{setBfcpGLPK}
+\alias{setBfcpGLPK}
+\alias{glp_set_bfcp}
+
+\title{
+  Change Basis Factorization Control Parameters
+}
+
+\description{
+  Sets/Changes the values of corresponding members of in the structure
+  \code{glp_bfcp}. Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setBfcpGLPK(lp, parm, val)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{parm}{
+    A vector containing integer values or symbolic names
+    of the control parameters to be changed
+    (see \code{\link{glpkConstants}}, section \sQuote{Control Parameters}).
+  }
+  \item{val}{
+    A vector containing the new values for the corresponding
+    control parameters.
+  }
+}
+
+\details{
+  The Arguments \code{parm} and \code{val} must have the
+  same length. The value \code{val[i]} belongs to the
+  parameter \code{parm[i]}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setColBndGLPK.Rd b/man/setColBndGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ec18d4fdd39d1b1b4b6784c556d0fa6c066e75e2
--- /dev/null
+++ b/man/setColBndGLPK.Rd
@@ -0,0 +1,65 @@
+\name{setColBndGLPK}
+\alias{setColBndGLPK}
+\alias{glp_set_col_bnds}
+
+\title{
+  Set/Change Column Bounds
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_col_bnds}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setColBndGLPK(lp, j, type, lb, ub)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number \code{j}.
+  }
+  \item{type}{
+    Column type. For possible values, see \code{\link{glpkConstants}},
+    section \sQuote{LP/MIP problem object}.
+  }
+  \item{lb}{
+    Lower bound.
+  }
+  \item{ub}{
+    Upper bound.
+  }
+}
+
+\details{
+  Interface to the C function \code{setColBnd} which calls the GLPK
+  function \code{glp_set_col_bnds}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setColKindGLPK.Rd b/man/setColKindGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..8654f6d35b535c0d3fc108c96c3d195d44dc3ff5
--- /dev/null
+++ b/man/setColKindGLPK.Rd
@@ -0,0 +1,59 @@
+\name{setColKindGLPK}
+\alias{setColKindGLPK}
+\alias{glp_set_col_kind}
+
+\title{
+  Set Column Kind
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_col_kind}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setColKindGLPK(lp, j, kind)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number \code{j}.
+  }
+  \item{kind}{
+    Kind of column number \code{j}, for possible values see
+    \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+  }
+}
+
+\details{
+  Interface to the C function \code{setColKind} which calls the GLPK
+  function \code{glp_set_col_kind}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setColNameGLPK.Rd b/man/setColNameGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..2eec413874787b4649eb5862b6be51852aa7442f
--- /dev/null
+++ b/man/setColNameGLPK.Rd
@@ -0,0 +1,54 @@
+\name{setColNameGLPK}
+\alias{setColNameGLPK}
+\alias{glp_set_col_name}
+
+\title{
+  Set/Change Column Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_col_name}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setColNameGLPK(lp, j, cname = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+  \item{cname}{
+    Column name.
+  }
+}
+
+\details{
+  Interface to the C function \code{setColName} which calls the GLPK
+  function \code{glp_set_col_name}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setColStatGLPK.Rd b/man/setColStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..a4ef3c9c808c816b2bb6c671aad44581dcb1a746
--- /dev/null
+++ b/man/setColStatGLPK.Rd
@@ -0,0 +1,58 @@
+\name{setColStatGLPK}
+\alias{setColStatGLPK}
+\alias{glp_set_col_stat}
+
+\title{
+  Set column status
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_col_stat}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setColStatGLPK(lp, j, stat)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+  \item{stat}{
+    A status parameter, see \code{\link{glpkConstants}}, section
+    \sQuote{LP/MIP problem object} for possible values.
+  }
+}
+
+\details{
+  Interface to the C function \code{setColStat} which calls the GLPK
+  function \code{glp_set_col_stat}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
diff --git a/man/setColsBndsGLPK.Rd b/man/setColsBndsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..45bf48f1831ce4b25879043bfb6f0fd421b9d856
--- /dev/null
+++ b/man/setColsBndsGLPK.Rd
@@ -0,0 +1,68 @@
+\name{setColsBndsGLPK}
+\alias{setColsBndsGLPK}
+
+\title{
+  Set/Change Column Bounds
+}
+
+\description{
+  This is an advanced version of \code{\link{setColBndGLPK}}.
+  Here, \code{j} can be an integer vector, \code{lb} and \code{ub}
+  can be numeric vectors.
+}
+
+\usage{
+  setColsBndsGLPK(lp, j, lb, ub, type = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Vector of column numbers.
+  }
+  \item{lb}{
+    Vector of lower bounds.
+  }
+  \item{ub}{
+    Vector of upper bounds.
+  }
+  \item{type}{
+    Vector of variable types (default: NULL). For possible values, see
+    \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+  }
+}
+
+\details{
+  Interface to the C function \code{setColsBnds} which calls the GLPK
+  function \code{glp_set_col_bnds}.
+  
+  If \code{type} is set to NULL, the type of the variables will be estimated.
+  If lb[i] equals ub[i], variable j[i] is fixed, otherwise double bounded.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setColsBndsObjCoefsGLPK.Rd b/man/setColsBndsObjCoefsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..246c36c8534d42c7de384b5c75012a85d4739c10
--- /dev/null
+++ b/man/setColsBndsObjCoefsGLPK.Rd
@@ -0,0 +1,73 @@
+\name{setColsBndsObjCoefsGLPK}
+\alias{setColsBndsObjCoefsGLPK}
+
+\title{
+  Set/Change Column Bounds and Objective Coefficients and/or Constant Term
+}
+
+\description{
+  This is an combined version of \code{\link{setColsBndsGLPK}} and
+  \code{\link{setObjCoefsGLPK}}. Here, \code{j} can be an integer
+  vector, \code{lb}, \code{ub} and \code{obj_coef} can be numeric
+  vectors.
+}
+
+\usage{
+  setColsBndsObjCoefsGLPK(lp, j, lb, ub, obj_coef, type = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Vector of column numbers.
+  }
+  \item{lb}{
+    Vector of lower bounds.
+  }
+  \item{ub}{
+    Vector of upper bounds.
+  }
+  \item{obj_coef}{
+    Vector of objective coefficients.
+  }
+  \item{type}{
+    Vector of variable types (default: NULL). For possible values, see
+    \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+  }
+}
+
+\details{
+  Interface to the C function \code{setColsBndsObjCoefs} which
+  calls the GLPK functions \code{glp_set_col_bnds} and
+  \code{glp_set_obj_coef}.
+  
+  If \code{type} is set to NULL, the type of the variables will be estimated.
+  If lb[i] equals ub[i], variable j[i] is fixed, otherwise double bounded.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setColsKindGLPK.Rd b/man/setColsKindGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..86ad70a7ed13ca66a86ecb4272a5523ce563582c
--- /dev/null
+++ b/man/setColsKindGLPK.Rd
@@ -0,0 +1,56 @@
+\name{setColsKindGLPK}
+\alias{setColsKindGLPK}
+
+\title{
+  Set Column Kind for a Set of Columns
+}
+\description{
+  This is an advanced version of \code{\link{setColKindGLPK}}.
+  Here, \code{j} can be an integer vector.
+}
+\usage{
+  setColsKindGLPK(lp, j, kind)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    An integer vector of column indices.
+  }
+  \item{kind}{
+    An integer vector of column kinds, for possible values see
+    \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+  }
+}
+
+\details{
+  Interface to the C function \code{setColsKind} which calls the GLPK
+  function \code{glp_set_col_kind}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setColsNamesGLPK.Rd b/man/setColsNamesGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..56461c3424a62bd9ab2f0a8636c538aeff5100f9
--- /dev/null
+++ b/man/setColsNamesGLPK.Rd
@@ -0,0 +1,57 @@
+\name{setColsNamesGLPK}
+\alias{setColsNamesGLPK}
+
+\title{
+  Set/Change Column Names
+}
+
+\description{
+  This is an advanced version of \code{\link{setColNameGLPK}}.
+  Here, \code{j} can be an integer vector, \code{cnames} can be a character
+  vector.
+}
+\usage{
+  setColsNamesGLPK(lp, j, cnames = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Vector of column numbers.
+  }
+  \item{cnames}{
+    Vector of column names of the same length as \code{j} or \code{NULL}.
+  }
+}
+
+\details{
+  Interface to the C function \code{setColsNames} which calls the GLPK
+  function \code{glp_set_col_name}.
+
+  If \code{cnames} is set to \code{NULL}, all column names for column indices in
+  \code{j} will be removed. If \code{cname[k]} is the empty string \code{""},
+  column name \code{j[k]} will be removed.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setDefaultIptParmGLPK.Rd b/man/setDefaultIptParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..92e50d9e385845f8027473531094bcb3af75ecc0
--- /dev/null
+++ b/man/setDefaultIptParmGLPK.Rd
@@ -0,0 +1,44 @@
+\name{setDefaultIptParmGLPK}
+\alias{setDefaultIptParmGLPK}
+\alias{glp_init_iptcp}
+
+\title{
+  Sets the Default Control Parameters for the Interior-point Method.
+}
+
+\description{
+  Initializes a new structure \code{glp_iptcp}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setDefaultIptParmGLPK()
+}
+
+\details{
+  Interface to the C function \code{setDefaultIptParm} which calls the GLPK
+  function \code{glp_init_iptcp}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{Control Parameters}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/setDefaultMIPParmGLPK.Rd b/man/setDefaultMIPParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..b13dd96931cb70ae8f5395fbc50c6b45177474c5
--- /dev/null
+++ b/man/setDefaultMIPParmGLPK.Rd
@@ -0,0 +1,44 @@
+\name{setDefaultMIPParmGLPK}
+\alias{setDefaultMIPParmGLPK}
+\alias{glp_init_iocp}
+
+\title{
+  Sets the Default Control Parameters for the MIP Method
+}
+
+\description{
+  Initializes a new structure \code{glp_iocp}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setDefaultMIPParmGLPK()
+}
+
+\details{
+  Interface to the C function \code{setDefaultMIPParm} which calls the GLPK
+  function \code{glp_init_iocp}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{Control Parameters}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/setDefaultSmpParmGLPK.Rd b/man/setDefaultSmpParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..67e0dd8447e348befc4fbd122bb859237c5045b7
--- /dev/null
+++ b/man/setDefaultSmpParmGLPK.Rd
@@ -0,0 +1,43 @@
+\name{setDefaultSmpParmGLPK}
+\alias{setDefaultSmpParmGLPK}
+
+\title{
+  Sets the Default Control Parameters for the Simplex Methods.
+}
+
+\description{
+  Initializes a new structure \code{glp_smcp}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setDefaultSmpParmGLPK()
+}
+
+\details{
+  Interface to the C function \code{setDefaultSmpParm} which calls the GLPK
+  function \code{glp_init_smcp}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{Control Parameters}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/setInteriorParmGLPK.Rd b/man/setInteriorParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..51295132285968583d790c6d1a327641c2135c23
--- /dev/null
+++ b/man/setInteriorParmGLPK.Rd
@@ -0,0 +1,58 @@
+\name{setInteriorParmGLPK}
+\alias{setInteriorParmGLPK}
+
+\title{
+  Sets/Changes Control Parameters or the Interior-point Method.
+}
+
+\description{
+  Sets/Changes the values of corresponding members of in the structure
+  \code{glp_iptcp}. Consult the GLPK documentation for more detailed
+  information.
+}
+
+\usage{
+  setInteriorParmGLPK(parm, val)
+}
+
+\arguments{
+  \item{parm}{
+    A vector containing integer values or symbolic names
+    of the control parameters to be changed
+    (see \code{\link{glpkConstants}}, section \sQuote{Control Parameters}) and
+    \sQuote{interior-point solver control parameters}).
+  }
+  \item{val}{
+    A vector containing the new values for the corresponding
+    control parameters.
+  }
+}
+
+\details{
+  The Arguments \code{parm} and \code{val} must have the
+  same length. The value \code{val[i]} belongs to the
+  parameter \code{parm[i]}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setMIPParmGLPK.Rd b/man/setMIPParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..295eba0725eccee5ff72687d9f6ab9b2cf5acb36
--- /dev/null
+++ b/man/setMIPParmGLPK.Rd
@@ -0,0 +1,56 @@
+\name{setMIPParmGLPK}
+\alias{setMIPParmGLPK}
+
+\title{
+  Sets/Changes Control Parameters or the MIP Methods
+}
+
+\description{
+  Sets/Changes the values of corresponding members of in the structure
+  \code{glp_iocp}. Consult the GLPK documentation for more detailed information.
+}
+\usage{
+  setMIPParmGLPK(parm, val)
+}
+
+\arguments{
+  \item{parm}{
+    A vector containing integer values or symbolic names
+    of the control parameters to be changed
+    (see \code{\link{glpkConstants}}, section \sQuote{Control Parameters} and
+    \sQuote{integer optimizer control parameters}).
+  }
+  \item{val}{
+    A vector containing the new values for the corresponding
+    control parameters.
+  }
+}
+
+\details{
+  The Arguments \code{parm} and \code{val} must have the
+  same length. The value \code{val[i]} belongs to the
+  parameter \code{parm[i]}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setMatColGLPK.Rd b/man/setMatColGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..26903c0f70d1c0d93a7bb3764d9ba2ee2af17a6e
--- /dev/null
+++ b/man/setMatColGLPK.Rd
@@ -0,0 +1,60 @@
+\name{setMatColGLPK}
+\alias{setMatColGLPK}
+\alias{glp_set_mat_col}
+
+\title{
+  Set (Replace) Column of the Constraint Matrix
+}
+\description{
+  Low level interface function to the GLPK function \code{glp_set_mat_col}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setMatColGLPK(lp, j, len, ind, val)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Replace the \code{j}-th column of the constraint matrix of the specified
+    problem object.
+  }
+  \item{len}{
+    Number of new column elements.
+  }
+  \item{ind}{
+    Row indices of the new column elements.
+  }
+  \item{val}{
+    Numerical values of the new column elements.
+  }
+}
+
+\details{
+  Interface to the C function \code{setMatCol} which calls the GLPK
+  function \code{glp_set_mat_col}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setMatRowGLPK.Rd b/man/setMatRowGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..8145a1607ddab87510357f24a138ce1f1fd80cc4
--- /dev/null
+++ b/man/setMatRowGLPK.Rd
@@ -0,0 +1,60 @@
+\name{setMatRowGLPK}
+\alias{setMatRowGLPK}
+\alias{glp_set_mat_row}
+
+\title{
+  Set (Replace) Row of the Constraint Matrix
+}
+\description{
+  Low level interface function to the GLPK function \code{glp_set_mat_row}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setMatRowGLPK(lp, i, len, ind, val)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Replace the \code{i}-th row of the constraint matrix of the specified
+    problem object.
+  }
+  \item{len}{
+    Number of new row elements.
+  }
+  \item{ind}{
+    Column indices of the new row elements.
+  }
+  \item{val}{
+    Numerical values of the new row elements.
+  }
+}
+
+\details{
+  Interface to the C function \code{setMatRow} which calls the GLPK
+  function \code{glp_set_mat_row}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setObjCoefGLPK.Rd b/man/setObjCoefGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..03f0b575e88c4fedb6138d6cff054334d2b26281
--- /dev/null
+++ b/man/setObjCoefGLPK.Rd
@@ -0,0 +1,54 @@
+\name{setObjCoefGLPK}
+\alias{setObjCoefGLPK}
+\alias{glp_set_obj_coef}
+
+\title{
+  Set/Change Objective Coefficient or Constant Term
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_obj_coef}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setObjCoefGLPK(lp, j, obj_coef)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+  \item{obj_coef}{
+    Objective coefficient or constant term.
+  }
+}
+
+\details{
+  Interface to the C function \code{setObjCoef} which calls the GLPK
+  function \code{glp_set_obj_coef}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setObjCoefsGLPK.Rd b/man/setObjCoefsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..92db381ef3b80b0afd1bf30b53eddae6b0100b48
--- /dev/null
+++ b/man/setObjCoefsGLPK.Rd
@@ -0,0 +1,54 @@
+\name{setObjCoefsGLPK}
+\alias{setObjCoefsGLPK}
+
+\title{
+  Set/Change Objective Coefficients and/or Constant Term
+}
+
+\description{
+  This is an advanced version of \code{\link{setColBndGLPK}}.
+  Here, \code{j} can be an integer vector, \code{obj_coef}
+  can be a numeric vector.
+}
+
+\usage{
+  setObjCoefsGLPK(lp, j, obj_coef)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Vector of column numbers.
+  }
+  \item{obj_coef}{
+    Vector of objective coefficients.
+  }
+}
+
+\details{
+  Interface to the C function \code{setObjCoefs} which calls the
+  GLPK function \code{glp_set_obj_coef}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setObjDirGLPK.Rd b/man/setObjDirGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..cfbb3f7d1a22b32fdba10ec0f10622a502783b61
--- /dev/null
+++ b/man/setObjDirGLPK.Rd
@@ -0,0 +1,56 @@
+\name{setObjDirGLPK}
+\alias{setObjDirGLPK}
+\alias{glp_set_obj_dir}
+
+\title{
+  Set/Change Optimization Direction Flag
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_obj_dir}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setObjDirGLPK(lp, lpdir)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{lpdir}{
+    Optimization direction flag, which can be \code{GLP_MIN} (default) or
+    \code{GLP_MAX}.
+  }
+}
+
+\details{
+  Interface to the C function \code{setObjDir} which calls the GLPK
+  function \code{glp_set_obj_dir}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/setObjNameGLPK.Rd b/man/setObjNameGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..11ae344fede25aecc145ee47ad56282a18464b7e
--- /dev/null
+++ b/man/setObjNameGLPK.Rd
@@ -0,0 +1,51 @@
+\name{setObjNameGLPK}
+\alias{setObjNameGLPK}
+\alias{glp_set_obj_name}
+
+\title{
+  Set/Change Objective Function Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_obj_name}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setObjNameGLPK(lp, oname = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{oname}{
+    Objective Function name.
+  }
+}
+
+\details{
+  Interface to the C function \code{setObjName} which calls the GLPK
+  function \code{glp_set_obj_name}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setProbNameGLPK.Rd b/man/setProbNameGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..08a5eab9fa6d1bcd5ba75a8c0f9ef38244103148
--- /dev/null
+++ b/man/setProbNameGLPK.Rd
@@ -0,0 +1,51 @@
+\name{setProbNameGLPK}
+\alias{setProbNameGLPK}
+\alias{glp_set_prob_name}
+
+\title{
+  Set/Change Problem Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_prob_name}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setProbNameGLPK(lp, pname = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{pname}{
+    Problem name.
+  }
+}
+
+\details{
+  Interface to the C function \code{setProbName} which calls the GLPK
+  function \code{glp_set_prob_name}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setRhsZeroGLPK.Rd b/man/setRhsZeroGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..84456c7967c94edc5e432201d37b9b9a1a8560c4
--- /dev/null
+++ b/man/setRhsZeroGLPK.Rd
@@ -0,0 +1,46 @@
+\name{setRhsZeroGLPK}
+\alias{setRhsZeroGLPK}
+
+\title{
+  Set/Change all Row Bounds to Zero
+}
+
+\description{
+  This is an advanced version of \code{\link{setRowsBndsGLPK}}.
+}
+
+\usage{
+  setRhsZeroGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{setRowsBnds} which calls the GLPK
+  function \code{glp_set_col_bnds}. All row bounds are fixed at zero.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setRiiGLPK.Rd b/man/setRiiGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..f180bf031d458a4e1be59eaee783e1cd20f6554b
--- /dev/null
+++ b/man/setRiiGLPK.Rd
@@ -0,0 +1,53 @@
+\name{setRiiGLPK}
+\alias{setRiiGLPK}
+\alias{glp_set_rii}
+
+\title{
+  Set row scale factor
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_rii}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setRiiGLPK(lp, i, rii)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+  \item{rii}{
+    Scale factor $r_{ii}$.
+  }
+}
+
+\details{
+  Interface to the C function \code{setRii} which calls the GLPK
+  function \code{glp_set_rii}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/setRowBndGLPK.Rd b/man/setRowBndGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..3746fd57442163daf7b735d579ccef3603b0cabe
--- /dev/null
+++ b/man/setRowBndGLPK.Rd
@@ -0,0 +1,65 @@
+\name{setRowBndGLPK}
+\alias{setRowBndGLPK}
+\alias{glp_set_row_bnds}
+
+\title{
+  Set/Change Row Bounds
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_row_bnds}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setRowBndGLPK(lp, i, type, lb, ub)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+  \item{type}{
+    Row type. For possible values, see \code{\link{glpkConstants}}, section
+    \sQuote{LP/MIP problem object}.
+  }
+  \item{lb}{
+    Lower bound.
+  }
+  \item{ub}{
+    Upper bound.
+  }
+}
+
+\details{
+  Interface to the C function \code{setRowBnd} which calls the GLPK
+  function \code{glp_set_row_bnds}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setRowNameGLPK.Rd b/man/setRowNameGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..e21ba571ed56866c1fd130f2820c074376fd036e
--- /dev/null
+++ b/man/setRowNameGLPK.Rd
@@ -0,0 +1,54 @@
+\name{setRowNameGLPK}
+\alias{setRowNameGLPK}
+\alias{glp_set_row_name}
+
+\title{
+  Set/Change Row Name
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_row_name}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setRowNameGLPK(lp, i, rname = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+  \item{rname}{
+    Row name.
+  }
+}
+
+\details{
+  Interface to the C function \code{setRowName} which calls the GLPK
+  function \code{glp_set_row_name}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setRowStatGLPK.Rd b/man/setRowStatGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..571a3da0b3bdb0d74d5ababa89ea32cc678be5e8
--- /dev/null
+++ b/man/setRowStatGLPK.Rd
@@ -0,0 +1,57 @@
+\name{setRowStatGLPK}
+\alias{setRowStatGLPK}
+\alias{glp_set_row_stat}
+
+\title{
+  Set row status
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_row_stat}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setRowStatGLPK(lp, i, stat)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Row number i.
+  }
+  \item{stat}{
+    A status parameter, see \code{\link{glpkConstants}} for possible values.
+  }
+}
+
+\details{
+  Interface to the C function \code{setRowStat} which calls the GLPK
+  function \code{glp_set_row_stat}, section \sQuote{LP/MIP problem object}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
diff --git a/man/setRowsBndsGLPK.Rd b/man/setRowsBndsGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..8568ab2f9a04d7f40f5d36920d163431030e6ceb
--- /dev/null
+++ b/man/setRowsBndsGLPK.Rd
@@ -0,0 +1,68 @@
+\name{setRowsBndsGLPK}
+\alias{setRowsBndsGLPK}
+
+\title{
+  Set/Change Row Bounds
+}
+
+\description{
+  This is an advanced version of \code{\link{setRowBndGLPK}}.
+  Here, \code{i} can be an integer vector, \code{lb} and \code{ub}
+  can be numeric vectors.
+}
+
+\usage{
+  setRowsBndsGLPK(lp, i, lb, ub, type = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Vector of row numbers.
+  }
+  \item{lb}{
+    Vector of lower bounds.
+  }
+  \item{ub}{
+    Vector of upper bounds.
+  }
+  \item{type}{
+    Vector of variable types (default: NULL). For possible values, see
+    \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+  }
+}
+
+\details{
+  Interface to the C function \code{setRowsBnds} which calls the GLPK
+  function \code{glp_set_row_bnds}.
+
+  If \code{type} is set to NULL, the type of the variables will be estimated.
+  If lb[j] equals ub[j], variable i[j] is fixed, otherwise double bounded.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setRowsNamesGLPK.Rd b/man/setRowsNamesGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..05bfc47d3aafb0787946a99c7a9a23af40acc0fe
--- /dev/null
+++ b/man/setRowsNamesGLPK.Rd
@@ -0,0 +1,58 @@
+\name{setRowsNamesGLPK}
+\alias{setRowsNamesGLPK}
+
+\title{
+  Set/Change Row Names
+}
+
+\description{
+  This is an advanced version of \code{\link{setRowNameGLPK}}.
+  Here, \code{i} can be an integer vector, \code{rnames} can be a character
+  vector.
+}
+
+\usage{
+  setRowsNamesGLPK(lp, i, rnames = NULL)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{i}{
+    Vector of row numbers.
+  }
+  \item{rnames}{
+    Vector of row names of the same length as \code{i} or \code{NULL}.
+  }
+}
+
+\details{
+  Interface to the C function \code{setRowsNames} which calls the GLPK
+  function \code{glp_set_row_name}.
+
+  If \code{rnames} is set to \code{NULL}, all row names for row indices in
+  \code{i} will be removed. If \code{rname[k]} is the empty string \code{""},
+  row name \code{i[k]} will be removed.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/setSimplexParmGLPK.Rd b/man/setSimplexParmGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..835e80e86f3e69b8c33e8bb728ecbab44c4a4b67
--- /dev/null
+++ b/man/setSimplexParmGLPK.Rd
@@ -0,0 +1,57 @@
+\name{setSimplexParmGLPK}
+\alias{setSimplexParmGLPK}
+
+\title{
+  Sets/Changes Control Parameters or the Simplex Methods.
+}
+
+\description{
+  Sets/Changes the values of corresponding members of in the structure
+  \code{glp_smcp}. Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setSimplexParmGLPK(parm, val)
+}
+
+\arguments{
+  \item{parm}{
+    A vector containing integer values or symbolic names
+    of the control parameters to be changed
+    (see \code{\link{glpkConstants}}, section \sQuote{Control Parameters} and
+    \sQuote{simplex method control parameters}).
+  }
+  \item{val}{
+    A vector containing the new values for the corresponding
+    control parameters.
+  }
+}
+
+\details{
+  The Arguments \code{parm} and \code{val} must have the
+  same length. The value \code{val[i]} belongs to the
+  parameter \code{parm[i]}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}
+}
+
+\keyword{ optimize }
+
diff --git a/man/setSjjGLPK.Rd b/man/setSjjGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..760adeb12c3e15c19a4eb36807956c037eedee12
--- /dev/null
+++ b/man/setSjjGLPK.Rd
@@ -0,0 +1,53 @@
+\name{setSjjGLPK}
+\alias{setSjjGLPK}
+\alias{glp_set_sjj}
+
+\title{
+  Retrieve column scale factor
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_set_sjj}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  setSjjGLPK(lp, j, sjj)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{j}{
+    Column number j.
+  }
+  \item{sjj}{
+    Scale factor $s_{jj}$.
+  }
+}
+
+\details{
+  Interface to the C function \code{setSjj} which calls the GLPK
+  function \code{glp_set_sjj}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/solveInteriorGLPK.Rd b/man/solveInteriorGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..c7fb41113f98b4268cb41d8eb0b65e8d4b73ae51
--- /dev/null
+++ b/man/solveInteriorGLPK.Rd
@@ -0,0 +1,52 @@
+\name{solveInteriorGLPK}
+\alias{solveInteriorGLPK}
+\alias{glp_interior}
+
+\title{
+  Solve LP Problem with the Interior-Point Method
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_interior}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  solveInteriorGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{solveInterior} which calls the GLPK
+  function \code{glp_interior}.
+}
+
+\value{
+  A return code.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{return codes} and
+  \code{\link{return_codeGLPK}}.
+}
+
+\keyword{ optimize }
diff --git a/man/solveMIPGLPK.Rd b/man/solveMIPGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..fbb74cdce37057277a3f85f7f3cf3491c297f619
--- /dev/null
+++ b/man/solveMIPGLPK.Rd
@@ -0,0 +1,52 @@
+\name{solveMIPGLPK}
+\alias{solveMIPGLPK}
+\alias{glp_intopt}
+
+\title{
+  Solve MIP Problem with the Branch-and-Cut Method
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_intopt}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  solveMIPGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{solveMIP} which calls the GLPK
+  function \code{glp_intopt}.
+}
+
+\value{
+  A return code.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{return codes} and
+  \code{\link{return_codeGLPK}}.
+}
+
+\keyword{ optimize }
diff --git a/man/solveSimplexExactGLPK.Rd b/man/solveSimplexExactGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..09ef6a795132ed7e3ec5204dbcfbe2d4b5941aab
--- /dev/null
+++ b/man/solveSimplexExactGLPK.Rd
@@ -0,0 +1,53 @@
+\name{solveSimplexExactGLPK}
+\alias{solveSimplexExactGLPK}
+\alias{glp_exact}
+
+\title{
+  Solve LP Problem in Exact Arithmetic
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_exact}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  solveSimplexExactGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{solveSimplexExact} which calls the GLPK
+  function \code{glp_exact}.
+}
+
+\value{
+  A return code.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{return codes} and
+  \code{\link{return_codeGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/solveSimplexGLPK.Rd b/man/solveSimplexGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..8d0876f16b798c1acb1a4a866d1ce0e47c9b1365
--- /dev/null
+++ b/man/solveSimplexGLPK.Rd
@@ -0,0 +1,52 @@
+\name{solveSimplexGLPK}
+\alias{solveSimplexGLPK}
+\alias{glp_simplex}
+
+\title{
+  Solve LP Problem with the Primal or Dual Simplex Method
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_simplex}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  solveSimplexGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{solveSimplex} which calls the GLPK
+  function \code{glp_simplex}.
+}
+
+\value{
+  A return code.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{return codes} and
+  \code{\link{return_codeGLPK}}.
+}
+
+\keyword{ optimize }
diff --git a/man/sortMatrixGLPK.Rd b/man/sortMatrixGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..f873a59e08a23d248f8912ac92952afae39c7962
--- /dev/null
+++ b/man/sortMatrixGLPK.Rd
@@ -0,0 +1,48 @@
+\name{sortMatrixGLPK}
+\alias{sortMatrixGLPK}
+\alias{glp_sort_matrix}
+
+\title{
+  Sort Elements of the Constraint Matrix
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_sort_matrix}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  sortMatrixGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{sortMatrix} which calls the GLPK
+  function \code{glp_sort_matrix}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/status_codeGLPK.Rd b/man/status_codeGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..a509ea55445a39f2d5a1942eb58c2b390287ea22
--- /dev/null
+++ b/man/status_codeGLPK.Rd
@@ -0,0 +1,43 @@
+\name{status_codeGLPK}
+\alias{status_codeGLPK}
+
+\title{
+  Translates a GLPK Status Value into a Human Readable String
+}
+
+\description{
+  Translates a GLPK status code into a human readable string.
+}
+
+\usage{
+  status_codeGLPK(code)
+}
+
+\arguments{
+  \item{code}{
+    Status code from GLPK.
+  }
+}
+
+\value{
+  A character string associated with the GLPK status code.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{LP/MIP problem object}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/stdBasisGLPK.Rd b/man/stdBasisGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..d4ffafdb80f8b6581dc73c6e081ae78834d14970
--- /dev/null
+++ b/man/stdBasisGLPK.Rd
@@ -0,0 +1,48 @@
+\name{stdBasisGLPK}
+\alias{stdBasisGLPK}
+\alias{glp_std_basis}
+
+\title{
+  Contruct Standard Initial LP Basis
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_std_basis}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  stdBasisGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{stdBasis} which calls the GLPK
+  function \code{glp_std_basis}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/termOutGLPK.Rd b/man/termOutGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..32bd2e2c6dd8ffc98e952cfe4735ff44be7b7208
--- /dev/null
+++ b/man/termOutGLPK.Rd
@@ -0,0 +1,50 @@
+\name{termOutGLPK}
+\alias{termOutGLPK}
+\alias{glp_term_out}
+
+\title{
+  Enable/Disable Terminal Output
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_term_out}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  termOutGLPK(flag)
+}
+
+\arguments{
+  \item{flag}{
+    GLPK enable/disable flag: \code{GLP_ON} or \code{GLP_OFF}.
+  }
+}
+
+\details{
+  Interface to the C function \code{termOut} which calls the GLPK
+  function \code{glp_term_out}.
+}
+
+\value{
+  Returns the previous value of the terminal output flag.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{glpkConstants}}, section \sQuote{enable/disable flag}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/unscaleProbGLPK.Rd b/man/unscaleProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..b6f213e7740af403053829c80e64d486d082e5ed
--- /dev/null
+++ b/man/unscaleProbGLPK.Rd
@@ -0,0 +1,47 @@
+\name{unscaleProbGLPK}
+\alias{unscaleProbGLPK}
+\alias{glp_unscale_prob}
+
+\title{
+  Problem unscaling
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_unscale_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  unscaleProbGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{unscaleProb} which calls the GLPK
+  function \code{glp_unscale_prob}.
+}
+
+\value{
+  NULL
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
diff --git a/man/versionGLPK.Rd b/man/versionGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..0ab6d9ae590e7f83fdf14d20114ce848b176aae8
--- /dev/null
+++ b/man/versionGLPK.Rd
@@ -0,0 +1,40 @@
+\name{versionGLPK}
+\alias{versionGLPK}
+\alias{glp_version}
+
+\title{
+  Determine GLPK Callable Library Version
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_version}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  versionGLPK()
+}
+
+\details{
+  Interface to the C function \code{version} which calls the GLPK
+  function \code{glp_version}.
+}
+
+\value{
+  Returns a single character value containing the GLPK version number.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/warmUpGLPK.Rd b/man/warmUpGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..08ea408010c0d648c6b21f23a8ebd18e454483ea
--- /dev/null
+++ b/man/warmUpGLPK.Rd
@@ -0,0 +1,46 @@
+\name{warmUpGLPK}
+\alias{warmUpGLPK}
+\alias{glp_warm_up}
+
+\title{
+  Warm Up LP Basis
+}
+\description{
+  Low level interface function to the GLPK function \code{glp_warm_up}.
+  Consult the GLPK documentation for more detailed information.
+}
+\usage{
+  warmUpGLPK(lp)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+}
+
+\details{
+  Interface to the C function \code{warmUp} which calls the GLPK
+  function \code{glp_warm_up}.
+}
+
+\value{
+  Status of \dQuote{warming up}.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\keyword{ optimize }
+
diff --git a/man/writeIptGLPK.Rd b/man/writeIptGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..866058b28565eb18edcc47e2799d550879422b7b
--- /dev/null
+++ b/man/writeIptGLPK.Rd
@@ -0,0 +1,58 @@
+\name{writeIptGLPK}
+\alias{writeIptGLPK}
+\alias{glp_write_ipt}
+
+\title{
+  Write Interior-Point Solution to Text File
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_write_ipt}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  writeIptGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{writeIpt} which calls the GLPK
+  function \code{glp_write_ipt}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{printSolGLPK}}, \code{\link{readSolGLPK}},
+  \code{\link{writeSolGLPK}}, \code{\link{printIptGLPK}},
+  \code{\link{readIptGLPK}}, \code{\link{printMIPGLPK}},
+  \code{\link{readMIPGLPK}} and \code{\link{writeMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/writeLPGLPK.Rd b/man/writeLPGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..89b21ecd1c29c74b5311ead852c354f01afdaa5a
--- /dev/null
+++ b/man/writeLPGLPK.Rd
@@ -0,0 +1,58 @@
+\name{writeLPGLPK}
+\alias{writeLPGLPK}
+\alias{glp_write_lp}
+
+\title{
+  Write Problem Data in CPLEX LP Format
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_write_lp}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  writeLPGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{writeLP} which calls the GLPK
+  function \code{glp_write_lp}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero
+  and prints an error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{readMPSGLPK}}, \code{\link{readLPGLPK}},
+  \code{\link{readProbGLPK}}, 
+  \code{\link{writeMPSGLPK}} and \code{\link{writeProbGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/writeMIPGLPK.Rd b/man/writeMIPGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..9eecaafb9a31ada36cd647774faf661f5d004e64
--- /dev/null
+++ b/man/writeMIPGLPK.Rd
@@ -0,0 +1,58 @@
+\name{writeMIPGLPK}
+\alias{writeMIPGLPK}
+\alias{glp_write_mip}
+
+\title{
+  Write MIP Solution to Text File
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_write_mip}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  writeMIPGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{writeMIP} which calls the GLPK
+  function \code{glp_write_mip}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{printSolGLPK}}, \code{\link{readSolGLPK}},
+  \code{\link{writeSolGLPK}}, \code{\link{printIptGLPK}},
+  \code{\link{readIptGLPK}}, \code{\link{writeIptGLPK}},
+  \code{\link{printMIPGLPK}} and \code{\link{readMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/writeMPSGLPK.Rd b/man/writeMPSGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..ae5088e4e3eb84f02a8d831c4619249db52829bd
--- /dev/null
+++ b/man/writeMPSGLPK.Rd
@@ -0,0 +1,63 @@
+\name{writeMPSGLPK}
+\alias{writeMPSGLPK}
+\alias{glp_write_mps}
+
+\title{
+  Write Problem Data in MPS Format
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_write_mps}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  writeMPSGLPK(lp, fmt, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fmt}{
+    MPS format. See \code{\link{glpkConstants}}, section
+    \sQuote{MPS file formats}.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{writeMPS} which calls the GLPK
+  function \code{glp_write_mps}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero
+  and prints an error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{readMPSGLPK}}, \code{\link{readLPGLPK}},
+  \code{\link{readProbGLPK}}, 
+  \code{\link{writeLPGLPK}}, \code{\link{writeProbGLPK}} and
+  \code{\link{glpkConstants}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/writeProbGLPK.Rd b/man/writeProbGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..e416779e37b8e4197264b7671b85ceb163bb6a0d
--- /dev/null
+++ b/man/writeProbGLPK.Rd
@@ -0,0 +1,58 @@
+\name{writeProbGLPK}
+\alias{writeProbGLPK}
+\alias{glp_write_prob}
+
+\title{
+  Write Problem Data in GLPK Format
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_write_prob}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  writeProbGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{writeProb} which calls the GLPK
+  function \code{glp_write_prob}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero
+  and prints an error message.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{readMPSGLPK}}, \code{\link{readLPGLPK}},
+  \code{\link{readProbGLPK}}, 
+  \code{\link{writeLPGLPK}} and \code{\link{writeMPSGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/man/writeSolGLPK.Rd b/man/writeSolGLPK.Rd
new file mode 100644
index 0000000000000000000000000000000000000000..70d7e184fd9c15bc90a3ad5fd25e6626b19d9c14
--- /dev/null
+++ b/man/writeSolGLPK.Rd
@@ -0,0 +1,58 @@
+\name{writeSolGLPK}
+\alias{writeSolGLPK}
+\alias{glp_write_sol}
+
+\title{
+  Write Basic Solution to Text File
+}
+
+\description{
+  Low level interface function to the GLPK function \code{glp_write_sol}.
+  Consult the GLPK documentation for more detailed information.
+}
+
+\usage{
+  writeSolGLPK(lp, fname)
+}
+
+\arguments{
+  \item{lp}{
+    An object of class \code{"\linkS4class{glpkPtr}"} as returned by
+    \code{\link{initProbGLPK}}. This is basically a pointer to a GLPK problem
+    object.
+  }
+  \item{fname}{
+    The name of the text file to be written out.
+  }
+}
+
+\details{
+  Interface to the C function \code{writeSol} which calls the GLPK
+  function \code{glp_write_sol}.
+}
+
+\value{
+  Returns zero on success, otherwise it returns non-zero.
+}
+
+\references{
+  Based on the package \pkg{glpk} by Lopaka Lee.
+    
+  The GNU GLPK home page at \url{http://www.gnu.org/software/glpk/glpk.html}.
+}
+
+\author{
+  Gabriel Gelius-Dietrich
+
+  Maintainer: Gabriel Gelius-Dietrich <geliudie@uni-duesseldorf.de>
+}
+
+\seealso{
+  \code{\link{printSolGLPK}}, \code{\link{readSolGLPK}},
+  \code{\link{printIptGLPK}}, \code{\link{readIptGLPK}},
+  \code{\link{writeIptGLPK}}, \code{\link{printMIPGLPK}},
+  \code{\link{readMIPGLPK}} and \code{\link{writeMIPGLPK}}.
+}
+
+\keyword{ optimize }
+
diff --git a/src/Makevars.in b/src/Makevars.in
new file mode 100644
index 0000000000000000000000000000000000000000..f03b4d39e17631bd443edc49d5d1275b76391553
--- /dev/null
+++ b/src/Makevars.in
@@ -0,0 +1,3 @@
+PKG_CFLAGS=@PKG_CFLAGS@
+PKG_CPPFLAGS=@PKG_CPPFLAGS@
+PKG_LIBS=@PKG_LIBS@
diff --git a/src/Makevars.win b/src/Makevars.win
new file mode 100644
index 0000000000000000000000000000000000000000..3f63001276b707d2acc09cd34d04a087e0e65f3b
--- /dev/null
+++ b/src/Makevars.win
@@ -0,0 +1,2 @@
+PKG_CPPFLAGS=-g -D_R_=1 -DUSE_R=1 -I${GLPK_HOME}/include -DCHECK_GLPK_ARGS
+PKG_LIBS=-L${GLPK_HOME}/lib -lglpk -lgmp
diff --git a/src/config.h.in b/src/config.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..6c94579cdf2562f1a754dffb14447050b70e8b3f
--- /dev/null
+++ b/src/config.h.in
@@ -0,0 +1,9 @@
+/* config.h.in (glpkAPI configuration template file) */
+
+#undef CHECK_GLPK_ARGS
+/* defined, if arguments to GLPK should be checked */
+
+#undef USE_GMP
+/* defined, if gnu bignum is used */
+
+/* eof */
diff --git a/src/glpkAPI.c b/src/glpkAPI.c
new file mode 100644
index 0000000000000000000000000000000000000000..94e36e077c90c4c5ee51d7c92bd067748f78e684
--- /dev/null
+++ b/src/glpkAPI.c
@@ -0,0 +1,3900 @@
+/* glpkAPI.c
+   R interface to GLPK.
+ 
+   Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+   Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+   All right reserved.
+   Email: geliudie@uni-duesseldorf.de
+ 
+   This file is part of glpkAPI.
+ 
+   GlpkAPI is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+ 
+   GlpkAPI is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with glpkAPI.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <setjmp.h>
+#include "glpkAPI.h"
+#include "glpkCallback.h"
+
+
+static SEXP tagGLPKprob;
+static SEXP tagGLPKparm;
+static SEXP tagMATHprog;
+
+/* for the user callback routine */
+/* static struct cbInfo glpkCallbackInfo; */
+
+/* structure for glpk parameters */
+glp_smcp parmS;
+glp_iptcp parmI;
+glp_iocp parmM;
+
+/* BEGIN code by Ulrich Wittelsbuerger */
+struct glpkError {
+    int e;
+};
+
+static struct glpkError ge;
+jmp_buf jenv;
+
+void cleanGLPKerror( struct glpkError * ptr ) {
+    if( ptr != 0 ) {
+        /* Rprintf("GLPK error: %d\n",ptr->e); */
+        Rprintf("GLPK error\n");
+    }
+    else {
+        Rprintf("NULL pointer!\n");
+    }
+    longjmp(jenv, 1);
+}
+
+typedef void (*func)(void *info);
+/* END code by Ulrich Wittelsbuerger */
+
+
+/* -------------------------------------------------------------------------- */
+/* Finalizer                                                                  */
+/* -------------------------------------------------------------------------- */
+
+/* -------------------------------------------------------------------------- */
+/* finalizer for glpk problem objects */
+static void glpkProbFinalizer (SEXP lp) {
+    if (!R_ExternalPtrAddr(lp)) {
+        return;
+    }
+    else {
+        delProb(lp);
+    }
+}
+
+/* finalizer for MathProg translator workspace */
+static void mathProgFinalizer (SEXP wk) {
+    if (!R_ExternalPtrAddr(wk)) {
+        return;
+    }
+    else {
+        mplFreeWksp(wk);
+    }
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* help functions                                                             */
+/* -------------------------------------------------------------------------- */
+
+/* check for pointer to glpk */
+SEXP isGLPKptr(SEXP ptr) {
+
+    SEXP out = R_NilValue;
+
+    if ( (TYPEOF(ptr) == EXTPTRSXP) &&
+         (R_ExternalPtrTag(ptr) == tagGLPKprob) ) {
+        out = Rf_ScalarLogical(1);
+    }
+    else {
+        out = Rf_ScalarLogical(0);
+    }
+
+    return out;
+}
+
+/* check for pointer to translator workspace */
+SEXP isTRWKSptr(SEXP ptr) {
+
+    SEXP out = R_NilValue;
+
+    if ( (TYPEOF(ptr) == EXTPTRSXP) &&
+         (R_ExternalPtrTag(ptr) == tagMATHprog) ) {
+        out = Rf_ScalarLogical(1);
+    }
+    else {
+        out = Rf_ScalarLogical(0);
+    }
+
+    return out;
+}
+
+/* check for NULL pointer */
+SEXP isNULLptr(SEXP ptr) {
+
+    SEXP out = R_NilValue;
+
+    if ( (TYPEOF(ptr) == EXTPTRSXP) &&
+         (R_ExternalPtrAddr(ptr) == NULL) ) {
+        out = Rf_ScalarLogical(1);
+    }
+    else {
+        out = Rf_ScalarLogical(0);
+    }
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* API-Functions                                                              */
+/* -------------------------------------------------------------------------- */
+
+/* -------------------------------------------------------------------------- */
+/* initialize glpk */
+SEXP initGLPK(void) {
+    tagGLPKprob = Rf_install("TYPE_GLPK_PROB");
+    tagGLPKparm = Rf_install("TYPE_GLPK_PARM");
+    tagMATHprog = Rf_install("TYPE_MATH_PROG");
+    tagGLPKparm = Rf_install("TYPE_GLPK_PARM");
+    return R_NilValue;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* remove problem object */
+SEXP delProb(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    glp_prob *del = NULL;
+
+    checkProb(lp);
+
+    del = R_ExternalPtrAddr(lp);
+
+    glp_delete_prob(del);
+    R_ClearExternalPtr(lp);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* erase problem object content */
+SEXP eraseProb(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    glp_prob *del = NULL;
+
+    checkProb(lp);
+
+    del = R_ExternalPtrAddr(lp);
+
+    glp_erase_prob(del);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* copy problem object content */
+SEXP copyProb(SEXP lp, SEXP clp, SEXP names) {
+
+    SEXP out = R_NilValue;
+    glp_prob *prob = NULL;
+    glp_prob *dest = NULL;
+
+    checkProb(lp);
+    checkProb(clp);
+
+    prob = R_ExternalPtrAddr(lp);
+    dest = R_ExternalPtrAddr(clp);
+
+    glp_copy_prob(dest, prob, Rf_asInteger(names));
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* create new problem object */
+SEXP initProb(SEXP ptrtype) {
+
+    SEXP lpext = R_NilValue;
+    SEXP ptr, class;
+
+    glp_prob *lp;
+
+    /* initialize structure for control parameters */
+    glp_init_smcp(&parmS);
+    glp_init_iptcp(&parmI);
+    glp_init_iocp(&parmM);
+
+    /* create problem pointer */
+    PROTECT(ptr = Rf_allocVector(STRSXP, 1));
+    SET_STRING_ELT(ptr, 0, STRING_ELT(ptrtype, 0));
+
+    PROTECT(class = Rf_allocVector(STRSXP, 1));
+    SET_STRING_ELT(class, 0, Rf_mkChar("glpk_ptr"));
+
+    lp = glp_create_prob();
+
+    lpext = R_MakeExternalPtr(lp, tagGLPKprob, R_NilValue);
+    PROTECT(lpext);
+    R_RegisterCFinalizerEx(lpext, glpkProbFinalizer, TRUE);
+    Rf_setAttrib(ptr, class, lpext);
+    Rf_classgets(ptr, class);
+
+    UNPROTECT(3);
+
+    return ptr;
+}
+
+/* -------------------------------------------------------------------------- */
+/* create new problem object */
+/*
+SEXP initProb(SEXP ptrtype) {
+
+    SEXP lpext = R_NilValue;
+    SEXP ptr, class;
+
+    glp_prob *lp;
+
+glp_smcp parmSa;
+glp_iptcp parmIa;
+glp_iocp parmMa;
+SEXP psn, pin, pmn, psp, pip, pmp;
+
+
+
+
+
+    glp_init_smcp(&parmSa);
+    glp_init_iptcp(&parmIa);
+    glp_init_iocp(&parmMa);
+
+    PROTECT(ptr = Rf_allocVector(STRSXP, 1));
+    SET_STRING_ELT(ptr, 0, STRING_ELT(ptrtype, 0));
+
+PROTECT(psn = Rf_allocVector(STRSXP, 1));
+SET_STRING_ELT(psn, 0, Rf_mkChar("simplex"));
+PROTECT(pin = Rf_allocVector(STRSXP, 1));
+SET_STRING_ELT(pin, 0, Rf_mkChar("interior"));
+PROTECT(pmn = Rf_allocVector(STRSXP, 1));
+SET_STRING_ELT(pmn, 0, Rf_mkChar("mip"));
+
+psp = R_MakeExternalPtr(&parmSa, tagGLPKparm, R_NilValue);
+pip = R_MakeExternalPtr(&parmIa, tagGLPKparm, R_NilValue);
+pmp = R_MakeExternalPtr(&parmMa, tagGLPKparm, R_NilValue);
+PROTECT(psp);
+PROTECT(pip);
+PROTECT(pmp);
+
+    PROTECT(class = Rf_allocVector(STRSXP, 1));
+    SET_STRING_ELT(class, 0, Rf_mkChar("glpk_ptr"));
+
+    lp = glp_create_prob();
+
+    lpext = R_MakeExternalPtr(lp, tagGLPKprob, R_NilValue);
+    PROTECT(lpext);
+    R_RegisterCFinalizerEx(lpext, glpkProbFinalizer, TRUE);
+    Rf_setAttrib(ptr, class, lpext);
+    Rf_classgets(ptr, class);
+
+Rf_setAttrib(ptr, psn, psp);
+Rf_setAttrib(ptr, pin, pip);
+Rf_setAttrib(ptr, pmn, pmp);
+
+
+    UNPROTECT(9);
+
+    return ptr;
+}
+*/
+
+
+/* -------------------------------------------------------------------------- */
+/* set problem name */
+SEXP setProbName(SEXP lp, SEXP pname) {
+
+    SEXP out = R_NilValue;
+
+    const char *rpname;
+
+    checkProb(lp);
+
+    if (pname == R_NilValue) {
+        rpname = NULL;
+    }
+    else {
+        rpname = CHAR(STRING_ELT(pname, 0));
+    }
+
+    glp_set_prob_name(R_ExternalPtrAddr(lp), rpname);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get problem name */
+SEXP getProbName(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    const char *rpname = NULL;
+
+    checkProb(lp);
+
+    rpname = glp_get_prob_name(R_ExternalPtrAddr(lp));
+
+    if (rpname != NULL) {
+        out = Rf_mkString(rpname);
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set objective function name */
+SEXP setObjName(SEXP lp, SEXP oname) {
+
+    SEXP out = R_NilValue;
+
+    const char *roname;
+    if (oname == R_NilValue) {
+        roname = NULL;
+    }
+    else {
+        roname = CHAR(STRING_ELT(oname, 0));
+    }
+
+    checkProb(lp);
+
+    glp_set_obj_name(R_ExternalPtrAddr(lp), roname);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get objective function name */
+SEXP getObjName(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    const char *roname;
+
+    checkProb(lp);
+
+    roname = glp_get_obj_name(R_ExternalPtrAddr(lp));
+
+    if (roname != NULL) {
+        out = Rf_mkString(roname);
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* create name index */
+SEXP createIndex(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+
+    glp_create_index(R_ExternalPtrAddr(lp));
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* delete name index */
+SEXP deleteIndex(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+
+    glp_delete_index(R_ExternalPtrAddr(lp));
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* create parameter structure for simplex */
+SEXP setDefaultSmpParm() {
+
+    SEXP parmext = R_NilValue;
+
+    glp_init_smcp(&parmS);
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* create parameter structure for interior */
+SEXP setDefaultIptParm() {
+
+    SEXP parmext = R_NilValue;
+
+    glp_init_iptcp(&parmI);
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* create parameter structure for MIP */
+SEXP setDefaultMIPParm() {
+
+    SEXP parmext = R_NilValue;
+
+    glp_init_iocp(&parmM);
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set simplex control parameters */
+SEXP setSimplexParm(SEXP npari, SEXP pari, SEXP vali,
+                    SEXP npard, SEXP pard, SEXP vald) {
+
+    SEXP parmext = R_NilValue;
+
+    int *rpari;
+    int *rvali;
+
+    int *rpard;
+    double *rvald;
+
+    int i, d;
+
+    if (Rf_asInteger(npari) == 0) {
+        rpari = NULL;
+        rvali = NULL;
+        /* parmS.tm_lim = 10000; */
+    }
+    else {
+        rpari = INTEGER(pari);
+        rvali = INTEGER(vali);
+
+        for (i = 0; i < Rf_asInteger(npari); i++) {
+            /* Rprintf("par: %i  val: %i\n", rpari[i], rvali[i]); */
+            switch (rpari[i]) {
+                case 101:
+                    parmS.msg_lev = rvali[i];
+                    break;
+                case 102:
+                    parmS.meth = rvali[i];
+                    break;
+                case 103:
+                    parmS.pricing = rvali[i];
+                    break;
+                case 104:
+                    parmS.r_test = rvali[i];
+                    break;
+                case 105:
+                    parmS.it_lim = rvali[i];
+                    break;
+                case 106:
+                    parmS.tm_lim = rvali[i];
+                    break;
+                case 107:
+                    parmS.out_frq = rvali[i];
+                    break;
+                case 108:
+                    parmS.out_dly = rvali[i];
+                    break;
+                case 109:
+                    parmS.presolve = rvali[i];
+                    break;
+                default:
+                    Rf_warning("Unknown integer simplex parameter: %i!", rpari[i]);
+                    break;
+            }
+        }
+
+    }
+
+    if (Rf_asInteger(npard) == 0) {
+        rpard = NULL;
+        rvald = NULL;
+    }
+    else {
+        rpard = INTEGER(pard);
+        rvald = REAL(vald);
+
+        for (d = 0; d < Rf_asInteger(npard); d++) {
+            /* Rprintf("par: %i  val: %i\n", rpard[d], rvald[d]); */
+            switch (rpard[d]) {
+                case 201:
+                    parmS.tol_bnd = rvald[d];
+                    break;
+                case 202:
+                    parmS.tol_dj = rvald[d];
+                    break;
+                case 203:
+                    parmS.tol_piv = rvald[d];
+                    break;
+                case 204:
+                    parmS.obj_ll = rvald[d];
+                    break;
+                case 205:
+                    parmS.obj_ul = rvald[d];
+                    break;
+                default:
+                    Rf_warning("Unknown double simplex parameter: %i!", rpard[d]);
+                    break;
+            }
+        }
+
+    }
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set interior control parameters */
+SEXP setInteriorParm(SEXP npari, SEXP pari, SEXP vali) {
+
+    SEXP parmext = R_NilValue;
+
+    int *rpari = INTEGER(pari);
+    int *rvali = INTEGER(vali);
+
+    int i;
+
+    for (i = 0; i < Rf_asInteger(npari); i++) {
+        switch (rpari[i]) {
+            case 101:
+                parmI.msg_lev = rvali[i];
+                break;
+            case 301:
+                parmI.ord_alg = rvali[i];
+                break;
+            default:
+                Rf_warning("Unknown interior parameter: %i!", rpari[i]);
+                break;
+        }
+    }
+
+    return parmext;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set MIP control parameters */
+SEXP setMIPParm(SEXP npari, SEXP pari, SEXP vali,
+                SEXP npard, SEXP pard, SEXP vald) {
+
+    SEXP parmext = R_NilValue;
+
+    int *rpari;
+    int *rvali;
+
+    int *rpard;
+    double *rvald;
+
+    int i, d;
+
+    if (Rf_asInteger(npari) == 0) {
+        rpari = NULL;
+        rvali = NULL;
+    }
+    else {
+        rpari = INTEGER(pari);
+        rvali = INTEGER(vali);
+
+        for (i = 0; i < Rf_asInteger(npari); i++) {
+            switch (rpari[i]) {
+                case 101:
+                    parmM.msg_lev = rvali[i];
+                    break;
+                case 106:
+                    parmM.tm_lim = rvali[i];
+                    break;
+                case 107:
+                    parmM.out_frq = rvali[i];
+                    break;
+                case 108:
+                    parmM.out_dly = rvali[i];
+                    break;
+                case 109:
+                    parmM.presolve = rvali[i];
+                    break;
+                case 601:
+                    parmM.br_tech = rvali[i];
+                    break;
+                case 602:
+                    parmM.bt_tech = rvali[i];
+                    break;
+                case 603:
+                    parmM.pp_tech = rvali[i];
+                    break;
+                case 604:
+                    parmM.fp_heur = rvali[i];
+                    break;
+                case 605:
+                    parmM.gmi_cuts = rvali[i];
+                    break;
+                case 606:
+                    parmM.mir_cuts = rvali[i];
+                    break;
+                case 607:
+                    parmM.cov_cuts = rvali[i];
+                    break;
+                case 608:
+                    parmM.clq_cuts = rvali[i];
+                    break;
+                case 609:
+                    parmM.cb_size = rvali[i];
+                    break;
+                case 610:
+                    parmM.binarize = rvali[i];
+                    break;
+                case 651:
+                    if (rvali[i] == 0) {
+                        parmM.cb_func = NULL;
+                        /* parmM.cb_info = NULL; */
+                    }
+                    else {
+                        parmM.cb_func = glpkCallback;
+                        /* parmM.cb_info = &glpkCallbackInfo; */
+                    }
+                    break;
+                default:
+                    Rf_warning("Unknown integer MIP parameter: %i!", rpari[i]);
+                    break;
+            }
+        }
+
+    }
+
+    if (Rf_asInteger(npard) == 0) {
+        rpard = NULL;
+        rvald = NULL;
+    }
+    else {
+        rpard = INTEGER(pard);
+        rvald = REAL(vald);
+
+        for (d = 0; d < Rf_asInteger(npard); d++) {
+            switch (rpard[d]) {
+                case 701:
+                    parmM.tol_int = rvald[d];
+                    break;
+                case 702:
+                    parmM.tol_obj = rvald[d];
+                    break;
+                case 703:
+                    parmM.mip_gap = rvald[d];
+                    break;
+                default:
+                    Rf_warning("Unknown double MIP parameter: %i!", rpard[d]);
+                    break;
+            }
+        }
+
+    }
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get simplex control parameters */
+SEXP getSimplexParm() {
+
+    SEXP listv   = R_NilValue;
+    SEXP parmext = R_NilValue;
+    SEXP intids  = R_NilValue;
+    SEXP dbids   = R_NilValue;
+
+    SEXP pint  = R_NilValue;
+    SEXP pdb   = R_NilValue;
+
+    PROTECT(pint = Rf_allocVector(INTSXP, 9));
+    PROTECT(pdb  = Rf_allocVector(REALSXP, 5));
+
+    INTEGER(pint)[0] = parmS.msg_lev;
+    INTEGER(pint)[1] = parmS.meth;
+    INTEGER(pint)[2] = parmS.pricing;
+    INTEGER(pint)[3] = parmS.r_test;
+    INTEGER(pint)[4] = parmS.it_lim;
+    INTEGER(pint)[5] = parmS.tm_lim;
+    INTEGER(pint)[6] = parmS.out_frq;
+    INTEGER(pint)[7] = parmS.out_dly;
+    INTEGER(pint)[8] = parmS.presolve;
+
+    REAL(pdb)[0] = parmS.tol_bnd;
+    REAL(pdb)[1] = parmS.tol_dj;
+    REAL(pdb)[2] = parmS.tol_piv;
+    REAL(pdb)[3] = parmS.obj_ll;
+    REAL(pdb)[4] = parmS.obj_ul;
+
+    PROTECT(intids = Rf_allocVector(STRSXP, 9));
+    SET_STRING_ELT(intids, 0, Rf_mkChar("msg_lev"));
+    SET_STRING_ELT(intids, 1, Rf_mkChar("meth"));
+    SET_STRING_ELT(intids, 2, Rf_mkChar("pricing"));
+    SET_STRING_ELT(intids, 3, Rf_mkChar("r_test"));
+    SET_STRING_ELT(intids, 4, Rf_mkChar("it_lim"));
+    SET_STRING_ELT(intids, 5, Rf_mkChar("tm_lim"));
+    SET_STRING_ELT(intids, 6, Rf_mkChar("out_frq"));
+    SET_STRING_ELT(intids, 7, Rf_mkChar("out_dly"));
+    SET_STRING_ELT(intids, 8, Rf_mkChar("presolve"));
+
+    PROTECT(dbids = Rf_allocVector(STRSXP, 5));
+    SET_STRING_ELT(dbids, 0, Rf_mkChar("tol_bnd"));
+    SET_STRING_ELT(dbids, 1, Rf_mkChar("tol_dj"));
+    SET_STRING_ELT(dbids, 2, Rf_mkChar("tol_piv"));
+    SET_STRING_ELT(dbids, 3, Rf_mkChar("obj_ll"));
+    SET_STRING_ELT(dbids, 4, Rf_mkChar("obj_ul"));
+
+    Rf_setAttrib(pint, R_NamesSymbol, intids);
+    Rf_setAttrib(pdb, R_NamesSymbol, dbids);
+
+    PROTECT(parmext = Rf_allocVector(VECSXP, 2));
+    SET_VECTOR_ELT(parmext, 0, pint);
+    SET_VECTOR_ELT(parmext, 1, pdb);
+
+    PROTECT(listv = Rf_allocVector(STRSXP, 2));
+    SET_STRING_ELT(listv, 0, Rf_mkChar("integer"));
+    SET_STRING_ELT(listv, 1, Rf_mkChar("double"));
+
+    Rf_setAttrib(parmext, R_NamesSymbol, listv);
+
+    UNPROTECT(6);
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get interior control parameters */
+SEXP getInteriorParm() {
+
+    SEXP listv   = R_NilValue;
+    SEXP parmext = R_NilValue;
+    SEXP intids  = R_NilValue;
+    SEXP pint    = R_NilValue;
+
+    PROTECT(pint = Rf_allocVector(INTSXP, 2));
+    INTEGER(pint)[0] = parmI.msg_lev;
+    INTEGER(pint)[1] = parmI.ord_alg;
+
+    PROTECT(intids = Rf_allocVector(STRSXP, 2));
+    SET_STRING_ELT(intids, 0, Rf_mkChar("msg_lev"));
+    SET_STRING_ELT(intids, 1, Rf_mkChar("ord_alg"));
+
+    Rf_setAttrib(pint, R_NamesSymbol, intids);
+
+    PROTECT(parmext = Rf_allocVector(VECSXP, 1));
+    SET_VECTOR_ELT(parmext, 0, pint);
+
+    PROTECT(listv = Rf_allocVector(STRSXP, 1));
+    SET_STRING_ELT(listv, 0, Rf_mkChar("integer"));
+
+    Rf_setAttrib(parmext, R_NamesSymbol, listv);
+
+    UNPROTECT(4);
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get MIP control parameters */
+SEXP getMIPParm() {
+
+    SEXP listv   = R_NilValue;
+    SEXP parmext = R_NilValue;
+    SEXP intids  = R_NilValue;
+    SEXP dbids   = R_NilValue;
+
+    SEXP pint  = R_NilValue;
+    SEXP pdb   = R_NilValue;
+
+    PROTECT(pint = Rf_allocVector(INTSXP, 16));
+    PROTECT(pdb  = Rf_allocVector(REALSXP, 3));
+
+    INTEGER(pint)[0]  = parmM.msg_lev;
+    INTEGER(pint)[1]  = parmM.br_tech;
+    INTEGER(pint)[2]  = parmM.bt_tech;
+    INTEGER(pint)[3]  = parmM.pp_tech;
+    INTEGER(pint)[4]  = parmM.fp_heur;
+    INTEGER(pint)[5]  = parmM.gmi_cuts;
+    INTEGER(pint)[6]  = parmM.mir_cuts;
+    INTEGER(pint)[7]  = parmM.cov_cuts;
+    INTEGER(pint)[8]  = parmM.clq_cuts;
+    INTEGER(pint)[9]  = parmM.tm_lim;
+    INTEGER(pint)[10] = parmM.out_frq;
+    INTEGER(pint)[11] = parmM.out_dly;
+    INTEGER(pint)[12] = parmM.cb_size;
+    INTEGER(pint)[13] = parmM.presolve;
+    INTEGER(pint)[14] = parmM.binarize;
+    if (parmM.cb_func) {
+        INTEGER(pint)[15] = 1;
+    }
+    else {
+        INTEGER(pint)[15] = 0;
+    }
+
+    REAL(pdb)[0] = parmM.tol_int;
+    REAL(pdb)[1] = parmM.tol_obj;
+    REAL(pdb)[2] = parmM.mip_gap;
+
+    PROTECT(intids = Rf_allocVector(STRSXP, 16));
+    SET_STRING_ELT(intids, 0,  Rf_mkChar("msg_lev"));
+    SET_STRING_ELT(intids, 1,  Rf_mkChar("br_tech"));
+    SET_STRING_ELT(intids, 2,  Rf_mkChar("bt_tech"));
+    SET_STRING_ELT(intids, 3,  Rf_mkChar("pp_tech"));
+    SET_STRING_ELT(intids, 4,  Rf_mkChar("fp_heur"));
+    SET_STRING_ELT(intids, 5,  Rf_mkChar("gmi_cuts"));
+    SET_STRING_ELT(intids, 6,  Rf_mkChar("mir_cuts"));
+    SET_STRING_ELT(intids, 7,  Rf_mkChar("cov_cuts"));
+    SET_STRING_ELT(intids, 8,  Rf_mkChar("clq_cuts"));
+    SET_STRING_ELT(intids, 9,  Rf_mkChar("tm_lim"));
+    SET_STRING_ELT(intids, 10, Rf_mkChar("out_frq"));
+    SET_STRING_ELT(intids, 11, Rf_mkChar("out_dly"));
+    SET_STRING_ELT(intids, 12, Rf_mkChar("cb_size"));
+    SET_STRING_ELT(intids, 13, Rf_mkChar("presolve"));
+    SET_STRING_ELT(intids, 14, Rf_mkChar("binarize"));
+    SET_STRING_ELT(intids, 15, Rf_mkChar("cb_func"));
+
+    PROTECT(dbids = Rf_allocVector(STRSXP, 3));
+    SET_STRING_ELT(dbids, 0, Rf_mkChar("tol_int"));
+    SET_STRING_ELT(dbids, 1, Rf_mkChar("tol_obj"));
+    SET_STRING_ELT(dbids, 2, Rf_mkChar("mip_gap"));
+
+    Rf_setAttrib(pint, R_NamesSymbol, intids);
+    Rf_setAttrib(pdb, R_NamesSymbol, dbids);
+
+    PROTECT(parmext = Rf_allocVector(VECSXP, 2));
+    SET_VECTOR_ELT(parmext, 0, pint);
+    SET_VECTOR_ELT(parmext, 1, pdb);
+
+    PROTECT(listv = Rf_allocVector(STRSXP, 2));
+    SET_STRING_ELT(listv, 0, Rf_mkChar("integer"));
+    SET_STRING_ELT(listv, 1, Rf_mkChar("double"));
+
+    Rf_setAttrib(parmext, R_NamesSymbol, listv);
+
+    UNPROTECT(6);
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set optimization direction */
+SEXP setObjDir(SEXP lp, SEXP dir) {
+
+    SEXP out = R_NilValue;
+    int dr;
+    
+    checkProb(lp);
+
+    dr = (Rf_asInteger(dir) == GLP_MAX) ? GLP_MAX : GLP_MIN;
+
+    glp_set_obj_dir(R_ExternalPtrAddr(lp), dr);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get optimization direction */
+SEXP getObjDir(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int dir = 0;
+
+    checkProb(lp);
+
+    dir = glp_get_obj_dir(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(dir);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* add rows to the problem object */
+SEXP addRows(SEXP lp, SEXP nrows) {
+
+    SEXP out = R_NilValue;
+    int frow = 0;
+
+    checkProb(lp);
+
+    frow = glp_add_rows(R_ExternalPtrAddr(lp), Rf_asInteger(nrows));
+
+    out = Rf_ScalarInteger(frow);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set row name i */
+SEXP setRowName(SEXP lp, SEXP i, SEXP rname) {
+
+    SEXP out = R_NilValue;
+
+    const char *rrname;
+    if (rname == R_NilValue) {
+        rrname = NULL;
+    }
+    else {
+        rrname = CHAR(STRING_ELT(rname, 0));
+    }
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    glp_set_row_name(R_ExternalPtrAddr(lp), Rf_asInteger(i), rrname);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set row names */
+SEXP setRowsNames(SEXP lp, SEXP i, SEXP rnames) {
+
+    SEXP out = R_NilValue;
+
+    int *ri = INTEGER(i);
+    int k, numrn;
+
+    checkProb(lp);
+    checkRowIndices(lp, i, NULL);
+
+    if (rnames == R_NilValue) {
+        numrn = Rf_length(i);
+        for (k = 0; k < numrn; k++) {
+            glp_set_row_name(R_ExternalPtrAddr(lp), ri[k], NULL);
+        }
+    }
+    else {
+        checkVecLen(Rf_ScalarInteger(Rf_length(i)), rnames);
+        numrn = Rf_length(rnames);
+        for (k = 0; k < numrn; k++) {
+            glp_set_row_name(R_ExternalPtrAddr(lp),
+                             ri[k], CHAR(STRING_ELT(rnames, k)));
+        }
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get row name i */
+SEXP getRowName(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+
+    const char *rrname;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    rrname = glp_get_row_name(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    if (rrname != NULL) {
+        out = Rf_mkString(rrname);
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* find row by its name */
+SEXP findRow(SEXP lp, SEXP rname) {
+
+    SEXP out = R_NilValue;
+    int rind;
+
+    const char *rrname = CHAR(STRING_ELT(rname, 0));
+
+    checkProb(lp);
+
+    if ( setjmp(jenv) ) {
+        glp_error_hook( NULL, NULL );
+        return out;
+    }
+
+    ge.e = 100;
+    glp_error_hook( (func) &cleanGLPKerror, &ge );
+
+    rind = glp_find_row(R_ExternalPtrAddr(lp), rrname);
+
+    glp_error_hook( NULL, NULL );
+
+    out = Rf_ScalarInteger(rind);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* add collumns to the problem object */
+SEXP addCols(SEXP lp, SEXP ncols) {
+
+    SEXP out = R_NilValue;
+    int fcol = 0;
+
+    checkProb(lp);
+
+    fcol = glp_add_cols(R_ExternalPtrAddr(lp), Rf_asInteger(ncols));
+
+    out = Rf_ScalarInteger(fcol);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column name j */
+SEXP setColName(SEXP lp, SEXP j, SEXP cname) {
+
+    SEXP out = R_NilValue;
+
+    const char *rcname;
+    if (cname == R_NilValue) {
+        rcname = NULL;
+    }
+    else {
+        rcname = CHAR(STRING_ELT(cname, 0));
+    }
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    glp_set_col_name(R_ExternalPtrAddr(lp), Rf_asInteger(j), rcname);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column names */
+SEXP setColsNames(SEXP lp, SEXP j, SEXP cnames) {
+
+    SEXP out = R_NilValue;
+
+    int *rj = INTEGER(j);
+    int k, numcn;
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+
+    if (cnames == R_NilValue) {
+        numcn = Rf_length(j);
+        for (k = 0; k < numcn; k++) {
+            glp_set_col_name(R_ExternalPtrAddr(lp), rj[k], NULL);
+        }
+    }
+    else {
+        checkVecLen(Rf_ScalarInteger(Rf_length(j)), cnames);
+        numcn = Rf_length(cnames);
+        for (k = 0; k < numcn; k++) {
+            glp_set_col_name(R_ExternalPtrAddr(lp),
+                             rj[k], CHAR(STRING_ELT(cnames, k)));
+        }
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column name j */
+SEXP getColName(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+
+    const char *rcname;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    rcname = glp_get_col_name(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    if (rcname != NULL) {
+        out = Rf_mkString(rcname);
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* find column by its name */
+SEXP findCol(SEXP lp, SEXP cname) {
+
+    SEXP out = R_NilValue;
+    int cind;
+
+    const char *rcname = CHAR(STRING_ELT(cname, 0));
+
+    checkProb(lp);
+
+    if ( setjmp(jenv) ) {
+        glp_error_hook( NULL, NULL );
+        return out;
+    }
+
+    ge.e = 100;
+    glp_error_hook( (func) &cleanGLPKerror, &ge );
+
+    cind = glp_find_col(R_ExternalPtrAddr(lp), rcname);
+
+    glp_error_hook( NULL, NULL );
+
+    out = Rf_ScalarInteger(cind);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get number of rows */
+SEXP getNumRows(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int nrows = 0;
+
+    checkProb(lp);
+
+    nrows = glp_get_num_rows(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(nrows);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get number of columns */
+SEXP getNumCols(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int ncols = 0;
+
+    checkProb(lp);
+
+    ncols = glp_get_num_cols(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(ncols);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column bounds (for more than one column) */
+SEXP setColsBnds(SEXP lp, SEXP j, SEXP type, SEXP lb, SEXP ub) {
+
+    SEXP out = R_NilValue;
+
+    int k, nj;
+    int *rj = INTEGER(j);
+    double *rlb = REAL(lb), *rub = REAL(ub);
+    const int *rtype;
+
+    if (type == R_NilValue) {
+        rtype = NULL;
+    }
+    else {
+        rtype = INTEGER(type);
+    }
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+    checkVarTypes(type);
+
+    /* nj = sizeof(j)/sizeof(j[0]) */       /* j is a SEXP,                   */
+    nj = Rf_length(j);                      /*  better use Rf_length() from R */
+
+    if (rtype == NULL) {
+        for (k = 0; k < nj; k++) {
+            if (islessgreater(rlb[k], rub[k])) {
+                glp_set_col_bnds(R_ExternalPtrAddr(lp),
+                                 rj[k], GLP_DB, rlb[k], rub[k]
+                );
+            }
+            else {
+                glp_set_col_bnds(R_ExternalPtrAddr(lp),
+                                 rj[k], GLP_FX, rlb[k], rub[k]
+                );
+            }
+        }
+    }
+    else {
+        for (k = 0; k < nj; k++) {
+            glp_set_col_bnds(R_ExternalPtrAddr(lp),
+                             rj[k], rtype[k], rlb[k], rub[k]
+            );
+        }
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column bounds and objective coefficients (for more than one column) */
+SEXP setColsBndsObjCoefs(SEXP lp, SEXP j, SEXP type,
+                         SEXP lb, SEXP ub, SEXP obj_coef) {
+
+    SEXP out = R_NilValue;
+
+    int k, nj;
+    int *rj = INTEGER(j);
+    double *rlb = REAL(lb), *rub = REAL(ub), *robj_coef = REAL(obj_coef);
+    const int *rtype;
+
+    if (type == R_NilValue) {
+        rtype = NULL;
+    }
+    else {
+        rtype = INTEGER(type);
+    }
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+    checkVarTypes(type);
+
+    nj = Rf_length(j);
+
+    if (rtype == NULL) {
+        for (k = 0; k < nj; k++) {
+            if (islessgreater(rlb[k], rub[k])) {
+                glp_set_col_bnds(R_ExternalPtrAddr(lp),
+                                 rj[k], GLP_DB, rlb[k], rub[k]
+                );
+            }
+            else {
+                glp_set_col_bnds(R_ExternalPtrAddr(lp),
+                                 rj[k], GLP_FX, rlb[k], rub[k]
+                );
+            }
+            glp_set_obj_coef(R_ExternalPtrAddr(lp), rj[k], robj_coef[k]);
+        }
+    }
+    else {
+        for (k = 0; k < nj; k++) {
+            glp_set_col_bnds(R_ExternalPtrAddr(lp),
+                             rj[k], rtype[k], rlb[k], rub[k]
+            );
+            glp_set_obj_coef(R_ExternalPtrAddr(lp), rj[k], robj_coef[k]);
+        }
+
+    }
+
+    return out;
+
+}
+
+/* -------------------------------------------------------------------------- */
+/* set column bound (for only one column) */
+SEXP setColBnd(SEXP lp, SEXP j, SEXP type, SEXP lb, SEXP ub) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+    checkVarType(type);
+
+    glp_set_col_bnds(R_ExternalPtrAddr(lp), Rf_asInteger(j), Rf_asInteger(type),
+                     Rf_asReal(lb), Rf_asReal(ub)
+    );
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column lower bounds (for more than one column) */
+SEXP getColsLowBnds(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+
+    int k, nj;
+    double lowbnd;
+    int *rj = INTEGER(j);
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+
+    nj = Rf_length(j);
+
+    PROTECT(out = Rf_allocVector(REALSXP, nj));
+    for (k = 0; k < nj; k++) {
+        lowbnd = glp_get_col_lb(R_ExternalPtrAddr(lp), rj[k]);
+        REAL(out)[k] = lowbnd;
+    }
+    UNPROTECT(1);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column low bound (for only one column) */
+SEXP getColLowBnd(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double lowbnd = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    lowbnd = glp_get_col_lb(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(lowbnd);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column upper bounds (for more than one column) */
+SEXP getColsUppBnds(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+
+    int k, nj;
+    double uppbnd;
+    int *rj = INTEGER(j);
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+
+    nj = Rf_length(j);
+
+    PROTECT(out = Rf_allocVector(REALSXP, nj));
+    for (k = 0; k < nj; k++) {
+        uppbnd = glp_get_col_ub(R_ExternalPtrAddr(lp), rj[k]);
+        REAL(out)[k] = uppbnd;
+    }
+    UNPROTECT(1);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column upper bound (for only one column) */
+SEXP getColUppBnd(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double uppbnd = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    uppbnd = glp_get_col_ub(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(uppbnd);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column kind (for only one column) */
+SEXP setColKind(SEXP lp, SEXP j, SEXP kind) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+    checkVarKind(kind);
+
+    glp_set_col_kind(R_ExternalPtrAddr(lp),
+                     Rf_asInteger(j), Rf_asInteger(kind));
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column kind (for more than one column) */
+SEXP setColsKind(SEXP lp, SEXP j, SEXP kind) {
+
+    SEXP out = R_NilValue;
+
+    int k, nj;
+    int *rj = INTEGER(j);
+    int *rkind = INTEGER(kind);
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+    checkVarKinds(kind);
+
+    nj = Rf_length(j);
+    for (k = 0; k < nj; k++) {
+        glp_set_col_kind(R_ExternalPtrAddr(lp), rj[k], rkind[k]);
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column kind (for only one column) */
+SEXP getColKind(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    int kind = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    kind = glp_get_col_kind(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarInteger(kind);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column kind (for more than one column) */
+SEXP getColsKind(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+
+    int k, nj;
+    int kind;
+    int *rj = INTEGER(j);
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+
+    nj = Rf_length(j);
+
+    PROTECT(out = Rf_allocVector(INTSXP, nj));
+    for (k = 0; k < nj; k++) {
+        kind = glp_get_col_kind(R_ExternalPtrAddr(lp), rj[k]);
+        INTEGER(out)[k] = kind;
+    }
+    UNPROTECT(1);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve number of integer columns */
+SEXP getNumInt(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int num = 0;
+
+    checkProb(lp);
+
+    num = glp_get_num_int(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(num);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve number of binary columns */
+SEXP getNumBin(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int num = 0;
+
+    checkProb(lp);
+
+    num = glp_get_num_bin(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(num);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set row bounds (for more than one row) */
+SEXP setRowsBnds(SEXP lp, SEXP i, SEXP type, SEXP lb, SEXP ub) {
+
+    SEXP out = R_NilValue;
+
+    int k, ni;
+    int *ri = INTEGER(i);
+    double *rlb = REAL(lb), *rub = REAL(ub);
+    const int *rtype;
+
+    if (type == R_NilValue) {
+        rtype = NULL;
+    }
+    else {
+        rtype = INTEGER(type);
+    }
+
+    checkProb(lp);
+    checkRowIndices(lp, i, NULL);
+    checkVarTypes(type);
+
+    ni = Rf_length(i);
+
+    if (rtype == NULL) {
+        for (k = 0; k < ni; k++) {
+            if (islessgreater(rlb[k], rub[k])) {
+                glp_set_row_bnds(R_ExternalPtrAddr(lp),
+                                 ri[k], GLP_DB, rlb[k], rub[k]
+                );
+            }
+            else {
+                glp_set_row_bnds(R_ExternalPtrAddr(lp),
+                                 ri[k], GLP_FX, rlb[k], rub[k]
+                );
+            }
+        }
+    }
+    else {
+        for (k = 0; k < ni; k++) {
+            glp_set_row_bnds(R_ExternalPtrAddr(lp),
+                             ri[k], rtype[k], rlb[k], rub[k]
+            );
+        }
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set right hand side (rhs) to zero (fixed) */
+SEXP setRhsZero(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    int k, nrows;
+
+    checkProb(lp);
+
+    nrows = glp_get_num_rows(R_ExternalPtrAddr(lp));
+
+    for (k = 1; k <= nrows; k++) {
+        glp_set_row_bnds(R_ExternalPtrAddr(lp), k, GLP_FX,
+                         (double) 0, (double) 0
+        );
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set row bound (for only one row) */
+SEXP setRowBnd(SEXP lp, SEXP i, SEXP type, SEXP lb, SEXP ub) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+    checkVarType(type);
+
+    glp_set_row_bnds(R_ExternalPtrAddr(lp), Rf_asInteger(i),
+                     Rf_asInteger(type), Rf_asReal(lb), Rf_asReal(ub)
+    );
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get row lower bounds (for more than one row) */
+SEXP getRowsLowBnds(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+
+    int k, ni;
+    double lowbnd;
+    int *ri = INTEGER(i);
+
+    checkProb(lp);
+    checkRowIndices(lp, i, NULL);
+
+    ni = Rf_length(i);
+
+    PROTECT(out = Rf_allocVector(REALSXP, ni));
+    for (k = 0; k < ni; k++) {
+        lowbnd = glp_get_row_lb(R_ExternalPtrAddr(lp), ri[k]);
+        REAL(out)[k] = lowbnd;
+    }
+    UNPROTECT(1);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get row low bound (for only one row) */
+SEXP getRowLowBnd(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    double lowbnd = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    lowbnd = glp_get_row_lb(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarReal(lowbnd);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get row upper bounds (for more than one row) */
+SEXP getRowsUppBnds(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+
+    int k, ni;
+    double uppbnd;
+    int *ri = INTEGER(i);
+
+    checkProb(lp);
+    checkRowIndices(lp, i, NULL);
+
+    ni = Rf_length(i);
+
+    PROTECT(out = Rf_allocVector(REALSXP, ni));
+    for (k = 0; k < ni; k++) {
+        uppbnd = glp_get_row_ub(R_ExternalPtrAddr(lp), ri[k]);
+        REAL(out)[k] = uppbnd;
+    }
+    UNPROTECT(1);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get row upper bound (for only one row) */
+SEXP getRowUppBnd(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    double uppbnd = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    uppbnd = glp_get_row_ub(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarReal(uppbnd);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get row type */
+SEXP getRowType(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    int type = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    type = glp_get_row_type(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarInteger(type);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get row types (for more than one row) */
+SEXP getRowsTypes(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+
+    int k, ni, type;
+    int *ri = INTEGER(i);
+
+    checkProb(lp);
+    checkRowIndices(lp, i, NULL);
+
+    ni = Rf_length(i);
+
+    PROTECT(out = Rf_allocVector(INTSXP, ni));
+    for (k = 0; k < ni; k++) {
+        type = glp_get_row_type(R_ExternalPtrAddr(lp), ri[k]);
+        INTEGER(out)[k] = type;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get col type */
+SEXP getColType(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    int type = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    type = glp_get_col_type(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarInteger(type);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set objective coefficients (for more than one column) */
+SEXP setObjCoefs(SEXP lp, SEXP j, SEXP obj_coef) {
+
+    SEXP out = R_NilValue;
+
+    int k, nj;
+    int *rj = INTEGER(j);
+    double *robj_coef = REAL(obj_coef);
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+
+    nj = Rf_length(j);
+    for (k = 0; k < nj; k++) {
+        glp_set_obj_coef(R_ExternalPtrAddr(lp), rj[k], robj_coef[k]);
+    }
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set objective coefficient (for only one column) */
+SEXP setObjCoef(SEXP lp, SEXP j, SEXP obj_coef) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    glp_set_obj_coef(R_ExternalPtrAddr(lp),
+                     Rf_asInteger(j), Rf_asReal(obj_coef)
+    );
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get objective coefficients (for more than one column) */
+SEXP getObjCoefs(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+
+    int k, nj;
+    double obj_coef;
+    int *rj = INTEGER(j);
+
+    checkProb(lp);
+    checkColIndices(lp, j, NULL);
+
+    nj = Rf_length(j);
+
+    PROTECT(out = Rf_allocVector(REALSXP, nj));
+    for (k = 0; k < nj; k++) {
+        obj_coef = glp_get_obj_coef(R_ExternalPtrAddr(lp), rj[k]);
+        REAL(out)[k] = obj_coef;
+    }
+    UNPROTECT(1);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get objective coefficient (for only one column) */
+SEXP getObjCoef(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double obj_coef = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    obj_coef = glp_get_obj_coef(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(obj_coef);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* load the whole constraint matrix */
+SEXP loadMatrix(SEXP lp, SEXP ne, SEXP ia, SEXP ja, SEXP ra) {
+
+    SEXP out = R_NilValue;
+
+    const int *ria = INTEGER(ia);
+    const int *rja = INTEGER(ja);
+    const double *rra = REAL(ra);
+
+    checkProb(lp);
+    checkVecLen(ne, ia);
+    checkVecLen(ne, ja);
+    checkVecLen(ne, ra);
+    checkRowIndices(lp, ia, NULL);
+    checkColIndices(lp, ja, NULL);
+    checkDupIndices(ia, ja, ne);
+
+/*
+    if ( setjmp(jenv) ) {
+        glp_error_hook( NULL, NULL );
+        return out;
+    }
+
+    ge.e = 100;
+    glp_error_hook( (func) &cleanGLPKerror, &ge );
+*/
+
+    glp_load_matrix(R_ExternalPtrAddr(lp), Rf_asInteger(ne),
+                    &(ria[-1]), &(rja[-1]), &(rra[-1]));
+
+/*
+    glp_error_hook( NULL, NULL );
+*/
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* check for duplicate elements in sparse matrix */
+SEXP checkDup(SEXP m, SEXP n, SEXP ne, SEXP ia, SEXP ja) {
+
+    SEXP out = R_NilValue;
+    int dup = 0;
+
+    const int *ria = INTEGER(ia);
+    const int *rja = INTEGER(ja);
+
+    dup = glp_check_dup(Rf_asInteger(m), Rf_asInteger(n), Rf_asInteger(ne),
+                        &(ria[-1]), &(rja[-1]));
+
+    out = Rf_ScalarInteger(dup);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* sort elements of the constraint matrix */
+SEXP sortMatrix(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+
+    glp_sort_matrix(R_ExternalPtrAddr(lp));
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* delete rows from problem object */
+SEXP delRows(SEXP lp, SEXP nrows, SEXP i) {
+
+    SEXP out = R_NilValue;
+
+    const int *ri = INTEGER(i);
+
+    checkProb(lp);
+    checkVecLen(Rf_ScalarInteger(Rf_asInteger(nrows) + 1), i);
+    checkRowIndices(lp, i, 1);
+
+    glp_del_rows(R_ExternalPtrAddr(lp), Rf_asInteger(nrows), ri);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* delete columns from problem object */
+SEXP delCols(SEXP lp, SEXP ncols, SEXP j) {
+
+    SEXP out = R_NilValue;
+
+    const int *rj = INTEGER(j);
+
+    checkProb(lp);
+    checkVecLen(Rf_ScalarInteger(Rf_asInteger(ncols) + 1), j);
+    checkColIndices(lp, j, 1);
+
+    glp_del_cols(R_ExternalPtrAddr(lp), Rf_asInteger(ncols), rj);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set row scale factor */
+SEXP setRii(SEXP lp, SEXP i, SEXP rii) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    glp_set_rii(R_ExternalPtrAddr(lp), Rf_asInteger(i), Rf_asReal(rii));
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column scale factor */
+SEXP setSjj(SEXP lp, SEXP j, SEXP sjj) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    glp_set_sjj(R_ExternalPtrAddr(lp), Rf_asInteger(j), Rf_asReal(sjj));
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row scale factor */
+SEXP getRii(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    double rii = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    rii = glp_get_rii(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarReal(rii);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column scale factor */
+SEXP getSjj(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double sjj = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    sjj = glp_get_sjj(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(sjj);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* problem scaling */
+SEXP scaleProb(SEXP lp, SEXP opt) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkScaling(opt);
+
+    glp_scale_prob(R_ExternalPtrAddr(lp), Rf_asInteger(opt));
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* problem unscaling */
+SEXP unscaleProb(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+
+    glp_unscale_prob(R_ExternalPtrAddr(lp));
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set row status */
+SEXP setRowStat(SEXP lp, SEXP i, SEXP stat) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+    checkVarStat(stat);
+
+    glp_set_row_stat(R_ExternalPtrAddr(lp),
+                     Rf_asInteger(i), Rf_asInteger(stat)
+    );
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column status */
+SEXP setColStat(SEXP lp, SEXP j, SEXP stat) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+    checkVarStat(stat);
+
+    glp_set_col_stat(R_ExternalPtrAddr(lp),
+                     Rf_asInteger(j), Rf_asInteger(stat)
+    );
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* construct standard initial LP basis */
+SEXP stdBasis(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+
+    glp_std_basis(R_ExternalPtrAddr(lp));
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* construct advanced initial LP basis */
+SEXP advBasis(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+
+    glp_adv_basis(R_ExternalPtrAddr(lp), 0);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* construct Bixby's initial LP basis */
+SEXP cpxBasis(SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    checkProb(lp);
+
+    glp_cpx_basis(R_ExternalPtrAddr(lp));
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* "warm up" LP basis */
+SEXP warmUp(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int wup = 0;
+
+    checkProb(lp);
+
+    wup = glp_warm_up(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(wup);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* enable/disable terminal output */
+SEXP termOut(SEXP flag) {
+
+    SEXP out = R_NilValue;
+    int pfl = 0;
+    int fl;
+
+    fl = (Rf_asInteger(flag) == GLP_ON) ? GLP_ON : GLP_OFF;
+
+    pfl = glp_term_out(fl);
+
+    out = Rf_ScalarInteger(pfl);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* solve problem with simplex algorithm */
+SEXP solveSimplex(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int ret = 0;
+
+    checkProb(lp);
+
+    /*
+    glp_smcp parmS;
+    glp_init_smcp(&parmS);
+    parmS.tm_lim = 10000;
+    */
+    ret = glp_simplex(R_ExternalPtrAddr(lp), &parmS);
+    /* ret = glp_simplex(R_ExternalPtrAddr(lp), NULL); */
+
+    out = Rf_ScalarInteger(ret);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* solve problem with exact simplex algorithm */
+SEXP solveSimplexExact(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int ret = 0;
+
+    checkProb(lp);
+
+    ret = glp_exact(R_ExternalPtrAddr(lp), &parmS);
+    /* ret = glp_exact(R_ExternalPtrAddr(lp), NULL); */
+
+    out = Rf_ScalarInteger(ret);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get value of the objective function after simplex */
+SEXP getObjVal(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double obj_val = 0;
+
+    checkProb(lp);
+
+    obj_val = glp_get_obj_val(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarReal(obj_val);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get solution status after simplex */
+SEXP getSolStat(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int stat = 0;
+
+    checkProb(lp);
+
+    stat = glp_get_status(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(stat);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column primal value (flux distribution) for all columns */
+SEXP getColsPrim(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double col_prim = 0;
+
+    int num_cols, k;
+
+    checkProb(lp);
+
+    num_cols = glp_get_num_cols(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_cols));
+    for (k = 1; k <= num_cols; k++) {
+        col_prim = glp_get_col_prim(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = col_prim;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column primal value (flux distribution) for one column */
+SEXP getColPrim(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double col_prim = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    col_prim = glp_get_col_prim(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(col_prim);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve status of primal basic solution */
+SEXP getPrimStat(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int prim_stat = 0;
+
+    checkProb(lp);
+
+    prim_stat = glp_get_prim_stat(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(prim_stat);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve status of dual basic solution */
+SEXP getDualStat(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int dual_stat = 0;
+
+    checkProb(lp);
+
+    dual_stat = glp_get_dual_stat(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(dual_stat);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row status */
+SEXP getRowStat(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    int row_stat = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    row_stat = glp_get_row_stat(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarInteger(row_stat);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row status for all rows */
+SEXP getRowsStat(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int row_stat = 0;
+
+    int num_rows, k;
+
+    checkProb(lp);
+
+    num_rows = glp_get_num_rows(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(INTSXP, num_rows));
+    for (k = 1; k <= num_rows; k++) {
+        row_stat = glp_get_row_stat(R_ExternalPtrAddr(lp), k);
+        INTEGER(out)[k-1] = row_stat;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row primal value */
+SEXP getRowPrim(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    double row_prim;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    row_prim = glp_get_row_prim(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarReal(row_prim);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row primal value for all rows */
+SEXP getRowsPrim(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double row_prim = 0;
+
+    int num_rows, k;
+
+    checkProb(lp);
+
+    num_rows = glp_get_num_rows(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_rows));
+    for (k = 1; k <= num_rows; k++) {
+        row_prim = glp_get_row_prim(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = row_prim;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row dual value */
+SEXP getRowDual(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    double row_dual;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    row_dual = glp_get_row_dual(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarReal(row_dual);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row dual value for all rows */
+SEXP getRowsDual(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double row_dual = 0;
+
+    int num_rows, k;
+
+    checkProb(lp);
+
+    num_rows = glp_get_num_rows(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_rows));
+    for (k = 1; k <= num_rows; k++) {
+        row_dual = glp_get_row_dual(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = row_dual;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column status */
+SEXP getColStat(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    int col_stat = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    col_stat = glp_get_col_stat(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarInteger(col_stat);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column status for all columns */
+SEXP getColsStat(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int col_stat = 0;
+
+    int num_cols, k;
+
+    checkProb(lp);
+
+    num_cols = glp_get_num_cols(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(INTSXP, num_cols));
+    for (k = 1; k <= num_cols; k++) {
+        col_stat = glp_get_col_stat(R_ExternalPtrAddr(lp), k);
+        INTEGER(out)[k-1] = col_stat;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column dual value */
+SEXP getColDual(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double col_dual = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    col_dual = glp_get_col_dual(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(col_dual);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column dual value for all columns */
+SEXP getColsDual(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double col_dual = 0;
+
+    int num_cols, k;
+
+    checkProb(lp);
+
+    num_cols = glp_get_num_cols(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_cols));
+    for (k = 1; k <= num_cols; k++) {
+        col_dual = glp_get_col_dual(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = col_dual;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* determine variable causing unboundedness */
+SEXP getUnbndRay(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int unbnd;
+
+    checkProb(lp);
+
+    unbnd = glp_get_unbnd_ray(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(unbnd);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* solve problem with interior point method */
+SEXP solveInterior(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int ret = 0;
+
+    checkProb(lp);
+
+    ret = glp_interior(R_ExternalPtrAddr(lp), &parmI);
+    /* ret = glp_interior(R_ExternalPtrAddr(lp), NULL); */
+
+    out = Rf_ScalarInteger(ret);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get value of the objective function after interior point method */
+SEXP getObjValIpt(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double obj_val = 0;
+
+    checkProb(lp);
+
+    obj_val = glp_ipt_obj_val(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarReal(obj_val);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get solution status after interior point method */
+SEXP getSolStatIpt(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int stat = 0;
+
+    checkProb(lp);
+
+    stat = glp_ipt_status(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(stat);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column primal value (flux distribution) for all columns (interior) */
+SEXP getColsPrimIpt(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double col_prim = 0;
+
+    int num_cols, k;
+
+    checkProb(lp);
+
+    num_cols = glp_get_num_cols(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_cols));
+    for (k = 1; k <= num_cols; k++) {
+        col_prim = glp_ipt_col_prim(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = col_prim;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column primal value (flux distribution) for one column (interior) */
+SEXP getColPrimIpt(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double col_prim = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    col_prim = glp_ipt_col_prim(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(col_prim);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row primal value (interior) */
+SEXP getRowPrimIpt(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    double row_prim = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    row_prim = glp_ipt_row_prim(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarReal(row_prim);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row primal value (interior) for all rows (interior) */
+SEXP getRowsPrimIpt(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double row_prim = 0;
+
+    int num_rows, k;
+
+    checkProb(lp);
+
+    num_rows = glp_get_num_rows(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_rows));
+    for (k = 1; k <= num_rows; k++) {
+        row_prim = glp_ipt_row_prim(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = row_prim;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row dual value (interior) */
+SEXP getRowDualIpt(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    double row_dual = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    row_dual = glp_ipt_row_dual(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarReal(row_dual);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row dual value (interior) for all rows (interior) */
+SEXP getRowsDualIpt(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double row_dual = 0;
+
+    int num_rows, k;
+
+    checkProb(lp);
+
+    num_rows = glp_get_num_rows(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_rows));
+    for (k = 1; k <= num_rows; k++) {
+        row_dual = glp_ipt_row_dual(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = row_dual;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column dual value (interior) */
+SEXP getColDualIpt(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double col_dual = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    col_dual = glp_ipt_col_dual(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(col_dual);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column dual value (interior) for all columns (interior) */
+SEXP getColsDualIpt(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double col_dual = 0;
+
+    int num_cols, k;
+
+    checkProb(lp);
+
+    num_cols = glp_get_num_cols(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_cols));
+    for (k = 1; k <= num_cols; k++) {
+        col_dual = glp_ipt_col_dual(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = col_dual;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* solve MIP problem with the branch-and-cut method */
+SEXP solveMIP(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int ret = 0;
+
+    checkProb(lp);
+
+    ret = glp_intopt(R_ExternalPtrAddr(lp), &parmM);
+
+    out = Rf_ScalarInteger(ret);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* determine status of MIP solution */
+SEXP mipStatus(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int stat = 0;
+
+    checkProb(lp);
+
+    stat = glp_mip_status(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(stat);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve objective value */
+SEXP mipObjVal(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double obj_val = 0;
+
+    checkProb(lp);
+
+    obj_val = glp_mip_obj_val(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarReal(obj_val);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row value (MIP) */
+SEXP mipRowVal(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    double row = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    row = glp_mip_row_val(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarReal(row);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row value for all rows (MIP) */
+SEXP mipRowsVal(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double row = 0;
+
+    int num_rows, k;
+
+    checkProb(lp);
+
+    num_rows = glp_get_num_rows(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_rows));
+    for (k = 1; k <= num_rows; k++) {
+        row = glp_mip_row_val(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = row;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column value (MIP) */
+SEXP mipColVal(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    double col = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    col = glp_mip_col_val(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarReal(col);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column value for all columns (MIP) */
+SEXP mipColsVal(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    double col = 0;
+
+    int num_cols, k;
+
+    checkProb(lp);
+
+    num_cols = glp_get_num_cols(R_ExternalPtrAddr(lp));
+
+    PROTECT(out = Rf_allocVector(REALSXP, num_cols));
+    for (k = 1; k <= num_cols; k++) {
+        col = glp_mip_col_val(R_ExternalPtrAddr(lp), k);
+        REAL(out)[k-1] = col;
+    }
+    UNPROTECT(1);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get the number of constraint coefficients (number of non-zero elements in
+   the consrtaint matrix) */
+SEXP getNumNnz(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int nnz = 0;
+
+    checkProb(lp);
+
+    nnz = glp_get_num_nz(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(nnz);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get row i of the contraint matrix */
+SEXP getMatRow(SEXP lp, SEXP i) {
+
+    SEXP out   = R_NilValue;
+    SEXP ind   = R_NilValue;
+    SEXP val   = R_NilValue;
+    SEXP listv = R_NilValue;
+
+    int nnzr = 0;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    nnzr = glp_get_mat_row(R_ExternalPtrAddr(lp), Rf_asInteger(i), NULL, NULL);
+
+    if (nnzr > 0) {
+        PROTECT(ind = Rf_allocVector(INTSXP,  nnzr+1));
+        PROTECT(val = Rf_allocVector(REALSXP, nnzr+1));
+
+        nnzr = glp_get_mat_row(R_ExternalPtrAddr(lp), Rf_asInteger(i),
+                               INTEGER(ind), REAL(val)
+               );
+
+        /* maybe this is ugly */
+        REAL(val)[0] = 0;
+        INTEGER(ind)[0] = 0;
+
+        PROTECT(out = Rf_allocVector(VECSXP, 3));
+        SET_VECTOR_ELT(out, 0, Rf_ScalarInteger(nnzr));
+        SET_VECTOR_ELT(out, 1, ind);
+        SET_VECTOR_ELT(out, 2, val);
+
+        PROTECT(listv = Rf_allocVector(STRSXP, 3));
+        SET_STRING_ELT(listv, 0, Rf_mkChar("nnz"));
+        SET_STRING_ELT(listv, 1, Rf_mkChar("index"));
+        SET_STRING_ELT(listv, 2, Rf_mkChar("value"));
+        Rf_setAttrib(out, R_NamesSymbol, listv);
+
+        UNPROTECT(4);
+    }
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set row i of the contraint matrix */
+SEXP setMatRow(SEXP lp, SEXP i, SEXP len, SEXP ind, SEXP val) {
+
+    SEXP out   = R_NilValue;
+
+    int *rind;
+    double *rval;
+
+    if (ind == R_NilValue) {
+        rind = NULL;
+    }
+    else {
+        rind = INTEGER(ind);
+    }
+
+    if (val == R_NilValue) {
+        rval = NULL;
+    }
+    else {
+        rval = REAL(val);
+    }
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+    checkColIndices(lp, ind, 1);
+
+    glp_set_mat_row(R_ExternalPtrAddr(lp), Rf_asInteger(i),
+                    Rf_asInteger(len), rind, rval
+                   );
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get column j of the contraint matrix */
+SEXP getMatCol(SEXP lp, SEXP j) {
+
+    SEXP out   = R_NilValue;
+    SEXP ind   = R_NilValue;
+    SEXP val   = R_NilValue;
+    SEXP listv = R_NilValue;
+
+    int nnzc = 0;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    nnzc = glp_get_mat_col(R_ExternalPtrAddr(lp), Rf_asInteger(j), NULL, NULL);
+
+    if (nnzc > 0) {
+        PROTECT(ind = Rf_allocVector(INTSXP,  nnzc+1));
+        PROTECT(val = Rf_allocVector(REALSXP, nnzc+1));
+
+        nnzc = glp_get_mat_col(R_ExternalPtrAddr(lp), Rf_asInteger(j),
+                               INTEGER(ind), REAL(val)
+                               );
+
+        /* maybe this is ugly */
+        REAL(val)[0] = 0;
+        INTEGER(ind)[0] = 0;
+
+        PROTECT(out = Rf_allocVector(VECSXP, 3));
+        SET_VECTOR_ELT(out, 0, Rf_ScalarInteger(nnzc));
+        SET_VECTOR_ELT(out, 1, ind);
+        SET_VECTOR_ELT(out, 2, val);
+
+        PROTECT(listv = Rf_allocVector(STRSXP, 3));
+        SET_STRING_ELT(listv, 0, Rf_mkChar("nnz"));
+        SET_STRING_ELT(listv, 1, Rf_mkChar("index"));
+        SET_STRING_ELT(listv, 2, Rf_mkChar("value"));
+        Rf_setAttrib(out, R_NamesSymbol, listv);
+
+        UNPROTECT(4);
+    }
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* set column j of the contraint matrix */
+SEXP setMatCol(SEXP lp, SEXP j, SEXP len, SEXP ind, SEXP val) {
+
+    SEXP out   = R_NilValue;
+
+    const int *rind;
+    const double *rval;
+
+    if (ind == R_NilValue) {
+        rind = NULL;
+    }
+    else {
+        rind = INTEGER(ind);
+    }
+
+    if (val == R_NilValue) {
+        rval = NULL;
+    }
+    else {
+        rval = REAL(val);
+    }
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+    checkRowIndices(lp, ind, 1);
+
+    glp_set_mat_col(R_ExternalPtrAddr(lp), Rf_asInteger(j),
+                    Rf_asInteger(len), rind, rval
+                   );
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* read problem data in MPS format */
+SEXP readMPS(SEXP lp, SEXP fmt, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+    int fm;
+
+    checkProb(lp);
+
+    fm = (Rf_asInteger(fmt) == GLP_MPS_DECK) ? GLP_MPS_DECK : GLP_MPS_FILE;
+
+    check = glp_read_mps(R_ExternalPtrAddr(lp), fm, NULL, rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* read problem data in CPLEX LP format */
+SEXP readLP(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_read_lp(R_ExternalPtrAddr(lp), NULL, rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* read problem data in GLPK format */
+SEXP readProb(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+    int flags = 0;
+
+    checkProb(lp);
+
+    check = glp_read_prob(R_ExternalPtrAddr(lp), flags, rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write problem data in MPS format */
+SEXP writeMPS(SEXP lp, SEXP fmt, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+    int fm;
+
+    checkProb(lp);
+
+    fm = (Rf_asInteger(fmt) == GLP_MPS_DECK) ? GLP_MPS_DECK : GLP_MPS_FILE;
+
+    check = glp_write_mps(R_ExternalPtrAddr(lp), fm, NULL, rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write problem data in CPLEX LP format */
+SEXP writeLP(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_write_lp(R_ExternalPtrAddr(lp), NULL, rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write problem data in GLPK format */
+SEXP writeProb(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+    int flags = 0;
+
+    checkProb(lp);
+
+    check = glp_write_prob(R_ExternalPtrAddr(lp), flags, rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write basic solution in printable format */
+SEXP printSol(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_print_sol(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* read basic solution from text file */
+SEXP readSol(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_read_sol(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write basic solution to text file */
+SEXP writeSol(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_write_sol(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write interior-point solution in printable format */
+SEXP printIpt(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_print_ipt(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* read interior-point solution from text file */
+SEXP readIpt(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_read_ipt(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write interior-point solution to text file */
+SEXP writeIpt(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_write_ipt(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write MIP solution in printable format */
+SEXP printMIP(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_print_mip(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* read MIP solution from text file */
+SEXP readMIP(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_read_mip(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* write MIP solution to text file */
+SEXP writeMIP(SEXP lp, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkProb(lp);
+
+    check = glp_write_mip(R_ExternalPtrAddr(lp), rfname);
+
+    out = Rf_ScalarInteger(check);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* determine library version */
+SEXP version() {
+
+    SEXP out = R_NilValue;
+
+    const char *vstr = glp_version();
+
+    out = Rf_mkString(vstr);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* check if the basis factorization exists */
+SEXP bfExists(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int bex = 0;
+
+    checkProb(lp);
+
+    bex = glp_bf_exists(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(bex);
+
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* compute the basis factorization */
+SEXP factorize(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int fex = 0;
+
+    checkProb(lp);
+
+    fex = glp_factorize(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(fex);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* check if the basis factorization has been updated */
+SEXP bfUpdated(SEXP lp) {
+
+    SEXP out = R_NilValue;
+    int bup = 0;
+
+    checkProb(lp);
+
+    bup = glp_bf_updated(R_ExternalPtrAddr(lp));
+
+    out = Rf_ScalarInteger(bup);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* change basis factorization control parameters */
+SEXP setBfcp(SEXP lp, SEXP npari, SEXP pari, SEXP vali,
+                      SEXP npard, SEXP pard, SEXP vald) {
+
+    SEXP out   = R_NilValue;
+
+    glp_bfcp parmB;
+
+    int *rpari;
+    int *rvali;
+
+    int *rpard;
+    double *rvald;
+
+    int i, d;
+
+    checkProb(lp);
+
+    /* get current values of control parameters */
+    glp_get_bfcp(R_ExternalPtrAddr(lp), &parmB);
+
+    if (Rf_asInteger(npari) == 0) {
+        rpari = NULL;
+        rvali = NULL;
+    }
+    else {
+        rpari = INTEGER(pari);
+        rvali = INTEGER(vali);
+
+        for (i = 0; i < Rf_asInteger(npari); i++) {
+            /* Rprintf("par: %i  val: %i\n", rpari[i], rvali[i]); */
+            switch (rpari[i]) {
+                case 401:
+                    parmB.type = rvali[i];
+                    break;
+                case 402:
+                    parmB.lu_size = rvali[i];
+                    break;
+                case 403:
+                    parmB.piv_lim = rvali[i];
+                    break;
+                case 404:
+                    parmB.suhl = rvali[i];
+                    break;
+                case 405:
+                    parmB.nfs_max = rvali[i];
+                    break;
+                case 406:
+                    parmB.nrs_max = rvali[i];
+                    break;
+                case 407:
+                    parmB.rs_size = rvali[i];
+                    break;
+                default:
+                    Rf_warning("Unknown integer basis factorization parameter: %i!", rpari[i]);
+                    break;
+            }
+        }
+
+    }
+
+    if (Rf_asInteger(npard) == 0) {
+        rpard = NULL;
+        rvald = NULL;
+    }
+    else {
+        rpard = INTEGER(pard);
+        rvald = REAL(vald);
+
+        for (d = 0; d < Rf_asInteger(npard); d++) {
+            /* Rprintf("par: %i  val: %i\n", rpard[d], rvald[d]); */
+            switch (rpard[d]) {
+                case 501:
+                    parmB.piv_tol = rvald[d];
+                    break;
+                case 502:
+                    parmB.eps_tol = rvald[d];
+                    break;
+                case 503:
+                    parmB.max_gro = rvald[d];
+                    break;
+                case 504:
+                    parmB.upd_tol = rvald[d];
+                    break;
+                default:
+                    Rf_warning("Unknown double basis factorization parameter: %i!", rpard[d]);
+                    break;
+            }
+        }
+
+    }
+
+    /* set new values of control parameters */
+    glp_set_bfcp(R_ExternalPtrAddr(lp), &parmB);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* get basis factorization control parameters */
+SEXP getBfcp(SEXP lp) {
+
+    glp_bfcp parmB;
+
+    SEXP listv   = R_NilValue;
+    SEXP parmext = R_NilValue;
+    SEXP intids  = R_NilValue;
+    SEXP dbids   = R_NilValue;
+
+    SEXP pint  = R_NilValue;
+    SEXP pdb   = R_NilValue;
+
+    /* get current values of control parameters */
+    glp_get_bfcp(R_ExternalPtrAddr(lp), &parmB);
+
+    PROTECT(pint = Rf_allocVector(INTSXP, 7));
+    PROTECT(pdb  = Rf_allocVector(REALSXP, 4));
+
+    INTEGER(pint)[0] = parmB.type;
+    INTEGER(pint)[1] = parmB.lu_size;
+    INTEGER(pint)[2] = parmB.piv_lim;
+    INTEGER(pint)[3] = parmB.suhl;
+    INTEGER(pint)[4] = parmB.nfs_max;
+    INTEGER(pint)[5] = parmB.nrs_max;
+    INTEGER(pint)[6] = parmB.rs_size;
+
+    REAL(pdb)[0] = parmB.piv_tol;
+    REAL(pdb)[1] = parmB.eps_tol;
+    REAL(pdb)[2] = parmB.max_gro;
+    REAL(pdb)[3] = parmB.upd_tol;
+
+    PROTECT(intids = Rf_allocVector(STRSXP, 7));
+    SET_STRING_ELT(intids, 0, Rf_mkChar("type"));
+    SET_STRING_ELT(intids, 1, Rf_mkChar("lu_size"));
+    SET_STRING_ELT(intids, 2, Rf_mkChar("piv_lim"));
+    SET_STRING_ELT(intids, 3, Rf_mkChar("suhl"));
+    SET_STRING_ELT(intids, 4, Rf_mkChar("nfs_max"));
+    SET_STRING_ELT(intids, 5, Rf_mkChar("nrs_max"));
+    SET_STRING_ELT(intids, 6, Rf_mkChar("rs_size"));
+
+    PROTECT(dbids = Rf_allocVector(STRSXP, 4));
+    SET_STRING_ELT(dbids, 0, Rf_mkChar("piv_tol"));
+    SET_STRING_ELT(dbids, 1, Rf_mkChar("eps_tol"));
+    SET_STRING_ELT(dbids, 2, Rf_mkChar("max_gro"));
+    SET_STRING_ELT(dbids, 3, Rf_mkChar("upd_tol"));
+
+    Rf_setAttrib(pint, R_NamesSymbol, intids);
+    Rf_setAttrib(pdb, R_NamesSymbol, dbids);
+
+    PROTECT(parmext = Rf_allocVector(VECSXP, 2));
+    SET_VECTOR_ELT(parmext, 0, pint);
+    SET_VECTOR_ELT(parmext, 1, pdb);
+
+    PROTECT(listv = Rf_allocVector(STRSXP, 2));
+    SET_STRING_ELT(listv, 0, Rf_mkChar("integer"));
+    SET_STRING_ELT(listv, 1, Rf_mkChar("double"));
+
+    Rf_setAttrib(parmext, R_NamesSymbol, listv);
+
+    UNPROTECT(6);
+
+    return parmext;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve basis header information */
+SEXP getBhead(SEXP lp, SEXP k) {
+
+    SEXP out = R_NilValue;
+    int bh;
+
+    checkProb(lp);
+
+    bh = glp_get_bhead(R_ExternalPtrAddr(lp), Rf_asInteger(k));
+
+    out = Rf_ScalarInteger(bh);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve row index in the basis header */
+SEXP getRbind(SEXP lp, SEXP i) {
+
+    SEXP out = R_NilValue;
+    int rh;
+
+    checkProb(lp);
+    checkRowIndex(lp, i);
+
+    rh = glp_get_row_bind(R_ExternalPtrAddr(lp), Rf_asInteger(i));
+
+    out = Rf_ScalarInteger(rh);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* retrieve column index in the basis header */
+SEXP getCbind(SEXP lp, SEXP j) {
+
+    SEXP out = R_NilValue;
+    int ch;
+
+    checkProb(lp);
+    checkColIndex(lp, j);
+
+    ch = glp_get_col_bind(R_ExternalPtrAddr(lp), Rf_asInteger(j));
+
+    out = Rf_ScalarInteger(ch);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* print sensitivity analysis report */
+SEXP printRanges(SEXP lp, SEXP numrc, SEXP rowcol, SEXP fname) {
+
+    SEXP out = R_NilValue;
+
+    const int *rrowcol;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int sensit;
+
+    if (rowcol == R_NilValue) {
+        rrowcol = NULL;
+    }
+    else {
+        rrowcol = INTEGER(rowcol);
+    }
+
+    checkProb(lp);
+
+    sensit = glp_print_ranges(R_ExternalPtrAddr(lp), Rf_asInteger(numrc),
+                              rrowcol, 0, rfname
+                             );
+
+    out = Rf_ScalarInteger(sensit);
+
+    return out;
+
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* allocate translator workspace */
+SEXP mplAllocWksp(SEXP ptrtype) {
+
+    SEXP wkext = R_NilValue;
+    SEXP ptr, class;
+    
+    glp_tran *wk;
+
+    /* create translator workspace pointer */
+    PROTECT(ptr = Rf_allocVector(STRSXP, 1));
+    SET_STRING_ELT(ptr, 0, STRING_ELT(ptrtype, 0));
+
+    PROTECT(class = Rf_allocVector(STRSXP, 1));
+    SET_STRING_ELT(class, 0, Rf_mkChar("trwks_ptr"));
+
+    wk = glp_mpl_alloc_wksp();
+
+    wkext = R_MakeExternalPtr(wk, tagMATHprog, R_NilValue);
+    PROTECT(wkext);
+    R_RegisterCFinalizerEx(wkext, mathProgFinalizer, TRUE);
+    Rf_setAttrib(ptr, class, wkext);
+    Rf_classgets(ptr, class);
+    UNPROTECT(3);
+
+    return ptr;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* free translator workspace */
+SEXP mplFreeWksp(SEXP wksp) {
+
+    SEXP out = R_NilValue;
+    glp_tran *delwk = NULL;
+
+    checkMathProg(wksp);
+
+    delwk = R_ExternalPtrAddr(wksp);
+
+    glp_mpl_free_wksp(delwk);
+    R_ClearExternalPtr(wksp);
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* read and translate model section */
+SEXP mplReadModel(SEXP wk, SEXP fname, SEXP skip) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkMathProg(wk);
+
+    if ( setjmp(jenv) ) {
+        glp_error_hook( NULL, NULL );
+        return out;
+    }
+
+    ge.e = 100;
+    glp_error_hook( (func) &cleanGLPKerror, &ge );
+
+    check = glp_mpl_read_model(R_ExternalPtrAddr(wk),
+                               rfname, Rf_asInteger(skip));
+
+    glp_error_hook( NULL, NULL );
+    
+    if (check != 0) {
+        out = Rf_ScalarInteger(check);
+    }
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* read and translate data section */
+SEXP mplReadData(SEXP wk, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname = CHAR(STRING_ELT(fname, 0));
+    int check = 0;
+
+    checkMathProg(wk);
+
+    if ( setjmp(jenv) ) {
+        glp_error_hook( NULL, NULL );
+        return out;
+    }
+
+    ge.e = 100;
+    glp_error_hook( (func) &cleanGLPKerror, &ge );
+
+    check = glp_mpl_read_data(R_ExternalPtrAddr(wk), rfname);
+
+    glp_error_hook( NULL, NULL );
+
+    if (check != 0) {
+        out = Rf_ScalarInteger(check);
+    }
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* generate the model */
+SEXP mplGenerate(SEXP wk, SEXP fname) {
+
+    SEXP out = R_NilValue;
+    const char *rfname;
+    int check = 0;
+
+    checkMathProg(wk);
+
+    if (fname == R_NilValue) {
+        rfname = NULL;
+    }
+    else {
+        rfname = CHAR(STRING_ELT(fname, 0));
+    }
+
+    if ( setjmp(jenv) ) {
+        glp_error_hook( NULL, NULL );
+        return out;
+    }
+
+    ge.e = 100;
+    glp_error_hook( (func) &cleanGLPKerror, &ge );
+
+    check = glp_mpl_generate(R_ExternalPtrAddr(wk), rfname);
+
+    glp_error_hook( NULL, NULL );
+
+    if (check != 0) {
+        out = Rf_ScalarInteger(check);
+    }
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* build problem instance from model */
+SEXP mplBuildProb(SEXP wk, SEXP lp) {
+
+    SEXP out = R_NilValue;
+
+    checkMathProg(wk);
+    checkProb(lp);
+
+    glp_mpl_build_prob(R_ExternalPtrAddr(wk), R_ExternalPtrAddr(lp));
+
+    return out;
+}
+
+
+/* -------------------------------------------------------------------------- */
+/* postsolve model */
+SEXP mplPostsolve(SEXP wk, SEXP lp, SEXP sol) {
+
+    SEXP out = R_NilValue;
+    int check = 0;
+
+    checkMathProg(wk);
+    checkProb(lp);
+    checkSolType(sol);
+
+    ge.e = 100;
+    glp_error_hook( (func) &cleanGLPKerror, &ge );
+
+    check = glp_mpl_postsolve(R_ExternalPtrAddr(wk),
+                              R_ExternalPtrAddr(lp),
+                              Rf_asInteger(sol));
+
+    glp_error_hook( NULL, NULL );
+
+    if (check != 0) {
+        out = Rf_ScalarInteger(check);
+    }
+
+    return out;
+}
diff --git a/src/glpkAPI.h b/src/glpkAPI.h
new file mode 100644
index 0000000000000000000000000000000000000000..2560e1f17e66d6ce6f95f1c6d95c6b3dafe87a3c
--- /dev/null
+++ b/src/glpkAPI.h
@@ -0,0 +1,510 @@
+/* glpkAPI.h
+   R interface to GLPK.
+ 
+   Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+   Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+   All right reserved.
+   Email: geliudie@uni-duesseldorf.de
+ 
+   This file is part of glpkAPI.
+ 
+   GlpkAPI is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+ 
+   GlpkAPI is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with glpkAPI.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "glpkR.h"
+
+
+/* -------------------------------------------------------------------------- */
+/* help functions                                                             */
+/* -------------------------------------------------------------------------- */
+
+/* check for pointer to glpk */
+SEXP isGLPKptr(SEXP ptr);
+
+/* check for pointer to translator workspace */
+SEXP isTRWKSptr(SEXP ptr);
+
+/* check for NULL pointer */
+SEXP isNULLptr(SEXP ptr);
+
+
+/* -------------------------------------------------------------------------- */
+/* API functions                                                              */
+/* -------------------------------------------------------------------------- */
+
+/* initialize glpk */
+SEXP initGLPK(void);
+
+/* remove problem object */
+SEXP delProb(SEXP lp);
+
+/* erase problem object content */
+SEXP eraseProb(SEXP lp);
+
+/* copy problem object content */
+SEXP copyProb(SEXP lp, SEXP clp, SEXP names);
+
+/* create new problem object */
+SEXP initProb(SEXP ptrtype);
+
+/* set problem name */
+SEXP setProbName(SEXP lp, SEXP pname);
+
+/* get problem name */
+SEXP getProbName(SEXP lp);
+
+/* set objective function name */
+SEXP setObjName(SEXP lp, SEXP oname);
+
+/* get objective function name */
+SEXP getObjName(SEXP lp);
+
+/* create name index */
+SEXP createIndex(SEXP lp);
+
+/* delete name index */
+SEXP deleteIndex(SEXP lp);
+
+/* create parameter structure for simplex */
+SEXP setDefaultSmpParm();
+
+/* create parameter structure for interior */
+SEXP setDefaultIptParm();
+
+/* create parameter structure for MIP */
+SEXP setDefaultMIPParm();
+
+/* set simplex control parameters */
+SEXP setSimplexParm(SEXP npari, SEXP pari, SEXP vali,
+                    SEXP npard, SEXP pard, SEXP vald);
+
+/* set interior control parameters */
+SEXP setInteriorParm(SEXP npari, SEXP pari, SEXP vali);
+
+/* set MIP control parameters */
+SEXP setMIPParm(SEXP npari, SEXP pari, SEXP vali,
+                SEXP npard, SEXP pard, SEXP vald);
+
+/* get simplex control parameters */
+SEXP getSimplexParm();
+
+/* get interior control parameters */
+SEXP getInteriorParm();
+
+/* get MIP control parameters */
+SEXP getMIPParm();
+
+/* set optimization direction */
+SEXP setObjDir(SEXP lp, SEXP dir);
+
+/* get optimization direction */
+SEXP getObjDir(SEXP lp);
+
+/* add rows to the problem object */
+SEXP addRows(SEXP lp, SEXP nrows);
+
+/* set row name i */
+SEXP setRowName(SEXP lp, SEXP i, SEXP rname);
+
+/* set row names */
+SEXP setRowsNames(SEXP lp, SEXP i, SEXP rnames);
+
+/* get row name i */
+SEXP getRowName(SEXP lp, SEXP i);
+
+/* find row by its name */
+SEXP findRow(SEXP lp, SEXP rname);
+
+/* add collumns to the problem object */
+SEXP addCols(SEXP lp, SEXP ncols);
+
+/* set column name j */
+SEXP setColName(SEXP lp, SEXP j, SEXP cname);
+
+/* set column names */
+SEXP setColsNames(SEXP lp, SEXP j, SEXP cnames);
+
+/* get column name j */
+SEXP getColName(SEXP lp, SEXP j);
+
+/* find column by its name */
+SEXP findCol(SEXP lp, SEXP cname);
+
+/* get number of rows */
+SEXP getNumRows(SEXP lp);
+
+/* get number of columns */
+SEXP getNumCols(SEXP lp);
+
+/* set column bounds (for more than one column) */
+SEXP setColsBnds(SEXP lp, SEXP j, SEXP type, SEXP lb, SEXP ub);
+
+/* set column bounds and objective coefficients (for more than one column) */
+SEXP setColsBndsObjCoefs(SEXP lp, SEXP j, SEXP type,
+                         SEXP lb, SEXP ub, SEXP obj_coef);
+
+/* set column bound (for only one column) */
+SEXP setColBnd(SEXP lp, SEXP j, SEXP type, SEXP lb, SEXP ub);
+
+/* get column lower bounds (for more than one column) */
+SEXP getColsLowBnds(SEXP lp, SEXP j);
+
+/* get column low bound (for only one column) */
+SEXP getColLowBnd(SEXP lp, SEXP j);
+
+/* get column upper bounds (for more than one column) */
+SEXP getColsUppBnds(SEXP lp, SEXP j);
+
+/* get column upper bound (for only one column) */
+SEXP getColUppBnd(SEXP lp, SEXP j);
+
+/* set column kind (for only one column) */
+SEXP setColKind(SEXP lp, SEXP j, SEXP kind);
+
+/* set column kind (for more than one column) */
+SEXP setColsKind(SEXP lp, SEXP j, SEXP kind);
+
+/* retrieve column kind (for only one column) */
+SEXP getColKind(SEXP lp, SEXP j);
+
+/* retrieve column kind (for more than one column) */
+SEXP getColsKind(SEXP lp, SEXP j);
+
+/* retrieve number of integer columns */
+SEXP getNumInt(SEXP lp);
+
+/* retrieve number of binary columns */
+SEXP getNumBin(SEXP lp);
+
+/* set row bounds (for more than one row) */
+SEXP setRowsBnds(SEXP lp, SEXP i, SEXP type, SEXP lb, SEXP ub);
+
+/* set right hand side (rhs) to zero (fixed) */
+SEXP setRhsZero(SEXP lp);
+
+/* set row bound (for only one row) */
+SEXP setRowBnd(SEXP lp, SEXP i, SEXP type, SEXP lb, SEXP ub);
+
+/* get row lower bounds (for more than one row) */
+SEXP getRowsLowBnds(SEXP lp, SEXP i);
+
+/* get row low bound (for only one row) */
+SEXP getRowLowBnd(SEXP lp, SEXP i);
+
+/* get row upper bounds (for more than one row) */
+SEXP getRowsUppBnds(SEXP lp, SEXP i);
+
+/* get row upper bound (for only one row) */
+SEXP getRowUppBnd(SEXP lp, SEXP i);
+
+/* get row type */
+SEXP getRowType(SEXP lp, SEXP i);
+
+/* get row types (for more than one row) */
+SEXP getRowsTypes(SEXP lp, SEXP i);
+
+/* get col type */
+SEXP getColType(SEXP lp, SEXP j);
+
+/* set objective coefficients (for more than one column) */
+SEXP setObjCoefs(SEXP lp, SEXP j, SEXP obj_coef);
+
+/* set objective coefficient (for only one column) */
+SEXP setObjCoef(SEXP lp, SEXP j, SEXP obj_coef);
+
+/* get objective coefficients (for more than one column) */
+SEXP getObjCoefs(SEXP lp, SEXP j);
+
+/* get objective coefficient (for only one column) */
+SEXP getObjCoef(SEXP lp, SEXP j);
+
+/* load the whole constraint matrix */
+SEXP loadMatrix(SEXP lp, SEXP ne, SEXP ia, SEXP ja, SEXP ra);
+
+/* check for duplicate elements in sparse matrix */
+SEXP checkDup(SEXP m, SEXP n, SEXP ne, SEXP ia, SEXP ja);
+
+/* sort elements of the constraint matrix */
+SEXP sortMatrix(SEXP lp);
+
+/* delete rows from problem object */
+SEXP delRows(SEXP lp, SEXP nrows, SEXP i);
+
+/* delete columns from problem object */
+SEXP delCols(SEXP lp, SEXP ncols, SEXP j);
+
+/* set row scale factor */
+SEXP setRii(SEXP lp, SEXP i, SEXP rii);
+
+/* set column scale factor */
+SEXP setSjj(SEXP lp, SEXP j, SEXP sjj);
+
+/* retrieve row scale factor */
+SEXP getRii(SEXP lp, SEXP i);
+
+/* retrieve column scale factor */
+SEXP getSjj(SEXP lp, SEXP j);
+
+/* problem scaling */
+SEXP scaleProb(SEXP lp, SEXP opt);
+
+/* problem unscaling */
+SEXP unscaleProb(SEXP lp);
+
+/* set row status */
+SEXP setRowStat(SEXP lp, SEXP i, SEXP stat);
+
+/* set column status */
+SEXP setColStat(SEXP lp, SEXP j, SEXP stat);
+
+/* construct standard initial LP basis */
+SEXP stdBasis(SEXP lp);
+
+/* construct advanced initial LP basis */
+SEXP advBasis(SEXP lp);
+
+/* construct Bixby's initial LP basis */
+SEXP cpxBasis(SEXP lp);
+
+/* "warm up" LP basis */
+SEXP warmUp(SEXP lp);
+
+/* enable/disable terminal output */
+SEXP termOut(SEXP flag);
+
+/* solve problem with simplex algorithm */
+SEXP solveSimplex(SEXP lp);
+
+/* solve problem with exact simplex algorithm */
+SEXP solveSimplexExact(SEXP lp);
+
+/* get value of the objective function after simplex */
+SEXP getObjVal(SEXP lp);
+
+/* get solution status after simplex */
+SEXP getSolStat(SEXP lp);
+
+/* get column primal value (flux distribution) for all columns */
+SEXP getColsPrim(SEXP lp);
+
+/* get column primal value (flux distribution) for one column */
+SEXP getColPrim(SEXP lp, SEXP j);
+
+/* retrieve status of primal basic solution */
+SEXP getPrimStat(SEXP lp);
+
+/* retrieve status of dual basic solution */
+SEXP getDualStat(SEXP lp);
+
+/* retrieve row status */
+SEXP getRowStat(SEXP lp, SEXP i);
+
+/* retrieve row status for all rows */
+SEXP getRowsStat(SEXP lp);
+
+/* retrieve row primal value */
+SEXP getRowPrim(SEXP lp, SEXP i);
+
+/* retrieve row primal value for all rows */
+SEXP getRowsPrim(SEXP lp);
+
+/* retrieve row dual value */
+SEXP getRowDual(SEXP lp, SEXP i);
+
+/* retrieve row dual value for all rows */
+SEXP getRowsDual(SEXP lp);
+
+/* retrieve column status */
+SEXP getColStat(SEXP lp, SEXP j);
+
+/* retrieve column status for all columns */
+SEXP getColsStat(SEXP lp);
+
+/* retrieve column dual value */
+SEXP getColDual(SEXP lp, SEXP j);
+
+/* retrieve column dual value for all columns */
+SEXP getColsDual(SEXP lp);
+
+/* determine variable causing unboundedness */
+SEXP getUnbndRay(SEXP lp);
+
+/* solve problem with interior point method */
+SEXP solveInterior(SEXP lp);
+
+/* get value of the objective function after interior point method */
+SEXP getObjValIpt(SEXP lp);
+
+/* get solution status after interior point method */
+SEXP getSolStatIpt(SEXP lp);
+
+/* get column primal value (flux distribution) for all columns (interior) */
+SEXP getColsPrimIpt(SEXP lp);
+
+/* get column primal value (flux distribution) for one column (interior) */
+SEXP getColPrimIpt(SEXP lp, SEXP j);
+
+/* retrieve row primal value (interior) */
+SEXP getRowPrimIpt(SEXP lp, SEXP i);
+
+/* retrieve row primal value (interior) for all rows (interior) */
+SEXP getRowsPrimIpt(SEXP lp);
+
+/* retrieve row dual value (interior) */
+SEXP getRowDualIpt(SEXP lp, SEXP i);
+
+/* retrieve row dual value (interior) for all rows (interior) */
+SEXP getRowsDualIpt(SEXP lp);
+
+/* retrieve column dual value (interior) */
+SEXP getColDualIpt(SEXP lp, SEXP j);
+
+/* retrieve column dual value (interior) for all columns (interior) */
+SEXP getColsDualIpt(SEXP lp);
+
+/* solve MIP problem with the branch-and-cut method */
+SEXP solveMIP(SEXP lp);
+
+/* determine status of MIP solution */
+SEXP mipStatus(SEXP lp);
+
+/* retrieve objective value */
+SEXP mipObjVal(SEXP lp);
+
+/* retrieve row value (MIP) */
+SEXP mipRowVal(SEXP lp, SEXP i);
+
+/* retrieve row value for all rows (MIP) */
+SEXP mipRowsVal(SEXP lp);
+
+/* retrieve column value (MIP) */
+SEXP mipColVal(SEXP lp, SEXP j);
+
+/* retrieve column value for all columns (MIP) */
+SEXP mipColsVal(SEXP lp);
+
+/* get the number of constraint coefficients (number of non-zero elements in
+   the consrtaint matrix) */
+SEXP getNumNnz(SEXP lp);
+
+/* get row i of the contraint matrix */
+SEXP getMatRow(SEXP lp, SEXP i);
+
+/* set row i of the contraint matrix */
+SEXP setMatRow(SEXP lp, SEXP i, SEXP len, SEXP ind, SEXP val);
+
+/* get column j of the contraint matrix */
+SEXP getMatCol(SEXP lp, SEXP j);
+
+/* set column j of the contraint matrix */
+SEXP setMatCol(SEXP lp, SEXP j, SEXP len, SEXP ind, SEXP val);
+
+/* read problem data in MPS format */
+SEXP readMPS(SEXP lp, SEXP fmt, SEXP fname);
+
+/* read problem data in CPLEX LP format */
+SEXP readLP(SEXP lp, SEXP fname);
+
+/* read problem data in GLPK format */
+SEXP readProb(SEXP lp, SEXP fname);
+
+/* write problem data in MPS format */
+SEXP writeMPS(SEXP lp, SEXP fmt, SEXP fname);
+
+/* write problem data in CPLEX LP format */
+SEXP writeLP(SEXP lp, SEXP fname);
+
+/* write problem data in GLPK format */
+SEXP writeProb(SEXP lp, SEXP fname);
+
+/* write basic solution in printable format */
+SEXP printSol(SEXP lp, SEXP fname);
+
+/* read basic solution from text file */
+SEXP readSol(SEXP lp, SEXP fname);
+
+/* write basic solution to text file */
+SEXP writeSol(SEXP lp, SEXP fname);
+
+/* write interior-point solution in printable format */
+SEXP printIpt(SEXP lp, SEXP fname);
+
+/* read interior-point solution from text file */
+SEXP readIpt(SEXP lp, SEXP fname);
+
+/* write interior-point solution to text file */
+SEXP writeIpt(SEXP lp, SEXP fname);
+
+/* write MIP solution in printable format */
+SEXP printMIP(SEXP lp, SEXP fname);
+
+/* read MIP solution from text file */
+SEXP readMIP(SEXP lp, SEXP fname);
+
+/* write MIP solution to text file */
+SEXP writeMIP(SEXP lp, SEXP fname);
+
+/* determine library version */
+SEXP version();
+
+/* check if the basis factorization exists */
+SEXP bfExists(SEXP lp);
+
+/* compute the basis factorization */
+SEXP factorize(SEXP lp);
+
+/* check if the basis factorization has been updated */
+SEXP bfUpdated(SEXP lp);
+
+/* change basis factorization control parameters */
+SEXP setBfcp(SEXP lp, SEXP npari, SEXP pari, SEXP vali,
+                      SEXP npard, SEXP pard, SEXP vald);
+
+/* get basis factorization control parameters */
+SEXP getBfcp(SEXP lp);
+
+/* retrieve basis header information */
+SEXP getBhead(SEXP lp, SEXP k);
+
+/* retrieve row index in the basis header */
+SEXP getRbind(SEXP lp, SEXP i);
+
+/* retrieve column index in the basis header */
+SEXP getCbind(SEXP lp, SEXP j);
+
+/* print sensitivity analysis report */
+SEXP printRanges(SEXP lp, SEXP numrc, SEXP rowcol, SEXP fname);
+
+/* allocate translator workspace */
+SEXP mplAllocWksp();
+
+/* free translator workspace */
+SEXP mplFreeWksp(SEXP wksp);
+
+/* read and translate model section */
+SEXP mplReadModel(SEXP wk, SEXP fname, SEXP skip);
+
+/* read and translate data section */
+SEXP mplReadData(SEXP wk, SEXP fname);
+
+/* generate the model */
+SEXP mplGenerate(SEXP wk, SEXP fname);
+
+/* build problem instance from model */
+SEXP mplBuildProb(SEXP wk, SEXP lp);
+
+/* postsolve model */
+SEXP mplPostsolve(SEXP wk, SEXP lp, SEXP sol);
+
diff --git a/src/glpkCallback.c b/src/glpkCallback.c
new file mode 100644
index 0000000000000000000000000000000000000000..1c0f4b936b3129bb9f3c1603c78c5e238222b8ea
--- /dev/null
+++ b/src/glpkCallback.c
@@ -0,0 +1,74 @@
+/* glpkCallback.c
+   R interface to GLPK.
+ 
+   Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+   Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+   All right reserved.
+   Email: geliudie@uni-duesseldorf.de
+ 
+   This file is part of glpkAPI.
+ 
+   GlpkAPI is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+ 
+   GlpkAPI is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with glpkAPI.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "glpkR.h"
+
+/* for the user callback routine */
+/*
+struct cbInfo {
+    int b;
+};
+cbInfo.b = 42;
+*/
+
+/* this is from the GLPK manual, fit according to your needs */
+void glpkCallback(glp_tree *tree, void *info) {
+    switch (glp_ios_reason(tree)) { 
+
+        /* Rprintf("transit pointer: %i", info.b); */
+
+        case GLP_ISELECT:
+            Rprintf("request for subproblem selection\n");
+        break;
+
+        case GLP_IPREPRO:
+            Rprintf("request for preprocessing\n");
+        break;
+
+        case GLP_IROWGEN:
+            Rprintf("request for row generation\n");
+        break;
+
+        case GLP_IHEUR:
+            Rprintf("request for heuristic solution\n");
+        break;
+
+        case GLP_ICUTGEN:
+            Rprintf("request for cut generation\n");
+        break;
+
+        case GLP_IBRANCH:
+            Rprintf("request for branching\n");
+        break;
+
+        case GLP_IBINGO:
+            Rprintf("better integer solution found\n");
+        break;
+
+        default:
+        /* ignore call for other reasons */
+        break;
+    }
+    return;
+}
diff --git a/src/glpkCallback.h b/src/glpkCallback.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7f29318f7e15ea78eaa5226a1eb821ea76accc0
--- /dev/null
+++ b/src/glpkCallback.h
@@ -0,0 +1,25 @@
+/* glpkCallback.h
+   R interface to GLPK.
+ 
+   Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+   Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+   All right reserved.
+   Email: geliudie@uni-duesseldorf.de
+ 
+   This file is part of glpkAPI.
+ 
+   GlpkAPI is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+ 
+   GlpkAPI is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with glpkAPI.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+void glpkCallback(glp_tree *tree, void *info);
diff --git a/src/glpkR.h b/src/glpkR.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8265ff4458e94bc0181b81cdf3bb65da39f65f6
--- /dev/null
+++ b/src/glpkR.h
@@ -0,0 +1,226 @@
+/* glpkR.h
+   R interface to GLPK.
+ 
+   Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+   Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+   All right reserved.
+   Email: geliudie@uni-duesseldorf.de
+ 
+   This file is part of glpkAPI.
+ 
+   GlpkAPI is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+ 
+   GlpkAPI is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with glpkAPI.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <stdlib.h>
+#include <glpk.h>
+
+
+/* avoid remapping of Rf_<function> to <function> in R header files */
+#ifndef R_NO_REMAP
+#define R_NO_REMAP
+#endif /* R_NO_REMAP */
+
+/* use strict R headers */
+#ifndef STRICT_R_HEADERS
+#define STRICT_R_HEADERS
+#endif /* STRICT_R_HEADERS */
+
+#include <R.h>
+#include <Rinternals.h>
+#include <Rversion.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+
+/* -------------------------------------------------------------------------- */
+/* check arguments to GLPK */
+#ifdef CHECK_GLPK_ARGS
+#define checkRowIndex(p, r) do { \
+    if ( (Rf_asInteger(r) > glp_get_num_rows(R_ExternalPtrAddr(p))) || \
+         (Rf_asInteger(r) < 1) ) \
+        Rf_error("Row index '%i' is out of range!", Rf_asInteger(r)); \
+} while (0)
+#define checkColIndex(p, c) do { \
+    if ( (Rf_asInteger(c) > glp_get_num_cols(R_ExternalPtrAddr(p))) || \
+         (Rf_asInteger(c) < 1) ) \
+        Rf_error("Column index '%i' is out of range!", Rf_asInteger(c)); \
+} while (0)
+#define checkVarType(v) do { \
+    if ( (Rf_asInteger(v) > GLP_FX) || (Rf_asInteger(v) < GLP_FR) ) \
+        Rf_error("Invalid variable type '%i'!", Rf_asInteger(v)); \
+} while (0)
+#define checkVarKind(v) do { \
+    int rv = Rf_asInteger(v); \
+    if ( (rv != GLP_CV) && (rv != GLP_IV) && (rv != GLP_BV) ) \
+        Rf_error("Invalid variable kind '%i'!", Rf_asInteger(v)); \
+} while (0)
+#define checkVarStat(v) do { \
+    int rv = Rf_asInteger(v); \
+    if ( (rv != GLP_BS) && (rv != GLP_NL) && (rv != GLP_NU)  && (rv != GLP_NF) && (rv != GLP_NS) ) \
+        Rf_error("Invalid variable status '%i'!", Rf_asInteger(v)); \
+} while (0)
+#define checkSolType(v) do { \
+    int rv = Rf_asInteger(v); \
+    if ( (rv != GLP_SOL) && (rv != GLP_IPT) && (rv != GLP_MIP) ) \
+        Rf_error("Invalid variable status '%i'!", Rf_asInteger(v)); \
+} while (0)
+#define checkScaling(v) do { \
+    int rv = Rf_asInteger(v); \
+    if ( (rv != GLP_SF_GM) && (rv != GLP_SF_EQ) && (rv != GLP_SF_2N) && (rv != GLP_SF_SKIP) && (rv != GLP_SF_AUTO) ) \
+        Rf_error("Invalid scaling option '%i'!", Rf_asInteger(v)); \
+} while (0)
+#define checkVarTypes(v) do { \
+    int y = 0; \
+    const int *rv; \
+    if (TYPEOF(v) == INTSXP) { \
+        rv = INTEGER(v); \
+        while (y < Rf_length(v)) { \
+            if ( ((rv[y]) > GLP_FX) || ((rv[y]) < GLP_FR) ) { \
+                Rf_error("Variable type 'type[%i] = %i' is invalid!", (y+1), rv[y]); \
+            } \
+            y++; \
+        } \
+    } \
+} while (0)
+#define checkVarKinds(v) do { \
+    int y = 0; \
+    const int *rv; \
+    if (TYPEOF(v) == INTSXP) { \
+        rv = INTEGER(v); \
+        while (y < Rf_length(v)) { \
+            if ( ((rv[y]) != GLP_CV) && ((rv[y]) != GLP_IV) && ((rv[y]) != GLP_BV) ) { \
+                Rf_error("Variable kind 'kind[%i] = %i' is invalid!", (y+1), rv[y]); \
+            } \
+            y++; \
+        } \
+    } \
+} while (0)
+#define checkRowIndices(p, r, s) do { \
+    int y = s ? 1 : 0; \
+    int nr = glp_get_num_rows(R_ExternalPtrAddr(p)); \
+    const int *rr = INTEGER(r); \
+    while (y < Rf_length(r)) { \
+        if ( ((rr[y]) > nr) || ((rr[y]) < 1) ) { \
+            Rf_error("Row index 'i[%i] = %i' is out of range!", s ? y : (y+1), rr[y]); \
+        } \
+        y++; \
+    } \
+} while (0)
+#define checkColIndices(p, c, s) do { \
+    int y = s ? 1 : 0; \
+    int nc = glp_get_num_cols(R_ExternalPtrAddr(p)); \
+    const int *rc = INTEGER(c); \
+    while (y < Rf_length(c)) { \
+        if ( ((rc[y]) > nc) || ((rc[y]) < 1) ) { \
+            Rf_error("Column index 'j[%i] = %i' is out of range!", s ? y : (y+1), rc[y]); \
+        } \
+        y++; \
+    } \
+} while (0)
+#define checkVecLen(l, v) do { \
+    if ( Rf_length(v) != Rf_asInteger(l) ) { \
+        Rf_error("Vector does not have length %i!", Rf_asInteger(l)); \
+    } \
+} while (0)
+#if defined(R_VERSION) && R_VERSION >= R_Version(3, 0, 0)
+#define checkDupIndices(m, n, ne) do { \
+    int *oind; \
+    int dupA = 0; \
+    int dupB = 0; \
+    int y = 1; \
+    const int *rm = INTEGER(m); \
+    const int *rn = INTEGER(n); \
+    oind = R_Calloc(Rf_asInteger(ne), int); \
+    R_orderVector(oind, Rf_asInteger(ne), Rf_lang2(m, n), TRUE, FALSE); \
+    while (y < Rf_asInteger(ne)) { \
+        if ( (rm[oind[y-1]] == rm[oind[y]]) && (rn[oind[y-1]] == rn[oind[y]]) ) { \
+            dupA = oind[y-1]; \
+            dupB = oind[y]; \
+            break; \
+        } \
+        y++; \
+    } \
+    R_Free(oind); \
+    if (dupB) { \
+        Rf_error("Duplicate indices 'ia[%i] = ia[%i] = %i' and 'ja[%i] = ja[%i] = %i' not allowed!", dupA+1, dupB+1, rm[dupA], dupA+1, dupB+1, rn[dupB]); \
+    } \
+} while (0)
+#else
+#define checkDupIndices(m, n, ne)
+#endif
+#else
+#define checkRowIndex(p, r)
+#define checkColIndex(p, c)
+#define checkVarType(v)
+#define checkVarKind(v)
+#define checkVarStat(v)
+#define checkSolType(v)
+#define checkScaling(v)
+#define checkVarTypes(v)
+#define checkVarKinds(v)
+#define checkRowIndices(p, r)
+#define checkColIndices(p, c)
+#define checkVecLen(l, v)
+#define checkDupIndices(m, n, ne)
+#endif
+
+
+/* -------------------------------------------------------------------------- */
+/* NULL */
+#define checkIfNil(cp) do { \
+    if (R_ExternalPtrAddr(cp) == NULL) \
+        Rf_error("You passed a nil value!"); \
+} while (0)
+
+
+/* -------------------------------------------------------------------------- */
+/* problem */
+#define checkTypeOfProb(cp) do { \
+    if ( (TYPEOF(cp) != EXTPTRSXP) || (R_ExternalPtrTag(cp) != tagGLPKprob) ) \
+        Rf_error("You must pass a glpk problem structure!"); \
+} while (0)
+
+#define checkProb(p) do { \
+    checkIfNil(p); \
+    checkTypeOfProb(p); \
+} while (0)
+
+
+/* -------------------------------------------------------------------------- */
+/* parameters */
+#define checkTypeOfParm(pa) do { \
+    if ( (TYPEOF(pa) != EXTPTRSXP) || (R_ExternalPtrTag(pa) != tagGLPKparm) ) \
+        Rf_error("You must pass a pointer to an glpk parameter structure!"); \
+} while (0)
+
+#define checkParm(p) do { \
+    checkIfNil(p); \
+    checkTypeOfParm(p); \
+} while (0)
+
+
+/* -------------------------------------------------------------------------- */
+/* MathProg */
+#define checkTypeOfMathProg(mp) do { \
+    if ( (TYPEOF(mp) != EXTPTRSXP) || (R_ExternalPtrTag(mp) != tagMATHprog) ) \
+        Rf_error("You must pass a pointer to an MathProg translator workspace!"); \
+} while (0)
+
+#define checkMathProg(p) do { \
+    checkIfNil(p); \
+    checkTypeOfMathProg(p); \
+} while (0)
diff --git a/src/init.c b/src/init.c
new file mode 100644
index 0000000000000000000000000000000000000000..c712595fd0a11e7fdb06df4f6a87164ad83ab35e
--- /dev/null
+++ b/src/init.c
@@ -0,0 +1,196 @@
+/* init.c
+   R interface to GLPK.
+ 
+   Copyright (C) 2011-2014 Gabriel Gelius-Dietrich, Dpt. for Bioinformatics,
+   Institute for Informatics, Heinrich-Heine-University, Duesseldorf, Germany.
+   All right reserved.
+   Email: geliudie@uni-duesseldorf.de
+ 
+   This file is part of glpkAPI.
+ 
+   GlpkAPI is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+ 
+   GlpkAPI is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+ 
+   You should have received a copy of the GNU General Public License
+   along with glpkAPI.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <R.h>
+#include <Rinternals.h>
+
+#include "glpkAPI.h"
+
+#include <R_ext/Rdynload.h>
+
+static const R_CallMethodDef callMethods[] = {
+    {"isGLPKptr",           (DL_FUNC) &isGLPKptr,           1},
+    {"isTRWKSptr",          (DL_FUNC) &isTRWKSptr,          1},
+    {"isNULLptr",           (DL_FUNC) &isNULLptr,           1},
+    {"initGLPK",            (DL_FUNC) &initGLPK,            0},
+    {"delProb",             (DL_FUNC) &delProb,             1},
+    {"eraseProb",           (DL_FUNC) &eraseProb,           1},
+    {"copyProb",            (DL_FUNC) &copyProb,            3},
+    {"initProb",            (DL_FUNC) &initProb,            1},
+    {"setProbName",         (DL_FUNC) &setProbName,         2},
+    {"getProbName",         (DL_FUNC) &getProbName,         1},
+    {"setObjName",          (DL_FUNC) &setObjName,          2},
+    {"getObjName",          (DL_FUNC) &getObjName,          1},
+    {"createIndex",         (DL_FUNC) &createIndex,         1},
+    {"deleteIndex",         (DL_FUNC) &deleteIndex,         1},
+    {"setDefaultSmpParm",   (DL_FUNC) &setDefaultSmpParm,   0},
+    {"setDefaultIptParm",   (DL_FUNC) &setDefaultIptParm,   0},
+    {"setDefaultMIPParm",   (DL_FUNC) &setDefaultMIPParm,   0},
+    {"setSimplexParm",      (DL_FUNC) &setSimplexParm,      6},
+    {"setInteriorParm",     (DL_FUNC) &setInteriorParm,     3},
+    {"setMIPParm",          (DL_FUNC) &setMIPParm,          6},
+    {"getSimplexParm",      (DL_FUNC) &getSimplexParm,      0},
+    {"getInteriorParm",     (DL_FUNC) &getInteriorParm,     0},
+    {"getMIPParm",          (DL_FUNC) &getMIPParm,          0},
+    {"setObjDir",           (DL_FUNC) &setObjDir,           2},
+    {"getObjDir",           (DL_FUNC) &getObjDir,           1},
+    {"addRows",             (DL_FUNC) &addRows,             2},
+    {"setRowName",          (DL_FUNC) &setRowName,          3},
+    {"setRowsNames",        (DL_FUNC) &setRowsNames,        3},
+    {"getRowName",          (DL_FUNC) &getRowName,          2},
+    {"findRow",             (DL_FUNC) &findRow,             2},
+    {"addCols",             (DL_FUNC) &addCols,             2},
+    {"setColName",          (DL_FUNC) &setColName,          3},
+    {"setColsNames",        (DL_FUNC) &setColsNames,        3},
+    {"getColName",          (DL_FUNC) &getColName,          2},
+    {"findCol",             (DL_FUNC) &findCol,             2},
+    {"getNumRows",          (DL_FUNC) &getNumRows,          1},
+    {"getNumCols",          (DL_FUNC) &getNumCols,          1},
+    {"setColsBnds",         (DL_FUNC) &setColsBnds,         5},
+    {"setColsBndsObjCoefs", (DL_FUNC) &setColsBndsObjCoefs, 6},
+    {"setColBnd",           (DL_FUNC) &setColBnd,           5},
+    {"getColsLowBnds",      (DL_FUNC) &getColsLowBnds,      2},
+    {"getColLowBnd",        (DL_FUNC) &getColLowBnd,        2},
+    {"getColsUppBnds",      (DL_FUNC) &getColsUppBnds,      2},
+    {"getColUppBnd",        (DL_FUNC) &getColUppBnd,        2},
+    {"setColKind",          (DL_FUNC) &setColKind,          3},
+    {"setColsKind",         (DL_FUNC) &setColsKind,         3},
+    {"getColKind",          (DL_FUNC) &getColKind,          2},
+    {"getColsKind",         (DL_FUNC) &getColsKind,         2},
+    {"getNumInt",           (DL_FUNC) &getNumInt,           1},
+    {"getNumBin",           (DL_FUNC) &getNumBin,           1},
+    {"setRowsBnds",         (DL_FUNC) &setRowsBnds,         5},
+    {"setRhsZero",          (DL_FUNC) &setRhsZero,          1},
+    {"setRowBnd",           (DL_FUNC) &setRowBnd,           5},
+    {"getRowsLowBnds",      (DL_FUNC) &getRowsLowBnds,      2},
+    {"getRowLowBnd",        (DL_FUNC) &getRowLowBnd,        2},
+    {"getRowsUppBnds",      (DL_FUNC) &getRowsUppBnds,      2},
+    {"getRowUppBnd",        (DL_FUNC) &getRowUppBnd,        2},
+    {"getRowType",          (DL_FUNC) &getRowType,          2},
+    {"getRowsTypes",        (DL_FUNC) &getRowsTypes,        2},
+    {"getColType",          (DL_FUNC) &getColType,          2},
+    {"setObjCoefs",         (DL_FUNC) &setObjCoefs,         3},
+    {"setObjCoef",          (DL_FUNC) &setObjCoef,          3},
+    {"getObjCoefs",         (DL_FUNC) &getObjCoefs,         2},
+    {"getObjCoef",          (DL_FUNC) &getObjCoef,          2},
+    {"loadMatrix",          (DL_FUNC) &loadMatrix,          5},
+    {"checkDup",            (DL_FUNC) &checkDup,            5},
+    {"sortMatrix",          (DL_FUNC) &sortMatrix,          1},
+    {"delRows",             (DL_FUNC) &delRows,             3},
+    {"delCols",             (DL_FUNC) &delCols,             3},
+    {"setRii",              (DL_FUNC) &setRii,              3},
+    {"setSjj",              (DL_FUNC) &setSjj,              3},
+    {"getRii",              (DL_FUNC) &getRii,              2},
+    {"getSjj",              (DL_FUNC) &getSjj,              2},
+    {"scaleProb",           (DL_FUNC) &scaleProb,           2},
+    {"unscaleProb",         (DL_FUNC) &unscaleProb,         1},
+    {"setRowStat",          (DL_FUNC) &setRowStat,          3},
+    {"setColStat",          (DL_FUNC) &setColStat,          3},
+    {"stdBasis",            (DL_FUNC) &stdBasis,            1},
+    {"advBasis",            (DL_FUNC) &advBasis,            1},
+    {"cpxBasis",            (DL_FUNC) &cpxBasis,            1},
+    {"warmUp",              (DL_FUNC) &warmUp,              1},
+    {"termOut",             (DL_FUNC) &termOut,             1},
+    {"solveSimplex",        (DL_FUNC) &solveSimplex,        1},
+    {"solveSimplexExact",   (DL_FUNC) &solveSimplexExact,   1},
+    {"getObjVal",           (DL_FUNC) &getObjVal,           1},
+    {"getSolStat",          (DL_FUNC) &getSolStat,          1},
+    {"getColsPrim",         (DL_FUNC) &getColsPrim,         1},
+    {"getColPrim",          (DL_FUNC) &getColPrim,          2},
+    {"getPrimStat",         (DL_FUNC) &getPrimStat,         1},
+    {"getDualStat",         (DL_FUNC) &getDualStat,         1},
+    {"getRowStat",          (DL_FUNC) &getRowStat,          2},
+    {"getRowsStat",         (DL_FUNC) &getRowsStat,         1},
+    {"getRowPrim",          (DL_FUNC) &getRowPrim,          2},
+    {"getRowsPrim",         (DL_FUNC) &getRowsPrim,         1},
+    {"getRowDual",          (DL_FUNC) &getRowDual,          2},
+    {"getRowsDual",         (DL_FUNC) &getRowsDual,         1},
+    {"getColStat",          (DL_FUNC) &getColStat,          2},
+    {"getColsStat",         (DL_FUNC) &getColsStat,         1},
+    {"getColDual",          (DL_FUNC) &getColDual,          2},
+    {"getColsDual",         (DL_FUNC) &getColsDual,         1},
+    {"getUnbndRay",         (DL_FUNC) &getUnbndRay,         1},
+    {"solveInterior",       (DL_FUNC) &solveInterior,       1},
+    {"getObjValIpt",        (DL_FUNC) &getObjValIpt,        1},
+    {"getSolStatIpt",       (DL_FUNC) &getSolStatIpt,       1},
+    {"getColsPrimIpt",      (DL_FUNC) &getColsPrimIpt,      1},
+    {"getColPrimIpt",       (DL_FUNC) &getColPrimIpt,       2},
+    {"getRowPrimIpt",       (DL_FUNC) &getRowPrimIpt,       2},
+    {"getRowsPrimIpt",      (DL_FUNC) &getRowsPrimIpt,      1},
+    {"getRowDualIpt",       (DL_FUNC) &getRowDualIpt,       2},
+    {"getRowsDualIpt",      (DL_FUNC) &getRowsDualIpt,      1},
+    {"getColDualIpt",       (DL_FUNC) &getColDualIpt,       2},
+    {"getColsDualIpt",      (DL_FUNC) &getColsDualIpt,      1},
+    {"solveMIP",            (DL_FUNC) &solveMIP,            1},
+    {"mipStatus",           (DL_FUNC) &mipStatus,           1},
+    {"mipObjVal",           (DL_FUNC) &mipObjVal,           1},
+    {"mipRowVal",           (DL_FUNC) &mipRowVal,           2},
+    {"mipRowsVal",          (DL_FUNC) &mipRowsVal,          1},
+    {"mipColVal",           (DL_FUNC) &mipColVal,           2},
+    {"mipColsVal",          (DL_FUNC) &mipColsVal,          1},
+    {"getNumNnz",           (DL_FUNC) &getNumNnz,           1},
+    {"getMatRow",           (DL_FUNC) &getMatRow,           2},
+    {"setMatRow",           (DL_FUNC) &setMatRow,           5},
+    {"getMatCol",           (DL_FUNC) &getMatCol,           2},
+    {"setMatCol",           (DL_FUNC) &setMatCol,           5},
+    {"readMPS",             (DL_FUNC) &readMPS,             3},
+    {"readLP",              (DL_FUNC) &readLP,              2},
+    {"readProb",            (DL_FUNC) &readProb,            2},
+    {"writeMPS",            (DL_FUNC) &writeMPS,            3},
+    {"writeLP",             (DL_FUNC) &writeLP,             2},
+    {"writeProb",           (DL_FUNC) &writeProb,           2},
+    {"printSol",            (DL_FUNC) &printSol,            2},
+    {"readSol",             (DL_FUNC) &readSol,             2},
+    {"writeSol",            (DL_FUNC) &writeSol,            2},
+    {"printIpt",            (DL_FUNC) &printIpt,            2},
+    {"readIpt",             (DL_FUNC) &readIpt,             2},
+    {"writeIpt",            (DL_FUNC) &writeIpt,            2},
+    {"printMIP",            (DL_FUNC) &printMIP,            2},
+    {"readMIP",             (DL_FUNC) &readMIP,             2},
+    {"writeMIP",            (DL_FUNC) &writeMIP,            2},
+    {"version",             (DL_FUNC) &version,             0},
+    {"bfExists",            (DL_FUNC) &bfExists,            1},
+    {"factorize",           (DL_FUNC) &factorize,           1},
+    {"bfUpdated",           (DL_FUNC) &bfUpdated,           1},
+    {"setBfcp",             (DL_FUNC) &setBfcp,             7},
+    {"getBfcp",             (DL_FUNC) &getBfcp,             1},
+    {"getBhead",            (DL_FUNC) &getBhead,            2},
+    {"getRbind",            (DL_FUNC) &getRbind,            2},
+    {"getCbind",            (DL_FUNC) &getCbind,            2},
+    {"printRanges",         (DL_FUNC) &printRanges,         4},
+    {"mplAllocWksp",        (DL_FUNC) &mplAllocWksp,        1},
+    {"mplFreeWksp",         (DL_FUNC) &mplFreeWksp,         1},
+    {"mplReadModel",        (DL_FUNC) &mplReadModel,        3},
+    {"mplReadData",         (DL_FUNC) &mplReadData,         2},
+    {"mplGenerate",         (DL_FUNC) &mplGenerate,         2},
+    {"mplBuildProb",        (DL_FUNC) &mplBuildProb,        2},
+    {"mplPostsolve",        (DL_FUNC) &mplPostsolve,        3},
+    {NULL, NULL, 0}
+};
+
+
+void R_init_glpkAPI(DllInfo *info) {
+    R_registerRoutines(info, NULL, callMethods, NULL, NULL);
+    R_useDynamicSymbols(info, FALSE);
+}
diff --git a/vignettes/glpkAPI.Rnw b/vignettes/glpkAPI.Rnw
new file mode 100644
index 0000000000000000000000000000000000000000..0d3dc4f323353d2cf1a12ad0669e9c9d9aeecac5
--- /dev/null
+++ b/vignettes/glpkAPI.Rnw
@@ -0,0 +1,296 @@
+\documentclass[a4paper,headings=small]{scrartcl}
+\usepackage[english]{babel}
+\usepackage[T1]{fontenc}
+\usepackage[latin1]{inputenc}
+\usepackage{textcomp,lmodern}
+\typearea[current]{last}
+\usepackage{fixltx2e,mparhack,mathdots}
+
+\usepackage{natbib}
+\usepackage{hyperref}
+\bibliographystyle{abbrvnat}
+
+\usepackage{microtype}
+
+\newcommand{\Comp}[1]{\texttt{#1}}
+
+\usepackage{dblfnote}
+\deffootnote[1.5em]{1.5em}{1em}{%
+    \makebox[1.5em][l]{\scriptsize{\thefootnotemark}}%
+}
+
+\addtolength{\skip\footins}{0.5\baselineskip}
+
+\usepackage{fnpos}
+
+
+\hypersetup{
+	pdftitle = {glpkAPI -- Quick Start},
+	pdfauthor = {Gabriel Gelius-Dietrich},
+	pdfsubject = {R Interface to C API of GLPK},
+	pdfkeywords = {Optimization, GLPK},
+    pdfborder = {0 0 0},
+    pdfhighlight = {/N}
+}
+
+
+\newcommand{\pkg}[1]{\emph{#1}}
+\newcommand{\pkgname}{\pkg{glpkAPI}}
+\newcommand{\prgname}[1]{\textsc{#1}}
+
+
+\begin{document}
+\title{glpkAPI -- Quick Start}
+%\VignetteIndexEntry{Package glpkAPI -- Quick Start}
+\author{Gabriel Gelius-Dietrich}
+
+\maketitle
+
+\section{Introduction}
+The package \pkgname{} provides a low level interface to the C~API of
+\prgname{GLPK}\footnote{Andrew Makhorin: GNU Linear Programming Kit,
+Version~4.42 (or higher) \url{http://www.gnu.org/software/glpk/glpk.html}},
+the GNU Linear Programming Kit.
+It is similar in purpose to the package \pkg{glpk}\footnote{Maintained by
+Lopaka Lee, available on \textsc{CRAN}
+\url{http://cran.r-project.org/package=glpk}}, but
+\pkgname{} relies on a separate installation of \prgname{GLPK}.
+
+\section{Installation}
+The package \pkgname{} depends on a working installation of \prgname{GLPK}
+(in particular libraries and header files).
+It is recommended to link \prgname{GLPK} to the GNU Multiple Precision
+Arithmetic Library Library (\prgname{GMP})\footnote{\url{http://gmplib.org/}} in
+order to gain more performance when using the exact simplex algorithm.
+See \Comp{INSTALL} for installation instructions and platform specific details.
+\textsc{CRAN}\footnote{\url{http://cran.r-project.org/}} provides binary
+versions of \pkgname{} for Windows and MacOS X, no other software is required
+here.
+
+\section{Usage}
+
+\subsection{Creating and solving a linear optimization problem}
+
+In the following, an example lp-problem will be created and solved. It is the
+same lp-problem which is used in the \prgname{GLPK} manual:
+
+\noindent
+\hspace{.5in} maximize
+\[
+z = 10 x_1 + 6 x_2 + 4 x_3
+\]
+\hspace{.5in} subject to
+\[
+\begin{array}{r@{\:}c@{\:}r@{\:}c@{\:}r@{\:}c@{\:}r}
+   x_1 &+&   x_2 &+&   x_3 & \leq 100 \\
+10 x_1 &+& 4 x_2 &+& 5 x_3 & \leq 600 \\
+ 2 x_1 &+& 2 x_2 &+& 6 x_3 & \leq 300 \\
+\end{array}
+\]
+With all variables being non-negative.
+
+\newpage
+\noindent
+Load the library.
+<<>>=
+library(glpkAPI)
+@
+Create an empty problem object.
+<<>>=
+prob <- initProbGLPK()
+@
+Assign a name to the problem object.
+<<>>=
+setProbNameGLPK(prob, "sample")
+@
+Set the direction of optimization. The object \texttt{GLP\_MAX} is a predefined
+constant used by \prgname{GLPK}. A list of all available contants is written in
+the documentation \texttt{glpkConstants}.
+<<>>=
+setObjDirGLPK(prob, GLP_MAX)
+@
+Add three rows and three colunms to the problem object.
+<<>>=
+addRowsGLPK(prob, 3)
+addColsGLPK(prob, 3)
+@
+Set row and column names.
+<<>>=
+setRowNameGLPK(prob, 1, "p")
+setRowNameGLPK(prob, 2, "q")
+setRowNameGLPK(prob, 3, "r")
+setColNameGLPK(prob, 1, "x1")
+setColNameGLPK(prob, 2, "x2")
+setColNameGLPK(prob, 3, "x3")
+@
+Set the type and bounds of the rows.
+<<>>=
+setRowBndGLPK(prob, 1, GLP_UP, 0, 100)
+setRowBndGLPK(prob, 2, GLP_UP, 0, 600)
+setRowBndGLPK(prob, 3, GLP_UP, 0, 300)
+@
+Set the type and bounds of rows using a function which has the ability to work
+with vectors.
+<<>>=
+lb <- c(0, 0, 0)
+ub <- c(100, 600, 300)
+type <- rep(GLP_UP, 3)
+
+setRowsBndsGLPK(prob, 1:3, lb, ub, type)
+@
+Set the type and bounds of the columns.
+<<>>=
+setColBndGLPK(prob, 1, GLP_LO, 0, 0)
+setColBndGLPK(prob, 2, GLP_LO, 0, 0)
+setColBndGLPK(prob, 3, GLP_LO, 0, 0)
+@
+Set the objective function.
+<<>>=
+setObjCoefGLPK(prob, 1, 10)
+setObjCoefGLPK(prob, 2, 6)
+setObjCoefGLPK(prob, 3, 4)
+@
+Set the type and bounds of columns and the objective function using a function
+which has the ability to work with vectors.
+<<>>=
+lb <- c(0, 0, 0)
+ub <- lb
+type <- rep(GLP_LO, 3)
+obj <- c(10, 6, 4)
+
+setColsBndsObjCoefsGLPK(prob, 1:3, lb, ub, obj, type)
+@
+Load the constraint matrix.
+<<>>=
+ia <- c(1, 1, 1, 2, 3, 2, 3, 2, 3)
+ja <- c(1, 2, 3, 1, 1, 2, 2, 3, 3)
+ar <- c(1, 1, 1, 10, 2, 4, 2, 5, 6)
+
+loadMatrixGLPK(prob, 9, ia, ja, ar)
+@
+Solve the problem using the simplex algorithm.
+<<>>=
+solveSimplexGLPK(prob)
+@
+Retrieve the value of the objective function after optimization.
+<<>>=
+getObjValGLPK(prob)
+@
+Retrieve the values of the structural variables (columns) after optimization.
+<<>>=
+getColPrimGLPK(prob, 1)
+getColPrimGLPK(prob, 2)
+getColPrimGLPK(prob, 3)
+@
+Retrieve all primal values of the structural variables (columns) after
+optimization.
+<<>>=
+getColsPrimGLPK(prob)
+@
+Retrieve all dual values of the structural variables (columns) after
+optimization (reduced costs).
+<<>>=
+getColsDualGLPK(prob)
+@
+Print the solution to text file \texttt{sol.txt}.
+<<>>=
+printSolGLPK(prob, "sol.txt")
+@
+Write the problem to file \texttt{prob.lp} in lp format.
+<<>>=
+writeLPGLPK(prob, "prob.lp")
+@
+Read problem from file \texttt{prob.lp} in lp format.
+<<>>=
+lp <- initProbGLPK()
+readLPGLPK(lp, "prob.lp")
+@
+Free memory, allacated to the problem object.
+<<>>=
+delProbGLPK(prob)
+delProbGLPK(lp)
+@
+
+\subsection{Setting control prarmeters}
+All parameters and possible values are described in the documentation, see
+<<>>=
+help(glpkConstants)
+@
+for details. The control parameters used by \pkgname{} have the same names like
+those from \prgname{GLPK}, except that they are written in capital letters. For
+example, the parameter \texttt{tm\_lim} in \prgname{GLPK} is \texttt{TM\_LIM} in
+\pkgname. The prarmeters are stored in a structure available only once per
+\prgname{R}~session.
+Set the searching time limit to one second.
+<<>>=
+setSimplexParmGLPK(TM_LIM, 1000)
+@
+
+\section{Function names}
+
+\subsection{Searching}
+
+The function names in \pkgname{} are different from the names in \prgname{GLPK},
+e.\,g. the function \texttt{addColsGLPK} in \pkgname{} is called
+\texttt{glp\_add\_cols} in \prgname{GLPK}. The directory \texttt{inst/}
+containes a file \texttt{c2r.map} which maps a \prgname{GLPK} function name to
+the corresponding \pkgname{} function name. Additionally, all man-pages contain
+an alias to the \prgname{GLPK} function name. The call
+<<>>=
+help("glp_add_cols")
+@
+will bring up the man-page of \texttt{addColsGLPK}. Keep in mind that most of
+the \prgname{GLPK} functions do not work on vectors. For example the function
+\texttt{setColBndGLPK} (which is \texttt{glp\_set\_col\_bnds} in \prgname{GLPK})
+sets the upper and lower bounds for exactly one column. The function
+\texttt{setColsBndsGLPK} in \pkgname{} can handle a vector of column indices.
+
+Assume, we have a problem containing 1000 columns and 600 rows, with all
+variables having a lower bound of zero and an upper bound of 25. The problem
+will be created as follows.
+<<>>=
+prob <- initProbGLPK()
+addColsGLPK(prob, 1000)
+addRowsGLPK(prob, 600)
+@
+Now we can set the column bounds via \texttt{mapply} and \texttt{setColBndGLPK}.
+<<>>=
+system.time(
+   mapply(setColBndGLPK, j = 1:1000,
+   MoreArgs = list(lp = prob, type = GLP_DB, lb = 0, ub = 25))
+)
+@
+Or we use the simpler call to \texttt{setColsBndsGLPK}.
+<<>>=
+system.time(
+   setColsBndsGLPK(prob, j = 1:1000,
+                   type = rep(GLP_DB, 1000),
+                   lb = rep(0, 1000),
+                   ub = rep(0, 1000))
+)
+@
+The latter call is also much faster.
+
+
+\subsection{Mapping}
+
+The file \texttt{c2r.map} in \texttt{inst/} maps the \pkgname{} function names
+to the orininal \prgname{GLPK} function names of its C-API. To use the latter,
+run
+<<>>=
+c2r <- system.file(package = "glpkAPI", "c2r.map")
+source(c2r)
+@
+now either
+<<>>=
+pr1 <- initProbGLPK()
+delProbGLPK(pr1)
+@
+or the original functions
+<<>>=
+pr2 <- glp_create_prob()
+glp_delete_prob(pr2)
+@
+work both. Keep in mind that the mapping only affects the function names not the
+arguments of a function.
+\end{document}