lpkit.h

利用c语言编写

/* The same, but with string input */

int del_constraint(lprec *lp,int del_row);
/* Remove constrain nr del_row from the problem */

int add_lag_con(lprec *lp, REAL *row, short con_type, REAL rhs);
/* add a Lagrangian constraint of form Row' x contype Rhs */
int str_add_lag_con(lprec *lp, char *row, short con_type, REAL rhs);
/* The same, but with string input */

int add_column(lprec *lp, REAL *column);
/* Add a Column to the problem */
int str_add_column(lprec *lp, char *col_string);
/* The same, but with string input */

int del_column(lprec *lp, int column);
/* Delete a column */

int set_upbo(lprec *lp, int column, REAL value);
/* Set the upperbound of a variable */

int set_lowbo(lprec *lp, int column, REAL value);
/* Set the lowerbound of a variable */

int set_uprange(lprec *lp, int row, REAL value);
/* Set the upper range of a constraint */

int set_lowrange(lprec *lp, int row, REAL value);
/* Set the lower range of a constraint */

int set_int(lprec *lp, int column, short must_be_int);
/* Set the type of variable, if must_be_int = TRUE then the variable must be integer */

int is_int(lprec *lp, int column);

int set_semicont(lprec *lp, int column, short must_be_sc);

int is_semicont(lprec *lp, int column);

void set_verbose(lprec *lp, short verbose);
short get_verbose(lprec *lp);

void set_timeout(lprec *lp, long sectimeout);
long get_timeout(lprec *lp);

void set_print_duals(lprec *lp, MYBOOL print_duals);
MYBOOL is_print_duals(lprec *lp);

void set_print_sol(lprec *lp, MYBOOL print_sol);
MYBOOL is_print_sol(lprec *lp);

void set_debug(lprec *lp, MYBOOL debug);
MYBOOL is_debug(lprec *lp);

void set_print_at_invert(lprec *lp, short print_at_invert);
short is_print_at_invert(lprec *lp);

void set_trace(lprec *lp, MYBOOL trace);
MYBOOL is_trace(lprec *lp);

void set_anti_degen(lprec *lp, MYBOOL anti_degen);
MYBOOL is_anti_degen(lprec *lp);

void set_do_presolve(lprec *lp, MYBOOL do_presolve);
MYBOOL is_do_presolve(lprec *lp);

void set_max_num_inv(lprec *lp, int max_num_inv);
int get_max_num_inv(lprec *lp);

void set_bb_rule(lprec *lp, MYBOOL bb_rule);
MYBOOL get_bb_rule(lprec *lp);

void set_obj_bound(lprec *lp, REAL obj_bound);
REAL get_obj_bound(lprec *lp);

void set_floor_first(lprec *lp, MYBOOL floor_first);
MYBOOL get_floor_first(lprec *lp);

void set_infinite(lprec *lp, REAL infinite);
REAL get_infinite(lprec *lp);

void set_epsilon(lprec *lp, REAL epsilon);
REAL get_epsilon(lprec *lp);

void set_epsb(lprec *lp, REAL epsb);
REAL get_epsb(lprec *lp);

void set_epsd(lprec *lp, REAL epd);
REAL get_epsd(lprec *lp);

void set_epsel(lprec *lp, REAL epsel);
REAL get_epsel(lprec *lp);

void set_scalemode(lprec *lp, MYBOOL scalemode);
MYBOOL get_scalemode(lprec *lp);

void set_improve(lprec *lp, MYBOOL improve);
MYBOOL is_improve(lprec *lp);

void set_lag_trace(lprec *lp, MYBOOL lag_trace);
MYBOOL is_lag_trace(lprec *lp);

void set_piv_rule(lprec *lp, MYBOOL piv_rule);
MYBOOL get_piv_rule(lprec *lp);

void set_break_at_first(lprec *lp, MYBOOL break_at_first);
MYBOOL is_break_at_first(lprec *lp);

void set_bb_floorfirst(lprec *lp, short bb_floorfirst);
short is_bb_floorfirst(lprec *lp);

