# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.10
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_swiglpk')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_swiglpk')
    _swiglpk = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_swiglpk', [dirname(__file__)])
        except ImportError:
            import _swiglpk
            return _swiglpk
        if fp is not None:
            try:
                _mod = imp.load_module('_swiglpk', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _swiglpk = swig_import_helper()
    del swig_import_helper
else:
    import _swiglpk
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

GLP_MAJOR_VERSION = _swiglpk.GLP_MAJOR_VERSION
GLP_MINOR_VERSION = _swiglpk.GLP_MINOR_VERSION
GLP_MIN = _swiglpk.GLP_MIN
GLP_MAX = _swiglpk.GLP_MAX
GLP_CV = _swiglpk.GLP_CV
GLP_IV = _swiglpk.GLP_IV
GLP_BV = _swiglpk.GLP_BV
GLP_FR = _swiglpk.GLP_FR
GLP_LO = _swiglpk.GLP_LO
GLP_UP = _swiglpk.GLP_UP
GLP_DB = _swiglpk.GLP_DB
GLP_FX = _swiglpk.GLP_FX
GLP_BS = _swiglpk.GLP_BS
GLP_NL = _swiglpk.GLP_NL
GLP_NU = _swiglpk.GLP_NU
GLP_NF = _swiglpk.GLP_NF
GLP_NS = _swiglpk.GLP_NS
GLP_SF_GM = _swiglpk.GLP_SF_GM
GLP_SF_EQ = _swiglpk.GLP_SF_EQ
GLP_SF_2N = _swiglpk.GLP_SF_2N
GLP_SF_SKIP = _swiglpk.GLP_SF_SKIP
GLP_SF_AUTO = _swiglpk.GLP_SF_AUTO
GLP_SOL = _swiglpk.GLP_SOL
GLP_IPT = _swiglpk.GLP_IPT
GLP_MIP = _swiglpk.GLP_MIP
GLP_UNDEF = _swiglpk.GLP_UNDEF
GLP_FEAS = _swiglpk.GLP_FEAS
GLP_INFEAS = _swiglpk.GLP_INFEAS
GLP_NOFEAS = _swiglpk.GLP_NOFEAS
GLP_OPT = _swiglpk.GLP_OPT
GLP_UNBND = _swiglpk.GLP_UNBND
class glp_bfcp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_bfcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_bfcp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["msg_lev"] = _swiglpk.glp_bfcp_msg_lev_set
    __swig_getmethods__["msg_lev"] = _swiglpk.glp_bfcp_msg_lev_get
    if _newclass:
        msg_lev = _swig_property(_swiglpk.glp_bfcp_msg_lev_get, _swiglpk.glp_bfcp_msg_lev_set)
    __swig_setmethods__["type"] = _swiglpk.glp_bfcp_type_set
    __swig_getmethods__["type"] = _swiglpk.glp_bfcp_type_get
    if _newclass:
        type = _swig_property(_swiglpk.glp_bfcp_type_get, _swiglpk.glp_bfcp_type_set)
    __swig_setmethods__["lu_size"] = _swiglpk.glp_bfcp_lu_size_set
    __swig_getmethods__["lu_size"] = _swiglpk.glp_bfcp_lu_size_get
    if _newclass:
        lu_size = _swig_property(_swiglpk.glp_bfcp_lu_size_get, _swiglpk.glp_bfcp_lu_size_set)
    __swig_setmethods__["piv_tol"] = _swiglpk.glp_bfcp_piv_tol_set
    __swig_getmethods__["piv_tol"] = _swiglpk.glp_bfcp_piv_tol_get
    if _newclass:
        piv_tol = _swig_property(_swiglpk.glp_bfcp_piv_tol_get, _swiglpk.glp_bfcp_piv_tol_set)
    __swig_setmethods__["piv_lim"] = _swiglpk.glp_bfcp_piv_lim_set
    __swig_getmethods__["piv_lim"] = _swiglpk.glp_bfcp_piv_lim_get
    if _newclass:
        piv_lim = _swig_property(_swiglpk.glp_bfcp_piv_lim_get, _swiglpk.glp_bfcp_piv_lim_set)
    __swig_setmethods__["suhl"] = _swiglpk.glp_bfcp_suhl_set
    __swig_getmethods__["suhl"] = _swiglpk.glp_bfcp_suhl_get
    if _newclass:
        suhl = _swig_property(_swiglpk.glp_bfcp_suhl_get, _swiglpk.glp_bfcp_suhl_set)
    __swig_setmethods__["eps_tol"] = _swiglpk.glp_bfcp_eps_tol_set
    __swig_getmethods__["eps_tol"] = _swiglpk.glp_bfcp_eps_tol_get
    if _newclass:
        eps_tol = _swig_property(_swiglpk.glp_bfcp_eps_tol_get, _swiglpk.glp_bfcp_eps_tol_set)
    __swig_setmethods__["max_gro"] = _swiglpk.glp_bfcp_max_gro_set
    __swig_getmethods__["max_gro"] = _swiglpk.glp_bfcp_max_gro_get
    if _newclass:
        max_gro = _swig_property(_swiglpk.glp_bfcp_max_gro_get, _swiglpk.glp_bfcp_max_gro_set)
    __swig_setmethods__["nfs_max"] = _swiglpk.glp_bfcp_nfs_max_set
    __swig_getmethods__["nfs_max"] = _swiglpk.glp_bfcp_nfs_max_get
    if _newclass:
        nfs_max = _swig_property(_swiglpk.glp_bfcp_nfs_max_get, _swiglpk.glp_bfcp_nfs_max_set)
    __swig_setmethods__["upd_tol"] = _swiglpk.glp_bfcp_upd_tol_set
    __swig_getmethods__["upd_tol"] = _swiglpk.glp_bfcp_upd_tol_get
    if _newclass:
        upd_tol = _swig_property(_swiglpk.glp_bfcp_upd_tol_get, _swiglpk.glp_bfcp_upd_tol_set)
    __swig_setmethods__["nrs_max"] = _swiglpk.glp_bfcp_nrs_max_set
    __swig_getmethods__["nrs_max"] = _swiglpk.glp_bfcp_nrs_max_get
    if _newclass:
        nrs_max = _swig_property(_swiglpk.glp_bfcp_nrs_max_get, _swiglpk.glp_bfcp_nrs_max_set)
    __swig_setmethods__["rs_size"] = _swiglpk.glp_bfcp_rs_size_set
    __swig_getmethods__["rs_size"] = _swiglpk.glp_bfcp_rs_size_get
    if _newclass:
        rs_size = _swig_property(_swiglpk.glp_bfcp_rs_size_get, _swiglpk.glp_bfcp_rs_size_set)
    __swig_setmethods__["foo_bar"] = _swiglpk.glp_bfcp_foo_bar_set
    __swig_getmethods__["foo_bar"] = _swiglpk.glp_bfcp_foo_bar_get
    if _newclass:
        foo_bar = _swig_property(_swiglpk.glp_bfcp_foo_bar_get, _swiglpk.glp_bfcp_foo_bar_set)

    def __init__(self):
        this = _swiglpk.new_glp_bfcp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_bfcp
    __del__ = lambda self: None
glp_bfcp_swigregister = _swiglpk.glp_bfcp_swigregister
glp_bfcp_swigregister(glp_bfcp)
GLP_BF_LUF = _swiglpk.GLP_BF_LUF
GLP_BF_BTF = _swiglpk.GLP_BF_BTF
GLP_BF_FT = _swiglpk.GLP_BF_FT
GLP_BF_BG = _swiglpk.GLP_BF_BG
GLP_BF_GR = _swiglpk.GLP_BF_GR

class glp_smcp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_smcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_smcp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["msg_lev"] = _swiglpk.glp_smcp_msg_lev_set
    __swig_getmethods__["msg_lev"] = _swiglpk.glp_smcp_msg_lev_get
    if _newclass:
        msg_lev = _swig_property(_swiglpk.glp_smcp_msg_lev_get, _swiglpk.glp_smcp_msg_lev_set)
    __swig_setmethods__["meth"] = _swiglpk.glp_smcp_meth_set
    __swig_getmethods__["meth"] = _swiglpk.glp_smcp_meth_get
    if _newclass:
        meth = _swig_property(_swiglpk.glp_smcp_meth_get, _swiglpk.glp_smcp_meth_set)
    __swig_setmethods__["pricing"] = _swiglpk.glp_smcp_pricing_set
    __swig_getmethods__["pricing"] = _swiglpk.glp_smcp_pricing_get
    if _newclass:
        pricing = _swig_property(_swiglpk.glp_smcp_pricing_get, _swiglpk.glp_smcp_pricing_set)
    __swig_setmethods__["r_test"] = _swiglpk.glp_smcp_r_test_set
    __swig_getmethods__["r_test"] = _swiglpk.glp_smcp_r_test_get
    if _newclass:
        r_test = _swig_property(_swiglpk.glp_smcp_r_test_get, _swiglpk.glp_smcp_r_test_set)
    __swig_setmethods__["tol_bnd"] = _swiglpk.glp_smcp_tol_bnd_set
    __swig_getmethods__["tol_bnd"] = _swiglpk.glp_smcp_tol_bnd_get
    if _newclass:
        tol_bnd = _swig_property(_swiglpk.glp_smcp_tol_bnd_get, _swiglpk.glp_smcp_tol_bnd_set)
    __swig_setmethods__["tol_dj"] = _swiglpk.glp_smcp_tol_dj_set
    __swig_getmethods__["tol_dj"] = _swiglpk.glp_smcp_tol_dj_get
    if _newclass:
        tol_dj = _swig_property(_swiglpk.glp_smcp_tol_dj_get, _swiglpk.glp_smcp_tol_dj_set)
    __swig_setmethods__["tol_piv"] = _swiglpk.glp_smcp_tol_piv_set
    __swig_getmethods__["tol_piv"] = _swiglpk.glp_smcp_tol_piv_get
    if _newclass:
        tol_piv = _swig_property(_swiglpk.glp_smcp_tol_piv_get, _swiglpk.glp_smcp_tol_piv_set)
    __swig_setmethods__["obj_ll"] = _swiglpk.glp_smcp_obj_ll_set
    __swig_getmethods__["obj_ll"] = _swiglpk.glp_smcp_obj_ll_get
    if _newclass:
        obj_ll = _swig_property(_swiglpk.glp_smcp_obj_ll_get, _swiglpk.glp_smcp_obj_ll_set)
    __swig_setmethods__["obj_ul"] = _swiglpk.glp_smcp_obj_ul_set
    __swig_getmethods__["obj_ul"] = _swiglpk.glp_smcp_obj_ul_get
    if _newclass:
        obj_ul = _swig_property(_swiglpk.glp_smcp_obj_ul_get, _swiglpk.glp_smcp_obj_ul_set)
    __swig_setmethods__["it_lim"] = _swiglpk.glp_smcp_it_lim_set
    __swig_getmethods__["it_lim"] = _swiglpk.glp_smcp_it_lim_get
    if _newclass:
        it_lim = _swig_property(_swiglpk.glp_smcp_it_lim_get, _swiglpk.glp_smcp_it_lim_set)
    __swig_setmethods__["tm_lim"] = _swiglpk.glp_smcp_tm_lim_set
    __swig_getmethods__["tm_lim"] = _swiglpk.glp_smcp_tm_lim_get
    if _newclass:
        tm_lim = _swig_property(_swiglpk.glp_smcp_tm_lim_get, _swiglpk.glp_smcp_tm_lim_set)
    __swig_setmethods__["out_frq"] = _swiglpk.glp_smcp_out_frq_set
    __swig_getmethods__["out_frq"] = _swiglpk.glp_smcp_out_frq_get
    if _newclass:
        out_frq = _swig_property(_swiglpk.glp_smcp_out_frq_get, _swiglpk.glp_smcp_out_frq_set)
    __swig_setmethods__["out_dly"] = _swiglpk.glp_smcp_out_dly_set
    __swig_getmethods__["out_dly"] = _swiglpk.glp_smcp_out_dly_get
    if _newclass:
        out_dly = _swig_property(_swiglpk.glp_smcp_out_dly_get, _swiglpk.glp_smcp_out_dly_set)
    __swig_setmethods__["presolve"] = _swiglpk.glp_smcp_presolve_set
    __swig_getmethods__["presolve"] = _swiglpk.glp_smcp_presolve_get
    if _newclass:
        presolve = _swig_property(_swiglpk.glp_smcp_presolve_get, _swiglpk.glp_smcp_presolve_set)
    __swig_setmethods__["foo_bar"] = _swiglpk.glp_smcp_foo_bar_set
    __swig_getmethods__["foo_bar"] = _swiglpk.glp_smcp_foo_bar_get
    if _newclass:
        foo_bar = _swig_property(_swiglpk.glp_smcp_foo_bar_get, _swiglpk.glp_smcp_foo_bar_set)

    def __init__(self):
        this = _swiglpk.new_glp_smcp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_smcp
    __del__ = lambda self: None
glp_smcp_swigregister = _swiglpk.glp_smcp_swigregister
glp_smcp_swigregister(glp_smcp)
GLP_MSG_OFF = _swiglpk.GLP_MSG_OFF
GLP_MSG_ERR = _swiglpk.GLP_MSG_ERR
GLP_MSG_ON = _swiglpk.GLP_MSG_ON
GLP_MSG_ALL = _swiglpk.GLP_MSG_ALL
GLP_MSG_DBG = _swiglpk.GLP_MSG_DBG
GLP_PRIMAL = _swiglpk.GLP_PRIMAL
GLP_DUALP = _swiglpk.GLP_DUALP
GLP_DUAL = _swiglpk.GLP_DUAL
GLP_PT_STD = _swiglpk.GLP_PT_STD
GLP_PT_PSE = _swiglpk.GLP_PT_PSE
GLP_RT_STD = _swiglpk.GLP_RT_STD
GLP_RT_HAR = _swiglpk.GLP_RT_HAR
GLP_RT_FLIP = _swiglpk.GLP_RT_FLIP

class glp_iptcp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_iptcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_iptcp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["msg_lev"] = _swiglpk.glp_iptcp_msg_lev_set
    __swig_getmethods__["msg_lev"] = _swiglpk.glp_iptcp_msg_lev_get
    if _newclass:
        msg_lev = _swig_property(_swiglpk.glp_iptcp_msg_lev_get, _swiglpk.glp_iptcp_msg_lev_set)
    __swig_setmethods__["ord_alg"] = _swiglpk.glp_iptcp_ord_alg_set
    __swig_getmethods__["ord_alg"] = _swiglpk.glp_iptcp_ord_alg_get
    if _newclass:
        ord_alg = _swig_property(_swiglpk.glp_iptcp_ord_alg_get, _swiglpk.glp_iptcp_ord_alg_set)
    __swig_setmethods__["foo_bar"] = _swiglpk.glp_iptcp_foo_bar_set
    __swig_getmethods__["foo_bar"] = _swiglpk.glp_iptcp_foo_bar_get
    if _newclass:
        foo_bar = _swig_property(_swiglpk.glp_iptcp_foo_bar_get, _swiglpk.glp_iptcp_foo_bar_set)

    def __init__(self):
        this = _swiglpk.new_glp_iptcp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_iptcp
    __del__ = lambda self: None
glp_iptcp_swigregister = _swiglpk.glp_iptcp_swigregister
glp_iptcp_swigregister(glp_iptcp)
GLP_ORD_NONE = _swiglpk.GLP_ORD_NONE
GLP_ORD_QMD = _swiglpk.GLP_ORD_QMD
GLP_ORD_AMD = _swiglpk.GLP_ORD_AMD
GLP_ORD_SYMAMD = _swiglpk.GLP_ORD_SYMAMD

class glp_iocp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_iocp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_iocp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["msg_lev"] = _swiglpk.glp_iocp_msg_lev_set
    __swig_getmethods__["msg_lev"] = _swiglpk.glp_iocp_msg_lev_get
    if _newclass:
        msg_lev = _swig_property(_swiglpk.glp_iocp_msg_lev_get, _swiglpk.glp_iocp_msg_lev_set)
    __swig_setmethods__["br_tech"] = _swiglpk.glp_iocp_br_tech_set
    __swig_getmethods__["br_tech"] = _swiglpk.glp_iocp_br_tech_get
    if _newclass:
        br_tech = _swig_property(_swiglpk.glp_iocp_br_tech_get, _swiglpk.glp_iocp_br_tech_set)
    __swig_setmethods__["bt_tech"] = _swiglpk.glp_iocp_bt_tech_set
    __swig_getmethods__["bt_tech"] = _swiglpk.glp_iocp_bt_tech_get
    if _newclass:
        bt_tech = _swig_property(_swiglpk.glp_iocp_bt_tech_get, _swiglpk.glp_iocp_bt_tech_set)
    __swig_setmethods__["tol_int"] = _swiglpk.glp_iocp_tol_int_set
    __swig_getmethods__["tol_int"] = _swiglpk.glp_iocp_tol_int_get
    if _newclass:
        tol_int = _swig_property(_swiglpk.glp_iocp_tol_int_get, _swiglpk.glp_iocp_tol_int_set)
    __swig_setmethods__["tol_obj"] = _swiglpk.glp_iocp_tol_obj_set
    __swig_getmethods__["tol_obj"] = _swiglpk.glp_iocp_tol_obj_get
    if _newclass:
        tol_obj = _swig_property(_swiglpk.glp_iocp_tol_obj_get, _swiglpk.glp_iocp_tol_obj_set)
    __swig_setmethods__["tm_lim"] = _swiglpk.glp_iocp_tm_lim_set
    __swig_getmethods__["tm_lim"] = _swiglpk.glp_iocp_tm_lim_get
    if _newclass:
        tm_lim = _swig_property(_swiglpk.glp_iocp_tm_lim_get, _swiglpk.glp_iocp_tm_lim_set)
    __swig_setmethods__["out_frq"] = _swiglpk.glp_iocp_out_frq_set
    __swig_getmethods__["out_frq"] = _swiglpk.glp_iocp_out_frq_get
    if _newclass:
        out_frq = _swig_property(_swiglpk.glp_iocp_out_frq_get, _swiglpk.glp_iocp_out_frq_set)
    __swig_setmethods__["out_dly"] = _swiglpk.glp_iocp_out_dly_set
    __swig_getmethods__["out_dly"] = _swiglpk.glp_iocp_out_dly_get
    if _newclass:
        out_dly = _swig_property(_swiglpk.glp_iocp_out_dly_get, _swiglpk.glp_iocp_out_dly_set)
    __swig_setmethods__["cb_func"] = _swiglpk.glp_iocp_cb_func_set
    __swig_getmethods__["cb_func"] = _swiglpk.glp_iocp_cb_func_get
    if _newclass:
        cb_func = _swig_property(_swiglpk.glp_iocp_cb_func_get, _swiglpk.glp_iocp_cb_func_set)
    __swig_setmethods__["cb_info"] = _swiglpk.glp_iocp_cb_info_set
    __swig_getmethods__["cb_info"] = _swiglpk.glp_iocp_cb_info_get
    if _newclass:
        cb_info = _swig_property(_swiglpk.glp_iocp_cb_info_get, _swiglpk.glp_iocp_cb_info_set)
    __swig_setmethods__["cb_size"] = _swiglpk.glp_iocp_cb_size_set
    __swig_getmethods__["cb_size"] = _swiglpk.glp_iocp_cb_size_get
    if _newclass:
        cb_size = _swig_property(_swiglpk.glp_iocp_cb_size_get, _swiglpk.glp_iocp_cb_size_set)
    __swig_setmethods__["pp_tech"] = _swiglpk.glp_iocp_pp_tech_set
    __swig_getmethods__["pp_tech"] = _swiglpk.glp_iocp_pp_tech_get
    if _newclass:
        pp_tech = _swig_property(_swiglpk.glp_iocp_pp_tech_get, _swiglpk.glp_iocp_pp_tech_set)
    __swig_setmethods__["mip_gap"] = _swiglpk.glp_iocp_mip_gap_set
    __swig_getmethods__["mip_gap"] = _swiglpk.glp_iocp_mip_gap_get
    if _newclass:
        mip_gap = _swig_property(_swiglpk.glp_iocp_mip_gap_get, _swiglpk.glp_iocp_mip_gap_set)
    __swig_setmethods__["mir_cuts"] = _swiglpk.glp_iocp_mir_cuts_set
    __swig_getmethods__["mir_cuts"] = _swiglpk.glp_iocp_mir_cuts_get
    if _newclass:
        mir_cuts = _swig_property(_swiglpk.glp_iocp_mir_cuts_get, _swiglpk.glp_iocp_mir_cuts_set)
    __swig_setmethods__["gmi_cuts"] = _swiglpk.glp_iocp_gmi_cuts_set
    __swig_getmethods__["gmi_cuts"] = _swiglpk.glp_iocp_gmi_cuts_get
    if _newclass:
        gmi_cuts = _swig_property(_swiglpk.glp_iocp_gmi_cuts_get, _swiglpk.glp_iocp_gmi_cuts_set)
    __swig_setmethods__["cov_cuts"] = _swiglpk.glp_iocp_cov_cuts_set
    __swig_getmethods__["cov_cuts"] = _swiglpk.glp_iocp_cov_cuts_get
    if _newclass:
        cov_cuts = _swig_property(_swiglpk.glp_iocp_cov_cuts_get, _swiglpk.glp_iocp_cov_cuts_set)
    __swig_setmethods__["clq_cuts"] = _swiglpk.glp_iocp_clq_cuts_set
    __swig_getmethods__["clq_cuts"] = _swiglpk.glp_iocp_clq_cuts_get
    if _newclass:
        clq_cuts = _swig_property(_swiglpk.glp_iocp_clq_cuts_get, _swiglpk.glp_iocp_clq_cuts_set)
    __swig_setmethods__["presolve"] = _swiglpk.glp_iocp_presolve_set
    __swig_getmethods__["presolve"] = _swiglpk.glp_iocp_presolve_get
    if _newclass:
        presolve = _swig_property(_swiglpk.glp_iocp_presolve_get, _swiglpk.glp_iocp_presolve_set)
    __swig_setmethods__["binarize"] = _swiglpk.glp_iocp_binarize_set
    __swig_getmethods__["binarize"] = _swiglpk.glp_iocp_binarize_get
    if _newclass:
        binarize = _swig_property(_swiglpk.glp_iocp_binarize_get, _swiglpk.glp_iocp_binarize_set)
    __swig_setmethods__["fp_heur"] = _swiglpk.glp_iocp_fp_heur_set
    __swig_getmethods__["fp_heur"] = _swiglpk.glp_iocp_fp_heur_get
    if _newclass:
        fp_heur = _swig_property(_swiglpk.glp_iocp_fp_heur_get, _swiglpk.glp_iocp_fp_heur_set)
    __swig_setmethods__["ps_heur"] = _swiglpk.glp_iocp_ps_heur_set
    __swig_getmethods__["ps_heur"] = _swiglpk.glp_iocp_ps_heur_get
    if _newclass:
        ps_heur = _swig_property(_swiglpk.glp_iocp_ps_heur_get, _swiglpk.glp_iocp_ps_heur_set)
    __swig_setmethods__["ps_tm_lim"] = _swiglpk.glp_iocp_ps_tm_lim_set
    __swig_getmethods__["ps_tm_lim"] = _swiglpk.glp_iocp_ps_tm_lim_get
    if _newclass:
        ps_tm_lim = _swig_property(_swiglpk.glp_iocp_ps_tm_lim_get, _swiglpk.glp_iocp_ps_tm_lim_set)
    __swig_setmethods__["sr_heur"] = _swiglpk.glp_iocp_sr_heur_set
    __swig_getmethods__["sr_heur"] = _swiglpk.glp_iocp_sr_heur_get
    if _newclass:
        sr_heur = _swig_property(_swiglpk.glp_iocp_sr_heur_get, _swiglpk.glp_iocp_sr_heur_set)
    __swig_setmethods__["use_sol"] = _swiglpk.glp_iocp_use_sol_set
    __swig_getmethods__["use_sol"] = _swiglpk.glp_iocp_use_sol_get
    if _newclass:
        use_sol = _swig_property(_swiglpk.glp_iocp_use_sol_get, _swiglpk.glp_iocp_use_sol_set)
    __swig_setmethods__["save_sol"] = _swiglpk.glp_iocp_save_sol_set
    __swig_getmethods__["save_sol"] = _swiglpk.glp_iocp_save_sol_get
    if _newclass:
        save_sol = _swig_property(_swiglpk.glp_iocp_save_sol_get, _swiglpk.glp_iocp_save_sol_set)
    __swig_setmethods__["alien"] = _swiglpk.glp_iocp_alien_set
    __swig_getmethods__["alien"] = _swiglpk.glp_iocp_alien_get
    if _newclass:
        alien = _swig_property(_swiglpk.glp_iocp_alien_get, _swiglpk.glp_iocp_alien_set)
    __swig_setmethods__["flip"] = _swiglpk.glp_iocp_flip_set
    __swig_getmethods__["flip"] = _swiglpk.glp_iocp_flip_get
    if _newclass:
        flip = _swig_property(_swiglpk.glp_iocp_flip_get, _swiglpk.glp_iocp_flip_set)
    __swig_setmethods__["foo_bar"] = _swiglpk.glp_iocp_foo_bar_set
    __swig_getmethods__["foo_bar"] = _swiglpk.glp_iocp_foo_bar_get
    if _newclass:
        foo_bar = _swig_property(_swiglpk.glp_iocp_foo_bar_get, _swiglpk.glp_iocp_foo_bar_set)

    def __init__(self):
        this = _swiglpk.new_glp_iocp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_iocp
    __del__ = lambda self: None
glp_iocp_swigregister = _swiglpk.glp_iocp_swigregister
glp_iocp_swigregister(glp_iocp)
GLP_BR_FFV = _swiglpk.GLP_BR_FFV
GLP_BR_LFV = _swiglpk.GLP_BR_LFV
GLP_BR_MFV = _swiglpk.GLP_BR_MFV
GLP_BR_DTH = _swiglpk.GLP_BR_DTH
GLP_BR_PCH = _swiglpk.GLP_BR_PCH
GLP_BT_DFS = _swiglpk.GLP_BT_DFS
GLP_BT_BFS = _swiglpk.GLP_BT_BFS
GLP_BT_BLB = _swiglpk.GLP_BT_BLB
GLP_BT_BPH = _swiglpk.GLP_BT_BPH
GLP_PP_NONE = _swiglpk.GLP_PP_NONE
GLP_PP_ROOT = _swiglpk.GLP_PP_ROOT
GLP_PP_ALL = _swiglpk.GLP_PP_ALL

class glp_attr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_attr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_attr, name)
    __repr__ = _swig_repr
    __swig_setmethods__["level"] = _swiglpk.glp_attr_level_set
    __swig_getmethods__["level"] = _swiglpk.glp_attr_level_get
    if _newclass:
        level = _swig_property(_swiglpk.glp_attr_level_get, _swiglpk.glp_attr_level_set)
    __swig_setmethods__["origin"] = _swiglpk.glp_attr_origin_set
    __swig_getmethods__["origin"] = _swiglpk.glp_attr_origin_get
    if _newclass:
        origin = _swig_property(_swiglpk.glp_attr_origin_get, _swiglpk.glp_attr_origin_set)
    __swig_setmethods__["klass"] = _swiglpk.glp_attr_klass_set
    __swig_getmethods__["klass"] = _swiglpk.glp_attr_klass_get
    if _newclass:
        klass = _swig_property(_swiglpk.glp_attr_klass_get, _swiglpk.glp_attr_klass_set)
    __swig_setmethods__["foo_bar"] = _swiglpk.glp_attr_foo_bar_set
    __swig_getmethods__["foo_bar"] = _swiglpk.glp_attr_foo_bar_get
    if _newclass:
        foo_bar = _swig_property(_swiglpk.glp_attr_foo_bar_get, _swiglpk.glp_attr_foo_bar_set)

    def __init__(self):
        this = _swiglpk.new_glp_attr()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_attr
    __del__ = lambda self: None
