int main(void)
{ glp_prob *P;
P = glp_create_prob();
glp_read_mps(P, GLP_MPS_DECK, NULL, "25fv47.mps");
glp_adv_basis(P, 0);
glp_simplex(P, NULL);
glp_print_sol(P, "25fv47.txt");
glp_delete_prob(P);
return 0;
}
int main(void)
{ glp_prob *P;
glp_smcp parm;
P = glp_create_prob();
glp_read_mps(P, GLP_MPS_DECK, NULL, "25fv47.mps");
glp_init_smcp(&parm);
parm.meth = GLP_DUAL;
glp_simplex(P, &parm);
glp_print_sol(P, "25fv47.txt");
glp_delete_prob(P);
return 0;
}
/**
* Solves the MLP problem
*
* @param mlp the MLP Handle
* @param ctx solution context
* @return GNUNET_OK if could be solved, GNUNET_SYSERR on failure
*/
int
GAS_mlp_solve_problem (struct GAS_MLP_Handle *mlp, struct GAS_MLP_SolutionContext *ctx)
{
int res;
/* Check if solving is already running */
if (GNUNET_YES == mlp->semaphore)
{
if (mlp->mlp_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel(mlp->mlp_task);
mlp->mlp_task = GNUNET_SCHEDULER_NO_TASK;
}
mlp->mlp_task = GNUNET_SCHEDULER_add_delayed (mlp->exec_interval, &mlp_scheduler, mlp);
return GNUNET_SYSERR;
}
mlp->semaphore = GNUNET_YES;
mlp->last_execution = GNUNET_TIME_absolute_get ();
ctx->lp_result = GNUNET_SYSERR;
ctx->mlp_result = GNUNET_SYSERR;
ctx->lp_duration = GNUNET_TIME_UNIT_FOREVER_REL;
ctx->mlp_duration = GNUNET_TIME_UNIT_FOREVER_REL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Solve LP problem\n");
#if WRITE_MLP
char * name;
static int i;
i++;
GNUNET_asprintf(&name, "problem_%i", i);
glp_write_lp (mlp->prob, 0, name);
GNUNET_free (name);
# endif
res = mlp_solve_lp_problem (mlp, ctx);
ctx->lp_result = res;
if (res != GNUNET_OK)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "LP Problem solving failed\n");
mlp->semaphore = GNUNET_NO;
return GNUNET_SYSERR;
}
#if WRITE_MLP
GNUNET_asprintf(&name, "problem_%i_lp_solution", i);
glp_print_sol (mlp->prob, name);
GNUNET_free (name);
# endif
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Solve MLP problem\n");
res = mlp_solve_mlp_problem (mlp, ctx);
ctx->mlp_result = res;
if (res != GNUNET_OK)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MLP Problem solving failed\n");
mlp->semaphore = GNUNET_NO;
return GNUNET_SYSERR;
}
#if WRITE_MLP
GNUNET_asprintf(&name, "problem_%i_mlp_solution", i);
glp_print_mip (mlp->prob, name);
GNUNET_free (name);
# endif
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Problem solved %s (LP duration %llu / MLP duration %llu)\n",
(GNUNET_OK == res) ? "successfully" : "failed", ctx->lp_duration.rel_value, ctx->mlp_duration.rel_value);
/* Process result */
struct ATS_Peer *p = NULL;
struct ATS_Address *a = NULL;
struct MLP_information *mlpi = NULL;
for (p = mlp->peer_head; p != NULL; p = p->next)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%s'\n", GNUNET_i2s (&p->id));
for (a = p->head; a != NULL; a = a->next)
{
double b = 0.0;
double n = 0.0;
mlpi = a->mlp_information;
b = glp_mip_col_val(mlp->prob, mlpi->c_b);
mlpi->b = b;
n = glp_mip_col_val(mlp->prob, mlpi->c_n);
if (n == 1.0)
mlpi->n = GNUNET_YES;
else
mlpi->n = GNUNET_NO;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tAddress %s %f\n",
(n == 1.0) ? "[x]" : "[ ]", b);
}
}
if (mlp->mlp_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel(mlp->mlp_task);
mlp->mlp_task = GNUNET_SCHEDULER_NO_TASK;
}
mlp->mlp_task = GNUNET_SCHEDULER_add_delayed (mlp->exec_interval, &mlp_scheduler, mlp);
mlp->semaphore = GNUNET_NO;
return res;
}
int lpx_print_sol(LPX *lp, const char *fname)
{ /* write LP problem solution in printable format */
return glp_print_sol(lp, fname);
}
static PyObject* LPX_write(LPXObject *self, PyObject *args, PyObject *keywds)
{
static char* kwlist[] = {"mps", "freemps", "prob", "sol", "sens_bnds",
"ips", "mip", NULL};
char* fnames[] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL};
char* fname;
const char* err_msg = "writer for '%s' failed to write to '%s'";
int rv;
rv = PyArg_ParseTupleAndKeywords(args, keywds, "|sssssss", kwlist,
fnames,fnames+1,fnames+2,fnames+3, fnames+4,fnames+5,fnames+6);
if (!rv)
return NULL;
fname = fnames[0];
if (fname != NULL) {
rv = glp_write_mps(LP, GLP_MPS_DECK, NULL, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[0], fname);
return NULL;
}
}
fname = fnames[1];
if (fname != NULL) {
rv = glp_write_mps(LP, GLP_MPS_FILE, NULL, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[1], fname);
return NULL;
}
}
fname = fnames[2];
if (fname != NULL) {
rv = glp_write_lp(LP, NULL, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[2], fname);
return NULL;
}
}
fname = fnames[3];
if (fname != NULL) {
rv = glp_print_sol(LP, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[3], fname);
return NULL;
}
}
fname = fnames[4];
if (fname != NULL) {
if (glp_get_status(LP) == GLP_OPT && !glp_bf_exists(LP))
glp_factorize(LP);
rv = glp_print_ranges(LP, 0, NULL, 0, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[4], fname);
return NULL;
}
}
fname = fnames[5];
if (fname != NULL) {
rv = glp_print_ipt(LP, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[5], fname);
return NULL;
}
}
fname = fnames[6];
if (fname != NULL) {
glp_print_mip(LP, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[6], fname);
return NULL;
}
}
Py_RETURN_NONE;
}