LPX *lpx_read_freemps(const char *fname)
{ /* read problem data in free MPS format */
LPX *lp = lpx_create_prob();
if (glp_read_mps(lp, GLP_MPS_FILE, NULL, fname))
lpx_delete_prob(lp), lp = NULL;
return lp;
}
LPX *lpx_read_cpxlp(const char *fname)
{ /* read problem data in CPLEX LP format */
LPX *lp;
lp = lpx_create_prob();
if (glp_read_lp(lp, NULL, fname))
lpx_delete_prob(lp), lp = NULL;
return lp;
}
int CClp_create(CClp *lp, const char *name)
{ /* CREATES an empty lp. This supports an alternative to
CClp_loadlp for loading a problem.
- name attaches a name to the LP (it can be used by the LP
solver in io routines). */
insist(lp->lp == NULL);
lp->lp = lpx_create_prob();
lpx_set_prob_name(lp->lp, (char *)name);
return 0;
}
int GLPKInitialize() {
if (GLPKModel != NULL) {
if (GLPKClearSolver() == FAIL) {
return FAIL;
}
}
GLPKModel = lpx_create_prob();
//lpx_set_int_parm(GLPKModel, LPX_K_BFTYPE,3);
lpx_set_class(GLPKModel, LPX_LP);
return SUCCESS;
}
int main(void)
{ LPX *lp;
int ia[1+1000], ja[1+1000];
double ar[1+1000], Z, x1, x2, x3;
s1: lp = lpx_create_prob();
s2: lpx_set_prob_name(lp, "sample");
s3: lpx_set_obj_dir(lp, LPX_MAX);
s4: lpx_add_rows(lp, 3);
s5: lpx_set_row_name(lp, 1, "p");
s6: lpx_set_row_bnds(lp, 1, LPX_UP, 0.0, 100.0);
s7: lpx_set_row_name(lp, 2, "q");
s8: lpx_set_row_bnds(lp, 2, LPX_UP, 0.0, 600.0);
s9: lpx_set_row_name(lp, 3, "r");
s10: lpx_set_row_bnds(lp, 3, LPX_UP, 0.0, 300.0);
s11: lpx_add_cols(lp, 3);
s12: lpx_set_col_name(lp, 1, "x1");
s13: lpx_set_col_bnds(lp, 1, LPX_LO, 0.0, 0.0);
s14: lpx_set_obj_coef(lp, 1, 10.0);
s15: lpx_set_col_name(lp, 2, "x2");
s16: lpx_set_col_bnds(lp, 2, LPX_LO, 0.0, 0.0);
s17: lpx_set_obj_coef(lp, 2, 6.0);
s18: lpx_set_col_name(lp, 3, "x3");
s19: lpx_set_col_bnds(lp, 3, LPX_LO, 0.0, 0.0);
s20: lpx_set_obj_coef(lp, 3, 4.0);
s21: ia[1] = 1, ja[1] = 1, ar[1] = 1.0; /* a[1,1] = 1 */
s22: ia[2] = 1, ja[2] = 2, ar[2] = 1.0; /* a[1,2] = 1 */
s23: ia[3] = 1, ja[3] = 3, ar[3] = 1.0; /* a[1,3] = 1 */
s24: ia[4] = 2, ja[4] = 1, ar[4] = 10.0; /* a[2,1] = 10 */
s25: ia[5] = 3, ja[5] = 1, ar[5] = 2.0; /* a[3,1] = 2 */
s26: ia[6] = 2, ja[6] = 2, ar[6] = 4.0; /* a[2,2] = 4 */
s27: ia[7] = 3, ja[7] = 2, ar[7] = 2.0; /* a[3,2] = 2 */
s28: ia[8] = 2, ja[8] = 3, ar[8] = 5.0; /* a[2,3] = 5 */
s29: ia[9] = 3, ja[9] = 3, ar[9] = 6.0; /* a[3,3] = 6 */
s30: lpx_load_matrix(lp, 9, ia, ja, ar);
s31: lpx_simplex(lp);
s32: Z = lpx_get_obj_val(lp);
s33: x1 = lpx_get_col_prim(lp, 1);
s34: x2 = lpx_get_col_prim(lp, 2);
s35: x3 = lpx_get_col_prim(lp, 3);
s36: printf("\nZ = %g; x1 = %g; x2 = %g; x3 = %g\n", Z, x1, x2, x3);
s37: lpx_delete_prob(lp);
return 0;
}
LPX *lpp_build_prob(LPP *lpp)
{ LPX *prob;
LPPROW *row;
LPPCOL *col;
struct load_info info;
int i, j, typx;
/* count number of rows and columns in the resultant problem */
lpp->m = lpp->n = 0;
for (row = lpp->row_ptr; row != NULL; row = row->next) lpp->m++;
for (col = lpp->col_ptr; col != NULL; col = col->next) lpp->n++;
/* allocate two arrays to save reference numbers assigned to rows
and columns of the resultant problem */
lpp->row_ref = ucalloc(1+lpp->m, sizeof(int));
lpp->col_ref = ucalloc(1+lpp->n, sizeof(int));
/* create LP problem object */
prob = lpx_create_prob();
/* the resultant problem should have the same optimization sense
as the original problem */
lpx_set_obj_dir(prob, lpp->orig_dir);
/* set the constant term of the objective function */
lpx_set_obj_c0(prob,
lpp->orig_dir == LPX_MIN ? + lpp->c0 : - lpp->c0);
/* create rows of the resultant problem */
insist(lpp->m > 0);
lpx_add_rows(prob, lpp->m);
for (i = 1, row = lpp->row_ptr; i <= lpp->m; i++, row = row->next)
{ insist(row != NULL);
lpp->row_ref[i] = row->i;
row->i = i;
if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
typx = LPX_FR;
else if (row->ub == +DBL_MAX)
typx = LPX_LO;
else if (row->lb == -DBL_MAX)
typx = LPX_UP;
else if (row->lb != row->ub)
typx = LPX_DB;
else
typx = LPX_FX;
lpx_set_row_bnds(prob, i, typx, row->lb, row->ub);
}
insist(row == NULL);
/* create columns of the resultant problem */
insist(lpp->n > 0);
lpx_add_cols(prob, lpp->n);
for (j = 1, col = lpp->col_ptr; j <= lpp->n; j++, col = col->next)
{ insist(col != NULL);
lpp->col_ref[j] = col->j;
col->j = j;
if (col->lb == -DBL_MAX && col->ub == +DBL_MAX)
typx = LPX_FR;
else if (col->ub == +DBL_MAX)
typx = LPX_LO;
else if (col->lb == -DBL_MAX)
typx = LPX_UP;
else if (col->lb != col->ub)
typx = LPX_DB;
else
typx = LPX_FX;
lpx_set_col_bnds(prob, j, typx, col->lb, col->ub);
lpx_set_col_coef(prob, j,
lpp->orig_dir == LPX_MIN ? + col->c : - col->c);
}
insist(col == NULL);
/* create the constraint matrix of the resultant problem */
info.lpp = lpp;
info.row = NULL;
info.aij = NULL;
lpx_load_mat(prob, &info, next_aij);
/* count number of non-zeros in the resultant problem */
lpp->nnz = lpx_get_num_nz(prob);
/* internal data structures that represnts the resultant problem
are no longer needed, so free them */
dmp_delete_pool(lpp->row_pool), lpp->row_pool = NULL;
dmp_delete_pool(lpp->col_pool), lpp->col_pool = NULL;
dmp_delete_pool(lpp->aij_pool), lpp->aij_pool = NULL;
lpp->row_ptr = NULL, lpp->col_ptr = NULL;
lpp->row_que = NULL, lpp->col_que = NULL;
/* return a pointer to the built LP problem object */
return prob;
}
LPX *lpx_read_cpxlp(const char *fname)
{ /* read problem data in CPLEX LP format */
struct dsa _dsa, *dsa = &_dsa;
if (setjmp(dsa->jump)) goto fail;
dsa->lp = NULL;
dsa->fname = fname;
dsa->fp = NULL;
dsa->count = 0;
dsa->c = '\n';
dsa->token = T_EOF;
dsa->image[0] = '\0';
dsa->imlen = 0;
dsa->value = 0.0;
dsa->n_max = 100;
dsa->map = xcalloc(1+dsa->n_max, sizeof(int));
memset(&dsa->map[1], 0, dsa->n_max * sizeof(int));
dsa->ind = xcalloc(1+dsa->n_max, sizeof(int));
dsa->val = xcalloc(1+dsa->n_max, sizeof(double));
dsa->lb = xcalloc(1+dsa->n_max, sizeof(double));
dsa->ub = xcalloc(1+dsa->n_max, sizeof(double));
print("lpx_read_cpxlp: reading problem data from `%s'...",
dsa->fname);
dsa->fp = xfopen(dsa->fname, "r");
if (dsa->fp == NULL)
{ print("lpx_read_cpxlp: unable to open `%s' - %s", dsa->fname,
strerror(errno));
goto fail;
}
dsa->lp = lpx_create_prob();
lpx_create_index(dsa->lp);
#if 0
/* read very first character */
read_char(dsa);
#endif
/* scan very first token */
scan_token(dsa);
/* parse definition of the objective function */
if (!(dsa->token == T_MINIMIZE || dsa->token == T_MAXIMIZE))
fatal(dsa, "`minimize' or `maximize' keyword missing");
parse_objective(dsa);
/* parse constraints section */
if (dsa->token != T_SUBJECT_TO)
fatal(dsa, "constraints section missing");
parse_constraints(dsa);
/* parse optional bounds section */
if (dsa->token == T_BOUNDS) parse_bounds(dsa);
/* parse optional general, integer, and binary sections */
while (dsa->token == T_GENERAL ||
dsa->token == T_INTEGER ||
dsa->token == T_BINARY) parse_integer(dsa);
/* check for the keyword 'end' */
if (dsa->token == T_END)
scan_token(dsa);
else if (dsa->token == T_EOF)
print("%s:%d: warning: keyword `end' missing", dsa->fname,
dsa->count);
else
fatal(dsa, "symbol `%s' in wrong position", dsa->image);
/* nothing must follow the keyword 'end' (except comments) */
if (dsa->token != T_EOF)
fatal(dsa, "extra symbol(s) detected beyond `end'");
/* set bounds of variables */
{ int j, type;
double lb, ub;
for (j = lpx_get_num_cols(dsa->lp); j >= 1; j--)
{ lb = dsa->lb[j];
ub = dsa->ub[j];
if (lb == +DBL_MAX) lb = 0.0; /* default lb */
if (ub == -DBL_MAX) ub = +DBL_MAX; /* default ub */
if (lb == -DBL_MAX && ub == +DBL_MAX)
type = LPX_FR;
else if (ub == +DBL_MAX)
type = LPX_LO;
else if (lb == -DBL_MAX)
type = LPX_UP;
else if (lb != ub)
type = LPX_DB;
else
type = LPX_FX;
lpx_set_col_bnds(dsa->lp, j, type, lb, ub);
}
}
/* print some statistics */
{ int m = lpx_get_num_rows(dsa->lp);
int n = lpx_get_num_cols(dsa->lp);
int nnz = lpx_get_num_nz(dsa->lp);
print("lpx_read_cpxlp: %d row%s, %d column%s, %d non-zero%s",
m, m == 1 ? "" : "s", n, n == 1 ? "" : "s", nnz, nnz == 1 ?
"" : "s");
}
if (lpx_get_class(dsa->lp) == LPX_MIP)
{ int ni = lpx_get_num_int(dsa->lp);
int nb = lpx_get_num_bin(dsa->lp);
char s[50];
if (nb == 0)
strcpy(s, "none of");
else if (ni == 1 && nb == 1)
strcpy(s, "");
else if (nb == 1)
strcpy(s, "one of");
else if (nb == ni)
strcpy(s, "all of");
else
sprintf(s, "%d of", nb);
print("lpx_read_cpxlp: %d integer column%s, %s which %s binary"
, ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
}
print("lpx_read_cpxlp: %d lines were read", dsa->count);
xfclose(dsa->fp);
xfree(dsa->map);
xfree(dsa->ind);
xfree(dsa->val);
xfree(dsa->lb);
xfree(dsa->ub);
lpx_delete_index(dsa->lp);
lpx_order_matrix(dsa->lp);
return dsa->lp;
fail: if (dsa->lp != NULL) lpx_delete_prob(dsa->lp);
if (dsa->fp != NULL) xfclose(dsa->fp);
if (dsa->map != NULL) xfree(dsa->map);
if (dsa->ind != NULL) xfree(dsa->ind);
if (dsa->val != NULL) xfree(dsa->val);
if (dsa->lb != NULL) xfree(dsa->lb);
if (dsa->ub != NULL) xfree(dsa->ub);
return NULL;
}
int CClp_loadlp(CClp *lp, const char *name, int ncols, int nrows,
int objsense, double *obj, double *rhs, char *sense, int *matbeg,
int *matcnt, int *matind, double *matval, double *lb, double *ub)
{ /* LOADS the data into the LP.
- name attaches a name to the LP (it can be used by the LP
solver in io routines)
- ncols and nrows give the number of columns and rows in the LP
- objsense should be 1 for minimize and -1 for maximize
- obj and rhs are arrays giving the objective function and rhs
- sense is an array specifying 'L', 'E', or 'G' for each of the
rows
- matbeg, matcnt, matind, and matval give the coefficients of
the constraint matrix in column by column order.
matbeg gives the index of the start of each column;
matcnt gives the number of coefficients in each column;
matind gives the indices of the rows where the coefficients
are located in the constraint matrix (so for column j, the
indices are given in matcnt[j] locations starting at
matind[matbeg[j]]; and matval gives the actual coefficients
(organized like matind).
- lb and ub are arrays giving the upper and lower bounds of the
variables. */
int i, j;
/* create empty problem object */
insist(lp->lp == NULL);
lp->lp = lpx_create_prob();
lpx_set_prob_name(lp->lp, (char *)name);
/* set objective sense */
switch (objsense)
{ case +1:
/* minimization */
lpx_set_obj_dir(lp->lp, LPX_MIN); break;
case -1:
/* maximization */
lpx_set_obj_dir(lp->lp, LPX_MAX); break;
default:
insist(objsense != objsense);
}
/* add rows */
lpx_add_rows(lp->lp, nrows);
for (i = 0; i < nrows; i++)
{ int seqn, type;
double lo, up;
seqn = i+1;
switch (sense[i])
{ case 'L':
type = LPX_UP, lo = 0.0, up = rhs[i];
break;
case 'E':
type = LPX_FX, lo = up = rhs[i];
break;
case 'G':
type = LPX_LO, lo = rhs[i], up = 0.0;
break;
default:
insist(sense[i] != sense[i]);
}
lpx_set_row_bnds(lp->lp, seqn, type, lo, up);
}
/* add columns and constraint coefficients */
lpx_add_cols(lp->lp, ncols);
for (j = 0; j < ncols; j++)
{ int seqn, type, k;
double lo, up;
seqn = j+1;
lpx_set_col_coef(lp->lp, seqn, obj == NULL ? 0.0 : obj[j]);
lo = lb[j], up = ub[j];
/* check for finite bounds */
insist(-1e12 <= lo && lo <= up && up <= +1e12);
type = (lo == up ? LPX_FX : LPX_DB);
lpx_set_col_bnds(lp->lp, seqn, type, lo, up);
for (k = matbeg[j]; k < matbeg[j] + matcnt[j]; k++)
matind[k]++;
lpx_set_mat_col(lp->lp, seqn, matcnt[j],
&matind[matbeg[j]] - 1, &matval[matbeg[j]] - 1);
for (k = matbeg[j]; k < matbeg[j] + matcnt[j]; k++)
matind[k]--;
}
return 0;
}
LPX *lpx_extract_prob(void *_mpl)
{ MPL *mpl = _mpl;
LPX *lp;
int m, n, i, j, t, kind, type, len, *ind;
double lb, ub, *val;
/* create problem instance */
lp = lpx_create_prob();
/* set problem name */
lpx_set_prob_name(lp, mpl_get_prob_name(mpl));
/* build rows (constraints) */
m = mpl_get_num_rows(mpl);
if (m > 0) lpx_add_rows(lp, m);
for (i = 1; i <= m; i++)
{ /* set row name */
lpx_set_row_name(lp, i, mpl_get_row_name(mpl, i));
/* set row bounds */
type = mpl_get_row_bnds(mpl, i, &lb, &ub);
switch (type)
{ case MPL_FR: type = LPX_FR; break;
case MPL_LO: type = LPX_LO; break;
case MPL_UP: type = LPX_UP; break;
case MPL_DB: type = LPX_DB; break;
case MPL_FX: type = LPX_FX; break;
default: insist(type != type);
}
if (type == LPX_DB && fabs(lb - ub) < 1e-9 * (1.0 + fabs(lb)))
{ type = LPX_FX;
if (fabs(lb) <= fabs(ub)) ub = lb; else lb = ub;
}
lpx_set_row_bnds(lp, i, type, lb, ub);
/* warn about non-zero constant term */
if (mpl_get_row_c0(mpl, i) != 0.0)
print("lpx_read_model: row %s; constant term %.12g ignored",
mpl_get_row_name(mpl, i), mpl_get_row_c0(mpl, i));
}
/* build columns (variables) */
n = mpl_get_num_cols(mpl);
if (n > 0) lpx_add_cols(lp, n);
for (j = 1; j <= n; j++)
{ /* set column name */
lpx_set_col_name(lp, j, mpl_get_col_name(mpl, j));
/* set column kind */
kind = mpl_get_col_kind(mpl, j);
switch (kind)
{ case MPL_NUM:
break;
case MPL_INT:
case MPL_BIN:
lpx_set_class(lp, LPX_MIP);
lpx_set_col_kind(lp, j, LPX_IV);
break;
default:
insist(kind != kind);
}
/* set column bounds */
type = mpl_get_col_bnds(mpl, j, &lb, &ub);
switch (type)
{ case MPL_FR: type = LPX_FR; break;
case MPL_LO: type = LPX_LO; break;
case MPL_UP: type = LPX_UP; break;
case MPL_DB: type = LPX_DB; break;
case MPL_FX: type = LPX_FX; break;
default: insist(type != type);
}
if (kind == MPL_BIN)
{ if (type == LPX_FR || type == LPX_UP || lb < 0.0) lb = 0.0;
if (type == LPX_FR || type == LPX_LO || ub > 1.0) ub = 1.0;
type = LPX_DB;
}
if (type == LPX_DB && fabs(lb - ub) < 1e-9 * (1.0 + fabs(lb)))
{ type = LPX_FX;
if (fabs(lb) <= fabs(ub)) ub = lb; else lb = ub;
}
lpx_set_col_bnds(lp, j, type, lb, ub);
}
/* load the constraint matrix */
ind = ucalloc(1+n, sizeof(int));
val = ucalloc(1+n, sizeof(double));
for (i = 1; i <= m; i++)
{ len = mpl_get_mat_row(mpl, i, ind, val);
lpx_set_mat_row(lp, i, len, ind, val);
}
/* build objective function (the first objective is used) */
for (i = 1; i <= m; i++)
{ kind = mpl_get_row_kind(mpl, i);
if (kind == MPL_MIN || kind == MPL_MAX)
{ /* set objective name */
lpx_set_obj_name(lp, mpl_get_row_name(mpl, i));
/* set optimization direction */
lpx_set_obj_dir(lp, kind == MPL_MIN ? LPX_MIN : LPX_MAX);
/* set constant term */
lpx_set_obj_coef(lp, 0, mpl_get_row_c0(mpl, i));
/* set objective coefficients */
len = mpl_get_mat_row(mpl, i, ind, val);
for (t = 1; t <= len; t++)
lpx_set_obj_coef(lp, ind[t], val[t]);
break;
}
}
/* free working arrays */
ufree(ind);
ufree(val);
/* bring the problem object to the calling program */
return lp;
}
LPX *ipp_build_prob(IPP *ipp)
{ LPX *prob;
IPPROW *row;
IPPCOL *col;
IPPAIJ *aij;
int i, j, type, len, *ind;
double *val;
/* create problem object */
prob = lpx_create_prob();
#if 0
lpx_set_class(prob, LPX_MIP);
#endif
/* the resultant problem should have the same optimization sense
as the original problem */
lpx_set_obj_dir(prob, ipp->orig_dir);
/* set the constant term of the objective function */
lpx_set_obj_coef(prob, 0,
ipp->orig_dir == LPX_MIN ? + ipp->c0 : - ipp->c0);
/* copy rows of the resultant problem */
for (row = ipp->row_ptr; row != NULL; row = row->next)
{ i = lpx_add_rows(prob, 1);
if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
type = LPX_FR;
else if (row->ub == +DBL_MAX)
type = LPX_LO;
else if (row->lb == -DBL_MAX)
type = LPX_UP;
else if (row->lb != row->ub)
type = LPX_DB;
else
type = LPX_FX;
lpx_set_row_bnds(prob, i, type, row->lb, row->ub);
row->temp = i;
}
/* copy columns of the resultant problem */
ind = xcalloc(1+lpx_get_num_rows(prob), sizeof(int));
val = xcalloc(1+lpx_get_num_rows(prob), sizeof(double));
for (col = ipp->col_ptr; col != NULL; col = col->next)
{ j = lpx_add_cols(prob, 1);
if (col->i_flag) lpx_set_col_kind(prob, j, LPX_IV);
if (col->lb == -DBL_MAX && col->ub == +DBL_MAX)
type = LPX_FR;
else if (col->ub == +DBL_MAX)
type = LPX_LO;
else if (col->lb == -DBL_MAX)
type = LPX_UP;
else if (col->lb != col->ub)
type = LPX_DB;
else
type = LPX_FX;
lpx_set_col_bnds(prob, j, type, col->lb, col->ub);
lpx_set_obj_coef(prob, j,
ipp->orig_dir == LPX_MIN ? + col->c : - col->c);
/* copy constraint coefficients */
len = 0;
for (aij = col->ptr; aij != NULL; aij = aij->c_next)
{ len++;
ind[len] = aij->row->temp;
val[len] = aij->val;
}
lpx_set_mat_col(prob, j, len, ind, val);
}
xfree(ind);
xfree(val);
return prob;
}
int TankBlendOptimiser::go()
{
lp = lpx_create_prob();
lpx_set_int_parm(lp, LPX_K_MSGLEV, 0); // 0 = no output
lpx_set_int_parm(lp, LPX_K_SCALE, 3); // 3 = geometric mean scaling, then equilibration scaling
lpx_set_int_parm(lp, LPX_K_DUAL, 1); // 1 = if initial basic solution is dual feasible, use the dual simplex
lpx_set_int_parm(lp, LPX_K_ROUND, 1); // 1 = replace tiny primal and dual values by exact zero
lpx_set_int_parm(lp, LPX_K_PRESOL, 1); // 1 = use the built-in presolver.
lpx_set_prob_name(lp, "Blend Optimiser");
lpx_set_obj_dir(lp, LPX_MIN);
// Columns...
lpx_add_cols(lp, cols);
for (int i=0; i<tanks; i++) // 0.0 < x < tankMax
{
if (tankMax[i]>0.0)
lpx_set_col_bnds(lp, col, LPX_DB, 0.0, tankMax[i]);
else
lpx_set_col_bnds(lp, col, LPX_FX, 0.0, 0.0);
col++;
}
for (int i=0; i<tanks; i++) // 0.0 < slackTankLow
{
lpx_set_col_bnds(lp, col, LPX_LO, 0.0, 0.0);
lpx_set_obj_coef(lp, col, tankLowPenalty[i]); // penalty weight.
col++;
}
for (int i=0; i<tanks; i++) // 0.0 < slackTankHigh
{
lpx_set_col_bnds(lp, col, LPX_LO, 0.0, 0.0);
lpx_set_obj_coef(lp, col, tankHighPenalty[i]); // penalty weight.
col++;
}
for (int i=0; i<assays; i++) // 0.0 < slackAssayLow
{
lpx_set_col_bnds(lp, col, LPX_LO, 0.0, 0.0);
lpx_set_obj_coef(lp, col, assayLowPenalty[i]); // penalty weight.
col++;
}
for (int i=0; i<assays; i++) // 0.0 < slackAssayHigh
{
lpx_set_col_bnds(lp, col, LPX_LO, 0.0, 0.0);
lpx_set_obj_coef(lp, col, assayHighPenalty[i]); // penalty weight.
col++;
}
for (int i=0; i<assays; i++) // 0.0 < slackAssayRatioLow
for (int j=0; j<assays; j++)
{
lpx_set_col_bnds(lp, col, LPX_LO, 0.0, 0.0);
lpx_set_obj_coef(lp, col, assayRatioLowPenalty[i][j]); // penalty weight.
col++;
}
for (int i=0; i<assays; i++) // 0.0 < slackAssayRatioHigh
for (int j=0; j<assays; j++)
{
lpx_set_col_bnds(lp, col, LPX_LO, 0.0, 0.0);
lpx_set_obj_coef(lp, col, assayRatioHighPenalty[i][j]); // penalty weight.
col++;
}
// Rows...
lpx_add_rows(lp, rows);
{ // x1 + ... + xn = 1.0
lpx_set_row_bnds(lp, row, LPX_FX, 1.0, 1.0);
for (int i=0; i<tanks; i++)
ia[constraint] = row, ja[constraint] = 1+i, ar[constraint++] = 1.0;
row++;
}
for (int i=0; i<tanks; i++) // tankLow < tank + slackTankLow
{
lpx_set_row_bnds(lp, row, LPX_LO, tankLow[i], 0.0);
ia[constraint] = row, ja[constraint] = 1+i, ar[constraint++] = 1.0;
ia[constraint] = row, ja[constraint] = 1+i+tanks, ar[constraint++] = 1.0;
row++;
}
for (int i=0; i<tanks; i++) // tank - slackTankHigh < tankHigh
{
lpx_set_row_bnds(lp, row, LPX_UP, 0.0, tankHigh[i]);
ia[constraint] = row, ja[constraint] = 1+i, ar[constraint++] = 1.0;
ia[constraint] = row, ja[constraint] = 1+i+2*tanks, ar[constraint++] = -1.0;
row++;
}
for (int i=0; i<assays; i++) // assayLow < assay + slackAssayLow
{
lpx_set_row_bnds(lp, row, LPX_LO, assayLow[i], 0.0);
for (int j=0; j<tanks; j++)
{
if (assayConc[i][j]>0.0)
ia[constraint] = row, ja[constraint] = 1+j, ar[constraint++] = assayConc[i][j];
}
ia[constraint] = row, ja[constraint] = 1+i+3*tanks, ar[constraint++] = 1.0;
row++;
}
for (int i=0; i<assays; i++) // assay - slackAssayHigh < assayHigh
{
lpx_set_row_bnds(lp, row, LPX_UP, 0.0, assayHigh[i]);
for (int j=0; j<tanks; j++)
{
if (assayConc[i][j]>0.0)
ia[constraint] = row, ja[constraint] = 1+j, ar[constraint++] = assayConc[i][j];
}
ia[constraint] = row, ja[constraint] = 1+i+3*tanks+assays, ar[constraint++] = -1.0;
row++;
}
for (int i=0; i<assays; i++) // 0 < assayNum - assayRatioLow*assayDen + slackAssayLow
for (int j=0; j<assays; j++)
{
if (assayRatioLowEnabled[i][j])
lpx_set_row_bnds(lp, row, LPX_LO, 0.0, 0.0);
else
lpx_set_row_bnds(lp, row, LPX_FR, 0.0, 0.0);
for (int k=0; k<tanks; k++)
{
if (assayConc[i][k] - assayRatioLow[i][j]*assayConc[j][k]!=0.0)
ia[constraint] = row, ja[constraint] = 1+k, ar[constraint++] = assayConc[i][k] - assayRatioLow[i][j]*assayConc[j][k];
}
ia[constraint] = row, ja[constraint] = 1+i*assays+j+3*tanks+2*assays, ar[constraint++] = 1.0;
row++;
}
for (int i=0; i<assays; i++) // assayNum - assayRatioHigh*assayDen - slackAssayHigh < 0
for (int j=0; j<assays; j++)
{
if (assayRatioHighEnabled[i][j])
lpx_set_row_bnds(lp, row, LPX_UP, 0.0, 0.0);
else
lpx_set_row_bnds(lp, row, LPX_FR, 0.0, 0.0);
for (int k=0; k<tanks; k++)
{
if (assayConc[i][k] - assayRatioHigh[i][j]*assayConc[j][k]!=0.0)
ia[constraint] = row, ja[constraint] = 1+k, ar[constraint++] = assayConc[i][k] - assayRatioHigh[i][j]*assayConc[j][k];
}
ia[constraint] = row, ja[constraint] = 1+i*assays+j+3*tanks+2*assays+assays*assays, ar[constraint++] = -1.0;
row++;
}
lpx_load_matrix(lp, constraint-1, ia, ja, ar);
int exitCode = lpx_simplex(lp);
for (int i=0; i<tanks; i++)
tank[i] = lpx_get_col_prim(lp, 1+i);
for (int i=0; i<assays; i++)
{
assay[i] = 0.0;
for (int j=0; j<tanks; j++)
assay[i] += lpx_get_col_prim(lp, 1+j)*assayConc[i][j];
}
return exitCode;
// LPX_E_OK 200 /* success */
// LPX_E_FAULT 204 /* unable to start the search */
// LPX_E_ITLIM 207 /* iterations limit exhausted */
// LPX_E_TMLIM 208 /* time limit exhausted */
// LPX_E_SING 211 /* problems with basis matrix */
// LPX_E_NOPFS 213 /* no primal feas. sol. (LP presolver) */
// LPX_E_NODFS 214 /* no dual feas. sol. (LP presolver) */
// Usually:
// LPX_E_OK = Solution found.
// LPX_E_NOPFS = Sum-to-1.0 or tank-max constraints not met.
// Others = Some major fault has occurred.
}
int glpk (int sense, int n, int m, double *c, int nz, int *rn, int *cn,
double *a, double *b, char *ctype, int *freeLB, double *lb,
int *freeUB, double *ub, int *vartype, int isMIP, int lpsolver,
int save_pb, char *save_filename, char *filetype,
double *xmin, double *fmin, double *status,
double *lambda, double *redcosts, double *time, double *mem)
{
int typx = 0;
int method;
clock_t t_start = clock();
//Redirect standard output
if (glpIntParam[0] > 1) glp_term_hook (glpk_print_hook, NULL);
else glp_term_hook (NULL, NULL);
//-- Create an empty LP/MILP object
LPX *lp = lpx_create_prob ();
//-- Set the sense of optimization
if (sense == 1)
glp_set_obj_dir (lp, GLP_MIN);
else
glp_set_obj_dir (lp, GLP_MAX);
//-- Define the number of unknowns and their domains.
glp_add_cols (lp, n);
for (int i = 0; i < n; i++)
{
//-- Define type of the structural variables
if (! freeLB[i] && ! freeUB[i]) {
if ( lb[i] == ub[i] )
glp_set_col_bnds (lp, i+1, GLP_FX, lb[i], ub[i]);
else
glp_set_col_bnds (lp, i+1, GLP_DB, lb[i], ub[i]);
}
else
{
if (! freeLB[i] && freeUB[i])
glp_set_col_bnds (lp, i+1, GLP_LO, lb[i], ub[i]);
else
{
if (freeLB[i] && ! freeUB[i])
glp_set_col_bnds (lp, i+1, GLP_UP, lb[i], ub[i]);
else
glp_set_col_bnds (lp, i+1, GLP_FR, lb[i], ub[i]);
}
}
// -- Set the objective coefficient of the corresponding
// -- structural variable. No constant term is assumed.
glp_set_obj_coef(lp,i+1,c[i]);
if (isMIP)
glp_set_col_kind (lp, i+1, vartype[i]);
}
glp_add_rows (lp, m);
for (int i = 0; i < m; i++)
{
/* If the i-th row has no lower bound (types F,U), the
corrispondent parameter will be ignored.
If the i-th row has no upper bound (types F,L), the corrispondent
parameter will be ignored.
If the i-th row is of S type, the i-th LB is used, but
the i-th UB is ignored.
*/
switch (ctype[i])
{
case 'F': typx = GLP_FR; break;
// upper bound
case 'U': typx = GLP_UP; break;
// lower bound
case 'L': typx = GLP_LO; break;
// fixed constraint
case 'S': typx = GLP_FX; break;
// double-bounded variable
case 'D': typx = GLP_DB; break;
}
if ( typx == GLP_DB && -b[i] < b[i]) {
glp_set_row_bnds (lp, i+1, typx, -b[i], b[i]);
}
else if(typx == GLP_DB && -b[i] == b[i]) {
glp_set_row_bnds (lp, i+1, GLP_FX, b[i], b[i]);
}
else {
// this should be glp_set_row_bnds (lp, i+1, typx, -b[i], b[i]);
glp_set_row_bnds (lp, i+1, typx, b[i], b[i]);
}
}
// Load constraint matrix A
glp_load_matrix (lp, nz, rn, cn, a);
// Save problem
if (save_pb) {
if (!strcmp(filetype,"cplex")){
if (glp_write_lp (lp, NULL, save_filename) != 0) {
mexErrMsgTxt("glpk: unable to write the problem");
longjmp (mark, -1);
}
}else{
if (!strcmp(filetype,"fixedmps")){
if (glp_write_mps (lp, GLP_MPS_DECK, NULL, save_filename) != 0) {
mexErrMsgTxt("glpk: unable to write the problem");
longjmp (mark, -1);
}
}else{
if (!strcmp(filetype,"freemps")){
if (glp_write_mps (lp, GLP_MPS_FILE, NULL, save_filename) != 0) {
mexErrMsgTxt("glpk: unable to write the problem");
longjmp (mark, -1);
}
}else{// plain text
if (lpx_print_prob (lp, save_filename) != 0) {
mexErrMsgTxt("glpk: unable to write the problem");
longjmp (mark, -1);
}
}
}
}
}
//-- scale the problem data (if required)
if (! glpIntParam[16] || lpsolver != 1) {
switch ( glpIntParam[1] ) {
case ( 0 ): glp_scale_prob( lp, GLP_SF_SKIP ); break;
case ( 1 ): glp_scale_prob( lp, GLP_SF_GM ); break;
case ( 2 ): glp_scale_prob( lp, GLP_SF_EQ ); break;
case ( 3 ): glp_scale_prob( lp, GLP_SF_AUTO ); break;
case ( 4 ): glp_scale_prob( lp, GLP_SF_2N ); break;
default :
mexErrMsgTxt("glpk: unrecognized scaling option");
longjmp (mark, -1);
}
}
else {
/* do nothing? or unscale?
glp_unscale_prob( lp );
*/
}
//-- build advanced initial basis (if required)
if (lpsolver == 1 && ! glpIntParam[16])
glp_adv_basis (lp, 0);
glp_smcp sParam;
glp_init_smcp(&sParam);
//-- set control parameters for simplex/exact method
if (lpsolver == 1 || lpsolver == 3){
//remap of control parameters for simplex method
sParam.msg_lev=glpIntParam[0]; // message level
// simplex method: primal/dual
switch ( glpIntParam[2] ) {
case 0: sParam.meth=GLP_PRIMAL; break;
case 1: sParam.meth=GLP_DUAL; break;
case 2: sParam.meth=GLP_DUALP; break;
default:
mexErrMsgTxt("glpk: unrecognized primal/dual method");
longjmp (mark, -1);
}
// pricing technique
if (glpIntParam[3]==0) sParam.pricing=GLP_PT_STD;
else sParam.pricing=GLP_PT_PSE;
// ratio test
if (glpIntParam[20]==0) sParam.r_test = GLP_RT_STD;
else sParam.r_test=GLP_RT_HAR;
//tollerances
sParam.tol_bnd=glpRealParam[1]; // primal feasible tollerance
sParam.tol_dj=glpRealParam[2]; // dual feasible tollerance
sParam.tol_piv=glpRealParam[3]; // pivot tollerance
sParam.obj_ll=glpRealParam[4]; // lower limit
sParam.obj_ul=glpRealParam[5]; // upper limit
// iteration limit
if (glpIntParam[5]==-1) sParam.it_lim=INT_MAX;
else sParam.it_lim=glpIntParam[5];
// time limit
if (glpRealParam[6]==-1) sParam.tm_lim=INT_MAX;
else sParam.tm_lim=(int) glpRealParam[6];
sParam.out_frq=glpIntParam[7]; // output frequency
sParam.out_dly=(int) glpRealParam[7]; // output delay
// presolver
if (glpIntParam[16]) sParam.presolve=GLP_ON;
else sParam.presolve=GLP_OFF;
}else{
for(int i = 0; i < NIntP; i++) {
// skip assinging ratio test or
if ( i == 18 || i == 20) continue;
lpx_set_int_parm (lp, IParam[i], glpIntParam[i]);
}
for (int i = 0; i < NRealP; i++) {
lpx_set_real_parm (lp, RParam[i], glpRealParam[i]);
}
}
//set MIP params if MIP....
glp_iocp iParam;
glp_init_iocp(&iParam);
if ( isMIP ){
method = 'I';
switch (glpIntParam[0]) { //message level
case 0: iParam.msg_lev = GLP_MSG_OFF; break;
case 1: iParam.msg_lev = GLP_MSG_ERR; break;
case 2: iParam.msg_lev = GLP_MSG_ON; break;
case 3: iParam.msg_lev = GLP_MSG_ALL; break;
default: mexErrMsgTxt("glpk: msg_lev bad param");
}
switch (glpIntParam[14]) { //branching param
case 0: iParam.br_tech = GLP_BR_FFV; break;
case 1: iParam.br_tech = GLP_BR_LFV; break;
case 2: iParam.br_tech = GLP_BR_MFV; break;
case 3: iParam.br_tech = GLP_BR_DTH; break;
default: mexErrMsgTxt("glpk: branch bad param");
}
switch (glpIntParam[15]) { //backtracking heuristic
case 0: iParam.bt_tech = GLP_BT_DFS; break;
case 1: iParam.bt_tech = GLP_BT_BFS; break;
case 2: iParam.bt_tech = GLP_BT_BLB; break;
case 3: iParam.bt_tech = GLP_BT_BPH; break;
default: mexErrMsgTxt("glpk: backtrack bad param");
}
if ( glpRealParam[8] > 0.0 && glpRealParam[8] < 1.0 )
iParam.tol_int = glpRealParam[8]; // absolute tolorence
else
mexErrMsgTxt("glpk: tolint must be between 0 and 1");
iParam.tol_obj = glpRealParam[9]; // relative tolarence
iParam.mip_gap = glpRealParam[10]; // realative gap tolerance
// set time limit for mip
if ( glpRealParam[6] < 0.0 || glpRealParam[6] > 1e6 )
iParam.tm_lim = INT_MAX;
else
iParam.tm_lim = (int)(1000.0 * glpRealParam[6] );
// Choose Cutsets for mip
// shut all cuts off, then start over....
iParam.gmi_cuts = GLP_OFF;
iParam.mir_cuts = GLP_OFF;
iParam.cov_cuts = GLP_OFF;
iParam.clq_cuts = GLP_OFF;
switch( glpIntParam[17] ) {
case 0: break;
case 1: iParam.gmi_cuts = GLP_ON; break;
case 2: iParam.mir_cuts = GLP_ON; break;
case 3: iParam.cov_cuts = GLP_ON; break;
case 4: iParam.clq_cuts = GLP_ON; break;
case 5: iParam.clq_cuts = GLP_ON;
iParam.gmi_cuts = GLP_ON;
iParam.mir_cuts = GLP_ON;
iParam.cov_cuts = GLP_ON;
iParam.clq_cuts = GLP_ON; break;
default: mexErrMsgTxt("glpk: cutset bad param");
}
switch( glpIntParam[18] ) { // pre-processing for mip
case 0: iParam.pp_tech = GLP_PP_NONE; break;
case 1: iParam.pp_tech = GLP_PP_ROOT; break;
case 2: iParam.pp_tech = GLP_PP_ALL; break;
default: mexErrMsgTxt("glpk: pprocess bad param");
}
if (glpIntParam[16]) iParam.presolve=GLP_ON;
else iParam.presolve=GLP_OFF;
if (glpIntParam[19]) iParam.binarize = GLP_ON;
else iParam.binarize = GLP_OFF;
}
else {
/* Choose simplex method ('S')
or interior point method ('T')
or Exact method ('E')
to solve the problem */
switch (lpsolver) {
case 1: method = 'S'; break;
case 2: method = 'T'; break;
case 3: method = 'E'; break;
default:
mexErrMsgTxt("glpk: lpsolver != lpsolver");
longjmp (mark, -1);
}
}
// now run the problem...
int errnum = 0;
switch (method) {
case 'I':
errnum = glp_intopt( lp, &iParam );
errnum += 200; //this is to avoid ambiguity in the return codes.
break;
case 'S':
errnum = glp_simplex(lp, &sParam);
errnum += 100; //this is to avoid ambiguity in the return codes.
break;
case 'T':
errnum = glp_interior(lp, NULL );
errnum += 300; //this is to avoid ambiguity in the return codes.
break;
case 'E':
errnum = glp_exact(lp, &sParam);
errnum += 100; //this is to avoid ambiguity in the return codes.
break;
default: /*xassert (method != method); */
mexErrMsgTxt("glpk: method != method");
longjmp (mark, -1);
}
if (errnum==100 || errnum==200 || errnum==300 || errnum==106 || errnum==107 || errnum==108 || errnum==109 || errnum==209 || errnum==214 || errnum==308) {
// Get status and object value
if (isMIP) {
*status = glp_mip_status (lp);
*fmin = glp_mip_obj_val (lp);
}
else {
if (lpsolver == 1 || lpsolver == 3) {
*status = glp_get_status (lp);
*fmin = glp_get_obj_val (lp);
}
else {
*status = glp_ipt_status (lp);
*fmin = glp_ipt_obj_val (lp);
}
}
// Get optimal solution (if exists)
if (isMIP) {
for (int i = 0; i < n; i++)
xmin[i] = glp_mip_col_val (lp, i+1);
}
else {
/* Primal values */
for (int i = 0; i < n; i++) {
if (lpsolver == 1 || lpsolver == 3)
xmin[i] = glp_get_col_prim (lp, i+1);
else
xmin[i] = glp_ipt_col_prim (lp, i+1);
}
/* Dual values */
for (int i = 0; i < m; i++) {
if (lpsolver == 1 || lpsolver == 3)
lambda[i] = glp_get_row_dual (lp, i+1);
else
lambda[i] = glp_ipt_row_dual (lp, i+1);
}
/* Reduced costs */
for (int i = 0; i < glp_get_num_cols (lp); i++) {
if (lpsolver == 1 || lpsolver == 3)
redcosts[i] = glp_get_col_dual (lp, i+1);
else
redcosts[i] = glp_ipt_col_dual (lp, i+1);
}
}
*time = (clock () - t_start) / CLOCKS_PER_SEC;
size_t tpeak;
glp_mem_usage(NULL, NULL, NULL, &tpeak);
*mem=((double) tpeak) / (1024);
lpx_delete_prob(lp);
return 0;
}
else {
// printf("errnum is %d\n", errnum);
}
lpx_delete_prob(lp);
/* this shouldn't be nessiary with glp_deleted_prob, but try it
if we have weird behavior again... */
glp_free_env();
*status = errnum;
return errnum;
}
void Gspan::lpboost(){
std::cout << "in lpboost" << std::endl;
const char *out = "model";
//initialize
unsigned int gnum = gdata.size();
weight.resize(gnum);
std::fill(weight.begin(),weight.end(),1.0);
corlab.resize(gnum);
for(unsigned int gid=0;gid<gnum;++gid){
corlab[gid]=gdata[gid].class_label;
}
wbias=0.0;
Hypothesis model;
first_flag=true;
need_to_cooc = false;
cooc_is_opt = false;
std::cout.setf(std::ios::fixed,std::ios::floatfield);
std::cout.precision(8);
//Initialize GLPK
int* index = new int[gnum+2]; double* value = new double[gnum+2];
LPX* lp = lpx_create_prob();
lpx_add_cols(lp, gnum+1); // set u_1,...u_l, beta
for (unsigned int i = 0; i < gnum; ++i){
lpx_set_col_bnds(lp, COL(i), LPX_DB, 0.0, 1/(nu*gnum));
lpx_set_obj_coef(lp, COL(i), 0); // u
}
lpx_set_col_bnds(lp, COL(gnum), LPX_FR, 0.0, 0.0);
lpx_set_obj_coef(lp, COL(gnum), 1); // beta
lpx_set_obj_dir(lp, LPX_MIN); //optimization direction: min objective
lpx_add_rows(lp,1); // Add one row constraint s.t. sum_u == 1
for (unsigned int i = 0; i < gnum; ++i){
index[i+1] = COL(i);
value[i+1] = 1;
}
lpx_set_mat_row(lp, ROW(0), gnum, index, value);
lpx_set_row_bnds(lp, ROW(0), LPX_FX, 1, 1);
double beta = 0.0;
double margin = 0.0;
//main loop
for(unsigned int itr=0;itr < max_itr;++itr){
std::cout <<"itrator : "<<itr+1<<std::endl;
if(itr==coocitr) need_to_cooc=true;
opt_pat.gain=0.0;//gain init
opt_pat.size=0;
opt_pat.locsup.resize(0);
pattern.resize(0);
opt_pat.dfscode="";
Crun();
//std::cout<<opt_pat.gain<<" :"<<opt_pat.dfscode<<std::endl;
std::vector <int> result (gnum);
int _y;
vector<int> locvec;
std::string dfscode;
if(cooc_is_opt == false){
_y = opt_pat.gain > 0 ? +1 :-1;
locvec =opt_pat.locsup;
dfscode=opt_pat.dfscode;
}else{
_y = opt_pat_cooc.gain > 0 ? +1 :-1;
locvec =opt_pat_cooc.locsup;
dfscode=opt_pat_cooc.dfscode[0]+"\t"+opt_pat_cooc.dfscode[1];//=opt_pat_cooc.dfscode;
}
model.flag.resize(itr+1);
model.flag[itr]=_y;
std::fill (result.begin (), result.end(), -_y);
for (unsigned int i = 0; i < locvec.size(); ++i) result[locvec[i]] = _y;
double uyh = 0;
for (unsigned int i = 0; i < gnum; ++i) { // summarizing hypotheses
uyh += weight[i]*corlab[i]*result[i];
}
std::cout << "Stopping criterion: " << uyh << "<=?" << beta << " + " << conv_epsilon << std::endl;
if( (uyh <= beta + conv_epsilon ) ){
std::cout << "*********************************" << std::endl;
std::cout << "Convergence ! at iteration: " << itr+1 << std::endl;
std::cout << "*********************************" << std::endl;
if(!end_of_cooc || need_to_cooc == true) break;
need_to_cooc = true;
}
lpx_add_rows(lp,1); // Add one row constraint s.t. sum( uyh - beta ) <= 0
for (unsigned int i = 0; i < gnum; ++i){
index[i+1] = COL(i);
value[i+1] = result[i] * corlab[i];
}
index[gnum+1] = COL(gnum);
value[gnum+1] = -1;
lpx_set_mat_row(lp, ROW(itr+1), gnum+1, index, value);
lpx_set_row_bnds(lp, ROW(itr+1), LPX_UP, 0.0, 0.0);
model.weight.push_back(0);
model.dfs_vector.push_back(dfscode);
lpx_simplex(lp);
beta = lpx_get_obj_val(lp);
for (unsigned int i = 0; i < gnum; ++i){
double new_weight;
new_weight = lpx_get_col_prim(lp, COL(i));
if(new_weight < 0) new_weight = 0; // weight > 0
weight[i] = new_weight;
}
margin = lpx_get_row_dual(lp, ROW(0));
double margin_error = 0.0;
for (unsigned int i = 0; i < gnum; ++i) { // summarizing hypotheses
if (corlab[i]*result[i] < margin){
++margin_error;
}
}
margin_error /= gnum;
//next rule is estimated
wbias = 0.0;
for (unsigned int i = 0; i < gnum; ++i){
wbias += corlab[i] * weight[i];
}
std::ofstream os (out);
if (! os) {
std::cerr << "FATAL: Cannot open output file: " << out << std::endl;
return;
}
os.setf(std::ios::fixed,std::ios::floatfield);
os.precision(12);
for (unsigned int r = 0; r < itr; ++r){
model.weight[r] = - lpx_get_row_dual(lp, ROW(r+1));
if(model.weight[r] < 0) model.weight[r] = 0; // alpha > 0
os << model.flag[r] * model.weight[r] << "\t" << model.dfs_vector[r] << std::endl;
std::cout << model.flag[r] * model.weight[r] << "\t" << model.dfs_vector[r] << std::endl;
}
std::cout << "After iteration " << itr+1 << std::endl;
std::cout << "Margin: " << margin << std::endl;
std::cout << "Margin Error: " << margin_error << std::endl;
}
std::cout << "end lpboost" << std::endl;
}
