@graphty/graph-samples 0.0.1 → 0.1.2

package/src/generators/hyperbolic.ts

@@ -0,0 +1,193 @@
+/**
+ * Random hyperbolic graphs (D. Krioukov, F. Papadopoulos, M. Kitsak, A. Vahdat and M. Boguna,
+ * "Hyperbolic geometry of complex networks", Phys. Rev. E 82, 036106, 2010,
+ * doi:10.1103/PhysRevE.82.036106): power-law degrees, high clustering and a native 2D embedding.
+ */
+
+import { detExp } from "../random/exp.js";
+import { detLog } from "../random/log.js";
+import { RandomStream, resolveSeed } from "../random/stream.js";
+import { detCosSinTurn } from "../random/trig.js";
+import { type SampleGraph } from "../types.js";
+import { checkInt, EdgeBuffer, toGraph } from "./util.js";
+import { applyWeights, type WeightOptions } from "./weights.js";
+
+/** The largest node count of the O(n^2) pair loop. */
+const MAX_NODES = 20000;
+
+/** Options of {@link hyperbolicGraph}. */
+export interface HyperbolicOptions extends WeightOptions {
+    /** The node count, in [0, 20000]. */
+    n: number;
+    /** The target mean degree, a finite number > 0 (approximate: see {@link hyperbolicGraph}). */
+    averageDegree: number;
+    /** The power-law exponent gamma of the degree distribution, a finite number > 2. */
+    exponent: number;
+    /** The temperature T in [0, 1); 0 (default) is the threshold model, higher T lowers clustering. */
+    temperature?: number | undefined;
+    /** The seed, an integer in [0, 2^53); default 0. */
+    seed?: number | undefined;
+}
+
+/** The checked options, the disk radius and the points. */
+interface HyperbolicPlan {
+    readonly n: number;
+    readonly seed: number;
+    readonly temperature: number;
+    /** The disk radius R. */
+    readonly R: number;
+    readonly coshR: number;
+    readonly cosT: Float64Array<ArrayBuffer>;
+    readonly sinT: Float64Array<ArrayBuffer>;
+    readonly coshr: Float64Array<ArrayBuffer>;
+    readonly sinhr: Float64Array<ArrayBuffer>;
+    readonly x: Float64Array<ArrayBuffer>;
+    readonly y: Float64Array<ArrayBuffer>;
+    readonly radius: Float64Array<ArrayBuffer>;
+}
+
+/**
+ * cosh(x) from detExp.
+ * @param x - the argument
+ * @returns cosh x
+ */
+function cosh(x: number): number {
+    return (detExp(x) + detExp(-x)) / 2;
+}
+
+/**
+ * acosh(y) for y >= 1 from detLog.
+ * @param y - the argument
+ * @returns acosh y
+ */
+function acosh(y: number): number {
+    return detLog(y + Math.sqrt((y - 1) * (y + 1)));
+}
+
+/**
+ * Check the options, compute the disk radius and draw the points.
+ * @param options - the options
+ * @returns the plan
+ */
+export function planHyperbolic(options: HyperbolicOptions): HyperbolicPlan {
+    const { n, averageDegree, exponent } = options;
+    const temperature = options.temperature ?? 0;
+    checkInt("n", n, 0, MAX_NODES);
+    if (!(Number.isFinite(averageDegree) && averageDegree > 0)) {
+        throw new RangeError(`averageDegree must be a finite number > 0, got ${String(averageDegree)}`);
+    }
+    if (!(Number.isFinite(exponent) && exponent > 2)) {
+        throw new RangeError(`exponent must be a finite number > 2, got ${String(exponent)}`);
+    }
+    if (!(temperature >= 0 && temperature < 1)) {
+        throw new RangeError(`temperature must be in [0, 1), got ${String(temperature)}`);
+    }
+    const seed = resolveSeed(options.seed);
+
+    const alpha = (exponent - 1) / 2;
+    const xi = alpha / (alpha - 0.5);
+    let correction = 1;
+    if (temperature > 0) {
+        const cs = new Float64Array(2);
+        detCosSinTurn(temperature / 2, cs);
+        correction = (Math.PI * temperature) / cs[1];
+    }
+    const scale = ((2 * xi * xi * n) / (Math.PI * averageDegree)) * correction;
+    if (n >= 2 && !(scale > 1)) {
+        throw new RangeError(`averageDegree ${averageDegree} is too large for n = ${n}: the disk radius would be <= 0`);
+    }
+    const R = n >= 2 ? 2 * detLog(scale) : 0;
+    const coshAlphaR = cosh(alpha * R);
+    if (!Number.isFinite(coshAlphaR)) {
+        throw new RangeError(`exponent ${exponent} is too large: cosh(alpha R) overflows`);
+    }
+
+    const cosT = new Float64Array(n);
+    const sinT = new Float64Array(n);
+    const coshr = new Float64Array(n);
+    const sinhr = new Float64Array(n);
+    const x = new Float64Array(n);
+    const y = new Float64Array(n);
+    const radius = new Float64Array(n);
+    const cs = new Float64Array(2);
+    const stream = new RandomStream(seed, "hyperbolic-points", 0);
+    for (let i = 0; i < n; i++) {
+        stream.reset(i);
+        detCosSinTurn(stream.nextFloat(), cs);
+        const r = acosh(1 + (coshAlphaR - 1) * stream.nextFloat()) / alpha;
+        const er = detExp(r);
+        cosT[i] = cs[0];
+        sinT[i] = cs[1];
+        coshr[i] = (er + 1 / er) / 2;
+        sinhr[i] = (er - 1 / er) / 2;
+        radius[i] = r;
+        x[i] = r * cs[0];
+        y[i] = r * cs[1];
+    }
+    return { n, seed, temperature, R, coshR: cosh(R), cosT, sinT, coshr, sinhr, x, y, radius };
+}
+
+/**
+ * Rows [start, end) of the hyperbolic graph: row u holds the pairs (u, v), v = u + 1 .. n - 1 in
+ * ascending v, with cosh d = cosh r_u cosh r_v - sinh r_u sinh r_v cos(theta_u - theta_v) (the
+ * cosine of the angle difference expanded from the stored cosines and sines). At T = 0 the pair is
+ * an edge iff cosh d < cosh R (no draws). At T > 0 row u draws one nextFloat() t per pair from
+ * stream (seed, "hyperbolic", u) and the pair is an edge iff t < 1 / (1 + exp((d - R) / (2 T))),
+ * decided as acosh(cosh d) < R + 2 T ln((1 - t) / t) with no exp. Any split of [0, n) into
+ * consecutive ranges gives the whole graph.
+ * @param plan - the checked options and points
+ * @param start - the first row
+ * @param end - one past the last row
+ * @param out - receives the edges
+ */
+export function hyperbolicRows(plan: HyperbolicPlan, start: number, end: number, out: EdgeBuffer): void {
+    const { n, R, coshR, temperature, cosT, sinT, coshr, sinhr } = plan;
+    const stream = new RandomStream(plan.seed, "hyperbolic", 0);
+    for (let u = start; u < end; u++) {
+        stream.reset(u);
+        for (let v = u + 1; v < n; v++) {
+            const coshD = coshr[u] * coshr[v] - sinhr[u] * sinhr[v] * (cosT[u] * cosT[v] + sinT[u] * sinT[v]);
+            if (temperature === 0) {
+                if (coshD < coshR) {
+                    out.push(u, v);
+                }
+                continue;
+            }
+            const t = stream.nextFloat();
+            if (acosh(Math.max(1, coshD)) < R + 2 * temperature * detLog((1 - t) / t)) {
+                out.push(u, v);
+            }
+        }
+    }
+}
+
+/**
+ * A random hyperbolic graph (Krioukov et al. 2010): n points in a hyperbolic disk of radius R,
+ * angles uniform and radii with density proportional to sinh(alpha r), alpha = (gamma - 1) / 2,
+ * so the degrees follow a power law with exponent gamma. At temperature 0 two nodes are joined iff
+ * their hyperbolic distance is below R; at T > 0 with probability 1 / (1 + exp((d - R) / (2 T))).
+ *
+ * R comes from the paper's approximation of the mean degree, R = 2 ln(2 xi^2 n / (pi k)) with
+ * xi = alpha / (alpha - 1/2), times (pi T / sin(pi T)) inside the logarithm for T > 0. It is an
+ * approximation, so the measured mean degree only lands near `averageDegree`: measured at n = 3000
+ * and 10000, within about 10% for exponent >= 2.5 and T <= 0.7, but about 0.6x at exponent 2.2 and
+ * about 0.5x at T = 0.9 (the approximation degrades as gamma approaches 2 and T approaches 1).
+ *
+ * Node i draws its angle theta = 2 pi u and then its radius r = acosh(1 + (cosh(alpha R) - 1) u') /
+ * alpha (inverse CDF) from stream (seed, "hyperbolic-points", i); the pairs are decided by
+ * {@link hyperbolicRows}. Edges are the pairs (u, v), u < v, ascending u then v. Node columns (all
+ * Float64Array): `x`, `y` (the native polar embedding r cos theta, r sin theta) and `radius` (r).
+ *
+ * Cost: O(n^2) pairs (and one draw per pair at T > 0), so n is capped at 20000.
+ * ponytail: naive pair loop, n <= 20000; the band algorithm of M. von Looz, H. Meyerhenke and
+ * R. Prutkin, "Generating random hyperbolic graphs in subquadratic time", ISAAC 2015,
+ * doi:10.1007/978-3-662-48971-0_40, is the upgrade path.
+ * @param options - n, averageDegree, exponent, temperature and seed
+ * @returns the undirected graph
+ */
+export function hyperbolicGraph(options: HyperbolicOptions): SampleGraph {
+    const plan = planHyperbolic(options);
+    const out = new EdgeBuffer(Math.ceil(plan.n * options.averageDegree * 0.75) + 16);
+    hyperbolicRows(plan, 0, plan.n, out);
+    return applyWeights(toGraph(plan.n, out, false, { x: plan.x, y: plan.y, radius: plan.radius }), options);
+}