glp_attr_swigregister = _swiglpk.glp_attr_swigregister
glp_attr_swigregister(glp_attr)
GLP_RF_REG = _swiglpk.GLP_RF_REG
GLP_RF_LAZY = _swiglpk.GLP_RF_LAZY
GLP_RF_CUT = _swiglpk.GLP_RF_CUT
GLP_RF_GMI = _swiglpk.GLP_RF_GMI
GLP_RF_MIR = _swiglpk.GLP_RF_MIR
GLP_RF_COV = _swiglpk.GLP_RF_COV
GLP_RF_CLQ = _swiglpk.GLP_RF_CLQ

GLP_ON = _swiglpk.GLP_ON
GLP_OFF = _swiglpk.GLP_OFF
GLP_IROWGEN = _swiglpk.GLP_IROWGEN
GLP_IBINGO = _swiglpk.GLP_IBINGO
GLP_IHEUR = _swiglpk.GLP_IHEUR
GLP_ICUTGEN = _swiglpk.GLP_ICUTGEN
GLP_IBRANCH = _swiglpk.GLP_IBRANCH
GLP_ISELECT = _swiglpk.GLP_ISELECT
GLP_IPREPRO = _swiglpk.GLP_IPREPRO
GLP_NO_BRNCH = _swiglpk.GLP_NO_BRNCH
GLP_DN_BRNCH = _swiglpk.GLP_DN_BRNCH
GLP_UP_BRNCH = _swiglpk.GLP_UP_BRNCH
GLP_EBADB = _swiglpk.GLP_EBADB
GLP_ESING = _swiglpk.GLP_ESING
GLP_ECOND = _swiglpk.GLP_ECOND
GLP_EBOUND = _swiglpk.GLP_EBOUND
GLP_EFAIL = _swiglpk.GLP_EFAIL
GLP_EOBJLL = _swiglpk.GLP_EOBJLL
GLP_EOBJUL = _swiglpk.GLP_EOBJUL
GLP_EITLIM = _swiglpk.GLP_EITLIM
GLP_ETMLIM = _swiglpk.GLP_ETMLIM
GLP_ENOPFS = _swiglpk.GLP_ENOPFS
GLP_ENODFS = _swiglpk.GLP_ENODFS
GLP_EROOT = _swiglpk.GLP_EROOT
GLP_ESTOP = _swiglpk.GLP_ESTOP
GLP_EMIPGAP = _swiglpk.GLP_EMIPGAP
GLP_ENOFEAS = _swiglpk.GLP_ENOFEAS
GLP_ENOCVG = _swiglpk.GLP_ENOCVG
GLP_EINSTAB = _swiglpk.GLP_EINSTAB
GLP_EDATA = _swiglpk.GLP_EDATA
GLP_ERANGE = _swiglpk.GLP_ERANGE
GLP_KKT_PE = _swiglpk.GLP_KKT_PE
GLP_KKT_PB = _swiglpk.GLP_KKT_PB
GLP_KKT_DE = _swiglpk.GLP_KKT_DE
GLP_KKT_DB = _swiglpk.GLP_KKT_DB
GLP_KKT_CS = _swiglpk.GLP_KKT_CS
GLP_MPS_DECK = _swiglpk.GLP_MPS_DECK
GLP_MPS_FILE = _swiglpk.GLP_MPS_FILE
class glp_mpscp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_mpscp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_mpscp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["blank"] = _swiglpk.glp_mpscp_blank_set
    __swig_getmethods__["blank"] = _swiglpk.glp_mpscp_blank_get
    if _newclass:
        blank = _swig_property(_swiglpk.glp_mpscp_blank_get, _swiglpk.glp_mpscp_blank_set)
    __swig_setmethods__["obj_name"] = _swiglpk.glp_mpscp_obj_name_set
    __swig_getmethods__["obj_name"] = _swiglpk.glp_mpscp_obj_name_get
    if _newclass:
        obj_name = _swig_property(_swiglpk.glp_mpscp_obj_name_get, _swiglpk.glp_mpscp_obj_name_set)
    __swig_setmethods__["tol_mps"] = _swiglpk.glp_mpscp_tol_mps_set
    __swig_getmethods__["tol_mps"] = _swiglpk.glp_mpscp_tol_mps_get
    if _newclass:
        tol_mps = _swig_property(_swiglpk.glp_mpscp_tol_mps_get, _swiglpk.glp_mpscp_tol_mps_set)
    __swig_setmethods__["foo_bar"] = _swiglpk.glp_mpscp_foo_bar_set
    __swig_getmethods__["foo_bar"] = _swiglpk.glp_mpscp_foo_bar_get
    if _newclass:
        foo_bar = _swig_property(_swiglpk.glp_mpscp_foo_bar_get, _swiglpk.glp_mpscp_foo_bar_set)

    def __init__(self):
        this = _swiglpk.new_glp_mpscp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_mpscp
    __del__ = lambda self: None
