int GLPKAddConstraint(LinEquation* InEquation) {
if (InEquation->QuadCoeff.size() > 0) {
FErrorFile() << "GLPK solver cannot accept quadratic constraints." << endl;
FlushErrorFile();
return FAIL;
}
if (GLPKModel == NULL) {
FErrorFile() << "Could not add constraint because GLPK object does not exist." << endl;
FlushErrorFile();
return FAIL;
}
int NumRows = lpx_get_num_rows(GLPKModel);
if (InEquation->Index >= NumRows) {
lpx_add_rows(GLPKModel, 1);
}
if (InEquation->EqualityType == EQUAL) {
lpx_set_row_bnds(GLPKModel, InEquation->Index+1, LPX_FX, InEquation->RightHandSide, InEquation->RightHandSide);
} else if (InEquation->EqualityType == GREATER) {
lpx_set_row_bnds(GLPKModel, InEquation->Index+1, LPX_LO, InEquation->RightHandSide, InEquation->RightHandSide);
} else if (InEquation->EqualityType == LESS) {
lpx_set_row_bnds(GLPKModel, InEquation->Index+1, LPX_UP, InEquation->RightHandSide, InEquation->RightHandSide);
} else {
FErrorFile() << "Could not add constraint because the constraint type was not recognized." << endl;
FlushErrorFile();
return FAIL;
}
int NumColumns = lpx_get_num_cols(GLPKModel);
int* Indecies = new int[int(InEquation->Variables.size())+1];
double* Coeff = new double[int(InEquation->Variables.size())+1];
for (int i=0; i < int(InEquation->Variables.size()); i++) {
if (InEquation->Variables[i]->Index < NumColumns) {
Coeff[i+1] = InEquation->Coefficient[i];
Indecies[i+1] = InEquation->Variables[i]->Index+1;
} else {
FErrorFile() << "Variable index found in constraint is out of the range found in GLPK problem" << endl;
FlushErrorFile();
return FAIL;
}
}
lpx_set_mat_row(GLPKModel, InEquation->Index+1, int(InEquation->Variables.size()), Indecies, Coeff);
delete [] Indecies;
delete [] Coeff;
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;
}
int CClp_addrows(CClp *lp, int newrows, int newnz, double *rhs,
char *sense, int *rmatbeg, int *rmatind, double *rmatval)
{ /* ADDS the rows to the LP.
- newrows is the number of rows to be added;
- newnz is the number of nonzero coefficients in the new rows;
- rhs is an array of the rhs values for the new rows;
- sense is 'L', 'E', or 'G' for each of the new rows;
- rmatbeg, rmatind, and rmatval give the coefficients of the
new rows in sparse format. The arrays can be freed after the
call. */
int i;
lpx_add_rows(lp->lp, newrows);
for (i = 0; i < newrows; i++)
{ int seqn, type, k, t;
double lo, up;
seqn = lpx_get_num_rows(lp->lp) - newrows + 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);
insist(rmatbeg != NULL);
insist(rmatind != NULL);
insist(rmatval != NULL);
insist(rmatbeg[0] == 0);
t = (i < newrows-1 ? rmatbeg[i+1] : newnz);
for (k = rmatbeg[i]; k < t; k++) rmatind[k]++;
lpx_set_mat_row(lp->lp, seqn, t - rmatbeg[i],
&rmatind[rmatbeg[i]] - 1, &rmatval[rmatbeg[i]] - 1);
for (k = rmatbeg[i]; k < t; k++) rmatind[k]--;
}
return 0;
}
int CClp_new_row(CClp *lp, char sense, double rhs)
{ /* ADDS a new empty row to the lp.
- sense is 'L', 'E', or 'G' for a <=, =, or >= constraint;
- rhs is the right-hand side of the row. */
int seqn;
lpx_add_rows(lp->lp, 1);
seqn = lpx_get_num_rows(lp->lp);
switch (sense)
{ case 'L':
lpx_set_row_bnds(lp->lp, seqn, LPX_UP, 0.0, rhs);
break;
case 'E':
lpx_set_row_bnds(lp->lp, seqn, LPX_FX, rhs, rhs);
break;
case 'G':
lpx_set_row_bnds(lp->lp, seqn, LPX_LO, rhs, 0.0);
break;
default:
insist(sense != sense);
}
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;
}
static void parse_constraints(struct dsa *dsa)
{ int i, len, type;
double s;
/* parse the keyword 'subject to' */
xassert(dsa->token == T_SUBJECT_TO);
scan_token(dsa);
loop: /* create new row (constraint) */
i = lpx_add_rows(dsa->lp, 1);
/* parse row name */
if (dsa->token == T_NAME && dsa->c == ':')
{ /* row name is followed by a colon */
if (lpx_find_row(dsa->lp, dsa->image) != 0)
fatal(dsa, "constraint `%s' multiply defined", dsa->image);
lpx_set_row_name(dsa->lp, i, dsa->image);
scan_token(dsa);
xassert(dsa->token == T_COLON);
scan_token(dsa);
}
else
{ /* row name is not specified; use default */
char name[50];
sprintf(name, "r.%d", dsa->count);
lpx_set_row_name(dsa->lp, i, name);
}
/* parse linear form */
len = parse_linear_form(dsa);
lpx_set_mat_row(dsa->lp, i, len, dsa->ind, dsa->val);
/* parse constraint sense */
if (dsa->token == T_LE)
type = LPX_UP, scan_token(dsa);
else if (dsa->token == T_GE)
type = LPX_LO, scan_token(dsa);
else if (dsa->token == T_EQ)
type = LPX_FX, scan_token(dsa);
else
fatal(dsa, "missing constraint sense");
/* parse right-hand side */
if (dsa->token == T_PLUS)
s = +1.0, scan_token(dsa);
else if (dsa->token == T_MINUS)
s = -1.0, scan_token(dsa);
else
s = +1.0;
if (dsa->token != T_NUMBER)
fatal(dsa, "missing right-hand side");
switch (type)
{ case LPX_LO:
lpx_set_row_bnds(dsa->lp, i, LPX_LO, s * dsa->value, 0.0);
break;
case LPX_UP:
lpx_set_row_bnds(dsa->lp, i, LPX_UP, 0.0, s * dsa->value);
break;
case LPX_FX:
lpx_set_row_bnds(dsa->lp, i, LPX_FX, s * dsa->value, 0.0);
break;
}
/* the rest of the current line must be empty */
if (!(dsa->c == '\n' || dsa->c == EOF))
fatal(dsa, "invalid symbol(s) beyond right-hand side");
scan_token(dsa);
/* if the next token is a sign, numeric constant, or a symbolic
name, here is another constraint */
if (dsa->token == T_PLUS || dsa->token == T_MINUS ||
dsa->token == T_NUMBER || dsa->token == T_NAME) goto loop;
return;
}
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.
}
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;
}
static void gen_gomory_cut(LPX *prob, int maxlen)
{ int m = lpx_get_num_rows(prob);
int n = lpx_get_num_cols(prob);
int i, j, k, len, cut_j, *ind;
double x, d, r, temp, cut_d, cut_r, *val, *work;
insist(lpx_get_status(prob) == LPX_OPT);
/* allocate working arrays */
ind = ucalloc(1+n, sizeof(int));
val = ucalloc(1+n, sizeof(double));
work = ucalloc(1+m+n, sizeof(double));
/* nothing is chosen so far */
cut_j = 0; cut_d = 0.0; cut_r = 0.0;
/* look through all structural variables */
for (j = 1; j <= n; j++)
{ /* if the variable is continuous, skip it */
if (lpx_get_col_kind(prob, j) != LPX_IV) continue;
/* if the variable is non-basic, skip it */
if (lpx_get_col_stat(prob, j) != LPX_BS) continue;
/* if the variable is fixed, skip it */
if (lpx_get_col_type(prob, j) == LPX_FX) continue;
/* obtain current primal value of the variable */
x = lpx_get_col_prim(prob, j);
/* if the value is close enough to nearest integer, skip the
variable */
if (fabs(x - floor(x + 0.5)) < 1e-4) continue;
/* compute the row of the simplex table corresponding to the
variable */
len = lpx_eval_tab_row(prob, m+j, ind, val);
len = lpx_remove_tiny(len, ind, NULL, val, 1e-10);
/* generate Gomory's mixed integer cut:
a[1]*x[1] + ... + a[n]*x[n] >= b */
len = lpx_gomory_cut(prob, len, ind, val, work);
if (len < 0) continue;
insist(0 <= len && len <= n);
len = lpx_remove_tiny(len, ind, NULL, val, 1e-10);
if (fabs(val[0]) < 1e-10) val[0] = 0.0;
/* if the cut is too long, skip it */
if (len > maxlen) continue;
/* if the cut contains coefficients with too large magnitude,
do not use it to prevent numeric instability */
for (k = 0; k <= len; k++) /* including rhs */
if (fabs(val[k]) > 1e+6) break;
if (k <= len) continue;
/* at the current point the cut inequality is violated, i.e.
the residual b - (a[1]*x[1] + ... + a[n]*x[n]) > 0; note
that for Gomory's cut the residual is less than 1.0 */
/* in order not to depend on the magnitude of coefficients we
use scaled residual:
r = [b - (a[1]*x[1] + ... + a[n]*x[n])] / max(1, |a[j]|) */
temp = 1.0;
for (k = 1; k <= len; k++)
if (temp < fabs(val[k])) temp = fabs(val[k]);
r = (val[0] - lpx_eval_row(prob, len, ind, val)) / temp;
if (r < 1e-5) continue;
/* estimate degradation (worsening) of the objective function
by one dual simplex step if the cut row would be introduced
in the problem */
d = lpx_eval_degrad(prob, len, ind, val, LPX_LO, val[0]);
/* ignore the sign of degradation */
d = fabs(d);
/* which cut should be used? there are two basic cases:
1) if the degradation is non-zero, we are interested in a
cut providing maximal degradation;
2) if the degradation is zero (i.e. a non-basic variable
which would enter the basis in the adjacent vertex has
zero reduced cost), we are interested in a cut providing
maximal scaled residual;
in both cases it is desired that the cut length (the number
of inequality coefficients) is possibly short */
/* if both degradation and scaled residual are small, skip the
cut */
if (d < 0.001 && r < 0.001)
continue;
/* if there is no cut chosen, choose this cut */
else if (cut_j == 0)
;
/* if this cut provides stronger degradation and has shorter
length, choose it */
else if (cut_d != 0.0 && cut_d < d)
;
/* if this cut provides larger scaled residual and has shorter
length, choose it */
else if (cut_d == 0.0 && cut_r < r)
;
/* otherwise skip the cut */
else
continue;
/* save attributes of the cut choosen */
cut_j = j, cut_r = r, cut_d = d;
}
/* if a cut has been chosen, include it to the problem */
if (cut_j != 0)
{ j = cut_j;
/* compute the row of the simplex table */
len = lpx_eval_tab_row(prob, m+j, ind, val);
len = lpx_remove_tiny(len, ind, NULL, val, 1e-10);
/* generate the cut */
len = lpx_gomory_cut(prob, len, ind, val, work);
insist(0 <= len && len <= n);
len = lpx_remove_tiny(len, ind, NULL, val, 1e-10);
if (fabs(val[0]) < 1e-10) val[0] = 0.0;
/* include the corresponding row in the problem */
i = lpx_add_rows(prob, 1);
lpx_set_row_bnds(prob, i, LPX_LO, val[0], 0.0);
lpx_set_mat_row(prob, i, len, ind, val);
}
/* free working arrays */
ufree(ind);
ufree(val);
ufree(work);
return;
}
