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 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;
}
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 lpx_integer(LPX *mip)
{ int m = lpx_get_num_rows(mip);
int n = lpx_get_num_cols(mip);
MIPTREE *tree;
LPX *lp;
int ret, i, j, stat, type, len, *ind;
double lb, ub, coef, *val;
#if 0
/* the problem must be of MIP class */
if (lpx_get_class(mip) != LPX_MIP)
{ print("lpx_integer: problem is not of MIP class");
ret = LPX_E_FAULT;
goto done;
}
#endif
/* an optimal solution of LP relaxation must be known */
if (lpx_get_status(mip) != LPX_OPT)
{ print("lpx_integer: optimal solution of LP relaxation required"
);
ret = LPX_E_FAULT;
goto done;
}
/* bounds of all integer variables must be integral */
for (j = 1; j <= n; j++)
{ if (lpx_get_col_kind(mip, j) != LPX_IV) continue;
type = lpx_get_col_type(mip, j);
if (type == LPX_LO || type == LPX_DB || type == LPX_FX)
{ lb = lpx_get_col_lb(mip, j);
if (lb != floor(lb))
{ print("lpx_integer: integer column %d has non-integer lo"
"wer bound or fixed value %g", j, lb);
ret = LPX_E_FAULT;
goto done;
}
}
if (type == LPX_UP || type == LPX_DB)
{ ub = lpx_get_col_ub(mip, j);
if (ub != floor(ub))
{ print("lpx_integer: integer column %d has non-integer up"
"per bound %g", j, ub);
ret = LPX_E_FAULT;
goto done;
}
}
}
/* it seems all is ok */
if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 2)
print("Integer optimization begins...");
/* create the branch-and-bound tree */
tree = mip_create_tree(m, n, lpx_get_obj_dir(mip));
/* set up column kinds */
for (j = 1; j <= n; j++)
tree->int_col[j] = (lpx_get_col_kind(mip, j) == LPX_IV);
/* access the LP relaxation template */
lp = tree->lp;
/* set up the objective function */
tree->int_obj = 1;
for (j = 0; j <= tree->n; j++)
{ coef = lpx_get_obj_coef(mip, j);
lpx_set_obj_coef(lp, j, coef);
if (coef != 0.0 && !(tree->int_col[j] && coef == floor(coef)))
tree->int_obj = 0;
}
if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 2 && tree->int_obj)
print("Objective function is integral");
/* set up the constraint matrix */
ind = xcalloc(1+n, sizeof(int));
val = xcalloc(1+n, sizeof(double));
for (i = 1; i <= m; i++)
{ len = lpx_get_mat_row(mip, i, ind, val);
lpx_set_mat_row(lp, i, len, ind, val);
}
xfree(ind);
xfree(val);
/* set up scaling matrices */
for (i = 1; i <= m; i++)
lpx_set_rii(lp, i, lpx_get_rii(mip, i));
for (j = 1; j <= n; j++)
lpx_set_sjj(lp, j, lpx_get_sjj(mip, j));
/* revive the root subproblem */
mip_revive_node(tree, 1);
/* set up row attributes for the root subproblem */
for (i = 1; i <= m; i++)
{ type = lpx_get_row_type(mip, i);
lb = lpx_get_row_lb(mip, i);
ub = lpx_get_row_ub(mip, i);
stat = lpx_get_row_stat(mip, i);
lpx_set_row_bnds(lp, i, type, lb, ub);
lpx_set_row_stat(lp, i, stat);
}
/* set up column attributes for the root subproblem */
for (j = 1; j <= n; j++)
{ type = lpx_get_col_type(mip, j);
lb = lpx_get_col_lb(mip, j);
ub = lpx_get_col_ub(mip, j);
stat = lpx_get_col_stat(mip, j);
lpx_set_col_bnds(lp, j, type, lb, ub);
lpx_set_col_stat(lp, j, stat);
}
/* freeze the root subproblem */
mip_freeze_node(tree);
/* inherit some control parameters and statistics */
tree->msg_lev = lpx_get_int_parm(mip, LPX_K_MSGLEV);
if (tree->msg_lev > 2) tree->msg_lev = 2;
tree->branch = lpx_get_int_parm(mip, LPX_K_BRANCH);
tree->btrack = lpx_get_int_parm(mip, LPX_K_BTRACK);
tree->tol_int = lpx_get_real_parm(mip, LPX_K_TOLINT);
tree->tol_obj = lpx_get_real_parm(mip, LPX_K_TOLOBJ);
tree->tm_lim = lpx_get_real_parm(mip, LPX_K_TMLIM);
lpx_set_int_parm(lp, LPX_K_BFTYPE, lpx_get_int_parm(mip,
LPX_K_BFTYPE));
lpx_set_int_parm(lp, LPX_K_PRICE, lpx_get_int_parm(mip,
LPX_K_PRICE));
lpx_set_real_parm(lp, LPX_K_RELAX, lpx_get_real_parm(mip,
LPX_K_RELAX));
lpx_set_real_parm(lp, LPX_K_TOLBND, lpx_get_real_parm(mip,
LPX_K_TOLBND));
lpx_set_real_parm(lp, LPX_K_TOLDJ, lpx_get_real_parm(mip,
LPX_K_TOLDJ));
lpx_set_real_parm(lp, LPX_K_TOLPIV, lpx_get_real_parm(mip,
LPX_K_TOLPIV));
lpx_set_int_parm(lp, LPX_K_ITLIM, lpx_get_int_parm(mip,
LPX_K_ITLIM));
lpx_set_int_parm(lp, LPX_K_ITCNT, lpx_get_int_parm(mip,
LPX_K_ITCNT));
/* reset the status of MIP solution */
lpx_put_mip_soln(mip, LPX_I_UNDEF, NULL, NULL);
/* try solving the problem */
ret = mip_driver(tree);
/* if an integer feasible solution has been found, copy it to the
MIP problem object */
if (tree->found)
lpx_put_mip_soln(mip, LPX_I_FEAS, &tree->mipx[0],
&tree->mipx[m]);
/* copy back statistics about spent resources */
lpx_set_real_parm(mip, LPX_K_TMLIM, tree->tm_lim);
lpx_set_int_parm(mip, LPX_K_ITLIM, lpx_get_int_parm(lp,
LPX_K_ITLIM));
lpx_set_int_parm(mip, LPX_K_ITCNT, lpx_get_int_parm(lp,
LPX_K_ITCNT));
/* analyze exit code reported by the mip driver */
switch (ret)
{ case MIP_E_OK:
if (tree->found)
{ if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 3)
print("INTEGER OPTIMAL SOLUTION FOUND");
lpx_put_mip_soln(mip, LPX_I_OPT, NULL, NULL);
}
else
{ if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 3)
print("PROBLEM HAS NO INTEGER FEASIBLE SOLUTION");
lpx_put_mip_soln(mip, LPX_I_NOFEAS, NULL, NULL);
}
ret = LPX_E_OK;
break;
case MIP_E_ITLIM:
if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 3)
print("ITERATIONS LIMIT EXCEEDED; SEARCH TERMINATED");
ret = LPX_E_ITLIM;
break;
case MIP_E_TMLIM:
if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 3)
print("TIME LIMIT EXCEEDED; SEARCH TERMINATED");
ret = LPX_E_TMLIM;
break;
case MIP_E_ERROR:
if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 1)
print("lpx_integer: cannot solve current LP relaxation");
ret = LPX_E_SING;
break;
default:
xassert(ret != ret);
}
/* delete the branch-and-bound tree */
mip_delete_tree(tree);
done: /* return to the application program */
return ret;
}
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;
}
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;
}
LPX *lpp_build_prob(LPP *lpp)
{ LPX *prob;
LPPROW *row;
LPPCOL *col;
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 = xcalloc(1+lpp->m, sizeof(int));
lpp->col_ref = xcalloc(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_coef(prob, 0,
lpp->orig_dir == LPX_MIN ? + lpp->c0 : - lpp->c0);
/* create rows of the resultant problem */
#if 0 /* 03/VII-2008 */
xassert(lpp->m > 0);
#endif
if (lpp->m > 0)
lpx_add_rows(prob, lpp->m);
for (i = 1, row = lpp->row_ptr; i <= lpp->m; i++, row = row->next)
{ xassert(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);
}
xassert(row == NULL);
/* create columns of the resultant problem */
#if 0 /* 03/VII-2008 */
xassert(lpp->n > 0);
#endif
if (lpp->n > 0)
lpx_add_cols(prob, lpp->n);
for (j = 1, col = lpp->col_ptr; j <= lpp->n; j++, col = col->next)
{ xassert(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_obj_coef(prob, j,
lpp->orig_dir == LPX_MIN ? + col->c : - col->c);
}
xassert(col == NULL);
/* create the constraint matrix of the resultant problem */
#if 0
info.lpp = lpp;
info.row = NULL;
info.aij = NULL;
lpx_load_mat(prob, &info, next_aij);
#else
{ LPPAIJ *aij;
int len, *ind;
double *val;
ind = xcalloc(1+lpp->n, sizeof(int));
val = xcalloc(1+lpp->n, sizeof(double));
for (row = lpp->row_ptr; row != NULL; row = row->next)
{ len = 0;
for (aij = row->ptr; aij != NULL; aij = aij->r_next)
len++, ind[len] = aij->col->j, val[len] = aij->val;
lpx_set_mat_row(prob, row->i, len, ind, val);
}
xfree(ind);
xfree(val);
}
#endif
/* 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;
}