glp_mpscp_swigregister = _swiglpk.glp_mpscp_swigregister
glp_mpscp_swigregister(glp_mpscp)

class glp_cpxcp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_cpxcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_cpxcp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["foo_bar"] = _swiglpk.glp_cpxcp_foo_bar_set
    __swig_getmethods__["foo_bar"] = _swiglpk.glp_cpxcp_foo_bar_get
    if _newclass:
        foo_bar = _swig_property(_swiglpk.glp_cpxcp_foo_bar_get, _swiglpk.glp_cpxcp_foo_bar_set)

    def __init__(self):
        this = _swiglpk.new_glp_cpxcp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_cpxcp
    __del__ = lambda self: None
glp_cpxcp_swigregister = _swiglpk.glp_cpxcp_swigregister
glp_cpxcp_swigregister(glp_cpxcp)


def glp_create_prob():
    return _swiglpk.glp_create_prob()
glp_create_prob = _swiglpk.glp_create_prob

def glp_set_prob_name(P, name):
    return _swiglpk.glp_set_prob_name(P, name)
glp_set_prob_name = _swiglpk.glp_set_prob_name

def glp_set_obj_name(P, name):
    return _swiglpk.glp_set_obj_name(P, name)
glp_set_obj_name = _swiglpk.glp_set_obj_name

