@graphty/graph-samples 0.0.1 → 0.1.2

package/dist/generators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generators.js","sources":["../src/random/log.ts","../src/random/threefry.ts","../src/random/stream.ts","../src/generators/util.ts","../src/generators/weights.ts","../src/generators/bipartite.ts","../src/generators/block-model.ts","../src/generators/classic.ts","../src/random/exp.ts","../src/generators/degree-sequence.ts","../src/generators/directed.ts","../src/generators/erdos-renyi.ts","../src/generators/flow.ts","../src/generators/geometric.ts","../src/generators/growth.ts","../src/random/trig.ts","../src/generators/hyperbolic.ts","../src/generators/lattices.ts","../src/generators/lfr.ts","../src/generators/named.ts","../src/generators/preferential-attachment.ts","../src/generators/trees-and-dags.ts","../src/generators/variants.ts"],"sourcesContent":["/**\n * A natural logarithm that returns the same bits on every JavaScript engine.\n *\n * ECMAScript leaves `Math.log` \"implementation-approximated\", so two engines may differ in the\n * last bit, and a geometric skip `floor(log(u) / log(1 - p))` that lands on an integer boundary\n * would then pick a different edge. This is a port of fdlibm's `__ieee754_log` (e_log.c, Sun\n * Microsystems 1993, the code V8 and SpiderMonkey themselves use): it reads the exponent and\n * mantissa through a little-endian DataView and otherwise uses only IEEE-754 double addition,\n * subtraction, multiplication and division, which ECMAScript requires to be correctly rounded\n * (and forbids from being fused). So the result is a pure function of the input bits.\n * Error below 1 ulp.\n */\n\nconst LN2_HI = 6.9314718036912381649e-1; // 3fe62e42 fee00000\nconst LN2_LO = 1.90821492927058770002e-10; // 3dea39ef 35793c76\nconst TWO54 = 1.8014398509481984e16; // 43500000 00000000\nconst LG1 = 6.66666666666673513e-1; // 3FE55555 55555593\nconst LG2 = 3.999999999940941908e-1; // 3FD99999 9997FA04\nconst LG3 = 2.857142874366239149e-1; // 3FD24924 94229359\nconst LG4 = 2.222219843214978396e-1; // 3FCC71C5 1D8E78AF\nconst LG5 = 1.818357216161805012e-1; // 3FC74664 96CB03DE\nconst LG6 = 1.531383769920937332e-1; // 3FC39A09 D078C69F\nconst LG7 = 1.479819860511658591e-1; // 3FC2F112 DF3E5244\n\nconst view = new DataView(new ArrayBuffer(8));\n\n/**\n * The natural logarithm of `x`, bit-identical across engines.\n * @param input - the argument\n * @returns ln(input); -Infinity for 0, NaN for negative input or NaN\n */\nexport function detLog(input: number): number {\n    let x = input;\n    view.setFloat64(0, x, true);\n    let hx = view.getInt32(4, true);\n    const lx = view.getUint32(0, true);\n\n    let k = 0;\n    if (hx < 0x00100000) {\n        if (((hx & 0x7fffffff) | lx) === 0) {\n            return -Infinity;\n        }\n        if (hx < 0) {\n            return NaN;\n        }\n        // subnormal: scale up\n        k -= 54;\n        x *= TWO54;\n        view.setFloat64(0, x, true);\n        hx = view.getInt32(4, true);\n    }\n    if (hx >= 0x7ff00000) {\n        return x + x;\n    }\n    k += (hx >> 20) - 1023;\n    hx &= 0x000fffff;\n    const i0 = (hx + 0x95f64) & 0x100000;\n    // normalize x or x/2\n    view.setInt32(4, hx | (i0 ^ 0x3ff00000), true);\n    x = view.getFloat64(0, true);\n    k += i0 >> 20;\n    const f = x - 1.0;\n    if ((0x000fffff & (2 + hx)) < 3) {\n        // |f| < 2**-20\n        if (f === 0) {\n            return k === 0 ? 0 : k * LN2_HI + k * LN2_LO;\n        }\n        const r = f * f * (0.5 - 0.3333333333333333 * f);\n        return k === 0 ? f - r : k * LN2_HI - (r - k * LN2_LO - f);\n    }\n    const s = f / (2.0 + f);\n    const dk = k;\n    const z = s * s;\n    let i = hx - 0x6147a;\n    const w = z * z;\n    const j = 0x6b851 - hx;\n    const t1 = w * (LG2 + w * (LG4 + w * LG6));\n    const t2 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));\n    i |= j;\n    const R = t2 + t1;\n    if (i > 0) {\n        const hfsq = 0.5 * f * f;\n        return k === 0 ? f - (hfsq - s * (hfsq + R)) : dk * LN2_HI - (hfsq - (s * (hfsq + R) + dk * LN2_LO) - f);\n    }\n    return k === 0 ? f - s * (f - R) : dk * LN2_HI - (s * (f - R) - dk * LN2_LO - f);\n}\n","/**\n * Threefry-2x32 with 20 rounds: the counter-based block function of J. K. Salmon, M. A. Moraes,\n * R. O. Dror and D. E. Shaw, \"Parallel random numbers: as easy as 1, 2, 3\", SC11 (2011),\n * doi:10.1145/2063384.2063405, as specified by the Random123 library and used by JAX.\n *\n * It maps a 64-bit key and a 64-bit counter to 64 random bits using only 32-bit addition,\n * rotation and xor, so JavaScript computes it exactly on every engine: no floating point, no\n * 64-bit multiply, no BigInt. It passes BigCrush with 13 rounds; 20 is Random123's default.\n */\n\n/** Rotation constants R_32x2 of Threefry-2x32 (Random123 threefry.h). */\nconst ROTATIONS = [13, 15, 26, 6, 17, 29, 16, 24] as const;\n\n/** The Skein key-schedule parity constant for 32-bit words. */\nconst KS_PARITY = 0x1bd11bda;\n\n/**\n * Encrypt one 64-bit counter under one 64-bit key.\n * @param k0 - key word 0 (unsigned 32-bit)\n * @param k1 - key word 1 (unsigned 32-bit)\n * @param c0 - counter word 0 (unsigned 32-bit)\n * @param c1 - counter word 1 (unsigned 32-bit)\n * @param out - receives the two output words\n */\nexport function threefry2x32(k0: number, k1: number, c0: number, c1: number, out: Uint32Array): void {\n    const ks0 = k0 >>> 0;\n    const ks1 = k1 >>> 0;\n    const ks2 = (KS_PARITY ^ ks0 ^ ks1) >>> 0;\n    const ks = [ks0, ks1, ks2];\n    let x0 = (c0 + ks0) | 0;\n    let x1 = (c1 + ks1) | 0;\n    for (let round = 0; round < 20; round++) {\n        x0 = (x0 + x1) | 0;\n        const r = ROTATIONS[round & 7];\n        x1 = (x1 << r) | (x1 >>> (32 - r));\n        x1 ^= x0;\n        if ((round & 3) === 3) {\n            const s = (round + 1) >>> 2;\n            x0 = (x0 + ks[s % 3]) | 0;\n            x1 = (x1 + ks[(s + 1) % 3] + s) | 0;\n        }\n    }\n    out[0] = x0;\n    out[1] = x1;\n}\n","/**\n * The one random number source of @graphty/graph-samples, and its determinism contract.\n *\n * A stream is named by `(seed, domain, block)`:\n *\n * - `seed` is the caller's seed, any safe integer in [0, 2^53).\n * - `domain` is a fixed ASCII name per generator and purpose (\"gnp\", \"sbm\", ...). It is hashed\n *   with 32-bit FNV-1a to `domainId`.\n * - `block` is a unit of work the ALGORITHM defines (a row of the adjacency matrix, a node), an\n *   integer in [0, 2^32). It never depends on how many workers or chunks run the generator.\n *\n * The stream's key is `Threefry2x32-20(key = (seed mod 2^32, floor(seed / 2^32)),\n * counter = (domainId, block))`, and its words are `Threefry2x32-20(key = streamKey,\n * counter = (i mod 2^32, floor(i / 2^32)))` for i = 0, 1, 2, ..., two words per counter, word 0\n * first. Every draw below is defined in terms of those words with integer-exact arithmetic, so the\n * same `(seed, domain, block)` yields the same values on every engine, platform and version.\n * `test/random/stream.test.ts` freezes it with golden values: changing anything here changes every\n * seeded graph, which is a breaking change of the package.\n */\n\nimport { detLog } from \"./log.js\";\nimport { threefry2x32 } from \"./threefry.js\";\n\nconst TWO_32 = 4294967296;\nconst TWO_53 = 9007199254740992;\n\n/**\n * 32-bit FNV-1a over the UTF-16 code units of `name` (the names are ASCII, so this is the bytes).\n * @param name - the domain name\n * @returns the unsigned 32-bit hash\n */\nexport function domainId(name: string): number {\n    let h = 0x811c9dc5;\n    for (let i = 0; i < name.length; i++) {\n        h ^= name.charCodeAt(i);\n        h = Math.imul(h, 0x01000193);\n    }\n    return h >>> 0;\n}\n\n/**\n * The seed every random generator uses when the caller gives none: 0. A fixed default, never the\n * clock, so an unseeded call is as reproducible as a seeded one. Frozen with the rest of the\n * contract: changing it changes every unseeded graph.\n */\nexport const DEFAULT_SEED = 0;\n\n/**\n * The caller's seed, or {@link DEFAULT_SEED} when it is undefined; throws on an invalid seed.\n * @param seed - the seed option\n * @returns the seed to use\n */\nexport function resolveSeed(seed: number | undefined): number {\n    const resolved = seed ?? DEFAULT_SEED;\n    checkSeed(resolved);\n    return resolved;\n}\n\n/**\n * Throw unless `seed` is a safe non-negative integer.\n * @param seed - the seed\n */\nexport function checkSeed(seed: number): void {\n    if (!Number.isSafeInteger(seed) || seed < 0) {\n        throw new RangeError(`seed must be an integer in [0, 2^53), got ${String(seed)}`);\n    }\n}\n\n/** A deterministic stream of random words keyed by (seed, domain, block). */\nexport class RandomStream {\n    private readonly seedLo: number;\n    private readonly seedHi: number;\n    private readonly domain: number;\n    private readonly key = new Uint32Array(2);\n    private readonly out = new Uint32Array(2);\n    private counter = 0;\n    private spare = -1;\n\n    /**\n     * The stream of one block.\n     * @param seed - the caller's seed, an integer in [0, 2^53)\n     * @param domain - the generator's fixed domain name\n     * @param block - the first block, an integer in [0, 2^32)\n     */\n    constructor(seed: number, domain: string, block: number) {\n        checkSeed(seed);\n        this.seedLo = seed >>> 0;\n        this.seedHi = Math.floor(seed / TWO_32);\n        this.domain = domainId(domain);\n        this.reset(block);\n    }\n\n    /**\n     * Restart the stream at the first word of another block of the same seed and domain.\n     * @param block - the block, an integer in [0, 2^32)\n     */\n    reset(block: number): void {\n        threefry2x32(this.seedLo, this.seedHi, this.domain, block >>> 0, this.key);\n        this.counter = 0;\n        this.spare = -1;\n    }\n\n    /**\n     * The next word.\n     * @returns an unsigned 32-bit integer\n     */\n    nextU32(): number {\n        if (this.spare >= 0) {\n            const word = this.spare;\n            this.spare = -1;\n            return word;\n        }\n        const c = this.counter++;\n        threefry2x32(this.key[0], this.key[1], c >>> 0, Math.floor(c / TWO_32), this.out);\n        this.spare = this.out[1];\n        return this.out[0];\n    }\n\n    /**\n     * A uniform double in [0, 1) with 53 random bits: (a >>> 5) * 2^26 + (b >>> 6), over 2^53,\n     * for the next two words a and b. Exact: every step is an integer below 2^53.\n     * @returns the double\n     */\n    nextFloat(): number {\n        const a = this.nextU32() >>> 5;\n        const b = this.nextU32() >>> 6;\n        return (a * 67108864 + b) / TWO_53;\n    }\n\n    /**\n     * A uniform integer in [0, n) by masked rejection: draw a word, keep its low\n     * ceil(log2 n) bits, retry while the result is >= n. Exact and unbiased; fewer than two\n     * words per call on average. For n above 2^32 the high bits come from one extra word drawn\n     * first.\n     * @param n - the bound, an integer in [1, 2^53]\n     * @returns the integer\n     */\n    nextBelow(n: number): number {\n        if (n <= TWO_32) {\n            const mask = n === 1 ? 0 : 0xffffffff >>> Math.clz32(n - 1);\n            for (;;) {\n                const x = (this.nextU32() & mask) >>> 0;\n                if (x < n) {\n                    return x;\n                }\n            }\n        }\n        const hiBound = Math.ceil(n / TWO_32);\n        const hiMask = 0xffffffff >>> Math.clz32(hiBound - 1);\n        for (;;) {\n            const hi = (this.nextU32() & hiMask) >>> 0;\n            const x = hi * TWO_32 + this.nextU32();\n            if (x < n) {\n                return x;\n            }\n        }\n    }\n\n    /**\n     * The number of failures before the next success of a Bernoulli(p) sequence, given\n     * `logQ = detLog(1 - p)` for 0 < p < 1: floor(detLog(1 - u) / logQ) for u = nextFloat().\n     * The caller handles p = 0 and p = 1 without drawing.\n     * @param logQ - detLog(1 - p), negative and finite\n     * @returns a non-negative integer (possibly above 2^53 for tiny p)\n     */\n    nextSkip(logQ: number): number {\n        return Math.floor(detLog(1 - this.nextFloat()) / logQ);\n    }\n}\n","/**\n * Shared plumbing of the generators: argument checks, the growable edge buffer and the Bernoulli\n * row sampler every G(n, p)-style generator is built on.\n */\n\nimport { MAX_COUNT, type U32 } from \"@graphty/graph-format\";\n\nimport { type RandomStream } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\n\n/**\n * Throw unless `value` is an integer in [min, max].\n * @param name - the option name, for the message\n * @param value - the value\n * @param min - the smallest allowed value\n * @param max - the largest allowed value\n */\nexport function checkInt(name: string, value: number, min: number, max: number = MAX_COUNT): void {\n    if (!Number.isInteger(value) || value < min || value > max) {\n        throw new RangeError(`${name} must be an integer in [${min}, ${max}], got ${String(value)}`);\n    }\n}\n\n/**\n * Throw unless `value` is a probability in [0, 1].\n * @param name - the option name, for the message\n * @param value - the value\n */\nexport function checkProbability(name: string, value: number): void {\n    if (!(value >= 0 && value <= 1)) {\n        throw new RangeError(`${name} must be a probability in [0, 1], got ${String(value)}`);\n    }\n}\n\n/**\n * Throw unless `count` edges fit a graph-format snapshot.\n * @param count - the edge count\n */\nexport function checkEdgeCount(count: number): void {\n    if (count > MAX_COUNT) {\n        throw new RangeError(`the graph would have ${count} edges, above the limit of ${MAX_COUNT}`);\n    }\n}\n\n/** A growable pair of Uint32Array edge endpoint arrays. */\nexport class EdgeBuffer {\n    src: U32;\n    dst: U32;\n    length = 0;\n\n    /**\n     * An empty buffer.\n     * @param capacity - the initial capacity in edges\n     */\n    constructor(capacity: number) {\n        const size = Math.max(16, Math.min(capacity, MAX_COUNT));\n        this.src = new Uint32Array(size);\n        this.dst = new Uint32Array(size);\n    }\n\n    /**\n     * Append one edge.\n     * @param u - the source index\n     * @param v - the target index\n     */\n    push(u: number, v: number): void {\n        if (this.length === this.src.length) {\n            this.grow();\n        }\n        this.src[this.length] = u;\n        this.dst[this.length] = v;\n        this.length++;\n    }\n\n    /**\n     * The edges pushed so far as exactly sized arrays (copies when the buffer has slack).\n     * @returns the endpoint arrays\n     */\n    finish(): { src: U32; dst: U32 } {\n        if (this.length === this.src.length) {\n            return { src: this.src, dst: this.dst };\n        }\n        return { src: this.src.slice(0, this.length), dst: this.dst.slice(0, this.length) };\n    }\n\n    private grow(): void {\n        checkEdgeCount(this.length + 1);\n        const size = Math.min(this.src.length * 2, MAX_COUNT);\n        const src = new Uint32Array(size);\n        const dst = new Uint32Array(size);\n        src.set(this.src);\n        dst.set(this.dst);\n        this.src = src;\n        this.dst = dst;\n    }\n}\n\n/**\n * A buffer sized for a binomial number of edges: the mean plus six standard deviations, so it\n * almost never grows.\n * @param pairs - the number of candidate pairs\n * @param p - the edge probability\n * @returns the buffer\n */\nexport function binomialBuffer(pairs: number, p: number): EdgeBuffer {\n    const mean = pairs * p;\n    checkEdgeCount(mean);\n    return new EdgeBuffer(Math.ceil(mean + 6 * Math.sqrt(mean * (1 - p)) + 16));\n}\n\n/**\n * Append (row, c) for every column c in [lo, hi) chosen independently with probability p, in\n * ascending c, by geometric skipping (V. Batagelj and U. Brandes, \"Efficient generation of large\n * random networks\", Phys. Rev. E 71, 036113, 2005): O(1 + selected) draws instead of hi - lo.\n * p = 0 and p = 1 draw nothing.\n * @param stream - the row's stream\n * @param p - the probability\n * @param logQ - detLog(1 - p)\n * @param row - the row node, written as the source\n * @param lo - the first candidate column\n * @param hi - one past the last candidate column\n * @param out - the buffer\n */\nexport function bernoulliSegment(\n    stream: RandomStream,\n    p: number,\n    logQ: number,\n    row: number,\n    lo: number,\n    hi: number,\n    out: EdgeBuffer,\n): void {\n    if (p === 0 || lo >= hi) {\n        return;\n    }\n    if (p === 1) {\n        for (let c = lo; c < hi; c++) {\n            out.push(row, c);\n        }\n        return;\n    }\n    let c = lo + stream.nextSkip(logQ);\n    while (c < hi) {\n        out.push(row, c);\n        c += 1 + stream.nextSkip(logQ);\n    }\n}\n\n/**\n * Assemble an undirected or directed SampleGraph from a buffer.\n * @param nodeCount - the node count\n * @param edges - the edges\n * @param directed - whether the graph is directed\n * @param nodeColumns - ground-truth columns, if any\n * @returns the graph\n */\nexport function toGraph(\n    nodeCount: number,\n    edges: EdgeBuffer,\n    directed: boolean,\n    nodeColumns?: SampleGraph[\"nodeColumns\"],\n): SampleGraph {\n    const { src, dst } = edges.finish();\n    return nodeColumns === undefined\n        ? { directed, nodeCount, src, dst }\n        : { directed, nodeCount, src, dst, nodeColumns };\n}\n","/**\n * Edge weights for any graph: the `weights` option every generator takes, and `withWeights` for a\n * graph that already exists (a dataset, a hand-built graph).\n */\n\nimport { type TypedArrayData } from \"@graphty/graph-format\";\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\n\n/** How to combine the two endpoint values of a node column into an edge weight. */\nexport type ColumnCombine = \"source\" | \"target\" | \"sum\" | \"mean\" | \"product\" | \"min\" | \"max\" | \"difference\";\n\n/**\n * A weight distribution. Random kinds draw one value per edge, in edge order, from stream\n * (seed, \"weights\", 0).\n *\n * - `uniform`: a real in [min, max) (default [0, 1)).\n * - `integer`: an integer in [min, max], both ends included -- capacities, Dijkstra demos.\n * - `exponential`: -mean ln(1 - u), mean default 1.\n * - `euclidean`: the distance between the endpoints' `x`, `y` (and `z`, when present) node columns;\n *   for the generators that emit positions.\n * - `column`: from a numeric node column: the source's value, the target's, their sum, mean,\n *   product, min, max, or the absolute difference.\n */\nexport type WeightSpec =\n    | { readonly kind: \"uniform\"; readonly min?: number | undefined; readonly max?: number | undefined }\n    | { readonly kind: \"integer\"; readonly min: number; readonly max: number }\n    | { readonly kind: \"exponential\"; readonly mean?: number | undefined }\n    | { readonly kind: \"euclidean\" }\n    | { readonly kind: \"column\"; readonly column: string; readonly combine?: ColumnCombine | undefined };\n\n/** The options every generator accepts on top of its own. */\nexport interface WeightOptions {\n    /** Give every edge a weight from this distribution; absent means unweighted. */\n    weights?: WeightSpec | undefined;\n    /**\n     * The seed of the weight draws, an integer in [0, 2^53); default 0. Random generators share it\n     * with their structure (the weights use their own stream domain, so adding weights never changes\n     * the edges).\n     */\n    seed?: number | undefined;\n}\n\n/**\n * A numeric node column of the graph, or a RangeError naming it.\n * @param graph - the graph\n * @param name - the column name\n * @returns the column's values\n */\nfunction numericColumn(graph: SampleGraph, name: string): TypedArrayData {\n    const column = graph.nodeColumns?.[name];\n    if (column === undefined || !ArrayBuffer.isView(column)) {\n        throw new RangeError(`weights: the graph has no numeric node column \"${name}\"`);\n    }\n    return column;\n}\n\n/**\n * The weight of every edge under `spec`.\n * @param graph - the graph\n * @param spec - the distribution\n * @param seed - the seed (already resolved)\n * @returns one weight per edge\n */\nfunction drawWeights(graph: SampleGraph, spec: WeightSpec, seed: number): Float32Array<ArrayBuffer> {\n    const m = graph.src.length;\n    const out = new Float32Array(m);\n    const { src, dst } = graph;\n    const stream = new RandomStream(seed, \"weights\", 0);\n    switch (spec.kind) {\n        case \"uniform\": {\n            const min = spec.min ?? 0;\n            const max = spec.max ?? 1;\n            if (!(Number.isFinite(min) && Number.isFinite(max) && min <= max)) {\n                throw new RangeError(`weights: uniform needs finite min <= max, got ${min} and ${max}`);\n            }\n            for (let e = 0; e < m; e++) {\n                out[e] = min + (max - min) * stream.nextFloat();\n            }\n            break;\n        }\n        case \"integer\": {\n            const { min, max } = spec;\n            if (!(Number.isSafeInteger(min) && Number.isSafeInteger(max) && min <= max)) {\n                throw new RangeError(`weights: integer needs integers min <= max, got ${min} and ${max}`);\n            }\n            for (let e = 0; e < m; e++) {\n                out[e] = min + stream.nextBelow(max - min + 1);\n            }\n            break;\n        }\n        case \"exponential\": {\n            const mean = spec.mean ?? 1;\n            if (!(mean > 0 && Number.isFinite(mean))) {\n                throw new RangeError(`weights: exponential needs a positive mean, got ${mean}`);\n            }\n            for (let e = 0; e < m; e++) {\n                out[e] = -mean * detLog(1 - stream.nextFloat());\n            }\n            break;\n        }\n        case \"euclidean\": {\n            const x = numericColumn(graph, \"x\");\n            const y = numericColumn(graph, \"y\");\n            const z = graph.nodeColumns?.z === undefined ? null : numericColumn(graph, \"z\");\n            for (let e = 0; e < m; e++) {\n                const dx = x[src[e]] - x[dst[e]];\n                const dy = y[src[e]] - y[dst[e]];\n                const dz = z === null ? 0 : z[src[e]] - z[dst[e]];\n                out[e] = Math.sqrt(dx * dx + dy * dy + dz * dz);\n            }\n            break;\n        }\n        default: {\n            const values = numericColumn(graph, spec.column);\n            const combine = spec.combine ?? \"sum\";\n            for (let e = 0; e < m; e++) {\n                const a = values[src[e]];\n                const b = values[dst[e]];\n                out[e] = combineValues(combine, a, b);\n            }\n        }\n    }\n    return out;\n}\n\n/**\n * Combine two endpoint values.\n * @param combine - the rule\n * @param a - the source value\n * @param b - the target value\n * @returns the weight\n */\nfunction combineValues(combine: ColumnCombine, a: number, b: number): number {\n    switch (combine) {\n        case \"source\":\n            return a;\n        case \"target\":\n            return b;\n        case \"sum\":\n            return a + b;\n        case \"mean\":\n            return (a + b) / 2;\n        case \"product\":\n            return a * b;\n        case \"min\":\n            return Math.min(a, b);\n        case \"max\":\n            return Math.max(a, b);\n        default:\n            return Math.abs(a - b);\n    }\n}\n\n/**\n * A copy of `graph` (sharing its arrays) with edge weights drawn from `spec`. Any graph works: a\n * generator's output, a dataset, a hand-built SampleGraph. Existing weights are replaced.\n * @param graph - the graph\n * @param spec - the distribution\n * @param seed - the seed of the draws, default 0\n * @returns the weighted graph\n */\nexport function withWeights(graph: SampleGraph, spec: WeightSpec, seed?: number): SampleGraph {\n    return { ...graph, weights: drawWeights(graph, spec, resolveSeed(seed)) };\n}\n\n/**\n * Apply the common `weights` option, if set: the last step of every generator.\n * @param graph - the generated graph\n * @param options - the generator's options\n * @returns the graph, weighted when asked\n */\nexport function applyWeights(graph: SampleGraph, options: WeightOptions): SampleGraph {\n    return options.weights === undefined ? graph : withWeights(graph, options.weights, options.seed);\n}\n","/**\n * The random bipartite graph G(n1, n2, p), optionally with a planted perfect matching.\n */\n\nimport { type U32 } from \"@graphty/graph-format\";\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { binomialBuffer, checkInt, checkProbability, type EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** Options of {@link randomBipartiteGraph}. */\nexport interface RandomBipartiteOptions extends WeightOptions {\n    /** The left side's size, >= 0. */\n    n1: number;\n    /** The right side's size, >= 0. */\n    n2: number;\n    /** The probability of each left-right pair, in [0, 1]. */\n    p: number;\n    /**\n     * Plant a perfect matching: left node i is always joined to right node `matching[i]` of a\n     * uniformly random permutation, so a perfect matching is guaranteed. Needs n1 === n2.\n     */\n    perfectMatching?: boolean | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The planted matching: a Fisher-Yates shuffle of 0 .. n - 1 from stream (seed,\n * \"bipartite-matching\", 0), drawing nextBelow(i + 1) for i = n - 1 down to 1.\n * @param n - the side size\n * @param seed - the seed\n * @returns match[i] = the right-side offset joined to left node i\n */\nexport function plantedMatching(n: number, seed: number): U32 {\n    const stream = new RandomStream(seed, \"bipartite-matching\", 0);\n    const match = new Uint32Array(n);\n    for (let i = 0; i < n; i++) {\n        match[i] = i;\n    }\n    for (let i = n - 1; i > 0; i--) {\n        const j = stream.nextBelow(i + 1);\n        const t = match[i];\n        match[i] = match[j];\n        match[j] = t;\n    }\n    return match;\n}\n\n/**\n * Rows [start, end) of the bipartite graph: left node u draws from stream (seed, \"bipartite\", u)\n * and holds (u, n1 + j) for the chosen right offsets j in ascending order, with the planted match\n * merged in at its place (never twice).\n * @param options - the checked options\n * @param match - the planted matching, or null\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the edges\n */\nexport function bipartiteRows(\n    options: RandomBipartiteOptions,\n    match: U32 | null,\n    start: number,\n    end: number,\n    out: EdgeBuffer,\n): void {\n    const { n1, n2, p } = options;\n    const seed = resolveSeed(options.seed);\n    const logQ = detLog(1 - p);\n    const stream = new RandomStream(seed, \"bipartite\", 0);\n    for (let u = start; u < end; u++) {\n        stream.reset(u);\n        let pending = match === null ? -1 : match[u];\n        const emit = (j: number): void => {\n            if (pending >= 0 && pending < j) {\n                out.push(u, n1 + pending);\n            }\n            if (pending >= 0 && pending <= j) {\n                pending = -1;\n            }\n            out.push(u, n1 + j);\n        };\n        if (p === 1) {\n            for (let j = 0; j < n2; j++) {\n                emit(j);\n            }\n        } else if (p > 0) {\n            let j = stream.nextSkip(logQ);\n            while (j < n2) {\n                emit(j);\n                j += 1 + stream.nextSkip(logQ);\n            }\n        }\n        if (pending >= 0) {\n            out.push(u, n1 + pending);\n        }\n    }\n}\n\n/**\n * The random bipartite graph G(n1, n2, p) in O(n + m): left nodes 0 .. n1 - 1, right nodes\n * n1 .. n1 + n2 - 1, each left-right pair independently with probability p; edges row by row from\n * the left side, right ends ascending. Node column `side` (u8): 0 left, 1 right.\n * @param options - n1, n2, p, perfectMatching and seed\n * @returns the undirected graph\n */\nexport function randomBipartiteGraph(options: RandomBipartiteOptions): SampleGraph {\n    const { n1, n2, p } = options;\n    checkInt(\"n1\", n1, 0);\n    checkInt(\"n2\", n2, 0);\n    checkInt(\"n1 + n2\", n1 + n2, 0);\n    checkProbability(\"p\", p);\n    const seed = resolveSeed(options.seed);\n    let match: U32 | null = null;\n    if (options.perfectMatching === true) {\n        if (n1 !== n2) {\n            throw new RangeError(`perfectMatching needs n1 === n2, got ${n1} and ${n2}`);\n        }\n        match = plantedMatching(n1, seed);\n    }\n    const out = binomialBuffer(n1 * n2, p);\n    bipartiteRows(options, match, 0, n1, out);\n    const side = new Uint8Array(n1 + n2).fill(1, n1);\n    return applyWeights(toGraph(n1 + n2, out, false, { side }), options);\n}\n","/**\n * Stochastic block models (P. W. Holland, K. B. Laskey and S. Leinhardt, \"Stochastic blockmodels:\n * first steps\", Social Networks 5, 109-137, 1983) and the planted partition model (A. Condon and\n * R. M. Karp, Random Structures and Algorithms 18, 116-140, 2001), with the planted blocks emitted\n * as ground truth.\n */\n\nimport { type U32 } from \"@graphty/graph-format\";\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { bernoulliSegment, binomialBuffer, checkInt, checkProbability, type EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** Options of {@link stochasticBlockModelGraph}. */\nexport interface StochasticBlockModelOptions extends WeightOptions {\n    /** The size of every block; block b holds the next `sizes[b]` node indices. */\n    sizes: readonly number[];\n    /** The symmetric B x B matrix of edge probabilities between blocks. */\n    probabilities: readonly (readonly number[])[];\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/** The checked and precomputed form of the options. */\ninterface BlockPlan {\n    readonly n: number;\n    readonly seed: number;\n    /** starts[b] = first node of block b; starts[B] = n. */\n    readonly starts: readonly number[];\n    readonly block: U32;\n    readonly p: readonly (readonly number[])[];\n    readonly logQ: readonly (readonly number[])[];\n}\n\n/**\n * Check the options and precompute block boundaries and detLog(1 - p).\n * @param options - the options\n * @returns the plan\n */\nexport function planBlocks(options: StochasticBlockModelOptions): BlockPlan {\n    const { sizes, probabilities } = options;\n    const seed = resolveSeed(options.seed);\n    const count = sizes.length;\n    checkInt(\"sizes.length\", count, 1);\n    if (probabilities.length !== count) {\n        throw new RangeError(`probabilities must be ${count} x ${count}`);\n    }\n    const starts = [0];\n    for (let b = 0; b < count; b++) {\n        checkInt(`sizes[${b}]`, sizes[b], 0);\n        starts.push(starts[b] + sizes[b]);\n        if (probabilities[b].length !== count) {\n            throw new RangeError(`probabilities must be ${count} x ${count}`);\n        }\n        for (let c = 0; c < count; c++) {\n            checkProbability(`probabilities[${b}][${c}]`, probabilities[b][c]);\n            if (probabilities[b][c] !== probabilities[c][b]) {\n                throw new RangeError(`probabilities must be symmetric: [${b}][${c}] differs from [${c}][${b}]`);\n            }\n        }\n    }\n    const n = starts[count];\n    checkInt(\"the total size\", n, 0);\n    const block = new Uint32Array(n);\n    for (let b = 0; b < count; b++) {\n        block.fill(b, starts[b], starts[b + 1]);\n    }\n    return {\n        n,\n        seed,\n        starts,\n        block,\n        p: probabilities,\n        logQ: probabilities.map((row) => row.map((p) => detLog(1 - p))),\n    };\n}\n\n/**\n * Rows [start, end) of the block model: row u (in block b) draws from stream (seed, \"sbm\", u) and\n * walks blocks c = b .. B - 1 in order, holding the pairs (u, v) for v > u in block c with\n * probability p[b][c], ascending v. Concatenating consecutive row ranges gives the whole graph.\n * @param plan - the checked options\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the edges\n */\nexport function blockModelRows(plan: BlockPlan, start: number, end: number, out: EdgeBuffer): void {\n    const { starts, block, p, logQ } = plan;\n    const stream = new RandomStream(plan.seed, \"sbm\", 0);\n    const count = starts.length - 1;\n    for (let u = start; u < end; u++) {\n        stream.reset(u);\n        const b = block[u];\n        // ponytail: O(B) per row, fine to n * B ~ 1e8; iterate only non-zero blocks if B grows large\n        for (let c = b; c < count; c++) {\n            bernoulliSegment(stream, p[b][c], logQ[b][c], u, c === b ? u + 1 : starts[c], starts[c + 1], out);\n        }\n    }\n}\n\n/**\n * The stochastic block model in O(n B + m): node pairs are joined independently with the\n * probability of their blocks, by geometric skipping inside each row's block segments. Edges are\n * the pairs (u, v), u < v, row-major. Node column `community` (u32): the block.\n * @param options - sizes, probabilities and seed\n * @returns the undirected graph\n */\nexport function stochasticBlockModelGraph(options: StochasticBlockModelOptions): SampleGraph {\n    const plan = planBlocks(options);\n    let expected = 0;\n    let pairs = 0;\n    for (let b = 0; b < plan.starts.length - 1; b++) {\n        for (let c = b; c < plan.starts.length - 1; c++) {\n            const sb = plan.starts[b + 1] - plan.starts[b];\n            const sc = plan.starts[c + 1] - plan.starts[c];\n            const blockPairs = b === c ? (sb * (sb - 1)) / 2 : sb * sc;\n            expected += blockPairs * plan.p[b][c];\n            pairs += blockPairs;\n        }\n    }\n    const out = binomialBuffer(pairs, pairs === 0 ? 0 : expected / pairs);\n    blockModelRows(plan, 0, plan.n, out);\n    return applyWeights(toGraph(plan.n, out, false, { community: plan.block }), options);\n}\n\n/** Options of {@link plantedPartitionGraph}. */\nexport interface PlantedPartitionOptions extends WeightOptions {\n    /** The number of groups, >= 1. */\n    groups: number;\n    /** The size of every group, >= 1. */\n    groupSize: number;\n    /** The edge probability inside a group. */\n    pIn: number;\n    /** The edge probability between groups. */\n    pOut: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The planted partition model: `groups` equal blocks, `pIn` inside, `pOut` between. Exactly the\n * stochastic block model with that matrix (same seed, same graph). Node column `community` (u32).\n * @param options - groups, groupSize, pIn, pOut and seed\n * @returns the undirected graph\n */\nexport function plantedPartitionGraph(options: PlantedPartitionOptions): SampleGraph {\n    const { groups, groupSize, pIn, pOut, seed } = options;\n    checkInt(\"groups\", groups, 1);\n    checkInt(\"groupSize\", groupSize, 1);\n    return stochasticBlockModelGraph({\n        sizes: new Array<number>(groups).fill(groupSize),\n        probabilities: Array.from({ length: groups }, (_, b) =>\n            Array.from({ length: groups }, (_2, c) => (b === c ? pIn : pOut)),\n        ),\n        seed,\n        weights: options.weights,\n    });\n}\n","/**\n * The deterministic families: no seed, closed-form structure, O(n + m). Every function returns an\n * undirected simple graph whose node order and edge order are part of its contract (stated in each\n * JSDoc), so an index means the same node in every version.\n */\n\nimport { type U32 } from \"@graphty/graph-format\";\n\nimport { type SampleGraph } from \"../types.js\";\nimport { checkEdgeCount, checkInt, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/**\n * Append every pair (lo + i, lo + j), i < j, of the clique on [lo, lo + size), row-major.\n * @param out - the buffer\n * @param lo - the first node\n * @param size - the clique size\n */\nfunction pushClique(out: EdgeBuffer, lo: number, size: number): void {\n    for (let i = lo; i < lo + size; i++) {\n        for (let j = i + 1; j < lo + size; j++) {\n            out.push(i, j);\n        }\n    }\n}\n\n/**\n * The path P_n: edges (i, i + 1) for i = 0 .. n - 2.\n * @param options - the options\n * @param options.n - the node count, >= 0\n * @returns the graph\n */\nexport function pathGraph(options: { n: number } & WeightOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 0);\n    const out = new EdgeBuffer(n);\n    for (let i = 0; i + 1 < n; i++) {\n        out.push(i, i + 1);\n    }\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/**\n * The cycle C_n: the path P_n plus the edge (n - 1, 0).\n * @param options - the options\n * @param options.n - the node count, >= 3\n * @returns the graph\n */\nexport function cycleGraph(options: { n: number } & WeightOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 3);\n    const out = new EdgeBuffer(n);\n    for (let i = 0; i + 1 < n; i++) {\n        out.push(i, i + 1);\n    }\n    out.push(n - 1, 0);\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/**\n * The star: hub 0 joined to every other node, edges (0, i) for i = 1 .. n - 1.\n * @param options - the options\n * @param options.n - the node count including the hub, >= 1\n * @returns the graph\n */\nexport function starGraph(options: { n: number } & WeightOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 1);\n    const out = new EdgeBuffer(n);\n    for (let i = 1; i < n; i++) {\n        out.push(0, i);\n    }\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/**\n * The wheel W_n: the star's spokes (0, i), then the rim (i, i + 1) for i = 1 .. n - 2, then\n * (n - 1, 1).\n * @param options - the options\n * @param options.n - the node count including the hub, >= 4\n * @returns the graph\n */\nexport function wheelGraph(options: { n: number } & WeightOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 4);\n    const out = new EdgeBuffer(2 * n);\n    for (let i = 1; i < n; i++) {\n        out.push(0, i);\n    }\n    for (let i = 1; i + 1 < n; i++) {\n        out.push(i, i + 1);\n    }\n    out.push(n - 1, 1);\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/**\n * The complete graph K_n: every pair (i, j), i < j, row-major.\n * @param options - the options\n * @param options.n - the node count, >= 0\n * @returns the graph\n */\nexport function completeGraph(options: { n: number } & WeightOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 0);\n    const m = (n * (n - 1)) / 2;\n    checkEdgeCount(m);\n    const out = new EdgeBuffer(m);\n    pushClique(out, 0, n);\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/**\n * The complete bipartite graph K_{a,b}: left nodes 0 .. a - 1, right nodes a .. a + b - 1, every\n * pair (i, a + j), row-major. Node column `side` (u8): 0 left, 1 right.\n * @param options - the options\n * @param options.a - the left side's size, >= 0\n * @param options.b - the right side's size, >= 0\n * @returns the graph\n */\nexport function completeBipartiteGraph(options: { a: number; b: number } & WeightOptions): SampleGraph {\n    const { a, b } = options;\n    checkInt(\"a\", a, 0);\n    checkInt(\"b\", b, 0);\n    checkInt(\"a + b\", a + b, 0);\n    checkEdgeCount(a * b);\n    const out = new EdgeBuffer(a * b);\n    for (let i = 0; i < a; i++) {\n        for (let j = 0; j < b; j++) {\n            out.push(i, a + j);\n        }\n    }\n    const side = new Uint8Array(a + b).fill(1, a);\n    return applyWeights(toGraph(a + b, out, false, { side }), options);\n}\n\n/**\n * The hypercube Q_d: nodes are the d-bit integers, edges join integers one bit apart; for each node\n * i in order and each bit b ascending that is 0 in i, the edge (i, i | 2^b).\n * @param options - the options\n * @param options.dimension - d, in [0, 26]\n * @returns the graph\n */\nexport function hypercubeGraph(options: { dimension: number } & WeightOptions): SampleGraph {\n    const { dimension } = options;\n    checkInt(\"dimension\", dimension, 0, 26);\n    const n = 2 ** dimension;\n    const out = new EdgeBuffer((dimension * n) / 2);\n    for (let i = 0; i < n; i++) {\n        for (let b = 0; b < dimension; b++) {\n            const j = i | (1 << b);\n            if (j !== i) {\n                out.push(i, j);\n            }\n        }\n    }\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/**\n * The ladder L_n: two paths 0 .. n - 1 and n .. 2n - 1, then the rungs (i, n + i).\n * @param options - the options\n * @param options.n - the number of rungs, >= 1\n * @returns the graph\n */\nexport function ladderGraph(options: { n: number } & WeightOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 1);\n    checkInt(\"2n\", 2 * n, 2);\n    return applyWeights(toGraph(2 * n, ladderEdges(n), false), options);\n}\n\n/**\n * The barbell: a clique on 0 .. m1 - 1, the path m1 - 1, m1, .., m1 + m2 (m2 path nodes plus the\n * two joining edges' ends), and a clique on m1 + m2 .. 2 m1 + m2 - 1. Edge order: left clique, path,\n * right clique.\n * @param options - the options\n * @param options.cliqueSize - m1, each bell's size, >= 2\n * @param options.pathLength - m2, the number of nodes on the bar, >= 0\n * @returns the graph\n */\nexport function barbellGraph(options: { cliqueSize: number; pathLength: number } & WeightOptions): SampleGraph {\n    const { cliqueSize: m1, pathLength: m2 } = options;\n    checkInt(\"cliqueSize\", m1, 2);\n    checkInt(\"pathLength\", m2, 0);\n    const n = 2 * m1 + m2;\n    checkInt(\"2 * cliqueSize + pathLength\", n, 4);\n    checkEdgeCount(m1 * (m1 - 1) + m2 + 1);\n    const out = new EdgeBuffer(m1 * (m1 - 1) + m2 + 1);\n    pushClique(out, 0, m1);\n    for (let i = m1 - 1; i < m1 + m2; i++) {\n        out.push(i, i + 1);\n    }\n    pushClique(out, m1 + m2, m1);\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/**\n * The lollipop: a clique on 0 .. m - 1 and a tail path m - 1, m, .., m + n - 1.\n * @param options - the options\n * @param options.cliqueSize - m, >= 2\n * @param options.pathLength - n, the number of tail nodes, >= 0\n * @returns the graph\n */\nexport function lollipopGraph(options: { cliqueSize: number; pathLength: number } & WeightOptions): SampleGraph {\n    const { cliqueSize: m, pathLength } = options;\n    checkInt(\"cliqueSize\", m, 2);\n    checkInt(\"pathLength\", pathLength, 0);\n    checkInt(\"cliqueSize + pathLength\", m + pathLength, 2);\n    checkEdgeCount((m * (m - 1)) / 2 + pathLength);\n    const out = new EdgeBuffer((m * (m - 1)) / 2 + pathLength);\n    pushClique(out, 0, m);\n    for (let i = m - 1; i + 1 < m + pathLength; i++) {\n        out.push(i, i + 1);\n    }\n    return applyWeights(toGraph(m + pathLength, out, false), options);\n}\n\n/**\n * Community labels for `cliques` consecutive groups of `size` nodes.\n * @param cliques - the number of groups\n * @param size - the group size\n * @returns the u32 labels\n */\nfunction groupLabels(cliques: number, size: number): U32 {\n    const community = new Uint32Array(cliques * size);\n    for (let g = 0; g < cliques; g++) {\n        community.fill(g, g * size, (g + 1) * size);\n    }\n    return community;\n}\n\n/**\n * The caveman graph (Watts 1999): `cliques` disjoint cliques of `size` nodes, clique g on\n * g * size .. (g + 1) * size - 1. Node column `community` (u32): the clique.\n * @param options - the options\n * @param options.cliques - the number of cliques, >= 1\n * @param options.size - the clique size, >= 1\n * @returns the graph\n */\nexport function cavemanGraph(options: { cliques: number; size: number } & WeightOptions): SampleGraph {\n    const { cliques, size } = options;\n    checkInt(\"cliques\", cliques, 1);\n    checkInt(\"size\", size, 1);\n    const n = cliques * size;\n    checkInt(\"cliques * size\", n, 1);\n    checkEdgeCount((n * (size - 1)) / 2);\n    const out = new EdgeBuffer((n * (size - 1)) / 2);\n    for (let g = 0; g < cliques; g++) {\n        pushClique(out, g * size, size);\n    }\n    return applyWeights(toGraph(n, out, false, { community: groupLabels(cliques, size) }), options);\n}\n\n/**\n * The connected caveman graph (Watts 1999, as networkx builds it): the caveman graph with, in each\n * clique starting at s, the edge (s, s + 1) replaced in place by (s, s - 1 mod n), which joins the\n * cliques into a ring. Node column `community` (u32): the clique.\n * @param options - the options\n * @param options.cliques - the number of cliques, >= 2\n * @param options.size - the clique size, >= 2\n * @returns the graph\n */\nexport function connectedCavemanGraph(options: { cliques: number; size: number } & WeightOptions): SampleGraph {\n    const { cliques, size } = options;\n    checkInt(\"cliques\", cliques, 2);\n    checkInt(\"size\", size, 2);\n    const n = cliques * size;\n    checkInt(\"cliques * size\", n, 4);\n    checkEdgeCount((n * (size - 1)) / 2);\n    const out = new EdgeBuffer((n * (size - 1)) / 2);\n    for (let g = 0; g < cliques; g++) {\n        const s = g * size;\n        for (let i = s; i < s + size; i++) {\n            for (let j = i + 1; j < s + size; j++) {\n                if (i === s && j === s + 1) {\n                    out.push(s, (s - 1 + n) % n);\n                } else {\n                    out.push(i, j);\n                }\n            }\n        }\n    }\n    return applyWeights(toGraph(n, out, false, { community: groupLabels(cliques, size) }), options);\n}\n\n/**\n * The balanced r-ary tree of height h, numbered breadth first: node i's children are\n * r i + 1 .. r i + r; edges (parent(c), c) for c = 1 .. n - 1.\n * @param options - the options\n * @param options.branching - r, >= 1\n * @param options.height - h, >= 0 (a single root at 0)\n * @returns the graph\n */\nexport function balancedTreeGraph(options: { branching: number; height: number } & WeightOptions): SampleGraph {\n    const { branching: r, height: h } = options;\n    checkInt(\"branching\", r, 1);\n    checkInt(\"height\", h, 0);\n    let n = 0;\n    let level = 1;\n    for (let d = 0; d <= h; d++) {\n        n += level;\n        level *= r;\n        checkInt(\"node count\", n, 1);\n    }\n    const out = new EdgeBuffer(n);\n    for (let c = 1; c < n; c++) {\n        out.push(Math.floor((c - 1) / r), c);\n    }\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/**\n * The Petersen graph: outer cycle 0 .. 4, spokes (i, i + 5), inner pentagram (5 + i, 5 + (i + 2) mod 5).\n * 3-regular, girth 5, non-planar.\n * @param options - the common weight options\n * @returns the graph\n */\nexport function petersenGraph(options: WeightOptions = {}): SampleGraph {\n    const out = new EdgeBuffer(15);\n    for (let i = 0; i < 5; i++) {\n        out.push(i, (i + 1) % 5);\n    }\n    for (let i = 0; i < 5; i++) {\n        out.push(i, i + 5);\n    }\n    for (let i = 0; i < 5; i++) {\n        out.push(5 + i, 5 + ((i + 2) % 5));\n    }\n    return applyWeights(toGraph(10, out, false), options);\n}\n\n/**\n * The empty graph: n isolated nodes, no edges.\n * @param options - the options\n * @param options.n - the node count, >= 0\n * @returns the graph\n */\nexport function emptyGraph(options: { n: number } & WeightOptions): SampleGraph {\n    checkInt(\"n\", options.n, 0);\n    return applyWeights(toGraph(options.n, new EdgeBuffer(0), false), options);\n}\n\n/**\n * The complete multipartite graph K_{s0, s1, ...}: part p holds the next `sizes[p]` node indices,\n * and every pair of nodes in different parts is joined; for each node in index order, the edges to\n * every later node of a later part, ascending. Node column `part` (u32).\n * @param options - the options\n * @param options.sizes - the part sizes, each >= 0\n * @returns the graph\n */\nexport function completeMultipartiteGraph(options: { sizes: readonly number[] } & WeightOptions): SampleGraph {\n    const { sizes } = options;\n    const starts = [0];\n    for (let p = 0; p < sizes.length; p++) {\n        checkInt(`sizes[${p}]`, sizes[p], 0);\n        starts.push(starts[p] + sizes[p]);\n    }\n    const n = starts[sizes.length];\n    checkInt(\"the total size\", n, 0);\n    let m = (n * (n - 1)) / 2;\n    for (const size of sizes) {\n        m -= (size * (size - 1)) / 2;\n    }\n    checkEdgeCount(m);\n    const part = new Uint32Array(n);\n    for (let p = 0; p < sizes.length; p++) {\n        part.fill(p, starts[p], starts[p + 1]);\n    }\n    const out = new EdgeBuffer(m);\n    for (let u = 0; u < n; u++) {\n        for (let v = starts[part[u] + 1]; v < n; v++) {\n            out.push(u, v);\n        }\n    }\n    return applyWeights(toGraph(n, out, false, { part }), options);\n}\n\n/**\n * The circular ladder CL_n (the n-prism): the ladder's rails 0 .. n - 1 and n .. 2n - 1 and rungs\n * (i, n + i), as {@link ladderGraph} lists them, then the closing edges (n - 1, 0) and\n * (2n - 1, n). 3-regular and planar.\n * @param options - the options\n * @param options.n - the number of rungs, >= 3\n * @returns the graph\n */\nexport function circularLadderGraph(options: { n: number } & WeightOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 3);\n    checkEdgeCount(3 * n);\n    const out = ladderEdges(n);\n    out.push(n - 1, 0);\n    out.push(2 * n - 1, n);\n    return applyWeights(toGraph(2 * n, out, false), options);\n}\n\n/**\n * The Moebius ladder M_{2n}: the cycle 0 .. 2n - 1 (edges (i, i + 1), then (2n - 1, 0)) and the n\n * chords (i, i + n). 3-regular and, unlike the circular ladder, not planar for n >= 3.\n * @param options - the options\n * @param options.n - the number of rungs, >= 3\n * @returns the graph\n */\nexport function mobiusLadderGraph(options: { n: number } & WeightOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 3);\n    checkEdgeCount(3 * n);\n    const out = new EdgeBuffer(3 * n);\n    for (let i = 0; i + 1 < 2 * n; i++) {\n        out.push(i, i + 1);\n    }\n    out.push(2 * n - 1, 0);\n    for (let i = 0; i < n; i++) {\n        out.push(i, i + n);\n    }\n    return applyWeights(toGraph(2 * n, out, false), options);\n}\n\n/**\n * The ladder's edges: two rails 0 .. n - 1 and n .. 2n - 1, then the rungs (i, n + i).\n * @param n - the number of rungs\n * @returns the buffer\n */\nfunction ladderEdges(n: number): EdgeBuffer {\n    const out = new EdgeBuffer(3 * n);\n    for (let side = 0; side < 2; side++) {\n        for (let i = 0; i + 1 < n; i++) {\n            out.push(side * n + i, side * n + i + 1);\n        }\n    }\n    for (let i = 0; i < n; i++) {\n        out.push(i, n + i);\n    }\n    return out;\n}\n\n/**\n * The ring of cliques, as networkx's `ring_of_cliques`: for each clique i in order, its edges\n * (row-major), then the ring edge (i size + 1, (i + 1) size mod n). The standard example of\n * modularity's resolution limit (Fortunato and Barthelemy, PNAS 104:36-41, 2007,\n * doi:10.1073/pnas.0605965104). Node column `community` (u32): the clique.\n * @param options - the options\n * @param options.cliques - the number of cliques, >= 2\n * @param options.size - the clique size, >= 2\n * @returns the graph\n */\nexport function ringOfCliquesGraph(options: { cliques: number; size: number } & WeightOptions): SampleGraph {\n    const { cliques, size } = options;\n    checkInt(\"cliques\", cliques, 2);\n    checkInt(\"size\", size, 2);\n    const n = cliques * size;\n    checkInt(\"cliques * size\", n, 4);\n    const m = (n * (size - 1)) / 2 + cliques;\n    checkEdgeCount(m);\n    const out = new EdgeBuffer(m);\n    for (let g = 0; g < cliques; g++) {\n        pushClique(out, g * size, size);\n        out.push(g * size + 1, ((g + 1) * size) % n);\n    }\n    return applyWeights(toGraph(n, out, false, { community: groupLabels(cliques, size) }), options);\n}\n","/**\n * An exponential and the power functions built on it, returning the same bits on every JavaScript\n * engine: a port of fdlibm's `__ieee754_exp` (e_exp.c, Sun Microsystems 1993), for the same reason\n * and with the same technique as `detLog` in log.ts -- the exponent is read and written through a\n * little-endian DataView and everything else is IEEE-754 double addition, subtraction,\n * multiplication and division, which ECMAScript requires to be correctly rounded. Error below 1 ulp.\n */\n\nimport { detLog } from \"./log.js\";\n\nconst O_THRESHOLD = 7.09782712893383973096e2;\nconst U_THRESHOLD = -7.45133219101941108420e2;\nconst LN2_HI = 6.93147180369123816490e-1;\nconst LN2_LO = 1.90821492927058770002e-10;\nconst INV_LN2 = 1.44269504088896338700;\nconst TWOM1000 = 9.33263618503218878990e-302;\nconst P1 = 1.66666666666666019037e-1;\nconst P2 = -2.77777777770155933842e-3;\nconst P3 = 6.61375632143793436117e-5;\nconst P4 = -1.65339022054652515390e-6;\nconst P5 = 4.13813679705723846039e-8;\n\nconst view = new DataView(new ArrayBuffer(8));\n\n/**\n * `y * 2^k` for a y in [0.5, 2) and k >= -1021, by adding k to the exponent field.\n * @param y - the mantissa part\n * @param k - the power of two\n * @returns the scaled value\n */\nfunction scale(y: number, k: number): number {\n    view.setFloat64(0, y, true);\n    view.setInt32(4, view.getInt32(4, true) + (k << 20), true);\n    return view.getFloat64(0, true);\n}\n\n/**\n * e^x, bit-identical across engines.\n * @param x - the argument\n * @returns e^x; +Infinity above about 709.78, 0 below about -745.13, NaN for NaN\n */\nexport function detExp(x: number): number {\n    view.setFloat64(0, x, true);\n    const high = view.getInt32(4, true);\n    const negative = high < 0 ? 1 : 0;\n    const hx = high & 0x7fffffff;\n    if (hx >= 0x40862e42) {\n        if (hx >= 0x7ff00000) {\n            // NaN stays NaN, +Infinity stays, -Infinity gives 0\n            return negative === 0 || Number.isNaN(x) ? x + x : 0;\n        }\n        if (x > O_THRESHOLD) {\n            return Infinity;\n        }\n        if (x < U_THRESHOLD) {\n            return 0;\n        }\n    }\n    let hi = 0;\n    let lo = 0;\n    let k = 0;\n    let r = x;\n    if (hx > 0x3fd62e42) {\n        // |x| > 0.5 ln 2: reduce to r = x - k ln 2\n        if (hx < 0x3ff0a2b2) {\n            hi = negative === 0 ? x - LN2_HI : x + LN2_HI;\n            lo = negative === 0 ? LN2_LO : -LN2_LO;\n            k = 1 - negative - negative;\n        } else {\n            k = Math.trunc(INV_LN2 * x + (negative === 0 ? 0.5 : -0.5));\n            hi = x - k * LN2_HI;\n            lo = k * LN2_LO;\n        }\n        r = hi - lo;\n    } else if (hx < 0x3e300000) {\n        // |x| < 2^-28\n        return 1 + x;\n    }\n    const t = r * r;\n    const c = r - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n    if (k === 0) {\n        return 1 - ((r * c) / (c - 2.0) - r);\n    }\n    const y = 1 - (lo - (r * c) / (2.0 - c) - hi);\n    return k >= -1021 ? scale(y, k) : scale(y, k + 1000) * TWOM1000;\n}\n\n/**\n * x^y as `detExp(y * detLog(x))` for x > 0: deterministic, not correctly rounded (the relative\n * error grows with |y ln x|, about 1e-13 for the magnitudes the generators use). 0^y is 0 for\n * y > 0.\n * @param x - the base, >= 0\n * @param y - the exponent\n * @returns x^y\n */\nexport function detPow(x: number, y: number): number {\n    if (x === 0) {\n        if (y === 0) {\n            return 1;\n        }\n        return y > 0 ? 0 : Infinity;\n    }\n    return detExp(y * detLog(x));\n}\n","/**\n * Degree-sequence models: power-law degree sequences, the configuration model (undirected,\n * directed and bipartite), Chung-Lu expected-degree graphs, the degree-corrected stochastic block\n * model and random regular graphs.\n */\n\nimport { MAX_COUNT, type U32 } from \"@graphty/graph-format\";\n\nimport { detPow } from \"../random/exp.js\";\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { checkEdgeCount, checkInt, checkProbability, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/**\n * What a generator does with self-loops or repeated pairs: keep them, or erase all but the first\n * occurrence in edge order.\n */\nexport type EdgePolicy = \"keep\" | \"erase\";\n\n/** The largest power-law support (maxDegree - minDegree + 1): the size of the cumulative table. */\nconst MAX_POWER_LAW_SUPPORT = 2 ** 24;\n\n/**\n * Throw unless `exponent` is a finite number >= 0.\n * @param name - the option name\n * @param exponent - the value\n */\nfunction checkExponent(name: string, exponent: number): void {\n    if (!(Number.isFinite(exponent) && exponent >= 0)) {\n        throw new RangeError(`${name} must be a finite number >= 0, got ${String(exponent)}`);\n    }\n}\n\n/**\n * A sampler of the discrete power law P(d) ~ d^-exponent on [min, max]: a cumulative table of\n * detPow(d, -exponent), and per draw one nextFloat u and a binary search for the first entry\n * above u times the total. Checks its arguments.\n * @param names - the option names of [exponent, min, max], for the messages\n * @param exponent - the exponent, >= 0\n * @param min - the smallest value, >= 1\n * @param max - the largest value, >= min\n * @returns the sampler\n */\nexport function powerLawSampler(\n    names: readonly [string, string, string],\n    exponent: number,\n    min: number,\n    max: number,\n): (stream: RandomStream) => number {\n    checkExponent(names[0], exponent);\n    checkInt(names[1], min, 1);\n    checkInt(names[2], max, min, Math.min(MAX_COUNT, min + MAX_POWER_LAW_SUPPORT - 1));\n    const count = max - min + 1;\n    const cdf = new Float64Array(count);\n    let total = 0;\n    for (let k = 0; k < count; k++) {\n        total += detPow(min + k, -exponent);\n        cdf[k] = total;\n    }\n    return (stream) => {\n        const u = stream.nextFloat() * total;\n        let lo = 0;\n        let hi = count - 1;\n        while (lo < hi) {\n            const mid = (lo + hi) >>> 1;\n            if (cdf[mid] > u) {\n                hi = mid;\n            } else {\n                lo = mid + 1;\n            }\n        }\n        return min + lo;\n    };\n}\n\n/**\n * Make the sum of `seq` even by changing its LAST entry: +1 when it is below `max`, else -1 when\n * it is above `min`; a RangeError when neither is possible.\n * @param seq - the sequence, changed in place\n * @param min - the smallest allowed value\n * @param max - the largest allowed value\n */\nexport function makeSumEven(seq: U32, min: number, max: number): void {\n    let total = 0;\n    for (const d of seq) {\n        total += d;\n    }\n    if (total % 2 === 0) {\n        return;\n    }\n    const last = seq.length - 1;\n    if (seq[last] < max) {\n        seq[last]++;\n    } else if (seq[last] > min) {\n        seq[last]--;\n    } else {\n        throw new RangeError(`cannot make the degree sum even: every degree is ${min} and n is odd`);\n    }\n}\n\n/** Options of {@link powerLawDegreeSequence}. */\nexport interface PowerLawDegreeSequenceOptions {\n    /** The sequence length, >= 0. */\n    n: number;\n    /** The exponent of P(d) ~ d^-exponent, a finite number >= 0 (typically 2 to 3). */\n    exponent: number;\n    /** The smallest degree, >= 1. */\n    minDegree: number;\n    /** The largest degree, >= minDegree, and at most minDegree + 2^24 - 1. */\n    maxDegree: number;\n    /** Make the sum even (so a configuration model can pair it); default true. */\n    evenSum?: boolean | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * A sequence of n integers drawn independently from the discrete power law\n * P(d) ~ d^-exponent on [minDegree, maxDegree], by inversion of a cumulative table built with\n * detPow: entry i is one nextFloat of stream (seed, \"power-law\", 0), in index order. With\n * `evenSum` (the default) an odd sum is fixed by changing the last entry: +1 when it is below\n * maxDegree, else -1. O(n log(maxDegree - minDegree) + maxDegree - minDegree).\n * @param options - n, exponent, minDegree, maxDegree, evenSum and seed\n * @returns the sequence\n */\nexport function powerLawDegreeSequence(options: PowerLawDegreeSequenceOptions): Uint32Array<ArrayBuffer> {\n    const { n, exponent, minDegree, maxDegree } = options;\n    const seed = resolveSeed(options.seed);\n    checkInt(\"n\", n, 0);\n    const sample = powerLawSampler([\"exponent\", \"minDegree\", \"maxDegree\"], exponent, minDegree, maxDegree);\n    const stream = new RandomStream(seed, \"power-law\", 0);\n    const seq = new Uint32Array(n);\n    for (let i = 0; i < n; i++) {\n        seq[i] = sample(stream);\n    }\n    if ((options.evenSum ?? true) && n > 0) {\n        makeSumEven(seq, minDegree, maxDegree);\n    }\n    return seq;\n}\n\n/**\n * Check a degree sequence and return its sum.\n * @param name - the option name\n * @param degrees - the degrees\n * @returns the sum\n */\nfunction degreeSum(name: string, degrees: ArrayLike<number>): number {\n    checkInt(`${name}.length`, degrees.length, 0);\n    let total = 0;\n    for (let i = 0; i < degrees.length; i++) {\n        const d = degrees[i];\n        if (!(Number.isInteger(d) && d >= 0 && d <= MAX_COUNT)) {\n            checkInt(`${name}[${i}]`, d, 0);\n        }\n        total += d;\n    }\n    checkEdgeCount(total / 2);\n    return total;\n}\n\n/**\n * The option value of a keep / erase policy, checked.\n * @param name - the option name\n * @param value - the value (default \"erase\")\n * @returns true for keep\n */\nfunction keeps(name: string, value: EdgePolicy | undefined): boolean {\n    if (value !== undefined && value !== \"keep\" && value !== \"erase\") {\n        throw new RangeError(`${name} must be \"keep\" or \"erase\", got ${String(value)}`);\n    }\n    return value === \"keep\";\n}\n\n/**\n * The stub list: node i + offset repeated degrees[i] times, ascending.\n * @param degrees - the degrees\n * @param total - their sum\n * @param offset - added to every node index\n * @returns the stubs\n */\nexport function stubList(degrees: ArrayLike<number>, total: number, offset = 0): Uint32Array<ArrayBuffer> {\n    const stubs = new Uint32Array(total);\n    let k = 0;\n    for (let i = 0; i < degrees.length; i++) {\n        stubs.fill(i + offset, k, k + degrees[i]);\n        k += degrees[i];\n    }\n    return stubs;\n}\n\n/**\n * Fisher-Yates shuffle in place: for i = length - 1 down to 1, swap entries i and nextBelow(i + 1).\n * @param a - the array\n * @param stream - the stream\n */\nexport function shuffle(a: U32, stream: RandomStream): void {\n    for (let i = a.length - 1; i > 0; i--) {\n        const j = stream.nextBelow(i + 1);\n        const t = a[i];\n        a[i] = a[j];\n        a[j] = t;\n    }\n}\n\n/**\n * Filter an edge list, keeping edge order: drop self-loops unless `keepLoops`, drop edges whose\n * endpoints share a `group` value when `group` is given, and drop every repeat of a pair (ordered\n * when directed, unordered otherwise) after its first kept occurrence unless `keepMulti`. O(n + m)\n * by a counting sort on the smaller endpoint and a last-seen mark per node, no hashing.\n * @param n - the node count\n * @param src - the sources\n * @param dst - the targets\n * @param directed - whether pairs are ordered\n * @param keepLoops - keep self-loops\n * @param keepMulti - keep repeated pairs\n * @param out - receives the kept edges\n * @param group - a node column; edges inside one group are dropped\n */\nfunction eraseEdges(\n    n: number,\n    src: U32,\n    dst: U32,\n    directed: boolean,\n    keepLoops: boolean,\n    keepMulti: boolean,\n    out: EdgeBuffer,\n    group?: U32,\n): void {\n    const m = src.length;\n    const keep = new Uint8Array(m).fill(1);\n    for (let e = 0; e < m; e++) {\n        const u = src[e];\n        const v = dst[e];\n        if ((!keepLoops && u === v) || (group !== undefined && group[u] === group[v])) {\n            keep[e] = 0;\n        }\n    }\n    if (!keepMulti) {\n        const lo = (e: number): number => (directed ? src[e] : Math.min(src[e], dst[e]));\n        const start = new Uint32Array(n + 1);\n        for (let e = 0; e < m; e++) {\n            start[lo(e) + 1]++;\n        }\n        for (let i = 0; i < n; i++) {\n            start[i + 1] += start[i];\n        }\n        const fill = start.slice(0, n);\n        const order = new Uint32Array(m);\n        for (let e = 0; e < m; e++) {\n            order[fill[lo(e)]++] = e;\n        }\n        // mark[v] = u + 1 when the pair (u, v) has been seen in u's bucket\n        const mark = new Uint32Array(n);\n        for (let k = 0; k < m; k++) {\n            const e = order[k];\n            if (keep[e] === 0) {\n                continue;\n            }\n            const u = lo(e);\n            const v = directed ? dst[e] : Math.max(src[e], dst[e]);\n            if (mark[v] === u + 1) {\n                keep[e] = 0;\n            } else {\n                mark[v] = u + 1;\n            }\n        }\n    }\n    for (let e = 0; e < m; e++) {\n        if (keep[e] === 1) {\n            out.push(src[e], dst[e]);\n        }\n    }\n}\n\n/**\n * Pair consecutive stubs of a shuffled undirected stub list into edges (stubs[2k], stubs[2k + 1])\n * and erase as asked.\n * @param n - the node count\n * @param stubs - the shuffled stubs (even length)\n * @param keepLoops - keep self-loops\n * @param keepMulti - keep repeated pairs\n * @param out - receives the edges\n * @param group - a node column; edges inside one group are dropped\n */\nexport function pairStubs(\n    n: number,\n    stubs: U32,\n    keepLoops: boolean,\n    keepMulti: boolean,\n    out: EdgeBuffer,\n    group?: U32,\n): void {\n    const m = stubs.length / 2;\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    for (let k = 0; k < m; k++) {\n        src[k] = stubs[2 * k];\n        dst[k] = stubs[2 * k + 1];\n    }\n    eraseEdges(n, src, dst, false, keepLoops, keepMulti, out, group);\n}\n\n/** Options of {@link configurationModelGraph}. */\nexport interface ConfigurationModelOptions extends WeightOptions {\n    /** The degree of every node; the sum must be even. */\n    degrees: ArrayLike<number>;\n    /** Keep or erase self-loops; default \"erase\". */\n    selfLoops?: EdgePolicy | undefined;\n    /** Keep or erase repeated pairs (the first occurrence in edge order stays); default \"erase\". */\n    multiEdges?: EdgePolicy | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The configuration model (E. A. Bender and E. R. Canfield, \"The asymptotic number of labeled\n * graphs with given degree sequences\", J. Combin. Theory A 24, 296-307, 1978,\n * doi:10.1016/0097-3165(78)90059-6; M. Molloy and B. Reed, \"A critical point for random graphs with\n * a given degree sequence\", Random Struct. Algorithms 6, 161-179, 1995, doi:10.1002/rsa.3240060204;\n * M. E. J. Newman, S. H. Strogatz and D. J. Watts, \"Random graphs with arbitrary degree\n * distributions and their applications\", Phys. Rev. E 64, 026118, 2001,\n * doi:10.1103/PhysRevE.64.026118). The stub list (node i repeated degrees[i] times, ascending) is\n * Fisher-Yates shuffled with stream (seed, \"configuration\", 0) and consecutive stubs are paired:\n * edge k is (stubs[2k], stubs[2k + 1]), in that order. With keep / keep the degrees are exact (a\n * multigraph); erasing drops self-loops and every repeat of a pair after its first occurrence, so\n * degrees can only go down. An odd degree sum is a RangeError. O(n + m).\n * @param options - degrees, selfLoops, multiEdges and seed\n * @returns the undirected graph\n */\nexport function configurationModelGraph(options: ConfigurationModelOptions): SampleGraph {\n    const { degrees } = options;\n    const seed = resolveSeed(options.seed);\n    const keepLoops = keeps(\"selfLoops\", options.selfLoops);\n    const keepMulti = keeps(\"multiEdges\", options.multiEdges);\n    const total = degreeSum(\"degrees\", degrees);\n    if (total % 2 !== 0) {\n        throw new RangeError(`the degree sum must be even, got ${total}`);\n    }\n    const n = degrees.length;\n    const stubs = stubList(degrees, total);\n    shuffle(stubs, new RandomStream(seed, \"configuration\", 0));\n    const out = new EdgeBuffer(total / 2);\n    pairStubs(n, stubs, keepLoops, keepMulti, out);\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/** Options of {@link directedConfigurationModelGraph}. */\nexport interface DirectedConfigurationModelOptions extends WeightOptions {\n    /** The out-degree of every node. */\n    outDegrees: ArrayLike<number>;\n    /** The in-degree of every node; same length and same sum as outDegrees. */\n    inDegrees: ArrayLike<number>;\n    /** Keep or erase self-loops; default \"erase\". */\n    selfLoops?: EdgePolicy | undefined;\n    /** Keep or erase repeated ordered pairs (the first occurrence stays); default \"erase\". */\n    multiEdges?: EdgePolicy | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The directed configuration model (Newman, Strogatz and Watts 2001, section on directed graphs):\n * the in-stub list (node i repeated inDegrees[i] times, ascending) is Fisher-Yates shuffled with\n * stream (seed, \"configuration-directed\", 0) and paired in order with the ascending out-stub list,\n * so edge k runs from the k-th out-stub to the k-th shuffled in-stub (edges come grouped by\n * source, ascending). Erasing works as in {@link configurationModelGraph} on ordered pairs.\n * O(n + m).\n * @param options - outDegrees, inDegrees, selfLoops, multiEdges and seed\n * @returns the directed graph\n */\nexport function directedConfigurationModelGraph(options: DirectedConfigurationModelOptions): SampleGraph {\n    const { outDegrees, inDegrees } = options;\n    const seed = resolveSeed(options.seed);\n    const keepLoops = keeps(\"selfLoops\", options.selfLoops);\n    const keepMulti = keeps(\"multiEdges\", options.multiEdges);\n    const outTotal = degreeSum(\"outDegrees\", outDegrees);\n    const inTotal = degreeSum(\"inDegrees\", inDegrees);\n    if (outDegrees.length !== inDegrees.length) {\n        throw new RangeError(`outDegrees and inDegrees must have the same length`);\n    }\n    if (outTotal !== inTotal) {\n        throw new RangeError(`the out-degree sum (${outTotal}) must equal the in-degree sum (${inTotal})`);\n    }\n    const n = outDegrees.length;\n    const dst = stubList(inDegrees, inTotal);\n    shuffle(dst, new RandomStream(seed, \"configuration-directed\", 0));\n    const out = new EdgeBuffer(outTotal);\n    eraseEdges(n, stubList(outDegrees, outTotal), dst, true, keepLoops, keepMulti, out);\n    return applyWeights(toGraph(n, out, true), options);\n}\n\n/** Options of {@link bipartiteConfigurationModelGraph}. */\nexport interface BipartiteConfigurationModelOptions extends WeightOptions {\n    /** The degree of every left node (nodes 0 .. L - 1). */\n    leftDegrees: ArrayLike<number>;\n    /** The degree of every right node (nodes L .. L + R - 1); same sum as leftDegrees. */\n    rightDegrees: ArrayLike<number>;\n    /** Keep or erase repeated pairs (the first occurrence stays); default \"erase\". */\n    multiEdges?: EdgePolicy | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The bipartite configuration model (Newman, Strogatz and Watts 2001, section on bipartite\n * graphs): left nodes are 0 .. L - 1, right nodes L .. L + R - 1. The right stub list (ascending)\n * is Fisher-Yates shuffled with stream (seed, \"bipartite-configuration\", 0) and paired in order with\n * the ascending left stub list; edge k is (k-th left stub, k-th shuffled right stub). Node column\n * `side` (u8): 0 left, 1 right. O(n + m).\n * @param options - leftDegrees, rightDegrees, multiEdges and seed\n * @returns the undirected bipartite graph\n */\nexport function bipartiteConfigurationModelGraph(options: BipartiteConfigurationModelOptions): SampleGraph {\n    const { leftDegrees, rightDegrees } = options;\n    const seed = resolveSeed(options.seed);\n    const keepMulti = keeps(\"multiEdges\", options.multiEdges);\n    const leftTotal = degreeSum(\"leftDegrees\", leftDegrees);\n    const rightTotal = degreeSum(\"rightDegrees\", rightDegrees);\n    if (leftTotal !== rightTotal) {\n        throw new RangeError(`the left degree sum (${leftTotal}) must equal the right degree sum (${rightTotal})`);\n    }\n    const left = leftDegrees.length;\n    const n = left + rightDegrees.length;\n    checkInt(\"the node count\", n, 0);\n    const dst = stubList(rightDegrees, rightTotal, left);\n    shuffle(dst, new RandomStream(seed, \"bipartite-configuration\", 0));\n    const out = new EdgeBuffer(leftTotal);\n    eraseEdges(n, stubList(leftDegrees, leftTotal), dst, false, true, keepMulti, out);\n    const side = new Uint8Array(n).fill(1, left);\n    return applyWeights(toGraph(n, out, false, { side }), options);\n}\n\n/** The checked and precomputed form of an expected-degree model (Chung-Lu or the DC-SBM). */\ninterface ExpectedDegreePlan {\n    readonly n: number;\n    readonly seed: number;\n    readonly domain: string;\n    /** order[row] = the node of that row. */\n    readonly order: U32;\n    /** The weight of every row. */\n    readonly weight: Float64Array;\n    /** The block of every row. */\n    readonly rowBlock: U32;\n    /** starts[b] = the first row of block b; starts[B] = n. */\n    readonly starts: readonly number[];\n    /** P(u, v) = min(1, factor[r][s] w_u w_v) for u in block r, v in block s. */\n    readonly factor: readonly (readonly number[])[];\n    /** The sum of the weights. */\n    readonly total: number;\n}\n\n/**\n * Check weights (finite, >= 0) and return their sum.\n * @param weights - the weights\n * @returns the sum\n */\nfunction weightSum(weights: ArrayLike<number>): number {\n    checkInt(\"expectedDegrees.length\", weights.length, 0);\n    let total = 0;\n    for (let i = 0; i < weights.length; i++) {\n        if (!(Number.isFinite(weights[i]) && weights[i] >= 0)) {\n            throw new RangeError(`expectedDegrees[${i}] must be a finite number >= 0, got ${String(weights[i])}`);\n        }\n        total += weights[i];\n    }\n    return total;\n}\n\n/**\n * Build the rows of an expected-degree model: nodes of each block (consecutive index ranges) sorted\n * by weight descending, ties by index ascending.\n * @param weights - the node weights\n * @param nodeStarts - block boundaries in node indices\n * @param factor - the block-pair factors\n * @param seed - the seed\n * @param domain - the stream domain\n * @param total - the weight sum\n * @returns the plan\n */\nfunction planRows(\n    weights: ArrayLike<number>,\n    nodeStarts: readonly number[],\n    factor: readonly (readonly number[])[],\n    seed: number,\n    domain: string,\n    total: number,\n): ExpectedDegreePlan {\n    const n = weights.length;\n    const order = new Uint32Array(n);\n    const rowBlock = new Uint32Array(n);\n    for (let i = 0; i < n; i++) {\n        order[i] = i;\n    }\n    for (let b = 0; b + 1 < nodeStarts.length; b++) {\n        order.subarray(nodeStarts[b], nodeStarts[b + 1]).sort((x, y) => weights[y] - weights[x] || x - y);\n        rowBlock.fill(b, nodeStarts[b], nodeStarts[b + 1]);\n    }\n    const weight = Float64Array.from(order, (i) => weights[i]);\n    return { n, seed, domain, order, weight, rowBlock, starts: nodeStarts, factor, total };\n}\n\n/** Options of {@link chungLuGraph}. */\nexport interface ChungLuOptions extends WeightOptions {\n    /** The expected degree (weight) of every node, finite and >= 0. */\n    expectedDegrees: ArrayLike<number>;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Check Chung-Lu options and build the plan: one block, factor 1 / S.\n * @param options - the options\n * @returns the plan\n */\nexport function planChungLu(options: ChungLuOptions): ExpectedDegreePlan {\n    const seed = resolveSeed(options.seed);\n    const total = weightSum(options.expectedDegrees);\n    const n = options.expectedDegrees.length;\n    return planRows(options.expectedDegrees, [0, n], [[total > 0 ? 1 / total : 0]], seed, \"chung-lu\", total);\n}\n\n/**\n * Rows [start, end) of an expected-degree model (Chung-Lu, or the DC-SBM with its own plan and\n * domain) by the skipping of Miller and Hagberg: row `row` (in block r) draws from stream\n * (seed, domain, row) and walks blocks s = r .. B - 1 in order; inside block s it visits the later\n * rows v (all rows of s when s > r) in row order, whose weights never increase, skipping with the\n * previous probability p (nextSkip(detLog(1 - p)) unless p = 1) and accepting the landing v with\n * probability q / p (one nextFloat), q = min(1, factor[r][s] w_row w_v). Edges are\n * (order[row], order[v]) in original node indices. Concatenating consecutive row ranges gives\n * the whole graph.\n * @param plan - the checked options\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the edges\n */\nexport function chungLuRows(plan: ExpectedDegreePlan, start: number, end: number, out: EdgeBuffer): void {\n    const { order, weight, rowBlock, starts, factor } = plan;\n    const stream = new RandomStream(plan.seed, plan.domain, 0);\n    const count = starts.length - 1;\n    for (let row = start; row < end; row++) {\n        stream.reset(row);\n        const r = rowBlock[row];\n        // ponytail: O(B) per row like the block model; iterate non-zero blocks if B grows large\n        for (let s = r; s < count; s++) {\n            const cu = factor[r][s] * weight[row];\n            let v = s === r ? row + 1 : starts[s];\n            const hi = starts[s + 1];\n            if (cu === 0 || v >= hi) {\n                continue;\n            }\n            let p = Math.min(1, cu * weight[v]);\n            while (v < hi && p > 0) {\n                if (p !== 1) {\n                    const logQ = detLog(1 - p);\n                    // p below 2^-53 rounds 1 - p to 1: no further edge in this segment\n                    if (logQ === 0) {\n                        break;\n                    }\n                    v += stream.nextSkip(logQ);\n                    if (v >= hi) {\n                        break;\n                    }\n                }\n                const q = Math.min(1, cu * weight[v]);\n                if (stream.nextFloat() < q / p) {\n                    out.push(order[row], order[v]);\n                }\n                p = q;\n                v++;\n            }\n        }\n    }\n}\n\n/**\n * Run a plan over all its rows.\n * @param plan - the plan\n * @param nodeColumns - ground-truth columns\n * @param options - for the weights option\n * @returns the graph\n */\nfunction runPlan(plan: ExpectedDegreePlan, nodeColumns: SampleGraph[\"nodeColumns\"], options: WeightOptions): SampleGraph {\n    const mean = plan.total / 2;\n    checkEdgeCount(mean);\n    const out = new EdgeBuffer(Math.ceil(mean + 6 * Math.sqrt(mean) + 16));\n    chungLuRows(plan, 0, plan.n, out);\n    return applyWeights(toGraph(plan.n, out, false, nodeColumns), options);\n}\n\n/**\n * The Chung-Lu expected-degree graph (F. Chung and L. Lu, \"The average distances in random graphs\n * with given expected degrees\", PNAS 99, 15879-15882, 2002, doi:10.1073/pnas.252631999): every\n * pair u != v is joined independently with probability min(1, w_u w_v / S), S the weight sum, so\n * node u's expected degree is about w_u when every w_u w_v is below S. Linear time by the skipping\n * of J. C. Miller and A. Hagberg, \"Efficient generation of networks with given expected degrees\",\n * WAW 2011, LNCS 6732, 115-126, doi:10.1007/978-3-642-21286-4_10. Rows are the nodes sorted by\n * weight descending (ties by index ascending); row i draws from stream (seed, \"chung-lu\", i) (see\n * {@link chungLuRows}). Edges are listed by row, each (row node, later node) in original indices.\n * Simple, undirected. O(n log n + m).\n * @param options - expectedDegrees and seed\n * @returns the undirected graph\n */\nexport function chungLuGraph(options: ChungLuOptions): SampleGraph {\n    return runPlan(planChungLu(options), undefined, options);\n}\n\n/** Options of {@link degreeCorrectedSbmGraph}. */\nexport interface DegreeCorrectedSbmOptions extends WeightOptions {\n    /** The size of every block; block b holds the next `sizes[b]` node indices. */\n    sizes: readonly number[];\n    /** The target degree of every node, finite and >= 0; length = the sum of sizes. */\n    expectedDegrees: ArrayLike<number>;\n    /** The mixing parameter mu in [0, 1]: the share of each node's edges that leave its block. */\n    mixing: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Check DC-SBM options and build the plan.\n * @param options - the options\n * @returns the plan\n */\nexport function planDegreeCorrectedSbm(options: DegreeCorrectedSbmOptions): ExpectedDegreePlan {\n    const { sizes, expectedDegrees, mixing } = options;\n    const seed = resolveSeed(options.seed);\n    checkInt(\"sizes.length\", sizes.length, 1);\n    checkProbability(\"mixing\", mixing);\n    const total = weightSum(expectedDegrees);\n    const starts = [0];\n    for (let b = 0; b < sizes.length; b++) {\n        checkInt(`sizes[${b}]`, sizes[b], 0);\n        starts.push(starts[b] + sizes[b]);\n    }\n    if (starts[sizes.length] !== expectedDegrees.length) {\n        throw new RangeError(\n            `the sizes sum to ${starts[sizes.length]}, but expectedDegrees has ${expectedDegrees.length} entries`,\n        );\n    }\n    const kappa = sizes.map((_, b) => {\n        let k = 0;\n        for (let i = starts[b]; i < starts[b + 1]; i++) {\n            k += expectedDegrees[i];\n        }\n        return k;\n    });\n    const between = total > 0 ? mixing / total : 0;\n    const inside = kappa.map((kr) => (kr > 0 ? (1 - mixing) / kr : 0));\n    const factor = kappa.map((_, r) => kappa.map((_2, s) => (r === s ? inside[r] : between)));\n    return planRows(expectedDegrees, starts, factor, seed, \"dcsbm\", total);\n}\n\n/**\n * The degree-corrected stochastic block model (B. Karrer and M. E. J. Newman, \"Stochastic\n * blockmodels and community structure in networks\", Phys. Rev. E 83, 016107, 2011,\n * doi:10.1103/PhysRevE.83.016107), sampled as a simple graph with Bernoulli edges:\n * P(uv) = min(1, theta_u theta_v omega_rs) with theta_u = d_u / kappa_r (kappa_r the degree total of\n * u's block r, K the grand total), omega_rr = (1 - mu) kappa_r and omega_rs = mu kappa_r kappa_s / K\n * for r != s. So node u's expected degree is about d_u (1 - mu kappa_r / K): the inside share is\n * 1 - mu, but the outside share misses the mu kappa_r / K that would land in u's own block.\n * Rows: block by block, inside a block the nodes sorted by d descending (ties by index); row i\n * draws from stream (seed, \"dcsbm\", i) and walks its own block's later rows, then every later\n * block (see {@link chungLuRows}). Edges are listed by row in original node indices. Node column\n * `community` (u32). With one block and mu = 0 it is Chung-Lu. O(n log n + n B + m).\n * @param options - sizes, expectedDegrees, mixing and seed\n * @returns the undirected graph\n */\nexport function degreeCorrectedSbmGraph(options: DegreeCorrectedSbmOptions): SampleGraph {\n    const plan = planDegreeCorrectedSbm(options);\n    const community = new Uint32Array(plan.n);\n    for (let b = 0; b + 1 < plan.starts.length; b++) {\n        community.fill(b, plan.starts[b], plan.starts[b + 1]);\n    }\n    return runPlan(plan, { community }, options);\n}\n\n/** Options of {@link randomRegularGraph}. */\nexport interface RandomRegularOptions extends WeightOptions {\n    /** The node count, >= 0. */\n    n: number;\n    /** The degree of every node, in [0, n - 1]; n d must be even. */\n    d: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/** Attempts before randomRegularGraph gives up. */\nconst REGULAR_ATTEMPTS = 100;\n/** Re-pairing rounds inside one attempt before it counts as failed. */\nconst REGULAR_ROUNDS = 1000;\n\n/**\n * One attempt of the Steger-Wormald pairing; fills `adj` (d slots per node) and `deg`.\n * @param n - the node count\n * @param d - the degree\n * @param stream - the attempt's stream\n * @param adj - the adjacency slots\n * @param deg - the filled slot count per node\n * @returns true on success\n */\nfunction regularAttempt(n: number, d: number, stream: RandomStream, adj: U32, deg: U32): boolean {\n    deg.fill(0);\n    const has = (u: number, v: number): boolean => {\n        const base = u * d;\n        for (let k = base; k < base + deg[u]; k++) {\n            if (adj[k] === v) {\n                return true;\n            }\n        }\n        return false;\n    };\n    const potential = new Uint32Array(n);\n    let stubs: U32 = stubList(new Uint32Array(n).fill(d), n * d);\n    for (let round = 0; round < REGULAR_ROUNDS && stubs.length > 0; round++) {\n        shuffle(stubs, stream);\n        const touched: number[] = [];\n        for (let k = 0; k < stubs.length; k += 2) {\n            const u = Math.min(stubs[k], stubs[k + 1]);\n            const v = Math.max(stubs[k], stubs[k + 1]);\n            if (u !== v && !has(u, v)) {\n                adj[u * d + deg[u]++] = v;\n                adj[v * d + deg[v]++] = u;\n            } else {\n                for (const x of [u, v]) {\n                    if (potential[x]++ === 0) {\n                        touched.push(x);\n                    }\n                }\n            }\n        }\n        touched.sort((a, b) => a - b);\n        // suitable: some pair of distinct leftover nodes is not yet an edge\n        let suitable = touched.length === 0;\n        for (let i = 0; i < touched.length && !suitable; i++) {\n            for (let j = i + 1; j < touched.length && !suitable; j++) {\n                suitable = !has(touched[i], touched[j]);\n            }\n        }\n        if (!suitable) {\n            return false;\n        }\n        let total = 0;\n        for (const x of touched) {\n            total += potential[x];\n        }\n        const next = new Uint32Array(total);\n        let k = 0;\n        for (const x of touched) {\n            next.fill(x, k, k + potential[x]);\n            k += potential[x];\n            potential[x] = 0;\n        }\n        stubs = next;\n    }\n    return stubs.length === 0;\n}\n\n/**\n * A uniformly-ish random d-regular simple graph by the pairing algorithm of A. Steger and\n * N. C. Wormald, \"Generating random regular graphs quickly\", Combin. Probab. Comput. 8, 377-396,\n * 1999, doi:10.1017/S0963548399003867, structured like networkx's `random_regular_graph`: attempt\n * a (a = 0, 1, ...) draws from stream (seed, \"random-regular\", a); it Fisher-Yates shuffles the\n * stub list (node i repeated d times, ascending), keeps each consecutive pair that is not a loop\n * and not yet an edge, and re-pairs the leftover stubs (ascending node order) while some leftover\n * pair could still be joined; otherwise it restarts. At most 100 attempts of at most 1000 rounds,\n * then a RangeError. Edges (u, v), u < v, in lexicographic order. Expected O(n d^2) for small d.\n * @param options - n, d and seed\n * @returns the undirected graph\n */\nexport function randomRegularGraph(options: RandomRegularOptions): SampleGraph {\n    const { n, d } = options;\n    const seed = resolveSeed(options.seed);\n    checkInt(\"n\", n, 0);\n    checkInt(\"d\", d, 0, Math.max(0, n - 1));\n    if ((n * d) % 2 !== 0) {\n        throw new RangeError(`n * d must be even, got ${n} * ${d}`);\n    }\n    checkEdgeCount((n * d) / 2);\n    const out = new EdgeBuffer((n * d) / 2);\n    if (d > 0) {\n        const adj = new Uint32Array(n * d);\n        const deg = new Uint32Array(n);\n        const stream = new RandomStream(seed, \"random-regular\", 0);\n        let attempt = 0;\n        for (; attempt < REGULAR_ATTEMPTS; attempt++) {\n            stream.reset(attempt);\n            if (regularAttempt(n, d, stream, adj, deg)) {\n                break;\n            }\n        }\n        if (attempt === REGULAR_ATTEMPTS) {\n            throw new RangeError(`randomRegularGraph found no ${d}-regular graph on ${n} nodes in ${REGULAR_ATTEMPTS} attempts`);\n        }\n        for (let u = 0; u < n; u++) {\n            const row = adj.subarray(u * d, u * d + d).sort();\n            for (const v of row) {\n                if (v > u) {\n                    out.push(u, v);\n                }\n            }\n        }\n    }\n    return applyWeights(toGraph(n, out, false), options);\n}\n","/**\n * Directed random graphs: stochastic Kronecker graphs and R-MAT (the recursive-matrix family behind\n * the Graph500 benchmark), Price's citation network and the random-order DAG.\n */\n\nimport { type U32 } from \"@graphty/graph-format\";\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { type EdgePolicy } from \"./degree-sequence.js\";\nimport {\n    bernoulliSegment,\n    binomialBuffer,\n    checkEdgeCount,\n    checkInt,\n    checkProbability,\n    EdgeBuffer,\n    toGraph,\n} from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** The options R-MAT and Kronecker graphs share. */\ninterface RecursiveOptions extends WeightOptions {\n    /** Self-loops: \"keep\" (the default) or \"erase\" them. */\n    selfLoops?: EdgePolicy | undefined;\n    /**\n     * Repeated pairs: \"keep\" (the default) or \"erase\" all but the first occurrence in edge order.\n     * For an undirected graph (u, v) and (v, u) are the same pair.\n     */\n    multiEdges?: EdgePolicy | undefined;\n    /** Relabel the nodes by a uniformly random permutation, as Graph500 does; default false. */\n    permute?: boolean | undefined;\n    /** Whether the graph is directed; default true. */\n    directed?: boolean | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Throw unless `value` is undefined or a duplicate policy.\n * @param name - the option name\n * @param value - the value\n */\nfunction checkPolicy(name: string, value: EdgePolicy | undefined): void {\n    if (value !== undefined && value !== \"keep\" && value !== \"erase\") {\n        throw new RangeError(`${name} must be \"keep\" or \"erase\", got ${String(value)}`);\n    }\n}\n\n/**\n * Apply `permute`, `selfLoops` and `multiEdges` to freshly sampled edges, then build the graph.\n * The permutation is a Fisher-Yates shuffle of 0 .. n - 1 (for i = n - 1 down to 1, swap i with\n * nextBelow(i + 1)) from stream (seed, permuteDomain, 0); node u becomes perm[u]. Erasing keeps\n * the first occurrence of a pair in edge order, and is not affected by the relabelling.\n * @param n - the node count\n * @param src - the sources, in edge order\n * @param dst - the targets\n * @param options - the options\n * @param seed - the resolved seed\n * @param permuteDomain - the permutation's stream domain\n * @returns the graph (before weights)\n */\nfunction finishRecursive(\n    n: number,\n    src: U32,\n    dst: U32,\n    options: RecursiveOptions,\n    seed: number,\n    permuteDomain: string,\n): SampleGraph {\n    const directed = options.directed ?? true;\n    const m = src.length;\n    if (options.permute === true) {\n        const perm = new Uint32Array(n);\n        for (let i = 0; i < n; i++) {\n            perm[i] = i;\n        }\n        const stream = new RandomStream(seed, permuteDomain, 0);\n        for (let i = n - 1; i > 0; i--) {\n            const j = stream.nextBelow(i + 1);\n            const t = perm[i];\n            perm[i] = perm[j];\n            perm[j] = t;\n        }\n        for (let e = 0; e < m; e++) {\n            src[e] = perm[src[e]];\n            dst[e] = perm[dst[e]];\n        }\n    }\n    const keep = new Uint8Array(m).fill(1);\n    if (options.selfLoops === \"erase\") {\n        for (let e = 0; e < m; e++) {\n            if (src[e] === dst[e]) {\n                keep[e] = 0;\n            }\n        }\n    }\n    if (options.multiEdges === \"erase\") {\n        const lo = directed ? src : src.map((u, e) => Math.min(u, dst[e]));\n        const hi = directed ? dst : src.map((u, e) => Math.max(u, dst[e]));\n        // ponytail: O(m log m) comparator sort of edge indices; a hash set if erasing 100M+ edges matters\n        const order = new Uint32Array(m);\n        for (let e = 0; e < m; e++) {\n            order[e] = e;\n        }\n        order.sort((a, b) => lo[a] - lo[b] || hi[a] - hi[b] || a - b);\n        for (let i = 1; i < m; i++) {\n            const a = order[i - 1];\n            const b = order[i];\n            if (lo[a] === lo[b] && hi[a] === hi[b]) {\n                keep[b] = 0;\n            }\n        }\n    }\n    const out = new EdgeBuffer(m);\n    for (let e = 0; e < m; e++) {\n        if (keep[e] === 1) {\n            out.push(src[e], dst[e]);\n        }\n    }\n    return toGraph(n, out, directed);\n}\n\n/**\n * Check the options R-MAT and Kronecker graphs share.\n * @param options - the options\n * @returns the resolved seed\n */\nfunction checkRecursive(options: RecursiveOptions): number {\n    checkPolicy(\"selfLoops\", options.selfLoops);\n    checkPolicy(\"multiEdges\", options.multiEdges);\n    return resolveSeed(options.seed);\n}\n\n/** Options of {@link kroneckerGraph}. */\nexport interface KroneckerOptions extends RecursiveOptions {\n    /** The k x k initiator matrix, k >= 1, entries in [0, 1]. */\n    initiator: readonly (readonly number[])[];\n    /** The Kronecker power, in [1, 64]; the graph has k^power nodes. */\n    power: number;\n    /** The number of edges to sample; default round((sum of the initiator)^power). */\n    edges?: number | undefined;\n}\n\n/**\n * A stochastic Kronecker graph (J. Leskovec, D. Chakrabarti, J. Kleinberg, C. Faloutsos and\n * Z. Ghahramani, \"Kronecker graphs: an approach to modeling networks\", JMLR 11, 985-1042, 2010)\n * by their fast O(E power) sampling: n = k^power nodes and E = round(S^power) edges, S the sum of\n * the initiator (S^power by repeated multiplication), unless `edges` is given. Edge e draws from\n * stream (seed, \"kronecker\", e): `power` descents, most significant first, each drawing\n * u = nextFloat() and picking the first initiator cell (row-major) whose cumulative entry over S\n * exceeds u; cell (r, c) appends digit r to the source and c to the target in base k. Edges are\n * listed in sampling order. A multigraph unless erased: see `selfLoops`, `multiEdges`, `permute`\n * (stream (seed, \"kronecker-permute\", 0)) and `directed`.\n * @param options - initiator, power, edges, the shared recursive options and seed\n * @returns the graph\n */\nexport function kroneckerGraph(options: KroneckerOptions): SampleGraph {\n    const { initiator, power } = options;\n    const k = initiator.length;\n    checkInt(\"initiator.length\", k, 1);\n    let sum = 0;\n    for (let r = 0; r < k; r++) {\n        checkInt(`initiator[${r}].length`, initiator[r].length, k, k);\n        for (const value of initiator[r]) {\n            checkProbability(`initiator[${r}] entries`, value);\n            sum += value;\n        }\n    }\n    checkInt(\"power\", power, 1, 64);\n    let n = 1;\n    let mean = 1;\n    for (let i = 0; i < power; i++) {\n        n *= k;\n        mean *= sum;\n    }\n    checkInt(\"k^power (the node count)\", n, 1);\n    const m = options.edges ?? Math.round(mean);\n    checkEdgeCount(m);\n    checkInt(\"edges\", m, 0);\n    if (m > 0 && sum === 0) {\n        throw new RangeError(\"edges must be 0 when the initiator is all zeros\");\n    }\n    const seed = checkRecursive(options);\n    // cumulative table over S; from the last positive cell on it is exactly 1, so u < 1 always hits\n    const cells = k * k;\n    const cumulative = new Float64Array(cells);\n    let partial = 0;\n    let lastPositive = 0;\n    for (let i = 0; i < cells; i++) {\n        const value = initiator[Math.floor(i / k)][i % k];\n        partial += value;\n        cumulative[i] = partial / sum;\n        if (value > 0) {\n            lastPositive = i;\n        }\n    }\n    cumulative.fill(1, lastPositive);\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    const stream = new RandomStream(seed, \"kronecker\", 0);\n    for (let e = 0; e < m; e++) {\n        stream.reset(e);\n        let u = 0;\n        let v = 0;\n        for (let level = 0; level < power; level++) {\n            const x = stream.nextFloat();\n            let cell = 0;\n            while (x >= cumulative[cell]) {\n                cell++;\n            }\n            u = u * k + Math.floor(cell / k);\n            v = v * k + (cell % k);\n        }\n        src[e] = u;\n        dst[e] = v;\n    }\n    return applyWeights(finishRecursive(n, src, dst, options, seed, \"kronecker-permute\"), options);\n}\n\n/** Options of {@link rmatGraph}. */\nexport interface RmatOptions extends RecursiveOptions {\n    /** log2 of the node count, in [0, 31]. */\n    scale: number;\n    /** Edges per node, an integer >= 0; default 16 (Graph500). */\n    edgeFactor?: number | undefined;\n    /** The top-left quadrant probability; default 0.57 (Graph500). */\n    a?: number | undefined;\n    /** The top-right quadrant probability; default 0.19. */\n    b?: number | undefined;\n    /** The bottom-left quadrant probability; default 0.19. */\n    c?: number | undefined;\n    /** The bottom-right quadrant probability; default 0.05. a + b + c + d must be 1. */\n    d?: number | undefined;\n}\n\n/**\n * R-MAT (D. Chakrabarti, Y. Zhan and C. Faloutsos, \"R-MAT: a recursive model for graph mining\",\n * SIAM SDM 2004, 442-446, doi:10.1137/1.9781611972740.43) with Graph500's defaults: n = 2^scale\n * nodes and m = edgeFactor n edges in O(m scale). Edge e draws from stream (seed, \"rmat\", e):\n * `scale` levels, most significant bit first, each comparing one nextFloat() with a, a + b and\n * a + b + c to pick the top-left, top-right, bottom-left or else bottom-right quadrant (bit 0/1 of\n * the source for top/bottom, of the target for left/right). Edges are listed in sampling order.\n * A multigraph with self-loops unless erased: see `selfLoops`, `multiEdges`, `permute` (stream\n * (seed, \"rmat-permute\", 0)) and `directed`.\n *\n * webgpu-graph-algorithms carries three private R-MAT copies on xorshift / LCG streams\n * (benchmarks/datasets.ts, test/helpers/graphs.ts, demo/main.ts) that should move to this. Two\n * of them move a self-loop to (u, (v + 1) mod n), keeping exactly m edges; `selfLoops: \"erase\"`\n * drops the loop instead (about m / n^0.4 fewer edges at the defaults), and `weights: { kind:\n * \"integer\", min: 1, max: 10 }` reproduces their 1..10 weights. The third keeps self-loops, which\n * is this function's default.\n * @param options - scale, edgeFactor, a, b, c, d, the shared recursive options and seed\n * @returns the graph\n */\nexport function rmatGraph(options: RmatOptions): SampleGraph {\n    const { scale } = options;\n    const edgeFactor = options.edgeFactor ?? 16;\n    const a = options.a ?? 0.57;\n    const b = options.b ?? 0.19;\n    const c = options.c ?? 0.19;\n    const d = options.d ?? 0.05;\n    checkInt(\"scale\", scale, 0, 31);\n    checkInt(\"edgeFactor\", edgeFactor, 0);\n    checkProbability(\"a\", a);\n    checkProbability(\"b\", b);\n    checkProbability(\"c\", c);\n    checkProbability(\"d\", d);\n    if (Math.abs(a + b + c + d - 1) > 1e-9) {\n        throw new RangeError(`a + b + c + d must be 1, got ${a + b + c + d}`);\n    }\n    const n = 2 ** scale;\n    const m = edgeFactor * n;\n    checkEdgeCount(m);\n    const seed = checkRecursive(options);\n    const ab = a + b;\n    const abc = a + b + c;\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    const stream = new RandomStream(seed, \"rmat\", 0);\n    for (let e = 0; e < m; e++) {\n        stream.reset(e);\n        let u = 0;\n        let v = 0;\n        for (let level = 0; level < scale; level++) {\n            const x = stream.nextFloat();\n            u *= 2;\n            v *= 2;\n            if (x < a) {\n                // top-left\n            } else if (x < ab) {\n                v += 1;\n            } else if (x < abc) {\n                u += 1;\n            } else {\n                u += 1;\n                v += 1;\n            }\n        }\n        src[e] = u;\n        dst[e] = v;\n    }\n    return applyWeights(finishRecursive(n, src, dst, options, seed, \"rmat-permute\"), options);\n}\n\n/** Options of {@link priceGraph}. */\nexport interface PriceOptions extends WeightOptions {\n    /** The node count, >= 1. */\n    n: number;\n    /** The number of earlier nodes each new node cites, >= 1 (fewer while fewer exist). */\n    citations: number;\n    /** The attractiveness a > 0 added to every in-degree; default 1. */\n    attractiveness?: number | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Price's citation network (D. J. de S. Price, \"Networks of scientific papers\", Science 149,\n * 510-515, 1965, doi:10.1126/science.149.3683.510; \"A general theory of bibliometric and other\n * cumulative advantage processes\", J. Am. Soc. Inf. Sci. 27, 292-306, 1976): a directed acyclic\n * graph with arcs from the citing (newer) node to the cited (older) one, in-degrees following a\n * power law with exponent 2 + a / m.\n *\n * Node t = 1 .. n - 1 cites min(m, t) distinct earlier nodes, each chosen with probability\n * proportional to in-degree + a, the in-degrees as they were when t arrived. When t <= m it cites\n * every earlier node, ascending, without drawing. Otherwise, with E arcs made before t, every draw\n * takes x = nextFloat() * (E + a t) and then, if x < E, the target of a uniformly chosen earlier\n * arc (nextBelow(E) into the list of cited targets), else a uniform node nextBelow(t); a node t\n * already cites is redrawn. All draws come from the single stream (seed, \"price\", 0): the process\n * is sequential. Arcs are listed by citing node, in draw order. O(n m) expected.\n * @param options - n, citations, attractiveness and seed\n * @returns the directed graph\n */\nexport function priceGraph(options: PriceOptions): SampleGraph {\n    const { n, citations: m } = options;\n    const attractiveness = options.attractiveness ?? 1;\n    checkInt(\"n\", n, 1);\n    checkInt(\"citations\", m, 1);\n    if (!(attractiveness > 0 && Number.isFinite(attractiveness))) {\n        throw new RangeError(`attractiveness must be a positive number, got ${String(attractiveness)}`);\n    }\n    const seed = resolveSeed(options.seed);\n    const full = Math.min(m, n);\n    const edgeCount = (full * (full - 1)) / 2 + (n - full) * m;\n    checkEdgeCount(edgeCount);\n    const stream = new RandomStream(seed, \"price\", 0);\n    const out = new EdgeBuffer(edgeCount);\n    const citedBy = new Int32Array(n).fill(-1);\n    for (let t = 1; t < n; t++) {\n        const arcs = out.length;\n        if (t <= m) {\n            for (let v = 0; v < t; v++) {\n                out.push(t, v);\n            }\n            continue;\n        }\n        const total = arcs + attractiveness * t;\n        for (let found = 0; found < m; ) {\n            const x = stream.nextFloat() * total;\n            const v = x < arcs ? out.dst[stream.nextBelow(arcs)] : stream.nextBelow(t);\n            if (citedBy[v] !== t) {\n                citedBy[v] = t;\n                out.push(t, v);\n                found++;\n            }\n        }\n    }\n    return applyWeights(toGraph(n, out, true), options);\n}\n\n/** Options of {@link randomOrderDagGraph}. */\nexport interface RandomOrderDagOptions extends WeightOptions {\n    /** The node count, >= 0. */\n    n: number;\n    /** The probability of each arc i -> j, i < j, in [0, 1]. */\n    p: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Rows [start, end) of the random-order DAG: row u draws from stream (seed, \"order-dag\", u) and\n * holds the arcs u -> v, v = u + 1 .. n - 1 chosen, ascending. Any split of [0, n) into\n * consecutive ranges concatenates to the whole graph's arc list.\n * @param options - the generator's options (already checked)\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the arcs\n */\nexport function orderDagRows(options: RandomOrderDagOptions, start: number, end: number, out: EdgeBuffer): void {\n    const { n, p } = options;\n    const logQ = detLog(1 - p);\n    const stream = new RandomStream(resolveSeed(options.seed), \"order-dag\", 0);\n    for (let u = start; u < end; u++) {\n        stream.reset(u);\n        bernoulliSegment(stream, p, logQ, u, u + 1, n, out);\n    }\n}\n\n/**\n * The random-order DAG: a directed G(n, p) restricted to the arcs i -> j with i < j, so node\n * index order is a topological order (B. Karrer and M. E. J. Newman, \"Random acyclic networks\",\n * Phys. Rev. Lett. 102, 128701, 2009, doi:10.1103/PhysRevLett.102.128701). O(n + m) by geometric\n * skipping; arcs in row-major order, see {@link orderDagRows}.\n * @param options - n, p and seed\n * @returns the directed acyclic graph\n */\nexport function randomOrderDagGraph(options: RandomOrderDagOptions): SampleGraph {\n    const { n, p } = options;\n    checkInt(\"n\", n, 0);\n    checkProbability(\"p\", p);\n    resolveSeed(options.seed);\n    const out = binomialBuffer((n * (n - 1)) / 2, p);\n    orderDagRows(options, 0, n, out);\n    return applyWeights(toGraph(n, out, true), options);\n}\n","/**\n * Erdos-Renyi random graphs: Gilbert's G(n, p) (every pair independently with probability p) and\n * Erdos-Renyi's G(n, m) (m pairs uniformly without replacement).\n */\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { bernoulliSegment, binomialBuffer, checkInt, checkProbability, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** Options of {@link erdosRenyiGraph}. */\nexport interface ErdosRenyiOptions extends WeightOptions {\n    /** The node count, >= 0. */\n    n: number;\n    /** The probability of each pair, in [0, 1]. */\n    p: number;\n    /**\n     * Directed: every ordered pair (u, v), u != v, is an arc independently with probability p.\n     * Default false (unordered pairs).\n     */\n    directed?: boolean | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Rows [start, end) of G(n, p): row u draws from stream (seed, \"gnp\", u) and holds the pairs\n * (u, v), v = u + 1 .. n - 1, in ascending v. Concatenating any split of [0, n) into consecutive\n * ranges gives exactly the whole graph's edge list.\n * @param options - the generator's options (already checked)\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the edges\n */\nexport function erdosRenyiRows(options: ErdosRenyiOptions, start: number, end: number, out: EdgeBuffer): void {\n    const { n, p } = options;\n    const logQ = detLog(1 - p);\n    if (options.directed === true) {\n        directedRows(n, p, logQ, resolveSeed(options.seed), start, end, out);\n        return;\n    }\n    const stream = new RandomStream(resolveSeed(options.seed), \"gnp\", 0);\n    for (let u = start; u < end; u++) {\n        stream.reset(u);\n        bernoulliSegment(stream, p, logQ, u, u + 1, n, out);\n    }\n}\n\n/**\n * Rows [start, end) of the directed G(n, p): row u draws from stream (seed, \"gnp-directed\", u)\n * and skips over its n - 1 candidates, candidate j being the node j < u ? j : j + 1, so the arcs\n * (u, v) come in ascending v.\n * @param n - the node count\n * @param p - the probability\n * @param logQ - detLog(1 - p)\n * @param seed - the resolved seed\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the arcs\n */\nfunction directedRows(n: number, p: number, logQ: number, seed: number, start: number, end: number, out: EdgeBuffer): void {\n    if (p === 0) {\n        return;\n    }\n    const stream = new RandomStream(seed, \"gnp-directed\", 0);\n    for (let u = start; u < end; u++) {\n        stream.reset(u);\n        let j = p === 1 ? 0 : stream.nextSkip(logQ);\n        while (j < n - 1) {\n            out.push(u, j < u ? j : j + 1);\n            j += p === 1 ? 1 : 1 + stream.nextSkip(logQ);\n        }\n    }\n}\n\n/**\n * Gilbert's G(n, p) in O(n + m) by geometric skipping (Batagelj and Brandes 2005). Edges are the\n * pairs (u, v), u < v, in row-major order; row u draws from its own stream, so the graph does not\n * depend on how the rows are split between workers. With `directed: true`, the arcs (u, v) of\n * every ordered pair u != v, by u then v ascending, each row from stream (seed, \"gnp-directed\", u).\n * @param options - n, p and seed\n * @returns the undirected graph\n */\nexport function erdosRenyiGraph(options: ErdosRenyiOptions): SampleGraph {\n    const { n, p } = options;\n    checkInt(\"n\", n, 0);\n    checkProbability(\"p\", p);\n    resolveSeed(options.seed);\n    const directed = options.directed === true;\n    const pairs = (n * (n - 1)) / (directed ? 1 : 2);\n    const out = binomialBuffer(pairs, p);\n    erdosRenyiRows(options, 0, n, out);\n    return applyWeights(toGraph(n, out, directed), options);\n}\n\n/** Options of {@link erdosRenyiGnmGraph}. */\nexport interface ErdosRenyiGnmOptions extends WeightOptions {\n    /** The node count, >= 0. */\n    n: number;\n    /** The edge count, in [0, n (n - 1) / 2]. */\n    m: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * An open-addressing set of non-negative integers below 2^53, sized for `capacity` entries.\n */\nclass NumberSet {\n    private readonly slots: Float64Array;\n    private readonly mask: number;\n\n    /**\n     * An empty set.\n     * @param capacity - the maximum number of entries\n     */\n    constructor(capacity: number) {\n        let size = 16;\n        while (size < capacity * 2) {\n            size *= 2;\n        }\n        this.slots = new Float64Array(size).fill(-1);\n        this.mask = size - 1;\n    }\n\n    /**\n     * Insert `x`.\n     * @param x - the value\n     * @returns false when it was already present\n     */\n    add(x: number): boolean {\n        let i = Math.imul((x >>> 0) ^ Math.floor(x / 4294967296), 0x9e3779b1) & this.mask;\n        for (;;) {\n            const slot = this.slots[i];\n            if (slot === -1) {\n                this.slots[i] = x;\n                return true;\n            }\n            if (slot === x) {\n                return false;\n            }\n            i = (i + 1) & this.mask;\n        }\n    }\n}\n\n/**\n * Erdos-Renyi's G(n, m): m distinct pairs chosen uniformly, by Floyd's sampling over the pair\n * indices 0 .. n (n - 1) / 2 - 1 (exactly m draws from stream (seed, \"gnm\", 0), no rejection\n * loop), in O(m log m). Edges are the pairs (u, v), u < v, in row-major order.\n * @param options - n, m and seed\n * @returns the undirected graph\n */\nexport function erdosRenyiGnmGraph(options: ErdosRenyiGnmOptions): SampleGraph {\n    const { n, m } = options;\n    const seed = resolveSeed(options.seed);\n    // the pair indices must stay below 2^53 to be exact doubles\n    checkInt(\"n\", n, 0, 2 ** 27);\n    const total = (n * (n - 1)) / 2;\n    checkInt(\"m\", m, 0, Math.min(total, 2 ** 32 - 2));\n    const stream = new RandomStream(seed, \"gnm\", 0);\n    const chosen = new Float64Array(m);\n    const set = new NumberSet(m);\n    for (let k = 0, j = total - m; j < total; j++, k++) {\n        const t = stream.nextBelow(j + 1);\n        if (set.add(t)) {\n            chosen[k] = t;\n        } else {\n            set.add(j);\n            chosen[k] = j;\n        }\n    }\n    chosen.sort();\n    const out = new EdgeBuffer(m);\n    // walk the sorted pair indices row by row: row u holds indices [rowStart, rowStart + n - u - 1)\n    let u = 0;\n    let rowStart = 0;\n    for (let k = 0; k < m; k++) {\n        const index = chosen[k];\n        while (index >= rowStart + (n - u - 1)) {\n            rowStart += n - u - 1;\n            u++;\n        }\n        out.push(u, u + 1 + (index - rowStart));\n    }\n    return applyWeights(toGraph(n, out, false), options);\n}\n","/**\n * Maximum-flow networks: a grid (the image-segmentation shape), a random layered DAG, GENRMF and\n * the AK network. Every one is directed, with integer capacities as its `weights`, a `role` node\n * column and its source and sink.\n */\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { bernoulliSegment, checkEdgeCount, checkInt, checkProbability, EdgeBuffer } from \"./util.js\";\n\n/** A maximum-flow instance: a directed graph whose `weights` are integer capacities. */\nexport interface FlowNetwork extends SampleGraph {\n    /** The source node. */\n    readonly source: number;\n    /** The sink node. */\n    readonly sink: number;\n}\n\n/**\n * The largest capacity: 2^24, the last point where every integer is exact in a Float32 weight.\n */\nconst MAX_CAPACITY = 2 ** 24;\n\n/** The capacity range options of the random flow networks. */\ninterface CapacityOptions {\n    /** The smallest arc capacity, an integer >= 0; default 1. */\n    minCapacity?: number | undefined;\n    /** The largest arc capacity, an integer >= minCapacity; default 10. */\n    maxCapacity?: number | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The checked capacity range.\n * @param options - the options\n * @param terminalFactor - the terminal arcs carry terminalFactor * maxCapacity, which must stay exact\n * @returns min and max\n */\nfunction capacityRange(options: CapacityOptions, terminalFactor: number): { min: number; max: number } {\n    const min = options.minCapacity ?? 1;\n    const max = options.maxCapacity ?? 10;\n    checkInt(\"minCapacity\", min, 0, MAX_CAPACITY);\n    checkInt(\"maxCapacity\", max, min, Math.floor(MAX_CAPACITY / terminalFactor));\n    return { min, max };\n}\n\n/**\n * Assemble a flow network.\n * @param n - the node count\n * @param out - the arcs\n * @param capacities - one capacity per arc\n * @param source - the source\n * @param sink - the sink\n * @param columns - node columns besides `role`\n * @returns the network\n */\nfunction toNetwork(\n    n: number,\n    out: EdgeBuffer,\n    capacities: number[],\n    source: number,\n    sink: number,\n    columns: NonNullable<SampleGraph[\"nodeColumns\"]>,\n): FlowNetwork {\n    const { src, dst } = out.finish();\n    const role = new Uint8Array(n);\n    role[source] = 1;\n    role[sink] = 2;\n    return {\n        directed: true,\n        nodeCount: n,\n        src,\n        dst,\n        weights: Float32Array.from(capacities),\n        nodeColumns: { ...columns, role },\n        source,\n        sink,\n    };\n}\n\n/**\n * Push the arcs of node (r, c) of a rows x cols grid starting at `base` to its 4-neighbours, in\n * the order right, down, left, up.\n * @param out - the buffer\n * @param base - the grid's first node\n * @param rows - the row count\n * @param cols - the column count\n * @param r - the row\n * @param c - the column\n * @returns how many arcs were pushed\n */\nfunction gridArcs(out: EdgeBuffer, base: number, rows: number, cols: number, r: number, c: number): number {\n    const u = base + r * cols + c;\n    const before = out.length;\n    if (c + 1 < cols) {\n        out.push(u, u + 1);\n    }\n    if (r + 1 < rows) {\n        out.push(u, u + cols);\n    }\n    if (c > 0) {\n        out.push(u, u - 1);\n    }\n    if (r > 0) {\n        out.push(u, u - cols);\n    }\n    return out.length - before;\n}\n\n/** Options of {@link gridFlowNetwork}. */\nexport interface GridFlowOptions extends CapacityOptions {\n    /** The grid's row count, >= 1. */\n    rows: number;\n    /** The grid's column count, >= 2. */\n    cols: number;\n}\n\n/**\n * A grid flow network, the shape of graph-cut image segmentation: node r * cols + c for pixel\n * (r, c), arcs to each 4-neighbour in both directions, listed by node, in the order right, down,\n * left, up; node u draws its arcs' capacities, uniform integers in [minCapacity, maxCapacity],\n * from stream (seed, \"grid-flow\", u) in that order. Then the source rows * cols with an arc to\n * every left-column node (by row), and every right-column node with an arc to the sink\n * rows * cols + 1 (by row), each of capacity 4 * maxCapacity. Those terminal arcs are never a\n * minimum cut: the arcs from the first column to the second already cut the network with at most\n * rows * maxCapacity. Node columns `x` = c and `y` = r (Float64), the source at x = -1 and the\n * sink at x = cols, both at the middle row; `role` (u8: 0 inner, 1 source, 2 sink). O(rows cols).\n * @param options - rows, cols, minCapacity, maxCapacity and seed\n * @returns the flow network\n */\nexport function gridFlowNetwork(options: GridFlowOptions): FlowNetwork {\n    const { rows, cols } = options;\n    checkInt(\"rows\", rows, 1);\n    checkInt(\"cols\", cols, 2);\n    const cells = rows * cols;\n    checkInt(\"rows * cols + 2 (the node count)\", cells + 2, 0);\n    const { min, max } = capacityRange(options, 4);\n    const seed = resolveSeed(options.seed);\n    const arcs = 2 * (rows * (cols - 1) + cols * (rows - 1)) + 2 * rows;\n    checkEdgeCount(arcs);\n    const out = new EdgeBuffer(arcs);\n    const capacities: number[] = [];\n    const stream = new RandomStream(seed, \"grid-flow\", 0);\n    const x = new Float64Array(cells + 2);\n    const y = new Float64Array(cells + 2);\n    for (let r = 0; r < rows; r++) {\n        for (let c = 0; c < cols; c++) {\n            const u = r * cols + c;\n            x[u] = c;\n            y[u] = r;\n            stream.reset(u);\n            const count = gridArcs(out, 0, rows, cols, r, c);\n            for (let i = 0; i < count; i++) {\n                capacities.push(min + stream.nextBelow(max - min + 1));\n            }\n        }\n    }\n    const source = cells;\n    const sink = cells + 1;\n    x[source] = -1;\n    x[sink] = cols;\n    y[source] = (rows - 1) / 2;\n    y[sink] = (rows - 1) / 2;\n    for (let r = 0; r < rows; r++) {\n        out.push(source, r * cols);\n        capacities.push(4 * max);\n    }\n    for (let r = 0; r < rows; r++) {\n        out.push(r * cols + cols - 1, sink);\n        capacities.push(4 * max);\n    }\n    return toNetwork(cells + 2, out, capacities, source, sink, { x, y });\n}\n\n/** Options of {@link layeredFlowNetwork}. */\nexport interface LayeredFlowOptions extends CapacityOptions {\n    /** The width of every inner layer, >= 1 each; layer i holds the next `layers[i]` node indices. */\n    layers: readonly number[];\n    /** The probability of each arc from a node to a node of the next layer. */\n    p: number;\n}\n\n/** The node layout of a layered flow network. */\ninterface LayeredFlowPlan {\n    /** starts[i] = the first node of inner layer i; starts[L] = the inner node count. */\n    readonly starts: readonly number[];\n    /** The inner layer of every inner node. */\n    readonly layerOf: Uint32Array;\n    /** The arc probability. */\n    readonly p: number;\n    /** The capacity range. */\n    readonly min: number;\n    /** The capacity range. */\n    readonly max: number;\n    /** The capacity of every terminal arc: max * (the widest layer). */\n    readonly terminal: number;\n    /** The resolved seed. */\n    readonly seed: number;\n}\n\n/**\n * Check a layered flow network's options and lay out its nodes.\n * @param options - the options\n * @returns the plan\n */\nexport function planLayeredFlow(options: LayeredFlowOptions): LayeredFlowPlan {\n    const { layers, p } = options;\n    checkInt(\"layers.length\", layers.length, 1);\n    checkProbability(\"p\", p);\n    const starts = [0];\n    let widest = 0;\n    for (let i = 0; i < layers.length; i++) {\n        checkInt(`layers[${i}]`, layers[i], 1);\n        starts.push(starts[i] + layers[i]);\n        widest = Math.max(widest, layers[i]);\n    }\n    const inner = starts[layers.length];\n    checkInt(\"the total size + 2 (the node count)\", inner + 2, 0);\n    const { min, max } = capacityRange(options, widest);\n    const layerOf = new Uint32Array(inner);\n    for (let i = 0; i < layers.length; i++) {\n        layerOf.fill(i, starts[i], starts[i + 1]);\n    }\n    return { starts, layerOf, p, min, max, terminal: max * widest, seed: resolveSeed(options.seed) };\n}\n\n/**\n * Rows [start, end) of the inner arcs of a layered flow network: inner node u of a layer before\n * the last draws from stream (seed, \"layered-flow\", u) first its arcs to the next layer\n * (ascending, by geometric skipping), then their capacities in the same order.\n * @param plan - the plan\n * @param start - the first inner node\n * @param end - one past the last inner node\n * @param out - receives the arcs\n * @param capacities - receives their capacities\n */\nexport function layeredFlowRows(\n    plan: LayeredFlowPlan,\n    start: number,\n    end: number,\n    out: EdgeBuffer,\n    capacities: number[],\n): void {\n    const { starts, layerOf, p, min, max } = plan;\n    const logQ = detLog(1 - p);\n    const stream = new RandomStream(plan.seed, \"layered-flow\", 0);\n    const last = starts.length - 2;\n    for (let u = start; u < end; u++) {\n        const layer = layerOf[u];\n        if (layer < last) {\n            stream.reset(u);\n            const before = out.length;\n            bernoulliSegment(stream, p, logQ, u, starts[layer + 1], starts[layer + 2], out);\n            for (let i = before; i < out.length; i++) {\n                capacities.push(min + stream.nextBelow(max - min + 1));\n            }\n        }\n    }\n}\n\n/**\n * A random layered flow network: inner layers as in `randomDagGraph` (arcs only from layer i to\n * layer i + 1, each with probability p, capacities uniform integers in [minCapacity,\n * maxCapacity]), a source feeding every node of the first layer and every node of the last layer\n * feeding a sink. Inner nodes come first, layer by layer; the source is node N and the sink\n * N + 1 (N inner nodes). Arcs: the inner arcs by source node (see {@link layeredFlowRows}), then\n * source -> first-layer nodes ascending, then last-layer nodes -> sink ascending; each terminal\n * arc has capacity maxCapacity * (the widest layer), at least what any one node can pass on.\n * Node column `layer` (u32): inner layer i is i + 1, the source is layer 0 and the sink layer\n * L + 1, so the column is a topological layering of the whole network; `role` (u8). O(N + m).\n * @param options - layers, p, minCapacity, maxCapacity and seed\n * @returns the flow network\n */\nexport function layeredFlowNetwork(options: LayeredFlowOptions): FlowNetwork {\n    const plan = planLayeredFlow(options);\n    const { starts } = plan;\n    const L = starts.length - 1;\n    const inner = starts[L];\n    const out = new EdgeBuffer(inner);\n    const capacities: number[] = [];\n    layeredFlowRows(plan, 0, inner, out, capacities);\n    const source = inner;\n    const sink = inner + 1;\n    const { terminal } = plan;\n    for (let u = starts[0]; u < starts[1]; u++) {\n        out.push(source, u);\n        capacities.push(terminal);\n    }\n    for (let u = starts[L - 1]; u < starts[L]; u++) {\n        out.push(u, sink);\n        capacities.push(terminal);\n    }\n    const layer = new Uint32Array(inner + 2);\n    for (let u = 0; u < inner; u++) {\n        layer[u] = plan.layerOf[u] + 1;\n    }\n    layer[sink] = L + 1;\n    return toNetwork(inner + 2, out, capacities, source, sink, { layer });\n}\n\n/** Options of {@link genrmfGraph}. */\nexport interface GenrmfOptions {\n    /** The side of every frame (an a x a grid), >= 1. */\n    a: number;\n    /** The number of frames, >= 1. */\n    b: number;\n    /** The smallest capacity between frames, an integer >= 0. */\n    c1: number;\n    /** The largest capacity between frames, an integer >= c1; arcs inside a frame carry c2 a^2. */\n    c2: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * GENRMF, the max-flow family of D. Goldfarb and M. D. Grigoriadis (\"A computational comparison\n * of the Dinic and network simplex methods for maximum flow\", Annals of Operations Research 13,\n * 81-123, 1988, doi:10.1007/BF02288321) as generated by Tamas Badics's `genrmf` (1991, First\n * DIMACS Implementation Challenge): b frames, each an a x a grid. Node f a^2 + r a + c is (r, c)\n * of frame f. Arcs, frame by frame: the frame's grid arcs to each 4-neighbour in both directions\n * (by node; right, down, left, up) with capacity c2 a^2; then, for f < b - 1, node j of frame f\n * -> node perm_f(j) of frame f + 1 for j ascending, with capacity uniform in [c1, c2]. Stream\n * (seed, \"genrmf\", f) first draws perm_f, a Fisher-Yates shuffle of 0 .. a^2 - 1 (for i = a^2 - 1\n * down to 1, swap i with nextBelow(i + 1)), then the a^2 capacities in j order. The source is\n * node 0 (the first node of the first frame), the sink the last node of the last frame. Node\n * columns `frame` (u32) and `role` (u8). Badics's own random numbers are not reproduced; the\n * structure is. O(a^2 b).\n * @param options - a, b, c1, c2 and seed\n * @returns the flow network\n */\nexport function genrmfGraph(options: GenrmfOptions): FlowNetwork {\n    const { a, b, c1, c2 } = options;\n    checkInt(\"a\", a, 1);\n    checkInt(\"b\", b, 1);\n    const side = a * a;\n    checkInt(\"a * a * b (the node count)\", side * b, 2);\n    checkInt(\"c1\", c1, 0, MAX_CAPACITY);\n    checkInt(\"c2\", c2, c1, MAX_CAPACITY);\n    if (c2 * side > MAX_CAPACITY) {\n        throw new RangeError(`c2 * a * a must be at most 2^24 to stay exact, got ${c2 * side}`);\n    }\n    const seed = resolveSeed(options.seed);\n    const n = side * b;\n    const arcs = b * 4 * a * (a - 1) + (b - 1) * side;\n    checkEdgeCount(arcs);\n    const out = new EdgeBuffer(arcs);\n    const capacities: number[] = [];\n    const frame = new Uint32Array(n);\n    const perm = new Uint32Array(side);\n    const stream = new RandomStream(seed, \"genrmf\", 0);\n    for (let f = 0; f < b; f++) {\n        const base = f * side;\n        frame.fill(f, base, base + side);\n        for (let r = 0; r < a; r++) {\n            for (let c = 0; c < a; c++) {\n                const count = gridArcs(out, base, a, a, r, c);\n                for (let i = 0; i < count; i++) {\n                    capacities.push(c2 * side);\n                }\n            }\n        }\n        if (f === b - 1) {\n            break;\n        }\n        stream.reset(f);\n        for (let i = 0; i < side; i++) {\n            perm[i] = i;\n        }\n        for (let i = side - 1; i > 0; i--) {\n            const j = stream.nextBelow(i + 1);\n            const t = perm[i];\n            perm[i] = perm[j];\n            perm[j] = t;\n        }\n        for (let j = 0; j < side; j++) {\n            out.push(base + j, base + side + perm[j]);\n            capacities.push(c1 + stream.nextBelow(c2 - c1 + 1));\n        }\n    }\n    return toNetwork(n, out, capacities, 0, n - 1, { frame });\n}\n\n/** Options of {@link akGraph}. */\nexport interface AkOptions {\n    /** The size parameter, in [1, 499998]: 4k + 6 nodes and 6k + 7 arcs. */\n    k: number;\n}\n\n/** The capacity of the AK network's terminal arcs, as in igraph's ak-4102.max instance. */\nconst AK_BIG = 1000000;\n\n/**\n * The AK network of B. V. Cherkassky and A. V. Goldberg (\"On implementing the push-relabel method\n * for the maximum flow problem\", Algorithmica 19, 390-410, 1997, doi:10.1007/PL00009180), built to\n * be hard for push-relabel. Deterministic; n = 4k + 6 nodes, m = 6k + 7 arcs.\n *\n * Nodes: s = 0, t = 1; part A a_i = 2 + i (i = 0 .. k); a hub chain h = k + 3 .. e = 2k + 3;\n * part B b_i = 2k + 4 + i (i = 0 .. 2k + 1). Arcs, in this order: for i = 0 .. k - 1, a_i ->\n * a_{i+1} (capacity k + 1 - i) then a_i -> h (1); a_k -> e (1), a_k -> h (1); the chain j -> j + 1\n * for j = h .. e - 1 (k + 1); b_i -> b_{i+1} for i = 0 .. 2k (k); the folds b_i -> b_{2k+1-i}\n * (1) for i = 0 .. k - 1; finally s -> a_0, s -> b_0, e -> t and b_{2k+1} -> t, each 1000000.\n * The maximum flow is 2k + 3 and the largest inner capacity k + 1, so k is capped at 499998 to\n * keep the terminal capacity 1000000 from ever binding (every value is then exact in Float32).\n * Node column `role` (u8). O(k).\n * @param options - k\n * @returns the flow network\n */\nexport function akGraph(options: AkOptions): FlowNetwork {\n    const { k } = options;\n    checkInt(\"k\", k, 1, 499998);\n    const n = 4 * k + 6;\n    const out = new EdgeBuffer(6 * k + 7);\n    const capacities: number[] = [];\n    const arc = (u: number, v: number, capacity: number): void => {\n        out.push(u, v);\n        capacities.push(capacity);\n    };\n    const hub = k + 3;\n    const chainEnd = 2 * k + 3;\n    const b0 = 2 * k + 4;\n    for (let i = 0; i < k; i++) {\n        arc(2 + i, 3 + i, k + 1 - i);\n        arc(2 + i, hub, 1);\n    }\n    arc(2 + k, chainEnd, 1);\n    arc(2 + k, hub, 1);\n    for (let j = hub; j < chainEnd; j++) {\n        arc(j, j + 1, k + 1);\n    }\n    for (let i = 0; i <= 2 * k; i++) {\n        arc(b0 + i, b0 + i + 1, k);\n    }\n    for (let i = 0; i < k; i++) {\n        arc(b0 + i, b0 + 2 * k + 1 - i, 1);\n    }\n    arc(0, 2, AK_BIG);\n    arc(0, b0, AK_BIG);\n    arc(chainEnd, 1, AK_BIG);\n    arc(b0 + 2 * k + 1, 1, AK_BIG);\n    return toNetwork(n, out, capacities, 0, 1, {});\n}\n","/**\n * Geometric random graphs: nodes are random points, edges depend on the distance between them.\n * Every generator emits its points as Float64Array node columns `x`, `y` (and `z` in 3D), so the\n * `weights: { kind: \"euclidean\" }` option and a fixed layout can use them.\n *\n * Node i's point always comes from its own stream block i, so the points do not depend on n or on\n * how the work is split. Edge decisions compare squared distances (no square root).\n */\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { checkEdgeCount, checkInt, checkProbability, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** L of the Waxman model: the diagonal of the unit square, the largest possible distance. */\nconst WAXMAN_L = Math.SQRT2;\n\n/** The largest expected number of Waxman candidate draws, beta n^2 / 2. */\nconst WAXMAN_MAX_DRAWS = 5e8;\n\n/**\n * Throw unless `dimension` is 2 or 3.\n * @param dimension - the option value\n * @returns the dimension\n */\nfunction checkDimension(dimension: number | undefined): 2 | 3 {\n    const d = dimension ?? 2;\n    if (d !== 2 && d !== 3) {\n        throw new RangeError(`dimension must be 2 or 3, got ${String(d)}`);\n    }\n    return d;\n}\n\n/**\n * Throw unless `value` is a finite number >= 0 (or > 0 when `positive`).\n * @param name - the option name\n * @param value - the value\n * @param positive - whether 0 is excluded\n */\nfunction checkNonNegative(name: string, value: number, positive = false): void {\n    if (!(Number.isFinite(value) && (positive ? value > 0 : value >= 0))) {\n        throw new RangeError(`${name} must be a finite number ${positive ? \">\" : \">=\"} 0, got ${String(value)}`);\n    }\n}\n\n/**\n * Uniform points in [0, 1)^dimension: point i takes `dimension` nextFloat() draws (x, then y, then\n * z) from stream (seed, domain, i).\n * @param seed - the seed\n * @param domain - the points' stream domain\n * @param n - the point count\n * @param dimension - 2 or 3\n * @returns one column per axis\n */\nfunction uniformPoints(seed: number, domain: string, n: number, dimension: number): Float64Array<ArrayBuffer>[] {\n    const axes = Array.from({ length: dimension }, () => new Float64Array(n));\n    const stream = new RandomStream(seed, domain, 0);\n    for (let i = 0; i < n; i++) {\n        stream.reset(i);\n        for (const axis of axes) {\n            axis[i] = stream.nextFloat();\n        }\n    }\n    return axes;\n}\n\n/**\n * The position columns x, y (and z) of a graph.\n * @param axes - the coordinate columns\n * @returns the node columns\n */\nfunction positionColumns(axes: Float64Array<ArrayBuffer>[]): Record<string, Float64Array<ArrayBuffer>> {\n    const names = [\"x\", \"y\", \"z\"];\n    return Object.fromEntries(axes.map((axis, a) => [names[a], axis]));\n}\n\n/**\n * The largest g >= 1 with g^dimension <= target.\n * @param target - the cell budget\n * @param dimension - 2 or 3\n * @returns cells per axis\n */\nfunction cellsPerAxis(target: number, dimension: number): number {\n    let g = 1;\n    while ((g + 1) ** dimension <= target) {\n        g++;\n    }\n    return g;\n}\n\n/** Points bucketed into a uniform grid of g^dimension cells by a counting sort. */\ninterface CellGrid {\n    /** Cells per axis. */\n    readonly g: number;\n    /** The low corner of the grid on every axis. */\n    readonly lo: readonly number[];\n    /** The cell side on every axis. */\n    readonly side: readonly number[];\n    /** start[c] .. start[c + 1] indexes `items` for cell c. */\n    readonly start: Uint32Array;\n    /** Point indices grouped by cell, ascending inside each cell. */\n    readonly items: Uint32Array;\n    /** The cell coordinate of every point on every axis. */\n    readonly cell: Uint32Array[];\n}\n\n/**\n * Bucket points into a g^dimension grid spanning [lo, hi] on each axis.\n * @param axes - the coordinate columns\n * @param g - cells per axis\n * @param lo - the low corner per axis\n * @param hi - the high corner per axis\n * @returns the grid\n */\nfunction buildGrid(axes: Float64Array[], g: number, lo: number[], hi: number[]): CellGrid {\n    const n = axes[0].length;\n    const side = lo.map((l, a) => (hi[a] - l) / g || 1);\n    const cell = axes.map(() => new Uint32Array(n));\n    const flat = new Uint32Array(n);\n    const start = new Uint32Array(g ** axes.length + 1);\n    for (let i = 0; i < n; i++) {\n        let c = 0;\n        for (let a = 0; a < axes.length; a++) {\n            const k = Math.min(g - 1, Math.floor((axes[a][i] - lo[a]) / side[a]));\n            cell[a][i] = k;\n            c = c * g + k;\n        }\n        flat[i] = c;\n        start[c + 1]++;\n    }\n    for (let c = 0; c + 1 < start.length; c++) {\n        start[c + 1] += start[c];\n    }\n    const fill = start.slice(0, -1);\n    const items = new Uint32Array(n);\n    for (let i = 0; i < n; i++) {\n        items[fill[flat[i]]++] = i;\n    }\n    return { g, lo, side, start, items, cell };\n}\n\n/** Options of {@link randomGeometricGraph}. */\nexport interface RandomGeometricOptions extends WeightOptions {\n    /** The node count, >= 0. */\n    n: number;\n    /** The connection radius, a finite number >= 0: u and v are joined iff their distance is <= radius. */\n    radius: number;\n    /** 2 (the unit square, default) or 3 (the unit cube). */\n    dimension?: 2 | 3 | undefined;\n    /** Measure distance on the torus (each axis wraps around), removing the boundary effect; default false. */\n    periodic?: boolean | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The random geometric graph (E. N. Gilbert, \"Random plane networks\", J. SIAM 9(4), 533-543, 1961,\n * doi:10.1137/0109045; M. Penrose, Random Geometric Graphs, Oxford University Press, 2003): n\n * uniform points in the unit square or cube, u and v joined iff their Euclidean distance (torus\n * distance when `periodic`) is at most `radius`.\n *\n * Node i's point is x, y (, z) = one nextFloat() per axis from stream (seed, \"rgg-points\", i). The\n * points are bucketed into a uniform grid of cells of side >= radius (at most about n cells) and\n * each node checks the 3^dimension cells around its own. Edges are the pairs (u, v), u < v,\n * ascending u then ascending v. Expected cost O(n + m). Node columns `x`, `y` (, `z`): Float64Array\n * in [0, 1). The mean degree is about n pi r^2 in 2D and n 4/3 pi r^3 in 3D (less near the border\n * unless periodic); connectivity needs r above about sqrt(ln n / (pi n)) in 2D.\n * @param options - n, radius, dimension, periodic and seed\n * @returns the undirected graph\n */\nexport function randomGeometricGraph(options: RandomGeometricOptions): SampleGraph {\n    const { n, radius } = options;\n    checkInt(\"n\", n, 0);\n    checkNonNegative(\"radius\", radius);\n    const dimension = checkDimension(options.dimension);\n    const periodic = options.periodic ?? false;\n    const seed = resolveSeed(options.seed);\n    const axes = uniformPoints(seed, \"rgg-points\", n, dimension);\n\n    const r2 = radius * radius;\n    // cells a hair wider than the radius, so a point rounded into the next cell is still covered\n    const g = Math.max(1, Math.min(Math.floor((1 - 1e-9) / radius), cellsPerAxis(Math.max(1, n), dimension)));\n    const grid = buildGrid(axes, g, new Array<number>(dimension).fill(0), new Array<number>(dimension).fill(1));\n    const volume = dimension === 2 ? Math.PI * r2 : (4 / 3) * Math.PI * r2 * radius;\n    const pairs = (n * (n - 1)) / 2;\n    const out = new EdgeBuffer(Math.ceil(Math.min(pairs, pairs * volume * 1.1, 1 << 24) + 16));\n\n    // the distinct neighbouring cell coordinates of cell k on one axis\n    const around = Array.from({ length: g }, (_, k) => {\n        const list = periodic ? [(k + g - 1) % g, k, (k + 1) % g] : [k - 1, k, k + 1].filter((c) => c >= 0 && c < g);\n        return [...new Set(list)];\n    });\n    let found = new Uint32Array(16);\n    for (let u = 0; u < n; u++) {\n        let count = 0;\n        const zCells = dimension === 3 ? around[grid.cell[2][u]] : [0];\n        for (const cx of around[grid.cell[0][u]]) {\n            for (const cy of around[grid.cell[1][u]]) {\n                for (const cz of zCells) {\n                    const c = dimension === 3 ? (cx * g + cy) * g + cz : cx * g + cy;\n                    for (let t = grid.start[c]; t < grid.start[c + 1]; t++) {\n                        const v = grid.items[t];\n                        if (v <= u) {\n                            continue;\n                        }\n                        let d2 = 0;\n                        for (const axis of axes) {\n                            let d = Math.abs(axis[u] - axis[v]);\n                            if (periodic && d > 0.5) {\n                                d = 1 - d;\n                            }\n                            d2 += d * d;\n                        }\n                        if (d2 <= r2) {\n                            if (count === found.length) {\n                                const grown = new Uint32Array(count * 2);\n                                grown.set(found);\n                                found = grown;\n                            }\n                            found[count++] = v;\n                        }\n                    }\n                }\n            }\n        }\n        const row = found.subarray(0, count).sort();\n        for (const v of row) {\n            out.push(u, v);\n        }\n    }\n    return applyWeights(toGraph(n, out, false, positionColumns(axes)), options);\n}\n\n/** Options of {@link waxmanGraph}. */\nexport interface WaxmanOptions extends WeightOptions {\n    /** The node count, >= 0; beta n^2 / 2 must stay below 5e8. */\n    n: number;\n    /** The distance scale, a finite number > 0: larger alpha makes long edges likelier. */\n    alpha: number;\n    /** The edge probability at distance 0, in [0, 1]. */\n    beta: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/** The checked and precomputed form of {@link WaxmanOptions}. */\ninterface WaxmanPlan {\n    readonly n: number;\n    readonly seed: number;\n    readonly beta: number;\n    readonly logQ: number;\n    /** alpha L. */\n    readonly scale: number;\n    readonly x: Float64Array<ArrayBuffer>;\n    readonly y: Float64Array<ArrayBuffer>;\n}\n\n/**\n * Check the Waxman options and draw the points.\n * @param options - the options\n * @returns the plan\n */\nexport function planWaxman(options: WaxmanOptions): WaxmanPlan {\n    const { n, alpha, beta } = options;\n    checkInt(\"n\", n, 0);\n    checkNonNegative(\"alpha\", alpha, true);\n    checkProbability(\"beta\", beta);\n    const seed = resolveSeed(options.seed);\n    if ((beta * n * n) / 2 > WAXMAN_MAX_DRAWS) {\n        throw new RangeError(\n            `waxmanGraph: beta n^2 / 2 = ${(beta * n * n) / 2} candidate pairs, above the limit of ${WAXMAN_MAX_DRAWS}`,\n        );\n    }\n    const [x, y] = uniformPoints(seed, \"waxman-points\", n, 2);\n    return { n, seed, beta, logQ: detLog(1 - beta), scale: alpha * WAXMAN_L, x, y };\n}\n\n/**\n * Rows [start, end) of the Waxman graph: row u draws from stream (seed, \"waxman\", u), walks the\n * candidates v > u by geometric skipping at probability beta (one draw per skip), and keeps a\n * candidate with a second draw t iff d^2 < (alpha L ln t)^2, which is t < exp(-d / (alpha L)) with\n * no exp. Edges ascend in v. Any split of [0, n) into consecutive ranges gives the whole graph.\n * @param plan - the checked options and points\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the edges\n */\nexport function waxmanRows(plan: WaxmanPlan, start: number, end: number, out: EdgeBuffer): void {\n    const { n, beta, logQ, scale, x, y } = plan;\n    if (beta === 0) {\n        return;\n    }\n    const stream = new RandomStream(plan.seed, \"waxman\", 0);\n    const skip = (): number => (beta === 1 ? 0 : stream.nextSkip(logQ));\n    for (let u = start; u < end; u++) {\n        stream.reset(u);\n        for (let v = u + 1 + skip(); v < n; v += 1 + skip()) {\n            const dx = x[u] - x[v];\n            const dy = y[u] - y[v];\n            const bound = scale * detLog(stream.nextFloat());\n            if (dx * dx + dy * dy < bound * bound) {\n                out.push(u, v);\n            }\n        }\n    }\n}\n\n/**\n * The Waxman graph (B. M. Waxman, \"Routing of multipoint connections\", IEEE J. Selected Areas in\n * Communications 6(9), 1617-1622, 1988): n uniform points in the unit square, each pair joined\n * independently with probability beta exp(-d / (alpha L)).\n *\n * L is fixed at sqrt(2), the diagonal of the unit square (networkx uses the largest distance\n * between the drawn points instead, so the two differ slightly). Node i's point is x, y = two\n * nextFloat() draws from stream (seed, \"waxman-points\", i); the pairs are drawn by\n * {@link waxmanRows}. Edges are the pairs (u, v), u < v, ascending u then v. Every pair has a\n * non-zero probability, so the cost is O(n + beta n^2 / 2) draws; above 5e8 expected draws it\n * throws a RangeError (n about 31,600 at beta 1). Node columns `x`, `y`: Float64Array in [0, 1).\n * @param options - n, alpha, beta and seed\n * @returns the undirected graph\n */\nexport function waxmanGraph(options: WaxmanOptions): SampleGraph {\n    const plan = planWaxman(options);\n    const out = new EdgeBuffer(Math.min(Math.ceil((plan.beta * plan.n * plan.n) / 8), 1 << 24) + 16);\n    waxmanRows(plan, 0, plan.n, out);\n    return applyWeights(toGraph(plan.n, out, false, positionColumns([plan.x, plan.y])), options);\n}\n\n/** Options of {@link knnGraph}. */\nexport interface KnnOptions extends WeightOptions {\n    /** The node count, >= 0. */\n    n: number;\n    /** The neighbours per node, in [0, n - 1]. */\n    k: number;\n    /** 2 (default) or 3. */\n    dimension?: 2 | 3 | undefined;\n    /** Arcs u -> each of u's k nearest (default true), or with false the undirected union without duplicates. */\n    directed?: boolean | undefined;\n    /** Draw the points from a mixture of this many Gaussian clusters, >= 1; default uniform points. */\n    clusters?: number | undefined;\n    /** The standard deviation of every cluster on each axis, a finite number >= 0; default 0.05. Needs `clusters`. */\n    spread?: number | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Gaussian mixture points: cluster c's centre is `dimension` nextFloat() draws from stream\n * (seed, \"knn-centres\", c); point i draws its cluster with nextBelow(clusters) and then standard\n * normal offsets by the Marsaglia polar method (pairs u, v = 2 nextFloat() - 1 until\n * 0 < s = u^2 + v^2 < 1, then u sqrt(-2 ln s / s) and v sqrt(-2 ln s / s)), all from stream\n * (seed, \"knn-points\", i).\n * @param seed - the seed\n * @param n - the point count\n * @param dimension - 2 or 3\n * @param clusters - the cluster count\n * @param spread - the standard deviation\n * @returns the coordinate columns and the cluster of every point\n */\nfunction mixturePoints(\n    seed: number,\n    n: number,\n    dimension: number,\n    clusters: number,\n    spread: number,\n): { axes: Float64Array<ArrayBuffer>[]; community: Uint32Array<ArrayBuffer> } {\n    const centres = uniformPoints(seed, \"knn-centres\", clusters, dimension);\n    const axes = Array.from({ length: dimension }, () => new Float64Array(n));\n    const community = new Uint32Array(n);\n    const stream = new RandomStream(seed, \"knn-points\", 0);\n    const normals = new Float64Array(4);\n    for (let i = 0; i < n; i++) {\n        stream.reset(i);\n        const c = stream.nextBelow(clusters);\n        community[i] = c;\n        for (let j = 0; j < dimension; j += 2) {\n            let u: number;\n            let v: number;\n            let s: number;\n            do {\n                u = 2 * stream.nextFloat() - 1;\n                v = 2 * stream.nextFloat() - 1;\n                s = u * u + v * v;\n            } while (s >= 1 || s === 0);\n            const m = Math.sqrt((-2 * detLog(s)) / s);\n            normals[j] = u * m;\n            normals[j + 1] = v * m;\n        }\n        for (let a = 0; a < dimension; a++) {\n            axes[a][i] = centres[a][c] + spread * normals[a];\n        }\n    }\n    return { axes, community };\n}\n\n/**\n * The k nearest neighbours of every point, exact, by an expanding ring search over a cell grid.\n * @param axes - the coordinate columns\n * @param k - neighbours per point\n * @returns row u's neighbours at [u k, (u + 1) k), ascending by index\n */\nfunction nearestNeighbours(axes: Float64Array[], k: number): Uint32Array<ArrayBuffer> {\n    const n = axes[0].length;\n    const dimension = axes.length;\n    const result = new Uint32Array(n * k);\n    if (k === 0) {\n        return result;\n    }\n    const lo = axes.map((axis) => axis.reduce((a, b) => Math.min(a, b), Infinity));\n    const hi = axes.map((axis) => axis.reduce((a, b) => Math.max(a, b), -Infinity));\n    const g = cellsPerAxis(Math.max(1, n / k), dimension);\n    const grid = buildGrid(axes, g, lo, hi);\n    const bestD = new Float64Array(k);\n    const bestI = new Uint32Array(k);\n    // the absolute rounding slack of a cell assignment\n    const slack = 1e-12 * Math.max(1, ...lo.map(Math.abs), ...hi.map(Math.abs));\n    const cell = new Array<number>(dimension).fill(0);\n    const offset = new Array<number>(dimension).fill(0);\n    for (let u = 0; u < n; u++) {\n        let count = 0;\n        const consider = (v: number): void => {\n            let d2 = 0;\n            for (const axis of axes) {\n                const d = Math.abs(axis[u] - axis[v]);\n                d2 += d * d;\n            }\n            // insert (d2, v) into the sorted best list when it beats the worst kept\n            if (count === k && (d2 > bestD[k - 1] || (d2 === bestD[k - 1] && v > bestI[k - 1]))) {\n                return;\n            }\n            let j = count < k ? count++ : k - 1;\n            while (j > 0 && (bestD[j - 1] > d2 || (bestD[j - 1] === d2 && bestI[j - 1] > v))) {\n                bestD[j] = bestD[j - 1];\n                bestI[j] = bestI[j - 1];\n                j--;\n            }\n            bestD[j] = d2;\n            bestI[j] = v;\n        };\n        for (let a = 0; a < dimension; a++) {\n            cell[a] = grid.cell[a][u];\n        }\n        // ponytail: ring r scans the whole (2r + 1)^dimension block and skips its inside, O(r^dimension)\n        // per ring; walk only the shell if large k or very uneven clusters make that measurable\n        for (let r = 0; ; r++) {\n            let covered = true;\n            for (let a = 0; a < dimension; a++) {\n                offset[a] = -r;\n                if (cell[a] - r > 0 || cell[a] + r < g - 1) {\n                    covered = false;\n                }\n            }\n            for (;;) {\n                let chebyshev = 0;\n                let inside = true;\n                let c = 0;\n                for (let a = 0; a < dimension; a++) {\n                    const k2 = cell[a] + offset[a];\n                    if (k2 < 0 || k2 >= g) {\n                        inside = false;\n                    }\n                    chebyshev = Math.max(chebyshev, Math.abs(offset[a]));\n                    c = c * g + k2;\n                }\n                if (inside && chebyshev === r) {\n                    for (let t = grid.start[c]; t < grid.start[c + 1]; t++) {\n                        const v = grid.items[t];\n                        if (v !== u) {\n                            consider(v);\n                        }\n                    }\n                }\n                let a = dimension - 1;\n                while (a >= 0 && offset[a] === r) {\n                    offset[a] = -r;\n                    a--;\n                }\n                if (a < 0) {\n                    break;\n                }\n                offset[a]++;\n            }\n            if (covered) {\n                break;\n            }\n            if (count === k) {\n                // every point outside the searched block is at least `gap` away\n                let gap = Infinity;\n                for (let a = 0; a < dimension; a++) {\n                    const p = axes[a][u] - grid.lo[a];\n                    gap = Math.min(gap, p - (cell[a] - r) * grid.side[a], (cell[a] + r + 1) * grid.side[a] - p);\n                }\n                // the margins cover the rounding of the cell assignment and of the squared distances, so\n                // a point outside the block can never tie or beat the k-th best\n                gap -= slack;\n                if (gap > 0 && bestD[k - 1] < gap * gap * (1 - 1e-9)) {\n                    break;\n                }\n            }\n        }\n        const row = result.subarray(u * k, (u + 1) * k);\n        row.set(bestI);\n        row.sort();\n    }\n    return result;\n}\n\n/**\n * The k-nearest-neighbour graph of random points, the standard input of spectral clustering\n * (U. von Luxburg, \"A tutorial on spectral clustering\", Statistics and Computing 17, 395-416, 2007,\n * doi:10.1007/s11222-007-9033-z).\n *\n * Points: uniform in the unit square or cube (point i = nextFloat() per axis from stream\n * (seed, \"knn-points\", i)), or with `clusters` a Gaussian mixture: cluster centres uniform in the\n * unit cube from stream (seed, \"knn-centres\", c), point i picks its cluster uniformly and adds\n * normal offsets of standard deviation `spread` (Marsaglia polar method) from stream\n * (seed, \"knn-points\", i); mixture points may leave [0, 1). Each node's k nearest are exact,\n * ties broken by the smaller index, found by an expanding ring search over a cell grid of about\n * n / k cells: expected O(n k^2) for uniform points.\n *\n * Directed (default): the arcs u -> each of its k nearest, ascending u then ascending target.\n * Undirected: the union of those pairs without duplicates as (u, v), u < v, ascending u then v.\n * Node columns `x`, `y` (, `z`): Float64Array; with `clusters`, `community` (u32): the cluster.\n * @param options - n, k, dimension, directed, clusters, spread and seed\n * @returns the graph\n */\nexport function knnGraph(options: KnnOptions): SampleGraph {\n    const { n, k, clusters, spread } = options;\n    checkInt(\"n\", n, 0);\n    checkInt(\"k\", k, 0, Math.max(0, n - 1));\n    const dimension = checkDimension(options.dimension);\n    const directed = options.directed ?? true;\n    if (clusters === undefined && spread !== undefined) {\n        throw new RangeError(\"spread needs clusters\");\n    }\n    const seed = resolveSeed(options.seed);\n    let axes: Float64Array<ArrayBuffer>[];\n    const columns: Record<string, Float64Array<ArrayBuffer> | Uint32Array<ArrayBuffer>> = {};\n    if (clusters === undefined) {\n        axes = uniformPoints(seed, \"knn-points\", n, dimension);\n    } else {\n        checkInt(\"clusters\", clusters, 1);\n        const sd = spread ?? 0.05;\n        checkNonNegative(\"spread\", sd);\n        let community: Uint32Array<ArrayBuffer>;\n        ({ axes, community } = mixturePoints(seed, n, dimension, clusters, sd));\n        columns.community = community;\n    }\n    Object.assign(columns, positionColumns(axes));\n    const neighbours = nearestNeighbours(axes, k);\n    checkEdgeCount(n * k);\n    let out: EdgeBuffer;\n    if (directed) {\n        out = new EdgeBuffer(n * k);\n        for (let u = 0; u < n; u++) {\n            for (let j = u * k; j < (u + 1) * k; j++) {\n                out.push(u, neighbours[j]);\n            }\n        }\n    } else {\n        // bucket the pairs (min, max) by their smaller end with a counting sort, then sort and dedupe each bucket\n        const start = new Uint32Array(n + 1);\n        for (let u = 0; u < n; u++) {\n            for (let j = u * k; j < (u + 1) * k; j++) {\n                start[Math.min(u, neighbours[j]) + 1]++;\n            }\n        }\n        for (let u = 0; u < n; u++) {\n            start[u + 1] += start[u];\n        }\n        const fill = start.slice(0, -1);\n        const other = new Uint32Array(n * k);\n        for (let u = 0; u < n; u++) {\n            for (let j = u * k; j < (u + 1) * k; j++) {\n                const v = neighbours[j];\n                other[fill[Math.min(u, v)]++] = Math.max(u, v);\n            }\n        }\n        out = new EdgeBuffer(n * k);\n        for (let u = 0; u < n; u++) {\n            const row = other.subarray(start[u], start[u + 1]).sort();\n            for (let j = 0; j < row.length; j++) {\n                if (j === 0 || row[j] !== row[j - 1]) {\n                    out.push(u, row[j]);\n                }\n            }\n        }\n    }\n    return applyWeights(toGraph(n, out, directed, columns), options);\n}\n","/**\n * Sequential growth models: the random recursive tree, forest fire, duplication-divergence,\n * Newman-Watts, Bianconi-Barabasi fitness, the random Apollonian network and Wilson's uniform\n * spanning tree of a grid (a perfect maze). Each draws from one stream (seed, domain, 0): the\n * processes are sequential, so there is no row-parallel form.\n */\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { checkEdgeCount, checkInt, checkProbability, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** Options of {@link randomRecursiveTreeGraph}. */\nexport interface RandomRecursiveTreeOptions extends WeightOptions {\n    /** The node count, >= 1. */\n    n: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The random recursive tree (R. T. Smythe and H. M. Mahmoud, \"A survey of recursive trees\",\n * Theory Probab. Math. Statist. 51, 1-27, 1995): node t = 1 .. n - 1 attaches to a uniform earlier\n * node, drawn as nextBelow(t) from the stream (seed, \"recursive-tree\", 0). Edge t - 1 is\n * (parent, t), in t order. O(n). Depth about ln n, root degree about ln n.\n * @param options - n and seed\n * @returns the undirected tree\n */\nexport function randomRecursiveTreeGraph(options: RandomRecursiveTreeOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 1);\n    const stream = new RandomStream(resolveSeed(options.seed), \"recursive-tree\", 0);\n    const src = new Uint32Array(n - 1);\n    const dst = new Uint32Array(n - 1);\n    for (let t = 1; t < n; t++) {\n        src[t - 1] = stream.nextBelow(t);\n        dst[t - 1] = t;\n    }\n    return applyWeights({ directed: false, nodeCount: n, src, dst }, options);\n}\n\n/** Options of {@link forestFireGraph}. */\nexport interface ForestFireOptions extends WeightOptions {\n    /** The node count, >= 1. */\n    n: number;\n    /** The forward burning probability p, in [0, 1). */\n    forward: number;\n    /** The backward burning ratio r >= 0; the backward burning probability r p must be below 1. */\n    backward: number;\n    /** The most nodes one new node may burn (and link to), >= 1; default 1000. */\n    maxBurn?: number | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Pick `count` of `candidates` uniformly without replacement (a partial Fisher-Yates shuffle in\n * place): the picks are candidates[0 .. count).\n * @param stream - the stream\n * @param candidates - the candidates, reordered in place\n * @param count - how many to pick, <= candidates.length\n */\nfunction pickPrefix(stream: RandomStream, candidates: number[], count: number): void {\n    for (let i = 0; i < count; i++) {\n        const j = i + stream.nextBelow(candidates.length - i);\n        const t = candidates[i];\n        candidates[i] = candidates[j];\n        candidates[j] = t;\n    }\n}\n\n/**\n * The forest fire model (J. Leskovec, J. Kleinberg and C. Faloutsos, \"Graphs over time:\n * densification laws, shrinking diameters and possible explanations\", KDD 2005,\n * doi:10.1145/1081870.1081893). Directed; heavy-tailed degrees, densification, community locality.\n *\n * Node 0 starts alone. Each new node v = 1 .. n - 1 draws an ambassador w = nextBelow(v) and burns\n * breadth-first from it: for each burning node x in burn order, draw x_out = floor(ln(1 - u) / ln p)\n * (geometric, P(x_out >= k) = p^k, mean p / (1 - p)) and then x_in the same way with r p; then pick\n * x_out of x's out-neighbours and then x_in of its in-neighbours uniformly among those not yet\n * burned (adjacency order, partial Fisher-Yates; all of them when there are fewer), and burn them.\n * Burning stops at `maxBurn` nodes. v then links to every burned node: arcs (v, t) in burn order.\n * Edges are listed by v. All draws come from the stream (seed, \"forest-fire\", 0).\n *\n * Cost: O(sum over burning nodes of their degree), since each burning node's lists are scanned;\n * the edge count explodes for p above about 0.37, which `maxBurn` bounds at n maxBurn arcs.\n * @param options - n, forward, backward, maxBurn and seed\n * @returns the directed graph\n */\nexport function forestFireGraph(options: ForestFireOptions): SampleGraph {\n    const { n, forward: p, backward: r } = options;\n    const maxBurn = options.maxBurn ?? 1000;\n    checkInt(\"n\", n, 1);\n    if (!(p >= 0 && p < 1)) {\n        throw new RangeError(`forward must be a probability in [0, 1), got ${String(p)}`);\n    }\n    if (!(r >= 0 && r * p < 1)) {\n        throw new RangeError(`backward must be >= 0 with backward * forward < 1, got ${String(r)}`);\n    }\n    checkInt(\"maxBurn\", maxBurn, 1);\n    const stream = new RandomStream(resolveSeed(options.seed), \"forest-fire\", 0);\n    const pb = r * p;\n    const logForward = detLog(p);\n    const logBackward = detLog(pb);\n    // ponytail: number[][] adjacency, fine to a few million arcs; a growable CSR beyond\n    const out: number[][] = Array.from({ length: n }, () => []);\n    const inn: number[][] = Array.from({ length: n }, () => []);\n    const stamp = new Uint32Array(n);\n    const edges = new EdgeBuffer(4 * n);\n    const burned: number[] = [];\n    const burn = (v: number, list: number[], count: number): void => {\n        const candidates = list.filter((t) => stamp[t] !== v);\n        const take = Math.min(count, candidates.length, maxBurn - burned.length);\n        pickPrefix(stream, candidates, take);\n        for (let i = 0; i < take; i++) {\n            stamp[candidates[i]] = v;\n            burned.push(candidates[i]);\n        }\n    };\n    for (let v = 1; v < n; v++) {\n        burned.length = 0;\n        const w = stream.nextBelow(v);\n        stamp[w] = v;\n        burned.push(w);\n        for (let head = 0; head < burned.length && burned.length < maxBurn; head++) {\n            const x = burned[head];\n            const xOut = p === 0 ? 0 : stream.nextSkip(logForward);\n            const xIn = pb === 0 ? 0 : stream.nextSkip(logBackward);\n            burn(v, out[x], xOut);\n            burn(v, inn[x], xIn);\n        }\n        for (const t of burned) {\n            edges.push(v, t);\n            out[v].push(t);\n            inn[t].push(v);\n        }\n    }\n    return applyWeights(toGraph(n, edges, true), options);\n}\n\n/** Options of {@link duplicationDivergenceGraph}. */\nexport interface DuplicationDivergenceOptions extends WeightOptions {\n    /** The node count, >= 2. */\n    n: number;\n    /** The probability that a duplicate keeps each of the original's edges, in (0, 1]. */\n    retention: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The duplication-divergence model (I. Ispolatov, P. L. Krapivsky and A. Yuryev,\n * \"Duplication-divergence model of protein interaction network\", Phys. Rev. E 71, 061911, 2005,\n * doi:10.1103/PhysRevE.71.061911), as networkx's `duplication_divergence_graph`: protein-network\n * like, with many nodes sharing neighbours.\n *\n * Start with the edge (0, 1). While there are fewer than n nodes, draw a node x = nextBelow(i) for\n * the next index i, then one float per neighbour of x (in the order they were joined to x): below\n * `retention`, the edge (i, neighbour). If i got at least one edge it is kept, otherwise the attempt\n * is discarded. All draws come from the stream (seed, \"duplication-divergence\", 0). Edges are\n * listed by new node. Simple and connected.\n *\n * Cost: O(sum of the copied nodes' degrees). Each attempt succeeds with probability at least\n * `retention`; after 1000 n attempts in total it throws a RangeError rather than loop on.\n * @param options - n, retention and seed\n * @returns the undirected graph\n */\nexport function duplicationDivergenceGraph(options: DuplicationDivergenceOptions): SampleGraph {\n    const { n, retention } = options;\n    checkInt(\"n\", n, 2);\n    if (!(retention > 0 && retention <= 1)) {\n        throw new RangeError(`retention must be a probability in (0, 1], got ${String(retention)}`);\n    }\n    const stream = new RandomStream(resolveSeed(options.seed), \"duplication-divergence\", 0);\n    // ponytail: number[][] adjacency, fine to a few million edges; a growable CSR beyond\n    const adj: number[][] = Array.from({ length: n }, () => []);\n    const edges = new EdgeBuffer(4 * n);\n    edges.push(0, 1);\n    adj[0].push(1);\n    adj[1].push(0);\n    const maxAttempts = 1000 * n;\n    let attempts = 0;\n    for (let i = 2; i < n; ) {\n        if (++attempts > maxAttempts) {\n            throw new RangeError(\n                `duplicationDivergenceGraph gave up after ${maxAttempts} attempts at ${i} of ${n} nodes: retention ${retention} is too small`,\n            );\n        }\n        const copied = adj[stream.nextBelow(i)];\n        for (const t of copied) {\n            if (stream.nextFloat() < retention) {\n                edges.push(i, t);\n                adj[i].push(t);\n            }\n        }\n        for (const t of adj[i]) {\n            adj[t].push(i);\n        }\n        if (adj[i].length > 0) {\n            i++;\n        }\n    }\n    return applyWeights(toGraph(n, edges, false), options);\n}\n\n/** Options of {@link newmanWattsGraph}. */\nexport interface NewmanWattsOptions extends WeightOptions {\n    /** The node count, > k. */\n    n: number;\n    /** Each node's ring neighbours, even, >= 2. */\n    k: number;\n    /** The probability of a shortcut per ring edge, in [0, 1]. */\n    p: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The Newman-Watts small world (M. E. J. Newman and D. J. Watts, \"Renormalization group analysis\n * of the small-world network model\", Phys. Lett. A 263, 341-346, 1999,\n * doi:10.1016/S0375-9601(99)00757-4): Watts-Strogatz with shortcuts added instead of rewired, so\n * the graph stays connected.\n *\n * The ring lattice of `wattsStrogatzGraph` comes first: edge slot u k/2 + (j - 1) is\n * (u, (u + j) mod n). Then for each slot in order, with source u: draw a float; if it is below p and\n * u is not joined to every other node, redraw w = nextBelow(n) until w is neither u nor a\n * neighbour of u, and append the shortcut (u, w). All draws come from the stream (seed,\n * \"newman-watts\", 0). O(n k) expected.\n * @param options - n, k, p and seed\n * @returns the undirected graph\n */\nexport function newmanWattsGraph(options: NewmanWattsOptions): SampleGraph {\n    const { n, k, p } = options;\n    checkInt(\"k\", k, 2);\n    if (k % 2 !== 0) {\n        throw new RangeError(`k must be even, got ${k}`);\n    }\n    checkInt(\"n\", n, k + 1);\n    checkProbability(\"p\", p);\n    const half = k / 2;\n    const ring = n * half;\n    checkEdgeCount(2 * ring);\n    const edges = new EdgeBuffer(ring + Math.ceil(ring * p + 6 * Math.sqrt(ring) + 16));\n    const degree = new Uint32Array(n).fill(k);\n    // ponytail: a Set of u * n + v keys, like wattsStrogatzGraph; a hashed typed table beyond millions\n    const present = new Set<number>();\n    const key = (a: number, b: number): number => (a < b ? a * n + b : b * n + a);\n    for (let u = 0; u < n; u++) {\n        for (let j = 1; j <= half; j++) {\n            const v = (u + j) % n;\n            edges.push(u, v);\n            present.add(key(u, v));\n        }\n    }\n    const stream = new RandomStream(resolveSeed(options.seed), \"newman-watts\", 0);\n    for (let slot = 0; slot < ring; slot++) {\n        const u = edges.src[slot];\n        if (stream.nextFloat() >= p || degree[u] >= n - 1) {\n            continue;\n        }\n        let w = stream.nextBelow(n);\n        while (w === u || present.has(key(u, w))) {\n            w = stream.nextBelow(n);\n        }\n        edges.push(u, w);\n        present.add(key(u, w));\n        degree[u]++;\n        degree[w]++;\n    }\n    return applyWeights(toGraph(n, edges, false), options);\n}\n\n/** Options of {@link bianconiBarabasiGraph}. */\nexport interface BianconiBarabasiOptions extends WeightOptions {\n    /** The node count, > m. */\n    n: number;\n    /** The number of edges each new node brings, >= 1. */\n    m: number;\n    /**\n     * Each node's fitness, n finite positive values; default uniform in (0, 1], node i's drawn as\n     * 1 - nextFloat() from the stream (seed, \"fitness\", i).\n     */\n    fitness?: ArrayLike<number> | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The Bianconi-Barabasi fitness model (G. Bianconi and A.-L. Barabasi, \"Competition and\n * multiscaling in evolving networks\", Europhys. Lett. 54, 436-442, 2001,\n * doi:10.1209/epl/i2001-00260-6): preferential attachment weighted by fitness, so a fit latecomer\n * can overtake older hubs (\"fit get richer\").\n *\n * Start from the clique on nodes 0 .. m, edges (a, b) for a < b in lexicographic order. Each new\n * node s = m + 1 .. n - 1 picks m distinct existing nodes, one at a time, with probability\n * proportional to fitness_i * degree_i among those not yet picked: x = nextFloat() * total, then a\n * descent of a Fenwick tree over the Float64 weights. Edges (s, t) follow in pick order. Draws\n * come from the stream (seed, \"bianconi-barabasi\", 0). O(n m log n). Emits the Float64 node column\n * `fitness`.\n * @param options - n, m, fitness and seed\n * @returns the undirected graph\n */\nexport function bianconiBarabasiGraph(options: BianconiBarabasiOptions): SampleGraph {\n    const { n, m } = options;\n    checkInt(\"m\", m, 1);\n    checkInt(\"n\", n, m + 1);\n    const seed = resolveSeed(options.seed);\n    checkEdgeCount((m * (m + 1)) / 2 + (n - m - 1) * m);\n    const fitness = new Float64Array(n);\n    if (options.fitness === undefined) {\n        const draw = new RandomStream(seed, \"fitness\", 0);\n        for (let i = 0; i < n; i++) {\n            draw.reset(i);\n            fitness[i] = 1 - draw.nextFloat();\n        }\n    } else {\n        if (options.fitness.length !== n) {\n            throw new RangeError(`fitness must have n = ${n} values, got ${options.fitness.length}`);\n        }\n        for (let i = 0; i < n; i++) {\n            const f = options.fitness[i];\n            if (!(f > 0 && Number.isFinite(f))) {\n                throw new RangeError(`fitness[${i}] must be finite and positive, got ${String(f)}`);\n            }\n            fitness[i] = f;\n        }\n    }\n    const edges = new EdgeBuffer((m * (m + 1)) / 2 + (n - m - 1) * m);\n    const degree = new Uint32Array(n);\n    for (let a = 0; a <= m; a++) {\n        for (let b = a + 1; b <= m; b++) {\n            edges.push(a, b);\n        }\n        degree[a] = m;\n    }\n    // Fenwick tree over weight[i] = fitness[i] * degree[i] (1-based internally)\n    const weight = new Float64Array(n);\n    const tree = new Float64Array(n + 1);\n    const add = (i: number, delta: number): void => {\n        weight[i] += delta;\n        for (let j = i + 1; j <= n; j += j & -j) {\n            tree[j] += delta;\n        }\n    };\n    let top = 1;\n    while (top * 2 <= n) {\n        top *= 2;\n    }\n    const find = (x: number, limit: number): number => {\n        let pos = 0;\n        let rest = x;\n        for (let step = top; step >= 1; step = Math.floor(step / 2)) {\n            if (pos + step <= n && tree[pos + step] <= rest) {\n                pos += step;\n                rest -= tree[pos];\n            }\n        }\n        // rounding guard: land on a node with weight, below the newcomer\n        pos = Math.min(pos, limit - 1);\n        while (weight[pos] === 0) {\n            pos--;\n        }\n        return pos;\n    };\n    let total = 0;\n    for (let i = 0; i <= m; i++) {\n        add(i, fitness[i] * m);\n        total += fitness[i] * m;\n    }\n    const stream = new RandomStream(seed, \"bianconi-barabasi\", 0);\n    const picked = new Uint32Array(m);\n    for (let s = m + 1; s < n; s++) {\n        let remaining = total;\n        for (let i = 0; i < m; i++) {\n            const t = find(stream.nextFloat() * remaining, s);\n            picked[i] = t;\n            remaining -= weight[t];\n            add(t, -weight[t]);\n        }\n        for (let i = 0; i < m; i++) {\n            const t = picked[i];\n            edges.push(s, t);\n            degree[t]++;\n            add(t, fitness[t] * degree[t]);\n        }\n        degree[s] = m;\n        add(s, fitness[s] * m);\n        total = 0;\n        // recompute the total from the tree's roots so it never drifts from the tree\n        for (let j = n; j > 0; j -= j & -j) {\n            total += tree[j];\n        }\n    }\n    return applyWeights(toGraph(n, edges, false, { fitness }), options);\n}\n\n/** Options of {@link randomApollonianGraph}. */\nexport interface RandomApollonianOptions extends WeightOptions {\n    /** The node count, >= 3. */\n    n: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The random Apollonian network (T. Zhou, G. Yan and B.-H. Wang, \"Maximal planar networks with\n * large clustering coefficient and power-law degree distribution\", Phys. Rev. E 71, 046141, 2005,\n * doi:10.1103/PhysRevE.71.046141; the deterministic one is J. S. Andrade et al., Phys. Rev. Lett. 94,\n * 018702, 2005): maximal planar, power-law degrees, high clustering.\n *\n * Start from the triangle 0, 1, 2 (edges (0, 1), (0, 2), (1, 2)) whose inner face is face 0; the\n * outer face is never split. Each new node v = 3 .. n - 1 picks face f = nextBelow(faceCount) =\n * (a, b, c), adds the edges (v, a), (v, b), (v, c), and splits f: face f becomes (a, b, v), and\n * (b, c, v) and (a, c, v) are appended. Draws come from the stream (seed, \"apollonian\", 0).\n * 3n - 6 edges. O(n).\n * @param options - n and seed\n * @returns the undirected graph\n */\nexport function randomApollonianGraph(options: RandomApollonianOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 3);\n    const m = 3 * n - 6;\n    checkEdgeCount(m);\n    const stream = new RandomStream(resolveSeed(options.seed), \"apollonian\", 0);\n    const faces = 2 * n - 5;\n    const fa = new Uint32Array(faces);\n    const fb = new Uint32Array(faces);\n    const fc = new Uint32Array(faces);\n    fa[0] = 0;\n    fb[0] = 1;\n    fc[0] = 2;\n    let faceCount = 1;\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    src.set([0, 0, 1]);\n    dst.set([1, 2, 2]);\n    let e = 3;\n    for (let v = 3; v < n; v++) {\n        const f = stream.nextBelow(faceCount);\n        const a = fa[f];\n        const b = fb[f];\n        const c = fc[f];\n        src.fill(v, e, e + 3);\n        dst[e++] = a;\n        dst[e++] = b;\n        dst[e++] = c;\n        fc[f] = v;\n        fa[faceCount] = b;\n        fb[faceCount] = c;\n        fc[faceCount++] = v;\n        fa[faceCount] = a;\n        fb[faceCount] = c;\n        fc[faceCount++] = v;\n    }\n    return applyWeights({ directed: false, nodeCount: n, src, dst }, options);\n}\n\n/** Options of {@link wilsonMazeGraph}. */\nexport interface WilsonMazeOptions extends WeightOptions {\n    /** The number of rows, >= 1. */\n    rows: number;\n    /** The number of columns, >= 1. */\n    cols: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * A uniform spanning tree of the rows x cols grid, a perfect maze, by Wilson's algorithm\n * (D. B. Wilson, \"Generating random spanning trees more quickly than the cover time\", STOC 1996,\n * doi:10.1145/237814.237880): loop-erased random walks.\n *\n * Node (r, c) is index r cols + c. The root is node 0. For each start node in index order that is\n * not yet in the tree, walk until the tree is hit, each step to a uniform grid neighbour\n * (candidates in the order left, right, up, down; nextBelow(count)), remembering only the last exit\n * from each node (which erases the loops); then add the path: edges (u, next(u)) from the start to\n * the tree, in that order. Draws come from the stream (seed, \"wilson\", 0). rows cols - 1 edges.\n * Float64 node columns `x` = column and `y` = row. Expected cost is the mean hitting time of the\n * root, about O(n log n) on a grid.\n * @param options - rows, cols and seed\n * @returns the undirected tree\n */\nexport function wilsonMazeGraph(options: WilsonMazeOptions): SampleGraph {\n    const { rows, cols } = options;\n    checkInt(\"rows\", rows, 1);\n    checkInt(\"cols\", cols, 1);\n    const n = rows * cols;\n    checkInt(\"rows * cols\", n, 1);\n    const stream = new RandomStream(resolveSeed(options.seed), \"wilson\", 0);\n    const inTree = new Uint8Array(n);\n    const next = new Uint32Array(n);\n    const src = new Uint32Array(n - 1);\n    const dst = new Uint32Array(n - 1);\n    const options4 = new Uint32Array(4);\n    inTree[0] = 1;\n    let e = 0;\n    for (let start = 1; start < n; start++) {\n        let u = start;\n        while (inTree[u] === 0) {\n            const r = Math.floor(u / cols);\n            const c = u - r * cols;\n            let count = 0;\n            if (c > 0) {\n                options4[count++] = u - 1;\n            }\n            if (c + 1 < cols) {\n                options4[count++] = u + 1;\n            }\n            if (r > 0) {\n                options4[count++] = u - cols;\n            }\n            if (r + 1 < rows) {\n                options4[count++] = u + cols;\n            }\n            next[u] = options4[stream.nextBelow(count)];\n            u = next[u];\n        }\n        for (u = start; inTree[u] === 0; u = next[u]) {\n            inTree[u] = 1;\n            src[e] = u;\n            dst[e++] = next[u];\n        }\n    }\n    const x = new Float64Array(n);\n    const y = new Float64Array(n);\n    for (let i = 0; i < n; i++) {\n        y[i] = Math.floor(i / cols);\n        x[i] = i - y[i] * cols;\n    }\n    return applyWeights({ directed: false, nodeCount: n, src, dst, nodeColumns: { x, y } }, options);\n}\n","/**\n * The cosine and sine of a uniformly drawn angle, the same bits on every engine.\n *\n * The angle is given as a turn fraction u in [0, 1) (angle 2 pi u), so the argument reduction is\n * exact: 8u splits into an octant k and a fraction f without rounding, and only f * pi / 4 rounds\n * once. On [0, pi / 4] the polynomials are fdlibm's `__kernel_sin` and `__kernel_cos` (FreeBSD\n * k_sin.c and k_cos.c, Sun Microsystems 1993) with a zero tail, evaluated with the four basic\n * operations only. Error a few ulp; bit-identical everywhere.\n */\n\nconst PIO4 = 7.85398163397448278999e-1;\n\nconst S1 = -1.66666666666666324348e-1;\nconst S2 = 8.33333333332248946124e-3;\nconst S3 = -1.98412698298579493134e-4;\nconst S4 = 2.75573137070700676789e-6;\nconst S5 = -2.50507602534068634195e-8;\nconst S6 = 1.58969099521155010221e-10;\n\nconst C1 = 4.16666666666666019037e-2;\nconst C2 = -1.38888888888741095749e-3;\nconst C3 = 2.48015872894767294178e-5;\nconst C4 = -2.75573143513906633035e-7;\nconst C5 = 2.08757232129817482790e-9;\nconst C6 = -1.13596475577881948265e-11;\n\n/**\n * sin(x) for |x| <= pi / 4.\n * @param x - the argument\n * @returns the sine\n */\nfunction kernelSin(x: number): number {\n    const z = x * x;\n    const r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)));\n    return x + z * x * (S1 + z * r);\n}\n\n/**\n * cos(x) for |x| <= pi / 4.\n * @param x - the argument\n * @returns the cosine\n */\nfunction kernelCos(x: number): number {\n    const z = x * x;\n    const w = z * z;\n    const r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n    const hz = 0.5 * z;\n    const v = 1.0 - hz;\n    return v + (1.0 - v - hz + z * r);\n}\n\n/**\n * cos(2 pi u) and sin(2 pi u).\n * @param u - the turn fraction, in [0, 1)\n * @param out - receives [cos, sin]\n */\nexport function detCosSinTurn(u: number, out: Float64Array): void {\n    const t = u * 8;\n    const octant = Math.floor(t);\n    const x = (t - octant) * PIO4;\n    // the octant's angle is (octant >> 1) quarter turns plus x (even octant) or pi/2 - (pi/4 - x)\n    const odd = (octant & 1) === 1;\n    const z = odd ? PIO4 - x : x;\n    const c = odd ? kernelSin(z) : kernelCos(z);\n    const s = odd ? kernelCos(z) : kernelSin(z);\n    switch ((octant >> 1) & 3) {\n        case 0:\n            out[0] = c;\n            out[1] = s;\n            break;\n        case 1:\n            out[0] = -s;\n            out[1] = c;\n            break;\n        case 2:\n            out[0] = -c;\n            out[1] = -s;\n            break;\n        default:\n            out[0] = s;\n            out[1] = -c;\n    }\n}\n","/**\n * Random hyperbolic graphs (D. Krioukov, F. Papadopoulos, M. Kitsak, A. Vahdat and M. Boguna,\n * \"Hyperbolic geometry of complex networks\", Phys. Rev. E 82, 036106, 2010,\n * doi:10.1103/PhysRevE.82.036106): power-law degrees, high clustering and a native 2D embedding.\n */\n\nimport { detExp } from \"../random/exp.js\";\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { detCosSinTurn } from \"../random/trig.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { checkInt, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** The largest node count of the O(n^2) pair loop. */\nconst MAX_NODES = 20000;\n\n/** Options of {@link hyperbolicGraph}. */\nexport interface HyperbolicOptions extends WeightOptions {\n    /** The node count, in [0, 20000]. */\n    n: number;\n    /** The target mean degree, a finite number > 0 (approximate: see {@link hyperbolicGraph}). */\n    averageDegree: number;\n    /** The power-law exponent gamma of the degree distribution, a finite number > 2. */\n    exponent: number;\n    /** The temperature T in [0, 1); 0 (default) is the threshold model, higher T lowers clustering. */\n    temperature?: number | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/** The checked options, the disk radius and the points. */\ninterface HyperbolicPlan {\n    readonly n: number;\n    readonly seed: number;\n    readonly temperature: number;\n    /** The disk radius R. */\n    readonly R: number;\n    readonly coshR: number;\n    readonly cosT: Float64Array<ArrayBuffer>;\n    readonly sinT: Float64Array<ArrayBuffer>;\n    readonly coshr: Float64Array<ArrayBuffer>;\n    readonly sinhr: Float64Array<ArrayBuffer>;\n    readonly x: Float64Array<ArrayBuffer>;\n    readonly y: Float64Array<ArrayBuffer>;\n    readonly radius: Float64Array<ArrayBuffer>;\n}\n\n/**\n * cosh(x) from detExp.\n * @param x - the argument\n * @returns cosh x\n */\nfunction cosh(x: number): number {\n    return (detExp(x) + detExp(-x)) / 2;\n}\n\n/**\n * acosh(y) for y >= 1 from detLog.\n * @param y - the argument\n * @returns acosh y\n */\nfunction acosh(y: number): number {\n    return detLog(y + Math.sqrt((y - 1) * (y + 1)));\n}\n\n/**\n * Check the options, compute the disk radius and draw the points.\n * @param options - the options\n * @returns the plan\n */\nexport function planHyperbolic(options: HyperbolicOptions): HyperbolicPlan {\n    const { n, averageDegree, exponent } = options;\n    const temperature = options.temperature ?? 0;\n    checkInt(\"n\", n, 0, MAX_NODES);\n    if (!(Number.isFinite(averageDegree) && averageDegree > 0)) {\n        throw new RangeError(`averageDegree must be a finite number > 0, got ${String(averageDegree)}`);\n    }\n    if (!(Number.isFinite(exponent) && exponent > 2)) {\n        throw new RangeError(`exponent must be a finite number > 2, got ${String(exponent)}`);\n    }\n    if (!(temperature >= 0 && temperature < 1)) {\n        throw new RangeError(`temperature must be in [0, 1), got ${String(temperature)}`);\n    }\n    const seed = resolveSeed(options.seed);\n\n    const alpha = (exponent - 1) / 2;\n    const xi = alpha / (alpha - 0.5);\n    let correction = 1;\n    if (temperature > 0) {\n        const cs = new Float64Array(2);\n        detCosSinTurn(temperature / 2, cs);\n        correction = (Math.PI * temperature) / cs[1];\n    }\n    const scale = ((2 * xi * xi * n) / (Math.PI * averageDegree)) * correction;\n    if (n >= 2 && !(scale > 1)) {\n        throw new RangeError(`averageDegree ${averageDegree} is too large for n = ${n}: the disk radius would be <= 0`);\n    }\n    const R = n >= 2 ? 2 * detLog(scale) : 0;\n    const coshAlphaR = cosh(alpha * R);\n    if (!Number.isFinite(coshAlphaR)) {\n        throw new RangeError(`exponent ${exponent} is too large: cosh(alpha R) overflows`);\n    }\n\n    const cosT = new Float64Array(n);\n    const sinT = new Float64Array(n);\n    const coshr = new Float64Array(n);\n    const sinhr = new Float64Array(n);\n    const x = new Float64Array(n);\n    const y = new Float64Array(n);\n    const radius = new Float64Array(n);\n    const cs = new Float64Array(2);\n    const stream = new RandomStream(seed, \"hyperbolic-points\", 0);\n    for (let i = 0; i < n; i++) {\n        stream.reset(i);\n        detCosSinTurn(stream.nextFloat(), cs);\n        const r = acosh(1 + (coshAlphaR - 1) * stream.nextFloat()) / alpha;\n        const er = detExp(r);\n        cosT[i] = cs[0];\n        sinT[i] = cs[1];\n        coshr[i] = (er + 1 / er) / 2;\n        sinhr[i] = (er - 1 / er) / 2;\n        radius[i] = r;\n        x[i] = r * cs[0];\n        y[i] = r * cs[1];\n    }\n    return { n, seed, temperature, R, coshR: cosh(R), cosT, sinT, coshr, sinhr, x, y, radius };\n}\n\n/**\n * Rows [start, end) of the hyperbolic graph: row u holds the pairs (u, v), v = u + 1 .. n - 1 in\n * ascending v, with cosh d = cosh r_u cosh r_v - sinh r_u sinh r_v cos(theta_u - theta_v) (the\n * cosine of the angle difference expanded from the stored cosines and sines). At T = 0 the pair is\n * an edge iff cosh d < cosh R (no draws). At T > 0 row u draws one nextFloat() t per pair from\n * stream (seed, \"hyperbolic\", u) and the pair is an edge iff t < 1 / (1 + exp((d - R) / (2 T))),\n * decided as acosh(cosh d) < R + 2 T ln((1 - t) / t) with no exp. Any split of [0, n) into\n * consecutive ranges gives the whole graph.\n * @param plan - the checked options and points\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the edges\n */\nexport function hyperbolicRows(plan: HyperbolicPlan, start: number, end: number, out: EdgeBuffer): void {\n    const { n, R, coshR, temperature, cosT, sinT, coshr, sinhr } = plan;\n    const stream = new RandomStream(plan.seed, \"hyperbolic\", 0);\n    for (let u = start; u < end; u++) {\n        stream.reset(u);\n        for (let v = u + 1; v < n; v++) {\n            const coshD = coshr[u] * coshr[v] - sinhr[u] * sinhr[v] * (cosT[u] * cosT[v] + sinT[u] * sinT[v]);\n            if (temperature === 0) {\n                if (coshD < coshR) {\n                    out.push(u, v);\n                }\n                continue;\n            }\n            const t = stream.nextFloat();\n            if (acosh(Math.max(1, coshD)) < R + 2 * temperature * detLog((1 - t) / t)) {\n                out.push(u, v);\n            }\n        }\n    }\n}\n\n/**\n * A random hyperbolic graph (Krioukov et al. 2010): n points in a hyperbolic disk of radius R,\n * angles uniform and radii with density proportional to sinh(alpha r), alpha = (gamma - 1) / 2,\n * so the degrees follow a power law with exponent gamma. At temperature 0 two nodes are joined iff\n * their hyperbolic distance is below R; at T > 0 with probability 1 / (1 + exp((d - R) / (2 T))).\n *\n * R comes from the paper's approximation of the mean degree, R = 2 ln(2 xi^2 n / (pi k)) with\n * xi = alpha / (alpha - 1/2), times (pi T / sin(pi T)) inside the logarithm for T > 0. It is an\n * approximation, so the measured mean degree only lands near `averageDegree`: measured at n = 3000\n * and 10000, within about 10% for exponent >= 2.5 and T <= 0.7, but about 0.6x at exponent 2.2 and\n * about 0.5x at T = 0.9 (the approximation degrades as gamma approaches 2 and T approaches 1).\n *\n * Node i draws its angle theta = 2 pi u and then its radius r = acosh(1 + (cosh(alpha R) - 1) u') /\n * alpha (inverse CDF) from stream (seed, \"hyperbolic-points\", i); the pairs are decided by\n * {@link hyperbolicRows}. Edges are the pairs (u, v), u < v, ascending u then v. Node columns (all\n * Float64Array): `x`, `y` (the native polar embedding r cos theta, r sin theta) and `radius` (r).\n *\n * Cost: O(n^2) pairs (and one draw per pair at T > 0), so n is capped at 20000.\n * ponytail: naive pair loop, n <= 20000; the band algorithm of M. von Looz, H. Meyerhenke and\n * R. Prutkin, \"Generating random hyperbolic graphs in subquadratic time\", ISAAC 2015,\n * doi:10.1007/978-3-662-48971-0_40, is the upgrade path.\n * @param options - n, averageDegree, exponent, temperature and seed\n * @returns the undirected graph\n */\nexport function hyperbolicGraph(options: HyperbolicOptions): SampleGraph {\n    const plan = planHyperbolic(options);\n    const out = new EdgeBuffer(Math.ceil(plan.n * options.averageDegree * 0.75) + 16);\n    hyperbolicRows(plan, 0, plan.n, out);\n    return applyWeights(toGraph(plan.n, out, false, { x: plan.x, y: plan.y, radius: plan.radius }), options);\n}\n","/**\n * Lattices: the square and cubic grids (with torus wrap-around, diagonal neighbours, forward-only\n * arcs, random obstacles and position columns), the triangular lattice and the hexagonal\n * (honeycomb) lattice. All deterministic except the obstacles, which draw from stream\n * (seed, \"grid-obstacles\", node).\n */\n\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { checkEdgeCount, checkInt, checkProbability, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** Options of {@link grid3dGraph}. */\nexport interface Grid3dOptions extends WeightOptions {\n    /** The number of rows, >= 1. */\n    rows: number;\n    /** The number of columns, >= 1. */\n    cols: number;\n    /** The number of layers, >= 1. */\n    layers: number;\n    /**\n     * Wrap around (a torus): the last node of each row, column and layer is joined to the first.\n     * A dimension shorter than 3 does not wrap, so the graph stays simple.\n     */\n    periodic?: boolean | undefined;\n    /**\n     * Join diagonal neighbours too: the king's graph (8 neighbours) in 2D, the 26-neighbour lattice\n     * in 3D.\n     */\n    diagonals?: boolean | undefined;\n    /**\n     * Emit each edge once as an arc from the lower index to the higher: a DAG whose only source is\n     * node 0 and only sink node n - 1. Not with `periodic`.\n     */\n    directed?: boolean | undefined;\n    /**\n     * Block each node independently with this probability, in [0, 1): a blocked node keeps its\n     * index (and position) but has no edges, and the u8 node column `blocked` marks it (1).\n     */\n    obstacles?: number | undefined;\n    /** Emit Float64 node columns `x` (column), `y` (row) and, when layers > 1, `z` (layer). */\n    positions?: boolean | undefined;\n}\n\n/** Options of {@link gridGraph}: {@link Grid3dOptions} without layers. */\nexport type GridOptions = Omit<Grid3dOptions, \"layers\">;\n\n/**\n * The neighbour offsets (dc, dr, dl) a node links forward to, in edge order: +column, +row,\n * +layer, then (with diagonals) every other offset in {-1, 0, 1}^3 that is lexicographically\n * positive in (dl, dr, dc), ordered by dl, then dr, then dc.\n * @param diagonals - whether to include the diagonal offsets\n * @returns the offsets\n */\nfunction forwardOffsets(diagonals: boolean): number[][] {\n    const offsets = [\n        [1, 0, 0],\n        [0, 1, 0],\n        [0, 0, 1],\n    ];\n    if (diagonals) {\n        for (let dl = 0; dl <= 1; dl++) {\n            for (let dr = -1; dr <= 1; dr++) {\n                for (let dc = -1; dc <= 1; dc++) {\n                    const positive = dl > 0 || (dl === 0 && (dr > 0 || (dr === 0 && dc > 0)));\n                    const axis = Math.abs(dc) + Math.abs(dr) + Math.abs(dl) === 1;\n                    if (positive && !axis) {\n                        offsets.push([dc, dr, dl]);\n                    }\n                }\n            }\n        }\n    }\n    return offsets;\n}\n\n/**\n * The rows x cols x layers grid. Node (l, r, c) is index (l * rows + r) * cols + c. For each node\n * in index order, the edge to each forward neighbour in the order of the offsets: +column, +row,\n * +layer, then the diagonals. Without options this is the 6-neighbour lattice of phase 1, edge for\n * edge. Obstacles draw one float per node from stream (seed, \"grid-obstacles\", node) -- node < p\n * blocks it -- so the obstacle map does not depend on the other options.\n * @param options - sizes and the lattice options\n * @returns the graph\n */\nexport function grid3dGraph(options: Grid3dOptions): SampleGraph {\n    const { rows, cols, layers } = options;\n    checkInt(\"rows\", rows, 1);\n    checkInt(\"cols\", cols, 1);\n    checkInt(\"layers\", layers, 1);\n    const n = rows * cols * layers;\n    checkInt(\"rows * cols * layers\", n, 1);\n    const periodic = options.periodic === true;\n    const directed = options.directed === true;\n    if (periodic && directed) {\n        throw new RangeError(\"directed grids cannot be periodic: the wrap-around arcs would close cycles\");\n    }\n    const offsets = forwardOffsets(options.diagonals === true);\n    checkEdgeCount(n * offsets.length);\n    let blocked: Uint8Array<ArrayBuffer> | null = null;\n    if (options.obstacles !== undefined) {\n        const p = options.obstacles;\n        checkProbability(\"obstacles\", p);\n        if (p >= 1) {\n            throw new RangeError(\"obstacles must be below 1\");\n        }\n        blocked = new Uint8Array(n);\n        const stream = new RandomStream(resolveSeed(options.seed), \"grid-obstacles\", 0);\n        for (let i = 0; i < n; i++) {\n            stream.reset(i);\n            blocked[i] = stream.nextFloat() < p ? 1 : 0;\n        }\n    }\n    const sizes = [cols, rows, layers];\n    const wraps = sizes.map((size) => periodic && size >= 3);\n    const plane = rows * cols;\n    const out = new EdgeBuffer(n * Math.min(offsets.length, 3));\n    const at = [0, 0, 0];\n    for (let l = 0; l < layers; l++) {\n        for (let r = 0; r < rows; r++) {\n            for (let c = 0; c < cols; c++) {\n                const i = l * plane + r * cols + c;\n                if (blocked?.[i] === 1) {\n                    continue;\n                }\n                const here = [c, r, l];\n                for (const offset of offsets) {\n                    let inside = true;\n                    for (let axis = 0; axis < 3; axis++) {\n                        let x = here[axis] + offset[axis];\n                        if (x < 0 || x >= sizes[axis]) {\n                            if (!wraps[axis]) {\n                                inside = false;\n                                break;\n                            }\n                            x = (x + sizes[axis]) % sizes[axis];\n                        }\n                        at[axis] = x;\n                    }\n                    if (!inside) {\n                        continue;\n                    }\n                    const j = at[2] * plane + at[1] * cols + at[0];\n                    if (blocked?.[j] === 1) {\n                        continue;\n                    }\n                    out.push(directed && j < i ? j : i, directed && j < i ? i : j);\n                }\n            }\n        }\n    }\n    const columns: Record<string, Uint8Array<ArrayBuffer> | Float64Array<ArrayBuffer>> = {};\n    if (blocked !== null) {\n        columns.blocked = blocked;\n    }\n    if (options.positions === true) {\n        const x = new Float64Array(n);\n        const y = new Float64Array(n);\n        const z = layers > 1 ? new Float64Array(n) : null;\n        for (let i = 0; i < n; i++) {\n            x[i] = i % cols;\n            y[i] = Math.floor(i / cols) % rows;\n            if (z !== null) {\n                z[i] = Math.floor(i / plane);\n            }\n        }\n        columns.x = x;\n        columns.y = y;\n        if (z !== null) {\n            columns.z = z;\n        }\n    }\n    const graph = toGraph(n, out, directed, Object.keys(columns).length > 0 ? columns : undefined);\n    return applyWeights(graph, options);\n}\n\n/**\n * The rows x cols grid: {@link grid3dGraph} with one layer. Node (r, c) is index r * cols + c; for\n * each node in index order, the edge to its right neighbour, then the one below, then (with\n * diagonals) below-left and below-right.\n * @param options - sizes and the lattice options\n * @returns the graph\n */\nexport function gridGraph(options: GridOptions): SampleGraph {\n    return grid3dGraph({ ...options, layers: 1 });\n}\n\n/** Options of {@link triangularLatticeGraph} and {@link hexagonalLatticeGraph}. */\nexport interface PlanarLatticeOptions extends WeightOptions {\n    /** The number of rows, >= 1. */\n    rows: number;\n    /** The number of columns, >= 1. */\n    cols: number;\n    /** Emit Float64 node columns `x` and `y` placing every edge at unit length. */\n    positions?: boolean | undefined;\n}\n\nconst HALF_SQRT3 = 0.8660254037844386;\n\n/**\n * Check the sizes of a planar lattice.\n * @param options - the options\n * @returns the node count\n */\nfunction planarSize(options: PlanarLatticeOptions): number {\n    checkInt(\"rows\", options.rows, 1);\n    checkInt(\"cols\", options.cols, 1);\n    const n = options.rows * options.cols;\n    checkInt(\"rows * cols\", n, 1);\n    checkEdgeCount(3 * n);\n    return n;\n}\n\n/**\n * The triangular lattice as a triangulated rows x cols grid: node (r, c) is index r * cols + c and\n * links to (r, c + 1), (r + 1, c) and (r + 1, c - 1), in that order, for each node in index order.\n * Interior nodes have degree 6. Positions shear the grid into a parallelogram of equilateral\n * triangles: x = c + r / 2, y = r sqrt(3) / 2.\n * @param options - rows, cols, positions\n * @returns the undirected graph\n */\nexport function triangularLatticeGraph(options: PlanarLatticeOptions): SampleGraph {\n    const n = planarSize(options);\n    const { rows, cols } = options;\n    const out = new EdgeBuffer(3 * n);\n    for (let r = 0; r < rows; r++) {\n        for (let c = 0; c < cols; c++) {\n            const i = r * cols + c;\n            if (c + 1 < cols) {\n                out.push(i, i + 1);\n            }\n            if (r + 1 < rows) {\n                out.push(i, i + cols);\n                if (c > 0) {\n                    out.push(i, i + cols - 1);\n                }\n            }\n        }\n    }\n    let columns: SampleGraph[\"nodeColumns\"];\n    if (options.positions === true) {\n        const x = new Float64Array(n);\n        const y = new Float64Array(n);\n        for (let i = 0; i < n; i++) {\n            const r = Math.floor(i / cols);\n            x[i] = (i % cols) + r / 2;\n            y[i] = r * HALF_SQRT3;\n        }\n        columns = { x, y };\n    }\n    return applyWeights(toGraph(n, out, false, columns), options);\n}\n\n/**\n * The hexagonal (honeycomb) lattice in its brick-wall form: node (r, c) is index r * cols + c and\n * links to (r, c + 1) always and to (r + 1, c) when r + c is even, in that order, for each node in\n * index order. Interior nodes have degree 3; every face is a hexagon. Positions give unit edges:\n * x = c sqrt(3) / 2, y = 1.5 r + (r + c even ? 0.5 : 0).\n * @param options - rows, cols, positions\n * @returns the undirected graph\n */\nexport function hexagonalLatticeGraph(options: PlanarLatticeOptions): SampleGraph {\n    const n = planarSize(options);\n    const { rows, cols } = options;\n    const out = new EdgeBuffer(2 * n);\n    for (let r = 0; r < rows; r++) {\n        for (let c = 0; c < cols; c++) {\n            const i = r * cols + c;\n            if (c + 1 < cols) {\n                out.push(i, i + 1);\n            }\n            if (r + 1 < rows && (r + c) % 2 === 0) {\n                out.push(i, i + cols);\n            }\n        }\n    }\n    let columns: SampleGraph[\"nodeColumns\"];\n    if (options.positions === true) {\n        const x = new Float64Array(n);\n        const y = new Float64Array(n);\n        for (let i = 0; i < n; i++) {\n            const r = Math.floor(i / cols);\n            const c = i % cols;\n            x[i] = c * HALF_SQRT3;\n            y[i] = 1.5 * r + ((r + c) % 2 === 0 ? 0.5 : 0);\n        }\n        columns = { x, y };\n    }\n    return applyWeights(toGraph(n, out, false, columns), options);\n}\n","/**\n * The LFR community-detection benchmark: power-law degrees, power-law community sizes and a\n * mixing parameter, with the planted communities as ground truth.\n */\n\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { makeSumEven, pairStubs, powerLawSampler, shuffle, stubList } from \"./degree-sequence.js\";\nimport { checkInt, checkProbability, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** The largest LFR graph. */\nconst MAX_LFR_NODES = 1_000_000;\n\n/** Options of {@link lfrGraph}. */\nexport interface LfrOptions extends WeightOptions {\n    /** The node count, in [1, 1,000,000]. */\n    n: number;\n    /** The smallest degree, >= 1. */\n    minDegree: number;\n    /** The largest degree, in [minDegree, n - 1]. */\n    maxDegree: number;\n    /** The degree power-law exponent (tau1), a finite number >= 0, typically 2 to 3. */\n    degreeExponent: number;\n    /** The smallest community, >= 1. */\n    minCommunity: number;\n    /** The largest community, in [minCommunity, n]. */\n    maxCommunity: number;\n    /** The community-size power-law exponent (tau2), a finite number >= 0, typically 1 to 2. */\n    communityExponent: number;\n    /** The mixing parameter mu in [0, 1]: the share of each node's edges that leave its community. */\n    mixing: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Community sizes from the power law on [min, max] summing to exactly n: draw sizes from stream\n * (seed, \"lfr-sizes\", 0) until their sum reaches n; if k sizes of at least `min` no longer fit n,\n * drop the last draw and grow sizes from the last one backwards (each up to max) to close the gap,\n * otherwise shrink them from the last one backwards (each down to min) to remove the excess.\n * @param n - the node count\n * @param min - the smallest size\n * @param max - the largest size\n * @param sample - the power-law sampler\n * @param seed - the seed\n * @returns the sizes\n */\nfunction communitySizes(\n    n: number,\n    min: number,\n    max: number,\n    sample: (stream: RandomStream) => number,\n    seed: number,\n): number[] {\n    if (Math.ceil(n / max) * min > n) {\n        throw new RangeError(`there is no partition of ${n} nodes into communities of ${min} to ${max} nodes`);\n    }\n    const stream = new RandomStream(seed, \"lfr-sizes\", 0);\n    const sizes: number[] = [];\n    let excess = -n;\n    while (excess < 0) {\n        const s = sample(stream);\n        sizes.push(s);\n        excess += s;\n    }\n    if (sizes.length * min > n) {\n        excess -= sizes[sizes.length - 1];\n        sizes.pop();\n    }\n    // the feasibility check above guarantees these loops close the gap exactly\n    for (let i = sizes.length - 1; i >= 0 && excess !== 0; i--) {\n        const change = excess > 0 ? -Math.min(excess, sizes[i] - min) : Math.min(-excess, max - sizes[i]);\n        sizes[i] += change;\n        excess += change;\n    }\n    return sizes;\n}\n\n/**\n * Assign every node a community larger than its internal degree: nodes by internal degree\n * descending (ties by index), each to a uniform choice (nextBelow of stream (seed, \"lfr-assign\", 0))\n * among the communities with room whose size exceeds its internal degree. The communities that fit\n * only grow as the internal degree falls, so this fails exactly when no assignment exists.\n * @param internal - the internal degree of every node\n * @param sizes - the community sizes (summing to the node count)\n * @param seed - the seed\n * @returns the community of every node\n */\nfunction assignCommunities(internal: Uint32Array, sizes: readonly number[], seed: number): Uint32Array<ArrayBuffer> {\n    const n = internal.length;\n    const nodes = Uint32Array.from({ length: n }, (_, i) => i).sort((a, b) => internal[b] - internal[a] || a - b);\n    const bySize = Uint32Array.from(sizes, (_, i) => i).sort((a, b) => sizes[b] - sizes[a] || a - b);\n    const room = sizes.slice();\n    const open: number[] = [];\n    const community = new Uint32Array(n);\n    const stream = new RandomStream(seed, \"lfr-assign\", 0);\n    let next = 0;\n    for (const node of nodes) {\n        while (next < bySize.length && sizes[bySize[next]] > internal[node]) {\n            open.push(bySize[next++]);\n        }\n        if (open.length === 0) {\n            throw new RangeError(\n                `could not assign communities: node ${node} needs a community of more than ${internal[node]} nodes; ` +\n                    `raise maxCommunity or mixing, or lower maxDegree`,\n            );\n        }\n        const j = stream.nextBelow(open.length);\n        const c = open[j];\n        community[node] = c;\n        if (--room[c] === 0) {\n            open[j] = open[open.length - 1];\n            open.pop();\n        }\n    }\n    return community;\n}\n\n/**\n * The LFR benchmark (A. Lancichinetti, S. Fortunato and F. Radicchi, \"Benchmark graphs for testing\n * community detection algorithms\", Phys. Rev. E 78, 046110, 2008,\n * doi:10.1103/PhysRevE.78.046110), built with configuration models:\n *\n * 1. Degrees: node i's degree is the i-th power-law draw on [minDegree, maxDegree] from stream\n *    (seed, \"lfr-degrees\", 0); an odd sum is fixed on the last node as in powerLawDegreeSequence.\n * 2. Community sizes: power law on [minCommunity, maxCommunity] summing to exactly n (stream\n *    \"lfr-sizes\"); community ids are the draw order.\n * 3. Internal degree round((1 - mu) d); assignment of nodes to communities larger than their\n *    internal degree (stream \"lfr-assign\"); a RangeError when none exists.\n * 4. Inside each community c, ascending: when its internal degrees sum to an odd number the member\n *    with the largest (lowest index on ties) moves one stub to the outside; then a configuration\n *    model on the members' ascending stub list shuffled with stream (seed, \"lfr-internal\", c).\n * 5. Outside: a configuration model on the remaining degrees d - internal, stream\n *    (seed, \"lfr-external\", 0).\n *\n * Self-loops and repeated pairs are erased, and so are external pairs that land inside one\n * community, so degrees and the mixing come out approximate: the mean degree drops by up to about\n * 10% (repeated pairs inside small communities), and the measured mixing lands within about 0.02 of\n * mu for thousands of nodes. No edge switching repairs this. Edges: every community's internal\n * edges (communities ascending, pair order), then the external edges. Node column `community` (u32).\n * O(n log n + m); n at most 1,000,000.\n * @param options - n, degree and community power laws, mixing and seed\n * @returns the undirected graph\n */\nexport function lfrGraph(options: LfrOptions): SampleGraph {\n    const { n, minDegree, maxDegree, minCommunity, maxCommunity, mixing } = options;\n    const seed = resolveSeed(options.seed);\n    checkInt(\"n\", n, 1, MAX_LFR_NODES);\n    checkInt(\"maxDegree\", maxDegree, 1, n - 1);\n    checkProbability(\"mixing\", mixing);\n    checkInt(\"maxCommunity\", maxCommunity, 1, n);\n    const degreeOf = powerLawSampler(\n        [\"degreeExponent\", \"minDegree\", \"maxDegree\"],\n        options.degreeExponent,\n        minDegree,\n        maxDegree,\n    );\n    const sizeOf = powerLawSampler(\n        [\"communityExponent\", \"minCommunity\", \"maxCommunity\"],\n        options.communityExponent,\n        minCommunity,\n        maxCommunity,\n    );\n\n    const degree = new Uint32Array(n);\n    const degreeStream = new RandomStream(seed, \"lfr-degrees\", 0);\n    for (let i = 0; i < n; i++) {\n        degree[i] = degreeOf(degreeStream);\n    }\n    makeSumEven(degree, minDegree, maxDegree);\n    const sizes = communitySizes(n, minCommunity, maxCommunity, sizeOf, seed);\n    const internal = Uint32Array.from(degree, (d) => Math.round((1 - mixing) * d));\n    const community = assignCommunities(internal, sizes, seed);\n\n    // members of every community, ascending, by a counting sort\n    const start = new Uint32Array(sizes.length + 1);\n    for (let c = 0; c < sizes.length; c++) {\n        start[c + 1] = start[c] + sizes[c];\n    }\n    const fill = start.slice(0, sizes.length);\n    const members = new Uint32Array(n);\n    for (let i = 0; i < n; i++) {\n        members[fill[community[i]]++] = i;\n    }\n\n    let total = 0;\n    for (const d of degree) {\n        total += d;\n    }\n    const out = new EdgeBuffer(total / 2);\n    const stream = new RandomStream(seed, \"lfr-internal\", 0);\n    for (let c = 0; c < sizes.length; c++) {\n        const group = members.subarray(start[c], start[c + 1]);\n        const k = Uint32Array.from(group, (i) => internal[i]);\n        let sum = 0;\n        let largest = 0;\n        for (let j = 0; j < k.length; j++) {\n            sum += k[j];\n            if (k[j] > k[largest]) {\n                largest = j;\n            }\n        }\n        if (sum % 2 === 1) {\n            k[largest]--;\n            internal[group[largest]]--;\n            sum--;\n        }\n        const stubs = stubList(k, sum);\n        for (let j = 0; j < stubs.length; j++) {\n            stubs[j] = group[stubs[j]];\n        }\n        stream.reset(c);\n        shuffle(stubs, stream);\n        pairStubs(n, stubs, false, false, out);\n    }\n\n    const external = Uint32Array.from(degree, (d, i) => d - internal[i]);\n    let externalTotal = 0;\n    for (const d of external) {\n        externalTotal += d;\n    }\n    const stubs = stubList(external, externalTotal);\n    shuffle(stubs, new RandomStream(seed, \"lfr-external\", 0));\n    pairStubs(n, stubs, false, false, out, community);\n    return applyWeights(toGraph(n, out, false, { community }), options);\n}\n","/**\n * Named small graphs with well-known invariants: the teaching graphs and the platonic solids.\n * The edge lists (node order and edge order) are those of networkx 3.1's `small.py`\n * (A. Hagberg, D. Schult, P. Swart, \"Exploring network structure, dynamics, and function using\n * NetworkX\", SciPy 2008; BSD-3-Clause), which in turn follow the literature (Krackhardt 1990,\n * Frucht 1939, Tutte 1946, Hoffman and Singleton 1960, Sedgewick 1990). They are mathematical facts;\n * the ordering is frozen like any other generator's. The Petersen graph is `petersenGraph()`.\n */\n\nimport { type SampleGraph } from \"../types.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** The name of every graph {@link namedGraph} knows. */\nexport const NAMED_GRAPH_NAMES = [\n    \"bull\",\n    \"chvatal\",\n    \"cubical\",\n    \"desargues\",\n    \"diamond\",\n    \"dodecahedral\",\n    \"frucht\",\n    \"heawood\",\n    \"hoffman-singleton\",\n    \"house\",\n    \"house-x\",\n    \"icosahedral\",\n    \"krackhardt-kite\",\n    \"moebius-kantor\",\n    \"octahedral\",\n    \"pappus\",\n    \"sedgewick-maze\",\n    \"tetrahedral\",\n    \"truncated-cube\",\n    \"truncated-tetrahedron\",\n    \"tutte\",\n] as const;\n\n/** A name {@link namedGraph} accepts. */\nexport type NamedGraphName = (typeof NAMED_GRAPH_NAMES)[number];\n\n/** Node count and flat edge list [u0, v0, u1, v1, ...] of every named graph. */\nconst GRAPHS: Readonly<Record<NamedGraphName, readonly [number, readonly number[]]>> = {\n    // a triangle with two pendant horns; 5 nodes, 5 edges\n    bull: [5, [0, 1, 0, 2, 1, 2, 1, 3, 2, 4]],\n    // the smallest triangle-free 4-regular 4-chromatic graph; 12 nodes, 24 edges\n    chvatal: [\n        12,\n        [\n            0, 1, 0, 4, 0, 6, 0, 9, 1, 2, 1, 5, 1, 7, 2, 3, 2, 6, 2, 8, 3, 4, 3, 7, 3, 9, 4, 5, 4, 8, 5, 10, 5, 11, 6,\n            10, 6, 11, 7, 8, 7, 11, 8, 10, 9, 10, 9, 11,\n        ],\n    ],\n    // the cube's skeleton (Q_3); 8 nodes, 12 edges, planar\n    cubical: [8, [0, 1, 0, 3, 0, 4, 1, 2, 1, 7, 2, 3, 2, 6, 3, 5, 4, 5, 4, 7, 5, 6, 6, 7]],\n    // the Desargues graph, 3-regular, distance-transitive; 20 nodes, 30 edges\n    desargues: [\n        20,\n        [\n            0, 1, 0, 19, 0, 5, 1, 2, 1, 16, 2, 3, 2, 11, 3, 4, 3, 14, 4, 5, 4, 9, 5, 6, 6, 7, 6, 15, 7, 8, 7, 18, 8, 9,\n            8, 13, 9, 10, 10, 11, 10, 19, 11, 12, 12, 13, 12, 17, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19,\n        ],\n    ],\n    // K_4 minus one edge; 4 nodes, 5 edges\n    diamond: [4, [0, 1, 0, 2, 1, 2, 1, 3, 2, 3]],\n    // the dodecahedron's skeleton; 20 nodes, 30 edges, planar, 3-regular\n    dodecahedral: [\n        20,\n        [\n            0, 1, 0, 19, 0, 10, 1, 2, 1, 8, 2, 3, 2, 6, 3, 4, 3, 19, 4, 5, 4, 17, 5, 6, 5, 15, 6, 7, 7, 8, 7, 14, 8, 9,\n            9, 10, 9, 13, 10, 11, 11, 12, 11, 18, 12, 13, 12, 16, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19,\n        ],\n    ],\n    // 3-regular with no non-trivial automorphism; 12 nodes, 18 edges\n    frucht: [\n        12,\n        [\n            0, 1, 0, 6, 0, 7, 1, 2, 1, 7, 2, 3, 2, 8, 3, 4, 3, 9, 4, 5, 4, 9, 5, 6, 5, 10, 6, 10, 7, 11, 8, 11, 8, 9,\n            10, 11,\n        ],\n    ],\n    // the (3,6)-cage, the Fano plane's incidence graph; 14 nodes, 21 edges\n    heawood: [\n        14,\n        [\n            0, 1, 0, 13, 0, 5, 1, 2, 1, 10, 2, 3, 2, 7, 3, 4, 3, 12, 4, 5, 4, 9, 5, 6, 6, 7, 6, 11, 7, 8, 8, 9, 8, 13,\n            9, 10, 10, 11, 11, 12, 12, 13,\n        ],\n    ],\n    // the (7,5)-cage, a Moore graph; 50 nodes, 175 edges\n    \"hoffman-singleton\": [\n        50,\n        [\n            0, 1, 0, 2, 0, 3, 0, 6, 0, 7, 0, 8, 0, 9, 1, 17, 1, 12, 1, 26, 1, 27, 1, 28, 1, 29, 2, 10, 2, 11, 2, 13, 2,\n            14, 2, 15, 2, 16, 3, 4, 3, 5, 3, 30, 3, 35, 3, 40, 3, 45, 4, 11, 4, 17, 4, 34, 4, 39, 4, 44, 4, 49, 5, 12,\n            5, 10, 5, 33, 5, 38, 5, 43, 5, 48, 6, 22, 6, 18, 6, 31, 6, 39, 6, 43, 6, 47, 7, 34, 7, 23, 7, 19, 7, 37, 7,\n            41, 7, 48, 8, 33, 8, 36, 8, 24, 8, 20, 8, 42, 8, 49, 9, 32, 9, 38, 9, 44, 9, 25, 9, 21, 9, 46, 10, 17, 10,\n            18, 10, 19, 10, 20, 10, 21, 11, 12, 11, 32, 11, 37, 11, 42, 11, 47, 12, 31, 12, 36, 12, 41, 12, 46, 13, 30,\n            13, 26, 13, 22, 13, 36, 13, 44, 13, 48, 14, 31, 14, 27, 14, 23, 14, 38, 14, 40, 14, 49, 15, 34, 15, 35, 15,\n            28, 15, 24, 15, 43, 15, 46, 16, 33, 16, 39, 16, 41, 16, 45, 16, 29, 16, 25, 17, 22, 17, 23, 17, 24, 17, 25,\n            18, 32, 18, 26, 18, 35, 18, 41, 18, 49, 19, 30, 19, 27, 19, 39, 19, 42, 19, 46, 20, 31, 20, 37, 20, 28, 20,\n            44, 20, 45, 21, 34, 21, 36, 21, 40, 21, 47, 21, 29, 22, 33, 22, 37, 22, 40, 22, 46, 23, 32, 23, 36, 23, 43,\n            23, 45, 24, 30, 24, 38, 24, 41, 24, 47, 25, 31, 25, 35, 25, 42, 25, 48, 26, 34, 26, 38, 26, 42, 26, 45, 27,\n            33, 27, 35, 27, 44, 27, 47, 28, 32, 28, 39, 28, 40, 28, 48, 29, 30, 29, 37, 29, 43, 29, 49, 30, 31, 30, 32,\n            31, 34, 32, 33, 33, 34, 35, 36, 35, 37, 36, 39, 37, 38, 38, 39, 40, 41, 40, 42, 41, 44, 42, 43, 43, 44, 45,\n            46, 45, 47, 46, 49, 47, 48, 48, 49,\n        ],\n    ],\n    // a square with a triangular roof; 5 nodes, 6 edges\n    house: [5, [0, 1, 0, 2, 1, 3, 2, 3, 2, 4, 3, 4]],\n    // the house with both diagonals of the square; 5 nodes, 8 edges\n    \"house-x\": [5, [0, 1, 0, 2, 0, 3, 1, 3, 1, 2, 2, 3, 2, 4, 3, 4]],\n    // the icosahedron's skeleton; 12 nodes, 30 edges, planar, 5-regular\n    icosahedral: [\n        12,\n        [\n            0, 1, 0, 5, 0, 7, 0, 8, 0, 11, 1, 2, 1, 5, 1, 6, 1, 8, 2, 3, 2, 6, 2, 8, 2, 9, 3, 4, 3, 6, 3, 9, 3, 10, 4,\n            5, 4, 6, 4, 10, 4, 11, 5, 6, 5, 11, 7, 8, 7, 9, 7, 10, 7, 11, 8, 9, 9, 10, 10, 11,\n        ],\n    ],\n    // Krackhardt's kite: degree, betweenness and closeness each crown a different node; 10 nodes, 18 edges\n    \"krackhardt-kite\": [\n        10,\n        [0, 1, 0, 2, 0, 3, 0, 5, 1, 3, 1, 4, 1, 6, 2, 3, 2, 5, 3, 4, 3, 5, 3, 6, 4, 6, 5, 6, 5, 7, 6, 7, 7, 8, 8, 9],\n    ],\n    // the Moebius-Kantor graph, the generalized Petersen graph GP(8, 3); 16 nodes, 24 edges\n    \"moebius-kantor\": [\n        16,\n        [\n            0, 1, 0, 15, 0, 5, 1, 2, 1, 12, 2, 3, 2, 7, 3, 4, 3, 14, 4, 5, 4, 9, 5, 6, 6, 7, 6, 11, 7, 8, 8, 9, 8, 13,\n            9, 10, 10, 11, 10, 15, 11, 12, 12, 13, 13, 14, 14, 15,\n        ],\n    ],\n    // the octahedron's skeleton, K_{2,2,2}; 6 nodes, 12 edges\n    octahedral: [6, [0, 1, 0, 2, 0, 3, 0, 4, 1, 2, 1, 3, 1, 5, 2, 4, 2, 5, 3, 4, 3, 5, 4, 5]],\n    // the Pappus graph, 3-regular, bipartite, distance-regular; 18 nodes, 27 edges\n    pappus: [\n        18,\n        [\n            0, 1, 0, 17, 0, 5, 1, 2, 1, 8, 2, 3, 2, 13, 3, 4, 3, 10, 4, 5, 4, 15, 5, 6, 6, 7, 6, 11, 7, 8, 7, 14, 8, 9,\n            9, 10, 9, 16, 10, 11, 11, 12, 12, 13, 12, 17, 13, 14, 14, 15, 15, 16, 16, 17,\n        ],\n    ],\n    // the small maze of Sedgewick's Algorithms in C (DFS teaching); 8 nodes, 10 edges\n    \"sedgewick-maze\": [8, [0, 2, 0, 7, 0, 5, 1, 7, 2, 6, 3, 4, 3, 5, 4, 5, 4, 7, 4, 6]],\n    // the tetrahedron's skeleton, K_4; 4 nodes, 6 edges\n    tetrahedral: [4, [0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3]],\n    // the truncated cube's skeleton; 24 nodes, 36 edges, planar\n    \"truncated-cube\": [\n        24,\n        [\n            0, 1, 0, 2, 0, 4, 1, 11, 1, 14, 2, 3, 2, 4, 3, 6, 3, 8, 4, 5, 5, 16, 5, 18, 6, 7, 6, 8, 7, 10, 7, 12, 8, 9,\n            9, 17, 9, 20, 10, 11, 10, 12, 11, 14, 12, 13, 13, 21, 13, 22, 14, 15, 15, 19, 15, 23, 16, 17, 16, 18, 17,\n            20, 18, 19, 19, 23, 20, 21, 21, 22, 22, 23,\n        ],\n    ],\n    // the truncated tetrahedron's skeleton; 12 nodes, 18 edges, planar\n    \"truncated-tetrahedron\": [\n        12,\n        [\n            0, 1, 0, 2, 0, 9, 1, 2, 1, 6, 2, 3, 3, 4, 3, 11, 4, 5, 4, 11, 5, 6, 5, 7, 6, 7, 7, 8, 8, 9, 8, 10, 9, 10,\n            10, 11,\n        ],\n    ],\n    // Tutte's graph: 3-regular, 3-connected, planar and not Hamiltonian; 46 nodes, 69 edges\n    tutte: [\n        46,\n        [\n            0, 1, 0, 2, 0, 3, 1, 4, 1, 26, 2, 10, 2, 11, 3, 18, 3, 19, 4, 5, 4, 33, 5, 6, 5, 29, 6, 7, 6, 27, 7, 8, 7,\n            14, 8, 9, 8, 38, 9, 10, 9, 37, 10, 39, 11, 12, 11, 39, 12, 13, 12, 35, 13, 14, 13, 15, 14, 34, 15, 16, 15,\n            22, 16, 17, 16, 44, 17, 18, 17, 43, 18, 45, 19, 20, 19, 45, 20, 21, 20, 41, 21, 22, 21, 23, 22, 40, 23, 24,\n            23, 27, 24, 25, 24, 32, 25, 26, 25, 31, 26, 33, 27, 28, 28, 29, 28, 32, 29, 30, 30, 31, 30, 33, 31, 32, 34,\n            35, 34, 38, 35, 36, 36, 37, 36, 39, 37, 38, 40, 41, 40, 44, 41, 42, 42, 43, 42, 45, 43, 44,\n        ],\n    ],\n};\n\n/**\n * A named small graph (see {@link NAMED_GRAPH_NAMES}): an undirected simple graph with networkx's\n * node and edge order.\n * @param name - the graph's name\n * @param options - the common weight options\n * @returns the graph\n */\nexport function namedGraph(name: NamedGraphName, options: WeightOptions = {}): SampleGraph {\n    const entry = Object.prototype.hasOwnProperty.call(GRAPHS, name) ? GRAPHS[name] : undefined;\n    if (entry === undefined) {\n        throw new RangeError(`unknown named graph \"${name}\"; see NAMED_GRAPH_NAMES`);\n    }\n    const [nodeCount, flat] = entry;\n    const m = flat.length / 2;\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    for (let e = 0; e < m; e++) {\n        src[e] = flat[2 * e];\n        dst[e] = flat[2 * e + 1];\n    }\n    return applyWeights({ directed: false, nodeCount, src, dst }, options);\n}\n","/**\n * Growth models: Barabasi-Albert preferential attachment with the Holme-Kim triad-formation step,\n * and the Watts-Strogatz small world.\n */\n\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { checkEdgeCount, checkInt, checkProbability, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** Options of {@link barabasiAlbertGraph}. */\nexport interface BarabasiAlbertOptions extends WeightOptions {\n    /** The node count, > m. */\n    n: number;\n    /** The number of edges each new node brings, >= 1. */\n    m: number;\n    /**\n     * Holme-Kim: after each preferential edge, the probability that the next of the node's m edges\n     * closes a triangle with a neighbour of that edge's target instead. 0 (the default) is plain\n     * Barabasi-Albert.\n     */\n    triadProbability?: number | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Barabasi-Albert preferential attachment (A.-L. Barabasi and R. Albert, \"Emergence of scaling in\n * random networks\", Science 286, 509-512, 1999), optionally with triad formation (P. Holme and\n * B. J. Kim, \"Growing scale-free networks with tunable clustering\", Phys. Rev. E 65, 026107, 2002),\n * in O(n m) with the repeated-endpoint list of Batagelj and Brandes (2005).\n *\n * The algorithm is networkx's `powerlaw_cluster_graph`, which is `barabasi_albert_graph` when the\n * triad probability is 0: start from m isolated nodes 0 .. m - 1 whose repeated list holds each\n * once; each new node s = m .. n - 1 draws m distinct targets uniformly from the repeated list\n * (in draw order), then adds m edges (s, t): the first to the first target; each further one, with\n * probability `triadProbability`, to a uniformly chosen neighbour of the previous target that s is\n * not yet joined to, otherwise to the next unused target. Every endpoint is appended to the\n * repeated list, s itself m times. All draws come from the single stream (seed,\n * \"barabasi-albert\", 0): the process is sequential. Edges are listed by new node, in the order\n * added. (n - m) m edges, no self-loops, no repeats.\n * @param options - n, m, triadProbability and seed\n * @returns the undirected graph\n */\nexport function barabasiAlbertGraph(options: BarabasiAlbertOptions): SampleGraph {\n    const { n, m } = options;\n    const triad = options.triadProbability ?? 0;\n    checkInt(\"m\", m, 1);\n    checkInt(\"n\", n, m + 1);\n    checkProbability(\"triadProbability\", triad);\n    const seed = resolveSeed(options.seed);\n    const edgeCount = (n - m) * m;\n    checkEdgeCount(edgeCount);\n    const stream = new RandomStream(seed, \"barabasi-albert\", 0);\n    const out = new EdgeBuffer(edgeCount);\n    const repeated = new Uint32Array(m + 2 * edgeCount);\n    let length = 0;\n    for (let i = 0; i < m; i++) {\n        repeated[length++] = i;\n    }\n    // neighbour lists, only for the triad step\n    // ponytail: number[][] per node; a CSR-like growable adjacency if HK at 1M+ nodes matters\n    const adjacency: number[][] | null = triad > 0 ? Array.from({ length: n }, () => []) : null;\n    const targets = new Array<number>(m);\n    const link = (s: number, t: number): void => {\n        out.push(s, t);\n        repeated[length++] = t;\n        if (adjacency !== null) {\n            adjacency[s].push(t);\n            adjacency[t].push(s);\n        }\n    };\n    for (let s = m; s < n; s++) {\n        // m distinct targets from the repeated list, in draw order\n        let found = 0;\n        while (found < m) {\n            const t = repeated[stream.nextBelow(length)];\n            let fresh = true;\n            for (let i = 0; i < found; i++) {\n                fresh &&= targets[i] !== t;\n            }\n            if (fresh) {\n                targets[found++] = t;\n            }\n        }\n        let next = 0;\n        let target = targets[next++];\n        link(s, target);\n        for (let count = 1; count < m; count++) {\n            if (adjacency !== null && stream.nextFloat() < triad) {\n                const mine = adjacency[s];\n                const candidates = adjacency[target].filter((x) => x !== s && !mine.includes(x));\n                if (candidates.length > 0) {\n                    link(s, candidates[stream.nextBelow(candidates.length)]);\n                    continue;\n                }\n            }\n            // the next unused target (a triad step may already have joined s to it)\n            do {\n                target = targets[next++];\n            } while (adjacency !== null && adjacency[s].includes(target) && next < m);\n            if (adjacency !== null && adjacency[s].includes(target)) {\n                // every planned target is taken: fall back to a fresh preferential draw\n                do {\n                    target = repeated[stream.nextBelow(length)];\n                } while (target === s || adjacency[s].includes(target));\n            }\n            link(s, target);\n        }\n        for (let i = 0; i < m; i++) {\n            repeated[length++] = s;\n        }\n    }\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/** Options of {@link wattsStrogatzGraph}. */\nexport interface WattsStrogatzOptions extends WeightOptions {\n    /** The node count, > k. */\n    n: number;\n    /** Each node's ring neighbours before rewiring, even, >= 2. */\n    k: number;\n    /** The rewiring probability of each edge, in [0, 1]. */\n    beta: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * The Watts-Strogatz small world (D. J. Watts and S. H. Strogatz, \"Collective dynamics of\n * 'small-world' networks\", Nature 393, 440-442, 1998), as networkx's `watts_strogatz_graph`\n * builds it, in O(n k).\n *\n * Start from the ring lattice: edge slot u k/2 + (j - 1) holds (u, (u + j) mod n) for j = 1 .. k/2.\n * Then for j = 1 .. k/2 and u = 0 .. n - 1 in that order: draw a float; if it is below beta and u is\n * not already joined to every other node, redraw w = nextBelow(n) until w is neither u nor a\n * neighbour of u, and rewire the slot to (u, w). All draws come from the single stream (seed,\n * \"watts-strogatz\", 0). Edges are listed in slot order.\n * @param options - n, k, beta and seed\n * @returns the undirected graph\n */\nexport function wattsStrogatzGraph(options: WattsStrogatzOptions): SampleGraph {\n    const { n, k, beta } = options;\n    checkInt(\"k\", k, 2);\n    if (k % 2 !== 0) {\n        throw new RangeError(`k must be even, got ${k}`);\n    }\n    checkInt(\"n\", n, k + 1);\n    checkProbability(\"beta\", beta);\n    const seed = resolveSeed(options.seed);\n    const half = k / 2;\n    const m = n * half;\n    checkEdgeCount(m);\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    const degree = new Uint32Array(n).fill(k);\n    // ponytail: a Set of u * n + v keys, fine to a few million edges; a hashed typed table beyond\n    const edges = new Set<number>();\n    const key = (a: number, b: number): number => (a < b ? a * n + b : b * n + a);\n    for (let u = 0; u < n; u++) {\n        for (let j = 1; j <= half; j++) {\n            const v = (u + j) % n;\n            src[u * half + j - 1] = u;\n            dst[u * half + j - 1] = v;\n            edges.add(key(u, v));\n        }\n    }\n    const stream = new RandomStream(seed, \"watts-strogatz\", 0);\n    for (let j = 1; j <= half; j++) {\n        for (let u = 0; u < n; u++) {\n            if (stream.nextFloat() >= beta || degree[u] >= n - 1) {\n                continue;\n            }\n            let w = stream.nextBelow(n);\n            while (w === u || edges.has(key(u, w))) {\n                w = stream.nextBelow(n);\n            }\n            const slot = u * half + j - 1;\n            const v = dst[slot];\n            edges.delete(key(u, v));\n            edges.add(key(u, w));\n            degree[v]--;\n            degree[w]++;\n            dst[slot] = w;\n        }\n    }\n    return applyWeights({ directed: false, nodeCount: n, src, dst }, options);\n}\n","/**\n * Random trees and random directed acyclic graphs.\n */\n\nimport { type U32 } from \"@graphty/graph-format\";\n\nimport { detLog } from \"../random/log.js\";\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { bernoulliSegment, binomialBuffer, checkInt, checkProbability, EdgeBuffer, toGraph } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** Options of {@link randomTreeGraph}. */\nexport interface RandomTreeOptions extends WeightOptions {\n    /** The node count, >= 1. */\n    n: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * A uniformly random labelled tree: a uniformly random Pruefer sequence (H. Pruefer, Archiv der\n * Mathematik und Physik 27, 142-144, 1918) of n - 2 draws nextBelow(n) from stream (seed,\n * \"prufer\", 0), decoded in O(n). Edge k joins the k-th removed leaf to its neighbour; the last\n * edge is (leaf, n - 1).\n * @param options - n and seed\n * @returns the undirected tree\n */\nexport function randomTreeGraph(options: RandomTreeOptions): SampleGraph {\n    const { n } = options;\n    checkInt(\"n\", n, 1);\n    const seed = resolveSeed(options.seed);\n    const out = new EdgeBuffer(n);\n    if (n === 1) {\n        return applyWeights(toGraph(1, out, false), options);\n    }\n    const stream = new RandomStream(seed, \"prufer\", 0);\n    const code = new Uint32Array(n - 2);\n    const degree = new Uint32Array(n).fill(1);\n    for (let i = 0; i < n - 2; i++) {\n        code[i] = stream.nextBelow(n);\n        degree[code[i]]++;\n    }\n    let ptr = 0;\n    while (degree[ptr] !== 1) {\n        ptr++;\n    }\n    let leaf = ptr;\n    for (let i = 0; i < n - 2; i++) {\n        const v = code[i];\n        out.push(leaf, v);\n        degree[v]--;\n        if (degree[v] === 1 && v < ptr) {\n            leaf = v;\n        } else {\n            ptr++;\n            while (degree[ptr] !== 1) {\n                ptr++;\n            }\n            leaf = ptr;\n        }\n    }\n    out.push(leaf, n - 1);\n    return applyWeights(toGraph(n, out, false), options);\n}\n\n/** Options of {@link randomDagGraph}. */\nexport interface RandomDagOptions extends WeightOptions {\n    /** The width of every layer, top to bottom; layer i holds the next `layers[i]` node indices. */\n    layers: readonly number[];\n    /** The probability of each arc from a node to a node of the next layer. */\n    p: number;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * Rows [start, end) of the layered DAG: node u of layer i < L - 1 draws from stream (seed,\n * \"layered-dag\", u) and holds the arcs to the chosen nodes of layer i + 1, ascending.\n * @param starts - starts[i] = first node of layer i; starts[L] = n\n * @param layerOf - the layer of every node\n * @param p - the probability\n * @param seed - the seed\n * @param start - the first row\n * @param end - one past the last row\n * @param out - receives the arcs\n */\nexport function dagRows(\n    starts: readonly number[],\n    layerOf: U32,\n    p: number,\n    seed: number,\n    start: number,\n    end: number,\n    out: EdgeBuffer,\n): void {\n    const logQ = detLog(1 - p);\n    const stream = new RandomStream(seed, \"layered-dag\", 0);\n    const last = starts.length - 2;\n    for (let u = start; u < end; u++) {\n        const layer = layerOf[u];\n        if (layer < last) {\n            stream.reset(u);\n            bernoulliSegment(stream, p, logQ, u, starts[layer + 1], starts[layer + 2], out);\n        }\n    }\n}\n\n/**\n * A random layered DAG: arcs only from layer i to layer i + 1, each independently with\n * probability p, O(n + m). The standard input for layered (Sugiyama) drawing, topological sort\n * and longest path. Arcs are listed by source node, targets ascending. Node column `layer` (u32).\n * @param options - layers, p and seed\n * @returns the directed graph\n */\nexport function randomDagGraph(options: RandomDagOptions): SampleGraph {\n    const { layers, p } = options;\n    checkInt(\"layers.length\", layers.length, 1);\n    checkProbability(\"p\", p);\n    const seed = resolveSeed(options.seed);\n    const starts = [0];\n    let pairs = 0;\n    for (let i = 0; i < layers.length; i++) {\n        checkInt(`layers[${i}]`, layers[i], 0);\n        starts.push(starts[i] + layers[i]);\n        if (i > 0) {\n            pairs += layers[i - 1] * layers[i];\n        }\n    }\n    const n = starts[layers.length];\n    checkInt(\"the total size\", n, 0);\n    const layerOf = new Uint32Array(n);\n    for (let i = 0; i < layers.length; i++) {\n        layerOf.fill(i, starts[i], starts[i + 1]);\n    }\n    const out = binomialBuffer(pairs, p);\n    dagRows(starts, layerOf, p, seed, 0, n, out);\n    return applyWeights(toGraph(n, out, true, { layer: layerOf }), options);\n}\n","/**\n * Structural variants for testing consumers: random multigraphs, a helper that adds self-loops,\n * parallel and anti-parallel edges to any graph, and a pack of small (and a few huge) edge-case\n * graphs that parsers, loaders and algorithms must survive.\n */\n\nimport { RandomStream, resolveSeed } from \"../random/stream.js\";\nimport { type SampleGraph } from \"../types.js\";\nimport { checkEdgeCount, checkInt } from \"./util.js\";\nimport { applyWeights, type WeightOptions } from \"./weights.js\";\n\n/** Options of {@link randomMultigraph}. */\nexport interface RandomMultigraphOptions extends WeightOptions {\n    /** The node count, >= 1 (>= 2 without self-loops). */\n    n: number;\n    /** The edge count, >= 0. */\n    m: number;\n    /** Whether the edges are directed; default false. */\n    directed?: boolean | undefined;\n    /** Whether an edge may join a node to itself; default true. */\n    selfLoops?: boolean | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * A random multigraph: m edges, each an independent uniform ordered pair (u, v) -- drawn with\n * replacement, so parallel edges and (when allowed) self-loops are kept. Undirected, this is the\n * \"each endpoint uniform\" model: a given self-loop is half as likely as a given pair u != v. Edge e\n * draws u = nextBelow(n) and then v = nextBelow(n), or v = nextBelow(n - 1) shifted past u when\n * self-loops are off, from the stream (seed, \"multigraph\", 0); one sequential stream, since two\n * draws per edge are cheaper than a per-edge stream derivation. O(m).\n * @param options - n, m, directed, selfLoops and seed\n * @returns the multigraph\n */\nexport function randomMultigraph(options: RandomMultigraphOptions): SampleGraph {\n    const { n, m } = options;\n    const loops = options.selfLoops ?? true;\n    checkInt(\"n\", n, 1);\n    checkInt(\"m\", m, 0);\n    if (!loops && n < 2) {\n        throw new RangeError(`selfLoops: false needs n >= 2, got ${n}`);\n    }\n    const stream = new RandomStream(resolveSeed(options.seed), \"multigraph\", 0);\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    for (let e = 0; e < m; e++) {\n        const u = stream.nextBelow(n);\n        let v: number;\n        if (loops) {\n            v = stream.nextBelow(n);\n        } else {\n            v = stream.nextBelow(n - 1);\n            if (v >= u) {\n                v++;\n            }\n        }\n        src[e] = u;\n        dst[e] = v;\n    }\n    return applyWeights({ directed: options.directed ?? false, nodeCount: n, src, dst }, options);\n}\n\n/** Options of {@link addPathologicalEdges}. */\nexport interface PathologicalEdgeOptions {\n    /** How many self-loops to add at uniform nodes; default 0. */\n    selfLoops?: number | undefined;\n    /** How many copies of uniform existing edges to add; default 0. */\n    parallelEdges?: number | undefined;\n    /** How many reversed copies of uniform existing arcs to add (directed graphs only); default 0. */\n    antiParallelEdges?: number | undefined;\n    /** The seed, an integer in [0, 2^53); default 0. */\n    seed?: number | undefined;\n}\n\n/**\n * A copy of `graph` with pathological edges appended after its own, in this order: `selfLoops`\n * self-loops (v, v) at v = nextBelow(nodeCount); `parallelEdges` copies of edge e =\n * nextBelow(original edge count); `antiParallelEdges` reversed copies (dst[e], src[e]) of\n * e = nextBelow(original edge count). Copies are only ever of the original edges. Draws come from\n * the stream (seed, \"pathological\", 0) in that order. A weighted graph's copies keep the copied\n * edge's weight and a self-loop gets weight 1. `ids` and `nodeColumns` are shared, not copied.\n * O(m + added).\n * @param graph - the graph\n * @param options - the counts and the seed\n * @returns the new graph\n */\nexport function addPathologicalEdges(graph: SampleGraph, options: PathologicalEdgeOptions): SampleGraph {\n    const loops = options.selfLoops ?? 0;\n    const parallel = options.parallelEdges ?? 0;\n    const anti = options.antiParallelEdges ?? 0;\n    checkInt(\"selfLoops\", loops, 0);\n    checkInt(\"parallelEdges\", parallel, 0);\n    checkInt(\"antiParallelEdges\", anti, 0);\n    if (anti > 0 && !graph.directed) {\n        throw new RangeError(\"antiParallelEdges needs a directed graph\");\n    }\n    const m = graph.src.length;\n    if (loops > 0 && graph.nodeCount === 0) {\n        throw new RangeError(\"selfLoops needs a graph with at least one node\");\n    }\n    if (parallel + anti > 0 && m === 0) {\n        throw new RangeError(\"parallelEdges and antiParallelEdges need a graph with at least one edge\");\n    }\n    const total = m + loops + parallel + anti;\n    checkEdgeCount(total);\n    const stream = new RandomStream(resolveSeed(options.seed), \"pathological\", 0);\n    const src = new Uint32Array(total);\n    const dst = new Uint32Array(total);\n    src.set(graph.src);\n    dst.set(graph.dst);\n    const weights = graph.weights === undefined ? undefined : new Float32Array(total);\n    weights?.set(graph.weights ?? []);\n    let e = m;\n    for (let i = 0; i < loops; i++, e++) {\n        const v = stream.nextBelow(graph.nodeCount);\n        src[e] = v;\n        dst[e] = v;\n        if (weights !== undefined) {\n            weights[e] = 1;\n        }\n    }\n    for (let i = 0; i < parallel + anti; i++, e++) {\n        const f = stream.nextBelow(m);\n        const reversed = i >= parallel;\n        src[e] = reversed ? graph.dst[f] : graph.src[f];\n        dst[e] = reversed ? graph.src[f] : graph.dst[f];\n        if (weights !== undefined) {\n            weights[e] = weights[f];\n        }\n    }\n    return { ...graph, src, dst, weights };\n}\n\n/** The names of the {@link edgeCaseGraph} cases. */\nexport const EDGE_CASE_NAMES = [\n    \"empty\",\n    \"single-node\",\n    \"single-self-loop\",\n    \"isolated-nodes\",\n    \"disconnected\",\n    \"pathological-undirected\",\n    \"pathological-directed\",\n    \"zero-weights\",\n    \"negative-weights\",\n    \"negative-cycle\",\n    \"duplicate-heavy\",\n    \"max-node-index\",\n    \"star-100k\",\n    \"path-100k\",\n] as const;\n\n/** One of {@link EDGE_CASE_NAMES}. */\nexport type EdgeCaseName = (typeof EDGE_CASE_NAMES)[number];\n\n/**\n * A small graph from a flat edge list.\n * @param directed - whether the edges are directed\n * @param nodeCount - the node count\n * @param edges - [u, v, u, v, ...], or [u, v, w, u, v, w, ...] when weighted\n * @param weighted - whether every edge carries a weight\n * @returns the graph\n */\nfunction build(directed: boolean, nodeCount: number, edges: readonly number[], weighted = false): SampleGraph {\n    const stride = weighted ? 3 : 2;\n    const m = edges.length / stride;\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    const weights = new Float32Array(weighted ? m : 0);\n    for (let e = 0; e < m; e++) {\n        src[e] = edges[e * stride];\n        dst[e] = edges[e * stride + 1];\n        weights[e] = weighted ? edges[e * stride + 2] : 0;\n    }\n    return weighted ? { directed, nodeCount, src, dst, weights } : { directed, nodeCount, src, dst };\n}\n\n/**\n * A graph whose edge e is end(e) for e < m.\n * @param nodeCount - the node count\n * @param m - the edge count\n * @param end - maps e to [source, target]\n * @returns the undirected graph\n */\nfunction generated(nodeCount: number, m: number, end: (e: number) => [number, number]): SampleGraph {\n    const src = new Uint32Array(m);\n    const dst = new Uint32Array(m);\n    for (let e = 0; e < m; e++) {\n        [src[e], dst[e]] = end(e);\n    }\n    return { directed: false, nodeCount, src, dst };\n}\n\nconst CASES: Record<EdgeCaseName, () => SampleGraph> = {\n    empty: () => build(false, 0, []),\n    \"single-node\": () => build(false, 1, []),\n    \"single-self-loop\": () => build(false, 1, [0, 0]),\n    \"isolated-nodes\": () => build(false, 10, []),\n    // triangle 0-1-2, path 3-4-5, edge 6-7, isolated 8 and 9\n    disconnected: () => build(false, 10, [0, 1, 1, 2, 2, 0, 3, 4, 4, 5, 6, 7]),\n    // self-loop at 0; (1, 2) three times, once written (2, 1); weights 0, negative and fractional\n    \"pathological-undirected\": () =>\n        build(false, 4, [0, 0, 1, 1, 2, 0, 1, 2, -2, 2, 1, 0.5, 2, 3, 2.5, 3, 0, -1], true),\n    // self-loop at 0; parallel arcs 0 -> 1; the 2-cycle 1 <-> 2 (an anti-parallel pair, one arc\n    // of weight 0); the negative cycle 2 -> 3 -> 4 -> 2 of total weight -2, reachable from 0\n    \"pathological-directed\": () =>\n        build(true, 5, [0, 0, 1, 0, 1, 2, 0, 1, 3, 1, 2, 1, 2, 1, 0, 2, 3, -1, 3, 4, -2, 4, 2, 1, 1, 3, 0.5], true),\n    // a 4-cycle with the chord 0-2, every weight 0: ties everywhere for Dijkstra and MST\n    \"zero-weights\": () => build(false, 4, [0, 1, 0, 1, 2, 0, 2, 3, 0, 3, 0, 0, 0, 2, 0], true),\n    // a DAG with negative arcs and no negative cycle; distances from 0 are [0, 4, 1, 4, 3]\n    \"negative-weights\": () => build(true, 5, [0, 1, 4, 0, 2, 2, 1, 2, -3, 1, 3, 2, 2, 3, 3, 3, 4, -1, 2, 4, 5], true),\n    // 0 -> 1, then the cycle 1 -> 2 -> 3 -> 1 of total weight -1\n    \"negative-cycle\": () => build(true, 4, [0, 1, 1, 1, 2, -1, 2, 3, -1, 3, 1, 1], true),\n    // 1,000 copies of the edge (0, 1)\n    \"duplicate-heavy\": () => generated(2, 1000, () => [0, 1]),\n    // 2^20 nodes, edges only at the ends: sparse index handling and large-id output\n    \"max-node-index\": () => build(false, 2 ** 20, [0, 1, 2 ** 20 - 2, 2 ** 20 - 1, 0, 2 ** 20 - 1]),\n    // hub 0 with 100,000 leaves\n    \"star-100k\": () => generated(100_001, 100_000, (e) => [0, e + 1]),\n    // the path 0 - 1 - ... - 99,999\n    \"path-100k\": () => generated(100_000, 99_999, (e) => [e, e + 1]),\n};\n\n/**\n * An edge-case graph for testing parsers, loaders and algorithms. Every case loads with\n * graph-format's `fromEdgeArrays` default options, and each call returns fresh arrays.\n *\n * - `empty`: 0 nodes, 0 edges.\n * - `single-node`: 1 node, no edges.\n * - `single-self-loop`: 1 node with a self-loop.\n * - `isolated-nodes`: 10 nodes, no edges.\n * - `disconnected`: a triangle, a 3-node path, one edge and 2 isolated nodes (5 components).\n * - `pathological-undirected`: a self-loop, a triple parallel edge (one written reversed), weights\n *   0, negative and fractional.\n * - `pathological-directed`: a self-loop, parallel arcs, an anti-parallel pair (a 2-cycle), a\n *   negative-weight cycle reachable from 0, zero and negative weights.\n * - `zero-weights`: a 4-cycle plus a chord, all weights 0.\n * - `negative-weights`: a DAG with negative weights and no negative cycle (Bellman-Ford, DAG\n *   shortest paths); distances from 0 are [0, 4, 1, 4, 3].\n * - `negative-cycle`: a directed cycle of total weight -1 reachable from node 0.\n * - `duplicate-heavy`: 1,000 copies of the edge (0, 1).\n * - `max-node-index`: 2^20 nodes, 3 edges touching nodes 0, 1, 2^20 - 2 and 2^20 - 1.\n * - `star-100k`: a hub with 100,000 leaves (degree extremes).\n * - `path-100k`: a 100,000-node path (deep recursion, long diameters).\n * @param name - the case\n * @returns the graph\n */\nexport function edgeCaseGraph(name: EdgeCaseName): SampleGraph {\n    if (!(EDGE_CASE_NAMES as readonly string[]).includes(name)) {\n        throw new RangeError(`unknown edge case \"${name}\"; expected one of ${EDGE_CASE_NAMES.join(\", \")}`);\n    }\n    return CASES[name]();\n}\n"],"names":["LN2_HI","LN2_LO","view","c","k","scale","a","cs","stubs"],"mappings":"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G;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MACzG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MACvG;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MACzG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAG;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MACvG;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MACxG;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MACxG;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MACxG;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MACxG;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;AAAA,MAAI;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"}