glp_arc *glp_add_arc(glp_graph *G, int i, int j)
{ glp_arc *a;
if (!(1 <= i && i <= G->nv))
xerror("glp_add_arc: i = %d; tail vertex number out of range\n"
, i);
if (!(1 <= j && j <= G->nv))
xerror("glp_add_arc: j = %d; head vertex number out of range\n"
, j);
if (G->na == NA_MAX)
xerror("glp_add_arc: too many arcs\n");
a = dmp_get_atom(G->pool, sizeof(glp_arc));
a->tail = G->v[i];
a->head = G->v[j];
if (G->a_size == 0)
a->data = NULL;
else
{ a->data = dmp_get_atom(G->pool, G->a_size);
memset(a->data, 0, G->a_size);
}
a->temp = NULL;
a->t_prev = NULL;
a->t_next = G->v[i]->out;
if (a->t_next != NULL) a->t_next->t_prev = a;
a->h_prev = NULL;
a->h_next = G->v[j]->in;
if (a->h_next != NULL) a->h_next->h_prev = a;
G->v[i]->out = G->v[j]->in = a;
G->na++;
return a;
}
void *npp_push_tse(NPP *npp, int (*func)(NPP *npp, void *info),
int size)
{ /* push new entry to the transformation stack */
NPPTSE *tse;
tse = dmp_get_atom(npp->stack, sizeof(NPPTSE));
tse->func = func;
tse->info = dmp_get_atom(npp->stack, size);
tse->link = npp->top;
npp->top = tse;
return tse->info;
}
IPPCOL *ipp_add_col(IPP *ipp, int i_flag, double lb, double ub,
double c)
{ IPPCOL *col;
/* perform sanity checks */
xassert(lb <= ub);
if (i_flag)
{ if (lb != -DBL_MAX) xassert(lb == floor(lb));
if (ub != +DBL_MAX) xassert(ub == floor(ub));
}
/* create new column */
col = dmp_get_atom(ipp->col_pool, sizeof(IPPCOL));
col->j = ++(ipp->ncols);
col->i_flag = i_flag;
col->lb = lb;
col->ub = ub;
col->c = c;
col->ptr = NULL;
col->temp = 0;
col->prev = NULL;
col->next = ipp->col_ptr;
col->q_flag = 0;
col->q_prev = NULL;
col->q_next = NULL;
/* add the column to the linked list of columns */
if (col->next != NULL) col->next->prev = col;
ipp->col_ptr = col;
return col;
}
void glp_set_col_name(glp_prob *lp, int j, const char *name)
{ GLPCOL *col;
if (!(1 <= j && j <= lp->n))
xerror("glp_set_col_name: j = %d; column number out of range\n"
, j);
col = lp->col[j];
if (col->name != NULL)
{ if (col->node != NULL)
{ xassert(lp->c_tree != NULL);
avl_delete_node(lp->c_tree, col->node);
col->node = NULL;
}
dmp_free_atom(lp->pool, col->name, strlen(col->name)+1);
col->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ if (strlen(name) > 255)
xerror("glp_set_col_name: j = %d; column name too long\n",
j);
col->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(col->name, name);
if (lp->c_tree != NULL && col->name != NULL)
{ xassert(col->node == NULL);
col->node = avl_insert_node(lp->c_tree, col->name);
avl_set_node_link(col->node, col);
}
}
return;
}
void glp_set_row_name(glp_prob *lp, int i, const char *name)
{ GLPROW *row;
if (!(1 <= i && i <= lp->m))
xerror("glp_set_row_name: i = %d; row number out of range\n",
i);
row = lp->row[i];
if (row->name != NULL)
{ if (row->node != NULL)
{ xassert(lp->r_tree != NULL);
avl_delete_node(lp->r_tree, row->node);
row->node = NULL;
}
dmp_free_atom(lp->pool, row->name, strlen(row->name)+1);
row->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ if (strlen(name) > 255)
xerror("glp_set_row_name: i = %d; row name too long\n", i);
row->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(row->name, name);
if (lp->r_tree != NULL)
{ xassert(row->node == NULL);
row->node = avl_insert_node(lp->r_tree, row->name);
avl_set_node_link(row->node, row);
}
}
return;
}
int glp_add_rows(glp_prob *lp, int nrs)
{ glp_tree *tree = lp->tree;
GLPROW *row;
int m_new, i;
/* determine new number of rows */
if (nrs < 1)
xerror("glp_add_rows: nrs = %d; invalid number of rows\n",
nrs);
if (nrs > M_MAX - lp->m)
xerror("glp_add_rows: nrs = %d; too many rows\n", nrs);
m_new = lp->m + nrs;
/* increase the room, if necessary */
if (lp->m_max < m_new)
{ GLPROW **save = lp->row;
while (lp->m_max < m_new)
{ lp->m_max += lp->m_max;
xassert(lp->m_max > 0);
}
lp->row = xcalloc(1+lp->m_max, sizeof(GLPROW *));
memcpy(&lp->row[1], &save[1], lp->m * sizeof(GLPROW *));
xfree(save);
/* do not forget about the basis header */
xfree(lp->head);
lp->head = xcalloc(1+lp->m_max, sizeof(int));
}
/* add new rows to the end of the row list */
for (i = lp->m+1; i <= m_new; i++)
{ /* create row descriptor */
lp->row[i] = row = dmp_get_atom(lp->pool, sizeof(GLPROW));
row->i = i;
row->name = NULL;
row->node = NULL;
row->type = GLP_FR;
row->lb = row->ub = 0.0;
row->ptr = NULL;
row->rii = 1.0;
row->stat = GLP_BS;
#if 0
row->bind = -1;
#else
row->bind = 0;
#endif
row->prim = row->dual = 0.0;
row->pval = row->dval = 0.0;
row->mipx = 0.0;
}
/* set new number of rows */
lp->m = m_new;
/* invalidate the basis factorization */
lp->valid = 0;
#if 1
if (tree != NULL && tree->reason != 0) tree->reopt = 1;
#endif
/* return the ordinal number of the first row added */
return m_new - nrs + 1;
}
int glp_add_vertices(glp_graph *G, int nadd)
{ int i, nv_new;
if (nadd < 1)
xerror("glp_add_vertices: nadd = %d; invalid number of vertice"
"s\n", nadd);
if (nadd > NV_MAX - G->nv)
xerror("glp_add_vertices: nadd = %d; too many vertices\n",
nadd);
/* determine new number of vertices */
nv_new = G->nv + nadd;
/* increase the room, if necessary */
if (G->nv_max < nv_new)
{ glp_vertex **save = G->v;
while (G->nv_max < nv_new)
{ G->nv_max += G->nv_max;
xassert(G->nv_max > 0);
}
G->v = xcalloc(1+G->nv_max, sizeof(glp_vertex *));
memcpy(&G->v[1], &save[1], G->nv * sizeof(glp_vertex *));
xfree(save);
}
/* add new vertices to the end of the vertex list */
for (i = G->nv+1; i <= nv_new; i++)
{ glp_vertex *v;
G->v[i] = v = dmp_get_atom(G->pool, sizeof(glp_vertex));
v->i = i;
v->name = NULL;
v->entry = NULL;
if (G->v_size == 0)
v->data = NULL;
else
{ v->data = dmp_get_atom(G->pool, G->v_size);
memset(v->data, 0, G->v_size);
}
v->temp = NULL;
v->in = v->out = NULL;
}
/* set new number of vertices */
G->nv = nv_new;
/* return the ordinal number of the first vertex added */
return nv_new - nadd + 1;
}
NPPROW *npp_add_row(NPP *npp)
{ /* add new row to the current problem */
NPPROW *row;
row = dmp_get_atom(npp->pool, sizeof(NPPROW));
row->i = ++(npp->nrows);
row->name = NULL;
row->lb = -DBL_MAX, row->ub = +DBL_MAX;
row->ptr = NULL;
row->temp = 0;
npp_insert_row(npp, row, 1);
return row;
}
int ipp_nonbin_col(IPP *ipp, IPPCOL *col)
{ /* process non-binary column */
struct nonbin_col *info;
IPPROW *row;
IPPCOL *bin;
IPPAIJ *aij;
IPPLFE *lfe;
int u, t, two_t, k, two_k;
/* the column must be integral */
xassert(col->i_flag);
/* its lower bound must be zero */
xassert(col->lb == 0.0);
/* its upper bound must be greater than one */
xassert(col->ub >= 2.0);
/* and must be not greater than 2^15-1 = 32767 (implementation
restriction) */
xassert(col->ub <= 32767.0);
/* create transformation queue entry */
info = ipp_append_tqe(ipp, IPP_NONBIN_COL, sizeof(*info));
info->q = col->j;
info->ptr = NULL;
/* determine t, minimal number of bits sufficient to represent
the upper bound */
u = (int)col->ub;
xassert(col->ub == (double)u);
for (t = 2, two_t = 4; t <= 15; t++, two_t += two_t)
if (u <= two_t - 1) break;
xassert(t <= 15);
/* create additional constraint (3), if necessary */
if (u <= two_t - 2)
row = ipp_add_row(ipp, -DBL_MAX, (double)u);
/* create binary columns z[0], z[1], ..., z[t-1] */
for (k = 0, two_k = 1; k < t; k++, two_k += two_k)
{ bin = ipp_add_col(ipp, 1, 0.0, 1.0, 0.0);
lfe = dmp_get_atom(ipp->tqe_pool, sizeof(IPPLFE));
lfe->ref = bin->j;
lfe->val = (double)two_k;
lfe->next = info->ptr;
info->ptr = lfe;
/* create constraint coefficients for z[k] */
for (aij = col->ptr; aij != NULL; aij = aij->c_next)
ipp_add_aij(ipp, aij->row, bin, aij->val * lfe->val);
/* create objective coefficient for z[k] */
bin->c = col->c * lfe->val;
/* include z[k] in additional constraint (3), if necessary */
if (u <= two_t - 2)
ipp_add_aij(ipp, row, bin, lfe->val);
}
/* remove the original column x[q] from the problem */
ipp_remove_col(ipp, col);
return t;
}
int glp_add_cols(glp_prob *lp, int ncs)
{ glp_tree *tree = lp->tree;
GLPCOL *col;
int n_new, j;
if (tree != NULL && tree->reason != 0)
xerror("glp_add_cols: operation not allowed\n");
/* determine new number of columns */
if (ncs < 1)
xerror("glp_add_cols: ncs = %d; invalid number of columns\n",
ncs);
if (ncs > N_MAX - lp->n)
xerror("glp_add_cols: ncs = %d; too many columns\n", ncs);
n_new = lp->n + ncs;
/* increase the room, if necessary */
if (lp->n_max < n_new)
{ GLPCOL **save = lp->col;
while (lp->n_max < n_new)
{ lp->n_max += lp->n_max;
xassert(lp->n_max > 0);
}
lp->col = xcalloc(1+lp->n_max, sizeof(GLPCOL *));
memcpy(&lp->col[1], &save[1], lp->n * sizeof(GLPCOL *));
xfree(save);
}
/* add new columns to the end of the column list */
for (j = lp->n+1; j <= n_new; j++)
{ /* create column descriptor */
lp->col[j] = col = dmp_get_atom(lp->pool, sizeof(GLPCOL));
col->j = j;
col->name = NULL;
col->node = NULL;
col->kind = GLP_CV;
col->type = GLP_FX;
col->lb = col->ub = 0.0;
col->coef = 0.0;
col->ptr = NULL;
col->sjj = 1.0;
col->stat = GLP_NS;
#if 0
col->bind = -1;
#else
col->bind = 0; /* the basis may remain valid */
#endif
col->prim = col->dual = 0.0;
col->pval = col->dval = 0.0;
col->mipx = 0.0;
}
/* set new number of columns */
lp->n = n_new;
/* return the ordinal number of the first column added */
return n_new - ncs + 1;
}
void glp_set_obj_name(glp_prob *lp, const char *name)
{ if (lp->obj != NULL)
{ dmp_free_atom(lp->pool, lp->obj, strlen(lp->obj)+1);
lp->obj = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ if (strlen(name) > 255)
xerror("glp_set_obj_name: objective name too long\n");
lp->obj = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(lp->obj, name);
}
return;
}
void glp_set_prob_name(glp_prob *lp, const char *name)
{ if (lp->name != NULL)
{ dmp_free_atom(lp->pool, lp->name, strlen(lp->name)+1);
lp->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ if (strlen(name) > 255)
xerror("glp_set_prob_name: problem name too long\n");
lp->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(lp->name, name);
}
return;
}
static struct elem *copy_form(NPP *npp, NPPROW *row, double s)
{ /* copy linear form */
NPPAIJ *aij;
struct elem *ptr, *e;
ptr = NULL;
for (aij = row->ptr; aij != NULL; aij = aij->r_next)
{ e = dmp_get_atom(npp->pool, sizeof(struct elem));
e->aj = s * aij->val;
e->xj = aij->col;
e->next = ptr;
ptr = e;
}
return ptr;
}
IPPAIJ *ipp_add_aij(IPP *ipp, IPPROW *row, IPPCOL *col, double val)
{ IPPAIJ *aij;
xassert(val != 0.0);
aij = dmp_get_atom(ipp->aij_pool, sizeof(IPPAIJ));
aij->row = row;
aij->col = col;
aij->val = val;
aij->r_prev = NULL;
aij->r_next = row->ptr;
aij->c_prev = NULL;
aij->c_next = col->ptr;
if (row->ptr != NULL) row->ptr->r_prev = aij;
if (col->ptr != NULL) col->ptr->c_prev = aij;
row->ptr = col->ptr = aij;
return aij;
}
LPPAIJ *lpp_add_aij(LPP *lpp, LPPROW *row, LPPCOL *col, double val)
{ LPPAIJ *aij;
insist(val != 0.0);
aij = dmp_get_atom(lpp->aij_pool);
aij->row = row;
aij->col = col;
aij->val = val;
aij->r_prev = NULL;
aij->r_next = row->ptr;
aij->c_prev = NULL;
aij->c_next = col->ptr;
if (row->ptr != NULL) row->ptr->r_prev = aij;
if (col->ptr != NULL) col->ptr->c_prev = aij;
row->ptr = col->ptr = aij;
return aij;
}
NPPCOL *npp_add_col(NPP *npp)
{ /* add new column to the current problem */
NPPCOL *col;
col = dmp_get_atom(npp->pool, sizeof(NPPCOL));
col->j = ++(npp->ncols);
col->name = NULL;
#if 0
col->kind = GLP_CV;
#else
col->is_int = 0;
#endif
col->lb = col->ub = col->coef = 0.0;
col->ptr = NULL;
col->temp = 0;
npp_insert_col(npp, col, 1);
return col;
}
SPME *spm_new_elem(SPM *A, int i, int j, double val)
{ SPME *e;
xassert(1 <= i && i <= A->m);
xassert(1 <= j && j <= A->n);
e = dmp_get_atom(A->pool, sizeof(SPME));
e->i = i;
e->j = j;
e->val = val;
e->r_prev = NULL;
e->r_next = A->row[i];
if (e->r_next != NULL) e->r_next->r_prev = e;
e->c_prev = NULL;
e->c_next = A->col[j];
if (e->c_next != NULL) e->c_next->c_prev = e;
A->row[i] = A->col[j] = e;
return e;
}
LPPCOL *lpp_add_col(LPP *lpp, double lb, double ub, double c)
{ LPPCOL *col;
col = dmp_get_atom(lpp->col_pool);
col->j = ++(lpp->ncols);
col->lb = lb;
col->ub = ub;
col->c = c;
col->ptr = NULL;
col->prev = NULL;
col->next = lpp->col_ptr;
col->q_flag = 0;
col->q_prev = col->q_next = NULL;
if (lpp->col_ptr != NULL) lpp->col_ptr->prev = col;
lpp->col_ptr = col;
lpp_enque_col(lpp, col);
return col;
}
LPPROW *lpp_add_row(LPP *lpp, double lb, double ub)
{ LPPROW *row;
row = dmp_get_atom(lpp->row_pool);
row->i = ++(lpp->nrows);
row->lb = lb;
row->ub = ub;
row->ptr = NULL;
row->temp = 0;
row->prev = NULL;
row->next = lpp->row_ptr;
row->q_flag = 0;
row->q_prev = row->q_next = NULL;
if (lpp->row_ptr != NULL) lpp->row_ptr->prev = row;
lpp->row_ptr = row;
lpp_enque_row(lpp, row);
return row;
}
NPPAIJ *npp_add_aij(NPP *npp, NPPROW *row, NPPCOL *col, double val)
{ /* add new element to the constraint matrix */
NPPAIJ *aij;
aij = dmp_get_atom(npp->pool, sizeof(NPPAIJ));
aij->row = row;
aij->col = col;
aij->val = val;
aij->r_prev = NULL;
aij->r_next = row->ptr;
aij->c_prev = NULL;
aij->c_next = col->ptr;
if (aij->r_next != NULL)
aij->r_next->r_prev = aij;
if (aij->c_next != NULL)
aij->c_next->c_prev = aij;
row->ptr = col->ptr = aij;
return aij;
}
SLICE *expand_slice
( MPL *mpl,
SLICE *slice, /* destroyed */
SYMBOL *sym /* destroyed */
)
{ SLICE *tail, *temp;
/* create a new component */
tail = dmp_get_atom(mpl->tuples);
tail->sym = sym;
tail->next = NULL;
/* and append it to the component list */
if (slice == NULL)
slice = tail;
else
{ for (temp = slice; temp->next != NULL; temp = temp->next);
temp->next = tail;
}
return slice;
}
void glp_set_graph_name(glp_graph *G, const char *name)
{ if (G->name != NULL)
{ dmp_free_atom(G->pool, G->name, strlen(G->name)+1);
G->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int j;
for (j = 0; name[j] != '\0'; j++)
{ if (j == 256)
xerror("glp_set_graph_name: graph name too long\n");
if (iscntrl((unsigned char)name[j]))
xerror("glp_set_graph_name: graph name contains invalid "
"character(s)\n");
}
G->name = dmp_get_atom(G->pool, strlen(name)+1);
strcpy(G->name, name);
}
return;
}
SCGRIB *scg_add_edge(SCG *g, int i, int j)
{ /* add new edge (i,j) to cliqued graph */
SCGRIB *e;
int t;
xassert(1 <= i && i <= g->n);
xassert(1 <= j && j <= g->n);
if (i > j) t = i, i = j, j = t;
xassert(i < j);
e = dmp_get_atom(g->pool, sizeof(SCGRIB));
e->i = i;
e->j = j;
e->i_prev = NULL;
e->i_next = g->i_ptr[i];
e->j_prev = NULL;
e->j_next = g->j_ptr[j];
if (e->i_next != NULL) e->i_next->i_prev = e;
if (e->j_next != NULL) e->j_next->j_prev = e;
g->i_ptr[i] = g->j_ptr[j] = e;
return e;
}
IPPROW *ipp_add_row(IPP *ipp, double lb, double ub)
{ IPPROW *row;
/* perform sanity checks */
xassert(lb <= ub);
/* create new row */
row = dmp_get_atom(ipp->row_pool, sizeof(IPPROW));
row->lb = lb;
row->ub = ub;
row->ptr = NULL;
row->temp = 0;
row->prev = NULL;
row->next = ipp->row_ptr;
row->q_flag = 0;
row->q_prev = NULL;
row->q_next = NULL;
/* add the row to the linked list of rows */
if (row->next != NULL) row->next->prev = row;
ipp->row_ptr = row;
return row;
}
void glp_set_row_name(glp_prob *lp, int i, const char *name)
{ glp_tree *tree = lp->tree;
GLPROW *row;
if (!(1 <= i && i <= lp->m))
xerror("glp_set_row_name: i = %d; row number out of range\n",
i);
row = lp->row[i];
if (tree != NULL && tree->reason != 0)
{ xassert(tree->curr != NULL);
xassert(row->level == tree->curr->level);
}
if (row->name != NULL)
{ if (row->node != NULL)
{ xassert(lp->r_tree != NULL);
avl_delete_node(lp->r_tree, row->node);
row->node = NULL;
}
dmp_free_atom(lp->pool, row->name, strlen(row->name)+1);
row->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_row_name: i = %d; row name too long\n",
i);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_row_name: i = %d: row name contains inva"
"lid character(s)\n", i);
}
row->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(row->name, name);
if (lp->r_tree != NULL)
{ xassert(row->node == NULL);
row->node = avl_insert_node(lp->r_tree, row->name);
avl_set_node_link(row->node, row);
}
}
return;
}
void glp_set_obj_name(glp_prob *lp, const char *name)
{ glp_tree *tree = lp->tree;
if (tree != NULL && tree->reason != 0)
xerror("glp_set_obj_name: operation not allowed\n");
if (lp->obj != NULL)
{ dmp_free_atom(lp->pool, lp->obj, strlen(lp->obj)+1);
lp->obj = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_obj_name: objective name too long\n");
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_obj_name: objective name contains invali"
"d character(s)\n");
}
lp->obj = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(lp->obj, name);
}
return;
}
int npp_make_fixed(NPP *npp, NPPCOL *q)
{ /* process column with almost identical bounds */
struct make_fixed *info;
NPPAIJ *aij;
NPPLFE *lfe;
double s, eps, nint;
/* the column must be double-bounded */
xassert(q->lb != -DBL_MAX);
xassert(q->ub != +DBL_MAX);
xassert(q->lb < q->ub);
/* check column bounds */
eps = 1e-9 + 1e-12 * fabs(q->lb);
if (q->ub - q->lb > eps) return 0;
/* column bounds are very close to each other */
/* create transformation stack entry */
info = npp_push_tse(npp,
rcv_make_fixed, sizeof(struct make_fixed));
info->q = q->j;
info->c = q->coef;
info->ptr = NULL;
/* save column coefficients a[i,q] (needed for basic solution
only) */
if (npp->sol == GLP_SOL)
{ for (aij = q->ptr; aij != NULL; aij = aij->c_next)
{ lfe = dmp_get_atom(npp->stack, sizeof(NPPLFE));
lfe->ref = aij->row->i;
lfe->val = aij->val;
lfe->next = info->ptr;
info->ptr = lfe;
}
}
/* compute column fixed value */
s = 0.5 * (q->ub + q->lb);
nint = floor(s + 0.5);
if (fabs(s - nint) <= eps) s = nint;
/* make column q fixed */
q->lb = q->ub = s;
return 1;
}
void glp_set_col_name(glp_prob *lp, int j, const char *name)
{ glp_tree *tree = lp->tree;
GLPCOL *col;
if (tree != NULL && tree->reason != 0)
xerror("glp_set_col_name: operation not allowed\n");
if (!(1 <= j && j <= lp->n))
xerror("glp_set_col_name: j = %d; column number out of range\n"
, j);
col = lp->col[j];
if (col->name != NULL)
{ if (col->node != NULL)
{ xassert(lp->c_tree != NULL);
avl_delete_node(lp->c_tree, col->node);
col->node = NULL;
}
dmp_free_atom(lp->pool, col->name, strlen(col->name)+1);
col->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_col_name: j = %d; column name too long\n"
, j);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_col_name: j = %d: column name contains i"
"nvalid character(s)\n", j);
}
col->name = dmp_get_atom(lp->pool, strlen(name)+1);
strcpy(col->name, name);
if (lp->c_tree != NULL && col->name != NULL)
{ xassert(col->node == NULL);
col->node = avl_insert_node(lp->c_tree, col->name);
avl_set_node_link(col->node, col);
}
}
return;
}
void glp_set_vertex_name(glp_graph *G, int i, const char *name)
{ /* assign (change) vertex name */
glp_vertex *v;
if (!(1 <= i && i <= G->nv))
xerror("glp_set_vertex_name: i = %d; vertex number out of rang"
"e\n", i);
v = G->v[i];
if (v->name != NULL)
{ if (v->entry != NULL)
{ xassert(G->index != NULL);
avl_delete_node(G->index, v->entry);
v->entry = NULL;
}
dmp_free_atom(G->pool, v->name, strlen(v->name)+1);
v->name = NULL;
}
if (!(name == NULL || name[0] == '\0'))
{ int k;
for (k = 0; name[k] != '\0'; k++)
{ if (k == 256)
xerror("glp_set_vertex_name: i = %d; vertex name too lon"
"g\n", i);
if (iscntrl((unsigned char)name[k]))
xerror("glp_set_vertex_name: i = %d; vertex name contain"
"s invalid character(s)\n", i);
}
v->name = dmp_get_atom(G->pool, strlen(name)+1);
strcpy(v->name, name);
if (G->index != NULL)
{ xassert(v->entry == NULL);
v->entry = avl_insert_node(G->index, v->name);
avl_set_node_link(v->entry, v);
}
}
return;
}
static void initialize(LUX *lux, int (*col)(void *info, int j,
int ind[], mpq_t val[]), void *info, LUXWKA *wka)
{ int n = lux->n;
DMP *pool = lux->pool;
LUXELM **F_row = lux->F_row;
LUXELM **F_col = lux->F_col;
mpq_t *V_piv = lux->V_piv;
LUXELM **V_row = lux->V_row;
LUXELM **V_col = lux->V_col;
int *P_row = lux->P_row;
int *P_col = lux->P_col;
int *Q_row = lux->Q_row;
int *Q_col = lux->Q_col;
int *R_len = wka->R_len;
int *R_head = wka->R_head;
int *R_prev = wka->R_prev;
int *R_next = wka->R_next;
int *C_len = wka->C_len;
int *C_head = wka->C_head;
int *C_prev = wka->C_prev;
int *C_next = wka->C_next;
LUXELM *fij, *vij;
int i, j, k, len, *ind;
mpq_t *val;
/* F := I */
for (i = 1; i <= n; i++)
{ while (F_row[i] != NULL)
{ fij = F_row[i], F_row[i] = fij->r_next;
mpq_clear(fij->val);
dmp_free_atom(pool, fij, sizeof(LUXELM));
}
}
for (j = 1; j <= n; j++) F_col[j] = NULL;
/* V := 0 */
for (k = 1; k <= n; k++) mpq_set_si(V_piv[k], 0, 1);
for (i = 1; i <= n; i++)
{ while (V_row[i] != NULL)
{ vij = V_row[i], V_row[i] = vij->r_next;
mpq_clear(vij->val);
dmp_free_atom(pool, vij, sizeof(LUXELM));
}
}
for (j = 1; j <= n; j++) V_col[j] = NULL;
/* V := A */
ind = xcalloc(1+n, sizeof(int));
val = xcalloc(1+n, sizeof(mpq_t));
for (k = 1; k <= n; k++) mpq_init(val[k]);
for (j = 1; j <= n; j++)
{ /* obtain j-th column of matrix A */
len = col(info, j, ind, val);
if (!(0 <= len && len <= n))
xfault("lux_decomp: j = %d: len = %d; invalid column length"
"\n", j, len);
/* copy elements of j-th column to matrix V */
for (k = 1; k <= len; k++)
{ /* get row index of a[i,j] */
i = ind[k];
if (!(1 <= i && i <= n))
xfault("lux_decomp: j = %d: i = %d; row index out of ran"
"ge\n", j, i);
/* check for duplicate indices */
if (V_row[i] != NULL && V_row[i]->j == j)
xfault("lux_decomp: j = %d: i = %d; duplicate row indice"
"s not allowed\n", j, i);
/* check for zero value */
if (mpq_sgn(val[k]) == 0)
xfault("lux_decomp: j = %d: i = %d; zero elements not al"
"lowed\n", j, i);
/* add new element v[i,j] = a[i,j] to V */
vij = dmp_get_atom(pool, sizeof(LUXELM));
vij->i = i, vij->j = j;
mpq_init(vij->val);
mpq_set(vij->val, val[k]);
vij->r_prev = NULL;
vij->r_next = V_row[i];
vij->c_prev = NULL;
vij->c_next = V_col[j];
if (vij->r_next != NULL) vij->r_next->r_prev = vij;
if (vij->c_next != NULL) vij->c_next->c_prev = vij;
V_row[i] = V_col[j] = vij;
}
}
xfree(ind);
for (k = 1; k <= n; k++) mpq_clear(val[k]);
xfree(val);
/* P := Q := I */
for (k = 1; k <= n; k++)
P_row[k] = P_col[k] = Q_row[k] = Q_col[k] = k;
/* the rank of A and V is not determined yet */
lux->rank = -1;
/* initially the entire matrix V is active */
/* determine its row lengths */
for (i = 1; i <= n; i++)
{ len = 0;
for (vij = V_row[i]; vij != NULL; vij = vij->r_next) len++;
R_len[i] = len;
}
/* build linked lists of active rows */
for (len = 0; len <= n; len++) R_head[len] = 0;
for (i = 1; i <= n; i++)
{ len = R_len[i];
R_prev[i] = 0;
R_next[i] = R_head[len];
if (R_next[i] != 0) R_prev[R_next[i]] = i;
R_head[len] = i;
}
/* determine its column lengths */
for (j = 1; j <= n; j++)
{ len = 0;
for (vij = V_col[j]; vij != NULL; vij = vij->c_next) len++;
C_len[j] = len;
}
/* build linked lists of active columns */
for (len = 0; len <= n; len++) C_head[len] = 0;
for (j = 1; j <= n; j++)
{ len = C_len[j];
C_prev[j] = 0;
C_next[j] = C_head[len];
if (C_next[j] != 0) C_prev[C_next[j]] = j;
C_head[len] = j;
}
return;
}
