# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _swiglpk
else:
    import _swiglpk

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    msg_lev = property(_swiglpk.glp_bfcp_msg_lev_get, _swiglpk.glp_bfcp_msg_lev_set)
    type = property(_swiglpk.glp_bfcp_type_get, _swiglpk.glp_bfcp_type_set)
    lu_size = property(_swiglpk.glp_bfcp_lu_size_get, _swiglpk.glp_bfcp_lu_size_set)
    piv_tol = property(_swiglpk.glp_bfcp_piv_tol_get, _swiglpk.glp_bfcp_piv_tol_set)
    piv_lim = property(_swiglpk.glp_bfcp_piv_lim_get, _swiglpk.glp_bfcp_piv_lim_set)
    suhl = property(_swiglpk.glp_bfcp_suhl_get, _swiglpk.glp_bfcp_suhl_set)
    eps_tol = property(_swiglpk.glp_bfcp_eps_tol_get, _swiglpk.glp_bfcp_eps_tol_set)
    max_gro = property(_swiglpk.glp_bfcp_max_gro_get, _swiglpk.glp_bfcp_max_gro_set)
    nfs_max = property(_swiglpk.glp_bfcp_nfs_max_get, _swiglpk.glp_bfcp_nfs_max_set)
    upd_tol = property(_swiglpk.glp_bfcp_upd_tol_get, _swiglpk.glp_bfcp_upd_tol_set)
    nrs_max = property(_swiglpk.glp_bfcp_nrs_max_get, _swiglpk.glp_bfcp_nrs_max_set)
    rs_size = property(_swiglpk.glp_bfcp_rs_size_get, _swiglpk.glp_bfcp_rs_size_set)
    foo_bar = property(_swiglpk.glp_bfcp_foo_bar_get, _swiglpk.glp_bfcp_foo_bar_set)

    def __init__(self):
        _swiglpk.glp_bfcp_swiginit(self, _swiglpk.new_glp_bfcp())
    __swig_destroy__ = _swiglpk.delete_glp_bfcp

# Register glp_bfcp in _swiglpk:
_swiglpk.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    msg_lev = property(_swiglpk.glp_smcp_msg_lev_get, _swiglpk.glp_smcp_msg_lev_set)
    meth = property(_swiglpk.glp_smcp_meth_get, _swiglpk.glp_smcp_meth_set)
    pricing = property(_swiglpk.glp_smcp_pricing_get, _swiglpk.glp_smcp_pricing_set)
    r_test = property(_swiglpk.glp_smcp_r_test_get, _swiglpk.glp_smcp_r_test_set)
    tol_bnd = property(_swiglpk.glp_smcp_tol_bnd_get, _swiglpk.glp_smcp_tol_bnd_set)
    tol_dj = property(_swiglpk.glp_smcp_tol_dj_get, _swiglpk.glp_smcp_tol_dj_set)
    tol_piv = property(_swiglpk.glp_smcp_tol_piv_get, _swiglpk.glp_smcp_tol_piv_set)
    obj_ll = property(_swiglpk.glp_smcp_obj_ll_get, _swiglpk.glp_smcp_obj_ll_set)
    obj_ul = property(_swiglpk.glp_smcp_obj_ul_get, _swiglpk.glp_smcp_obj_ul_set)
    it_lim = property(_swiglpk.glp_smcp_it_lim_get, _swiglpk.glp_smcp_it_lim_set)
    tm_lim = property(_swiglpk.glp_smcp_tm_lim_get, _swiglpk.glp_smcp_tm_lim_set)
    out_frq = property(_swiglpk.glp_smcp_out_frq_get, _swiglpk.glp_smcp_out_frq_set)
    out_dly = property(_swiglpk.glp_smcp_out_dly_get, _swiglpk.glp_smcp_out_dly_set)
    presolve = property(_swiglpk.glp_smcp_presolve_get, _swiglpk.glp_smcp_presolve_set)
    excl = property(_swiglpk.glp_smcp_excl_get, _swiglpk.glp_smcp_excl_set)
    shift = property(_swiglpk.glp_smcp_shift_get, _swiglpk.glp_smcp_shift_set)
    aorn = property(_swiglpk.glp_smcp_aorn_get, _swiglpk.glp_smcp_aorn_set)
    foo_bar = property(_swiglpk.glp_smcp_foo_bar_get, _swiglpk.glp_smcp_foo_bar_set)

    def __init__(self):
        _swiglpk.glp_smcp_swiginit(self, _swiglpk.new_glp_smcp())
    __swig_destroy__ = _swiglpk.delete_glp_smcp