package/src/generators/index.ts

@@ -0,0 +1,133 @@
+/**
+ * `@graphty/graph-samples/generators`: every graph generator. Each returns a {@link SampleGraph}
+ * (typed arrays that `fromEdgeArrays` of @graphty/graph-format loads directly). The random ones
+ * take an optional `seed` (default 0) and produce the same graph for the same options on every platform and
+ * every version of this package.
+ */
+
+export { type SampleGraph } from "../types.js";
+export { randomBipartiteGraph, type RandomBipartiteOptions } from "./bipartite.js";
+export {
+    plantedPartitionGraph,
+    type PlantedPartitionOptions,
+    stochasticBlockModelGraph,
+    type StochasticBlockModelOptions,
+} from "./block-model.js";
+export {
+    balancedTreeGraph,
+    barbellGraph,
+    cavemanGraph,
+    circularLadderGraph,
+    completeBipartiteGraph,
+    completeGraph,
+    completeMultipartiteGraph,
+    connectedCavemanGraph,
+    cycleGraph,
+    emptyGraph,
+    hypercubeGraph,
+    ladderGraph,
+    lollipopGraph,
+    mobiusLadderGraph,
+    pathGraph,
+    petersenGraph,
+    ringOfCliquesGraph,
+    starGraph,
+    wheelGraph,
+} from "./classic.js";
+export {
+    bipartiteConfigurationModelGraph,
+    type BipartiteConfigurationModelOptions,
+    chungLuGraph,
+    type ChungLuOptions,
+    configurationModelGraph,
+    type ConfigurationModelOptions,
+    degreeCorrectedSbmGraph,
+    type DegreeCorrectedSbmOptions,
+    directedConfigurationModelGraph,
+    type DirectedConfigurationModelOptions,
+    type EdgePolicy,
+    powerLawDegreeSequence,
+    type PowerLawDegreeSequenceOptions,
+    randomRegularGraph,
+    type RandomRegularOptions,
+} from "./degree-sequence.js";
+export {
+    kroneckerGraph,
+    type KroneckerOptions,
+    priceGraph,
+    type PriceOptions,
+    randomOrderDagGraph,
+    type RandomOrderDagOptions,
+    rmatGraph,
+    type RmatOptions,
+} from "./directed.js";
+export {
+    erdosRenyiGnmGraph,
+    type ErdosRenyiGnmOptions,
+    erdosRenyiGraph,
+    type ErdosRenyiOptions,
+} from "./erdos-renyi.js";
+export {
+    akGraph,
+    type AkOptions,
+    type FlowNetwork,
+    genrmfGraph,
+    type GenrmfOptions,
+    gridFlowNetwork,
+    type GridFlowOptions,
+    layeredFlowNetwork,
+    type LayeredFlowOptions,
+} from "./flow.js";
+export {
+    knnGraph,
+    type KnnOptions,
+    randomGeometricGraph,
+    type RandomGeometricOptions,
+    waxmanGraph,
+    type WaxmanOptions,
+} from "./geometric.js";
+export {
+    bianconiBarabasiGraph,
+    type BianconiBarabasiOptions,
+    duplicationDivergenceGraph,
+    type DuplicationDivergenceOptions,
+    forestFireGraph,
+    type ForestFireOptions,
+    newmanWattsGraph,
+    type NewmanWattsOptions,
+    randomApollonianGraph,
+    type RandomApollonianOptions,
+    randomRecursiveTreeGraph,
+    type RandomRecursiveTreeOptions,
+    wilsonMazeGraph,
+    type WilsonMazeOptions,
+} from "./growth.js";
+export { hyperbolicGraph, type HyperbolicOptions } from "./hyperbolic.js";
+export {
+    grid3dGraph,
+    type Grid3dOptions,
+    gridGraph,
+    type GridOptions,
+    hexagonalLatticeGraph,
+    type PlanarLatticeOptions,
+    triangularLatticeGraph,
+} from "./lattices.js";
+export { lfrGraph, type LfrOptions } from "./lfr.js";
+export { NAMED_GRAPH_NAMES, namedGraph, type NamedGraphName } from "./named.js";
+export {
+    barabasiAlbertGraph,
+    type BarabasiAlbertOptions,
+    wattsStrogatzGraph,
+    type WattsStrogatzOptions,
+} from "./preferential-attachment.js";
+export { randomDagGraph, type RandomDagOptions, randomTreeGraph, type RandomTreeOptions } from "./trees-and-dags.js";
+export {
+    addPathologicalEdges,
+    EDGE_CASE_NAMES,
+    edgeCaseGraph,
+    type EdgeCaseName,
+    type PathologicalEdgeOptions,
+    randomMultigraph,
+    type RandomMultigraphOptions,
+} from "./variants.js";
+export { type ColumnCombine, type WeightOptions, type WeightSpec, withWeights } from "./weights.js";