def glp_set_obj_dir(P, dir):
    return _swiglpk.glp_set_obj_dir(P, dir)
glp_set_obj_dir = _swiglpk.glp_set_obj_dir

def glp_add_rows(P, nrs):
    return _swiglpk.glp_add_rows(P, nrs)
glp_add_rows = _swiglpk.glp_add_rows

def glp_add_cols(P, ncs):
    return _swiglpk.glp_add_cols(P, ncs)
glp_add_cols = _swiglpk.glp_add_cols

def glp_set_row_name(P, i, name):
    return _swiglpk.glp_set_row_name(P, i, name)
glp_set_row_name = _swiglpk.glp_set_row_name

def glp_set_col_name(P, j, name):
    return _swiglpk.glp_set_col_name(P, j, name)
glp_set_col_name = _swiglpk.glp_set_col_name

def glp_set_row_bnds(P, i, type, lb, ub):
    return _swiglpk.glp_set_row_bnds(P, i, type, lb, ub)
glp_set_row_bnds = _swiglpk.glp_set_row_bnds

def glp_set_col_bnds(P, j, type, lb, ub):
    return _swiglpk.glp_set_col_bnds(P, j, type, lb, ub)
glp_set_col_bnds = _swiglpk.glp_set_col_bnds

def glp_set_obj_coef(P, j, coef):
    return _swiglpk.glp_set_obj_coef(P, j, coef)
glp_set_obj_coef = _swiglpk.glp_set_obj_coef

def glp_set_mat_row(P, i, len, ind, val):
    return _swiglpk.glp_set_mat_row(P, i, len, ind, val)
glp_set_mat_row = _swiglpk.glp_set_mat_row

def glp_set_mat_col(P, j, len, ind, val):
    return _swiglpk.glp_set_mat_col(P, j, len, ind, val)
glp_set_mat_col = _swiglpk.glp_set_mat_col

def glp_load_matrix(P, ne, ia, ja, ar):
    return _swiglpk.glp_load_matrix(P, ne, ia, ja, ar)
glp_load_matrix = _swiglpk.glp_load_matrix

def glp_check_dup(m, n, ne, ia, ja):
    return _swiglpk.glp_check_dup(m, n, ne, ia, ja)
glp_check_dup = _swiglpk.glp_check_dup

def glp_sort_matrix(P):
    return _swiglpk.glp_sort_matrix(P)
glp_sort_matrix = _swiglpk.glp_sort_matrix

def glp_del_rows(P, nrs, num):
    return _swiglpk.glp_del_rows(P, nrs, num)
glp_del_rows = _swiglpk.glp_del_rows

def glp_del_cols(P, ncs, num):
    return _swiglpk.glp_del_cols(P, ncs, num)
glp_del_cols = _swiglpk.glp_del_cols

def glp_copy_prob(dest, prob, names):
    return _swiglpk.glp_copy_prob(dest, prob, names)
glp_copy_prob = _swiglpk.glp_copy_prob

def glp_erase_prob(P):
    return _swiglpk.glp_erase_prob(P)
glp_erase_prob = _swiglpk.glp_erase_prob

def glp_delete_prob(P):
    return _swiglpk.glp_delete_prob(P)
glp_delete_prob = _swiglpk.glp_delete_prob

def glp_get_prob_name(P):
    return _swiglpk.glp_get_prob_name(P)
glp_get_prob_name = _swiglpk.glp_get_prob_name

def glp_get_obj_name(P):
    return _swiglpk.glp_get_obj_name(P)
glp_get_obj_name = _swiglpk.glp_get_obj_name

def glp_get_obj_dir(P):
    return _swiglpk.glp_get_obj_dir(P)
glp_get_obj_dir = _swiglpk.glp_get_obj_dir

def glp_get_num_rows(P):
    return _swiglpk.glp_get_num_rows(P)
glp_get_num_rows = _swiglpk.glp_get_num_rows

def glp_get_num_cols(P):
    return _swiglpk.glp_get_num_cols(P)
glp_get_num_cols = _swiglpk.glp_get_num_cols

def glp_get_row_name(P, i):
    return _swiglpk.glp_get_row_name(P, i)
glp_get_row_name = _swiglpk.glp_get_row_name

def glp_get_col_name(P, j):
    return _swiglpk.glp_get_col_name(P, j)
glp_get_col_name = _swiglpk.glp_get_col_name

def glp_get_row_type(P, i):
    return _swiglpk.glp_get_row_type(P, i)
glp_get_row_type = _swiglpk.glp_get_row_type

def glp_get_row_lb(P, i):
    return _swiglpk.glp_get_row_lb(P, i)
glp_get_row_lb = _swiglpk.glp_get_row_lb

def glp_get_row_ub(P, i):
    return _swiglpk.glp_get_row_ub(P, i)
glp_get_row_ub = _swiglpk.glp_get_row_ub

def glp_get_col_type(P, j):
    return _swiglpk.glp_get_col_type(P, j)
glp_get_col_type = _swiglpk.glp_get_col_type

def glp_get_col_lb(P, j):
    return _swiglpk.glp_get_col_lb(P, j)
glp_get_col_lb = _swiglpk.glp_get_col_lb

def glp_get_col_ub(P, j):
    return _swiglpk.glp_get_col_ub(P, j)
glp_get_col_ub = _swiglpk.glp_get_col_ub

def glp_get_obj_coef(P, j):
    return _swiglpk.glp_get_obj_coef(P, j)
glp_get_obj_coef = _swiglpk.glp_get_obj_coef

def glp_get_num_nz(P):
    return _swiglpk.glp_get_num_nz(P)
glp_get_num_nz = _swiglpk.glp_get_num_nz

def glp_get_mat_row(P, i, ind, val):
    return _swiglpk.glp_get_mat_row(P, i, ind, val)
glp_get_mat_row = _swiglpk.glp_get_mat_row

def glp_get_mat_col(P, j, ind, val):
    return _swiglpk.glp_get_mat_col(P, j, ind, val)
glp_get_mat_col = _swiglpk.glp_get_mat_col

def glp_create_index(P):
    return _swiglpk.glp_create_index(P)
glp_create_index = _swiglpk.glp_create_index

def glp_find_row(P, name):
    return _swiglpk.glp_find_row(P, name)
glp_find_row = _swiglpk.glp_find_row

def glp_find_col(P, name):
    return _swiglpk.glp_find_col(P, name)
glp_find_col = _swiglpk.glp_find_col

def glp_delete_index(P):
    return _swiglpk.glp_delete_index(P)
glp_delete_index = _swiglpk.glp_delete_index

def glp_set_rii(P, i, rii):
    return _swiglpk.glp_set_rii(P, i, rii)
glp_set_rii = _swiglpk.glp_set_rii

