windll.c

利用c语言编写

  return(ret);
 }

void __declspec(dllexport) WINAPI _set_break_at_first(lprec *lp, long break_at_first)
 {
  if (lp != NULL) {
   freebuferror();
   set_break_at_first(lp, (MYBOOL) break_at_first);
  }
 }

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

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

void __declspec(dllexport) WINAPI _set_bb_floorfirst(lprec *lp, long bb_floorfirst)
 {
  if (lp != NULL) {
   freebuferror();
   set_bb_floorfirst(lp, (short) bb_floorfirst);
  }
 }

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

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

void __declspec(dllexport) WINAPI _set_break_at_value(lprec *lp, double break_at_value)
 {
  if (lp != NULL) {
   freebuferror();
   set_break_at_value(lp, break_at_value);
  }
 }

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

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

void __declspec(dllexport) WINAPI _set_negrange(lprec *lp, double negrange)
 {
  if (lp != NULL) {
   freebuferror();
   set_negrange(lp, negrange);
  }
 }

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

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

void __declspec(dllexport) WINAPI _set_epsperturb(lprec *lp, double epsperturb)
 {
  if (lp != NULL) {
   freebuferror();
   set_epsperturb(lp, epsperturb);
  }
 }

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

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

void __declspec(dllexport) WINAPI _set_epspivot(lprec *lp, double epspivot)
 {
  if (lp != NULL) {
   freebuferror();
   set_epspivot(lp, epspivot);
  }
 }

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

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

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

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

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

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

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

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

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

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

long __declspec(dllexport) WINAPI _get_variables(lprec *lp, double *variables)
 {
  long ret;

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

long __declspec(dllexport) WINAPI _get_constraints(lprec *lp, double *constraints)
 {
  long ret;

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

/* check if var is semi-continious */
long __declspec(dllexport) WINAPI _is_semicont(lprec *lp, long column)
 {
  long ret;

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

/* Add SOS constraint */
long __declspec(dllexport) WINAPI _add_SOS(lprec *lp, char *name, long sostype, long priority, long count, long *sosvars, double *weights)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = add_SOS(lp, name, (short) sostype, priority, count, sosvars, weights);
  }
  else
   ret = 0;
  return(ret);
 }

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

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

/* Set the name of the model */
long __declspec(dllexport) WINAPI _set_lp_name(lprec *lp, char *name)
 {
  long ret;

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

/* Set the right hand side of a constraint row */
long __declspec(dllexport) WINAPI _set_rh(lprec *lp, long row, double value)
 {
  long ret;

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

/* Get the right hand side of a constraint row */
double __declspec(dllexport) WINAPI _get_rh(lprec *lp, long row)
 {
  double ret;

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

/* Set the right hand side vector range */
long __declspec(dllexport) WINAPI _set_rh_range(lprec *lp, long row, double deltavalue)
 {
  long ret;

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

/* Get the right hand side vector range */
double __declspec(dllexport) WINAPI _get_rh_range(lprec *lp, long row)
 {
  double ret;

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

/* Set the right hand side vector */
void __declspec(dllexport) WINAPI _set_rh_vec(lprec *lp, double *rh)
 {
  if (lp != NULL) {
   freebuferror();
   set_rh_vec(lp, rh);
  }
 }

/* Set the right hand side vector with string input */
long __declspec(dllexport) WINAPI _str_set_rh_vec(lprec *lp, char *rh)
 {
  long ret;

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

/* maximise the objective function */
void __declspec(dllexport) WINAPI _set_maxim(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   set_maxim(lp);
  }
 }

/* minimise the objective function */
void __declspec(dllexport) WINAPI _set_minim(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   set_minim(lp);
  }
 }

/* Set the type of constraint in row Row (LE, GE, EQ) */
long __declspec(dllexport) WINAPI _set_constr_type(lprec *lp, long row, long con_type)
 {
  long ret;

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

/* Get the type of constraint in row Row (LE, GE, EQ) */
long __declspec(dllexport) WINAPI _get_constr_type(lprec *lp, long row)
 {
  long ret;

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

/* Set the name of a constraint row */
long __declspec(dllexport) WINAPI _set_row_name(lprec *lp, long row, char *new_name)
 {
  long ret;

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

/* Get the name of a constraint row */
char __declspec(dllexport) *WINAPI _get_row_name(lprec *lp, long row)
 {
  char *ret;

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

/* Set the name of a variable column */
long __declspec(dllexport) WINAPI _set_col_name(lprec *lp, long column, char *new_name)
 {
  long ret;

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

/* Get the name of a variable column */
char __declspec(dllexport) *WINAPI _get_col_name(lprec *lp, long column)
 {
  char *ret;

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

/* scale of the problem */
double __declspec(dllexport) WINAPI _scale(lprec *lp, double *myrowscale, double *mycolscale)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = scale(lp, myrowscale, mycolscale);
  }
  else
   ret = 0.0;
  return(ret);
 }

/* Automatic scaling of the problem */
double __declspec(dllexport) WINAPI _auto_scale(lprec *lp)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = auto_scale(lp);
  }
  else
   ret = 0.0;
  return(ret);
 }

/* Curtis-Reid scaling */
long __declspec(dllexport) WINAPI _scaleCR(lprec *lp)
 {
  long ret;

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

/* Remove all scaling from the problem */
void __declspec(dllexport) WINAPI _unscale(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   unscale(lp);
  }
 }

/* Set the basis of a problem */
void __declspec(dllexport) WINAPI _set_basis(lprec *lp, long *bascolumn)
 {
  if (lp != NULL) {
   freebuferror();
   set_basis(lp, bascolumn);
  }
 }

/* Get the basis of a problem */
void __declspec(dllexport) WINAPI _get_basis(lprec *lp, long *bascolumn)
 {
  if (lp != NULL) {
   freebuferror();
   get_basis(lp, bascolumn);
  }
 }

/* Solve the problem */
long __declspec(dllexport) WINAPI _solve(lprec *lp)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = solve(lp);
  }
  else
   ret = FAILURE;
  return(ret);
 }

/* Do NumIter iterations with Lagrangian relaxation constraints */
long __declspec(dllexport) WINAPI _lag_solve(lprec *lp, double start_bound, long num_iter, long verbose)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = lag_solve(lp, start_bound, num_iter, (short) ((verbose == 0) ? FALSE : TRUE));
  }
  else
   ret = FAILURE;
  return(ret);
 }

/* Reset the basis of a problem, can be usefull in case of degeneracy - JD */
void __declspec(dllexport) WINAPI _reset_basis(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   reset_basis(lp);
  }
 }

/* get a single element from the matrix */
double __declspec(dllexport) WINAPI _mat_elm(lprec *lp, long row, long column)
 {
  double ret;

  if (lp != NULL) {
   freebuferror();
   ret = mat_elm(lp, row, column);
  }
  else
   ret = 0.0;
  return(ret);
 }

/* fill row with the row row_nr from the problem */
long __declspec(dllexport) WINAPI _get_row(lprec *lp, long row_nr, double *row)
 {
  long ret;

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

/* fill column with the column col_nr from the problem */
long __declspec(dllexport) WINAPI _get_column(lprec *lp, long col_nr, double *column)
 {
  long ret;

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

/* get the reduced costs vector */
long __declspec(dllexport) WINAPI _get_reduced_costs(lprec *lp, double *rc)
 {
  long ret;

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

/* get sensitivity objective function */
long __declspec(dllexport) WINAPI _get_sensitivity_obj(lprec *lp, double *objfrom, double *objtill)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_sensitivity_obj(lp, objfrom, objtill);
  }
  return(ret);
 }

/* get sensitivity RHS */
long __declspec(dllexport) WINAPI _get_sensitivity_rhs(lprec *lp, double *duals, double *dualsfrom, double *dualstill)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = get_sensitivity_rhs(lp, duals, dualsfrom, dualstill);
  }
  else
   ret = 0;
  return(ret);
 }

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

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

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

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

/* returns TRUE if the vector in values is a feasible solution to the lp */
long __declspec(dllexport) WINAPI _is_feasible(lprec *lp, double *values)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = is_feasible(lp, values);
  }
  else
   ret = FALSE;
  return(ret);
 }