package/src/generators/lattices.ts

@@ -0,0 +1,290 @@
+/**
+ * Lattices: the square and cubic grids (with torus wrap-around, diagonal neighbours, forward-only
+ * arcs, random obstacles and position columns), the triangular lattice and the hexagonal
+ * (honeycomb) lattice. All deterministic except the obstacles, which draw from stream
+ * (seed, "grid-obstacles", node).
+ */
+
+import { RandomStream, resolveSeed } from "../random/stream.js";
+import { type SampleGraph } from "../types.js";
+import { checkEdgeCount, checkInt, checkProbability, EdgeBuffer, toGraph } from "./util.js";
+import { applyWeights, type WeightOptions } from "./weights.js";
+
+/** Options of {@link grid3dGraph}. */
+export interface Grid3dOptions extends WeightOptions {
+    /** The number of rows, >= 1. */
+    rows: number;
+    /** The number of columns, >= 1. */
+    cols: number;
+    /** The number of layers, >= 1. */
+    layers: number;
+    /**
+     * Wrap around (a torus): the last node of each row, column and layer is joined to the first.
+     * A dimension shorter than 3 does not wrap, so the graph stays simple.
+     */
+    periodic?: boolean | undefined;
+    /**
+     * Join diagonal neighbours too: the king's graph (8 neighbours) in 2D, the 26-neighbour lattice
+     * in 3D.
+     */
+    diagonals?: boolean | undefined;
+    /**
+     * Emit each edge once as an arc from the lower index to the higher: a DAG whose only source is
+     * node 0 and only sink node n - 1. Not with `periodic`.
+     */
+    directed?: boolean | undefined;
+    /**
+     * Block each node independently with this probability, in [0, 1): a blocked node keeps its
+     * index (and position) but has no edges, and the u8 node column `blocked` marks it (1).
+     */
+    obstacles?: number | undefined;
+    /** Emit Float64 node columns `x` (column), `y` (row) and, when layers > 1, `z` (layer). */
+    positions?: boolean | undefined;
+}
+
+/** Options of {@link gridGraph}: {@link Grid3dOptions} without layers. */
+export type GridOptions = Omit<Grid3dOptions, "layers">;
+
+/**
+ * The neighbour offsets (dc, dr, dl) a node links forward to, in edge order: +column, +row,
+ * +layer, then (with diagonals) every other offset in {-1, 0, 1}^3 that is lexicographically
+ * positive in (dl, dr, dc), ordered by dl, then dr, then dc.
+ * @param diagonals - whether to include the diagonal offsets
+ * @returns the offsets
+ */
+function forwardOffsets(diagonals: boolean): number[][] {
+    const offsets = [
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1],
+    ];
+    if (diagonals) {
+        for (let dl = 0; dl <= 1; dl++) {
+            for (let dr = -1; dr <= 1; dr++) {
+                for (let dc = -1; dc <= 1; dc++) {
+                    const positive = dl > 0 || (dl === 0 && (dr > 0 || (dr === 0 && dc > 0)));
+                    const axis = Math.abs(dc) + Math.abs(dr) + Math.abs(dl) === 1;
+                    if (positive && !axis) {
+                        offsets.push([dc, dr, dl]);
+                    }
+                }
+            }
+        }
+    }
+    return offsets;
+}
+
+/**
+ * The rows x cols x layers grid. Node (l, r, c) is index (l * rows + r) * cols + c. For each node
+ * in index order, the edge to each forward neighbour in the order of the offsets: +column, +row,
+ * +layer, then the diagonals. Without options this is the 6-neighbour lattice of phase 1, edge for
+ * edge. Obstacles draw one float per node from stream (seed, "grid-obstacles", node) -- node < p
+ * blocks it -- so the obstacle map does not depend on the other options.
+ * @param options - sizes and the lattice options
+ * @returns the graph
+ */
+export function grid3dGraph(options: Grid3dOptions): SampleGraph {
+    const { rows, cols, layers } = options;
+    checkInt("rows", rows, 1);
+    checkInt("cols", cols, 1);
+    checkInt("layers", layers, 1);
+    const n = rows * cols * layers;
+    checkInt("rows * cols * layers", n, 1);
+    const periodic = options.periodic === true;
+    const directed = options.directed === true;
+    if (periodic && directed) {
+        throw new RangeError("directed grids cannot be periodic: the wrap-around arcs would close cycles");
+    }
+    const offsets = forwardOffsets(options.diagonals === true);
+    checkEdgeCount(n * offsets.length);
+    let blocked: Uint8Array<ArrayBuffer> | null = null;
+    if (options.obstacles !== undefined) {
+        const p = options.obstacles;
+        checkProbability("obstacles", p);
+        if (p >= 1) {
+            throw new RangeError("obstacles must be below 1");
+        }
+        blocked = new Uint8Array(n);
+        const stream = new RandomStream(resolveSeed(options.seed), "grid-obstacles", 0);
+        for (let i = 0; i < n; i++) {
+            stream.reset(i);
+            blocked[i] = stream.nextFloat() < p ? 1 : 0;
+        }
+    }
+    const sizes = [cols, rows, layers];
+    const wraps = sizes.map((size) => periodic && size >= 3);
+    const plane = rows * cols;
+    const out = new EdgeBuffer(n * Math.min(offsets.length, 3));
+    const at = [0, 0, 0];
+    for (let l = 0; l < layers; l++) {
+        for (let r = 0; r < rows; r++) {
+            for (let c = 0; c < cols; c++) {
+                const i = l * plane + r * cols + c;
+                if (blocked?.[i] === 1) {
+                    continue;
+                }
+                const here = [c, r, l];
+                for (const offset of offsets) {
+                    let inside = true;
+                    for (let axis = 0; axis < 3; axis++) {
+                        let x = here[axis] + offset[axis];
+                        if (x < 0 || x >= sizes[axis]) {
+                            if (!wraps[axis]) {
+                                inside = false;
+                                break;
+                            }
+                            x = (x + sizes[axis]) % sizes[axis];
+                        }
+                        at[axis] = x;
+                    }
+                    if (!inside) {
+                        continue;
+                    }
+                    const j = at[2] * plane + at[1] * cols + at[0];
+                    if (blocked?.[j] === 1) {
+                        continue;
+                    }
+                    out.push(directed && j < i ? j : i, directed && j < i ? i : j);
+                }
+            }
+        }
+    }
+    const columns: Record<string, Uint8Array<ArrayBuffer> | Float64Array<ArrayBuffer>> = {};
+    if (blocked !== null) {
+        columns.blocked = blocked;
+    }
+    if (options.positions === true) {
+        const x = new Float64Array(n);
+        const y = new Float64Array(n);
+        const z = layers > 1 ? new Float64Array(n) : null;
+        for (let i = 0; i < n; i++) {
+            x[i] = i % cols;
+            y[i] = Math.floor(i / cols) % rows;
+            if (z !== null) {
+                z[i] = Math.floor(i / plane);
+            }
+        }
+        columns.x = x;
+        columns.y = y;
+        if (z !== null) {
+            columns.z = z;
+        }
+    }
+    const graph = toGraph(n, out, directed, Object.keys(columns).length > 0 ? columns : undefined);
+    return applyWeights(graph, options);
+}
+
+/**
+ * The rows x cols grid: {@link grid3dGraph} with one layer. Node (r, c) is index r * cols + c; for
+ * each node in index order, the edge to its right neighbour, then the one below, then (with
+ * diagonals) below-left and below-right.
+ * @param options - sizes and the lattice options
+ * @returns the graph
+ */
+export function gridGraph(options: GridOptions): SampleGraph {
+    return grid3dGraph({ ...options, layers: 1 });
+}
+
+/** Options of {@link triangularLatticeGraph} and {@link hexagonalLatticeGraph}. */
+export interface PlanarLatticeOptions extends WeightOptions {
+    /** The number of rows, >= 1. */
+    rows: number;
+    /** The number of columns, >= 1. */
+    cols: number;
+    /** Emit Float64 node columns `x` and `y` placing every edge at unit length. */
+    positions?: boolean | undefined;
+}
+
+const HALF_SQRT3 = 0.8660254037844386;
+
+/**
+ * Check the sizes of a planar lattice.
+ * @param options - the options
+ * @returns the node count
+ */
+function planarSize(options: PlanarLatticeOptions): number {
+    checkInt("rows", options.rows, 1);
+    checkInt("cols", options.cols, 1);
+    const n = options.rows * options.cols;
+    checkInt("rows * cols", n, 1);
+    checkEdgeCount(3 * n);
+    return n;
+}
+
+/**
+ * The triangular lattice as a triangulated rows x cols grid: node (r, c) is index r * cols + c and
+ * links to (r, c + 1), (r + 1, c) and (r + 1, c - 1), in that order, for each node in index order.
+ * Interior nodes have degree 6. Positions shear the grid into a parallelogram of equilateral
+ * triangles: x = c + r / 2, y = r sqrt(3) / 2.
+ * @param options - rows, cols, positions
+ * @returns the undirected graph
+ */
+export function triangularLatticeGraph(options: PlanarLatticeOptions): SampleGraph {
+    const n = planarSize(options);
+    const { rows, cols } = options;
+    const out = new EdgeBuffer(3 * n);
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            const i = r * cols + c;
+            if (c + 1 < cols) {
+                out.push(i, i + 1);
+            }
+            if (r + 1 < rows) {
+                out.push(i, i + cols);
+                if (c > 0) {
+                    out.push(i, i + cols - 1);
+                }
+            }
+        }
+    }
+    let columns: SampleGraph["nodeColumns"];
+    if (options.positions === true) {
+        const x = new Float64Array(n);
+        const y = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            const r = Math.floor(i / cols);
+            x[i] = (i % cols) + r / 2;
+            y[i] = r * HALF_SQRT3;
+        }
+        columns = { x, y };
+    }
+    return applyWeights(toGraph(n, out, false, columns), options);
+}
+
+/**
+ * The hexagonal (honeycomb) lattice in its brick-wall form: node (r, c) is index r * cols + c and
+ * links to (r, c + 1) always and to (r + 1, c) when r + c is even, in that order, for each node in
+ * index order. Interior nodes have degree 3; every face is a hexagon. Positions give unit edges:
+ * x = c sqrt(3) / 2, y = 1.5 r + (r + c even ? 0.5 : 0).
+ * @param options - rows, cols, positions
+ * @returns the undirected graph
+ */
+export function hexagonalLatticeGraph(options: PlanarLatticeOptions): SampleGraph {
+    const n = planarSize(options);
+    const { rows, cols } = options;
+    const out = new EdgeBuffer(2 * n);
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            const i = r * cols + c;
+            if (c + 1 < cols) {
+                out.push(i, i + 1);
+            }
+            if (r + 1 < rows && (r + c) % 2 === 0) {
+                out.push(i, i + cols);
+            }
+        }
+    }
+    let columns: SampleGraph["nodeColumns"];
+    if (options.positions === true) {
+        const x = new Float64Array(n);
+        const y = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            const r = Math.floor(i / cols);
+            const c = i % cols;
+            x[i] = c * HALF_SQRT3;
+            y[i] = 1.5 * r + ((r + c) % 2 === 0 ? 0.5 : 0);
+        }
+        columns = { x, y };
+    }
+    return applyWeights(toGraph(n, out, false, columns), options);
+}