def glp_set_sjj(P, j, sjj):
    return _swiglpk.glp_set_sjj(P, j, sjj)
glp_set_sjj = _swiglpk.glp_set_sjj

def glp_get_rii(P, i):
    return _swiglpk.glp_get_rii(P, i)
glp_get_rii = _swiglpk.glp_get_rii

def glp_get_sjj(P, j):
    return _swiglpk.glp_get_sjj(P, j)
glp_get_sjj = _swiglpk.glp_get_sjj

def glp_scale_prob(P, flags):
    return _swiglpk.glp_scale_prob(P, flags)
glp_scale_prob = _swiglpk.glp_scale_prob

def glp_unscale_prob(P):
    return _swiglpk.glp_unscale_prob(P)
glp_unscale_prob = _swiglpk.glp_unscale_prob

def glp_set_row_stat(P, i, stat):
    return _swiglpk.glp_set_row_stat(P, i, stat)
glp_set_row_stat = _swiglpk.glp_set_row_stat

def glp_set_col_stat(P, j, stat):
    return _swiglpk.glp_set_col_stat(P, j, stat)
glp_set_col_stat = _swiglpk.glp_set_col_stat

def glp_std_basis(P):
    return _swiglpk.glp_std_basis(P)
glp_std_basis = _swiglpk.glp_std_basis

def glp_adv_basis(P, flags):
    return _swiglpk.glp_adv_basis(P, flags)
glp_adv_basis = _swiglpk.glp_adv_basis

def glp_cpx_basis(P):
    return _swiglpk.glp_cpx_basis(P)
glp_cpx_basis = _swiglpk.glp_cpx_basis

def glp_simplex(P, parm):
    return _swiglpk.glp_simplex(P, parm)
glp_simplex = _swiglpk.glp_simplex

def glp_exact(P, parm):
    return _swiglpk.glp_exact(P, parm)
glp_exact = _swiglpk.glp_exact

def glp_init_smcp(parm):
    return _swiglpk.glp_init_smcp(parm)
glp_init_smcp = _swiglpk.glp_init_smcp

def glp_get_status(P):
    return _swiglpk.glp_get_status(P)
glp_get_status = _swiglpk.glp_get_status

def glp_get_prim_stat(P):
    return _swiglpk.glp_get_prim_stat(P)
glp_get_prim_stat = _swiglpk.glp_get_prim_stat

def glp_get_dual_stat(P):
    return _swiglpk.glp_get_dual_stat(P)
glp_get_dual_stat = _swiglpk.glp_get_dual_stat

def glp_get_obj_val(P):
    return _swiglpk.glp_get_obj_val(P)
glp_get_obj_val = _swiglpk.glp_get_obj_val

def glp_get_row_stat(P, i):
    return _swiglpk.glp_get_row_stat(P, i)
glp_get_row_stat = _swiglpk.glp_get_row_stat

def glp_get_row_prim(P, i):
    return _swiglpk.glp_get_row_prim(P, i)
glp_get_row_prim = _swiglpk.glp_get_row_prim

def glp_get_row_dual(P, i):
    return _swiglpk.glp_get_row_dual(P, i)
glp_get_row_dual = _swiglpk.glp_get_row_dual

def glp_get_col_stat(P, j):
    return _swiglpk.glp_get_col_stat(P, j)
glp_get_col_stat = _swiglpk.glp_get_col_stat

def glp_get_col_prim(P, j):
    return _swiglpk.glp_get_col_prim(P, j)
glp_get_col_prim = _swiglpk.glp_get_col_prim

def glp_get_col_dual(P, j):
    return _swiglpk.glp_get_col_dual(P, j)
glp_get_col_dual = _swiglpk.glp_get_col_dual

def glp_get_unbnd_ray(P):
    return _swiglpk.glp_get_unbnd_ray(P)
glp_get_unbnd_ray = _swiglpk.glp_get_unbnd_ray

def glp_get_it_cnt(P):
    return _swiglpk.glp_get_it_cnt(P)
glp_get_it_cnt = _swiglpk.glp_get_it_cnt

def glp_set_it_cnt(P, it_cnt):
    return _swiglpk.glp_set_it_cnt(P, it_cnt)
glp_set_it_cnt = _swiglpk.glp_set_it_cnt

def glp_interior(P, parm):
    return _swiglpk.glp_interior(P, parm)
glp_interior = _swiglpk.glp_interior

def glp_init_iptcp(parm):
    return _swiglpk.glp_init_iptcp(parm)
glp_init_iptcp = _swiglpk.glp_init_iptcp

def glp_ipt_status(P):
    return _swiglpk.glp_ipt_status(P)
glp_ipt_status = _swiglpk.glp_ipt_status

def glp_ipt_obj_val(P):
    return _swiglpk.glp_ipt_obj_val(P)
glp_ipt_obj_val = _swiglpk.glp_ipt_obj_val

def glp_ipt_row_prim(P, i):
    return _swiglpk.glp_ipt_row_prim(P, i)
glp_ipt_row_prim = _swiglpk.glp_ipt_row_prim

def glp_ipt_row_dual(P, i):
    return _swiglpk.glp_ipt_row_dual(P, i)
glp_ipt_row_dual = _swiglpk.glp_ipt_row_dual

def glp_ipt_col_prim(P, j):
    return _swiglpk.glp_ipt_col_prim(P, j)
glp_ipt_col_prim = _swiglpk.glp_ipt_col_prim

def glp_ipt_col_dual(P, j):
    return _swiglpk.glp_ipt_col_dual(P, j)
glp_ipt_col_dual = _swiglpk.glp_ipt_col_dual

def glp_set_col_kind(P, j, kind):
    return _swiglpk.glp_set_col_kind(P, j, kind)
glp_set_col_kind = _swiglpk.glp_set_col_kind

def glp_get_col_kind(P, j):
    return _swiglpk.glp_get_col_kind(P, j)
glp_get_col_kind = _swiglpk.glp_get_col_kind

def glp_get_num_int(P):
    return _swiglpk.glp_get_num_int(P)
glp_get_num_int = _swiglpk.glp_get_num_int

def glp_get_num_bin(P):
    return _swiglpk.glp_get_num_bin(P)
glp_get_num_bin = _swiglpk.glp_get_num_bin

def glp_intopt(P, parm):
    return _swiglpk.glp_intopt(P, parm)
glp_intopt = _swiglpk.glp_intopt

def glp_init_iocp(parm):
    return _swiglpk.glp_init_iocp(parm)
glp_init_iocp = _swiglpk.glp_init_iocp

def glp_mip_status(P):
    return _swiglpk.glp_mip_status(P)
glp_mip_status = _swiglpk.glp_mip_status

def glp_mip_obj_val(P):
    return _swiglpk.glp_mip_obj_val(P)
glp_mip_obj_val = _swiglpk.glp_mip_obj_val

def glp_mip_row_val(P, i):
    return _swiglpk.glp_mip_row_val(P, i)
glp_mip_row_val = _swiglpk.glp_mip_row_val

def glp_mip_col_val(P, j):
    return _swiglpk.glp_mip_col_val(P, j)
glp_mip_col_val = _swiglpk.glp_mip_col_val

def glp_check_kkt(P, sol, cond, ae_max, ae_ind, re_max, re_ind):
    return _swiglpk.glp_check_kkt(P, sol, cond, ae_max, ae_ind, re_max, re_ind)
glp_check_kkt = _swiglpk.glp_check_kkt

def glp_print_sol(P, fname):
    return _swiglpk.glp_print_sol(P, fname)
glp_print_sol = _swiglpk.glp_print_sol

def glp_read_sol(P, fname):
    return _swiglpk.glp_read_sol(P, fname)
glp_read_sol = _swiglpk.glp_read_sol

def glp_write_sol(P, fname):
    return _swiglpk.glp_write_sol(P, fname)
glp_write_sol = _swiglpk.glp_write_sol

def glp_print_ranges(P, len, list, flags, fname):
    return _swiglpk.glp_print_ranges(P, len, list, flags, fname)
glp_print_ranges = _swiglpk.glp_print_ranges

def glp_print_ipt(P, fname):
    return _swiglpk.glp_print_ipt(P, fname)
glp_print_ipt = _swiglpk.glp_print_ipt

def glp_read_ipt(P, fname):
    return _swiglpk.glp_read_ipt(P, fname)
glp_read_ipt = _swiglpk.glp_read_ipt

def glp_write_ipt(P, fname):
    return _swiglpk.glp_write_ipt(P, fname)
glp_write_ipt = _swiglpk.glp_write_ipt

def glp_print_mip(P, fname):
    return _swiglpk.glp_print_mip(P, fname)
glp_print_mip = _swiglpk.glp_print_mip

def glp_read_mip(P, fname):
    return _swiglpk.glp_read_mip(P, fname)
glp_read_mip = _swiglpk.glp_read_mip

def glp_write_mip(P, fname):
    return _swiglpk.glp_write_mip(P, fname)
glp_write_mip = _swiglpk.glp_write_mip

def glp_bf_exists(P):
    return _swiglpk.glp_bf_exists(P)
glp_bf_exists = _swiglpk.glp_bf_exists

def glp_factorize(P):
    return _swiglpk.glp_factorize(P)
glp_factorize = _swiglpk.glp_factorize

def glp_bf_updated(P):
    return _swiglpk.glp_bf_updated(P)
glp_bf_updated = _swiglpk.glp_bf_updated

def glp_get_bfcp(P, parm):
    return _swiglpk.glp_get_bfcp(P, parm)
glp_get_bfcp = _swiglpk.glp_get_bfcp

def glp_set_bfcp(P, parm):
    return _swiglpk.glp_set_bfcp(P, parm)
glp_set_bfcp = _swiglpk.glp_set_bfcp

def glp_get_bhead(P, k):
    return _swiglpk.glp_get_bhead(P, k)
glp_get_bhead = _swiglpk.glp_get_bhead

def glp_get_row_bind(P, i):
    return _swiglpk.glp_get_row_bind(P, i)
glp_get_row_bind = _swiglpk.glp_get_row_bind

def glp_get_col_bind(P, j):
    return _swiglpk.glp_get_col_bind(P, j)
glp_get_col_bind = _swiglpk.glp_get_col_bind

def glp_ftran(P, x):
    return _swiglpk.glp_ftran(P, x)
glp_ftran = _swiglpk.glp_ftran

