void npp_delete_wksp(NPP *npp) { /* delete LP/MIP preprocessor workspace */ if (npp->pool != NULL) dmp_delete_pool(npp->pool); if (npp->stack != NULL) dmp_delete_pool(npp->stack); if (npp->row_ref != NULL) xfree(npp->row_ref); if (npp->col_ref != NULL) xfree(npp->col_ref); if (npp->r_stat != NULL) xfree(npp->r_stat); #if 0 if (npp->r_prim != NULL) xfree(npp->r_prim); #endif if (npp->r_pi != NULL) xfree(npp->r_pi); if (npp->c_stat != NULL) xfree(npp->c_stat); if (npp->c_value != NULL) xfree(npp->c_value); #if 0 if (npp->c_dual != NULL) xfree(npp->c_dual); #endif xfree(npp); return; }
void ipp_delete_wksp(IPP *ipp) { if (ipp->row_pool != NULL) dmp_delete_pool(ipp->row_pool); if (ipp->col_pool != NULL) dmp_delete_pool(ipp->col_pool); if (ipp->aij_pool != NULL) dmp_delete_pool(ipp->aij_pool); if (ipp->tqe_pool != NULL) dmp_delete_pool(ipp->tqe_pool); if (ipp->col_stat != NULL) xfree(ipp->col_stat); if (ipp->col_mipx != NULL) xfree(ipp->col_mipx); xfree(ipp); return; }
void mpl_terminate(MPL *mpl) { if (setjmp(mpl->jump)) xassert(mpl != mpl); switch (mpl->phase) { case 0: case 1: case 2: case 3: /* there were no errors; clean the model content */ clean_model(mpl); xassert(mpl->a_list == NULL); #if 1 /* 11/II-2008 */ xassert(mpl->dca == NULL); #endif break; case 4: /* model processing has been finished due to error; delete search trees, which may be created for some arrays */ { ARRAY *a; for (a = mpl->a_list; a != NULL; a = a->next) if (a->tree != NULL) avl_delete_tree(a->tree); } #if 1 /* 11/II-2008 */ free_dca(mpl); #endif break; default: xassert(mpl != mpl); } /* delete the translator database */ xfree(mpl->image); xfree(mpl->b_image); xfree(mpl->f_image); xfree(mpl->context); dmp_delete_pool(mpl->pool); avl_delete_tree(mpl->tree); dmp_delete_pool(mpl->strings); dmp_delete_pool(mpl->symbols); dmp_delete_pool(mpl->tuples); dmp_delete_pool(mpl->arrays); dmp_delete_pool(mpl->members); dmp_delete_pool(mpl->elemvars); dmp_delete_pool(mpl->formulae); dmp_delete_pool(mpl->elemcons); xfree(mpl->sym_buf); xfree(mpl->tup_buf); rng_delete_rand(mpl->rand); if (mpl->row != NULL) xfree(mpl->row); if (mpl->col != NULL) xfree(mpl->col); if (mpl->in_fp != NULL) xfclose(mpl->in_fp); if (mpl->out_fp != NULL && mpl->out_fp != (void *)stdout) xfclose(mpl->out_fp); if (mpl->out_file != NULL) xfree(mpl->out_file); if (mpl->prt_fp != NULL) xfclose(mpl->prt_fp); if (mpl->prt_file != NULL) xfree(mpl->prt_file); if (mpl->mod_file != NULL) xfree(mpl->mod_file); xfree(mpl->mpl_buf); xfree(mpl); return; }
void lpp_delete_wksp(LPP *lpp) { if (lpp->row_pool != NULL) dmp_delete_pool(lpp->row_pool); if (lpp->col_pool != NULL) dmp_delete_pool(lpp->col_pool); if (lpp->aij_pool != NULL) dmp_delete_pool(lpp->aij_pool); if (lpp->tqe_pool != NULL) dmp_delete_pool(lpp->tqe_pool); if (lpp->row_ref != NULL) ufree(lpp->row_ref); if (lpp->col_ref != NULL) ufree(lpp->col_ref); if (lpp->row_stat != NULL) ufree(lpp->row_stat); if (lpp->row_prim != NULL) ufree(lpp->row_prim); if (lpp->row_dual != NULL) ufree(lpp->row_dual); if (lpp->col_stat != NULL) ufree(lpp->col_stat); if (lpp->col_prim != NULL) ufree(lpp->col_prim); if (lpp->col_dual != NULL) ufree(lpp->col_dual); ufree(lpp); return; }
void gmp_free_mem(void) { if (gmp_pool != NULL) dmp_delete_pool(gmp_pool); if (gmp_work != NULL) xfree(gmp_work); gmp_pool = NULL; gmp_size = 0; gmp_work = NULL; return; }
void spm_delete_mat(SPM *A) { /* delete sparse matrix */ if (A->pool != NULL) dmp_delete_pool(A->pool); if (A->row != NULL) xfree(A->row); if (A->col != NULL) xfree(A->col); xfree(A); return; }
void cfg_delete_graph(CFG *G) { tfree(G->pos); tfree(G->neg); dmp_delete_pool(G->pool); tfree(G->ref); tfree(G->vptr); tfree(G->cptr); tfree(G); return; }
void scg_delete_graph(SCG *g) { /* delete cliqued graph */ dmp_delete_pool(g->pool); xfree(g->i_ptr); xfree(g->j_ptr); xfree(g->c_ptr); xfree(g->v_ptr); xfree(g->flag); xfree(g); return; }
static void delete_prob(glp_prob *lp) { dmp_delete_pool(lp->pool); xfree(lp->cps); xassert(lp->tree == NULL); xfree(lp->row); xfree(lp->col); if (lp->r_tree != NULL) avl_delete_tree(lp->r_tree); if (lp->c_tree != NULL) avl_delete_tree(lp->c_tree); xfree(lp->head); if (lp->bfcp != NULL) xfree(lp->bfcp); if (lp->bfd != NULL) bfd_delete_it(lp->bfd); return; }
void lux_delete(LUX *lux) { int n = lux->n; LUXELM *fij, *vij; int i; for (i = 1; i <= n; i++) { for (fij = lux->F_row[i]; fij != NULL; fij = fij->r_next) mpq_clear(fij->val); mpq_clear(lux->V_piv[i]); for (vij = lux->V_row[i]; vij != NULL; vij = vij->r_next) mpq_clear(vij->val); } dmp_delete_pool(lux->pool); xfree(lux->F_row); xfree(lux->F_col); xfree(lux->V_piv); xfree(lux->V_row); xfree(lux->V_col); xfree(lux->P_row); xfree(lux->P_col); xfree(lux->Q_row); xfree(lux->Q_col); xfree(lux); return; }
LPX *lpp_build_prob(LPP *lpp) { LPX *prob; LPPROW *row; LPPCOL *col; struct load_info info; int i, j, typx; /* count number of rows and columns in the resultant problem */ lpp->m = lpp->n = 0; for (row = lpp->row_ptr; row != NULL; row = row->next) lpp->m++; for (col = lpp->col_ptr; col != NULL; col = col->next) lpp->n++; /* allocate two arrays to save reference numbers assigned to rows and columns of the resultant problem */ lpp->row_ref = ucalloc(1+lpp->m, sizeof(int)); lpp->col_ref = ucalloc(1+lpp->n, sizeof(int)); /* create LP problem object */ prob = lpx_create_prob(); /* the resultant problem should have the same optimization sense as the original problem */ lpx_set_obj_dir(prob, lpp->orig_dir); /* set the constant term of the objective function */ lpx_set_obj_c0(prob, lpp->orig_dir == LPX_MIN ? + lpp->c0 : - lpp->c0); /* create rows of the resultant problem */ insist(lpp->m > 0); lpx_add_rows(prob, lpp->m); for (i = 1, row = lpp->row_ptr; i <= lpp->m; i++, row = row->next) { insist(row != NULL); lpp->row_ref[i] = row->i; row->i = i; if (row->lb == -DBL_MAX && row->ub == +DBL_MAX) typx = LPX_FR; else if (row->ub == +DBL_MAX) typx = LPX_LO; else if (row->lb == -DBL_MAX) typx = LPX_UP; else if (row->lb != row->ub) typx = LPX_DB; else typx = LPX_FX; lpx_set_row_bnds(prob, i, typx, row->lb, row->ub); } insist(row == NULL); /* create columns of the resultant problem */ insist(lpp->n > 0); lpx_add_cols(prob, lpp->n); for (j = 1, col = lpp->col_ptr; j <= lpp->n; j++, col = col->next) { insist(col != NULL); lpp->col_ref[j] = col->j; col->j = j; if (col->lb == -DBL_MAX && col->ub == +DBL_MAX) typx = LPX_FR; else if (col->ub == +DBL_MAX) typx = LPX_LO; else if (col->lb == -DBL_MAX) typx = LPX_UP; else if (col->lb != col->ub) typx = LPX_DB; else typx = LPX_FX; lpx_set_col_bnds(prob, j, typx, col->lb, col->ub); lpx_set_col_coef(prob, j, lpp->orig_dir == LPX_MIN ? + col->c : - col->c); } insist(col == NULL); /* create the constraint matrix of the resultant problem */ info.lpp = lpp; info.row = NULL; info.aij = NULL; lpx_load_mat(prob, &info, next_aij); /* count number of non-zeros in the resultant problem */ lpp->nnz = lpx_get_num_nz(prob); /* internal data structures that represnts the resultant problem are no longer needed, so free them */ dmp_delete_pool(lpp->row_pool), lpp->row_pool = NULL; dmp_delete_pool(lpp->col_pool), lpp->col_pool = NULL; dmp_delete_pool(lpp->aij_pool), lpp->aij_pool = NULL; lpp->row_ptr = NULL, lpp->col_ptr = NULL; lpp->row_que = NULL, lpp->col_que = NULL; /* return a pointer to the built LP problem object */ return prob; }
void npp_build_prob(NPP *npp, glp_prob *prob) { /* build resultant (preprocessed) problem */ NPPROW *row; NPPCOL *col; NPPAIJ *aij; int i, j, type, len, *ind; double dir, *val; glp_erase_prob(prob); glp_set_prob_name(prob, npp->name); glp_set_obj_name(prob, npp->obj); glp_set_obj_dir(prob, npp->orig_dir); if (npp->orig_dir == GLP_MIN) dir = +1.0; else if (npp->orig_dir == GLP_MAX) dir = -1.0; else xassert(npp != npp); glp_set_obj_coef(prob, 0, dir * npp->c0); /* build rows */ for (row = npp->r_head; row != NULL; row = row->next) { row->temp = i = glp_add_rows(prob, 1); glp_set_row_name(prob, i, row->name); if (row->lb == -DBL_MAX && row->ub == +DBL_MAX) type = GLP_FR; else if (row->ub == +DBL_MAX) type = GLP_LO; else if (row->lb == -DBL_MAX) type = GLP_UP; else if (row->lb != row->ub) type = GLP_DB; else type = GLP_FX; glp_set_row_bnds(prob, i, type, row->lb, row->ub); } /* build columns and the constraint matrix */ ind = xcalloc(1+prob->m, sizeof(int)); val = xcalloc(1+prob->m, sizeof(double)); for (col = npp->c_head; col != NULL; col = col->next) { j = glp_add_cols(prob, 1); glp_set_col_name(prob, j, col->name); #if 0 glp_set_col_kind(prob, j, col->kind); #else glp_set_col_kind(prob, j, col->is_int ? GLP_IV : GLP_CV); #endif if (col->lb == -DBL_MAX && col->ub == +DBL_MAX) type = GLP_FR; else if (col->ub == +DBL_MAX) type = GLP_LO; else if (col->lb == -DBL_MAX) type = GLP_UP; else if (col->lb != col->ub) type = GLP_DB; else type = GLP_FX; glp_set_col_bnds(prob, j, type, col->lb, col->ub); glp_set_obj_coef(prob, j, dir * col->coef); len = 0; for (aij = col->ptr; aij != NULL; aij = aij->c_next) { len++; ind[len] = aij->row->temp; val[len] = aij->val; } glp_set_mat_col(prob, j, len, ind, val); } xfree(ind); xfree(val); /* resultant problem has been built */ npp->m = prob->m; npp->n = prob->n; npp->nnz = prob->nnz; npp->row_ref = xcalloc(1+npp->m, sizeof(int)); npp->col_ref = xcalloc(1+npp->n, sizeof(int)); for (row = npp->r_head, i = 0; row != NULL; row = row->next) npp->row_ref[++i] = row->i; for (col = npp->c_head, j = 0; col != NULL; col = col->next) npp->col_ref[++j] = col->j; /* transformed problem segment is no longer needed */ dmp_delete_pool(npp->pool), npp->pool = NULL; npp->name = npp->obj = NULL; npp->c0 = 0.0; npp->r_head = npp->r_tail = NULL; npp->c_head = npp->c_tail = NULL; return; }
static void delete_graph(glp_graph *G) { dmp_delete_pool(G->pool); xfree(G->v); if (G->index != NULL) avl_delete_tree(G->index); return; }
void avl_delete_tree(AVL *tree) { /* delete AVL tree */ dmp_delete_pool(tree->pool); xfree(tree); return; }