void ipp_remove_col(IPP *ipp, IPPCOL *col)
{ IPPAIJ *aij;
/* remove the column from the active queue */
ipp_deque_col(ipp, col);
/* remove elements of the column from the constraint matrix */
while (col->ptr != NULL)
{ /* get a next element in the column */
aij = col->ptr;
/* remove the element from the column list */
col->ptr = aij->c_next;
/* remove the element from the row list */
if (aij->r_prev == NULL)
aij->row->ptr = aij->r_next;
else
aij->r_prev->r_next = aij->r_next;
if (aij->r_next == NULL)
;
else
aij->r_next->r_prev = aij->r_prev;
/* and return it to its pool */
dmp_free_atom(ipp->aij_pool, aij, sizeof(IPPAIJ));
}
/* remove the column from the linked list */
if (col->prev == NULL)
ipp->col_ptr = col->next;
else
col->prev->next = col->next;
if (col->next == NULL)
;
else
col->next->prev = col->prev;
/* and return the column to its pool */
dmp_free_atom(ipp->col_pool, col, sizeof(IPPCOL));
return;
}
void glp_del_arc(glp_graph *G, glp_arc *a)
{ /* some sanity checks */
xassert(G->na > 0);
xassert(1 <= a->tail->i && a->tail->i <= G->nv);
xassert(a->tail == G->v[a->tail->i]);
xassert(1 <= a->head->i && a->head->i <= G->nv);
xassert(a->head == G->v[a->head->i]);
/* remove the arc from the list of incoming arcs */
if (a->h_prev == NULL)
a->head->in = a->h_next;
else
a->h_prev->h_next = a->h_next;
if (a->h_next == NULL)
;
else
a->h_next->h_prev = a->h_prev;
/* remove the arc from the list of outgoing arcs */
if (a->t_prev == NULL)
a->tail->out = a->t_next;
else
a->t_prev->t_next = a->t_next;
if (a->t_next == NULL)
;
else
a->t_next->t_prev = a->t_prev;
/* free arc data, if allocated */
if (a->data != NULL)
dmp_free_atom(G->pool, a->data, G->a_size);
/* delete the arc from the graph */
dmp_free_atom(G->pool, a, sizeof(glp_arc));
G->na--;
return;
}
void ipp_remove_row(IPP *ipp, IPPROW *row)
{ IPPAIJ *aij;
/* remove the row from the active queue */
ipp_deque_row(ipp, row);
/* remove elements of the row from the constraint matrix */
while (row->ptr != NULL)
{ /* get a next element in the row */
aij = row->ptr;
/* remove the element from the row list */
row->ptr = aij->r_next;
/* remove the element from the column list */
if (aij->c_prev == NULL)
aij->col->ptr = aij->c_next;
else
aij->c_prev->c_next = aij->c_next;
if (aij->c_next == NULL)
;
else
aij->c_next->c_prev = aij->c_prev;
/* and return it to its pool */
dmp_free_atom(ipp->aij_pool, aij, sizeof(IPPAIJ));
}
/* remove the row from the linked list */
if (row->prev == NULL)
ipp->row_ptr = row->next;
else
row->prev->next = row->next;
if (row->next == NULL)
;
else
row->next->prev = row->prev;
/* and return the row to its pool */
dmp_free_atom(ipp->row_pool, row, sizeof(IPPROW));
return;
}
void npp_del_row(NPP *npp, NPPROW *row)
{ /* remove row from the current problem */
#if 0 /* 23/XII-2009 */
NPPAIJ *aij;
#endif
if (row->name != NULL)
dmp_free_atom(npp->pool, row->name, strlen(row->name)+1);
#if 0 /* 23/XII-2009 */
while (row->ptr != NULL)
{ aij = row->ptr;
row->ptr = aij->r_next;
if (aij->c_prev == NULL)
aij->col->ptr = aij->c_next;
else
aij->c_prev->c_next = aij->c_next;
if (aij->c_next == NULL)
;
else
aij->c_next->c_prev = aij->c_prev;
dmp_free_atom(npp->pool, aij, sizeof(NPPAIJ));
}
#else
npp_erase_row(npp, row);
#endif
npp_remove_row(npp, row);
dmp_free_atom(npp->pool, row, sizeof(NPPROW));
return;
}
void glp_del_vertices(glp_graph *G, int ndel, const int num[])
{ glp_vertex *v;
int i, k, nv_new;
/* scan the list of vertices to be deleted */
if (!(1 <= ndel && ndel <= G->nv))
xerror("glp_del_vertices: ndel = %d; invalid number of vertice"
"s\n", ndel);
for (k = 1; k <= ndel; k++)
{ /* take the number of vertex to be deleted */
i = num[k];
/* obtain pointer to i-th vertex */
if (!(1 <= i && i <= G->nv))
xerror("glp_del_vertices: num[%d] = %d; vertex number out o"
"f range\n", k, i);
v = G->v[i];
/* check that the vertex is not marked yet */
if (v->i == 0)
xerror("glp_del_vertices: num[%d] = %d; duplicate vertex nu"
"mbers not allowed\n", k, i);
/* erase symbolic name assigned to the vertex */
glp_set_vertex_name(G, i, NULL);
xassert(v->name == NULL);
xassert(v->entry == NULL);
/* free vertex data, if allocated */
if (v->data != NULL)
dmp_free_atom(G->pool, v->data, G->v_size);
/* delete all incoming arcs */
while (v->in != NULL)
glp_del_arc(G, v->in);
/* delete all outgoing arcs */
while (v->out != NULL)
glp_del_arc(G, v->out);
/* mark the vertex to be deleted */
v->i = 0;
}
/* delete all marked vertices from the vertex list */
nv_new = 0;
for (i = 1; i <= G->nv; i++)
{ /* obtain pointer to i-th vertex */
v = G->v[i];
/* check if the vertex is marked */
if (v->i == 0)
{ /* it is marked, delete it */
dmp_free_atom(G->pool, v, sizeof(glp_vertex));
}
else
{ /* it is not marked, keep it */
v->i = ++nv_new;
G->v[v->i] = v;
}
}
/* set new number of vertices in the graph */
G->nv = nv_new;
return;
}
int spm_drop_zeros(SPM *A, double eps)
{ SPME *e, *next;
int i, count = 0;
for (i = 1; i <= A->m; i++)
{ for (e = A->row[i]; e != NULL; e = next)
{ next = e->r_next;
if (e->val == 0.0 || fabs(e->val) < eps)
{ /* remove element from the row list */
if (e->r_prev == NULL)
A->row[e->i] = e->r_next;
else
e->r_prev->r_next = e->r_next;
if (e->r_next == NULL)
;
else
e->r_next->r_prev = e->r_prev;
/* remove element from the column list */
if (e->c_prev == NULL)
A->col[e->j] = e->c_next;
else
e->c_prev->c_next = e->c_next;
if (e->c_next == NULL)
;
else
e->c_next->c_prev = e->c_prev;
/* return element to the memory pool */
dmp_free_atom(A->pool, e, sizeof(SPME));
count++;
}
}
}
return count;
}
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;
}
static void drop_form(NPP *npp, struct elem *ptr)
{ /* drop linear form */
struct elem *e;
while (ptr != NULL)
{ e = ptr;
ptr = e->next;
dmp_free_atom(npp->pool, e, sizeof(struct elem));
}
return;
}
void glp_del_rows(glp_prob *lp, int nrs, const int num[])
{ glp_tree *tree = lp->tree;
GLPROW *row;
int i, k, m_new;
/* mark rows to be deleted */
if (!(1 <= nrs && nrs <= lp->m))
xerror("glp_del_rows: nrs = %d; invalid number of rows\n",
nrs);
for (k = 1; k <= nrs; k++)
{ /* take the number of row to be deleted */
i = num[k];
/* obtain pointer to i-th row */
if (!(1 <= i && i <= lp->m))
xerror("glp_del_rows: num[%d] = %d; row number out of range"
"\n", k, i);
row = lp->row[i];
if (tree != NULL && tree->reason != 0)
{ xassert(tree->curr != NULL);
xassert(row->level == tree->curr->level);
}
/* check that the row is not marked yet */
if (row->i == 0)
xerror("glp_del_rows: num[%d] = %d; duplicate row numbers n"
"ot allowed\n", k, i);
/* erase symbolic name assigned to the row */
glp_set_row_name(lp, i, NULL);
xassert(row->node == NULL);
/* erase corresponding row of the constraint matrix */
glp_set_mat_row(lp, i, 0, NULL, NULL);
xassert(row->ptr == NULL);
/* mark the row to be deleted */
row->i = 0;
}
/* delete all marked rows from the row list */
m_new = 0;
for (i = 1; i <= lp->m; i++)
{ /* obtain pointer to i-th row */
row = lp->row[i];
/* check if the row is marked */
if (row->i == 0)
{ /* it is marked, delete it */
dmp_free_atom(lp->pool, row, sizeof(GLPROW));
}
else
{ /* it is not marked; keep it */
row->i = ++m_new;
lp->row[row->i] = row;
}
}
/* set new number of rows */
lp->m = m_new;
/* invalidate the basis factorization */
lp->valid = 0;
return;
}
void delete_slice
( MPL *mpl,
SLICE *slice /* destroyed */
)
{ SLICE *temp;
while (slice != NULL)
{ temp = slice;
slice = temp->next;
if (temp->sym != NULL) delete_symbol(mpl, temp->sym);
dmp_free_atom(mpl->tuples, temp);
}
return;
}
void npp_del_col(NPP *npp, NPPCOL *col)
{ /* remove column from the current problem */
NPPAIJ *aij;
if (col->name != NULL)
dmp_free_atom(npp->pool, col->name, strlen(col->name)+1);
while (col->ptr != NULL)
{ aij = col->ptr;
col->ptr = aij->c_next;
if (aij->r_prev == NULL)
aij->row->ptr = aij->r_next;
else
aij->r_prev->r_next = aij->r_next;
if (aij->r_next == NULL)
;
else
aij->r_next->r_prev = aij->r_prev;
dmp_free_atom(npp->pool, aij, sizeof(NPPAIJ));
}
npp_remove_col(npp, col);
dmp_free_atom(npp->pool, col, sizeof(NPPCOL));
return;
}
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;
}
void lpp_remove_col(LPP *lpp, LPPCOL *col)
{ LPPAIJ *aij;
/* remove the column from the active queue */
lpp_deque_col(lpp, col);
/* remove elements of the column from the constraint matrix */
while (col->ptr != NULL)
{ /* get a next element in the column */
aij = col->ptr;
/* activate the corresponding row */
lpp_enque_row(lpp, aij->row);
/* remove the element from the column list */
col->ptr = aij->c_next;
/* remove the element from the row list */
if (aij->r_prev == NULL)
aij->row->ptr = aij->r_next;
else
aij->r_prev->r_next = aij->r_next;
if (aij->r_next == NULL)
;
else
aij->r_next->r_prev = aij->r_prev;
/* and return it to its pool */
dmp_free_atom(lpp->aij_pool, aij);
}
/* remove the column from the linked list */
if (col->prev == NULL)
lpp->col_ptr = col->next;
else
col->prev->next = col->next;
if (col->next == NULL)
;
else
col->next->prev = col->prev;
/* and return the column to its pool */
dmp_free_atom(lpp->col_pool, col);
return;
}
/* move the column to the end of the column list */
npp_remove_col(npp, col);
npp_insert_col(npp, col, 1);
}
return;
}
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;
}
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;
}
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;
}
int npp_row_nnz(NPP *npp, NPPROW *row)
{ /* count number of non-zero coefficients in row */
NPPAIJ *aij;
int nnz;
xassert(npp == npp);
nnz = 0;
for (aij = row->ptr; aij != NULL; aij = aij->r_next)
nnz++;
return nnz;
}
int npp_col_nnz(NPP *npp, NPPCOL *col)
{ /* count number of non-zero coefficients in column */
NPPAIJ *aij;
int nnz;
xassert(npp == npp);
nnz = 0;
for (aij = col->ptr; aij != NULL; aij = aij->c_next)
nnz++;
return nnz;
}
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;
}
#if 1 /* 23/XII-2009 */
void npp_erase_row(NPP *npp, NPPROW *row)
{ /* erase row content to make it empty */
NPPAIJ *aij;
while (row->ptr != NULL)
{ aij = row->ptr;
row->ptr = aij->r_next;
if (aij->c_prev == NULL)
aij->col->ptr = aij->c_next;
else
aij->c_prev->c_next = aij->c_next;
if (aij->c_next == NULL)
;
else
aij->c_next->c_prev = aij->c_prev;
dmp_free_atom(npp->pool, aij, sizeof(NPPAIJ));
}
return;
}
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;
}
void npp_del_aij(NPP *npp, NPPAIJ *aij)
{ /* remove element from the constraint matrix */
if (aij->r_prev == NULL)
aij->row->ptr = aij->r_next;
else
aij->r_prev->r_next = aij->r_next;
if (aij->r_next == NULL)
;
else
aij->r_next->r_prev = aij->r_prev;
if (aij->c_prev == NULL)
aij->col->ptr = aij->c_next;
else
aij->c_prev->c_next = aij->c_next;
if (aij->c_next == NULL)
;
else
aij->c_next->c_prev = aij->c_prev;
dmp_free_atom(npp->pool, aij, sizeof(NPPAIJ));
return;
}
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;
}
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 eliminate(LUX *lux, LUXWKA *wka, LUXELM *piv, int flag[],
mpq_t work[])
{ 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 *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 *fip, *vij, *vpj, *viq, *next;
mpq_t temp;
int i, j, p, q;
mpq_init(temp);
/* determine row and column indices of the pivot v[p,q] */
xassert(piv != NULL);
p = piv->i, q = piv->j;
/* remove p-th (pivot) row from the active set; it will never
return there */
if (R_prev[p] == 0)
R_head[R_len[p]] = R_next[p];
else
R_next[R_prev[p]] = R_next[p];
if (R_next[p] == 0)
;
else
R_prev[R_next[p]] = R_prev[p];
/* remove q-th (pivot) column from the active set; it will never
return there */
if (C_prev[q] == 0)
C_head[C_len[q]] = C_next[q];
else
C_next[C_prev[q]] = C_next[q];
if (C_next[q] == 0)
;
else
C_prev[C_next[q]] = C_prev[q];
/* store the pivot value in a separate array */
mpq_set(V_piv[p], piv->val);
/* remove the pivot from p-th row */
if (piv->r_prev == NULL)
V_row[p] = piv->r_next;
else
piv->r_prev->r_next = piv->r_next;
if (piv->r_next == NULL)
;
else
piv->r_next->r_prev = piv->r_prev;
R_len[p]--;
/* remove the pivot from q-th column */
if (piv->c_prev == NULL)
V_col[q] = piv->c_next;
else
piv->c_prev->c_next = piv->c_next;
if (piv->c_next == NULL)
;
else
piv->c_next->c_prev = piv->c_prev;
C_len[q]--;
/* free the space occupied by the pivot */
mpq_clear(piv->val);
dmp_free_atom(pool, piv, sizeof(LUXELM));
/* walk through p-th (pivot) row, which already does not contain
the pivot v[p,q], and do the following... */
for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
{ /* get column index of v[p,j] */
j = vpj->j;
/* store v[p,j] in the working array */
flag[j] = 1;
mpq_set(work[j], vpj->val);
/* remove j-th column from the active set; it will return there
later with a new length */
if (C_prev[j] == 0)
C_head[C_len[j]] = C_next[j];
else
C_next[C_prev[j]] = C_next[j];
if (C_next[j] == 0)
;
else
C_prev[C_next[j]] = C_prev[j];
/* v[p,j] leaves the active submatrix, so remove it from j-th
column; however, v[p,j] is kept in p-th row */
if (vpj->c_prev == NULL)
V_col[j] = vpj->c_next;
else
vpj->c_prev->c_next = vpj->c_next;
if (vpj->c_next == NULL)
;
else
vpj->c_next->c_prev = vpj->c_prev;
C_len[j]--;
}
/* now walk through q-th (pivot) column, which already does not
contain the pivot v[p,q], and perform gaussian elimination */
while (V_col[q] != NULL)
{ /* element v[i,q] has to be eliminated */
viq = V_col[q];
/* get row index of v[i,q] */
i = viq->i;
/* remove i-th row from the active set; later it will return
there with a new length */
if (R_prev[i] == 0)
R_head[R_len[i]] = R_next[i];
else
R_next[R_prev[i]] = R_next[i];
if (R_next[i] == 0)
;
else
R_prev[R_next[i]] = R_prev[i];
/* compute gaussian multiplier f[i,p] = v[i,q] / v[p,q] and
store it in the matrix F */
fip = dmp_get_atom(pool, sizeof(LUXELM));
fip->i = i, fip->j = p;
mpq_init(fip->val);
mpq_div(fip->val, viq->val, V_piv[p]);
fip->r_prev = NULL;
fip->r_next = F_row[i];
fip->c_prev = NULL;
fip->c_next = F_col[p];
if (fip->r_next != NULL) fip->r_next->r_prev = fip;
if (fip->c_next != NULL) fip->c_next->c_prev = fip;
F_row[i] = F_col[p] = fip;
/* v[i,q] has to be eliminated, so remove it from i-th row */
if (viq->r_prev == NULL)
V_row[i] = viq->r_next;
else
viq->r_prev->r_next = viq->r_next;
if (viq->r_next == NULL)
;
else
viq->r_next->r_prev = viq->r_prev;
R_len[i]--;
/* and also from q-th column */
V_col[q] = viq->c_next;
C_len[q]--;
/* free the space occupied by v[i,q] */
mpq_clear(viq->val);
dmp_free_atom(pool, viq, sizeof(LUXELM));
/* perform gaussian transformation:
(i-th row) := (i-th row) - f[i,p] * (p-th row)
note that now p-th row, which is in the working array,
does not contain the pivot v[p,q], and i-th row does not
contain the element v[i,q] to be eliminated */
/* walk through i-th row and transform existing non-zero
elements */
for (vij = V_row[i]; vij != NULL; vij = next)
{ next = vij->r_next;
/* get column index of v[i,j] */
j = vij->j;
/* v[i,j] := v[i,j] - f[i,p] * v[p,j] */
if (flag[j])
{ /* v[p,j] != 0 */
flag[j] = 0;
mpq_mul(temp, fip->val, work[j]);
mpq_sub(vij->val, vij->val, temp);
if (mpq_sgn(vij->val) == 0)
{ /* new v[i,j] is zero, so remove it from the active
submatrix */
/* remove v[i,j] from i-th row */
if (vij->r_prev == NULL)
V_row[i] = vij->r_next;
else
vij->r_prev->r_next = vij->r_next;
if (vij->r_next == NULL)
;
else
vij->r_next->r_prev = vij->r_prev;
R_len[i]--;
/* remove v[i,j] from j-th column */
if (vij->c_prev == NULL)
V_col[j] = vij->c_next;
else
vij->c_prev->c_next = vij->c_next;
if (vij->c_next == NULL)
;
else
vij->c_next->c_prev = vij->c_prev;
C_len[j]--;
/* free the space occupied by v[i,j] */
mpq_clear(vij->val);
dmp_free_atom(pool, vij, sizeof(LUXELM));
}
}
}
/* now flag is the pattern of the set v[p,*] \ v[i,*] */
/* walk through p-th (pivot) row and create new elements in
i-th row, which appear due to fill-in */
for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
{ j = vpj->j;
if (flag[j])
{ /* create new non-zero v[i,j] = 0 - f[i,p] * v[p,j] and
add it to i-th row and j-th column */
vij = dmp_get_atom(pool, sizeof(LUXELM));
vij->i = i, vij->j = j;
mpq_init(vij->val);
mpq_mul(vij->val, fip->val, work[j]);
mpq_neg(vij->val, vij->val);
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;
R_len[i]++, C_len[j]++;
}
else
{ /* there is no fill-in, because v[i,j] already exists in
i-th row; restore the flag, which was reset before */
flag[j] = 1;
}
}
/* now i-th row has been completely transformed and can return
to the active set with a new length */
R_prev[i] = 0;
R_next[i] = R_head[R_len[i]];
if (R_next[i] != 0) R_prev[R_next[i]] = i;
R_head[R_len[i]] = i;
}
/* at this point q-th (pivot) column must be empty */
xassert(C_len[q] == 0);
/* walk through p-th (pivot) row again and do the following... */
for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
{ /* get column index of v[p,j] */
j = vpj->j;
/* erase v[p,j] from the working array */
flag[j] = 0;
mpq_set_si(work[j], 0, 1);
/* now j-th column has been completely transformed, so it can
return to the active list with a new length */
C_prev[j] = 0;
C_next[j] = C_head[C_len[j]];
if (C_next[j] != 0) C_prev[C_next[j]] = j;
C_head[C_len[j]] = j;
}
mpq_clear(temp);
/* return to the factorizing routine */
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;
}
void glp_load_matrix(glp_prob *lp, int ne, const int ia[],
const int ja[], const double ar[])
{ glp_tree *tree = lp->tree;
GLPROW *row;
GLPCOL *col;
GLPAIJ *aij, *next;
int i, j, k;
if (tree != NULL && tree->reason != 0)
xerror("glp_load_matrix: operation not allowed\n");
/* clear the constraint matrix */
for (i = 1; i <= lp->m; i++)
{ row = lp->row[i];
while (row->ptr != NULL)
{ aij = row->ptr;
row->ptr = aij->r_next;
dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
}
}
xassert(lp->nnz == 0);
for (j = 1; j <= lp->n; j++) lp->col[j]->ptr = NULL;
/* load the new contents of the constraint matrix and build its
row lists */
if (ne < 0)
xerror("glp_load_matrix: ne = %d; invalid number of constraint"
" coefficients\n", ne);
if (ne > NNZ_MAX)
xerror("glp_load_matrix: ne = %d; too many constraint coeffici"
"ents\n", ne);
for (k = 1; k <= ne; k++)
{ /* take indices of new element */
i = ia[k], j = ja[k];
/* obtain pointer to i-th row */
if (!(1 <= i && i <= lp->m))
xerror("glp_load_matrix: ia[%d] = %d; row index out of rang"
"e\n", k, i);
row = lp->row[i];
/* obtain pointer to j-th column */
if (!(1 <= j && j <= lp->n))
xerror("glp_load_matrix: ja[%d] = %d; column index out of r"
"ange\n", k, j);
col = lp->col[j];
/* create new element */
aij = dmp_get_atom(lp->pool, sizeof(GLPAIJ)), lp->nnz++;
aij->row = row;
aij->col = col;
aij->val = ar[k];
/* add the new element to the beginning of i-th row list */
aij->r_prev = NULL;
aij->r_next = row->ptr;
if (aij->r_next != NULL) aij->r_next->r_prev = aij;
row->ptr = aij;
}
xassert(lp->nnz == ne);
/* build column lists of the constraint matrix and check elements
with identical indices */
for (i = 1; i <= lp->m; i++)
{ for (aij = lp->row[i]->ptr; aij != NULL; aij = aij->r_next)
{ /* obtain pointer to corresponding column */
col = aij->col;
/* if there is element with identical indices, it can only
be found in the beginning of j-th column list */
if (col->ptr != NULL && col->ptr->row->i == i)
{ for (k = 1; k <= ne; k++)
if (ia[k] == i && ja[k] == col->j) break;
xerror("glp_load_mat: ia[%d] = %d; ja[%d] = %d; duplicat"
"e indices not allowed\n", k, i, k, col->j);
}
/* add the element to the beginning of j-th column list */
aij->c_prev = NULL;
aij->c_next = col->ptr;
if (aij->c_next != NULL) aij->c_next->c_prev = aij;
col->ptr = aij;
}
}
/* remove zero elements from the constraint matrix */
for (i = 1; i <= lp->m; i++)
{ row = lp->row[i];
for (aij = row->ptr; aij != NULL; aij = next)
{ next = aij->r_next;
if (aij->val == 0.0)
{ /* remove the element from the row list */
if (aij->r_prev == NULL)
row->ptr = next;
else
aij->r_prev->r_next = next;
if (next == NULL)
;
else
next->r_prev = aij->r_prev;
/* remove the element from the column list */
if (aij->c_prev == NULL)
aij->col->ptr = aij->c_next;
else
aij->c_prev->c_next = aij->c_next;
if (aij->c_next == NULL)
;
else
aij->c_next->c_prev = aij->c_prev;
/* return the element to the memory pool */
dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
}
}
}
/* invalidate the basis factorization */
lp->valid = 0;
return;
}
void glp_set_mat_col(glp_prob *lp, int j, int len, const int ind[],
const double val[])
{ glp_tree *tree = lp->tree;
GLPROW *row;
GLPCOL *col;
GLPAIJ *aij, *next;
int i, k;
if (tree != NULL && tree->reason != 0)
xerror("glp_set_mat_col: operation not allowed\n");
/* obtain pointer to j-th column */
if (!(1 <= j && j <= lp->n))
xerror("glp_set_mat_col: j = %d; column number out of range\n",
j);
col = lp->col[j];
/* remove all existing elements from j-th column */
while (col->ptr != NULL)
{ /* take next element in the column */
aij = col->ptr;
/* remove the element from the column list */
col->ptr = aij->c_next;
/* obtain pointer to corresponding row */
row = aij->row;
/* remove the element from the row list */
if (aij->r_prev == NULL)
row->ptr = aij->r_next;
else
aij->r_prev->r_next = aij->r_next;
if (aij->r_next == NULL)
;
else
aij->r_next->r_prev = aij->r_prev;
/* return the element to the memory pool */
dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
}
/* store new contents of j-th column */
if (!(0 <= len && len <= lp->m))
xerror("glp_set_mat_col: j = %d; len = %d; invalid column leng"
"th\n", j, len);
if (len > NNZ_MAX - lp->nnz)
xerror("glp_set_mat_col: j = %d; len = %d; too many constraint"
" coefficients\n", j, len);
for (k = 1; k <= len; k++)
{ /* take number i of corresponding row */
i = ind[k];
/* obtain pointer to i-th row */
if (!(1 <= i && i <= lp->m))
xerror("glp_set_mat_col: j = %d; ind[%d] = %d; row index ou"
"t of range\n", j, k, i);
row = lp->row[i];
/* if there is element with the same row index, it can only be
found in the beginning of i-th row list */
if (row->ptr != NULL && row->ptr->col->j == j)
xerror("glp_set_mat_col: j = %d; ind[%d] = %d; duplicate ro"
"w indices not allowed\n", j, k, i);
/* create new element */
aij = dmp_get_atom(lp->pool, sizeof(GLPAIJ)), lp->nnz++;
aij->row = row;
aij->col = col;
aij->val = val[k];
/* add the new element to the beginning of i-th row and j-th
column lists */
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;
}
/* remove zero elements from j-th column */
for (aij = col->ptr; aij != NULL; aij = next)
{ next = aij->c_next;
if (aij->val == 0.0)
{ /* remove the element from the row list */
xassert(aij->r_prev == NULL);
aij->row->ptr = aij->r_next;
if (aij->r_next != NULL) aij->r_next->r_prev = NULL;
/* remove the element from the column list */
if (aij->c_prev == NULL)
col->ptr = next;
else
aij->c_prev->c_next = next;
if (next == NULL)
;
else
next->c_prev = aij->c_prev;
/* return the element to the memory pool */
dmp_free_atom(lp->pool, aij, sizeof(GLPAIJ)), lp->nnz--;
}
}
/* if j-th column is basic, invalidate the basis factorization */
if (col->stat == GLP_BS) lp->valid = 0;
return;
}
void avl_delete_node(AVL *tree, AVLNODE *node)
{ /* delete specified node from AVL tree */
AVLNODE *f, *p, *q, *r, *s, *x, *y;
short int flag;
p = node;
/* if both subtrees of the specified node are non-empty, the node
should be interchanged with the next one, at least one subtree
of which is always empty */
if (p->left == NULL || p->right == NULL) goto skip;
f = p->up; q = p->left;
r = find_next_node(tree, p); s = r->right;
if (p->right == r)
{ if (f == NULL)
tree->root = r;
else
if (p->flag == 0) f->left = r; else f->right = r;
r->rank = p->rank; r->up = f;
r->flag = p->flag; r->bal = p->bal;
r->left = q; r->right = p;
q->up = r;
p->rank = 1; p->up = r; p->flag = 1;
p->bal = (short int)(s == NULL ? 0 : +1);
p->left = NULL; p->right = s;
if (s != NULL) s->up = p;
}
else
{ x = p->right; y = r->up;
if (f == NULL)
tree->root = r;
else
if (p->flag == 0) f->left = r; else f->right = r;
r->rank = p->rank; r->up = f;
r->flag = p->flag; r->bal = p->bal;
r->left = q; r->right = x;
q->up = r; x->up = r; y->left = p;
p->rank = 1; p->up = y; p->flag = 0;
p->bal = (short int)(s == NULL ? 0 : +1);
p->left = NULL; p->right = s;
if (s != NULL) s->up = p;
}
skip: /* now the specified node [p] has at least one empty subtree;
go upstairs to the root and adjust the rank field of all nodes
affected by deletion */
q = p; f = q->up;
while (f != NULL)
{ if (q->flag == 0) f->rank--;
q = f; f = q->up;
}
/* delete the specified node from the tree */
f = p->up; flag = p->flag;
q = p->left != NULL ? p->left : p->right;
if (f == NULL)
tree->root = q;
else
if (flag == 0) f->left = q; else f->right = q;
if (q != NULL) q->up = f, q->flag = flag;
tree->size--;
/* go upstairs to the root and correct all subtrees affected by
deletion */
while (f != NULL)
{ if (flag == 0)
{ /* the height of the left subtree of [f] is decreased */
if (f->bal == 0)
{ f->bal = +1;
break;
}
if (f->bal < 0)
f->bal = 0;
else
{ f = rotate_subtree(tree, f);
if (f->bal < 0) break;
}
flag = f->flag; f = f->up;
}
else
{ /* the height of the right subtree of [f] is decreased */
if (f->bal == 0)
{ f->bal = -1;
break;
}
if (f->bal > 0)
f->bal = 0;
else
{ f = rotate_subtree(tree, f);
if (f->bal > 0) break;
}
flag = f->flag; f = f->up;
}
}
/* if the root has been reached, the height of the entire tree is
decreased */
if (f == NULL) tree->height--;
/* returns the deleted node to the memory pool */
dmp_free_atom(tree->pool, p, sizeof(AVLNODE));
return;
}
void gmp_free_atom(void *ptr, int size)
{ xassert(gmp_pool != NULL);
dmp_free_atom(gmp_pool, ptr, size);
return;
}
void glp_del_cols(glp_prob *lp, int ncs, const int num[])
{ glp_tree *tree = lp->tree;
GLPCOL *col;
int j, k, n_new;
if (tree != NULL && tree->reason != 0)
xerror("glp_del_cols: operation not allowed\n");
/* mark columns to be deleted */
if (!(1 <= ncs && ncs <= lp->n))
xerror("glp_del_cols: ncs = %d; invalid number of columns\n",
ncs);
for (k = 1; k <= ncs; k++)
{ /* take the number of column to be deleted */
j = num[k];
/* obtain pointer to j-th column */
if (!(1 <= j && j <= lp->n))
xerror("glp_del_cols: num[%d] = %d; column number out of ra"
"nge", k, j);
col = lp->col[j];
/* check that the column is not marked yet */
if (col->j == 0)
xerror("glp_del_cols: num[%d] = %d; duplicate column number"
"s not allowed\n", k, j);
/* erase symbolic name assigned to the column */
glp_set_col_name(lp, j, NULL);
xassert(col->node == NULL);
/* erase corresponding column of the constraint matrix */
glp_set_mat_col(lp, j, 0, NULL, NULL);
xassert(col->ptr == NULL);
/* mark the column to be deleted */
col->j = 0;
/* if it is basic, invalidate the basis factorization */
if (col->stat == GLP_BS) lp->valid = 0;
}
/* delete all marked columns from the column list */
n_new = 0;
for (j = 1; j <= lp->n; j++)
{ /* obtain pointer to j-th column */
col = lp->col[j];
/* check if the column is marked */
if (col->j == 0)
{ /* it is marked; delete it */
dmp_free_atom(lp->pool, col, sizeof(GLPCOL));
}
else
{ /* it is not marked; keep it */
col->j = ++n_new;
lp->col[col->j] = col;
}
}
/* set new number of columns */
lp->n = n_new;
/* if the basis header is still valid, adjust it */
if (lp->valid)
{ int m = lp->m;
int *head = lp->head;
for (j = 1; j <= n_new; j++)
{ k = lp->col[j]->bind;
if (k != 0)
{ xassert(1 <= k && k <= m);
head[k] = m + j;
}
}
}
return;
}
