windll.c

利用c语言编写

#include <stdio.h>

#include "lpkit.h"
#include "debug.h"

static char *buferror = NULL;
static FILE *fplogfile = NULL;

/* this will only work in the following condition:

   int = long
   REAL = double 
*/

static void freebuferror()
 {
  if (buferror != NULL) {
   free(buferror);
   buferror = NULL;
  }
 }

void __declspec(dllexport) WINAPI _lasterror(char *str, long strsz)
 {
  if (strsz) {
   *str=0;
   if (buferror != NULL)
    strncpy(str,buferror,strsz);
  }
 }

/* return lp_solve version info */
void __declspec(dllexport) WINAPI _lp_solve_version(long *majorversion, long *minorversion, long *release, long *build)
 {
  lp_solve_version(majorversion, minorversion, release, build);
 }

void __declspec(dllexport) WINAPI _set_magic(long code, long param)
 {
  set_magic(code, param);
 }

/* create and initialise a lprec structure
   defaults:
   Empty (Rows * Columns) matrix,
   Minimise the objective function
   constraints all type <=
   Upperbounds all Infinite
   no integer variables
   floor first in B&B
   no scaling
   default basis */
lprec __declspec(dllexport) * WINAPI _make_lp(long rows, long columns)
 {
  freebuferror();
  return(make_lp(rows, columns));
 }

/* create and read an .lp file from input */
lprec __declspec(dllexport) * WINAPI _read_LP(char *filename, long verbose, char *lp_name)
 {
  lprec *lp;

  freebuferror();
  lp = read_LP(filename, (short) ((verbose == 0) ? FALSE : TRUE), lp_name);
  return(lp);
 }

/* Remove problem from memory */
void __declspec(dllexport) WINAPI _delete_lp(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   delete_lp(lp);
  }
 }

/* copy a lp structure */
lprec __declspec(dllexport) * WINAPI _copy_lp(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   return(copy_lp(lp));
  }
  else
   return(NULL);
 }

/* fill in element (Row,Column) of the matrix
   Row in [0..Rows] and Column in [1..Columns] */
long __declspec(dllexport) WINAPI _set_mat(lprec *lp, long row, long column, double value)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_mat(lp, row, column, value);
  }
  else
   ret = 0;
  return(ret);
 }

/* set the objective function (Row 0) of the matrix */
long __declspec(dllexport) WINAPI _set_obj_fn(lprec *lp, double *row)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_obj_fn(lp, row);
  }
  else
   ret = 0;
  return(ret);
 }

/* set the objective function (Row 0) of the matrix with string input */
long __declspec(dllexport) WINAPI _str_set_obj_fn(lprec *lp, char *row)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = str_set_obj_fn(lp, row);
  }
  else
   ret = 0;
  return(ret);
 }

/* Add a constraint to the problem,
   row is the constraint row,
   rh is the right hand side,
   constr_type is the type of constraint (LE (<=), GE(>=), EQ(=)) */
long __declspec(dllexport) WINAPI _add_constraint(lprec *lp, double *row, long constr_type, double rh)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = add_constraint(lp, row,(short) constr_type, rh);
  }
  else
   ret = 0;
  return(ret);
 }

/* Add a constraint to the problem with string input,
   row is the constraint row,
   rh is the right hand side,
   constr_type is the type of constraint (LE (<=), GE(>=), EQ(=)) */
long __declspec(dllexport) WINAPI _str_add_constraint(lprec *lp, char *row, long constr_type, double rh)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = str_add_constraint(lp, row,(short) constr_type, rh);
  }
  else
   ret = 0;
  return(ret);
 }

/* Remove constraint nr del_row from the problem */
long __declspec(dllexport) WINAPI _del_constraint(lprec *lp, long del_row)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = del_constraint(lp, del_row);
  }
  else
   ret = 0;
  return(ret);
 }

/* add a Lagrangian constraint of form Row' x contype Rhs */
long __declspec(dllexport) WINAPI _add_lag_con(lprec *lp, double *row, long con_type, double rhs)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = add_lag_con(lp, row, (short) con_type, rhs);
  }
  else
   ret = 0;
  return(ret);
 }

/* add a Lagrangian constraint of form Row' x contype Rhs with string input */
long __declspec(dllexport) WINAPI _str_add_lag_con(lprec *lp, char *row, long con_type, double rhs)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = str_add_lag_con(lp, row, (short) con_type, rhs);
  }
  else
   ret = -1;
  return(ret);
 }

