@knowvah/dot-engine 2.6.11 → 2.7.0

package/src/layout/neato/dijkstra.ts

@@ -30,126 +30,252 @@ export interface TermSgd {
 }
 
 // ---------------------------------------------------------------------------
-// Min-heap (keyed by Float32Array distances)
+// Float Dijkstra: dijkstra_f and its indexed heap (shares NgHeap and the
+// exchange / assign helpers with the DistType heap below)
 // ---------------------------------------------------------------------------
 
-/** Push vertex index `idx` into the heap. @internal */
-export function heapPush(
-  heap: number[],
-  dist: Float32Array,
-  idx: number,
-): void {
-  let pos = heap.length;
-  heap.push(idx);
-  while (pos > 0) {
-    const parent = (pos - 1) >> 1;
-    if (dist[heap[parent]] <= dist[heap[pos]]) break;
-    const tmp = heap[parent];
-    heap[parent] = heap[pos];
-    heap[pos] = tmp;
-    pos = parent;
-  }
+/** C `FLT_MAX`: the "unreachable" distance of dijkstra_f. */
+export const FLT_MAX = 3.4028234663852886e38;
+
+/** @see lib/neatogen/dijkstra.c:greaterPriority_f */
+function greaterPriorityF(h: NgHeap, i: number, j: number, dist: Float32Array): boolean {
+  return dist[h.data[i]!]! < dist[h.data[j]!]!;
 }
 
-/** Sift the root down to restore heap order after replacing it. @internal */
-export function heapSiftDown(heap: number[], dist: Float32Array): void {
-  let pos = 0;
+/** @see lib/neatogen/dijkstra.c:heapify_f */
+function heapifyF(h: NgHeap, start: number, dist: Float32Array): void {
+  let i = start;
   for (;;) {
-    const l = 2 * pos + 1;
-    const r = 2 * pos + 2;
-    let smallest = pos;
-    if (l < heap.length && dist[heap[l]] < dist[heap[smallest]]) smallest = l;
-    if (r < heap.length && dist[heap[r]] < dist[heap[smallest]]) smallest = r;
-    if (smallest === pos) break;
-    const tmp = heap[smallest];
-    heap[smallest] = heap[pos];
-    heap[pos] = tmp;
-    pos = smallest;
+    const l = ngLeft(i);
+    const r = ngRight(i);
+    let largest = ngInsideHeap(h, l) && greaterPriorityF(h, l, i, dist) ? l : i;
+    if (ngInsideHeap(h, r) && greaterPriorityF(h, r, largest, dist)) largest = r;
+    if (largest === i) break;
+    ngExchange(h, largest, i);
+    i = largest;
   }
 }
 
-/** Pop and return the vertex with minimum distance. @internal */
-export function heapPop(heap: number[], dist: Float32Array): number {
-  const top = heap[0];
-  const last = heap.pop()!;
-  if (heap.length === 0) return top;
-  heap[0] = last;
-  heapSiftDown(heap, dist);
-  return top;
-}
-
-/** Build a min-heap from all nodes except `src`. @internal */
-export function heapBuildExcluding(
-  src: number,
-  n: number,
-  dist: Float32Array,
-): number[] {
-  const heap: number[] = [];
+/** @see lib/neatogen/dijkstra.c:initHeap_f */
+function initHeapF(startVertex: number, dist: Float32Array, n: number): NgHeap {
+  const h: NgHeap = {
+    data: new Array<number>(Math.max(n - 1, 0)).fill(0),
+    heapSize: n - 1,
+    index: new Int32Array(n),
+  };
+  let count = 0;
   for (let i = 0; i < n; i++) {
-    if (i !== src) heapPush(heap, dist, i);
+    if (i !== startVertex) {
+      h.data[count] = i;
+      h.index[i] = count;
+      count++;
+    }
   }
-  return heap;
+  for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) heapifyF(h, j, dist);
+  return h;
 }
 
-// ---------------------------------------------------------------------------
-// dijkstra helpers
-// ---------------------------------------------------------------------------
+/**
+ * Pops the closest vertex; returns -1 (C `false`) when the heap is empty.
+ * @see lib/neatogen/dijkstra.c:extractMax_f
+ */
+function extractMaxF(h: NgHeap, dist: Float32Array): number {
+  if (h.heapSize === 0) return -1;
+  const max = h.data[0]!;
+  h.data[0] = h.data[h.heapSize - 1]!;
+  h.index[h.data[0]] = 0;
+  h.heapSize--;
+  heapifyF(h, 0, dist);
+  return max;
+}
 
-/** Initialise dist array from source edges. @internal */
-export function dijkstraInitDist(
-  src: number,
-  graph: VtxData[],
-  n: number,
-  dist: Float32Array,
+/** @see lib/neatogen/dijkstra.c:increaseKey_f */
+function increaseKeyF(
+  h: NgHeap, increasedVertex: number, newDist: number, dist: Float32Array,
 ): void {
-  for (let i = 0; i < n; i++) dist[i] = Infinity;
-  dist[src] = 0;
-  const v = graph[src];
-  for (let i = 1; i < v.nedges; i++) dist[v.edges[i]] = v.ewgts[i];
+  if (dist[increasedVertex]! <= newDist) return;
+  let i = h.index[increasedVertex]!;
+  dist[increasedVertex] = newDist;
+  while (i > 0 && dist[h.data[ngParent(i)]!]! > newDist) {
+    ngAssign(h, i, ngParent(i));
+    i = ngParent(i);
+  }
+  h.data[i] = increasedVertex;
+  h.index[increasedVertex] = i;
 }
 
-/** Relax all outgoing edges of `closest`. @internal */
-export function dijkstraRelax(
-  closest: number,
-  closestDist: number,
+/**
+ * Weighted single-source shortest paths from `vertex`; assumes a connected
+ * graph, unreachable vertices keep `FLT_MAX`. All arithmetic is C `float`.
+ *
+ * @see lib/neatogen/dijkstra.c:dijkstra_f
+ */
+export function dijkstra(
+  vertex: number,
   graph: VtxData[],
+  n: number,
   dist: Float32Array,
-  heap: number[],
 ): void {
-  const cv = graph[closest];
-  for (let i = 1; i < cv.nedges; i++) {
-    const nb = cv.edges[i];
-    const nd = closestDist + cv.ewgts[i];
-    if (nd < dist[nb]) {
-      dist[nb] = nd;
-      heapPush(heap, dist, nb);
+  for (let i = 0; i < n; i++) dist[i] = FLT_MAX;
+  dist[vertex] = 0;
+  const vd = graph[vertex]!;
+  for (let i = 1; i < vd.nedges; i++) dist[vd.edges[i]!] = vd.ewgts[i]!;
+
+  const h = initHeapF(vertex, dist, n);
+  for (let closest = extractMaxF(h, dist); closest >= 0; closest = extractMaxF(h, dist)) {
+    const closestDist = dist[closest]!;
+    if (closestDist === FLT_MAX) break;
+    const cd = graph[closest]!;
+    for (let i = 1; i < cd.nedges; i++) {
+      increaseKeyF(h, cd.edges[i]!, Math.fround(closestDist + Math.fround(cd.ewgts[i]!)), dist);
     }
   }
 }
 
 // ---------------------------------------------------------------------------
-// Public: dijkstra (float-weight, float-output)
+// Integer (DistType) Dijkstra: ngdijkstra and its max-heap
 // ---------------------------------------------------------------------------
 
+/** C `(DistType)INT_MAX`. @see lib/neatogen/dijkstra.c:MAX_DIST */
+export const MAX_DIST = 2147483647;
+
 /**
- * Single-source shortest paths (weighted) from `src`.
- * Populates `dist` with Float32 distances; unreachable nodes get Infinity.
- * Equivalent to `dijkstra_f` in lib/neatogen/dijkstra.c.
- *
- * @see lib/neatogen/dijkstra.c:dijkstra_f
+ * The heap of dijkstra.c: `data[i] = vertexNum <=> index[vertexNum] = i`, with
+ * the 0-rooted `left = 2i`, `right = 2i + 1`, `parent = i / 2` numbering.
+ * @see lib/neatogen/dijkstra.c:heap
  */
-export function dijkstra(
-  src: number,
-  graph: VtxData[],
-  n: number,
-  dist: Float32Array,
+export interface NgHeap {
+  data: number[];
+  heapSize: number;
+  index: Int32Array;
+}
+
+/** @see lib/neatogen/dijkstra.c:left */
+function ngLeft(i: number): number { return 2 * i; }
+
+/** @see lib/neatogen/dijkstra.c:right */
+function ngRight(i: number): number { return 2 * i + 1; }
+
+/** @see lib/neatogen/dijkstra.c:parent */
+function ngParent(i: number): number { return Math.trunc(i / 2); }
+
+/** @see lib/neatogen/dijkstra.c:insideHeap */
+function ngInsideHeap(h: NgHeap, i: number): boolean { return i < h.heapSize; }
+
+/** @see lib/neatogen/dijkstra.c:greaterPriority */
+function ngGreaterPriority(h: NgHeap, i: number, j: number, dist: Int32Array): boolean {
+  return dist[h.data[i]!]! < dist[h.data[j]!]!;
+}
+
+/** @see lib/neatogen/dijkstra.c:assign */
+function ngAssign(h: NgHeap, i: number, j: number): void {
+  h.data[i] = h.data[j]!;
+  h.index[h.data[i]!] = i;
+}
+
+/** @see lib/neatogen/dijkstra.c:exchange */
+function ngExchange(h: NgHeap, i: number, j: number): void {
+  const t = h.data[i]!;
+  h.data[i] = h.data[j]!;
+  h.data[j] = t;
+  h.index[h.data[i]!] = i;
+  h.index[h.data[j]!] = j;
+}
+
+/** @see lib/neatogen/dijkstra.c:heapify */
+function ngHeapify(h: NgHeap, start: number, dist: Int32Array): void {
+  let i = start;
+  for (;;) {
+    const l = ngLeft(i);
+    const r = ngRight(i);
+    let largest = ngInsideHeap(h, l) && ngGreaterPriority(h, l, i, dist) ? l : i;
+    if (ngInsideHeap(h, r) && ngGreaterPriority(h, r, largest, dist)) largest = r;
+    if (largest === i) break;
+    ngExchange(h, largest, i);
+    i = largest;
+  }
+}
+
+/** @see lib/neatogen/dijkstra.c:initHeap */
+export function ngInitHeap(startVertex: number, dist: Int32Array, n: number): NgHeap {
+  const h: NgHeap = {
+    data: new Array<number>(Math.max(n - 1, 0)).fill(0),
+    heapSize: n - 1,
+    index: new Int32Array(n),
+  };
+  let count = 0;
+  for (let i = 0; i < n; i++) {
+    if (i !== startVertex) {
+      h.data[count] = i;
+      h.index[i] = count;
+      count++;
+    }
+  }
+  for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) ngHeapify(h, j, dist);
+  return h;
+}
+
+/**
+ * Pops the closest vertex; returns -1 (C `false`) when the heap is empty.
+ * @see lib/neatogen/dijkstra.c:extractMax
+ */
+export function ngExtractMax(h: NgHeap, dist: Int32Array): number {
+  if (h.heapSize === 0) return -1;
+  const max = h.data[0]!;
+  h.data[0] = h.data[h.heapSize - 1]!;
+  h.index[h.data[0]] = 0;
+  h.heapSize--;
+  ngHeapify(h, 0, dist);
+  return max;
+}
+
+/** @see lib/neatogen/dijkstra.c:increaseKey */
+export function ngIncreaseKey(
+  h: NgHeap, increasedVertex: number, newDist: number, dist: Int32Array,
 ): void {
-  dijkstraInitDist(src, graph, n, dist);
-  const heap = heapBuildExcluding(src, n, dist);
-  while (heap.length > 0) {
-    const closest = heapPop(heap, dist);
-    const closestDist = dist[closest];
-    if (!isFinite(closestDist)) break;
-    dijkstraRelax(closest, closestDist, graph, dist, heap);
+  if (dist[increasedVertex]! <= newDist) return;
+  let i = h.index[increasedVertex]!;
+  dist[increasedVertex] = newDist;
+  while (i > 0 && dist[h.data[ngParent(i)]!]! > newDist) {
+    ngAssign(h, i, ngParent(i));
+    i = ngParent(i);
+  }
+  h.data[i] = increasedVertex;
+  h.index[increasedVertex] = i;
+}
+
+/** C `(DistType)` of a float edge weight (truncation toward zero). */
+function toDistType(w: number): number {
+  return Math.trunc(Math.fround(w));
+}
+
+/**
+ * Single-source shortest paths on the int-truncated edge weights `ewgts`;
+ * unreachable vertices get `prevClosestDist + 10` (INT_MAX when that would
+ * overflow).
+ * @see lib/neatogen/dijkstra.c:ngdijkstra
+ */
+export function ngdijkstra(vertex: number, graph: VtxData[], n: number, dist: Int32Array): void {
+  let prevClosestDist = MAX_DIST;
+  for (let i = 0; i < n; i++) dist[i] = MAX_DIST;
+  dist[vertex] = 0;
+  const vd = graph[vertex]!;
+  for (let i = 1; i < vd.nedges; i++) dist[vd.edges[i]!] = toDistType(vd.ewgts[i]!);
+
+  const h = ngInitHeap(vertex, dist, n);
+  for (let closest = ngExtractMax(h, dist); closest >= 0; closest = ngExtractMax(h, dist)) {
+    const closestDist = dist[closest]!;
+    if (closestDist === MAX_DIST) break;
+    const cd = graph[closest]!;
+    for (let i = 1; i < cd.nedges; i++) {
+      ngIncreaseKey(h, cd.edges[i]!, (closestDist + toDistType(cd.ewgts[i]!)) | 0, dist);
+    }
+    prevClosestDist = closestDist;
+  }
+
+  for (let i = 0; i < n; i++) {
+    if (dist[i] === MAX_DIST) {
+      dist[i] = MAX_DIST - prevClosestDist < 10 ? MAX_DIST : prevClosestDist + 10;
+    }
   }
 }

package/src/layout/neato/edge-len.ts

@@ -9,6 +9,7 @@
 
 import type { Graph } from '../../model/graph.js';
 import type { Edge } from '../../model/edge.js';
+import { agwarningf } from '../../common/agerr.js';
 
 /** `dfltlen` passed by scan_graph_mode. @see lib/neatogen/stuff.c:scan_graph_mode */
 export const DEFAULT_EDGE_LEN = 1.0;
@@ -24,7 +25,7 @@ export function lenattr(ep: Edge, g: Graph): number {
   const val = /^\s*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/.exec(s);
   const len = val === null ? Number.NaN : parseFloat(val[0]);
   if (Number.isNaN(len) || len < 0 || len === 0) {
-    console.warn(`bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
+    agwarningf(`bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
     return DEFAULT_EDGE_LEN;
   }
   return len;

package/src/layout/neato/fdp-adjust.ts

@@ -26,6 +26,7 @@ import { vpscAdjust } from './vpsc-adjust.js';
 import { sepFactor } from './sep-factor.js';
 import { lateDouble } from '../../common/nodeinit.js';
 import { RenderError } from '../../errors.js';
+import { agwarningf } from '../../common/agerr.js';
 
 /** @see lib/neatogen/adjust.c:DFLT_MARGIN (points) */
 const DFLT_MARGIN = 4;
@@ -161,7 +162,7 @@ export function warnUnrecognizedOverlap(flag: string | undefined): void {
   const s = flag.toLowerCase();
   if (s.startsWith('prism') || NAMED_MODES.has(s)) return;
   if (mapBoolDflt(flag, false) === mapBoolDflt(flag, true)) return;
-  console.warn(`Unrecognized overlap value "${flag}" - using false`);
+  agwarningf(`Unrecognized overlap value "${flag}" - using false`);
 }
 
 /**
@@ -203,7 +204,7 @@ function adjustLate(g: Graph, am: AdjustData): number {
     case AM_IPSEP: return 0;
     case AM_VPSC: return vpscAdjust(g);
     default:
-      console.warn(`Unhandled adjust option ${am.print}`);
+      agwarningf(`Unhandled adjust option ${am.print}`);
       return 0;
   }
 }

package/src/layout/neato/gts-triangle.ts

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * GTS's enclosing triangle, split from cdt-surface.ts to mirror the GTS source
+ * file it ports (the oracle links libgts 0.7.6 for neato's constrained
+ * Delaunay triangulation).
+ * @see gts-0.7.6 src/triangle.c
+ */
+
+import { fma } from '../../common/fma.js';
+
+/** `#define SQRT3 1.73205080757` (gts-0.7.6 src/triangle.c). */
+const SQRT3 = 1.73205080757;
+
+/**
+ * Vertices of the triangle enclosing points (px[0..n), py[0..n)). The oracle's
+ * libgts (arm64) fuses r*SQRT3 + xo, r*2 + yo, xo - r*SQRT3 and
+ * dx*dx + dy*dy (fmadd/fmsub in _gts_triangle_enclosing), so those are fma.
+ * @see gts-0.7.6 src/triangle.c:gts_triangle_enclosing
+ */
+export function gtsTriangleEnclosing(
+  px: number[], py: number[], n: number, scale: number,
+): [[number, number], [number, number], [number, number]] {
+  let xmin = px[0]!; let xmax = px[0]!;
+  let ymin = py[0]!; let ymax = py[0]!;
+  for (let i = 1; i < n; i++) {
+    if (px[i]! > xmax) xmax = px[i]!;
+    else if (px[i]! < xmin) xmin = px[i]!;
+    if (py[i]! > ymax) ymax = py[i]!;
+    else if (py[i]! < ymin) ymin = py[i]!;
+  }
+  const xo = (xmax + xmin) / 2;
+  const yo = (ymax + ymin) / 2;
+  const dx = xmax - xo;
+  const dy = ymax - yo;
+  let r = scale * Math.sqrt(fma(dx, dx, dy * dy));
+  if (r === 0) r = scale;
+  return [
+    [fma(r, SQRT3, xo), yo - r],
+    [xo, fma(r, 2, yo)],
+    [fma(-r, SQRT3, xo), yo - r],
+  ];
+}

package/src/layout/neato/init.ts

@@ -16,15 +16,22 @@ import type { Edge } from '../../model/edge.js';
 import type { VtxData } from './dijkstra.js';
 import {
   DFLT_ITERATIONS,
+  OPT_SMART_INIT as STRESS_OPT_SMART_INIT,
   MODEL_MDS as STRESS_MODEL_MDS,
   MODEL_CIRCUIT as STRESS_MODEL_CIRCUIT,
   MODEL_SUBSET as STRESS_MODEL_SUBSET,
 } from './stress.js';
 import { sgdLayout } from './sgd.js';
 import { kkNeato } from './kk.js';
-import { checkStart, assertSupported, parseStart, INIT_RANDOM, INIT_REGULAR } from './start.js';
-
-export { checkStart };
+import {
+  checkStart, assertSupported, parseStart, INIT_RANDOM, INIT_REGULAR, INIT_SELF,
+} from './start.js';
+import { makeGraphDataC, graphHasLen } from './make-graph-data.js';
+import type { DirectedVtxData } from './opt-arrangement.js';
+import { stressMajorizationWithHierarchy } from './constrained-majorization.js';
+import { agerr } from '../../common/agerr.js';
+
+export { makeGraphDataC, graphHasLen, checkStart };
 import { mapbool } from '../dot/rank.js';
 import {
   computeApspPacked,
@@ -50,6 +57,7 @@ export const MODE_HIER = 2;
 export const MODE_IPSEP = 3;
 /** Stochastic gradient descent. @see lib/neatogen/neatoprocs.h */
 export const MODE_SGD = 4;
+/** `MaxIter` under MODE_SGD. @see neatoinit.c:1285 */ const SGD_ITERATIONS = 30;
 
 // ---------------------------------------------------------------------------
 // Model constants — @see lib/neatogen/defs.h
@@ -321,79 +329,75 @@ export function mapModelToStress(model: number): number {
 // solveModel helpers
 // ---------------------------------------------------------------------------
 
-/** Run stress majorization and write positions back. @see lib/neatogen/neatoinit.c:majorization */
-export function runMajorization(g: Graph, mode: number, model: number): void {
-  void model; // only MODEL_SHORTPATH distances are exercised by the suite
-  const nodeList = assignNodeIds(g);
+/** `MaxIter` per mode; `maxiter` goes through C `atoi` (no digits -> 0). @see neatoinit.c:1280-1287 */
+export function neatoMaxIter(maxiter: string | undefined, mode: number, n: number): number {
+  if (maxiter !== undefined) return parseInt(maxiter, 10) || 0;
+  if (mode === MODE_MAJOR) return DFLT_ITERATIONS;
+  return mode === MODE_SGD ? SGD_ITERATIONS : 100 * n;
+}
+
+/** `late_double(g, "levelsgap", 0.0, -DBL_MAX)`. @see lib/neatogen/neatoinit.c:majorization */
+const levelsGapOf = (g: Graph): number =>
+  lateDouble(g.root.attrs.get('levelsgap'), 0.0, -Number.MAX_VALUE);
+
+/** What `majorization` was called with, plus the options derived from it. */
+interface MajorizationCtx {
+  readonly g: Graph;
+  readonly mode: number;
+  readonly model: number;
+  readonly haveLen: boolean;
+  /** `opt_*` bits from `checkExp` and `checkStart`. */
+  readonly opts: number;
+}
+
+/**
+ * The solver step of `majorization`: `stress_majorization_with_hierarchy` for
+ * MODE_HIER, else the kD_mkernel (MODE_IPSEP without constraints runs it too).
+ * Returns C's `rv`; the coordinates are left in `dCoords`.
+ * @see lib/neatogen/neatoinit.c:majorization
+ */
+function solveStress(
+  c: MajorizationCtx, vtx: DirectedVtxData[], dCoords: Float64Array[], nodeList: Node[],
+): number {
+  const { g, mode, model, haveLen, opts } = c;
   const n = nodeList.length;
-  const haveLen = graphHasLen(g);
-  const vtx = makeGraphDataC(g, nodeList, haveLen, mode === MODE_HIER || mode === MODE_IPSEP);
-  checkStart(g); // C: srand48(seed) immediately before initLayout draws
-  const maxi = lateDouble(g.attrs.get('maxiter'), DFLT_ITERATIONS, 0);
+  const maxi = neatoMaxIter(g.attrs.get('maxiter'), mode, n);
   const epsilon = lateDouble(g.attrs.get('epsilon'), 1e-4, 0); // DFLT_TOLERANCE
+  if (mode === MODE_HIER) {
+    return stressMajorizationWithHierarchy(vtx, n, dCoords, nodeList, {
+      dim: DFLT_DIM, opts, model, maxi, epsilon, levelsGap: levelsGapOf(g),
+    });
+  }
   // C ipsep (stress_majorization_cola, constrained_majorization_ipsep.c:150) always uses
   // compute_apsp_packed; kD_mkernel uses the weighted APSP iff graph->ewgts (stress.c:855).
   const weighted = haveLen && mode !== MODE_IPSEP;
   const Dij = weighted ? computeWeightedApspPacked(vtx, n) : computeApspPacked(vtx, n);
-  const dCoords = [new Float64Array(n), new Float64Array(n)];
-  stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
-    dim: DFLT_DIM, opts: OPT_EXP_FLAG, maxi, epsilon,
+  return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
+    dim: DFLT_DIM, opts, maxi, epsilon,
   });
-  for (let i = 0; i < n; i++) {
-    nodeList[i]!.info.pos = [dCoords[0]![i]!, dCoords[1]![i]!];
-  }
 }
 
-/** Any edge carries a len attr (C: agattr_text(g, AGEDGE, "len")). */
-export function graphHasLen(g: Graph): boolean {
-  for (const e of g.edges) {
-    if (e.attrs.has('len')) return true;
+/** Run stress majorization and write positions back. @see lib/neatogen/neatoinit.c:majorization */
+export function runMajorization(g: Graph, mode: number, model: number): void {
+  const nodeList = assignNodeIds(g);
+  const n = nodeList.length;
+  const haveLen = graphHasLen(g);
+  // C: srand48(seed) immediately before initLayout draws; hier starts from self
+  const init = checkStart(g, n, mode === MODE_HIER ? INIT_SELF : INIT_RANDOM);
+  const opts = init === INIT_SELF ? OPT_EXP_FLAG | STRESS_OPT_SMART_INIT : OPT_EXP_FLAG;
+  const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
+  const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
+  const dCoords = [new Float64Array(n), new Float64Array(n)];
+  if (solveStress({ g, mode, model, haveLen, opts }, vtx, dCoords, nodeList) < 0) {
+    agerr('prev', 'layout aborted');
+    return;
   }
-  return false;
-}
-
-/**
- * C makeGraphData's vtx_data: per node out-edges then in-edges (agfstedge order), self at
- * index 0, duplicate neighbours merged (len keeps the max). ewgts: lens (default 1.0) if any
- * len attr, else 1.0 under haveDir (hier/ipsep), else absent (C NULL). eweights (haveWt)
- * and edists are not built: nothing on a supported path reads them.
- * @see lib/neatogen/neatoinit.c:makeGraphData
- * @see lib/neatogen/stuff.c:setEdgeLen
- */
-export function makeGraphDataC(
-  g: Graph, nodeList: Node[], haveLen: boolean, haveDir: boolean,
-): VtxData[] {
-  const vtx: VtxData[] = nodeList.map((_, i) => ({
-    nedges: 1, edges: [i], ewgts: haveLen || haveDir ? [0] : [],
-  }));
-  for (const np of nodeList) {
-    const i = np.info.id!;
-    const entry = vtx[i]!;
-    const seen = new Map<number, number>();
-    for (const ep of [...np.outEdges(g), ...np.inEdges(g)]) {
-      if (ep.head === ep.tail) continue;
-      const vp = ep.tail === np ? ep.head : ep.tail;
-      const vid = vp.info.id!;
-      const dist = haveLen ? lateDouble(ep.attrs.get('len'), 1.0, 0) : 1.0;
-      const idx = seen.get(vid);
-      if (idx !== undefined) {
-        if (haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx]!, dist);
-        continue;
-      }
-      seen.set(vid, entry.nedges);
-      entry.edges.push(vid);
-      if (haveLen || haveDir) entry.ewgts.push(dist); // C neatoinit.c:827: haveDir 1.0
-      entry.nedges++;
-    }
+  for (let i = 0; i < n; i++) {
+    nodeList[i]!.info.pos = [dCoords[0]![i]!, dCoords[1]![i]!];
   }
-  return vtx;
 }
 
-/**
- * Dispatch to the appropriate layout solver for the given mode.
- *
- * @see lib/neatogen/neatoinit.c:neatoLayout
- */
+/** Dispatch to the layout solver for the mode. @see lib/neatogen/neatoinit.c:neatoLayout */
 export function solveModel(g: Graph, mode: number, model: number): void {
   if (g.nodes.size < 2) return;
   assertSupported(g, mode, model);
@@ -411,11 +415,7 @@ export function solveModel(g: Graph, mode: number, model: number): void {
 // neatoTranslate helpers
 // ---------------------------------------------------------------------------
 
-/**
- * Find minimum X and Y across all node positions.
- *
- * @see lib/neatogen/neatoinit.c (translate logic)
- */
+/** Minimum X and Y across all node positions. @see lib/neatogen/neatoinit.c (translate logic) */
 export function findMinPos(g: Graph): { minX: number; minY: number } {
   let minX = Infinity;
   let minY = Infinity;

package/src/layout/neato/kk.ts

@@ -27,6 +27,7 @@ import { MODEL_MDS } from './init.js';
 import { solve } from './kk-solve.js';
 import { lenattr } from './edge-len.js';
 import { newPathState, shortestPath, mdsModel, type Neighbour } from './kk-paths.js';
+import { agwarningf } from '../../common/agerr.js';
 
 /** `Ndim`: layout dimension (this port lays out in 2-D only). */
 const NDIM = 2;
@@ -289,7 +290,7 @@ function moveNode(st: KkState, m: number): void {
 function solveModel(g: Graph, st: KkState): void {
   for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
   if (st.move === st.maxIter) {
-    console.warn(`Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
+    agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
   }
 }