Function lg_build

src/store/store.c:6649–6703

Build a CSR graph from a deduplicated undirected edge list. */

/* Build a CSR graph from a deduplicated undirected edge list. */
static int lg_build(int n, const int *wsi, const int *wdi, const double *ww, int wn,
                    cbm_lg_t *out) {
    int *off = calloc((size_t)n + 1, sizeof(int));
    double *k = calloc((size_t)n, sizeof(double));
    int *fill = malloc((size_t)n * sizeof(int));
    if (!off || !k || !fill) {
        free(off);
        free(k);
        free(fill);
        return CBM_NOT_FOUND;
    }
    for (int e = 0; e < wn; e++) {
        off[wsi[e] + 1]++;
        off[wdi[e] + 1]++;
    }
    for (int i = 0; i < n; i++) {
        off[i + 1] += off[i];
    }
    int total = off[n];
    /* calloc, not malloc: every slot IS written (off[n] equals the summed
     * degrees, two writes per edge), but that invariant is invisible to
     * path-sensitive analysis, and zero-filled backing turns any future
     * degree-miscount bug into a benign self-loop instead of UB. */
    int *nbr = calloc((size_t)(total > 0 ? total : 1), sizeof(int));
    double *w = calloc((size_t)(total > 0 ? total : 1), sizeof(double));
    if (!nbr || !w) {
        free(off);
        free(k);
        free(fill);
        free(nbr);
        free(w);
        return CBM_NOT_FOUND;
    }
    memcpy(fill, off, (size_t)n * sizeof(int));
    for (int e = 0; e < wn; e++) {
        int a = wsi[e];
        int b = wdi[e];
        double we = ww[e];
        nbr[fill[a]] = b;
        w[fill[a]] = we;
        fill[a]++;
        nbr[fill[b]] = a;
        w[fill[b]] = we;
        fill[b]++;
        k[a] += we;
        k[b] += we;
    }
    free(fill);
    out->n = n;
    out->off = off;
    out->nbr = nbr;
    out->w = w;
    out->k = k;
    return CBM_STORE_OK;
}

/* Local-moving phase: greedily move each node to the neighbouring community
 * with the highest modularity gain, using a work queue seeded with every node