# Register glp_smcp in _swiglpk:
_swiglpk.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
GLP_USE_AT = _swiglpk.GLP_USE_AT
GLP_USE_NT = _swiglpk.GLP_USE_NT

class glp_iptcp(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    msg_lev = property(_swiglpk.glp_iptcp_msg_lev_get, _swiglpk.glp_iptcp_msg_lev_set)
    ord_alg = property(_swiglpk.glp_iptcp_ord_alg_get, _swiglpk.glp_iptcp_ord_alg_set)
    foo_bar = property(_swiglpk.glp_iptcp_foo_bar_get, _swiglpk.glp_iptcp_foo_bar_set)

    def __init__(self):
        _swiglpk.glp_iptcp_swiginit(self, _swiglpk.new_glp_iptcp())
    __swig_destroy__ = _swiglpk.delete_glp_iptcp

# Register glp_iptcp in _swiglpk:
_swiglpk.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    msg_lev = property(_swiglpk.glp_iocp_msg_lev_get, _swiglpk.glp_iocp_msg_lev_set)
    br_tech = property(_swiglpk.glp_iocp_br_tech_get, _swiglpk.glp_iocp_br_tech_set)
    bt_tech = property(_swiglpk.glp_iocp_bt_tech_get, _swiglpk.glp_iocp_bt_tech_set)
    tol_int = property(_swiglpk.glp_iocp_tol_int_get, _swiglpk.glp_iocp_tol_int_set)
    tol_obj = property(_swiglpk.glp_iocp_tol_obj_get, _swiglpk.glp_iocp_tol_obj_set)
    tm_lim = property(_swiglpk.glp_iocp_tm_lim_get, _swiglpk.glp_iocp_tm_lim_set)
    out_frq = property(_swiglpk.glp_iocp_out_frq_get, _swiglpk.glp_iocp_out_frq_set)
    out_dly = property(_swiglpk.glp_iocp_out_dly_get, _swiglpk.glp_iocp_out_dly_set)
    cb_func = property(_swiglpk.glp_iocp_cb_func_get, _swiglpk.glp_iocp_cb_func_set)
    cb_info = property(_swiglpk.glp_iocp_cb_info_get, _swiglpk.glp_iocp_cb_info_set)
    cb_size = property(_swiglpk.glp_iocp_cb_size_get, _swiglpk.glp_iocp_cb_size_set)
    pp_tech = property(_swiglpk.glp_iocp_pp_tech_get, _swiglpk.glp_iocp_pp_tech_set)
    mip_gap = property(_swiglpk.glp_iocp_mip_gap_get, _swiglpk.glp_iocp_mip_gap_set)
    mir_cuts = property(_swiglpk.glp_iocp_mir_cuts_get, _swiglpk.glp_iocp_mir_cuts_set)
    gmi_cuts = property(_swiglpk.glp_iocp_gmi_cuts_get, _swiglpk.glp_iocp_gmi_cuts_set)
    cov_cuts = property(_swiglpk.glp_iocp_cov_cuts_get, _swiglpk.glp_iocp_cov_cuts_set)
    clq_cuts = property(_swiglpk.glp_iocp_clq_cuts_get, _swiglpk.glp_iocp_clq_cuts_set)
    presolve = property(_swiglpk.glp_iocp_presolve_get, _swiglpk.glp_iocp_presolve_set)
    binarize = property(_swiglpk.glp_iocp_binarize_get, _swiglpk.glp_iocp_binarize_set)
    fp_heur = property(_swiglpk.glp_iocp_fp_heur_get, _swiglpk.glp_iocp_fp_heur_set)
    ps_heur = property(_swiglpk.glp_iocp_ps_heur_get, _swiglpk.glp_iocp_ps_heur_set)
    ps_tm_lim = property(_swiglpk.glp_iocp_ps_tm_lim_get, _swiglpk.glp_iocp_ps_tm_lim_set)
    sr_heur = property(_swiglpk.glp_iocp_sr_heur_get, _swiglpk.glp_iocp_sr_heur_set)
    use_sol = property(_swiglpk.glp_iocp_use_sol_get, _swiglpk.glp_iocp_use_sol_set)
    save_sol = property(_swiglpk.glp_iocp_save_sol_get, _swiglpk.glp_iocp_save_sol_set)
    alien = property(_swiglpk.glp_iocp_alien_get, _swiglpk.glp_iocp_alien_set)
    flip = property(_swiglpk.glp_iocp_flip_get, _swiglpk.glp_iocp_flip_set)
    foo_bar = property(_swiglpk.glp_iocp_foo_bar_get, _swiglpk.glp_iocp_foo_bar_set)

    def __init__(self):
        _swiglpk.glp_iocp_swiginit(self, _swiglpk.new_glp_iocp())
    __swig_destroy__ = _swiglpk.delete_glp_iocp

# Register glp_iocp in _swiglpk:
_swiglpk.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    level = property(_swiglpk.glp_attr_level_get, _swiglpk.glp_attr_level_set)
    origin = property(_swiglpk.glp_attr_origin_get, _swiglpk.glp_attr_origin_set)
    klass = property(_swiglpk.glp_attr_klass_get, _swiglpk.glp_attr_klass_set)
    foo_bar = property(_swiglpk.glp_attr_foo_bar_get, _swiglpk.glp_attr_foo_bar_set)

    def __init__(self):
        _swiglpk.glp_attr_swiginit(self, _swiglpk.new_glp_attr())
    __swig_destroy__ = _swiglpk.delete_glp_attr

# Register glp_attr in _swiglpk:
_swiglpk.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    blank = property(_swiglpk.glp_mpscp_blank_get, _swiglpk.glp_mpscp_blank_set)
    obj_name = property(_swiglpk.glp_mpscp_obj_name_get, _swiglpk.glp_mpscp_obj_name_set)
    tol_mps = property(_swiglpk.glp_mpscp_tol_mps_get, _swiglpk.glp_mpscp_tol_mps_set)
    foo_bar = property(_swiglpk.glp_mpscp_foo_bar_get, _swiglpk.glp_mpscp_foo_bar_set)

    def __init__(self):
        _swiglpk.glp_mpscp_swiginit(self, _swiglpk.new_glp_mpscp())
    __swig_destroy__ = _swiglpk.delete_glp_mpscp

# Register glp_mpscp in _swiglpk:
_swiglpk.glp_mpscp_swigregister(glp_mpscp)

class glp_cpxcp(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    foo_bar = property(_swiglpk.glp_cpxcp_foo_bar_get, _swiglpk.glp_cpxcp_foo_bar_set)

    def __init__(self):
        _swiglpk.glp_cpxcp_swiginit(self, _swiglpk.new_glp_cpxcp())
    __swig_destroy__ = _swiglpk.delete_glp_cpxcp

# Register glp_cpxcp in _swiglpk:
_swiglpk.glp_cpxcp_swigregister(glp_cpxcp)


def glp_create_prob():
    return _swiglpk.glp_create_prob()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

def glp_npp_alloc_wksp():
    return _swiglpk.glp_npp_alloc_wksp()

def glp_npp_load_prob(prep, P, sol, names):
    return _swiglpk.glp_npp_load_prob(prep, P, sol, names)

def glp_npp_preprocess1(prep, hard):
    return _swiglpk.glp_npp_preprocess1(prep, hard)

def glp_npp_build_prob(prep, Q):
    return _swiglpk.glp_npp_build_prob(prep, Q)

def glp_npp_postprocess(prep, Q):
    return _swiglpk.glp_npp_postprocess(prep, Q)

def glp_npp_obtain_sol(prep, P):
    return _swiglpk.glp_npp_obtain_sol(prep, P)

def glp_npp_free_wksp(prep):
    return _swiglpk.glp_npp_free_wksp(prep)

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def glp_mpl_alloc_wksp():
    return _swiglpk.glp_mpl_alloc_wksp()

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

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

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

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

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

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

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

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

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

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

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

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

def glp_init_env():
    return _swiglpk.glp_init_env()

def glp_version():
    return _swiglpk.glp_version()

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

def glp_free_env():
    return _swiglpk.glp_free_env()

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

def glp_printf(*args):
    return _swiglpk.glp_printf(*args)

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

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

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

def glp_close_tee():
    return _swiglpk.glp_close_tee()

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

def glp_at_error():
    return _swiglpk.glp_at_error()

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

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

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

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

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

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

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

def glp_time():
    return _swiglpk.glp_time()

def glp_difftime(t1, t0):
    return _swiglpk.glp_difftime(t1, t0)
class glp_graph(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    pool = property(_swiglpk.glp_graph_pool_get, _swiglpk.glp_graph_pool_set)
    name = property(_swiglpk.glp_graph_name_get, _swiglpk.glp_graph_name_set)
    nv_max = property(_swiglpk.glp_graph_nv_max_get, _swiglpk.glp_graph_nv_max_set)
    nv = property(_swiglpk.glp_graph_nv_get, _swiglpk.glp_graph_nv_set)
    na = property(_swiglpk.glp_graph_na_get, _swiglpk.glp_graph_na_set)
    v = property(_swiglpk.glp_graph_v_get, _swiglpk.glp_graph_v_set)
    index = property(_swiglpk.glp_graph_index_get, _swiglpk.glp_graph_index_set)
    v_size = property(_swiglpk.glp_graph_v_size_get, _swiglpk.glp_graph_v_size_set)
    a_size = property(_swiglpk.glp_graph_a_size_get, _swiglpk.glp_graph_a_size_set)

    def __init__(self):
        _swiglpk.glp_graph_swiginit(self, _swiglpk.new_glp_graph())
    __swig_destroy__ = _swiglpk.delete_glp_graph

# Register glp_graph in _swiglpk:
_swiglpk.glp_graph_swigregister(glp_graph)

class glp_vertex(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    i = property(_swiglpk.glp_vertex_i_get, _swiglpk.glp_vertex_i_set)
    name = property(_swiglpk.glp_vertex_name_get, _swiglpk.glp_vertex_name_set)
    entry = property(_swiglpk.glp_vertex_entry_get, _swiglpk.glp_vertex_entry_set)
    data = property(_swiglpk.glp_vertex_data_get, _swiglpk.glp_vertex_data_set)
    temp = property(_swiglpk.glp_vertex_temp_get, _swiglpk.glp_vertex_temp_set)
    _in = property(_swiglpk.glp_vertex__in_get, _swiglpk.glp_vertex__in_set)
    out = property(_swiglpk.glp_vertex_out_get, _swiglpk.glp_vertex_out_set)

    def __init__(self):
        _swiglpk.glp_vertex_swiginit(self, _swiglpk.new_glp_vertex())
    __swig_destroy__ = _swiglpk.delete_glp_vertex

# Register glp_vertex in _swiglpk:
_swiglpk.glp_vertex_swigregister(glp_vertex)

class glp_arc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    tail = property(_swiglpk.glp_arc_tail_get, _swiglpk.glp_arc_tail_set)
    head = property(_swiglpk.glp_arc_head_get, _swiglpk.glp_arc_head_set)
    data = property(_swiglpk.glp_arc_data_get, _swiglpk.glp_arc_data_set)
    temp = property(_swiglpk.glp_arc_temp_get, _swiglpk.glp_arc_temp_set)
    t_prev = property(_swiglpk.glp_arc_t_prev_get, _swiglpk.glp_arc_t_prev_set)
    t_next = property(_swiglpk.glp_arc_t_next_get, _swiglpk.glp_arc_t_next_set)
    h_prev = property(_swiglpk.glp_arc_h_prev_get, _swiglpk.glp_arc_h_prev_set)
    h_next = property(_swiglpk.glp_arc_h_next_get, _swiglpk.glp_arc_h_next_set)

    def __init__(self):
        _swiglpk.glp_arc_swiginit(self, _swiglpk.new_glp_arc())
    __swig_destroy__ = _swiglpk.delete_glp_arc

# Register glp_arc in _swiglpk:
_swiglpk.glp_arc_swigregister(glp_arc)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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)

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)

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

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)

def glp_check_asnprob(G, v_set):
    return _swiglpk.glp_check_asnprob(G, v_set)
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)

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)

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

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

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)

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)

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

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

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

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

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

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

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

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

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

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

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

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

def glp_wclique_exact(G, v_wgt, sol, v_set):
    return _swiglpk.glp_wclique_exact(G, v_wgt, sol, v_set)
class intArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _swiglpk.intArray_swiginit(self, _swiglpk.new_intArray(nelements))
    __swig_destroy__ = _swiglpk.delete_intArray

    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)

    @staticmethod
    def frompointer(t):
        return _swiglpk.intArray_frompointer(t)

# Register intArray in _swiglpk:
_swiglpk.intArray_swigregister(intArray)

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

class doubleArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _swiglpk.doubleArray_swiginit(self, _swiglpk.new_doubleArray(nelements))
    __swig_destroy__ = _swiglpk.delete_doubleArray

    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)

    @staticmethod
    def frompointer(t):
        return _swiglpk.doubleArray_frompointer(t)

# Register doubleArray in _swiglpk:
_swiglpk.doubleArray_swigregister(doubleArray)

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


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

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

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

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

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

def as_doubleArray(list):
    return _swiglpk.as_doubleArray(list)