def glp_btran(P, x):
    return _swiglpk.glp_btran(P, x)
glp_btran = _swiglpk.glp_btran

def glp_warm_up(P):
    return _swiglpk.glp_warm_up(P)
glp_warm_up = _swiglpk.glp_warm_up

def glp_eval_tab_row(P, k, ind, val):
    return _swiglpk.glp_eval_tab_row(P, k, ind, val)
glp_eval_tab_row = _swiglpk.glp_eval_tab_row

def glp_eval_tab_col(P, k, ind, val):
    return _swiglpk.glp_eval_tab_col(P, k, ind, val)
glp_eval_tab_col = _swiglpk.glp_eval_tab_col

def glp_transform_row(P, len, ind, val):
    return _swiglpk.glp_transform_row(P, len, ind, val)
glp_transform_row = _swiglpk.glp_transform_row

def glp_transform_col(P, len, ind, val):
    return _swiglpk.glp_transform_col(P, len, ind, val)
glp_transform_col = _swiglpk.glp_transform_col

def glp_prim_rtest(P, len, ind, val, dir, eps):
    return _swiglpk.glp_prim_rtest(P, len, ind, val, dir, eps)
glp_prim_rtest = _swiglpk.glp_prim_rtest

def glp_dual_rtest(P, len, ind, val, dir, eps):
    return _swiglpk.glp_dual_rtest(P, len, ind, val, dir, eps)
glp_dual_rtest = _swiglpk.glp_dual_rtest

def glp_analyze_bound(P, k, value1, var1, value2, var2):
    return _swiglpk.glp_analyze_bound(P, k, value1, var1, value2, var2)
glp_analyze_bound = _swiglpk.glp_analyze_bound

def glp_analyze_coef(P, k, coef1, var1, value1, coef2, var2, value2):
    return _swiglpk.glp_analyze_coef(P, k, coef1, var1, value1, coef2, var2, value2)
glp_analyze_coef = _swiglpk.glp_analyze_coef

def glp_ios_reason(T):
    return _swiglpk.glp_ios_reason(T)
glp_ios_reason = _swiglpk.glp_ios_reason

def glp_ios_get_prob(T):
    return _swiglpk.glp_ios_get_prob(T)
glp_ios_get_prob = _swiglpk.glp_ios_get_prob

def glp_ios_tree_size(T, a_cnt, n_cnt, t_cnt):
    return _swiglpk.glp_ios_tree_size(T, a_cnt, n_cnt, t_cnt)
glp_ios_tree_size = _swiglpk.glp_ios_tree_size

def glp_ios_curr_node(T):
    return _swiglpk.glp_ios_curr_node(T)
glp_ios_curr_node = _swiglpk.glp_ios_curr_node

def glp_ios_next_node(T, p):
    return _swiglpk.glp_ios_next_node(T, p)
glp_ios_next_node = _swiglpk.glp_ios_next_node

def glp_ios_prev_node(T, p):
    return _swiglpk.glp_ios_prev_node(T, p)
glp_ios_prev_node = _swiglpk.glp_ios_prev_node

def glp_ios_up_node(T, p):
    return _swiglpk.glp_ios_up_node(T, p)
glp_ios_up_node = _swiglpk.glp_ios_up_node

def glp_ios_node_level(T, p):
    return _swiglpk.glp_ios_node_level(T, p)
glp_ios_node_level = _swiglpk.glp_ios_node_level

def glp_ios_node_bound(T, p):
    return _swiglpk.glp_ios_node_bound(T, p)
glp_ios_node_bound = _swiglpk.glp_ios_node_bound

def glp_ios_best_node(T):
    return _swiglpk.glp_ios_best_node(T)
glp_ios_best_node = _swiglpk.glp_ios_best_node

def glp_ios_mip_gap(T):
    return _swiglpk.glp_ios_mip_gap(T)
glp_ios_mip_gap = _swiglpk.glp_ios_mip_gap

def glp_ios_node_data(T, p):
    return _swiglpk.glp_ios_node_data(T, p)
glp_ios_node_data = _swiglpk.glp_ios_node_data

def glp_ios_row_attr(T, i, attr):
    return _swiglpk.glp_ios_row_attr(T, i, attr)
glp_ios_row_attr = _swiglpk.glp_ios_row_attr

def glp_ios_pool_size(T):
    return _swiglpk.glp_ios_pool_size(T)
glp_ios_pool_size = _swiglpk.glp_ios_pool_size

def glp_ios_add_row(T, name, klass, flags, len, ind, val, type, rhs):
    return _swiglpk.glp_ios_add_row(T, name, klass, flags, len, ind, val, type, rhs)
glp_ios_add_row = _swiglpk.glp_ios_add_row

def glp_ios_del_row(T, i):
    return _swiglpk.glp_ios_del_row(T, i)
glp_ios_del_row = _swiglpk.glp_ios_del_row

def glp_ios_clear_pool(T):
    return _swiglpk.glp_ios_clear_pool(T)
glp_ios_clear_pool = _swiglpk.glp_ios_clear_pool

def glp_ios_can_branch(T, j):
    return _swiglpk.glp_ios_can_branch(T, j)
glp_ios_can_branch = _swiglpk.glp_ios_can_branch

def glp_ios_branch_upon(T, j, sel):
    return _swiglpk.glp_ios_branch_upon(T, j, sel)
glp_ios_branch_upon = _swiglpk.glp_ios_branch_upon

def glp_ios_select_node(T, p):
    return _swiglpk.glp_ios_select_node(T, p)
glp_ios_select_node = _swiglpk.glp_ios_select_node

def glp_ios_heur_sol(T, x):
    return _swiglpk.glp_ios_heur_sol(T, x)
glp_ios_heur_sol = _swiglpk.glp_ios_heur_sol

def glp_ios_terminate(T):
    return _swiglpk.glp_ios_terminate(T)
glp_ios_terminate = _swiglpk.glp_ios_terminate

def glp_init_mpscp(parm):
    return _swiglpk.glp_init_mpscp(parm)
glp_init_mpscp = _swiglpk.glp_init_mpscp

def glp_read_mps(P, fmt, parm, fname):
    return _swiglpk.glp_read_mps(P, fmt, parm, fname)
glp_read_mps = _swiglpk.glp_read_mps

def glp_write_mps(P, fmt, parm, fname):
    return _swiglpk.glp_write_mps(P, fmt, parm, fname)
glp_write_mps = _swiglpk.glp_write_mps

def glp_init_cpxcp(parm):
    return _swiglpk.glp_init_cpxcp(parm)
glp_init_cpxcp = _swiglpk.glp_init_cpxcp

def glp_read_lp(P, parm, fname):
    return _swiglpk.glp_read_lp(P, parm, fname)
glp_read_lp = _swiglpk.glp_read_lp

def glp_write_lp(P, parm, fname):
    return _swiglpk.glp_write_lp(P, parm, fname)
glp_write_lp = _swiglpk.glp_write_lp

def glp_read_prob(P, flags, fname):
    return _swiglpk.glp_read_prob(P, flags, fname)
glp_read_prob = _swiglpk.glp_read_prob

def glp_write_prob(P, flags, fname):
    return _swiglpk.glp_write_prob(P, flags, fname)
glp_write_prob = _swiglpk.glp_write_prob

def glp_mpl_alloc_wksp():
    return _swiglpk.glp_mpl_alloc_wksp()
glp_mpl_alloc_wksp = _swiglpk.glp_mpl_alloc_wksp

def glp_mpl_init_rand(tran, seed):
    return _swiglpk.glp_mpl_init_rand(tran, seed)
glp_mpl_init_rand = _swiglpk.glp_mpl_init_rand

def glp_mpl_read_model(tran, fname, skip):
    return _swiglpk.glp_mpl_read_model(tran, fname, skip)
glp_mpl_read_model = _swiglpk.glp_mpl_read_model

def glp_mpl_read_data(tran, fname):
    return _swiglpk.glp_mpl_read_data(tran, fname)
glp_mpl_read_data = _swiglpk.glp_mpl_read_data

def glp_mpl_generate(tran, fname):
    return _swiglpk.glp_mpl_generate(tran, fname)
glp_mpl_generate = _swiglpk.glp_mpl_generate

def glp_mpl_build_prob(tran, prob):
    return _swiglpk.glp_mpl_build_prob(tran, prob)
glp_mpl_build_prob = _swiglpk.glp_mpl_build_prob

def glp_mpl_postsolve(tran, prob, sol):
    return _swiglpk.glp_mpl_postsolve(tran, prob, sol)
glp_mpl_postsolve = _swiglpk.glp_mpl_postsolve

def glp_mpl_free_wksp(tran):
    return _swiglpk.glp_mpl_free_wksp(tran)
glp_mpl_free_wksp = _swiglpk.glp_mpl_free_wksp

def glp_read_cnfsat(P, fname):
    return _swiglpk.glp_read_cnfsat(P, fname)
glp_read_cnfsat = _swiglpk.glp_read_cnfsat

def glp_check_cnfsat(P):
    return _swiglpk.glp_check_cnfsat(P)
glp_check_cnfsat = _swiglpk.glp_check_cnfsat

def glp_write_cnfsat(P, fname):
    return _swiglpk.glp_write_cnfsat(P, fname)
glp_write_cnfsat = _swiglpk.glp_write_cnfsat

def glp_minisat1(P):
    return _swiglpk.glp_minisat1(P)
glp_minisat1 = _swiglpk.glp_minisat1

def glp_intfeas1(P, use_bound, obj_bound):
    return _swiglpk.glp_intfeas1(P, use_bound, obj_bound)
glp_intfeas1 = _swiglpk.glp_intfeas1

def glp_init_env():
    return _swiglpk.glp_init_env()
glp_init_env = _swiglpk.glp_init_env

def glp_version():
    return _swiglpk.glp_version()
glp_version = _swiglpk.glp_version

def glp_config(option):
    return _swiglpk.glp_config(option)
glp_config = _swiglpk.glp_config

def glp_free_env():
    return _swiglpk.glp_free_env()
glp_free_env = _swiglpk.glp_free_env

def glp_puts(s):
    return _swiglpk.glp_puts(s)
glp_puts = _swiglpk.glp_puts

def glp_printf(fmt):
    return _swiglpk.glp_printf(fmt)
glp_printf = _swiglpk.glp_printf