/* Add a Column to the problem */
long __declspec(dllexport) WINAPI _add_column(lprec *lp, double *column)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = add_column(lp, column);
  }
  else
   ret = 0;
  return(ret);
 }

/* Add a Column to the problem with string input */
long __declspec(dllexport) WINAPI _str_add_column(lprec *lp, char *column)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = str_add_column(lp, column);
  }
  else
   ret = 0;
  return(ret);
 }

/* Delete a column */
long __declspec(dllexport) WINAPI _del_column(lprec *lp, long column)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = del_column(lp, column);
  }
  else
   ret = 0;
  return(ret);
 }

/* Set the upperbound of a variable */
long __declspec(dllexport) WINAPI _set_upbo(lprec *lp, long column, double value)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_upbo(lp, column, value);
  }
  else
   ret = 0;
  return(ret);
 }

/* Set the lowerbound of a variable */
long __declspec(dllexport) WINAPI _set_lowbo(lprec *lp, long column, double value)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_lowbo(lp, column, value);
  }
  else
   ret = 0;
  return(ret);
 }

long __declspec(dllexport) WINAPI _set_bounds(lprec *lp, long column, double lower, double upper)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_bounds(lp, column, lower, upper);
  }
  else
   ret = 0;
  return(ret);
 }

/* Set the upper range of a constraint */
long __declspec(dllexport) WINAPI _set_uprange(lprec *lp, long row, double value)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_uprange(lp, row, value);
  }
  else
   ret = 0;
  return(ret);
 }

/* Set the lower range of a constraint */
long __declspec(dllexport) WINAPI _set_lowrange(lprec *lp, long row, double value)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_lowrange(lp, row, value);
  }
  else
   ret = 0;
  return(ret);
 }

/* Set the type of variable, if must_be_int = TRUE then the variable must be integer */
long __declspec(dllexport) WINAPI _set_int(lprec *lp, long column, long must_be_int)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_int(lp, column, (short) ((must_be_int == 0) ? FALSE : TRUE));
  }
  else
   ret = 0;
  return(ret);
 }

/* check if var is integer */
long __declspec(dllexport) WINAPI _is_int(lprec *lp, long column)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_int(lp, column);
  }
  else
   ret = 0;
  return(ret);
 }

/* set var semi-continious */
long __declspec(dllexport) WINAPI _set_semicont(lprec *lp, long column, long must_be_sc)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = set_semicont(lp, column, (short) ((must_be_sc == 0) ? FALSE : TRUE));
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_verbose(lprec *lp, long verbose)
 {
  if (lp != NULL) {
   freebuferror();
   set_verbose(lp, (short) verbose);
  }
 }