/* returns TRUE if column is already present in lp. (Does not look at bounds
   and types, only looks at matrix values */
long __declspec(dllexport) WINAPI _column_in_lp(lprec *lp, double *column)
 {
  long ret;

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

/* read a MPS file */
lprec __declspec(dllexport) * WINAPI _read_MPS(char *filename, long verbose)
 {
  lprec *lp;

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

/* write a MPS file to output */
long __declspec(dllexport) WINAPI _write_mps(lprec *lp, char *filename)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = write_mps(lp, filename);
  }
  return(ret);
 }

/* write a LP file to output */
long __declspec(dllexport) WINAPI _write_lp(lprec *lp, char *filename)
 {
  long ret;

  if (lp != NULL) {
   freebuferror();
   ret = write_lp(lp, filename);
  }
  return(ret);
 }

/* Print the current problem, only usefull in very small (test) problems.
  Shows the effect of scaling */
void __declspec(dllexport) WINAPI _print_lp(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   print_lp(lp);
  }
 }

/* Print the objective value */
void __declspec(dllexport) WINAPI _print_objective(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   print_objective(lp);
  }
 }

/* Print the solution */
void __declspec(dllexport) WINAPI _print_solution(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   print_solution(lp);
  }
 }

/* Print the constrataints */
void __declspec(dllexport) WINAPI _print_constraints(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   print_constraints(lp);
  }
 }

/* Print the dual variables of the solution */
void __declspec(dllexport) WINAPI _print_duals(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   print_duals(lp);
  }
 }

/* If scaling is used, print the scaling factors */
void __declspec(dllexport) WINAPI _print_scales(lprec *lp)
 {
  if (lp != NULL) {
   freebuferror();
   print_scales(lp);
  }
 }

/* file where results are printed to. Default stdout. If NULL then back stdout */
long __declspec(dllexport) WINAPI _print_file(char *filename)
 {
  freebuferror();
  return(print_file(filename));
 }

/* print a string */
void __declspec(dllexport) WINAPI _print_str(char *str)
 {
  print_str(str);
 }

void __declspec(dllexport) WINAPI _put_abortfunc(lprec *lp, abortfunc newabort, void *aborthandle)
 {
  put_abortfunc(lp, newabort, aborthandle);
 }

void __declspec(dllexport) WINAPI _put_logfunc(lprec *lp, logfunc newlog, void *loghandle)
 {
  put_logfunc(lp, newlog, loghandle);
 }

void __declspec(dllexport) WINAPI _put_msgfunc(lprec *lp, msgfunc newmsg, void *msghandle)
 {
  put_msgfunc(lp, newmsg, msghandle);
 }

void EndOfPgr(i)
 int i;
 {
 }

void __declspec(dllexport) WINAPI __Fortify_EnterScope()
 {
  Fortify_EnterScope();
 }

void __declspec(dllexport) WINAPI __Fortify_LeaveScope()
 {
  Fortify_LeaveScope();
 }