def glp_term_out(flag):
    return _swiglpk.glp_term_out(flag)
glp_term_out = _swiglpk.glp_term_out

def glp_term_hook(*args):
    return _swiglpk.glp_term_hook(*args)
glp_term_hook = _swiglpk.glp_term_hook

def glp_open_tee(name):
    return _swiglpk.glp_open_tee(name)
glp_open_tee = _swiglpk.glp_open_tee

def glp_close_tee():
    return _swiglpk.glp_close_tee()
glp_close_tee = _swiglpk.glp_close_tee

def glp_error_(file, line):
    return _swiglpk.glp_error_(file, line)
glp_error_ = _swiglpk.glp_error_

def glp_at_error():
    return _swiglpk.glp_at_error()
glp_at_error = _swiglpk.glp_at_error

def glp_assert_(expr, file, line):
    return _swiglpk.glp_assert_(expr, file, line)
glp_assert_ = _swiglpk.glp_assert_

def glp_error_hook(func, info):
    return _swiglpk.glp_error_hook(func, info)
glp_error_hook = _swiglpk.glp_error_hook

def glp_alloc(n, size):
    return _swiglpk.glp_alloc(n, size)
glp_alloc = _swiglpk.glp_alloc

def glp_realloc(ptr, n, size):
    return _swiglpk.glp_realloc(ptr, n, size)
glp_realloc = _swiglpk.glp_realloc

def glp_free(ptr):
    return _swiglpk.glp_free(ptr)
glp_free = _swiglpk.glp_free

def glp_mem_limit(limit):
    return _swiglpk.glp_mem_limit(limit)
glp_mem_limit = _swiglpk.glp_mem_limit

def glp_mem_usage(count, cpeak, total, tpeak):
    return _swiglpk.glp_mem_usage(count, cpeak, total, tpeak)
glp_mem_usage = _swiglpk.glp_mem_usage

def glp_time():
    return _swiglpk.glp_time()
glp_time = _swiglpk.glp_time

def glp_difftime(t1, t0):
    return _swiglpk.glp_difftime(t1, t0)
glp_difftime = _swiglpk.glp_difftime
class glp_graph(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_graph, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_graph, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pool"] = _swiglpk.glp_graph_pool_set
    __swig_getmethods__["pool"] = _swiglpk.glp_graph_pool_get
    if _newclass:
        pool = _swig_property(_swiglpk.glp_graph_pool_get, _swiglpk.glp_graph_pool_set)
    __swig_setmethods__["name"] = _swiglpk.glp_graph_name_set
    __swig_getmethods__["name"] = _swiglpk.glp_graph_name_get
    if _newclass:
        name = _swig_property(_swiglpk.glp_graph_name_get, _swiglpk.glp_graph_name_set)
    __swig_setmethods__["nv_max"] = _swiglpk.glp_graph_nv_max_set
    __swig_getmethods__["nv_max"] = _swiglpk.glp_graph_nv_max_get
    if _newclass:
        nv_max = _swig_property(_swiglpk.glp_graph_nv_max_get, _swiglpk.glp_graph_nv_max_set)
    __swig_setmethods__["nv"] = _swiglpk.glp_graph_nv_set
    __swig_getmethods__["nv"] = _swiglpk.glp_graph_nv_get
    if _newclass:
        nv = _swig_property(_swiglpk.glp_graph_nv_get, _swiglpk.glp_graph_nv_set)
    __swig_setmethods__["na"] = _swiglpk.glp_graph_na_set
    __swig_getmethods__["na"] = _swiglpk.glp_graph_na_get
    if _newclass:
        na = _swig_property(_swiglpk.glp_graph_na_get, _swiglpk.glp_graph_na_set)
    __swig_setmethods__["v"] = _swiglpk.glp_graph_v_set
    __swig_getmethods__["v"] = _swiglpk.glp_graph_v_get
    if _newclass:
        v = _swig_property(_swiglpk.glp_graph_v_get, _swiglpk.glp_graph_v_set)
    __swig_setmethods__["index"] = _swiglpk.glp_graph_index_set
    __swig_getmethods__["index"] = _swiglpk.glp_graph_index_get
    if _newclass:
        index = _swig_property(_swiglpk.glp_graph_index_get, _swiglpk.glp_graph_index_set)
    __swig_setmethods__["v_size"] = _swiglpk.glp_graph_v_size_set
    __swig_getmethods__["v_size"] = _swiglpk.glp_graph_v_size_get
    if _newclass:
        v_size = _swig_property(_swiglpk.glp_graph_v_size_get, _swiglpk.glp_graph_v_size_set)
    __swig_setmethods__["a_size"] = _swiglpk.glp_graph_a_size_set
    __swig_getmethods__["a_size"] = _swiglpk.glp_graph_a_size_get
    if _newclass:
        a_size = _swig_property(_swiglpk.glp_graph_a_size_get, _swiglpk.glp_graph_a_size_set)

    def __init__(self):
        this = _swiglpk.new_glp_graph()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_graph
    __del__ = lambda self: None
glp_graph_swigregister = _swiglpk.glp_graph_swigregister
glp_graph_swigregister(glp_graph)

class glp_vertex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_vertex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_vertex, name)
    __repr__ = _swig_repr
    __swig_setmethods__["i"] = _swiglpk.glp_vertex_i_set
    __swig_getmethods__["i"] = _swiglpk.glp_vertex_i_get
    if _newclass:
        i = _swig_property(_swiglpk.glp_vertex_i_get, _swiglpk.glp_vertex_i_set)
    __swig_setmethods__["name"] = _swiglpk.glp_vertex_name_set
    __swig_getmethods__["name"] = _swiglpk.glp_vertex_name_get
    if _newclass:
        name = _swig_property(_swiglpk.glp_vertex_name_get, _swiglpk.glp_vertex_name_set)
    __swig_setmethods__["entry"] = _swiglpk.glp_vertex_entry_set
    __swig_getmethods__["entry"] = _swiglpk.glp_vertex_entry_get
    if _newclass:
        entry = _swig_property(_swiglpk.glp_vertex_entry_get, _swiglpk.glp_vertex_entry_set)
    __swig_setmethods__["data"] = _swiglpk.glp_vertex_data_set
    __swig_getmethods__["data"] = _swiglpk.glp_vertex_data_get
    if _newclass:
        data = _swig_property(_swiglpk.glp_vertex_data_get, _swiglpk.glp_vertex_data_set)
    __swig_setmethods__["temp"] = _swiglpk.glp_vertex_temp_set
    __swig_getmethods__["temp"] = _swiglpk.glp_vertex_temp_get
    if _newclass:
        temp = _swig_property(_swiglpk.glp_vertex_temp_get, _swiglpk.glp_vertex_temp_set)
    __swig_setmethods__["_in"] = _swiglpk.glp_vertex__in_set
    __swig_getmethods__["_in"] = _swiglpk.glp_vertex__in_get
    if _newclass:
        _in = _swig_property(_swiglpk.glp_vertex__in_get, _swiglpk.glp_vertex__in_set)
    __swig_setmethods__["out"] = _swiglpk.glp_vertex_out_set
    __swig_getmethods__["out"] = _swiglpk.glp_vertex_out_get
    if _newclass:
        out = _swig_property(_swiglpk.glp_vertex_out_get, _swiglpk.glp_vertex_out_set)

    def __init__(self):
        this = _swiglpk.new_glp_vertex()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_vertex
    __del__ = lambda self: None
glp_vertex_swigregister = _swiglpk.glp_vertex_swigregister
glp_vertex_swigregister(glp_vertex)

class glp_arc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, glp_arc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, glp_arc, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tail"] = _swiglpk.glp_arc_tail_set
    __swig_getmethods__["tail"] = _swiglpk.glp_arc_tail_get
    if _newclass:
        tail = _swig_property(_swiglpk.glp_arc_tail_get, _swiglpk.glp_arc_tail_set)
    __swig_setmethods__["head"] = _swiglpk.glp_arc_head_set
    __swig_getmethods__["head"] = _swiglpk.glp_arc_head_get
    if _newclass:
        head = _swig_property(_swiglpk.glp_arc_head_get, _swiglpk.glp_arc_head_set)
    __swig_setmethods__["data"] = _swiglpk.glp_arc_data_set
    __swig_getmethods__["data"] = _swiglpk.glp_arc_data_get
    if _newclass:
        data = _swig_property(_swiglpk.glp_arc_data_get, _swiglpk.glp_arc_data_set)
    __swig_setmethods__["temp"] = _swiglpk.glp_arc_temp_set
    __swig_getmethods__["temp"] = _swiglpk.glp_arc_temp_get
    if _newclass:
        temp = _swig_property(_swiglpk.glp_arc_temp_get, _swiglpk.glp_arc_temp_set)
    __swig_setmethods__["t_prev"] = _swiglpk.glp_arc_t_prev_set
    __swig_getmethods__["t_prev"] = _swiglpk.glp_arc_t_prev_get
    if _newclass:
        t_prev = _swig_property(_swiglpk.glp_arc_t_prev_get, _swiglpk.glp_arc_t_prev_set)
    __swig_setmethods__["t_next"] = _swiglpk.glp_arc_t_next_set
    __swig_getmethods__["t_next"] = _swiglpk.glp_arc_t_next_get
    if _newclass:
        t_next = _swig_property(_swiglpk.glp_arc_t_next_get, _swiglpk.glp_arc_t_next_set)
    __swig_setmethods__["h_prev"] = _swiglpk.glp_arc_h_prev_set
    __swig_getmethods__["h_prev"] = _swiglpk.glp_arc_h_prev_get
    if _newclass:
        h_prev = _swig_property(_swiglpk.glp_arc_h_prev_get, _swiglpk.glp_arc_h_prev_set)
    __swig_setmethods__["h_next"] = _swiglpk.glp_arc_h_next_set
    __swig_getmethods__["h_next"] = _swiglpk.glp_arc_h_next_get
    if _newclass:
        h_next = _swig_property(_swiglpk.glp_arc_h_next_get, _swiglpk.glp_arc_h_next_set)

    def __init__(self):
        this = _swiglpk.new_glp_arc()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_glp_arc
    __del__ = lambda self: None
glp_arc_swigregister = _swiglpk.glp_arc_swigregister
glp_arc_swigregister(glp_arc)


def glp_create_graph(v_size, a_size):
    return _swiglpk.glp_create_graph(v_size, a_size)