long __declspec(dllexport) WINAPI _get_verbose(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_verbose(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_timeout(lprec *lp, long sectimeout)
 {
  if (lp != NULL) {
   freebuferror();
   set_timeout(lp, sectimeout);
  }
 }

long __declspec(dllexport) WINAPI _get_timeout(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_timeout(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_print_duals(lprec *lp, long print_duals)
 {
  if (lp != NULL) {
   freebuferror();
   set_print_duals(lp, (MYBOOL) ((print_duals == 0) ? FALSE : TRUE));
  }
 }

long __declspec(dllexport) WINAPI _is_print_duals(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_print_duals(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_print_sol(lprec *lp, long print_sol)
 {
  if (lp != NULL) {
   freebuferror();
   set_print_sol(lp, (MYBOOL) ((print_sol == 0) ? FALSE : TRUE));
  }
 }

long __declspec(dllexport) WINAPI _is_print_sol(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_print_sol(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_debug(lprec *lp, long debug)
 {
  if (lp != NULL) {
   freebuferror();
   set_debug(lp, (MYBOOL) ((debug == 0) ? FALSE : TRUE));
  }
 }

long __declspec(dllexport) WINAPI _is_debug(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_debug(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_print_at_invert(lprec *lp, long print_at_invert)
 {
  if (lp != NULL) {
   freebuferror();
   set_print_at_invert(lp, (MYBOOL) ((print_at_invert == 0) ? FALSE : TRUE));
  }
 }

long __declspec(dllexport) WINAPI _is_print_at_invert(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_print_at_invert(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_trace(lprec *lp, long trace)
 {
  if (lp != NULL) {
   freebuferror();
   set_trace(lp, (MYBOOL) ((trace == 0) ? FALSE : TRUE));
  }
 }

long __declspec(dllexport) WINAPI _is_trace(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_trace(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_anti_degen(lprec *lp, long anti_degen)
 {
  if (lp != NULL) {
   freebuferror();
   set_anti_degen(lp, (MYBOOL) ((anti_degen == 0) ? FALSE : TRUE));
  }
 }

long __declspec(dllexport) WINAPI _is_anti_degen(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_anti_degen(lp);
  }
  else
   ret = 0;
  return(ret);
 }

long __declspec(dllexport) WINAPI _is_do_presolve(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_do_presolve(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_do_presolve(lprec *lp, long do_presolve)
 {
  if (lp != NULL) {
   freebuferror();
   set_do_presolve(lp, (MYBOOL) ((do_presolve == 0) ? FALSE : TRUE));
  }
 }

void __declspec(dllexport) WINAPI _set_max_num_inv(lprec *lp, long max_num_inv)
 {
  if (lp != NULL) {
   freebuferror();
   set_max_num_inv(lp, (int) max_num_inv);
  }
 }

long __declspec(dllexport) WINAPI _get_max_num_inv(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_max_num_inv(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_bb_rule(lprec *lp, long bb_rule)
 {
  if (lp != NULL) {
   freebuferror();
   set_bb_rule(lp, (MYBOOL) bb_rule);
  }
 }

long __declspec(dllexport) WINAPI _get_bb_rule(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_bb_rule(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_obj_bound(lprec *lp, double obj_bound)
 {
  if (lp != NULL) {
   freebuferror();
   set_obj_bound(lp, (REAL) obj_bound);
  }
 }

double __declspec(dllexport) WINAPI _get_obj_bound(lprec *lp)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = (double) get_obj_bound(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_floor_first(lprec *lp, long floor_first)
 {
  if (lp != NULL) {
   freebuferror();
   set_floor_first(lp, (MYBOOL) floor_first);
  }
 }

long __declspec(dllexport) WINAPI _get_floor_first(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_floor_first(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_infinite(lprec *lp, double infinite)
 {
  if (lp != NULL) {
   freebuferror();
   set_infinite(lp, (REAL) infinite);
  }
 }

double __declspec(dllexport) WINAPI _get_infinite(lprec *lp)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = (double) get_infinite(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_epsilon(lprec *lp, double epsilon)
 {
  if (lp != NULL) {
   freebuferror();
   set_epsilon(lp, (REAL) epsilon);
  }
 }

double __declspec(dllexport) WINAPI _get_epsilon(lprec *lp)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = (double) get_epsilon(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_epsb(lprec *lp, double epsb)
 {
  if (lp != NULL) {
   freebuferror();
   set_epsb(lp, (REAL) epsb);
  }
 }

double __declspec(dllexport) WINAPI _get_epsb(lprec *lp)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = (double) get_epsb(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_epsd(lprec *lp, double epsd)
 {
  if (lp != NULL) {
   freebuferror();
   set_epsd(lp, (REAL) epsd);
  }
 }

double __declspec(dllexport) WINAPI _get_epsd(lprec *lp)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = (double) get_epsd(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_epsel(lprec *lp, double epsel)
 {
  if (lp != NULL) {
   freebuferror();
   set_epsel(lp, (REAL) epsel);
  }
 }

double __declspec(dllexport) WINAPI _get_epsel(lprec *lp)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = (double) get_epsel(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_scalemode(lprec *lp, long scalemode)
 {
  if (lp != NULL) {
   freebuferror();
   set_scalemode(lp, (MYBOOL) scalemode);
  }
 }

long __declspec(dllexport) WINAPI _get_scalemode(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_scalemode(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_improve(lprec *lp, long improve)
 {
  if (lp != NULL) {
   freebuferror();
   set_improve(lp, (MYBOOL) improve);
  }
 }

long __declspec(dllexport) WINAPI _is_improve(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_improve(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_lag_trace(lprec *lp, long lag_trace)
 {
  if (lp != NULL) {
   freebuferror();
   set_lag_trace(lp, (MYBOOL) lag_trace);
  }
 }

long __declspec(dllexport) WINAPI _is_lag_trace(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_lag_trace(lp);
  }
  else
   ret = 0;
  return(ret);
 }

void __declspec(dllexport) WINAPI _set_piv_rule(lprec *lp, long piv_rule)
 {
  if (lp != NULL) {
   freebuferror();
   set_piv_rule(lp, (MYBOOL) piv_rule);
  }
 }

long __declspec(dllexport) WINAPI _get_piv_rule(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_piv_rule(lp);
  }
  else
   ret = 0;