/**
* Solves a linear ordering problem.
*
* @param inFile input file
* @param outFile output file
*/
private void solve(String inFile, String outFile)
{
glp_iocp iocp;
GlpkCallback.addListener(this);
read_data(inFile);
build_mip();
GLPK.glp_adv_basis(prob, 0);
GLPK.glp_simplex(prob, null);
iocp = new glp_iocp();
GLPK.glp_init_iocp(iocp);
GLPK.glp_intopt(prob, iocp);
GLPK.glp_print_mip(prob, outFile);
GlpkCallback.removeListener(this);
GLPK.glp_delete_prob(prob);
}
/// <summary>
/// Résout le problème
/// </summary>
/// <returns>Borne inférieure</returns>
private double _solve()
{
GLPK.glp_term_out(GLPK.GLP_OFF);
glp_iocp iocp;
GlpkCallback.addListener(this);
buildProblem(); //On construit le problème
GLPK.glp_adv_basis(problem, 0);
GLPK.glp_simplex(problem, null); //On résout
double val = GLPK.glp_get_obj_val(problem);
iocp = new glp_iocp();
GLPK.glp_init_iocp(iocp);
GLPK.glp_intopt(problem, iocp); //On cherche la solution entière optimale
GlpkCallback.removeListener(this);
GLPK.glp_delete_prob(problem);
return(GLPK.glp_get_obj_val(problem));
}
private Route _solve()
{
glp_iocp iocp;
GlpkCallback.addListener(this);
buildProblem();
GLPK.glp_adv_basis(problem, 0);
GLPK.glp_simplex(problem, null);
iocp = new glp_iocp();
GLPK.glp_init_iocp(iocp);
GLPK.glp_intopt(problem, iocp);
List <Route> res = getSubroutes(true);
GlpkCallback.removeListener(this);
GLPK.glp_delete_prob(problem);
return(res[0]);
}
private double _solve()
{
GLPK.glp_term_out(GLPK.GLP_OFF);
GlpkCallback.addListener(this);
buildProblem();
GLPK.glp_adv_basis(problem, 0);
GLPK.glp_simplex(problem, null);
double val = GLPK.glp_get_obj_val(problem);
/*iocp = new glp_iocp();
* GLPK.glp_init_iocp(iocp);
* GLPK.glp_intopt(problem, iocp);*/
List <Route> res = getSubroutes(true);
GlpkCallback.removeListener(this);
GLPK.glp_delete_prob(problem);
return(GLPK.glp_get_obj_val(problem));
}
public void solve(string[] arg)
{
glp_prob lp;
glp_tran tran;
glp_iocp iocp;
String fname;
int skip = 0;
int ret;
// listen to callbacks
GlpkCallback.addListener(this);
// listen to terminal output
GlpkTerminal.addListener(this);
try {
// create problem
lp = GLPK.glp_create_prob();
// allocate workspace
tran = GLPK.glp_mpl_alloc_wksp();
// read model
fname = arg [0];
ret = GLPK.glp_mpl_read_model(tran, fname, skip);
if (ret != 0)
{
GLPK.glp_mpl_free_wksp(tran);
GLPK.glp_delete_prob(lp);
throw new ApplicationException("Model file not valid: " + fname);
}
// generate model
ret = GLPK.glp_mpl_generate(tran, null);
if (ret != 0)
{
GLPK.glp_mpl_free_wksp(tran);
GLPK.glp_delete_prob(lp);
throw new ApplicationException("Cannot generate model: " + fname);
}
// build model
GLPK.glp_mpl_build_prob(tran, lp);
// set solver parameters
iocp = new glp_iocp();
GLPK.glp_init_iocp(iocp);
iocp.presolve = GLPK.GLP_ON;
// do not listen to output anymore
GlpkTerminal.removeListener(this);
// solve model
ret = GLPK.glp_intopt(lp, iocp);
// postsolve model
if (ret == 0)
{
GLPK.glp_mpl_postsolve(tran, lp, GLPK.GLP_MIP);
}
// free memory
GLPK.glp_mpl_free_wksp(tran);
GLPK.glp_delete_prob(lp);
} catch (org.gnu.glpk.GlpkException e) {
Console.Error.WriteLine("An error inside the GLPK library occured.");
Console.Error.WriteLine(e.Message);
} catch (ApplicationException e) {
Console.Error.WriteLine(e.Message);
}
// do not listen for callbacks anymore
GlpkCallback.removeListener(this);
// check that the terinal hook function has been used
if (!hookUsed)
{
throw new ApplicationException(
"The terminal output hook was not used.");
}
}
/**
* Main method.
* @param args Command line arguments
*/
static void Main(string[] args)
{
glp_prob lp;
glp_arc arc;
glp_cli_arc_data adata;
glp_cli_vertex_data vdata;
try {
glp_graph graph =
GLPK.glp_create_graph(
GLPK.GLP_CLI_V_SIZE,
GLPK.GLP_CLI_A_SIZE);
GLPK.glp_set_graph_name(graph, "MinimumCostFlow");
GLPK.glp_add_vertices(graph, 9);
GLPK.glp_set_vertex_name(graph, 1, "v1");
GLPK.glp_set_vertex_name(graph, 2, "v2");
GLPK.glp_set_vertex_name(graph, 3, "v3");
GLPK.glp_set_vertex_name(graph, 4, "v4");
GLPK.glp_set_vertex_name(graph, 5, "v5");
GLPK.glp_set_vertex_name(graph, 6, "v6");
GLPK.glp_set_vertex_name(graph, 7, "v7");
GLPK.glp_set_vertex_name(graph, 8, "v8");
GLPK.glp_set_vertex_name(graph, 9, "v9");
vdata = GLPK.glp_cli_vertex_data_get(graph, 1);
vdata.rhs = 20;
vdata = GLPK.glp_cli_vertex_data_get(graph, 9);
vdata.rhs = -20;
arc = GLPK.glp_add_arc(graph, 1, 2);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 14; adata.cost = 0;
arc = GLPK.glp_add_arc(graph, 1, 4);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 23; adata.cost = 0;
arc = GLPK.glp_add_arc(graph, 2, 4);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 9; adata.cost = 3;
arc = GLPK.glp_add_arc(graph, 2, 3);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 10; adata.cost = 2;
arc = GLPK.glp_add_arc(graph, 4, 5);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 26; adata.cost = 0;
arc = GLPK.glp_add_arc(graph, 5, 2);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 11; adata.cost = 1;
arc = GLPK.glp_add_arc(graph, 3, 8);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 18; adata.cost = 0;
arc = GLPK.glp_add_arc(graph, 3, 5);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 2; adata.cap = 12; adata.cost = 1;
arc = GLPK.glp_add_arc(graph, 5, 6);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 25; adata.cost = 5;
arc = GLPK.glp_add_arc(graph, 5, 7);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 4; adata.cost = 7;
arc = GLPK.glp_add_arc(graph, 6, 7);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 7; adata.cost = 0;
arc = GLPK.glp_add_arc(graph, 6, 8);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 4; adata.cap = 8; adata.cost = 0;
arc = GLPK.glp_add_arc(graph, 8, 9);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 20; adata.cost = 9;
arc = GLPK.glp_add_arc(graph, 7, 9);
adata = GLPK.glp_cli_arc_get_data(arc);
adata.low = 0; adata.cap = 15; adata.cost = 3;
GLPK.glp_write_mincost(graph,
GLPK.GLP_CLI_V_RHS,
GLPK.GLP_CLI_A_LOW,
GLPK.GLP_CLI_A_CAP,
GLPK.GLP_CLI_A_COST,
"mincost.dimacs");
lp = GLPK.glp_create_prob();
GLPK.glp_mincost_lp(lp, graph,
GLPK.GLP_ON, // use symbolic names
GLPK.GLP_CLI_V_RHS,
GLPK.GLP_CLI_A_LOW,
GLPK.GLP_CLI_A_CAP,
GLPK.GLP_CLI_A_COST);
GLPK.glp_delete_graph(graph);
GLPK.glp_write_lp(lp, null, "mincost.lp");
GLPK.glp_delete_prob(lp);
} catch (org.gnu.glpk.GlpkException ex) {
Console.WriteLine(ex.Message);
Environment.Exit(1);
}
}
/**
* Build a model with one column
*
* @return error error occurred
*/
private bool run()
{
glp_prob lp;
glp_iocp iocp;
SWIGTYPE_p_int ind;
SWIGTYPE_p_double val;
bool ret = false;
try {
// Create problem
lp = GLPK.glp_create_prob();
Console.WriteLine("Problem created");
GLPK.glp_set_prob_name(lp, "myProblem");
// Define columns
GLPK.glp_add_cols(lp, 2);
GLPK.glp_set_col_name(lp, 1, "x1");
GLPK.glp_set_col_kind(lp, 1, GLPK.GLP_IV);
GLPK.glp_set_col_bnds(lp, 1, GLPK.GLP_LO, 0, 0);
GLPK.glp_set_col_name(lp, 2, "x2");
GLPK.glp_set_col_kind(lp, 2, GLPK.GLP_IV);
GLPK.glp_set_col_bnds(lp, 2, GLPK.GLP_LO, 0, 0);
// Create constraints
GLPK.glp_add_rows(lp, 2);
GLPK.glp_set_row_name(lp, 1, "c1");
GLPK.glp_set_row_bnds(lp, 1, GLPK.GLP_UP, 0, 40);
ind = GLPK.new_intArray(3);
GLPK.intArray_setitem(ind, 1, 1);
GLPK.intArray_setitem(ind, 2, 2);
val = GLPK.new_doubleArray(3);
GLPK.doubleArray_setitem(val, 1, 10);
GLPK.doubleArray_setitem(val, 2, 7);
GLPK.glp_set_mat_row(lp, 1, 2, ind, val);
GLPK.delete_intArray(ind);
GLPK.delete_doubleArray(val);
ind = GLPK.new_intArray(3);
GLPK.intArray_setitem(ind, 1, 1);
GLPK.intArray_setitem(ind, 2, 2);
val = GLPK.new_doubleArray(3);
GLPK.glp_set_row_name(lp, 2, "c2");
GLPK.glp_set_row_bnds(lp, 2, GLPK.GLP_UP, 0, 5);
GLPK.doubleArray_setitem(val, 1, 1);
GLPK.doubleArray_setitem(val, 2, 1);
GLPK.glp_set_mat_row(lp, 2, 2, ind, val);
GLPK.delete_intArray(ind);
GLPK.delete_doubleArray(val);
// Define objective
GLPK.glp_set_obj_name(lp, "obj");
GLPK.glp_set_obj_dir(lp, GLPK.GLP_MAX);
GLPK.glp_set_obj_coef(lp, 0, 0);
GLPK.glp_set_obj_coef(lp, 1, 17);
GLPK.glp_set_obj_coef(lp, 2, 12);
// solve model
iocp = new glp_iocp();
GLPK.glp_init_iocp(iocp);
iocp.presolve = GLPK.GLP_ON;
iocp.msg_lev = GLPK.GLP_MSG_OFF;
GLPK.glp_intopt(lp, iocp);
// free memory
GLPK.glp_delete_prob(lp);
} catch (GlpkException ex) {
Console.WriteLine(ex.Message);
ret = true;
}
return(ret);
}
static void Main(string[] args)
{
glp_prob lp;
glp_smcp parm;
SWIGTYPE_p_int ind;
SWIGTYPE_p_double val;
int ret;
try {
lp = GLPK.glp_create_prob();
Console.WriteLine("Problem created");
// Define columns
GLPK.glp_add_cols(lp, 3);
GLPK.glp_set_col_name(lp, 1, "x1");
GLPK.glp_set_col_kind(lp, 1, GLPK.GLP_CV);
GLPK.glp_set_col_bnds(lp, 1, GLPK.GLP_DB, 0, .5);
GLPK.glp_set_col_name(lp, 2, "x2");
GLPK.glp_set_col_kind(lp, 2, GLPK.GLP_CV);
GLPK.glp_set_col_bnds(lp, 2, GLPK.GLP_DB, 0, .5);
GLPK.glp_set_col_name(lp, 3, "x3");
GLPK.glp_set_col_kind(lp, 3, GLPK.GLP_CV);
GLPK.glp_set_col_bnds(lp, 3, GLPK.GLP_DB, 0, .5);
// Create constraints
// Allocate memory
ind = GLPK.new_intArray(3);
val = GLPK.new_doubleArray(3);
// Create rows
GLPK.glp_add_rows(lp, 2);
// Set row details
GLPK.glp_set_row_name(lp, 1, "c1");
GLPK.glp_set_row_bnds(lp, 1, GLPK.GLP_DB, 0, 0.2);
GLPK.intArray_setitem(ind, 1, 1);
GLPK.intArray_setitem(ind, 2, 2);
GLPK.doubleArray_setitem(val, 1, 1.0);
GLPK.doubleArray_setitem(val, 2, -.5);
GLPK.glp_set_mat_row(lp, 1, 2, ind, val);
GLPK.glp_set_row_name(lp, 2, "c2");
GLPK.glp_set_row_bnds(lp, 2, GLPK.GLP_UP, 0, 0.4);
GLPK.intArray_setitem(ind, 1, 2);
GLPK.intArray_setitem(ind, 2, 3);
GLPK.doubleArray_setitem(val, 1, -1.0);
GLPK.doubleArray_setitem(val, 2, 1.0);
GLPK.glp_set_mat_row(lp, 2, 2, ind, val);
// Free memory
GLPK.delete_intArray(ind);
GLPK.delete_doubleArray(val);
// Define objective
GLPK.glp_set_obj_name(lp, "z");
GLPK.glp_set_obj_dir(lp, GLPK.GLP_MIN);
GLPK.glp_set_obj_coef(lp, 0, 1.0);
GLPK.glp_set_obj_coef(lp, 1, -.5);
GLPK.glp_set_obj_coef(lp, 2, .5);
GLPK.glp_set_obj_coef(lp, 3, -1);
// Solve model
parm = new glp_smcp();
GLPK.glp_init_smcp(parm);
ret = GLPK.glp_simplex(lp, parm);
// Retrieve solution
if (ret == 0)
{
write_lp_solution(lp);
}
else
{
Console.WriteLine("The problem could not be solved");
}
// Free memory
GLPK.glp_delete_prob(lp);
} catch (GlpkException) {
Console.WriteLine("Error caught");
ret = 1;
}
Environment.Exit(ret);
}