glp_create_graph = _swiglpk.glp_create_graph

def glp_set_graph_name(G, name):
    return _swiglpk.glp_set_graph_name(G, name)
glp_set_graph_name = _swiglpk.glp_set_graph_name

def glp_add_vertices(G, nadd):
    return _swiglpk.glp_add_vertices(G, nadd)
glp_add_vertices = _swiglpk.glp_add_vertices

def glp_set_vertex_name(G, i, name):
    return _swiglpk.glp_set_vertex_name(G, i, name)
glp_set_vertex_name = _swiglpk.glp_set_vertex_name

def glp_add_arc(G, i, j):
    return _swiglpk.glp_add_arc(G, i, j)
glp_add_arc = _swiglpk.glp_add_arc

def glp_del_vertices(G, ndel, num):
    return _swiglpk.glp_del_vertices(G, ndel, num)
glp_del_vertices = _swiglpk.glp_del_vertices

def glp_del_arc(G, a):
    return _swiglpk.glp_del_arc(G, a)
glp_del_arc = _swiglpk.glp_del_arc

def glp_erase_graph(G, v_size, a_size):
    return _swiglpk.glp_erase_graph(G, v_size, a_size)
glp_erase_graph = _swiglpk.glp_erase_graph

def glp_delete_graph(G):
    return _swiglpk.glp_delete_graph(G)
glp_delete_graph = _swiglpk.glp_delete_graph

def glp_create_v_index(G):
    return _swiglpk.glp_create_v_index(G)
glp_create_v_index = _swiglpk.glp_create_v_index

def glp_find_vertex(G, name):
    return _swiglpk.glp_find_vertex(G, name)
glp_find_vertex = _swiglpk.glp_find_vertex

def glp_delete_v_index(G):
    return _swiglpk.glp_delete_v_index(G)
glp_delete_v_index = _swiglpk.glp_delete_v_index

def glp_read_graph(G, fname):
    return _swiglpk.glp_read_graph(G, fname)
glp_read_graph = _swiglpk.glp_read_graph

def glp_write_graph(G, fname):
    return _swiglpk.glp_write_graph(G, fname)
glp_write_graph = _swiglpk.glp_write_graph

def glp_mincost_lp(P, G, names, v_rhs, a_low, a_cap, a_cost):
    return _swiglpk.glp_mincost_lp(P, G, names, v_rhs, a_low, a_cap, a_cost)
glp_mincost_lp = _swiglpk.glp_mincost_lp

def glp_mincost_okalg(G, v_rhs, a_low, a_cap, a_cost, sol, a_x, v_pi):
    return _swiglpk.glp_mincost_okalg(G, v_rhs, a_low, a_cap, a_cost, sol, a_x, v_pi)
glp_mincost_okalg = _swiglpk.glp_mincost_okalg

def glp_mincost_relax4(G, v_rhs, a_low, a_cap, a_cost, crash, sol, a_x, a_rc):
    return _swiglpk.glp_mincost_relax4(G, v_rhs, a_low, a_cap, a_cost, crash, sol, a_x, a_rc)
glp_mincost_relax4 = _swiglpk.glp_mincost_relax4

def glp_maxflow_lp(P, G, names, s, t, a_cap):
    return _swiglpk.glp_maxflow_lp(P, G, names, s, t, a_cap)
glp_maxflow_lp = _swiglpk.glp_maxflow_lp

def glp_maxflow_ffalg(G, s, t, a_cap, sol, a_x, v_cut):
    return _swiglpk.glp_maxflow_ffalg(G, s, t, a_cap, sol, a_x, v_cut)
glp_maxflow_ffalg = _swiglpk.glp_maxflow_ffalg

def glp_check_asnprob(G, v_set):
    return _swiglpk.glp_check_asnprob(G, v_set)
glp_check_asnprob = _swiglpk.glp_check_asnprob
GLP_ASN_MIN = _swiglpk.GLP_ASN_MIN
GLP_ASN_MAX = _swiglpk.GLP_ASN_MAX
GLP_ASN_MMP = _swiglpk.GLP_ASN_MMP

def glp_asnprob_lp(P, form, G, names, v_set, a_cost):
    return _swiglpk.glp_asnprob_lp(P, form, G, names, v_set, a_cost)
glp_asnprob_lp = _swiglpk.glp_asnprob_lp

def glp_asnprob_okalg(form, G, v_set, a_cost, sol, a_x):
    return _swiglpk.glp_asnprob_okalg(form, G, v_set, a_cost, sol, a_x)
glp_asnprob_okalg = _swiglpk.glp_asnprob_okalg

def glp_asnprob_hall(G, v_set, a_x):
    return _swiglpk.glp_asnprob_hall(G, v_set, a_x)
glp_asnprob_hall = _swiglpk.glp_asnprob_hall

def glp_cpp(G, v_t, v_es, v_ls):
    return _swiglpk.glp_cpp(G, v_t, v_es, v_ls)
glp_cpp = _swiglpk.glp_cpp

def glp_read_mincost(G, v_rhs, a_low, a_cap, a_cost, fname):
    return _swiglpk.glp_read_mincost(G, v_rhs, a_low, a_cap, a_cost, fname)
glp_read_mincost = _swiglpk.glp_read_mincost

def glp_write_mincost(G, v_rhs, a_low, a_cap, a_cost, fname):
    return _swiglpk.glp_write_mincost(G, v_rhs, a_low, a_cap, a_cost, fname)
glp_write_mincost = _swiglpk.glp_write_mincost

def glp_read_maxflow(G, s, t, a_cap, fname):
    return _swiglpk.glp_read_maxflow(G, s, t, a_cap, fname)
glp_read_maxflow = _swiglpk.glp_read_maxflow

def glp_write_maxflow(G, s, t, a_cap, fname):
    return _swiglpk.glp_write_maxflow(G, s, t, a_cap, fname)
glp_write_maxflow = _swiglpk.glp_write_maxflow

def glp_read_asnprob(G, v_set, a_cost, fname):
    return _swiglpk.glp_read_asnprob(G, v_set, a_cost, fname)
glp_read_asnprob = _swiglpk.glp_read_asnprob

def glp_write_asnprob(G, v_set, a_cost, fname):
    return _swiglpk.glp_write_asnprob(G, v_set, a_cost, fname)
glp_write_asnprob = _swiglpk.glp_write_asnprob

def glp_read_ccdata(G, v_wgt, fname):
    return _swiglpk.glp_read_ccdata(G, v_wgt, fname)
glp_read_ccdata = _swiglpk.glp_read_ccdata

def glp_write_ccdata(G, v_wgt, fname):
    return _swiglpk.glp_write_ccdata(G, v_wgt, fname)
glp_write_ccdata = _swiglpk.glp_write_ccdata

def glp_netgen(G, v_rhs, a_cap, a_cost, parm):
    return _swiglpk.glp_netgen(G, v_rhs, a_cap, a_cost, parm)
glp_netgen = _swiglpk.glp_netgen

def glp_netgen_prob(nprob, parm):
    return _swiglpk.glp_netgen_prob(nprob, parm)
glp_netgen_prob = _swiglpk.glp_netgen_prob

def glp_gridgen(G, v_rhs, a_cap, a_cost, parm):
    return _swiglpk.glp_gridgen(G, v_rhs, a_cap, a_cost, parm)
glp_gridgen = _swiglpk.glp_gridgen

def glp_rmfgen(G, s, t, a_cap, parm):
    return _swiglpk.glp_rmfgen(G, s, t, a_cap, parm)
glp_rmfgen = _swiglpk.glp_rmfgen

def glp_weak_comp(G, v_num):
    return _swiglpk.glp_weak_comp(G, v_num)
glp_weak_comp = _swiglpk.glp_weak_comp

def glp_strong_comp(G, v_num):
    return _swiglpk.glp_strong_comp(G, v_num)
glp_strong_comp = _swiglpk.glp_strong_comp

def glp_top_sort(G, v_num):
    return _swiglpk.glp_top_sort(G, v_num)
glp_top_sort = _swiglpk.glp_top_sort

def glp_wclique_exact(G, v_wgt, sol, v_set):
    return _swiglpk.glp_wclique_exact(G, v_wgt, sol, v_set)
glp_wclique_exact = _swiglpk.glp_wclique_exact
class intArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, intArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, intArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _swiglpk.new_intArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_intArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _swiglpk.intArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _swiglpk.intArray___setitem__(self, index, value)

    def cast(self):
        return _swiglpk.intArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_swiglpk.intArray_frompointer)
    else:
        frompointer = _swiglpk.intArray_frompointer
intArray_swigregister = _swiglpk.intArray_swigregister
intArray_swigregister(intArray)

def intArray_frompointer(t):
    return _swiglpk.intArray_frompointer(t)
intArray_frompointer = _swiglpk.intArray_frompointer

class doubleArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doubleArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doubleArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _swiglpk.new_doubleArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swiglpk.delete_doubleArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _swiglpk.doubleArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _swiglpk.doubleArray___setitem__(self, index, value)

    def cast(self):
        return _swiglpk.doubleArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_swiglpk.doubleArray_frompointer)
    else:
        frompointer = _swiglpk.doubleArray_frompointer
doubleArray_swigregister = _swiglpk.doubleArray_swigregister
doubleArray_swigregister(doubleArray)

def doubleArray_frompointer(t):
    return _swiglpk.doubleArray_frompointer(t)
doubleArray_frompointer = _swiglpk.doubleArray_frompointer


def get_col_primals(P):
    return _swiglpk.get_col_primals(P)
get_col_primals = _swiglpk.get_col_primals

def get_col_duals(P):
    return _swiglpk.get_col_duals(P)
get_col_duals = _swiglpk.get_col_duals

def get_row_primals(P):
    return _swiglpk.get_row_primals(P)
get_row_primals = _swiglpk.get_row_primals

def get_row_duals(P):
    return _swiglpk.get_row_duals(P)
get_row_duals = _swiglpk.get_row_duals

def as_intArray(list):
    return _swiglpk.as_intArray(list)
as_intArray = _swiglpk.as_intArray

def as_doubleArray(list):
    return _swiglpk.as_doubleArray(list)
as_doubleArray = _swiglpk.as_doubleArray
# This file is compatible with both classic and new-style classes.


