GLPK.cs

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

namespace org.gnu.glpk {

public class GLPK {
  
public static SWIGTYPE_p_double new_doubleArray(int nelements) {
    global::System.IntPtr cPtr = GLPKPINVOKE.new_doubleArray(nelements);
    SWIGTYPE_p_double ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_double(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void delete_doubleArray(SWIGTYPE_p_double ary) {
    GLPKPINVOKE.delete_doubleArray(SWIGTYPE_p_double.getCPtr(ary));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static double doubleArray_getitem(SWIGTYPE_p_double ary, int index) {
    double ret = GLPKPINVOKE.doubleArray_getitem(SWIGTYPE_p_double.getCPtr(ary), index);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void doubleArray_setitem(SWIGTYPE_p_double ary, int index, double value) {
    GLPKPINVOKE.doubleArray_setitem(SWIGTYPE_p_double.getCPtr(ary), index, value);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static SWIGTYPE_p_int new_intArray(int nelements) {
    global::System.IntPtr cPtr = GLPKPINVOKE.new_intArray(nelements);
    SWIGTYPE_p_int ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_int(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void delete_intArray(SWIGTYPE_p_int ary) {
    GLPKPINVOKE.delete_intArray(SWIGTYPE_p_int.getCPtr(ary));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int intArray_getitem(SWIGTYPE_p_int ary, int index) {
    int ret = GLPKPINVOKE.intArray_getitem(SWIGTYPE_p_int.getCPtr(ary), index);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void intArray_setitem(SWIGTYPE_p_int ary, int index, int value) {
    GLPKPINVOKE.intArray_setitem(SWIGTYPE_p_int.getCPtr(ary), index, value);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_cli_error(string message) {
    GLPKPINVOKE.glp_cli_error(message);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_cli_set_msg_lvl(int msg_lvl) {
    GLPKPINVOKE.glp_cli_set_msg_lvl(msg_lvl);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  public static void glp_cli_set_numeric_locale(string locale) {
    GLPKPINVOKE.glp_cli_set_numeric_locale(locale);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static glp_cli_arc_data glp_cli_arc_get_data(glp_arc arc) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_cli_arc_get_data(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_arc.getCPtr(arc)));
    glp_cli_arc_data ret = (cPtr == global::System.IntPtr.Zero) ? null : new glp_cli_arc_data(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static glp_cli_vertex_data glp_cli_vertex_data_get(glp_graph G, int i) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_cli_vertex_data_get(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), i);
    glp_cli_vertex_data ret = (cPtr == global::System.IntPtr.Zero) ? null : new glp_cli_vertex_data(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static glp_cli_vertex_data glp_cli_vertex_get_data(glp_vertex v) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_cli_vertex_get_data(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_vertex.getCPtr(v)));
    glp_cli_vertex_data ret = (cPtr == global::System.IntPtr.Zero) ? null : new glp_cli_vertex_data(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static glp_vertex glp_cli_vertex_get(glp_graph G, int i) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_cli_vertex_get(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return (cPtr == global::System.IntPtr.Zero) ? null : new glp_vertex(cPtr, false);
  }

  
public static glp_prob glp_create_prob() {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_create_prob();
    glp_prob ret = (cPtr == global::System.IntPtr.Zero) ? null : new glp_prob(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_set_prob_name(glp_prob P, string name) {
    GLPKPINVOKE.glp_set_prob_name(glp_prob.getCPtr(P), name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_obj_name(glp_prob P, string name) {
    GLPKPINVOKE.glp_set_obj_name(glp_prob.getCPtr(P), name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_obj_dir(glp_prob P, int dir) {
    GLPKPINVOKE.glp_set_obj_dir(glp_prob.getCPtr(P), dir);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_add_rows(glp_prob P, int nrs) {
    int ret = GLPKPINVOKE.glp_add_rows(glp_prob.getCPtr(P), nrs);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_add_cols(glp_prob P, int ncs) {
    int ret = GLPKPINVOKE.glp_add_cols(glp_prob.getCPtr(P), ncs);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_set_row_name(glp_prob P, int i, string name) {
    GLPKPINVOKE.glp_set_row_name(glp_prob.getCPtr(P), i, name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_col_name(glp_prob P, int j, string name) {
    GLPKPINVOKE.glp_set_col_name(glp_prob.getCPtr(P), j, name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_row_bnds(glp_prob P, int i, int type, double lb, double ub) {
    GLPKPINVOKE.glp_set_row_bnds(glp_prob.getCPtr(P), i, type, lb, ub);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_col_bnds(glp_prob P, int j, int type, double lb, double ub) {
    GLPKPINVOKE.glp_set_col_bnds(glp_prob.getCPtr(P), j, type, lb, ub);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_obj_coef(glp_prob P, int j, double coef) {
    GLPKPINVOKE.glp_set_obj_coef(glp_prob.getCPtr(P), j, coef);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_mat_row(glp_prob P, int i, int len, SWIGTYPE_p_int ind, SWIGTYPE_p_double val) {
    GLPKPINVOKE.glp_set_mat_row(glp_prob.getCPtr(P), i, len, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_mat_col(glp_prob P, int j, int len, SWIGTYPE_p_int ind, SWIGTYPE_p_double val) {
    GLPKPINVOKE.glp_set_mat_col(glp_prob.getCPtr(P), j, len, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_load_matrix(glp_prob P, int ne, SWIGTYPE_p_int ia, SWIGTYPE_p_int ja, SWIGTYPE_p_double ar) {
    GLPKPINVOKE.glp_load_matrix(glp_prob.getCPtr(P), ne, SWIGTYPE_p_int.getCPtr(ia), SWIGTYPE_p_int.getCPtr(ja), SWIGTYPE_p_double.getCPtr(ar));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_check_dup(int m, int n, int ne, SWIGTYPE_p_int ia, SWIGTYPE_p_int ja) {
    int ret = GLPKPINVOKE.glp_check_dup(m, n, ne, SWIGTYPE_p_int.getCPtr(ia), SWIGTYPE_p_int.getCPtr(ja));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_sort_matrix(glp_prob P) {
    GLPKPINVOKE.glp_sort_matrix(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_del_rows(glp_prob P, int nrs, SWIGTYPE_p_int num) {
    GLPKPINVOKE.glp_del_rows(glp_prob.getCPtr(P), nrs, SWIGTYPE_p_int.getCPtr(num));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_del_cols(glp_prob P, int ncs, SWIGTYPE_p_int num) {
    GLPKPINVOKE.glp_del_cols(glp_prob.getCPtr(P), ncs, SWIGTYPE_p_int.getCPtr(num));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_copy_prob(glp_prob dest, glp_prob prob, int names) {
    GLPKPINVOKE.glp_copy_prob(glp_prob.getCPtr(dest), glp_prob.getCPtr(prob), names);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_erase_prob(glp_prob P) {
    GLPKPINVOKE.glp_erase_prob(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_delete_prob(glp_prob P) {
    GLPKPINVOKE.glp_delete_prob(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static string glp_get_prob_name(glp_prob P) {
    string ret = GLPKPINVOKE.glp_get_prob_name(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static string glp_get_obj_name(glp_prob P) {
    string ret = GLPKPINVOKE.glp_get_obj_name(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_obj_dir(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_obj_dir(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_num_rows(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_num_rows(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_num_cols(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_num_cols(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static string glp_get_row_name(glp_prob P, int i) {
    string ret = GLPKPINVOKE.glp_get_row_name(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static string glp_get_col_name(glp_prob P, int j) {
    string ret = GLPKPINVOKE.glp_get_col_name(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_row_type(glp_prob P, int i) {
    int ret = GLPKPINVOKE.glp_get_row_type(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_row_lb(glp_prob P, int i) {
    double ret = GLPKPINVOKE.glp_get_row_lb(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_row_ub(glp_prob P, int i) {
    double ret = GLPKPINVOKE.glp_get_row_ub(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_col_type(glp_prob P, int j) {
    int ret = GLPKPINVOKE.glp_get_col_type(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_col_lb(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_get_col_lb(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_col_ub(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_get_col_ub(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_obj_coef(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_get_obj_coef(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_num_nz(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_num_nz(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_mat_row(glp_prob P, int i, SWIGTYPE_p_int ind, SWIGTYPE_p_double val) {
    int ret = GLPKPINVOKE.glp_get_mat_row(glp_prob.getCPtr(P), i, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_mat_col(glp_prob P, int j, SWIGTYPE_p_int ind, SWIGTYPE_p_double val) {
    int ret = GLPKPINVOKE.glp_get_mat_col(glp_prob.getCPtr(P), j, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_create_index(glp_prob P) {
    GLPKPINVOKE.glp_create_index(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_find_row(glp_prob P, string name) {
    int ret = GLPKPINVOKE.glp_find_row(glp_prob.getCPtr(P), name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_find_col(glp_prob P, string name) {
    int ret = GLPKPINVOKE.glp_find_col(glp_prob.getCPtr(P), name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_delete_index(glp_prob P) {
    GLPKPINVOKE.glp_delete_index(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_rii(glp_prob P, int i, double rii) {
    GLPKPINVOKE.glp_set_rii(glp_prob.getCPtr(P), i, rii);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_sjj(glp_prob P, int j, double sjj) {
    GLPKPINVOKE.glp_set_sjj(glp_prob.getCPtr(P), j, sjj);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static double glp_get_rii(glp_prob P, int i) {
    double ret = GLPKPINVOKE.glp_get_rii(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_sjj(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_get_sjj(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_scale_prob(glp_prob P, int flags) {
    GLPKPINVOKE.glp_scale_prob(glp_prob.getCPtr(P), flags);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_unscale_prob(glp_prob P) {
    GLPKPINVOKE.glp_unscale_prob(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_row_stat(glp_prob P, int i, int stat) {
    GLPKPINVOKE.glp_set_row_stat(glp_prob.getCPtr(P), i, stat);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_col_stat(glp_prob P, int j, int stat) {
    GLPKPINVOKE.glp_set_col_stat(glp_prob.getCPtr(P), j, stat);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_std_basis(glp_prob P) {
    GLPKPINVOKE.glp_std_basis(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_adv_basis(glp_prob P, int flags) {
    GLPKPINVOKE.glp_adv_basis(glp_prob.getCPtr(P), flags);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_cpx_basis(glp_prob P) {
    GLPKPINVOKE.glp_cpx_basis(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_simplex(glp_prob P, glp_smcp parm) {
    int ret = GLPKPINVOKE.glp_simplex(glp_prob.getCPtr(P), glp_smcp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_exact(glp_prob P, glp_smcp parm) {
    int ret = GLPKPINVOKE.glp_exact(glp_prob.getCPtr(P), glp_smcp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_init_smcp(glp_smcp parm) {
    GLPKPINVOKE.glp_init_smcp(glp_smcp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_get_status(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_status(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_prim_stat(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_prim_stat(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_dual_stat(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_dual_stat(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_obj_val(glp_prob P) {
    double ret = GLPKPINVOKE.glp_get_obj_val(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_row_stat(glp_prob P, int i) {
    int ret = GLPKPINVOKE.glp_get_row_stat(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_row_prim(glp_prob P, int i) {
    double ret = GLPKPINVOKE.glp_get_row_prim(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_row_dual(glp_prob P, int i) {
    double ret = GLPKPINVOKE.glp_get_row_dual(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_col_stat(glp_prob P, int j) {
    int ret = GLPKPINVOKE.glp_get_col_stat(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_col_prim(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_get_col_prim(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_get_col_dual(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_get_col_dual(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_unbnd_ray(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_unbnd_ray(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_it_cnt(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_it_cnt(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_set_it_cnt(glp_prob P, int it_cnt) {
    GLPKPINVOKE.glp_set_it_cnt(glp_prob.getCPtr(P), it_cnt);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_interior(glp_prob P, glp_iptcp parm) {
    int ret = GLPKPINVOKE.glp_interior(glp_prob.getCPtr(P), glp_iptcp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_init_iptcp(glp_iptcp parm) {
    GLPKPINVOKE.glp_init_iptcp(glp_iptcp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_ipt_status(glp_prob P) {
    int ret = GLPKPINVOKE.glp_ipt_status(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_ipt_obj_val(glp_prob P) {
    double ret = GLPKPINVOKE.glp_ipt_obj_val(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_ipt_row_prim(glp_prob P, int i) {
    double ret = GLPKPINVOKE.glp_ipt_row_prim(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_ipt_row_dual(glp_prob P, int i) {
    double ret = GLPKPINVOKE.glp_ipt_row_dual(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_ipt_col_prim(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_ipt_col_prim(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_ipt_col_dual(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_ipt_col_dual(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_set_col_kind(glp_prob P, int j, int kind) {
    GLPKPINVOKE.glp_set_col_kind(glp_prob.getCPtr(P), j, kind);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_get_col_kind(glp_prob P, int j) {
    int ret = GLPKPINVOKE.glp_get_col_kind(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_num_int(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_num_int(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_num_bin(glp_prob P) {
    int ret = GLPKPINVOKE.glp_get_num_bin(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_intopt(glp_prob P, glp_iocp parm) {
    int ret = GLPKPINVOKE.glp_intopt(glp_prob.getCPtr(P), glp_iocp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_init_iocp(glp_iocp parm) {
    GLPKPINVOKE.glp_init_iocp(glp_iocp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_mip_status(glp_prob P) {
    int ret = GLPKPINVOKE.glp_mip_status(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_mip_obj_val(glp_prob P) {
    double ret = GLPKPINVOKE.glp_mip_obj_val(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_mip_row_val(glp_prob P, int i) {
    double ret = GLPKPINVOKE.glp_mip_row_val(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_mip_col_val(glp_prob P, int j) {
    double ret = GLPKPINVOKE.glp_mip_col_val(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_check_kkt(glp_prob P, int sol, int cond, SWIGTYPE_p_double ae_max, SWIGTYPE_p_int ae_ind, SWIGTYPE_p_double re_max, SWIGTYPE_p_int re_ind) {
    GLPKPINVOKE.glp_check_kkt(glp_prob.getCPtr(P), sol, cond, SWIGTYPE_p_double.getCPtr(ae_max), SWIGTYPE_p_int.getCPtr(ae_ind), SWIGTYPE_p_double.getCPtr(re_max), SWIGTYPE_p_int.getCPtr(re_ind));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_print_sol(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_print_sol(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_read_sol(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_read_sol(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_sol(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_write_sol(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_print_ranges(glp_prob P, int len, SWIGTYPE_p_int list, int flags, string fname) {
    int ret = GLPKPINVOKE.glp_print_ranges(glp_prob.getCPtr(P), len, SWIGTYPE_p_int.getCPtr(list), flags, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_print_ipt(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_print_ipt(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_read_ipt(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_read_ipt(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_ipt(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_write_ipt(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_print_mip(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_print_mip(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_read_mip(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_read_mip(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_mip(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_write_mip(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_bf_exists(glp_prob P) {
    int ret = GLPKPINVOKE.glp_bf_exists(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_factorize(glp_prob P) {
    int ret = GLPKPINVOKE.glp_factorize(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_bf_updated(glp_prob P) {
    int ret = GLPKPINVOKE.glp_bf_updated(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_get_bfcp(glp_prob P, glp_bfcp parm) {
    GLPKPINVOKE.glp_get_bfcp(glp_prob.getCPtr(P), glp_bfcp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_set_bfcp(glp_prob P, glp_bfcp parm) {
    GLPKPINVOKE.glp_set_bfcp(glp_prob.getCPtr(P), glp_bfcp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_get_bhead(glp_prob P, int k) {
    int ret = GLPKPINVOKE.glp_get_bhead(glp_prob.getCPtr(P), k);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_row_bind(glp_prob P, int i) {
    int ret = GLPKPINVOKE.glp_get_row_bind(glp_prob.getCPtr(P), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_get_col_bind(glp_prob P, int j) {
    int ret = GLPKPINVOKE.glp_get_col_bind(glp_prob.getCPtr(P), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_ftran(glp_prob P, SWIGTYPE_p_double x) {
    GLPKPINVOKE.glp_ftran(glp_prob.getCPtr(P), SWIGTYPE_p_double.getCPtr(x));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_btran(glp_prob P, SWIGTYPE_p_double x) {
    GLPKPINVOKE.glp_btran(glp_prob.getCPtr(P), SWIGTYPE_p_double.getCPtr(x));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_warm_up(glp_prob P) {
    int ret = GLPKPINVOKE.glp_warm_up(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_eval_tab_row(glp_prob P, int k, SWIGTYPE_p_int ind, SWIGTYPE_p_double val) {
    int ret = GLPKPINVOKE.glp_eval_tab_row(glp_prob.getCPtr(P), k, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_eval_tab_col(glp_prob P, int k, SWIGTYPE_p_int ind, SWIGTYPE_p_double val) {
    int ret = GLPKPINVOKE.glp_eval_tab_col(glp_prob.getCPtr(P), k, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_transform_row(glp_prob P, int len, SWIGTYPE_p_int ind, SWIGTYPE_p_double val) {
    int ret = GLPKPINVOKE.glp_transform_row(glp_prob.getCPtr(P), len, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_transform_col(glp_prob P, int len, SWIGTYPE_p_int ind, SWIGTYPE_p_double val) {
    int ret = GLPKPINVOKE.glp_transform_col(glp_prob.getCPtr(P), len, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_prim_rtest(glp_prob P, int len, SWIGTYPE_p_int ind, SWIGTYPE_p_double val, int dir, double eps) {
    int ret = GLPKPINVOKE.glp_prim_rtest(glp_prob.getCPtr(P), len, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val), dir, eps);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_dual_rtest(glp_prob P, int len, SWIGTYPE_p_int ind, SWIGTYPE_p_double val, int dir, double eps) {
    int ret = GLPKPINVOKE.glp_dual_rtest(glp_prob.getCPtr(P), len, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val), dir, eps);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_analyze_bound(glp_prob P, int k, SWIGTYPE_p_double value1, SWIGTYPE_p_int var1, SWIGTYPE_p_double value2, SWIGTYPE_p_int var2) {
    GLPKPINVOKE.glp_analyze_bound(glp_prob.getCPtr(P), k, SWIGTYPE_p_double.getCPtr(value1), SWIGTYPE_p_int.getCPtr(var1), SWIGTYPE_p_double.getCPtr(value2), SWIGTYPE_p_int.getCPtr(var2));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_analyze_coef(glp_prob P, int k, SWIGTYPE_p_double coef1, SWIGTYPE_p_int var1, SWIGTYPE_p_double value1, SWIGTYPE_p_double coef2, SWIGTYPE_p_int var2, SWIGTYPE_p_double value2) {
    GLPKPINVOKE.glp_analyze_coef(glp_prob.getCPtr(P), k, SWIGTYPE_p_double.getCPtr(coef1), SWIGTYPE_p_int.getCPtr(var1), SWIGTYPE_p_double.getCPtr(value1), SWIGTYPE_p_double.getCPtr(coef2), SWIGTYPE_p_int.getCPtr(var2), SWIGTYPE_p_double.getCPtr(value2));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  public static SWIGTYPE_p_glp_prep glp_npp_alloc_wksp() {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_npp_alloc_wksp();
    SWIGTYPE_p_glp_prep ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_glp_prep(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void glp_npp_load_prob(SWIGTYPE_p_glp_prep prep, glp_prob P, int sol, int names) {
    GLPKPINVOKE.glp_npp_load_prob(SWIGTYPE_p_glp_prep.getCPtr(prep), glp_prob.getCPtr(P), sol, names);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  public static int glp_npp_preprocess1(SWIGTYPE_p_glp_prep prep, int hard) {
    int ret = GLPKPINVOKE.glp_npp_preprocess1(SWIGTYPE_p_glp_prep.getCPtr(prep), hard);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void glp_npp_build_prob(SWIGTYPE_p_glp_prep prep, glp_prob Q) {
    GLPKPINVOKE.glp_npp_build_prob(SWIGTYPE_p_glp_prep.getCPtr(prep), glp_prob.getCPtr(Q));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  public static void glp_npp_postprocess(SWIGTYPE_p_glp_prep prep, glp_prob Q) {
    GLPKPINVOKE.glp_npp_postprocess(SWIGTYPE_p_glp_prep.getCPtr(prep), glp_prob.getCPtr(Q));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  public static void glp_npp_obtain_sol(SWIGTYPE_p_glp_prep prep, glp_prob P) {
    GLPKPINVOKE.glp_npp_obtain_sol(SWIGTYPE_p_glp_prep.getCPtr(prep), glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  public static void glp_npp_free_wksp(SWIGTYPE_p_glp_prep prep) {
    GLPKPINVOKE.glp_npp_free_wksp(SWIGTYPE_p_glp_prep.getCPtr(prep));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_ios_reason(glp_tree T) {
    int ret = GLPKPINVOKE.glp_ios_reason(glp_tree.getCPtr(T));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static glp_prob glp_ios_get_prob(glp_tree T) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_ios_get_prob(glp_tree.getCPtr(T));
    glp_prob ret = (cPtr == global::System.IntPtr.Zero) ? null : new glp_prob(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_ios_tree_size(glp_tree T, SWIGTYPE_p_int a_cnt, SWIGTYPE_p_int n_cnt, SWIGTYPE_p_int t_cnt) {
    GLPKPINVOKE.glp_ios_tree_size(glp_tree.getCPtr(T), SWIGTYPE_p_int.getCPtr(a_cnt), SWIGTYPE_p_int.getCPtr(n_cnt), SWIGTYPE_p_int.getCPtr(t_cnt));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_ios_curr_node(glp_tree T) {
    int ret = GLPKPINVOKE.glp_ios_curr_node(glp_tree.getCPtr(T));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_ios_next_node(glp_tree T, int p) {
    int ret = GLPKPINVOKE.glp_ios_next_node(glp_tree.getCPtr(T), p);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_ios_prev_node(glp_tree T, int p) {
    int ret = GLPKPINVOKE.glp_ios_prev_node(glp_tree.getCPtr(T), p);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_ios_up_node(glp_tree T, int p) {
    int ret = GLPKPINVOKE.glp_ios_up_node(glp_tree.getCPtr(T), p);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_ios_node_level(glp_tree T, int p) {
    int ret = GLPKPINVOKE.glp_ios_node_level(glp_tree.getCPtr(T), p);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_ios_node_bound(glp_tree T, int p) {
    double ret = GLPKPINVOKE.glp_ios_node_bound(glp_tree.getCPtr(T), p);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_ios_best_node(glp_tree T) {
    int ret = GLPKPINVOKE.glp_ios_best_node(glp_tree.getCPtr(T));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_ios_mip_gap(glp_tree T) {
    double ret = GLPKPINVOKE.glp_ios_mip_gap(glp_tree.getCPtr(T));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static SWIGTYPE_p_void glp_ios_node_data(glp_tree T, int p) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_ios_node_data(glp_tree.getCPtr(T), p);
    SWIGTYPE_p_void ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_ios_row_attr(glp_tree T, int i, glp_attr attr) {
    GLPKPINVOKE.glp_ios_row_attr(glp_tree.getCPtr(T), i, glp_attr.getCPtr(attr));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_ios_pool_size(glp_tree T) {
    int ret = GLPKPINVOKE.glp_ios_pool_size(glp_tree.getCPtr(T));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_ios_add_row(glp_tree T, string name, int klass, int flags, int len, SWIGTYPE_p_int ind, SWIGTYPE_p_double val, int type, double rhs) {
    int ret = GLPKPINVOKE.glp_ios_add_row(glp_tree.getCPtr(T), name, klass, flags, len, SWIGTYPE_p_int.getCPtr(ind), SWIGTYPE_p_double.getCPtr(val), type, rhs);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_ios_del_row(glp_tree T, int i) {
    GLPKPINVOKE.glp_ios_del_row(glp_tree.getCPtr(T), i);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_ios_clear_pool(glp_tree T) {
    GLPKPINVOKE.glp_ios_clear_pool(glp_tree.getCPtr(T));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_ios_can_branch(glp_tree T, int j) {
    int ret = GLPKPINVOKE.glp_ios_can_branch(glp_tree.getCPtr(T), j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_ios_branch_upon(glp_tree T, int j, int sel) {
    GLPKPINVOKE.glp_ios_branch_upon(glp_tree.getCPtr(T), j, sel);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_ios_select_node(glp_tree T, int p) {
    GLPKPINVOKE.glp_ios_select_node(glp_tree.getCPtr(T), p);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_ios_heur_sol(glp_tree T, SWIGTYPE_p_double x) {
    int ret = GLPKPINVOKE.glp_ios_heur_sol(glp_tree.getCPtr(T), SWIGTYPE_p_double.getCPtr(x));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_ios_terminate(glp_tree T) {
    GLPKPINVOKE.glp_ios_terminate(glp_tree.getCPtr(T));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_init_mpscp(glp_mpscp parm) {
    GLPKPINVOKE.glp_init_mpscp(glp_mpscp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_read_mps(glp_prob P, int fmt, glp_mpscp parm, string fname) {
    int ret = GLPKPINVOKE.glp_read_mps(glp_prob.getCPtr(P), fmt, glp_mpscp.getCPtr(parm), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_mps(glp_prob P, int fmt, glp_mpscp parm, string fname) {
    int ret = GLPKPINVOKE.glp_write_mps(glp_prob.getCPtr(P), fmt, glp_mpscp.getCPtr(parm), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_init_cpxcp(glp_cpxcp parm) {
    GLPKPINVOKE.glp_init_cpxcp(glp_cpxcp.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_read_lp(glp_prob P, glp_cpxcp parm, string fname) {
    int ret = GLPKPINVOKE.glp_read_lp(glp_prob.getCPtr(P), glp_cpxcp.getCPtr(parm), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_lp(glp_prob P, glp_cpxcp parm, string fname) {
    int ret = GLPKPINVOKE.glp_write_lp(glp_prob.getCPtr(P), glp_cpxcp.getCPtr(parm), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_read_prob(glp_prob P, int flags, string fname) {
    int ret = GLPKPINVOKE.glp_read_prob(glp_prob.getCPtr(P), flags, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_prob(glp_prob P, int flags, string fname) {
    int ret = GLPKPINVOKE.glp_write_prob(glp_prob.getCPtr(P), flags, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static glp_tran glp_mpl_alloc_wksp() {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_mpl_alloc_wksp();
    glp_tran ret = (cPtr == global::System.IntPtr.Zero) ? null : new glp_tran(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void glp_mpl_init_rand(glp_tran tran, int seed) {
    GLPKPINVOKE.glp_mpl_init_rand(glp_tran.getCPtr(tran), seed);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_mpl_read_model(glp_tran tran, string fname, int skip) {
    int ret = GLPKPINVOKE.glp_mpl_read_model(glp_tran.getCPtr(tran), fname, skip);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_mpl_read_data(glp_tran tran, string fname) {
    int ret = GLPKPINVOKE.glp_mpl_read_data(glp_tran.getCPtr(tran), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_mpl_generate(glp_tran tran, string fname) {
    int ret = GLPKPINVOKE.glp_mpl_generate(glp_tran.getCPtr(tran), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_mpl_build_prob(glp_tran tran, glp_prob prob) {
    GLPKPINVOKE.glp_mpl_build_prob(glp_tran.getCPtr(tran), glp_prob.getCPtr(prob));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_mpl_postsolve(glp_tran tran, glp_prob prob, int sol) {
    int ret = GLPKPINVOKE.glp_mpl_postsolve(glp_tran.getCPtr(tran), glp_prob.getCPtr(prob), sol);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_mpl_free_wksp(glp_tran tran) {
    GLPKPINVOKE.glp_mpl_free_wksp(glp_tran.getCPtr(tran));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_read_cnfsat(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_read_cnfsat(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_check_cnfsat(glp_prob P) {
    int ret = GLPKPINVOKE.glp_check_cnfsat(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_cnfsat(glp_prob P, string fname) {
    int ret = GLPKPINVOKE.glp_write_cnfsat(glp_prob.getCPtr(P), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_minisat1(glp_prob P) {
    int ret = GLPKPINVOKE.glp_minisat1(glp_prob.getCPtr(P));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_intfeas1(glp_prob P, int use_bound, int obj_bound) {
    int ret = GLPKPINVOKE.glp_intfeas1(glp_prob.getCPtr(P), use_bound, obj_bound);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_init_env() {
    int ret = GLPKPINVOKE.glp_init_env();
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static string glp_version() {
    string ret = GLPKPINVOKE.glp_version();
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static string glp_config(string option) {
    string ret = GLPKPINVOKE.glp_config(option);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_free_env() {
    int ret = GLPKPINVOKE.glp_free_env();
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_puts(string s) {
    GLPKPINVOKE.glp_puts(s);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_printf(string fmt) {
    GLPKPINVOKE.glp_printf(fmt);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_vprintf(string fmt, SWIGTYPE_p_va_list arg) {
    GLPKPINVOKE.glp_vprintf(fmt, SWIGTYPE_p_va_list.getCPtr(arg));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_term_out(int flag) {
    int ret = GLPKPINVOKE.glp_term_out(flag);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_term_hook(SWIGTYPE_p_f_p_void_p_q_const__char__int func, SWIGTYPE_p_void info) {
    GLPKPINVOKE.glp_term_hook(SWIGTYPE_p_f_p_void_p_q_const__char__int.getCPtr(func), SWIGTYPE_p_void.getCPtr(info));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_open_tee(string name) {
    int ret = GLPKPINVOKE.glp_open_tee(name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_close_tee() {
    int ret = GLPKPINVOKE.glp_close_tee();
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static SWIGTYPE_p_f_p_q_const__char_v_______void glp_error_(string file, int line) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_error_(file, line);
    SWIGTYPE_p_f_p_q_const__char_v_______void ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_q_const__char_v_______void(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_at_error() {
    int ret = GLPKPINVOKE.glp_at_error();
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_assert_(string expr, string file, int line) {
    GLPKPINVOKE.glp_assert_(expr, file, line);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_error_hook(SWIGTYPE_p_f_p_void__void func, SWIGTYPE_p_void info) {
    GLPKPINVOKE.glp_error_hook(SWIGTYPE_p_f_p_void__void.getCPtr(func), SWIGTYPE_p_void.getCPtr(info));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static SWIGTYPE_p_void glp_alloc(int n, int size) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_alloc(n, size);
    SWIGTYPE_p_void ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static SWIGTYPE_p_void glp_realloc(SWIGTYPE_p_void ptr, int n, int size) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_realloc(SWIGTYPE_p_void.getCPtr(ptr), n, size);
    SWIGTYPE_p_void ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_free(SWIGTYPE_p_void ptr) {
    GLPKPINVOKE.glp_free(SWIGTYPE_p_void.getCPtr(ptr));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_mem_limit(int limit) {
    GLPKPINVOKE.glp_mem_limit(limit);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_mem_usage(SWIGTYPE_p_int count, SWIGTYPE_p_int cpeak, SWIGTYPE_p_size_t total, SWIGTYPE_p_size_t tpeak) {
    GLPKPINVOKE.glp_mem_usage(SWIGTYPE_p_int.getCPtr(count), SWIGTYPE_p_int.getCPtr(cpeak), SWIGTYPE_p_size_t.getCPtr(total), SWIGTYPE_p_size_t.getCPtr(tpeak));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static double glp_time() {
    double ret = GLPKPINVOKE.glp_time();
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_difftime(double t1, double t0) {
    double ret = GLPKPINVOKE.glp_difftime(t1, t0);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static glp_graph glp_create_graph(int v_size, int a_size) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_create_graph(v_size, a_size);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return (cPtr == global::System.IntPtr.Zero) ? null : new glp_graph(cPtr, false);
  }

  
public static void glp_set_graph_name(glp_graph G, string name) {
    GLPKPINVOKE.glp_set_graph_name(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_add_vertices(glp_graph G, int nadd) {
    int ret = GLPKPINVOKE.glp_add_vertices(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), nadd);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_set_vertex_name(glp_graph G, int i, string name) {
    GLPKPINVOKE.glp_set_vertex_name(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), i, name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static glp_arc glp_add_arc(glp_graph G, int i, int j) {
    global::System.IntPtr cPtr = GLPKPINVOKE.glp_add_arc(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), i, j);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return (cPtr == global::System.IntPtr.Zero) ? null : new glp_arc(cPtr, false);
  }

  
public static void glp_del_vertices(glp_graph G, int ndel, SWIGTYPE_p_int num) {
    GLPKPINVOKE.glp_del_vertices(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), ndel, SWIGTYPE_p_int.getCPtr(num));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_del_arc(glp_graph G, glp_arc a) {
    GLPKPINVOKE.glp_del_arc(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_arc.getCPtr(a)));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_erase_graph(glp_graph G, int v_size, int a_size) {
    GLPKPINVOKE.glp_erase_graph(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_size, a_size);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_delete_graph(glp_graph G) {
    GLPKPINVOKE.glp_delete_graph(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static void glp_create_v_index(glp_graph G) {
    GLPKPINVOKE.glp_create_v_index(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_find_vertex(glp_graph G, string name) {
    int ret = GLPKPINVOKE.glp_find_vertex(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), name);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_delete_v_index(glp_graph G) {
    GLPKPINVOKE.glp_delete_v_index(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_read_graph(glp_graph G, string fname) {
    int ret = GLPKPINVOKE.glp_read_graph(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_graph(glp_graph G, string fname) {
    int ret = GLPKPINVOKE.glp_write_graph(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_mincost_lp(glp_prob P, glp_graph G, int names, int v_rhs, int a_low, int a_cap, int a_cost) {
    GLPKPINVOKE.glp_mincost_lp(glp_prob.getCPtr(P), global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), names, v_rhs, a_low, a_cap, a_cost);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_mincost_okalg(glp_graph G, int v_rhs, int a_low, int a_cap, int a_cost, SWIGTYPE_p_double sol, int a_x, int v_pi) {
    int ret = GLPKPINVOKE.glp_mincost_okalg(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_rhs, a_low, a_cap, a_cost, SWIGTYPE_p_double.getCPtr(sol), a_x, v_pi);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_mincost_relax4(glp_graph G, int v_rhs, int a_low, int a_cap, int a_cost, int crash, SWIGTYPE_p_double sol, int a_x, int a_rc) {
    int ret = GLPKPINVOKE.glp_mincost_relax4(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_rhs, a_low, a_cap, a_cost, crash, SWIGTYPE_p_double.getCPtr(sol), a_x, a_rc);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_maxflow_lp(glp_prob P, glp_graph G, int names, int s, int t, int a_cap) {
    GLPKPINVOKE.glp_maxflow_lp(glp_prob.getCPtr(P), global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), names, s, t, a_cap);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_maxflow_ffalg(glp_graph G, int s, int t, int a_cap, SWIGTYPE_p_double sol, int a_x, int v_cut) {
    int ret = GLPKPINVOKE.glp_maxflow_ffalg(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), s, t, a_cap, SWIGTYPE_p_double.getCPtr(sol), a_x, v_cut);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_check_asnprob(glp_graph G, int v_set) {
    int ret = GLPKPINVOKE.glp_check_asnprob(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_set);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_asnprob_lp(glp_prob P, int form, glp_graph G, int names, int v_set, int a_cost) {
    int ret = GLPKPINVOKE.glp_asnprob_lp(glp_prob.getCPtr(P), form, global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), names, v_set, a_cost);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_asnprob_okalg(int form, glp_graph G, int v_set, int a_cost, SWIGTYPE_p_double sol, int a_x) {
    int ret = GLPKPINVOKE.glp_asnprob_okalg(form, global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_set, a_cost, SWIGTYPE_p_double.getCPtr(sol), a_x);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_asnprob_hall(glp_graph G, int v_set, int a_x) {
    int ret = GLPKPINVOKE.glp_asnprob_hall(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_set, a_x);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static double glp_cpp(glp_graph G, int v_t, int v_es, int v_ls) {
    double ret = GLPKPINVOKE.glp_cpp(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_t, v_es, v_ls);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_read_mincost(glp_graph G, int v_rhs, int a_low, int a_cap, int a_cost, string fname) {
    int ret = GLPKPINVOKE.glp_read_mincost(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_rhs, a_low, a_cap, a_cost, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_mincost(glp_graph G, int v_rhs, int a_low, int a_cap, int a_cost, string fname) {
    int ret = GLPKPINVOKE.glp_write_mincost(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_rhs, a_low, a_cap, a_cost, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_read_maxflow(glp_graph G, SWIGTYPE_p_int s, SWIGTYPE_p_int t, int a_cap, string fname) {
    int ret = GLPKPINVOKE.glp_read_maxflow(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), SWIGTYPE_p_int.getCPtr(s), SWIGTYPE_p_int.getCPtr(t), a_cap, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_maxflow(glp_graph G, int s, int t, int a_cap, string fname) {
    int ret = GLPKPINVOKE.glp_write_maxflow(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), s, t, a_cap, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_read_asnprob(glp_graph G, int v_set, int a_cost, string fname) {
    int ret = GLPKPINVOKE.glp_read_asnprob(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_set, a_cost, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_asnprob(glp_graph G, int v_set, int a_cost, string fname) {
    int ret = GLPKPINVOKE.glp_write_asnprob(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_set, a_cost, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_read_ccdata(glp_graph G, int v_wgt, string fname) {
    int ret = GLPKPINVOKE.glp_read_ccdata(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_wgt, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_write_ccdata(glp_graph G, int v_wgt, string fname) {
    int ret = GLPKPINVOKE.glp_write_ccdata(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_wgt, fname);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_netgen(glp_graph G, int v_rhs, int a_cap, int a_cost, SWIGTYPE_p_int parm) {
    int ret = GLPKPINVOKE.glp_netgen(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_rhs, a_cap, a_cost, SWIGTYPE_p_int.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static void glp_netgen_prob(int nprob, SWIGTYPE_p_int parm) {
    GLPKPINVOKE.glp_netgen_prob(nprob, SWIGTYPE_p_int.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
  }

  
public static int glp_gridgen(glp_graph G, int v_rhs, int a_cap, int a_cost, SWIGTYPE_p_int parm) {
    int ret = GLPKPINVOKE.glp_gridgen(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_rhs, a_cap, a_cost, SWIGTYPE_p_int.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_rmfgen(glp_graph G, SWIGTYPE_p_int s, SWIGTYPE_p_int t, int a_cap, SWIGTYPE_p_int parm) {
    int ret = GLPKPINVOKE.glp_rmfgen(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), SWIGTYPE_p_int.getCPtr(s), SWIGTYPE_p_int.getCPtr(t), a_cap, SWIGTYPE_p_int.getCPtr(parm));
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_weak_comp(glp_graph G, int v_num) {
    int ret = GLPKPINVOKE.glp_weak_comp(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_num);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_strong_comp(glp_graph G, int v_num) {
    int ret = GLPKPINVOKE.glp_strong_comp(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_num);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_top_sort(glp_graph G, int v_num) {
    int ret = GLPKPINVOKE.glp_top_sort(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_num);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  
public static int glp_wclique_exact(glp_graph G, int v_wgt, SWIGTYPE_p_double sol, int v_set) {
    int ret = GLPKPINVOKE.glp_wclique_exact(global::System.Runtime.InteropServices.HandleRef.ToIntPtr(glp_graph.getCPtr(G)), v_wgt, SWIGTYPE_p_double.getCPtr(sol), v_set);
    if (GLPKPINVOKE.SWIGPendingException.Pending) throw GLPKPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static readonly int GLP_CLI_A_CAP = GLPKPINVOKE.GLP_CLI_A_CAP_get();
  public static readonly int GLP_CLI_A_COST = GLPKPINVOKE.GLP_CLI_A_COST_get();
  public static readonly int GLP_CLI_A_LOW = GLPKPINVOKE.GLP_CLI_A_LOW_get();
  public static readonly int GLP_CLI_A_RC = GLPKPINVOKE.GLP_CLI_A_RC_get();
  public static readonly int GLP_CLI_A_X = GLPKPINVOKE.GLP_CLI_A_X_get();
  public static readonly int GLP_CLI_A_SIZE = GLPKPINVOKE.GLP_CLI_A_SIZE_get();
  public static readonly int GLP_CLI_V_CUT = GLPKPINVOKE.GLP_CLI_V_CUT_get();
  public static readonly int GLP_CLI_V_PI = GLPKPINVOKE.GLP_CLI_V_PI_get();
  public static readonly int GLP_CLI_V_RHS = GLPKPINVOKE.GLP_CLI_V_RHS_get();
  public static readonly int GLP_CLI_V_SET = GLPKPINVOKE.GLP_CLI_V_SET_get();
  public static readonly int GLP_CLI_V_SIZE = GLPKPINVOKE.GLP_CLI_V_SIZE_get();
  public static readonly int GLP_CLI_MSG_LVL_OFF = GLPKPINVOKE.GLP_CLI_MSG_LVL_OFF_get();
  public static readonly int GLP_CLI_MSG_LVL_ALL = GLPKPINVOKE.GLP_CLI_MSG_LVL_ALL_get();
  public static readonly int GLP_MAJOR_VERSION = GLPKPINVOKE.GLP_MAJOR_VERSION_get();
  public static readonly int GLP_MINOR_VERSION = GLPKPINVOKE.GLP_MINOR_VERSION_get();
  public static readonly int GLP_MIN = GLPKPINVOKE.GLP_MIN_get();
  public static readonly int GLP_MAX = GLPKPINVOKE.GLP_MAX_get();
  public static readonly int GLP_CV = GLPKPINVOKE.GLP_CV_get();
  public static readonly int GLP_IV = GLPKPINVOKE.GLP_IV_get();
  public static readonly int GLP_BV = GLPKPINVOKE.GLP_BV_get();
  public static readonly int GLP_FR = GLPKPINVOKE.GLP_FR_get();
  public static readonly int GLP_LO = GLPKPINVOKE.GLP_LO_get();
  public static readonly int GLP_UP = GLPKPINVOKE.GLP_UP_get();
  public static readonly int GLP_DB = GLPKPINVOKE.GLP_DB_get();
  public static readonly int GLP_FX = GLPKPINVOKE.GLP_FX_get();
  public static readonly int GLP_BS = GLPKPINVOKE.GLP_BS_get();
  public static readonly int GLP_NL = GLPKPINVOKE.GLP_NL_get();
  public static readonly int GLP_NU = GLPKPINVOKE.GLP_NU_get();
  public static readonly int GLP_NF = GLPKPINVOKE.GLP_NF_get();
  public static readonly int GLP_NS = GLPKPINVOKE.GLP_NS_get();
  public static readonly int GLP_SF_GM = GLPKPINVOKE.GLP_SF_GM_get();
  public static readonly int GLP_SF_EQ = GLPKPINVOKE.GLP_SF_EQ_get();
  public static readonly int GLP_SF_2N = GLPKPINVOKE.GLP_SF_2N_get();
  public static readonly int GLP_SF_SKIP = GLPKPINVOKE.GLP_SF_SKIP_get();
  public static readonly int GLP_SF_AUTO = GLPKPINVOKE.GLP_SF_AUTO_get();
  public static readonly int GLP_SOL = GLPKPINVOKE.GLP_SOL_get();
  public static readonly int GLP_IPT = GLPKPINVOKE.GLP_IPT_get();
  public static readonly int GLP_MIP = GLPKPINVOKE.GLP_MIP_get();
  public static readonly int GLP_UNDEF = GLPKPINVOKE.GLP_UNDEF_get();
  public static readonly int GLP_FEAS = GLPKPINVOKE.GLP_FEAS_get();
  public static readonly int GLP_INFEAS = GLPKPINVOKE.GLP_INFEAS_get();
  public static readonly int GLP_NOFEAS = GLPKPINVOKE.GLP_NOFEAS_get();
  public static readonly int GLP_OPT = GLPKPINVOKE.GLP_OPT_get();
  public static readonly int GLP_UNBND = GLPKPINVOKE.GLP_UNBND_get();
  public static readonly int GLP_BF_LUF = GLPKPINVOKE.GLP_BF_LUF_get();
  public static readonly int GLP_BF_BTF = GLPKPINVOKE.GLP_BF_BTF_get();
  public static readonly int GLP_BF_FT = GLPKPINVOKE.GLP_BF_FT_get();
  public static readonly int GLP_BF_BG = GLPKPINVOKE.GLP_BF_BG_get();
  public static readonly int GLP_BF_GR = GLPKPINVOKE.GLP_BF_GR_get();
  public static readonly int GLP_MSG_OFF = GLPKPINVOKE.GLP_MSG_OFF_get();
  public static readonly int GLP_MSG_ERR = GLPKPINVOKE.GLP_MSG_ERR_get();
  public static readonly int GLP_MSG_ON = GLPKPINVOKE.GLP_MSG_ON_get();
  public static readonly int GLP_MSG_ALL = GLPKPINVOKE.GLP_MSG_ALL_get();
  public static readonly int GLP_MSG_DBG = GLPKPINVOKE.GLP_MSG_DBG_get();
  public static readonly int GLP_PRIMAL = GLPKPINVOKE.GLP_PRIMAL_get();
  public static readonly int GLP_DUALP = GLPKPINVOKE.GLP_DUALP_get();
  public static readonly int GLP_DUAL = GLPKPINVOKE.GLP_DUAL_get();
  public static readonly int GLP_PT_STD = GLPKPINVOKE.GLP_PT_STD_get();
  public static readonly int GLP_PT_PSE = GLPKPINVOKE.GLP_PT_PSE_get();
  public static readonly int GLP_RT_STD = GLPKPINVOKE.GLP_RT_STD_get();
  public static readonly int GLP_RT_HAR = GLPKPINVOKE.GLP_RT_HAR_get();
  public static readonly int GLP_RT_FLIP = GLPKPINVOKE.GLP_RT_FLIP_get();
  public static readonly int GLP_USE_AT = GLPKPINVOKE.GLP_USE_AT_get();
  public static readonly int GLP_USE_NT = GLPKPINVOKE.GLP_USE_NT_get();
  public static readonly int GLP_ORD_NONE = GLPKPINVOKE.GLP_ORD_NONE_get();
  public static readonly int GLP_ORD_QMD = GLPKPINVOKE.GLP_ORD_QMD_get();
  public static readonly int GLP_ORD_AMD = GLPKPINVOKE.GLP_ORD_AMD_get();
  public static readonly int GLP_ORD_SYMAMD = GLPKPINVOKE.GLP_ORD_SYMAMD_get();
  public static readonly int GLP_BR_FFV = GLPKPINVOKE.GLP_BR_FFV_get();
  public static readonly int GLP_BR_LFV = GLPKPINVOKE.GLP_BR_LFV_get();
  public static readonly int GLP_BR_MFV = GLPKPINVOKE.GLP_BR_MFV_get();
  public static readonly int GLP_BR_DTH = GLPKPINVOKE.GLP_BR_DTH_get();
  public static readonly int GLP_BR_PCH = GLPKPINVOKE.GLP_BR_PCH_get();
  public static readonly int GLP_BT_DFS = GLPKPINVOKE.GLP_BT_DFS_get();
  public static readonly int GLP_BT_BFS = GLPKPINVOKE.GLP_BT_BFS_get();
  public static readonly int GLP_BT_BLB = GLPKPINVOKE.GLP_BT_BLB_get();
  public static readonly int GLP_BT_BPH = GLPKPINVOKE.GLP_BT_BPH_get();
  public static readonly int GLP_PP_NONE = GLPKPINVOKE.GLP_PP_NONE_get();
  public static readonly int GLP_PP_ROOT = GLPKPINVOKE.GLP_PP_ROOT_get();
  public static readonly int GLP_PP_ALL = GLPKPINVOKE.GLP_PP_ALL_get();
  public static readonly int GLP_RF_REG = GLPKPINVOKE.GLP_RF_REG_get();
  public static readonly int GLP_RF_LAZY = GLPKPINVOKE.GLP_RF_LAZY_get();
  public static readonly int GLP_RF_CUT = GLPKPINVOKE.GLP_RF_CUT_get();
  public static readonly int GLP_RF_GMI = GLPKPINVOKE.GLP_RF_GMI_get();
  public static readonly int GLP_RF_MIR = GLPKPINVOKE.GLP_RF_MIR_get();
  public static readonly int GLP_RF_COV = GLPKPINVOKE.GLP_RF_COV_get();
  public static readonly int GLP_RF_CLQ = GLPKPINVOKE.GLP_RF_CLQ_get();
  public static readonly int GLP_ON = GLPKPINVOKE.GLP_ON_get();
  public static readonly int GLP_OFF = GLPKPINVOKE.GLP_OFF_get();
  public static readonly int GLP_IROWGEN = GLPKPINVOKE.GLP_IROWGEN_get();
  public static readonly int GLP_IBINGO = GLPKPINVOKE.GLP_IBINGO_get();
  public static readonly int GLP_IHEUR = GLPKPINVOKE.GLP_IHEUR_get();
  public static readonly int GLP_ICUTGEN = GLPKPINVOKE.GLP_ICUTGEN_get();
  public static readonly int GLP_IBRANCH = GLPKPINVOKE.GLP_IBRANCH_get();
  public static readonly int GLP_ISELECT = GLPKPINVOKE.GLP_ISELECT_get();
  public static readonly int GLP_IPREPRO = GLPKPINVOKE.GLP_IPREPRO_get();
  public static readonly int GLP_NO_BRNCH = GLPKPINVOKE.GLP_NO_BRNCH_get();
  public static readonly int GLP_DN_BRNCH = GLPKPINVOKE.GLP_DN_BRNCH_get();
  public static readonly int GLP_UP_BRNCH = GLPKPINVOKE.GLP_UP_BRNCH_get();
  public static readonly int GLP_EBADB = GLPKPINVOKE.GLP_EBADB_get();
  public static readonly int GLP_ESING = GLPKPINVOKE.GLP_ESING_get();
  public static readonly int GLP_ECOND = GLPKPINVOKE.GLP_ECOND_get();
  public static readonly int GLP_EBOUND = GLPKPINVOKE.GLP_EBOUND_get();
  public static readonly int GLP_EFAIL = GLPKPINVOKE.GLP_EFAIL_get();
  public static readonly int GLP_EOBJLL = GLPKPINVOKE.GLP_EOBJLL_get();
  public static readonly int GLP_EOBJUL = GLPKPINVOKE.GLP_EOBJUL_get();
  public static readonly int GLP_EITLIM = GLPKPINVOKE.GLP_EITLIM_get();
  public static readonly int GLP_ETMLIM = GLPKPINVOKE.GLP_ETMLIM_get();
  public static readonly int GLP_ENOPFS = GLPKPINVOKE.GLP_ENOPFS_get();
  public static readonly int GLP_ENODFS = GLPKPINVOKE.GLP_ENODFS_get();
  public static readonly int GLP_EROOT = GLPKPINVOKE.GLP_EROOT_get();
  public static readonly int GLP_ESTOP = GLPKPINVOKE.GLP_ESTOP_get();
  public static readonly int GLP_EMIPGAP = GLPKPINVOKE.GLP_EMIPGAP_get();
  public static readonly int GLP_ENOFEAS = GLPKPINVOKE.GLP_ENOFEAS_get();
  public static readonly int GLP_ENOCVG = GLPKPINVOKE.GLP_ENOCVG_get();
  public static readonly int GLP_EINSTAB = GLPKPINVOKE.GLP_EINSTAB_get();
  public static readonly int GLP_EDATA = GLPKPINVOKE.GLP_EDATA_get();
  public static readonly int GLP_ERANGE = GLPKPINVOKE.GLP_ERANGE_get();
  public static readonly int GLP_KKT_PE = GLPKPINVOKE.GLP_KKT_PE_get();
  public static readonly int GLP_KKT_PB = GLPKPINVOKE.GLP_KKT_PB_get();
  public static readonly int GLP_KKT_DE = GLPKPINVOKE.GLP_KKT_DE_get();
  public static readonly int GLP_KKT_DB = GLPKPINVOKE.GLP_KKT_DB_get();
  public static readonly int GLP_KKT_CS = GLPKPINVOKE.GLP_KKT_CS_get();
  public static readonly int GLP_MPS_DECK = GLPKPINVOKE.GLP_MPS_DECK_get();
  public static readonly int GLP_MPS_FILE = GLPKPINVOKE.GLP_MPS_FILE_get();
  public static readonly int GLP_ASN_MIN = GLPKPINVOKE.GLP_ASN_MIN_get();
  public static readonly int GLP_ASN_MAX = GLPKPINVOKE.GLP_ASN_MAX_get();
  public static readonly int GLP_ASN_MMP = GLPKPINVOKE.GLP_ASN_MMP_get();
}

}