void set_break_at_value(lprec *lp, REAL break_at_value);
REAL get_break_at_value(lprec *lp);

void set_negrange(lprec *lp, REAL negrange);
REAL get_negrange(lprec *lp);

void set_epsperturb(lprec *lp, REAL epsperturb);
REAL get_epsperturb(lprec *lp);

void set_epspivot(lprec *lp, REAL epspivot);
REAL get_epspivot(lprec *lp);

int get_max_level(lprec *lp);

int get_total_nodes(lprec *lp);

int get_total_iter(lprec *lp);

REAL get_objective(lprec *lp);

int get_variables(lprec *lp, REAL *var);

int get_ptr_variables(lprec *lp, REAL **var);

int get_constraints(lprec *lp, REAL *constr);

int get_ptr_constraints(lprec *lp, REAL **constr);

int get_sensitivity_rhs(lprec *lp, REAL *duals, REAL *dualsfrom, REAL *dualstill);

int get_ptr_sensitivity_rhs(lprec *lp, REAL **duals, REAL **dualsfrom, REAL **dualstill);

int get_sensitivity_obj(lprec *lp, REAL *objfrom, REAL *objtill);

int get_ptr_sensitivity_obj(lprec *lp, REAL **objfrom, REAL **objtill);

int get_Nrows(lprec *lp);

int get_Ncolumns(lprec *lp);

/* Add SOS constraints */
int add_SOS(lprec *lp, char *name, short sostype, int priority, int count, int *sosvars, REAL *weights);
int is_SOS_var(lprec *lp, int column);

int set_lp_name(lprec *lp, char *name);

int set_rh(lprec *lp, int row, REAL value);
REAL get_rh(lprec *lp, int row);
/* Set the right hand side of a constraint row */

int set_rh_range(lprec *lp, int row, REAL deltavalue);
REAL get_rh_range(lprec *lp, int row);
/* Set the RHS range; i.e. the lower and upper bounds of a constraint row */

void set_rh_vec(lprec *lp, REAL *rh);
/* Set the right hand side vector */
int str_set_rh_vec(lprec *lp, char *rh_string);
/* The same, but with string input */

void set_maxim(lprec *lp);
/* maximise the objective function */

void set_minim(lprec *lp);
/* minimize the objective function */

int set_constr_type(lprec *lp, int row, short con_type);
/* Set the type of constraint in row Row (LE, GE, EQ) */

int get_constr_type(lprec *lp, int row);
/* get the type of constraint in row Row (LE, GE, EQ) */

int set_row_name(lprec *lp, int row, char *new_name);
/* Set the name of a constraint row, make sure that the name has < 25 characters */

char *get_row_name(lprec *lp, int row);

int set_col_name(lprec *lp, int column, char *new_name);
/* Set the name of a varaible column, make sure that the name has < 25 characters */

char *get_col_name(lprec *lp, int column);

REAL scale(lprec *lp, REAL *myrowscale, REAL *mycolscale);
/* Automatic scaling of the problem */

REAL auto_scale(lprec *lp);
/* Automatic scaling of the problem */

int scaleCR(lprec *lp);
/* Curtis-Reid scaling */

void unscale(lprec *lp);
/* Remove all scaling from the problem */

/* Set/Get basis for a re-solved system */  /* Added by KE */
void set_basis(lprec *lp, int *bascolumn);
void get_basis(lprec *lp, int *bascolumn);

int solve(lprec *lp);
/* Solve the problem */

int lag_solve(lprec *lp, REAL start_bound, int num_iter, short verbose);
/* Do NumIter iterations with Lagrangian relaxation constraints */

void reset_basis(lprec *lp);
/* Reset the basis of a problem, can be usefull in case of degeneracy - JD */

REAL mat_elm(lprec *lp, int row, int column);
/* get a single element from the matrix */

int get_row(lprec *lp, int row_nr, REAL *row);
/* fill row with the row row_nr from the problem */

int get_column(lprec *lp, int col_nr, REAL *column);
/* fill column with the column col_nr from the problem */

