int glp_asnprob_lp(glp_prob *P, int form, glp_graph *G, int names,
int v_set, int a_cost)
{ glp_vertex *v;
glp_arc *a;
int i, j, ret, ind[1+2];
double cost, val[1+2];
if (!(form == GLP_ASN_MIN || form == GLP_ASN_MAX ||
form == GLP_ASN_MMP))
xerror("glp_asnprob_lp: form = %d; invalid parameter\n",
form);
if (!(names == GLP_ON || names == GLP_OFF))
xerror("glp_asnprob_lp: names = %d; invalid parameter\n",
names);
if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
xerror("glp_asnprob_lp: v_set = %d; invalid offset\n",
v_set);
if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
xerror("glp_asnprob_lp: a_cost = %d; invalid offset\n",
a_cost);
ret = glp_check_asnprob(G, v_set);
if (ret != 0) goto done;
glp_erase_prob(P);
if (names) glp_set_prob_name(P, G->name);
glp_set_obj_dir(P, form == GLP_ASN_MIN ? GLP_MIN : GLP_MAX);
if (G->nv > 0) glp_add_rows(P, G->nv);
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
if (names) glp_set_row_name(P, i, v->name);
glp_set_row_bnds(P, i, form == GLP_ASN_MMP ? GLP_UP : GLP_FX,
1.0, 1.0);
}
if (G->na > 0) glp_add_cols(P, G->na);
for (i = 1, j = 0; i <= G->nv; i++)
{ v = G->v[i];
for (a = v->out; a != NULL; a = a->t_next)
{ j++;
if (names)
{ char name[50+1];
sprintf(name, "x[%d,%d]", a->tail->i, a->head->i);
xassert(strlen(name) < sizeof(name));
glp_set_col_name(P, j, name);
}
ind[1] = a->tail->i, val[1] = +1.0;
ind[2] = a->head->i, val[2] = +1.0;
glp_set_mat_col(P, j, 2, ind, val);
glp_set_col_bnds(P, j, GLP_DB, 0.0, 1.0);
if (a_cost >= 0)
memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
else
cost = 1.0;
glp_set_obj_coef(P, j, cost);
}
}
xassert(j == G->na);
done:
return ret;
}
int glp_asnprob_okalg(int form, glp_graph *G, int v_set, int a_cost,
double *sol, int a_x)
{ /* solve assignment problem with out-of-kilter algorithm */
glp_vertex *v;
glp_arc *a;
int nv, na, i, k, *tail, *head, *low, *cap, *cost, *x, *pi, ret;
double temp;
if (!(form == GLP_ASN_MIN || form == GLP_ASN_MAX ||
form == GLP_ASN_MMP))
xerror("glp_asnprob_okalg: form = %d; invalid parameter\n",
form);
if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
xerror("glp_asnprob_okalg: v_set = %d; invalid offset\n",
v_set);
if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
xerror("glp_asnprob_okalg: a_cost = %d; invalid offset\n",
a_cost);
if (a_x >= 0 && a_x > G->a_size - (int)sizeof(int))
xerror("glp_asnprob_okalg: a_x = %d; invalid offset\n", a_x);
if (glp_check_asnprob(G, v_set))
return GLP_EDATA;
/* nv is the total number of nodes in the resulting network */
nv = G->nv + 1;
/* na is the total number of arcs in the resulting network */
na = G->na + G->nv;
/* allocate working arrays */
tail = xcalloc(1+na, sizeof(int));
head = xcalloc(1+na, sizeof(int));
low = xcalloc(1+na, sizeof(int));
cap = xcalloc(1+na, sizeof(int));
cost = xcalloc(1+na, sizeof(int));
x = xcalloc(1+na, sizeof(int));
pi = xcalloc(1+nv, sizeof(int));
/* construct the resulting network */
k = 0;
/* (original arcs) */
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
for (a = v->out; a != NULL; a = a->t_next)
{ k++;
tail[k] = a->tail->i;
head[k] = a->head->i;
low[k] = 0;
cap[k] = 1;
if (a_cost >= 0)
memcpy(&temp, (char *)a->data + a_cost, sizeof(double));
else
temp = 1.0;
if (!(fabs(temp) <= (double)INT_MAX && temp == floor(temp)))
{ ret = GLP_EDATA;
goto done;
}
cost[k] = (int)temp;
if (form != GLP_ASN_MIN) cost[k] = - cost[k];
}
}
/* (artificial arcs) */
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
k++;
if (v->out == NULL)
tail[k] = i, head[k] = nv;
else if (v->in == NULL)
tail[k] = nv, head[k] = i;
else
xassert(v != v);
low[k] = (form == GLP_ASN_MMP ? 0 : 1);
cap[k] = 1;
cost[k] = 0;
}
xassert(k == na);
/* find minimal-cost circulation in the resulting network */
ret = okalg(nv, na, tail, head, low, cap, cost, x, pi);
switch (ret)
{ case 0:
/* optimal circulation found */
ret = 0;
break;
case 1:
/* no feasible circulation exists */
ret = GLP_ENOPFS;
break;
case 2:
/* integer overflow occured */
ret = GLP_ERANGE;
goto done;
case 3:
/* optimality test failed (logic error) */
ret = GLP_EFAIL;
goto done;
default:
xassert(ret != ret);
}
/* store solution components */
/* (objective function = the total cost) */
if (sol != NULL)
{ temp = 0.0;
for (k = 1; k <= na; k++)
temp += (double)cost[k] * (double)x[k];
if (form != GLP_ASN_MIN) temp = - temp;
*sol = temp;
}
/* (arc flows) */
if (a_x >= 0)
{ k = 0;
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
for (a = v->out; a != NULL; a = a->t_next)
{ k++;
if (ret == 0)
xassert(x[k] == 0 || x[k] == 1);
memcpy((char *)a->data + a_x, &x[k], sizeof(int));
}
}
}
done: /* free working arrays */
xfree(tail);
xfree(head);
xfree(low);
xfree(cap);
xfree(cost);
xfree(x);
xfree(pi);
return ret;
}
int glp_asnprob_hall(glp_graph *G, int v_set, int a_x)
{ glp_vertex *v;
glp_arc *a;
int card, i, k, loc, n, n1, n2, xij;
int *num, *icn, *ip, *lenr, *iperm, *pr, *arp, *cv, *out;
if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
xerror("glp_asnprob_hall: v_set = %d; invalid offset\n",
v_set);
if (a_x >= 0 && a_x > G->a_size - (int)sizeof(int))
xerror("glp_asnprob_hall: a_x = %d; invalid offset\n", a_x);
if (glp_check_asnprob(G, v_set))
return -1;
/* determine the number of vertices in sets R and S and renumber
vertices in S which correspond to columns of the matrix; skip
all isolated vertices */
num = xcalloc(1+G->nv, sizeof(int));
n1 = n2 = 0;
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
if (v->in == NULL && v->out != NULL)
n1++, num[i] = 0; /* vertex in R */
else if (v->in != NULL && v->out == NULL)
n2++, num[i] = n2; /* vertex in S */
else
{ xassert(v->in == NULL && v->out == NULL);
num[i] = -1; /* isolated vertex */
}
}
/* the matrix must be square, thus, if it has more columns than
rows, extra rows will be just empty, and vice versa */
n = (n1 >= n2 ? n1 : n2);
/* allocate working arrays */
icn = xcalloc(1+G->na, sizeof(int));
ip = xcalloc(1+n, sizeof(int));
lenr = xcalloc(1+n, sizeof(int));
iperm = xcalloc(1+n, sizeof(int));
pr = xcalloc(1+n, sizeof(int));
arp = xcalloc(1+n, sizeof(int));
cv = xcalloc(1+n, sizeof(int));
out = xcalloc(1+n, sizeof(int));
/* build the adjacency matrix of the bipartite graph in row-wise
format (rows are vertices in R, columns are vertices in S) */
k = 0, loc = 1;
for (i = 1; i <= G->nv; i++)
{ if (num[i] != 0) continue;
/* vertex i in R */
ip[++k] = loc;
v = G->v[i];
for (a = v->out; a != NULL; a = a->t_next)
{ xassert(num[a->head->i] != 0);
icn[loc++] = num[a->head->i];
}
lenr[k] = loc - ip[k];
}
xassert(loc-1 == G->na);
/* make all extra rows empty (all extra columns are empty due to
the row-wise format used) */
for (k++; k <= n; k++)
ip[k] = loc, lenr[k] = 0;
/* find a row permutation that maximizes the number of non-zeros
on the main diagonal */
card = mc21a(n, icn, ip, lenr, iperm, pr, arp, cv, out);
#if 1 /* 18/II-2010 */
/* FIXED: if card = n, arp remains clobbered on exit */
for (i = 1; i <= n; i++)
arp[i] = 0;
for (i = 1; i <= card; i++)
{ k = iperm[i];
xassert(1 <= k && k <= n);
xassert(arp[k] == 0);
arp[k] = i;
}
#endif
/* store solution, if necessary */
if (a_x < 0) goto skip;
k = 0;
for (i = 1; i <= G->nv; i++)
{ if (num[i] != 0) continue;
/* vertex i in R */
k++;
v = G->v[i];
for (a = v->out; a != NULL; a = a->t_next)
{ /* arp[k] is the number of matched column or zero */
if (arp[k] == num[a->head->i])
{ xassert(arp[k] != 0);
xij = 1;
}
else
xij = 0;
memcpy((char *)a->data + a_x, &xij, sizeof(int));
}
}
skip: /* free working arrays */
xfree(num);
xfree(icn);
xfree(ip);
xfree(lenr);
xfree(iperm);
xfree(pr);
xfree(arp);
xfree(cv);
xfree(out);
return card;
}
