@graphty/graph-samples 0.0.1 → 0.1.1

package/dist/src/generators/degree-sequence.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Degree-sequence models: power-law degree sequences, the configuration model (undirected,
+ * directed and bipartite), Chung-Lu expected-degree graphs, the degree-corrected stochastic block
+ * model and random regular graphs.
+ */
+import { type U32 } from "@graphty/graph-format";
+import { RandomStream } from "../random/stream.js";
+import { type SampleGraph } from "../types.js";
+import { EdgeBuffer } from "./util.js";
+import { type WeightOptions } from "./weights.js";
+/**
+ * What a generator does with self-loops or repeated pairs: keep them, or erase all but the first
+ * occurrence in edge order.
+ */
+export type EdgePolicy = "keep" | "erase";
+/**
+ * A sampler of the discrete power law P(d) ~ d^-exponent on [min, max]: a cumulative table of
+ * detPow(d, -exponent), and per draw one nextFloat u and a binary search for the first entry
+ * above u times the total. Checks its arguments.
+ * @param names - the option names of [exponent, min, max], for the messages
+ * @param exponent - the exponent, >= 0
+ * @param min - the smallest value, >= 1
+ * @param max - the largest value, >= min
+ * @returns the sampler
+ */
+export declare function powerLawSampler(names: readonly [string, string, string], exponent: number, min: number, max: number): (stream: RandomStream) => number;
+/**
+ * Make the sum of `seq` even by changing its LAST entry: +1 when it is below `max`, else -1 when
+ * it is above `min`; a RangeError when neither is possible.
+ * @param seq - the sequence, changed in place
+ * @param min - the smallest allowed value
+ * @param max - the largest allowed value
+ */
+export declare function makeSumEven(seq: U32, min: number, max: number): void;
+/** Options of {@link powerLawDegreeSequence}. */
+export interface PowerLawDegreeSequenceOptions {
+    /** The sequence length, >= 0. */
+    n: number;
+    /** The exponent of P(d) ~ d^-exponent, a finite number >= 0 (typically 2 to 3). */
+    exponent: number;
+    /** The smallest degree, >= 1. */
+    minDegree: number;
+    /** The largest degree, >= minDegree, and at most minDegree + 2^24 - 1. */
+    maxDegree: number;
+    /** Make the sum even (so a configuration model can pair it); default true. */
+    evenSum?: boolean | undefined;
+    /** The seed, an integer in [0, 2^53); default 0. */
+    seed?: number | undefined;
+}
+/**
+ * A sequence of n integers drawn independently from the discrete power law
+ * P(d) ~ d^-exponent on [minDegree, maxDegree], by inversion of a cumulative table built with
+ * detPow: entry i is one nextFloat of stream (seed, "power-law", 0), in index order. With
+ * `evenSum` (the default) an odd sum is fixed by changing the last entry: +1 when it is below
+ * maxDegree, else -1. O(n log(maxDegree - minDegree) + maxDegree - minDegree).
+ * @param options - n, exponent, minDegree, maxDegree, evenSum and seed
+ * @returns the sequence
+ */
+export declare function powerLawDegreeSequence(options: PowerLawDegreeSequenceOptions): Uint32Array<ArrayBuffer>;
+/**
+ * The stub list: node i + offset repeated degrees[i] times, ascending.
+ * @param degrees - the degrees
+ * @param total - their sum
+ * @param offset - added to every node index
+ * @returns the stubs
+ */
+export declare function stubList(degrees: ArrayLike<number>, total: number, offset?: number): Uint32Array<ArrayBuffer>;
+/**
+ * Fisher-Yates shuffle in place: for i = length - 1 down to 1, swap entries i and nextBelow(i + 1).
+ * @param a - the array
+ * @param stream - the stream
+ */
+export declare function shuffle(a: U32, stream: RandomStream): void;
+/**
+ * Pair consecutive stubs of a shuffled undirected stub list into edges (stubs[2k], stubs[2k + 1])
+ * and erase as asked.
+ * @param n - the node count
+ * @param stubs - the shuffled stubs (even length)
+ * @param keepLoops - keep self-loops
+ * @param keepMulti - keep repeated pairs
+ * @param out - receives the edges
+ * @param group - a node column; edges inside one group are dropped
+ */
+export declare function pairStubs(n: number, stubs: U32, keepLoops: boolean, keepMulti: boolean, out: EdgeBuffer, group?: U32): void;
+/** Options of {@link configurationModelGraph}. */
+export interface ConfigurationModelOptions extends WeightOptions {
+    /** The degree of every node; the sum must be even. */
+    degrees: ArrayLike<number>;
+    /** Keep or erase self-loops; default "erase". */
+    selfLoops?: EdgePolicy | undefined;
+    /** Keep or erase repeated pairs (the first occurrence in edge order stays); default "erase". */
+    multiEdges?: EdgePolicy | undefined;
+    /** The seed, an integer in [0, 2^53); default 0. */
+    seed?: number | undefined;
+}
+/**
+ * The configuration model (E. A. Bender and E. R. Canfield, "The asymptotic number of labeled
+ * graphs with given degree sequences", J. Combin. Theory A 24, 296-307, 1978,
+ * doi:10.1016/0097-3165(78)90059-6; M. Molloy and B. Reed, "A critical point for random graphs with
+ * a given degree sequence", Random Struct. Algorithms 6, 161-179, 1995, doi:10.1002/rsa.3240060204;
+ * M. E. J. Newman, S. H. Strogatz and D. J. Watts, "Random graphs with arbitrary degree
+ * distributions and their applications", Phys. Rev. E 64, 026118, 2001,
+ * doi:10.1103/PhysRevE.64.026118). The stub list (node i repeated degrees[i] times, ascending) is
+ * Fisher-Yates shuffled with stream (seed, "configuration", 0) and consecutive stubs are paired:
+ * edge k is (stubs[2k], stubs[2k + 1]), in that order. With keep / keep the degrees are exact (a
+ * multigraph); erasing drops self-loops and every repeat of a pair after its first occurrence, so
+ * degrees can only go down. An odd degree sum is a RangeError. O(n + m).
+ * @param options - degrees, selfLoops, multiEdges and seed
+ * @returns the undirected graph
+ */
+export declare function configurationModelGraph(options: ConfigurationModelOptions): SampleGraph;
+/** Options of {@link directedConfigurationModelGraph}. */
+export interface DirectedConfigurationModelOptions extends WeightOptions {
+    /** The out-degree of every node. */
+    outDegrees: ArrayLike<number>;
+    /** The in-degree of every node; same length and same sum as outDegrees. */
+    inDegrees: ArrayLike<number>;
+    /** Keep or erase self-loops; default "erase". */
+    selfLoops?: EdgePolicy | undefined;
+    /** Keep or erase repeated ordered pairs (the first occurrence stays); default "erase". */
+    multiEdges?: EdgePolicy | undefined;
+    /** The seed, an integer in [0, 2^53); default 0. */
+    seed?: number | undefined;
+}
+/**
+ * The directed configuration model (Newman, Strogatz and Watts 2001, section on directed graphs):
+ * the in-stub list (node i repeated inDegrees[i] times, ascending) is Fisher-Yates shuffled with
+ * stream (seed, "configuration-directed", 0) and paired in order with the ascending out-stub list,
+ * so edge k runs from the k-th out-stub to the k-th shuffled in-stub (edges come grouped by
+ * source, ascending). Erasing works as in {@link configurationModelGraph} on ordered pairs.
+ * O(n + m).
+ * @param options - outDegrees, inDegrees, selfLoops, multiEdges and seed
+ * @returns the directed graph
+ */
+export declare function directedConfigurationModelGraph(options: DirectedConfigurationModelOptions): SampleGraph;
+/** Options of {@link bipartiteConfigurationModelGraph}. */
+export interface BipartiteConfigurationModelOptions extends WeightOptions {
+    /** The degree of every left node (nodes 0 .. L - 1). */
+    leftDegrees: ArrayLike<number>;
+    /** The degree of every right node (nodes L .. L + R - 1); same sum as leftDegrees. */
+    rightDegrees: ArrayLike<number>;
+    /** Keep or erase repeated pairs (the first occurrence stays); default "erase". */
+    multiEdges?: EdgePolicy | undefined;
+    /** The seed, an integer in [0, 2^53); default 0. */
+    seed?: number | undefined;
+}
+/**
+ * The bipartite configuration model (Newman, Strogatz and Watts 2001, section on bipartite
+ * graphs): left nodes are 0 .. L - 1, right nodes L .. L + R - 1. The right stub list (ascending)
+ * is Fisher-Yates shuffled with stream (seed, "bipartite-configuration", 0) and paired in order with
+ * the ascending left stub list; edge k is (k-th left stub, k-th shuffled right stub). Node column
+ * `side` (u8): 0 left, 1 right. O(n + m).
+ * @param options - leftDegrees, rightDegrees, multiEdges and seed
+ * @returns the undirected bipartite graph
+ */
+export declare function bipartiteConfigurationModelGraph(options: BipartiteConfigurationModelOptions): SampleGraph;
+/** The checked and precomputed form of an expected-degree model (Chung-Lu or the DC-SBM). */
+interface ExpectedDegreePlan {
+    readonly n: number;
+    readonly seed: number;
+    readonly domain: string;
+    /** order[row] = the node of that row. */
+    readonly order: U32;
+    /** The weight of every row. */
+    readonly weight: Float64Array;
+    /** The block of every row. */
+    readonly rowBlock: U32;
+    /** starts[b] = the first row of block b; starts[B] = n. */
+    readonly starts: readonly number[];
+    /** P(u, v) = min(1, factor[r][s] w_u w_v) for u in block r, v in block s. */
+    readonly factor: readonly (readonly number[])[];
+    /** The sum of the weights. */
+    readonly total: number;
+}
+/** Options of {@link chungLuGraph}. */
+export interface ChungLuOptions extends WeightOptions {
+    /** The expected degree (weight) of every node, finite and >= 0. */
+    expectedDegrees: ArrayLike<number>;
+    /** The seed, an integer in [0, 2^53); default 0. */
+    seed?: number | undefined;
+}
+/**
+ * Check Chung-Lu options and build the plan: one block, factor 1 / S.
+ * @param options - the options
+ * @returns the plan
+ */
+export declare function planChungLu(options: ChungLuOptions): ExpectedDegreePlan;
+/**
+ * Rows [start, end) of an expected-degree model (Chung-Lu, or the DC-SBM with its own plan and
+ * domain) by the skipping of Miller and Hagberg: row `row` (in block r) draws from stream
+ * (seed, domain, row) and walks blocks s = r .. B - 1 in order; inside block s it visits the later
+ * rows v (all rows of s when s > r) in row order, whose weights never increase, skipping with the
+ * previous probability p (nextSkip(detLog(1 - p)) unless p = 1) and accepting the landing v with
+ * probability q / p (one nextFloat), q = min(1, factor[r][s] w_row w_v). Edges are
+ * (order[row], order[v]) in original node indices. Concatenating consecutive row ranges gives
+ * the whole graph.
+ * @param plan - the checked options
+ * @param start - the first row
+ * @param end - one past the last row
+ * @param out - receives the edges
+ */
+export declare function chungLuRows(plan: ExpectedDegreePlan, start: number, end: number, out: EdgeBuffer): void;
+/**
+ * The Chung-Lu expected-degree graph (F. Chung and L. Lu, "The average distances in random graphs
+ * with given expected degrees", PNAS 99, 15879-15882, 2002, doi:10.1073/pnas.252631999): every
+ * pair u != v is joined independently with probability min(1, w_u w_v / S), S the weight sum, so
+ * node u's expected degree is about w_u when every w_u w_v is below S. Linear time by the skipping
+ * of J. C. Miller and A. Hagberg, "Efficient generation of networks with given expected degrees",
+ * WAW 2011, LNCS 6732, 115-126, doi:10.1007/978-3-642-21286-4_10. Rows are the nodes sorted by
+ * weight descending (ties by index ascending); row i draws from stream (seed, "chung-lu", i) (see
+ * {@link chungLuRows}). Edges are listed by row, each (row node, later node) in original indices.
+ * Simple, undirected. O(n log n + m).
+ * @param options - expectedDegrees and seed
+ * @returns the undirected graph
+ */
+export declare function chungLuGraph(options: ChungLuOptions): SampleGraph;
+/** Options of {@link degreeCorrectedSbmGraph}. */
+export interface DegreeCorrectedSbmOptions extends WeightOptions {
+    /** The size of every block; block b holds the next `sizes[b]` node indices. */
+    sizes: readonly number[];
+    /** The target degree of every node, finite and >= 0; length = the sum of sizes. */
+    expectedDegrees: ArrayLike<number>;
+    /** The mixing parameter mu in [0, 1]: the share of each node's edges that leave its block. */
+    mixing: number;
+    /** The seed, an integer in [0, 2^53); default 0. */
+    seed?: number | undefined;
+}
+/**
+ * Check DC-SBM options and build the plan.
+ * @param options - the options
+ * @returns the plan
+ */
+export declare function planDegreeCorrectedSbm(options: DegreeCorrectedSbmOptions): ExpectedDegreePlan;
+/**
+ * The degree-corrected stochastic block model (B. Karrer and M. E. J. Newman, "Stochastic
+ * blockmodels and community structure in networks", Phys. Rev. E 83, 016107, 2011,
+ * doi:10.1103/PhysRevE.83.016107), sampled as a simple graph with Bernoulli edges:
+ * P(uv) = min(1, theta_u theta_v omega_rs) with theta_u = d_u / kappa_r (kappa_r the degree total of
+ * u's block r, K the grand total), omega_rr = (1 - mu) kappa_r and omega_rs = mu kappa_r kappa_s / K
+ * for r != s. So node u's expected degree is about d_u (1 - mu kappa_r / K): the inside share is
+ * 1 - mu, but the outside share misses the mu kappa_r / K that would land in u's own block.
+ * Rows: block by block, inside a block the nodes sorted by d descending (ties by index); row i
+ * draws from stream (seed, "dcsbm", i) and walks its own block's later rows, then every later
+ * block (see {@link chungLuRows}). Edges are listed by row in original node indices. Node column
+ * `community` (u32). With one block and mu = 0 it is Chung-Lu. O(n log n + n B + m).
+ * @param options - sizes, expectedDegrees, mixing and seed
+ * @returns the undirected graph
+ */
+export declare function degreeCorrectedSbmGraph(options: DegreeCorrectedSbmOptions): SampleGraph;
+/** Options of {@link randomRegularGraph}. */
+export interface RandomRegularOptions extends WeightOptions {
+    /** The node count, >= 0. */
+    n: number;
+    /** The degree of every node, in [0, n - 1]; n d must be even. */
+    d: number;
+    /** The seed, an integer in [0, 2^53); default 0. */
+    seed?: number | undefined;
+}
+/**
+ * A uniformly-ish random d-regular simple graph by the pairing algorithm of A. Steger and
+ * N. C. Wormald, "Generating random regular graphs quickly", Combin. Probab. Comput. 8, 377-396,
+ * 1999, doi:10.1017/S0963548399003867, structured like networkx's `random_regular_graph`: attempt
+ * a (a = 0, 1, ...) draws from stream (seed, "random-regular", a); it Fisher-Yates shuffles the
+ * stub list (node i repeated d times, ascending), keeps each consecutive pair that is not a loop
+ * and not yet an edge, and re-pairs the leftover stubs (ascending node order) while some leftover
+ * pair could still be joined; otherwise it restarts. At most 100 attempts of at most 1000 rounds,
+ * then a RangeError. Edges (u, v), u < v, in lexicographic order. Expected O(n d^2) for small d.
+ * @param options - n, d and seed
+ * @returns the undirected graph
+ */
+export declare function randomRegularGraph(options: RandomRegularOptions): SampleGraph;
+export {};
+//# sourceMappingURL=degree-sequence.d.ts.map

package/dist/src/generators/degree-sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"degree-sequence.d.ts","sourceRoot":"","sources":["../../../src/generators/degree-sequence.ts"],"names":[],"mappings":"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"}