SparseMatrix_delete(polys);
SparseMatrix_delete(poly_lines);
SparseMatrix_delete(poly_point_map);
- FREE(xcombined);
- FREE(x_poly);
- FREE(polys_groups);
+ free(xcombined);
+ free(x_poly);
+ free(polys_groups);
}
SparseMatrix_distance_matrix(A, 0, &dist);
SparseMatrix_delete(A);
A = SparseMatrix_from_dense(n, n, dist);
- FREE(dist);
+ free(dist);
A = SparseMatrix_remove_diagonal(A);
SparseMatrix_export(stdout, A);
}
(*rgb_g)[i+1] = (float) colors[cdim*i + 1];
(*rgb_b)[i+1] = (float) colors[cdim*i + 2];
}
- FREE(colors);
-
+ free(colors);
}
void map_optimal_coloring(int seed, SparseMatrix A, float *rgb_r, float *rgb_g, float *rgb_b){
for (i = 0; i < n; i++) rgb_g[i] = u[i];
vector_float_take(n, rgb_b, n, p, &u);
for (i = 0; i < n; i++) rgb_b[i] = u[i];
- FREE(u);
-
+ free(u);
}
static int get_poly_id(int ip, SparseMatrix point_poly_map){
dot_one_poly(sbuff, -1, 1, np, xp, yp, cstring);
}
}
- FREE(xp);
- FREE(yp);
-
+ free(xp);
+ free(yp);
}
void plot_dot_map(Agraph_t* gr, int n, int dim, real *x, SparseMatrix polys,
*nt = ntri;
- FREE(trilist);
+ free(trilist);
}
static SparseMatrix get_country_graph(int n, SparseMatrix A, int *groups, int GRP_RANDOM, int GRP_BBOX){
SparseMatrix_delete(B);
SparseMatrix_delete(BB);
*poly_point_map = SparseMatrix_new(ncomps, n, n, MATRIX_TYPE_PATTERN, FORMAT_CSR);
- FREE((*poly_point_map)->ia);
- FREE((*poly_point_map)->ja);
+ free((*poly_point_map)->ia);
+ free((*poly_point_map)->ja);
(*poly_point_map)->ia = comps_ptr;
(*poly_point_map)->ja = comps;
(*poly_point_map)->nz = n;
SparseMatrix_delete(*poly_lines);
*poly_lines = A;
- FREE(tlist);
- FREE(elist);
+ free(tlist);
+ free(elist);
}
static void plot_cycle(int head, int *cycle, int *edge_table, real *x){
*polys = B;
SparseMatrix_delete(half_edges);
- FREE(cycle);
- FREE(edge_cycle_map);
- FREE(elist);
- FREE(emask);
- FREE(edge_table);
-
+ free(cycle);
+ free(edge_cycle_map);
+ free(elist);
+ free(emask);
+ free(edge_table);
}
+
static void get_polygons(int exclude_random, int n, int nrandom, int dim, SparseMatrix graph, int *grouping,
int nt, struct Triangle *Tp, SparseMatrix E, int *nverts, real **x_poly,
int *npolys, SparseMatrix *poly_lines, SparseMatrix *polys, int **polys_groups, SparseMatrix *poly_point_map, SparseMatrix *country_graph){
B = get_country_graph(n, E, groups, GRP_RANDOM, GRP_BBOX);
*country_graph = B;
- FREE(groups);
- FREE(mask);
+ free(groups);
+ free(mask);
}
static int make_map_internal(int exclude_random, int include_OK_points,
*nrandom += n - nh;/* count everything except cluster HIGHLIGHT_SET as random */
n = nh;
if (Verbose) fprintf(stderr,"nh = %d\n",nh);
- FREE(xtemp);
+ free(xtemp);
}
}
poly_point_map, country_graph);
SparseMatrix_delete(E);
- FREE(Tp);
- FREE(xran);
- if (grouping != grouping0) FREE(grouping);
- if (x != x0) FREE(x);
+ free(Tp);
+ free(xran);
+ if (grouping != grouping0) free(grouping);
+ if (x != x0) free(x);
return 0;
}
shore_depth_tol, xcombined, nverts, x_poly,
npolys, poly_lines, polys, polys_groups, poly_point_map, country_graph, highlight_cluster, flag);
if (graph != graph0) SparseMatrix_delete(graph);
- FREE(groups);
- FREE(X);
+ free(groups);
+ free(X);
}
return res;
}
} while (res < 1 - tolerance && iter++ < maxit);
}
- FREE(u);
- FREE(vv);
+ free(u);
+ free(vv);
}
SparseMatrix_delete(A);
A = B;
- FREE(x);
+ free(x);
x = xx;
dim = 2;
default:
A = NULL;
}
- FREE(I);
- FREE(J);
- FREE(val);
+ free(I);
+ free(J);
+ free(val);
if (mm_is_symmetric(matcode)) {
SparseMatrix_set_symmetric(A);
#include <getopt.h>
#define MALLOC malloc
-#define FREE free
#define test_flag(a, flag) ((a)&(flag))
#define real double
#define BUFS 1024
}
agxbfree (&xb);
- FREE(color);
- FREE(arr);
+ free(color);
+ free(arr);
return g;
}
}
}
- FREE(x1);
- FREE(x2);
+ free(x1);
+ free(x2);
return 0;
}
RETURN:
SparseMatrix_delete(A);
SparseMatrix_delete(C);
- FREE(colors);
- FREE(x);
+ free(colors);
+ free(x);
if (xsplines){
for (i = 0; i < ne; i++){
- FREE(xsplines[i]);
+ free(xsplines[i]);
}
- FREE(xsplines);
+ free(xsplines);
}
return g;
-
}
-
QuadTree_delete(qt0);
- FREE(candidates);
- FREE(candidates2);
-
+ free(candidates);
+ free(candidates2);
}
}/* continue down the quadtree */
- FREE(candidates);
- FREE(candidates2);
-
+ free(candidates);
+ free(candidates2);
}
qt = QuadTree_new_from_point_list(dim, n, max_qtree_level, x, NULL);
- FREE(x);
+ free(x);
return qt;
}
while (jj < nc -1 && dists[jj] < dists[ii] + step) jj++;
}
}
- FREE(dists);
- FREE(lab);
+ free(dists);
+ free(lab);
}
}
*color_diff0 = color_diff;
*color_diff_sum0 = color_diff_sum;
- FREE(x);
-
+ free(x);
}
static void node_distinct_coloring_internal(int scheme, QuadTree qt, int weightedQ, SparseMatrix A, int cdim, real accuracy, int iter_max, int seed, real *colors){
}
SparseMatrix_delete(B);
}
- FREE(ctmp);
+ free(ctmp);
if (A != A0) SparseMatrix_delete(A);
return 0;
/* on level 0, R0 = NULL, on level 1, R0 = R */
if (grid->level > 1) SparseMatrix_delete(grid->R0);
SparseMatrix_delete(grid->R);
- FREE(grid->inks);
+ free(grid->inks);
Agglomerative_Ink_Bundling_delete(grid->next);
- FREE(grid);
+ free(grid);
}
static Agglomerative_Ink_Bundling Agglomerative_Ink_Bundling_establish(Agglomerative_Ink_Bundling grid, int *pick, real angle_param, real angle){
}
RETURN:
- FREE(matching);
+ free(matching);
for (i = 0; i < n; i++) Vector_delete(cedges[i]);
- FREE(cedges);
- FREE(mask);
+ free(cedges);
+ free(mask);
return grid;
}
pick = MALLOC(sizeof(int)*A0->m);
grid = Agglomerative_Ink_Bundling_establish(grid, pick, angle_param, angle);
- FREE(pick);
+ free(pick);
if (A != A0) grid->delete_top_level_A = TRUE;/* be sure to clean up later */
agglomerative_ink_bundling_internal(dim, A_mid, mid_edges, nneighbors, recurse_level, MAX_RECURSE_LEVEL, angle_param, angle, open_gl, current_ink, ink00, flag);
SparseMatrix_delete(A_mid);
- FREE(xx);
+ free(xx);
/* patching edges with the new mid-section */
for (i = 0; i < R->m; i++){
}
void pedge_delete(pedge e){
- FREE(e->x);
- FREE(e);
+ free(e->x);
+ free(e);
}
pedge pedge_flip(pedge e){
memcpy(&x[(n-1-i)*dim], &x[i*dim], sizeof(real)*dim);
memcpy(&x[i*dim], y, sizeof(real)*dim);
}
- FREE(y);
+ free(y);
return e;
}
}
- FREE(force_t);
- FREE(force_a);
+ free(force_t);
+ free(force_a);
return edges;
}
A = NULL;
#endif
- FREE(irn);
- FREE(jcn);
- FREE(val);
+ free(irn);
+ free(jcn);
+ free(val);
return A;
-
-
}
*tris = mid.numberoftriangles;
- FREE(in.pointlist);
- FREE(in.pointattributelist);
- FREE(in.pointmarkerlist);
- FREE(in.regionlist);
- FREE(mid.pointlist);
- FREE(mid.pointattributelist);
- FREE(mid.pointmarkerlist);
- FREE(mid.triangleattributelist);
- FREE(mid.neighborlist);
- FREE(mid.segmentlist);
- FREE(mid.segmentmarkerlist);
- FREE(mid.edgelist);
- FREE(mid.edgemarkerlist);
- FREE(vorout.pointlist);
- FREE(vorout.pointattributelist);
- FREE(vorout.edgelist);
- FREE(vorout.normlist);
+ free(in.pointlist);
+ free(in.pointattributelist);
+ free(in.pointmarkerlist);
+ free(in.regionlist);
+ free(mid.pointlist);
+ free(mid.pointattributelist);
+ free(mid.pointmarkerlist);
+ free(mid.triangleattributelist);
+ free(mid.neighborlist);
+ free(mid.segmentlist);
+ free(mid.segmentmarkerlist);
+ free(mid.edgelist);
+ free(mid.edgemarkerlist);
+ free(vorout.pointlist);
+ free(vorout.pointattributelist);
+ free(vorout.edgelist);
+ free(vorout.normlist);
return mid.trianglelist;
}
}
check_overlap_RETURN:
- FREE(scanpointsx);
- FREE(scanpointsy);
+ free(scanpointsx);
+ free(scanpointsy);
RBTreeDestroy(treey);
B = SparseMatrix_from_coordinate_format(A);
relative_position_constraints data;
if (!d) return;
data = (relative_position_constraints) d;
- FREE(data->irn);
- FREE(data->jcn);
- FREE(data->val);
+ free(data->irn);
+ free(data->jcn);
+ free(data->val);
/* other stuff inside relative_position_constraints is assed back to the user hence no need to deallocator*/
- FREE(d);
+ free(d);
}
static relative_position_constraints relative_position_constraints_new(SparseMatrix A_constr, int edge_labeling_scheme, int n_constr_nodes, int *constr_nodes){
for (i = 0; i < dim; i++) fprintf(stderr,"{%f,%f}, ",xmin[i], xmax[i]);
fprintf(stderr,"\n");
- FREE(xmin);
- FREE(xmax);
+ free(xmin);
+ free(xmax);
}
static int check_convergence(real max_overlap, real res, int has_penalty_terms, real epsilon){
}
void Multilevel_control_delete(Multilevel_control ctrl){
- FREE(ctrl);
+ free(ctrl);
}
static Multilevel Multilevel_init(SparseMatrix A, SparseMatrix D, real *node_weights){
}
SparseMatrix_delete(grid->P);
SparseMatrix_delete(grid->R);
- if (grid->node_weights && grid->level > 0) FREE(grid->node_weights);
+ if (grid->node_weights && grid->level > 0) free(grid->node_weights);
Multilevel_delete(grid->next);
- FREE(grid);
+ free(grid);
}
static void maximal_independent_vertex_set(SparseMatrix A, int randomize, int **vset, int *nvset, int *nzc){
}
}
}
- FREE(p);
+ free(p);
}
(*nzc) += *nvset;
}
i = p[ii];
PriorityQueue_push(q, i, ia[i+1] - ia[i]);
}
- FREE(p);
+ free(p);
}
while (PriorityQueue_pop(q, &i, &gain)){
}
}
}
- FREE(p);
+ free(p);
}
}
(*nmatch)--;
}
}
- FREE(p);
+ free(p);
}
}
}
}
- FREE(p);
+ free(p);
}
- FREE(matched);
+ free(matched);
}
(*clusterp)[++(*ncluster)] = nz;
}
}
- FREE(p);
+ free(p);
}
- FREE(super);
+ free(super);
- FREE(superp);
+ free(superp);
- FREE(matched);
+ free(matched);
}
static int scomp(const void *s1, const void *s2){
(*clusterp)[++(*ncluster)] = nz;
}
}
- FREE(p);
+ free(p);
- FREE(matched);
+ free(matched);
}
static void maximal_independent_edge_set_heavest_edge_pernode_scaled(SparseMatrix A, int randomize, int **matching, int *nmatch){
int i, ii, j, *ia, *ja, m, n, *p = NULL;
(*nmatch)--;
}
}
- FREE(p);
+ free(p);
}
}
goto RETURN;
}
RETURN:
- FREE(matching);
- FREE(vset);
- FREE(irn);
- FREE(jcn);
- FREE(val);
+ free(matching);
+ free(vset);
+ free(irn);
+ free(jcn);
+ free(val);
if (B) SparseMatrix_delete(B);
- FREE(cluster);
- FREE(clusterp);
+ free(cluster);
+ free(clusterp);
}
void Multilevel_coarsen(SparseMatrix A, SparseMatrix *cA, SparseMatrix D, SparseMatrix *cD, real *node_wgt, real **cnode_wgt,
if (*cD) SparseMatrix_delete(*cD);
*cD = cD0;
- if (*cnode_wgt) FREE(*cnode_wgt);
+ if (*cnode_wgt) free(*cnode_wgt);
*cnode_wgt = cnode_wgt0;
A = cA0;
D = cD0;
ia = D->ia;
ja = D->ja;
if (D->type != MATRIX_TYPE_REAL){
- FREE(D->a);
+ free(D->a);
D->type = MATRIX_TYPE_REAL;
D->a = N_GNEW(D->nz,real);
}
sm->Lw->nz = nz;
sm->Lwd->nz = nz;
- FREE(mask);
- FREE(avg_dist);
+ free(mask);
+ free(avg_dist);
SparseMatrix_delete(ID);
return sm;
}
SparseMatrix_delete(Lw);
}
- FREE(x0);
- FREE(y);
- FREE(x00);
+ free(x0);
+ free(y);
+ free(x00);
return diff;
}
if (!sm) return;
if (sm->Lw) SparseMatrix_delete(sm->Lw);
if (sm->Lwd) SparseMatrix_delete(sm->Lwd);
- FREE(sm->lambda);
+ free(sm->lambda);
if (sm->data) sm->data_deallocator(sm->data);
- FREE(sm);
+ free(sm);
}
for (i = 0; i < iw[m]; i++) d[i] *= s;
sm->scaling = s;
- FREE(avg_dist);
+ free(avg_dist);
return sm;
}
sm->ctrl->step /= 2;
sm->ctrl->maxiter = 20;
- FREE(mask);
- FREE(avg_dist);
+ free(mask);
+ free(avg_dist);
SparseMatrix_delete(ID);
return sm;
free(pos);
SparseMatrix_delete (A);
if (D) SparseMatrix_delete (D);
- FREE(edge_label_nodes);
+ free(edge_label_nodes);
}
static int
static void Operator_matmul_delete(Operator o){
- FREE(o);
+ free(o);
}
}
static void Operator_diag_precon_delete(Operator o){
- FREE(o->data);
- FREE(o);
+ free(o->data);
+ free(o);
}
static real conjugate_gradient(Operator A, Operator precon, int n, real *x, real *rhs, real tol, int maxit){
rho_old = rho;
}
- FREE(z); FREE(r); FREE(p); FREE(q);
+ free(z); free(r); free(p); free(q);
#ifdef DEBUG
_statistics[0] += iter - 1;
#endif
rhs[i*dim+k] = x[i];
}
}
- FREE(x);
- FREE(b);
+ free(x);
+ free(b);
return res;
-
}
static real* jacobi(SparseMatrix A, int dim, real *x0, real *rhs, int maxit, int *flag){
}
- FREE(x);
- FREE(y);
- FREE(b);
+ free(x);
+ free(y);
+ free(b);
return rhs;
-
}
real SparseMatrix_solve(SparseMatrix A, int dim, real *x0, real *rhs, real tol, int maxit, int method, int *flag){
}
void spring_electrical_control_delete(spring_electrical_control ctrl){
- FREE(ctrl);
+ free(ctrl);
}
static char* smoothings[] = {
}
void oned_optimizer_delete(oned_optimizer opt){
- FREE(opt);
+ free(opt);
}
oned_optimizer oned_optimizer_new(int i){
}
- FREE(checked);
- FREE(angles);
- FREE(leaves);
+ free(checked);
+ free(angles);
+ free(leaves);
}
void force_print(FILE *fp, int n, int dim, real *x, real *force){
oned_optimizer_delete(qtree_level_optimizer);
ctrl->max_qtree_level = max_qtree_level;
- FREE(xold);
+ free(xold);
if (A != A0) SparseMatrix_delete(A);
- FREE(force);
+ free(force);
}
static void spring_electrical_embedding_slow(int dim, SparseMatrix A0, spring_electrical_control ctrl, real *node_weights, real *x, int *flag){
oned_optimizer_delete(qtree_level_optimizer);
ctrl->max_qtree_level = max_qtree_level;
}
- FREE(xold);
+ free(xold);
if (A != A0) SparseMatrix_delete(A);
- FREE(f);
- FREE(center);
- FREE(supernode_wgts);
- FREE(distances);
- FREE(force);
+ free(f);
+ free(center);
+ free(supernode_wgts);
+ free(distances);
+ free(force);
}
oned_optimizer_delete(qtree_level_optimizer);
ctrl->max_qtree_level = max_qtree_level;
}
- FREE(xold);
+ free(xold);
if (A != A0) SparseMatrix_delete(A);
- FREE(f);
- FREE(center);
- FREE(supernode_wgts);
- FREE(distances);
+ free(f);
+ free(center);
+ free(supernode_wgts);
+ free(distances);
}
static void scale_coord(int n, int dim, real *x, int *id, int *jd, real *d, real dj){
if (ctrl->beautify_leaves) beautify_leaves(dim, A, x);
RETURN:
- FREE(xold);
+ free(xold);
if (A != A0) SparseMatrix_delete(A);
- FREE(f);
- FREE(center);
- FREE(supernode_wgts);
- FREE(distances);
+ free(f);
+ free(center);
+ free(supernode_wgts);
+ free(distances);
}
if (ctrl->beautify_leaves) beautify_leaves(dim, A, x);
RETURN:
- FREE(xold);
+ free(xold);
if (A != A0) SparseMatrix_delete(A);
- FREE(f);
- FREE(center);
- FREE(supernode_wgts);
- FREE(distances);
+ free(f);
+ free(center);
+ free(supernode_wgts);
+ free(distances);
}
}
}
- FREE(y);
+ free(y);
}
static void prolongate(int dim, SparseMatrix A, SparseMatrix P, SparseMatrix R, real *x, real *y, int coarsen_scheme_used, real delta){
int nc, *ia, *ja, i, j, k;
max = MAX(max, mask[deg]);
}
if (mask[1] > 0.8*max && mask[1] > 0.3*m) res = TRUE;
- FREE(mask);
+ free(mask);
return res;
}
}
}
- FREE(mask);
+ free(mask);
}
static SparseMatrix shorting_edge_label_nodes(SparseMatrix A, int n_edge_label_nodes, int *edge_label_nodes){
B = SparseMatrix_from_coordinate_arrays(nz, id, id, irn, jcn, NULL, MATRIX_TYPE_PATTERN, sizeof(real));
- FREE(irn);
- FREE(jcn);
- FREE(mask);
+ free(irn);
+ free(jcn);
+ free(mask);
return B;
}
remove_overlap(dim, A, x, label_sizes, ctrl->overlap, ctrl->initial_scaling,
ctrl->edge_labeling_scheme, n_edge_label_nodes, edge_label_nodes, A, ctrl->do_shrinking);
SparseMatrix_delete(A2);
- FREE(x2);
+ free(x2);
if (A != A0) SparseMatrix_delete(A);
return;
}
if (Multilevel_is_finest(grid)) break;
if (*flag) {
- FREE(xc);
+ free(xc);
goto RETURN;
}
P = grid->P;
xf = MALLOC(sizeof(real)*grid->n*dim);
}
prolongate(dim, grid->A, P, grid->R, xc, xf, coarsen_scheme_used, (ctrl->K)*0.001);
- FREE(xc);
+ free(xc);
xc = xf;
ctrl->random_start = FALSE;
ctrl->K = ctrl->K * 0.75;
sm->data = MALLOC(sizeof(real)*2);
((real*) sm->data)[0] = alpha;
((real*) sm->data)[1] = M;
- sm->data_deallocator = FREE;
+ sm->data_deallocator = free;
sm->tol_cg = 0.01;
sm->maxit_cg = (int)sqrt((double) A->m);
void BinaryHeap_delete(BinaryHeap h, void (*del)(void* item)){
if (!h) return;
- FREE(h->id_to_pos);
- FREE(h->pos_to_id);
+ free(h->id_to_pos);
+ free(h->pos_to_id);
IntStack_delete(h->id_stack);
if (del) for (size_t i = 0; i < h->len; i++) del((h->heap)[i]);
- FREE(h->heap);
- FREE(h);
+ free(h->heap);
+ free(h);
}
static BinaryHeap BinaryHeap_realloc(BinaryHeap h){
for (size_t i = 0; i < h->len + IntStack_get_length(h->id_stack); i++)
assert(mask[i] != 0);
- FREE(mask);
+ free(mask);
}
void BinaryHeap_print(BinaryHeap h, void (*pnt)(void*)){
size_t k = 2;
}
}
if (!has_positions) {
- FREE(*x);
+ free(*x);
*x = NULL;
}
}
done:
if (format != FORMAT_COORD){
- FREE(I);
- FREE(J);
- FREE(val);
+ free(I);
+ free(J);
+ free(val);
}
- FREE(valD);
+ free(valD);
return A;
}
}
}
if (!has_position){
- FREE(*x);
+ free(*x);
*x = NULL;
}
}
- FREE(I);
- FREE(J);
- FREE(val);
+ free(I);
+ free(J);
+ free(val);
return A;
}
}
}
- FREE(I);
- FREE(J);
- FREE(val);
- FREE(clusters);
+ free(I);
+ free(J);
+ free(val);
+ free(clusters);
SparseMatrix_delete(A);
void IntStack_delete(IntStack s){
if (s){
- FREE(s->stack);
- FREE(s);
+ free(s->stack);
+ free(s);
}
}
#include <sparse/LinkedList.h>
#include <common/memory.h>
-#define FREE free
-
-
SingleLinkedList SingleLinkedList_new(void *data){
SingleLinkedList head;
do {
next = head->next;
if (head->data) linklist_deallocator(head->data);
- FREE(head);
+ free(head);
head = next;
} while (head);
do {
next = head->next;
if (head->data) linklist_deallocator(head->data);
- FREE(head);
+ free(head);
head = next;
} while (head);
prev = l->prev;
if (l->data) linklist_deallocator(l->data);
- FREE(l);
+ free(l);
l = NULL;
if (next) next->prev = prev;
static void node_data_delete(void *d){
node_data nd = (node_data) d;
- FREE(nd->coord);
- /*delete outside if (nd->data) FREE(nd->data);*/
- FREE(nd);
+ free(nd->coord);
+ /*delete outside if (nd->data) free(nd->data);*/
+ free(nd);
}
static real node_data_get_weight(void *d){
xmax = MALLOC(sizeof(real)*dim);
center = MALLOC(sizeof(real)*dim);
if (!xmin || !xmax || !center) {
- FREE(xmin);
- FREE(xmax);
- FREE(center);
+ free(xmin);
+ free(xmax);
+ free(center);
return NULL;
}
}
- FREE(xmin);
- FREE(xmax);
- FREE(center);
+ free(xmin);
+ free(xmax);
+ free(center);
return qt;
}
int i, dim;
if (!q) return;
dim = q->dim;
- FREE(q->center);
- FREE(q->average);
- FREE(q->data);
+ free(q->center);
+ free(q->average);
+ free(q->data);
if (q->qts){
for (i = 0; i < 1<<dim; i++){
QuadTree_delete(q->qts[i]);
}
- FREE(q->qts);
+ free(q->qts);
}
SingleLinkedList_delete(q->l, node_data_delete);
- FREE(q);
+ free(q);
}
static int QuadTree_get_quadrant(int dim, real *center, real *coord){
SparseMatrix_set_pattern_symmetric(A);
}
RETURN:
- FREE(mask);
+ free(mask);
SparseMatrix_delete(B);
return res;
/* return a sparse matrix skeleton with row dimension m and storage nz. If nz == 0,
only row pointers are allocated */
if (!A) return;
- FREE(A->ia);
- FREE(A->ja);
- FREE(A->a);
- FREE(A);
+ free(A->ia);
+ free(A->ja);
+ free(A->a);
+ free(A);
}
static void SparseMatrix_print_csr(char *c, SparseMatrix A){
int *ia, *ja;
C->nz = nz;
RETURN:
- FREE(mask);
+ free(mask);
return C;
}
C->nz = nz;
RETURN:
- FREE(mask);
+ free(mask);
return C;
-
}
D->nz = nz;
RETURN:
- FREE(mask);
+ free(mask);
return D;
-
}
SparseMatrix SparseMatrix_sum_repeat_entries(SparseMatrix A, int what_to_sum){
break;
}
A->nz = nz;
- FREE(mask);
+ free(mask);
return A;
}
}
if (A != A0) SparseMatrix_delete(A);
- FREE(levelset_ptr);
+ free(levelset_ptr);
- FREE(mask);
+ free(mask);
}
//fprintf(stderr," reset neighbor id=%d, dist=%f, hid = %d, a[%d]=%f, dist=%f\n",jj, ndata->dist,heap_id, jj, a[j], ndata->dist);
}
}
- FREE(ndata_min);
+ free(ndata_min);
}
*nlist = found;
*dist_max = dist[i];
- BinaryHeap_delete(h, FREE);
- FREE(heap_ids);
- if (a && a != A->a) FREE(a);
+ BinaryHeap_delete(h, free);
+ free(heap_ids);
+ if (a && a != A->a) free(a);
if (found == m || mask){
return 0;
} else {
printf("\n");
#endif
- FREE(mask);
- FREE(super);
-
+ free(mask);
+ free(super);
}
SparseMatrix SparseMatrix_get_augmented(SparseMatrix A){
B = SparseMatrix_from_coordinate_arrays(nz, m + n, m + n, irn, jcn, val, type, A->size);
SparseMatrix_set_symmetric(B);
SparseMatrix_set_pattern_symmetric(B);
- FREE(irn);
- FREE(jcn);
- FREE(val);
+ free(irn);
+ free(jcn);
+ free(val);
return B;
}
}
break;
case MATRIX_TYPE_UNKNOWN:
- FREE(rmask);
- FREE(cmask);
+ free(rmask);
+ free(cmask);
return NULL;
default:
- FREE(rmask);
- FREE(cmask);
+ free(rmask);
+ free(cmask);
return NULL;
}
B = SparseMatrix_from_coordinate_arrays(nz, nrow, ncol, irn, jcn, v, A->type, A->size);
- FREE(cmask);
- FREE(rmask);
- FREE(irn);
- FREE(jcn);
- if (v) FREE(v);
+ free(cmask);
+ free(rmask);
+ free(irn);
+ free(jcn);
+ if (v) free(v);
return B;
real *a;
int i;
- FREE(A->a);
+ free(A->a);
A->a = MALLOC(sizeof(real)*((size_t)A->nz));
a = (real*) (A->a);
for (i = 0; i < A->nz; i++) a[i] = 1.;
}
}
- FREE(levelset_ptr);
- FREE(levelset);
- FREE(mask);
+ free(levelset_ptr);
+ free(levelset);
+ free(mask);
if (D != D0) SparseMatrix_delete(D);
- FREE(list);
+ free(list);
return flag;
}
C = SparseMatrix_from_coordinate_format(B);
SparseMatrix_delete(B);
- FREE(levelset_ptr);
- FREE(levelset);
- FREE(mask);
- FREE(dist);
+ free(levelset_ptr);
+ free(levelset);
+ free(mask);
+ free(dist);
if (D != D0) SparseMatrix_delete(D);
- FREE(list);
+ free(list);
/* I can not find a reliable way to make the matrix symmetric. Right now I use a mask array to
limit consider of only nodes with in k hops, but even this is not symmetric. e.g.,
. 10 10 10 10
grid->deg_total = deg_total;
grid->deg = deg;
grid->modularity = modularity;
- FREE(indeg);
+ free(indeg);
}
}
SparseMatrix_delete(grid->P);
SparseMatrix_delete(grid->R);
- FREE(grid->matching);
- FREE(grid->deg);
+ free(grid->matching);
+ free(grid->deg);
Multilevel_Modularity_Clustering_delete(grid->next);
- FREE(grid);
+ free(grid);
}
static Multilevel_Modularity_Clustering Multilevel_Modularity_Clustering_establish(Multilevel_Modularity_Clustering grid, int ncluster_target){
} else if (n - ncluster_target <= ncluster_target - nc){/* ncluster_target close to n */
fprintf(stderr,"ncluster_target = %d, close to n=%d\n", ncluster_target, n);
for (i = 0; i < n; i++) matching[i] = i;
- FREE(deg_new);
+ free(deg_new);
goto RETURN;
}
} else if (n < ncluster_target){
fprintf(stderr,"n < target\n");
for (i = 0; i < n; i++) matching[i] = i;
- FREE(deg_new);
+ free(deg_new);
goto RETURN;
}
}
P = SparseMatrix_transpose(R);
B = SparseMatrix_multiply(R, A);
if (!B) {
- FREE(deg_new);
+ free(deg_new);
goto RETURN;
}
cA = SparseMatrix_multiply(B, P);
if (!cA) {
- FREE(deg_new);
+ free(deg_new);
goto RETURN;
}
SparseMatrix_delete(B);
/* if we want a small number of cluster but right now we have too many, we will force agglomeration */
if (ncluster_target > 0 && nc > ncluster_target && !(grid->agglomerate_regardless)){
grid->agglomerate_regardless = TRUE;
- FREE(deg_inter);
- FREE(mask);
- FREE(deg_new);
+ free(deg_inter);
+ free(mask);
+ free(deg_new);
return Multilevel_Modularity_Clustering_establish(grid, ncluster_target);
}
/* no more improvement, stop and final clustering found */
for (i = 0; i < n; i++) matching[i] = i;
- FREE(deg_new);
+ free(deg_new);
}
RETURN:
- FREE(deg_inter);
- FREE(mask);
+ free(deg_inter);
+ free(mask);
return grid;
}
real *v = NULL;
P = cgrid->prev->P;
SparseMatrix_multiply_vector(P, u, &v, FALSE);
- FREE(u);
+ free(u);
u = v;
cgrid = cgrid->prev;
}
*assignment = matching;
}
for (i = 0; i < grid->n; i++) (matching)[i] = (int) u[i];
- FREE(u);
+ free(u);
Multilevel_Modularity_Clustering_delete(grid);
-
}
qsort(u, n, sizeof(real)*2, comp_ascend);
for (i = 0; i < n; i++) (*p)[i] = (int) u[2*i+1];
- FREE(u);
-
+ free(u);
}
void vector_sort_int(int n, int *v){
#define REALLOC grealloc
#endif /* STANDALONE */
-#define FREE free
-
#ifndef DEBUG
#ifndef NDEBUG
#define NDEBUG /* switch off assert*/
*mq_in0 = mq_in;
*mq_out0 = mq_out;
*dout0 = dout;
- FREE(counts);
+ free(counts);
if (k > 1){
return 2*(mq_in/k - mq_out/(k*(k-1)));
}
SparseMatrix_delete(grid->P);
SparseMatrix_delete(grid->R);
- FREE(grid->matching);
- FREE(grid->deg_intra);
- FREE(grid->dout);
- FREE(grid->wgt);
+ free(grid->matching);
+ free(grid->deg_intra);
+ free(grid->dout);
+ free(grid->wgt);
Multilevel_MQ_Clustering_delete(grid->next);
- FREE(grid);
+ free(grid);
}
static Multilevel_MQ_Clustering Multilevel_MQ_Clustering_establish(Multilevel_MQ_Clustering grid, int maxcluster){
P = SparseMatrix_transpose(R);
B = SparseMatrix_multiply(R, A);
if (!B) {
- FREE(deg_intra_new);
- FREE(wgt_new);
- FREE(dout_new);
+ free(deg_intra_new);
+ free(wgt_new);
+ free(dout_new);
goto RETURN;
}
cA = SparseMatrix_multiply(B, P);
if (!cA) {
- FREE(deg_intra_new);
- FREE(wgt_new);
- FREE(dout_new);
+ free(deg_intra_new);
+ free(wgt_new);
+ free(dout_new);
goto RETURN;
}
SparseMatrix_delete(B);
/* no more improvement, stop and final clustering found */
for (i = 0; i < n; i++) matching[i] = i;
- FREE(deg_intra_new);
- FREE(wgt_new);
- FREE(dout_new);
+ free(deg_intra_new);
+ free(wgt_new);
+ free(dout_new);
}
RETURN:
for (i = 0; i < n; i++) SingleLinkedList_delete(neighbors[i], free);
- FREE(neighbors);
+ free(neighbors);
- FREE(deg_inter);
- FREE(mask);
+ free(deg_inter);
+ free(mask);
return grid;
}
real *v = NULL;
P = cgrid->prev->P;
SparseMatrix_multiply_vector(P, u, &v, FALSE);
- FREE(u);
+ free(u);
u = v;
cgrid = cgrid->prev;
}
*assignment = matching;
}
for (i = 0; i < grid->n; i++) (matching)[i] = (int) u[i];
- FREE(u);
+ free(u);
Multilevel_MQ_Clustering_delete(grid);
-
}
projects / graphviz / commitdiff