int get_reduced_costs(lprec *lp, REAL *rc);
/* get the reduced costs vector */

int is_feasible(lprec *lp, REAL *values);
/* returns TRUE if the vector in values is a feasible solution to the lp */

int column_in_lp(lprec *lp, REAL *column);
/* returns TRUE if column is already present in lp. (Does not look at bounds
   and types, only looks at matrix values */

lprec *read_MPS(char *input, short verbose);
lprec *read_mps(FILE *input, short verbose);
/* read a MPS file */

int write_mps(lprec *lp, char *output);
int write_MPS(lprec *lp, FILE *output);
/* write a MPS file to output */

int write_lp(lprec *lp, char *output);
int write_LP(lprec *lp, FILE *output);
/* write a LP file to output */

void print_lp(lprec *lp);
/* Print the current problem, only usefull in very small (test) problems.
  Shows the effect of scaling */

void print_objective(lprec *lp);
/* Print the value of the objective */

void print_solution(lprec *lp);
/* Print the values of the variables */

void print_constraints(lprec *lp);
/* Print the values of the constraints */

void print_duals(lprec *lp);
/* Print the dual variables of the solution */

void print_scales(lprec *lp);
/* If scaling is used, print the scaling factors */

int print_file(char *filename);
/* file where results are printed to. Default stderr. If NULL then back stderr */

/* Allow the user to define an interruption callback function */
void put_abortfunc(lprec *lp, abortfunc newabort, void *aborthandle);

/* Allow the user to define a logging function */
void put_logfunc(lprec *lp, logfunc newlog, void *loghandle);

/* Allow the user to define an event-driven message/reporting */
void put_msgfunc(lprec *lp, msgfunc newmsg, void *msghandle);


/* functions used internaly by the lp toolkit */
lprec *make_lpext(int rows, int columns, int non_zeros, int mat_alloc, char *lp_name);
int report(lprec *lp, short level, char *format, ...);
int inc_mat_space(lprec *lp, int max_extra);
int inc_row_space(lprec *lp);
int inc_col_space(lprec *lp);
void unscale_columns(lprec *lp);
void btran(lprec *lp, REAL *row, REAL roundzero);
int presolve(lprec *lp);
MYBOOL isvalid(lprec *lp);
REAL get_mat(lprec *lp, int row, int column);
int set_upbo(lprec *lp, int column, REAL value);
REAL get_upbo(lprec *lp, int column);
int set_lowbo(lprec *lp, int column, REAL value);
REAL get_lowbo(lprec *lp, int column);
int set_bounds(lprec *lp, int column, REAL lower, REAL upper);
int preprocess(lprec *lp);
void postprocess(lprec *lp);
int set_matrix(lprec *lp, int Row, int Column, REAL Value, MYBOOL doscale);
int SOS_infeasible(lprec *lp, int sosindex);
int SOS_get_type(lprec *lp, int sosindex);
int SOS_is_member(lprec *lp, int sosindex, int column);
int SOS_fix_unmarked(lprec *lp, int variable, int sosindex, REAL *bound, REAL value, MYBOOL isupper, int *diffcount);
int append_SOSrec(lprec *lp, SOSrec *SOS, int size, int *variables, REAL *weights);
MYBOOL SOS_set_marked(lprec *lp, int sosindex, int column, MYBOOL islive);
REAL get_mat_raw(lprec *lp, int row, int column);
MYBOOL SOS_unmark(lprec *lp, int sosindex, int column, MYBOOL islive);
MYBOOL SOS_is_member_of_type(lprec *lp, int column, short sostype);
MYBOOL SOS_is_active(lprec *lp, int sosindex, int column);
int SOS_is_satisfied(lprec *lp, int sosindex, REAL *solution);
MYBOOL SOS_can_mark(lprec *lp, int sosindex, int column);

/* define yyparse() to make compilers happy. There should be some system
   include file for this */
int yyparse(void);
void yyerror(char *);
void check_decl(int);
int yywrap();

#ifdef __cplusplus
};
#endif

#endif