@knowvah/dot-engine 2.6.11 → 2.7.0

package/src/layout/neato/__fixtures__/hier-majorization.ts

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Expected layouts for the T22 stress_majorization_with_hierarchy tests, captured
+ * from a native clang -O3 -flto=thin -arch arm64 (-DDIGCOLA) harness that links the
+ * oracle's own lib/neatogen (graphviz 16.1.0) and calls the function with a fresh
+ * libc rand()/drand48() stream (srand(1), srand48(seed)). Graphs are neato vtx_data
+ * with haveDir (edists); `g40` is a seeded random DAG (40 nodes, 70 edges).
+ * Generated data: do not hand-edit.
+ */
+
+/** One harness invocation and its native result. */
+export interface MajorizationCase {
+  readonly name: string;
+  readonly graph: 'probe' | 'c1554' | 'rdag' | 'g40';
+  readonly dim: number;
+  readonly opts: number;
+  readonly maxi: number;
+  readonly levelsGap: number;
+  readonly epsilon: number;
+  /** `srand48` seed before the call. */
+  readonly seed: number;
+  /** Native return value (iterations). */
+  readonly rv: number;
+  /** Native `d_coords`, one array per axis. */
+  readonly coords: readonly (readonly number[])[];
+}
+
+/** `vtx_data` rows of the `g40` graph. */
+export const G40_ROWS: readonly { edges: number[]; ewgts: number[]; edists: number[] }[] = [{"edges":[0,1,3,7,9,15,19,25],"ewgts":[0,1,1,1,1,1,1,1],"edists":[0,-1,-1,-1,-1,-1,-1,-1]},{"edges":[1,0,2,6,8],"ewgts":[0,1,1,1,1],"edists":[0,1,-1,-1,-1]},{"edges":[2,1],"ewgts":[0,1],"edists":[0,1]},{"edges":[3,0,4,5,18,22],"ewgts":[0,1,1,1,1,1],"edists":[0,1,-1,-1,-1,-1]},{"edges":[4,3,12],"ewgts":[0,1,1],"edists":[0,1,-1]},{"edges":[5,3,8,21,36],"ewgts":[0,1,1,1,1],"edists":[0,1,-1,-1,-1]},{"edges":[6,1,10,24,31],"ewgts":[0,1,1,1,1],"edists":[0,1,-1,-1,-1]},{"edges":[7,0,16],"ewgts":[0,1,1],"edists":[0,1,-1]},{"edges":[8,1,5,11,20,23,28,30],"ewgts":[0,1,1,1,1,1,1,1],"edists":[0,1,1,-1,-1,-1,-1,-1]},{"edges":[9,0,31],"ewgts":[0,1,1],"edists":[0,1,-1]},{"edges":[10,6,32],"ewgts":[0,1,1],"edists":[0,1,-1]},{"edges":[11,8,19,23],"ewgts":[0,1,1,1],"edists":[0,1,-1,-1]},{"edges":[12,4,13,14,15,26],"ewgts":[0,1,1,1,1,1],"edists":[0,1,-1,-1,-1,-1]},{"edges":[13,12],"ewgts":[0,1],"edists":[0,1]},{"edges":[14,12,24],"ewgts":[0,1,1],"edists":[0,1,-1]},{"edges":[15,0,12,19,21,31],"ewgts":[0,1,1,1,1,1],"edists":[0,1,1,-1,-1,-1]},{"edges":[16,7,17,18],"ewgts":[0,1,1,1],"edists":[0,1,-1,-1]},{"edges":[17,16,18,20,36],"ewgts":[0,1,1,1,1],"edists":[0,1,-1,-1,-1]},{"edges":[18,3,16,17,32,33,34],"ewgts":[0,1,1,1,1,1,1],"edists":[0,1,1,1,-1,-1,-1]},{"edges":[19,0,11,15,33,36],"ewgts":[0,1,1,1,1,1],"edists":[0,1,1,1,-1,-1]},{"edges":[20,8,17,24,26],"ewgts":[0,1,1,1,1],"edists":[0,1,1,-1,-1]},{"edges":[21,5,15,27,37],"ewgts":[0,1,1,1,1],"edists":[0,1,1,-1,-1]},{"edges":[22,3],"ewgts":[0,1],"edists":[0,1]},{"edges":[23,8,11,35],"ewgts":[0,1,1,1],"edists":[0,1,1,-1]},{"edges":[24,6,14,20,38],"ewgts":[0,1,1,1,1],"edists":[0,1,1,1,-1]},{"edges":[25,0,27,29],"ewgts":[0,1,1,1],"edists":[0,1,-1,-1]},{"edges":[26,12,20,30],"ewgts":[0,1,1,1],"edists":[0,1,1,-1]},{"edges":[27,21,25,37,39],"ewgts":[0,1,1,1,1],"edists":[0,1,1,-1,-1]},{"edges":[28,8,31,33],"ewgts":[0,1,1,1],"edists":[0,1,-1,-1]},{"edges":[29,25,34],"ewgts":[0,1,1],"edists":[0,1,-1]},{"edges":[30,8,26,36],"ewgts":[0,1,1,1],"edists":[0,1,1,-1]},{"edges":[31,6,9,15,28],"ewgts":[0,1,1,1,1],"edists":[0,1,1,1,1]},{"edges":[32,10,18,39],"ewgts":[0,1,1,1],"edists":[0,1,1,-1]},{"edges":[33,18,19,28,38],"ewgts":[0,1,1,1,1],"edists":[0,1,1,1,-1]},{"edges":[34,18,29],"ewgts":[0,1,1],"edists":[0,1,1]},{"edges":[35,23,37,38],"ewgts":[0,1,1,1],"edists":[0,1,-1,-1]},{"edges":[36,5,17,19,30,39],"ewgts":[0,1,1,1,1,1],"edists":[0,1,1,1,1,-1]},{"edges":[37,21,27,35,39],"ewgts":[0,1,1,1,1],"edists":[0,1,1,1,-1]},{"edges":[38,24,33,35],"ewgts":[0,1,1,1],"edists":[0,1,1,1]},{"edges":[39,27,32,36,37],"ewgts":[0,1,1,1,1],"edists":[0,1,1,1,1]}];
+
+export const MAJORIZATION_CASES: readonly MajorizationCase[] = [
+  {
+    name: "probe smart", graph: 'probe', dim: 2, opts: 6, maxi: 200,
+    levelsGap: 0, epsilon: 0.0001, seed: 1, rv: 25,
+    coords: [
+      [-0.8872857689857483, 0.09007769823074341, 0.6606655120849609, -0.6603541970252991, -0.0897926613688469, 0.8866894245147705],
+      [1.0345146656036377, 0.6522425413131714, 0.00009558413876220584, 0.00009558413876220584, -0.6516568064689636, -1.0352916717529297],
+    ],
+  },
+  {
+    name: "probe smart levelsgap", graph: 'probe', dim: 2, opts: 6, maxi: 200,
+    levelsGap: 0.5, epsilon: 0.0001, seed: 1, rv: 12,
+    coords: [
+      [-0.9963757991790771, -0.015388643369078636, 0.7450122237205505, -0.7450122833251953, 0.015388717874884605, 0.9963758587837219],
+      [1.25, 0.7500000596046448, 0.2500000596046448, -0.24999994039535522, -0.7499999403953552, -1.25],
+    ],
+  },
+  {
+    name: "probe smart one iteration", graph: 'probe', dim: 2, opts: 6, maxi: 1,
+    levelsGap: 0, epsilon: 0.0001, seed: 1, rv: 1,
+    coords: [
+      [-0.6022335886955261, 0.0778207927942276, 0.6716713309288025, -0.6716711521148682, -0.07782091200351715, 0.6022335290908813],
+      [1.225775957107544, 0.5940203070640564, 0.00004230230115354061, 0.00004230230115354061, -0.5944178700447083, -1.2254630327224731],
+    ],
+  },
+  {
+    name: "probe smart no iterations (initial layout only)", graph: 'probe', dim: 2, opts: 6, maxi: 0,
+    levelsGap: 0, epsilon: 0.0001, seed: 1, rv: 0,
+    coords: [
+      [-0.52421848664645, 0.07426209500899247, 0.6209262062730561, -0.6209262062730563, -0.07426209500899264, 0.52421848664645],
+      [1.250000000000003, 0.5833333333333612, 0.08333333333334564, -0.08333333333333418, -0.5833333333333085, -1.2499999999999796],
+    ],
+  },
+  {
+    name: "c1554 smart", graph: 'c1554', dim: 2, opts: 6, maxi: 200,
+    levelsGap: 0, epsilon: 0.0001, seed: 1, rv: 3,
+    coords: [
+      [-0.2410670518875122, -0.2410670518875122, -0.2410670518875122, -0.5535792112350464, -0.2410670518875122, 0.9464221000671387, 0.5714253187179565],
+      [0, 0, 0, -0, -0, 0, -0],
+    ],
+  },
+  {
+    name: "c1554 plain init", graph: 'c1554', dim: 2, opts: 2, maxi: 200,
+    levelsGap: 0, epsilon: 0.0001, seed: 7, rv: 43,
+    coords: [
+      [-0.2458767145872116, -0.2458767145872116, -0.22192083299160004, -0.7836974859237671, 0.8581828474998474, 0.7025991082191467, -0.06341015547513962],
+      [0.6164672374725342, 0.6164672374725342, 0.6364861130714417, -1.054526448249817, -0.7265203595161438, 0.27123403549194336, -0.35960766673088074],
+    ],
+  },
+  {
+    name: "rdag smart", graph: 'rdag', dim: 2, opts: 6, maxi: 200,
+    levelsGap: 0, epsilon: 0.0001, seed: 1, rv: 72,
+    coords: [
+      [2.106701612472534, -8.845921516418457, 1.4982528686523438, -2.2527546882629395, 2.649675130844116, -2.313718318939209, -1.8075244426727295, -1.0636497735977173, 0.8014016151428223, -0.03322816640138626, -1.123450517654419, -1.6615859270095825, 0.2914482355117798, 0.2493419051170349, 0.6228430271148682, -0.3555810749530792, -0.4617708921432495, 2.9189040660858154, 1.533380150794983, 0.7932320237159729, 0.1701584756374359, 1.095284104347229, 0.38050132989883423, 1.773295283317566, 1.6413025856018066, 1.0647715330123901, 0.2310933619737625, 0.4141763746738434, 0.9322999119758606, -0.6915730237960815, -1.4681257009506226, 1.2065339088439941, -0.40464577078819275, 0.10893333703279495],
+      [3.935408592224121, 3.935408592224121, 3.128432273864746, 3.128432273864746, 3.128432273864746, 1.9458963871002197, 1.9458963871002197, 1.726983666419983, 2.210876226425171, 1.726983666419983, 1.0466965436935425, 1.0466965436935425, 1.0466965436935425, 1.0466965436935425, 0.32058167457580566, 0.2997589111328125, 0.2997589111328125, -1.0779701471328735, -0.2633209824562073, -0.3105449080467224, -1.0779701471328735, -1.0779701471328735, -1.0779701471328735, -1.1902680397033691, -1.716605544090271, -1.716605544090271, -2.100672960281372, -2.100672960281372, -2.3096060752868652, -2.475639581680298, -3.3348419666290283, -3.3348419666290283, -3.3348419666290283, -3.41929292678833],
+    ],
+  },
+  {
+    name: "rdag smart levelsgap", graph: 'rdag', dim: 2, opts: 6, maxi: 200,
+    levelsGap: 0.5, epsilon: 0.0001, seed: 1, rv: 39,
+    coords: [
+      [-12301.8642578125, -40660.5, -9774.89453125, 11809.7578125, -6476.82958984375, -8734.6494140625, 6348.06201171875, -4525.720703125, -6536.2080078125, -3894.280517578125, 1880.763916015625, -4501.078125, -2043.1739501953125, 7986.6591796875, 3269.953857421875, -404.2750549316406, 1482.980224609375, 12090.8525390625, 8846.69921875, 6487.10302734375, 2671.696044921875, -1566.1962890625, 4674.43212890625, 3535.6015625, 4471.04833984375, 6479.380859375, -0.44706612825393677, -958.3173217773438, 8040.14599609375, 5781.75244140625, 420.898193359375, 1973.5867919921875, -157.3118438720703, 4284.37109375],
+      [4969.9560546875, 4970.4560546875, 4969.4560546875, 4968.9560546875, 4968.4560546875, 4967.4560546875, 4966.9560546875, 4965.9560546875, 4967.9560546875, 4966.4560546875, 4965.4560546875, 4963.9560546875, 4964.4560546875, 4964.9560546875, 3209.87158203125, 3208.87158203125, 3209.37158203125, -1517.34619140625, 941.6177978515625, 941.6177978515625, -1518.34619140625, -1517.84619140625, -1518.34619140625, -3001.77978515625, -3002.27978515625, -3002.77978515625, -5185.4501953125, -5185.9501953125, -6037.169921875, -8404.357421875, -10032.125, -10032.625, -10033.125, -11062.6962890625],
+    ],
+  },
+  {
+    name: "rdag smart negative levelsgap", graph: 'rdag', dim: 2, opts: 6, maxi: 200,
+    levelsGap: -1, epsilon: 0.0001, seed: 1, rv: 131,
+    coords: [
+      [0.975033164024353, -8.91601276397705, 0.5004842877388, 2.977956771850586, 1.6438225507736206, -0.07275602966547012, 2.1174063682556152, -1.1853382587432861, -0.04999632015824318, 0.354489266872406, 1.2431221008300781, 1.073130488395691, -0.6186935305595398, -1.086130976676941, 0.2677907943725586, -0.048997968435287476, 0.09275322407484055, 2.133812665939331, 1.1161925792694092, -0.7022860050201416, -0.21006172895431519, -0.41585826873779297, 0.19944527745246887, 1.0232882499694824, -0.009082501754164696, 0.6798028349876404, -0.6689338088035583, -1.152896523475647, 0.559933066368103, -1.5303906202316284, 1.2292211055755615, -1.478786587715149, -0.5989389419555664, 0.557475209236145],
+      [4.457009792327881, 3.457009792327881, 3.5111281871795654, 2.554044723510742, 3.554044723510742, 2.9412379264831543, 1.7162097692489624, 2.3648476600646973, 2.371692657470703, 1.4127448797225952, 1.007383108139038, 2.004547595977783, 1.4327563047409058, 0.4327562749385834, 0.0988132432103157, 0.9681377410888672, 0.3813791871070862, -2.0102105140686035, -0.47968974709510803, -0.47968974709510803, -0.9354557394981384, -1.598078727722168, -0.9982943534851074, -1.6566381454467773, -2.1973824501037598, -1.1973823308944702, -2.3070976734161377, -1.5450495481491089, -2.3397669792175293, -2.5018789768218994, -4.301966190338135, -3.3019661903381348, -3.345038414001465, -3.470165967941284],
+    ],
+  },
+  {
+    name: "rdag plain init levelsgap", graph: 'rdag', dim: 2, opts: 2, maxi: 200,
+    levelsGap: 1.5, epsilon: 0.0001, seed: 7, rv: 10,
+    coords: [
+      [-0.1714787483215332, -6.736390590667725, 0.16777358949184418, 0.7151613831520081, -0.3481586277484894, 0.7005362510681152, 0.5633029341697693, 0.25387802720069885, 0.16892887651920319, 0.2626030147075653, 0.32713907957077026, 0.8732405304908752, 0.017587635666131973, 0.18712081015110016, 0.1815183013677597, -0.21678774058818817, 0.039015546441078186, -0.8158586621284485, 0.37755346298217773, 0.8203425407409668, 0.6037594079971313, 0.3468809425830841, -0.022601669654250145, 0.09913724660873413, 0.14511209726333618, 0.3509961664676666, 0.3168884813785553, 0.2200707346200943, 0.10131124407052994, 0.3687672019004822, -0.5803648233413696, 0.3717065453529358, 0.3560970425605774, -0.04478844627737999],
+      [20.38235092163086, 21.88235092163086, 18.88235092163086, 17.38235092163086, 15.882349967956543, 12.882349967956543, 11.382349967956543, 8.382349967956543, 14.382349967956543, 9.882349967956543, 6.882349967956543, 2.382349967956543, 3.882349967956543, 5.382349967956543, 2.382349967956543, -0.6176499724388123, 0.8823500275611877, -2.117650032043457, -0.6176499724388123, -0.6176499724388123, -5.117650032043457, -3.617650032043457, -5.117650032043457, -6.617650032043457, -8.117650032043457, -9.617650032043457, -11.117650032043457, -12.617650032043457, -14.117650032043457, -15.617650032043457, -17.11764907836914, -18.61764907836914, -20.11764907836914, -21.61764907836914],
+    ],
+  },
+  {
+    name: "rdag plain init 3-D", graph: 'rdag', dim: 3, opts: 2, maxi: 200,
+    levelsGap: 0, epsilon: 0.0001, seed: 7, rv: 200,
+    coords: [
+      [1.9230509996414185, -4.450254917144775, 1.3397730588912964, -2.589007616043091, 2.468080759048462, -1.613430142402649, -2.190492868423462, -0.6790580153465271, 0.5338876843452454, 0.2040603905916214, -1.497606635093689, -1.385814905166626, -0.343102365732193, -0.14492037892341614, 0.7068026661872864, -0.5179460048675537, -0.762558102607727, 2.3182451725006104, 1.2608115673065186, 0.6364292502403259, 0.9157735705375671, 0.7901390194892883, -0.35626527667045593, 0.9255744218826294, 1.3133991956710815, 0.1679213047027588, 0.9619991779327393, 0.06195592135190964, -0.10869356244802475, 0.672370970249176, -1.7973697185516357, 1.6563245058059692, 0.33709609508514404, -0.7571752667427063],
+      [3.637824296951294, 3.637824296951294, 2.7765800952911377, 2.7765800952911377, 2.7765800952911377, 1.5580389499664307, 1.5580389499664307, 1.0393105745315552, 1.9450687170028687, 1.0393105745315552, 0.9515085220336914, 0.9515085220336914, 0.9515085220336914, 0.9515085220336914, 0.34407156705856323, 0.34407156705856323, 0.34407156705856323, -0.8591142892837524, -0.7320063710212708, -0.01923421397805214, -0.8591142892837524, -0.8591142892837524, -0.8845171928405762, -1.159713864326477, -1.2608681917190552, -1.2608681917190552, -1.7222142219543457, -1.7222142219543457, -1.967499017715454, -2.4355876445770264, -2.9603357315063477, -2.9603357315063477, -2.9603357315063477, -2.9603357315063477],
+      [1.6783900260925293, -7.6042938232421875, 1.5541224479675293, 0.6140518188476562, 1.7654837369918823, 2.535907030105591, 0.8192742466926575, 2.5690112113952637, 1.3691827058792114, 1.4288212060928345, 0.41665998101234436, 1.5223040580749512, 1.2993186712265015, -0.6007012724876404, 0.6095350384712219, 0.6627642512321472, -0.005488100461661816, -0.4538416862487793, 0.8484395146369934, -0.45605137944221497, 0.2692951560020447, -1.310333013534546, -0.4890795946121216, -0.3461270034313202, -1.5077654123306274, 0.27062326669692993, -0.7134277820587158, -1.548409104347229, -0.2979923188686371, -1.650607943534851, -1.3032701015472412, -0.3259759843349457, -0.9536048769950867, -0.6662144064903259],
+    ],
+  },
+  {
+    name: "rdag plain init tight epsilon", graph: 'rdag', dim: 2, opts: 5, maxi: 200,
+    levelsGap: 0.3, epsilon: 0.000001, seed: 3, rv: 138,
+    coords: [
+      [4881.32666015625, -11929.93359375, 3984.729736328125, 5013.54052734375, 5451.97216796875, 3440.62744140625, 3713.17822265625, 2185.936279296875, 2424.29541015625, 1528.0205078125, 2568.227783203125, 2554.77880859375, 830.9662475585938, 1267.5498046875, 58.524845123291016, 1124.128173828125, 921.0764770507812, 422.65399169921875, -1197.61767578125, -679.9918212890625, -1911.75341796875, -1896.5244140625, -523.93017578125, -913.9660034179688, -2868.36865234375, -1473.961669921875, -2835.732177734375, -2314.52685546875, -1578.99365234375, -3544.86962890625, -133.86082458496094, -4183.23779296875, -2921.099609375, -1463.163330078125],
+      [1197.1910400390625, 1197.4910888671875, 1015.1022338867188, 60.00261306762695, 59.702613830566406, 57.60552215576172, 57.30552291870117, 56.705509185791016, 59.40261459350586, 57.005523681640625, 56.40550994873047, 55.505496978759766, 55.805511474609375, 56.10551071166992, 55.50551223754883, 54.90549850463867, 55.20549774169922, 54.605499267578125, 54.90549850463867, 54.90549850463867, 54.00550079345703, 54.30550003051758, 54.00550079345703, 53.705501556396484, 53.40550231933594, 53.10550308227539, -177.1049041748047, -177.4049072265625, -177.7049102783203, -178.00491333007812, -178.30491638183594, -178.60491943359375, -1689.3165283203125, -1937.4561767578125],
+    ],
+  },
+  {
+    name: "g40 smart levelsgap", graph: 'g40', dim: 2, opts: 6, maxi: 200,
+    levelsGap: 0.4, epsilon: 0.0001, seed: 3, rv: 24,
+    coords: [
+      [-1.0094189643859863, 0.46773967146873474, -3.3577399253845215, -1.9939782619476318, 2.1472113132476807, -0.442900151014328, 0.8790810704231262, -3.9394562244415283, 2.4742016792297363, -1.820883870124817, -2.4455490112304688, 3.7843005657196045, 4.557663917541504, 7.654958724975586, 6.022160053253174, 0.9374023675918579, -3.5004780292510986, -1.2619199752807617, -3.0502116680145264, 0.0648970827460289, 2.897508382797241, -0.8611336350440979, -5.626335620880127, 4.28245735168457, 3.9111220836639404, -4.367393493652344, 5.062668323516846, -3.247391939163208, 1.5867946147918701, -6.725042819976807, 2.8278207778930664, 0.9058087468147278, -3.64738392829895, -0.300179660320282, -5.379117965698242, 2.9269683361053467, -0.2548547387123108, -0.4261185824871063, 2.303642749786377, -2.0369181632995605],
+      [6.885787487030029, 5.685787200927734, 0.8857858777046204, 6.485787391662598, 5.285787105560303, 4.085786819458008, 1.2857857942581177, 6.085787296295166, 3.6857869625091553, 3.2857868671417236, -2.718261241912842, 2.0857865810394287, 4.4857869148254395, -0.7182613015174866, 0.08173868805170059, 2.885786771774292, 4.885787010192871, 2.0857865810394287, -0.3182613253593445, 0.08173868805170059, 0.4817386865615845, -1.9182612895965576, 1.685786485671997, -1.5182613134384155, -4.318261623382568, 2.4857866764068604, -1.1182613372802734, -3.518261432647705, 0.4817386865615845, -2.31826114654541, -2.718261241912842, -3.1182613372802734, -5.138027667999268, -4.738027572631836, -5.138027667999268, -4.338027477264404, -3.9182615280151367, -5.538027763366699, -5.938027858734131, -6.3380279541015625],
+    ],
+  },
+  {
+    name: "g40 plain init", graph: 'g40', dim: 2, opts: 2, maxi: 200,
+    levelsGap: 0, epsilon: 0.0001, seed: 1, rv: 40,
+    coords: [
+      [-0.12023495882749557, -0.10719820857048035, 1.5805704593658447, 0.5768365263938904, 1.8122634887695312, -0.9591823816299438, -1.3762669563293457, 0.8809503316879272, -0.8322945237159729, 0.5418577790260315, -2.370654582977295, -2.0197994709014893, 1.8294569253921509, 3.072965145111084, 1.4248172044754028, 0.17721407115459442, -0.6475740671157837, -0.23643508553504944, -0.005045577418059111, -0.8544038534164429, 0.32631435990333557, -0.5968142151832581, 2.3127048015594482, -2.3471274375915527, -0.21284359693527222, 1.1981782913208008, 1.7212520837783813, 0.49165067076683044, -1.7203251123428345, 2.2751946449279785, 0.5792899131774902, -0.48429036140441895, -1.4397521018981934, -1.0145349502563477, 1.3649485111236572, -2.1717777252197266, -0.17960841953754425, -0.4082253575325012, -1.3772825002670288, -0.684794008731842],
+      [1.6038932800292969, 1.6038932800292969, 0.66395103931427, 1.6038932800292969, 1.6038932800292969, 0.7164790034294128, 0.66395103931427, 1.6038932800292969, 0.7164790034294128, 0.7164790034294128, -0.44643980264663696, 0.66395103931427, 0.7164790034294128, -0.2532619833946228, -0.2532619833946228, 0.66395103931427, 1.5865058898925781, 0.66395103931427, -0.2532619833946228, 0.07963717728853226, 0.07963717728853226, -0.44643980264663696, 0.66395103931427, -0.2532619833946228, -1.063781499862671, 0.66395103931427, -0.2532619833946228, -1.063781499862671, 0.07963717728853226, -0.44643980264663696, -0.44643980264663696, -0.44643980264663696, -1.1681492328643799, -1.1681492328643799, -1.3430408239364624, -1.1681492328643799, -1.063781499862671, -1.8904457092285156, -1.8904457092285156, -2.0402238368988037],
+    ],
+  },
+];

package/src/layout/neato/cdt-surface.ts

@@ -36,6 +36,7 @@
 
 import { incircle, orient2d } from './delaunay.js';
 import { InternalError } from '../../errors.js';
+import { gtsTriangleEnclosing } from './gts-triangle.js';
 
 /** Triangulated surface. @see lib/neatogen/delaunay.h:surface_t */
 export interface Surface {
@@ -354,14 +355,14 @@ class Cdt {
 
     if (this.inCircle(v1, v2, v3, v4) > 0) {
       const en = this.edgeOrNew(v3, v4);
-      // f3 ring: (v4, v2, v3) with edges (e5, e2, en); e5 = v4–v2
-      // f4 ring: (v1, v4, v3) with edges (e4, en, e3); e4 = v1–v4
-      // (rings derived from C's gts_face_new(en,e5,e2)/(en,e3,e4) cycles,
-      //  matching the vertex triples C passes to the recursive calls)
+      // C: f3 = gts_face_new(en, e5, e2), f4 = gts_face_new(en, e3, e4).
+      // The stored ring starts at C's t->e1 (en) because gts_triangle_vertices
+      // reads (e1-only, e1∩e2, e2-only): f3 → (v3, v4, v2), f4 → (v4, v3, v1).
+      // That is the vertex order mkSurface emits and triCenter sums in.
       this.removeFace(f1);
       this.removeFace(f2);
-      const f3 = this.addFace([v4, v2, v3], [e5, e2, en]);
-      const f4 = this.addFace([v1, v4, v3], [e4, en, e3]);
+      const f3 = this.addFace([v3, v4, v2], [en, e5, e2]);
+      const f4 = this.addFace([v4, v3, v1], [en, e3, e4]);
 
       this.swapIfInCircle(f3, v4, v2, v3, e5, e2, en);
       this.swapIfInCircle(f4, v1, v4, v3, e4, en, e3);
@@ -644,8 +645,6 @@ class Cdt {
   }
 }
 
-const SQRT3 = 1.73205080756887729;
-
 /**
  * Build the constrained Delaunay surface over n points with nsegs directed
  * constraint segments (segs[2k], segs[2k+1]), removing hole faces.
@@ -659,21 +658,12 @@ export function mkSurface(
   const py = y.slice(0, n);
 
   // gts_triangle_enclosing(points, scale=100)
-  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;
-  let r = 100 * Math.hypot(xmax - xo, ymax - yo);
-  if (r === 0) r = 100;
   const s0 = n;
-  px.push(xo + r * SQRT3, xo, xo - r * SQRT3);
-  py.push(yo - r, yo + 2 * r, yo - r);
+  const enc = gtsTriangleEnclosing(px, py, n, 100);
+  for (const [ex, ey] of enc) {
+    px.push(ex);
+    py.push(ey);
+  }
 
   const cdt = new Cdt(px, py);
   // tri(): constraint edges are created BEFORE the vertices are inserted,

package/src/layout/neato/compute-hierarchy.ts

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Partition graph nodes into levels by the minimizer of the hierarchy energy.
+ *
+ * @see lib/neatogen/compute_hierarchy.c
+ */
+
+import type { VtxData } from './dijkstra.js';
+import { quicksortPlace } from './kkutils.js';
+import { computeYCoords } from './opt-arrangement.js';
+
+/** Result of `compute_hierarchy` on success (C return value 0). */
+export interface Hierarchy {
+  /** Node ids sorted by `y`; level `k` is `ordering[levels[k-1]..levels[k])`. */
+  ordering: Int32Array;
+  /** Start index (in `ordering`) of every level but the first; `[n]` when there is one level. */
+  levels: Int32Array;
+  /** C `*num_levelsp` (0 means a single level, `levels = [n]`). */
+  numLevels: number;
+}
+
+/**
+ * Count the gaps wider than `tol` between consecutive sorted `y` values.
+ * @see lib/neatogen/compute_hierarchy.c:compute_hierarchy
+ */
+function countLevels(y: Float64Array, ordering: Int32Array, n: number, tol: number): number {
+  let numLevels = 0;
+  for (let i = 1; i < n; i++) {
+    if (y[ordering[i]!]! - y[ordering[i - 1]!]! > tol) numLevels++;
+  }
+  return numLevels;
+}
+
+/**
+ * Fill the level start indices (a SINGLE_LINK clustering).
+ * @see lib/neatogen/compute_hierarchy.c:compute_hierarchy
+ */
+function fillLevels(
+  y: Float64Array,
+  ordering: Int32Array,
+  n: number,
+  tol: number,
+  numLevels: number,
+): Int32Array {
+  if (numLevels === 0) {
+    const levels = new Int32Array(1);
+    levels[0] = n;
+    return levels;
+  }
+  const levels = new Int32Array(numLevels);
+  let count = 0;
+  for (let i = 1; i < n; i++) {
+    if (y[ordering[i]!]! - y[ordering[i - 1]!]! > tol) levels[count++] = i;
+  }
+  return levels;
+}
+
+/**
+ * Order the nodes by `y` (computed by `computeYCoords` unless `given` is
+ * supplied) and cut a new level wherever consecutive values differ by more
+ * than `max(absTol, relTol * span / (n - 1))`. Returns `null` where C returns
+ * nonzero (`compute_y_coords` failed).
+ * @see lib/neatogen/compute_hierarchy.c:compute_hierarchy
+ */
+export function computeHierarchy(
+  graph: VtxData[],
+  n: number,
+  absTol: number,
+  relTol: number,
+  given: Float64Array | null,
+): Hierarchy | null {
+  let y: Float64Array;
+  if (given) {
+    y = given;
+  } else {
+    y = new Float64Array(n);
+    if (computeYCoords(graph, n, y, n)) return null;
+  }
+  const ordering = new Int32Array(n);
+  for (let i = 0; i < n; i++) ordering[i] = i;
+  quicksortPlace(y, ordering, n);
+
+  const hierarchySpan = y[ordering[n - 1]!]! - y[ordering[0]!]!;
+  // C `MAX(a, b)` is `a > b ? a : b` (differs from Math.max only for NaN operands)
+  const relative = relTol * hierarchySpan / (n - 1);
+  const tol = absTol > relative ? absTol : relative;
+  const numLevels = countLevels(y, ordering, n, tol);
+  return { ordering, levels: fillLevels(y, ordering, n, tol, numLevels), numLevels };
+}

package/src/layout/neato/conjgrad-mkernel.ts

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * `conjugate_gradient_mkernel` and `right_mult_with_vector_ff` as the 16.1
+ * oracle executes them. The oracle is built `-O3 -flto=thin` for arm64, so a
+ * C statement `a += b * c` on floats is one `fmadd`/`fmla` (clang's default
+ * contraction), and a reduction the vectoriser took in blocks of 16 rounds
+ * the products of those leading elements before its in-order adds (strict FP
+ * forbids reassociation) while the scalar remainder is fused. `stress-kernel.ts`
+ * keeps the unfused rounding of these loops; the constrained-majorization driver
+ * needs the oracle's bits.
+ *
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ * @see lib/neatogen/matrix_ops.c:right_mult_with_vector_ff
+ */
+
+import { agerrorf } from '../../common/agerr.js';
+import {
+  copyVectorF, maxAbsF, orthog1f, vectorsInnerProductF, vectorsSubtractionF,
+} from './matrix-ops.js';
+import { fmaf } from './quad-prog-solve.js';
+
+const fr = Math.fround;
+
+/** Width of the vectorised reduction block of `right_mult_with_vector_ff`. */
+const RIGHT_MULT_BLOCK = 16;
+
+/** The unexpected-zero-residual diagnostic. @see lib/neatogen/conjgrad.c */
+const ZERO_LENGTH_MESSAGE = 'conjugate_gradient: unexpected length 0 vector\n';
+
+/**
+ * `result = packed_matrix * vector` for the packed upper triangle of a
+ * symmetric matrix: per row the first `16*floor(len/16)` products of the
+ * reduction are rounded before their adds, the rest fused; the scatter into
+ * `result[j]` is fused throughout.
+ * @see lib/neatogen/matrix_ops.c:right_mult_with_vector_ff
+ */
+export function rightMultWithVectorFFFused(
+  m: Float32Array, n: number, vector: Float32Array, result: Float32Array,
+): void {
+  for (let i = 0; i < n; i++) result[i] = 0;
+  let index = 0;
+  for (let i = 0; i < n; i++) {
+    const vi = vector[i]!;
+    let res = fmaf(m[index++]!, vi, 0); // deal with main diag
+    const len = n - i - 1;
+    const blockEnd = i + 1 + (len - (len % RIGHT_MULT_BLOCK));
+    for (let j = i + 1; j < n; j++, index++) {
+      const mij = m[index]!;
+      res = j < blockEnd ? fr(res + fr(mij * vector[j]!)) : fmaf(mij, vector[j]!, res);
+      result[j] = fmaf(mij, vi, result[j]!);
+    }
+    result[i] = result[i]! + res;
+  }
+}
+
+/** `vector1 += alpha * vector2`, fused. @see lib/neatogen/matrix_ops.c:vectors_mult_additionf */
+function vectorsMultAdditionFused(n: number, v1: Float32Array, alpha: number, v2: Float32Array): void {
+  for (let i = 0; i < n; i++) v1[i] = fmaf(alpha, v2[i]!, v1[i]!);
+}
+
+/** Conjugate-gradient working vectors and the running `r.r`. */
+interface CgState {
+  n: number;
+  r: Float32Array;
+  p: Float32Array;
+  Ap: Float32Array;
+  rR: number;
+}
+
+/** What one conjugate-gradient iteration decided. */
+const CgStep = { CONTINUE: 0, STOP: 1, ERROR: 2 } as const;
+
+/** Options of {@link conjugateGradientMkernelFused} (C's trailing `tol`, `max_iterations`). */
+export interface CgMkernelOptions {
+  tol: number;
+  maxIterations: number;
+}
+
+/**
+ * The residual `r = b - A*x` of the centred inputs, and `p = r`.
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ */
+function initialState(A: Float32Array, x: Float32Array, b: Float32Array, n: number): CgState {
+  const Ax = new Float32Array(n);
+  const st: CgState = { n, r: new Float32Array(n), p: new Float32Array(n), Ap: new Float32Array(n), rR: 0 };
+  orthog1f(n, x); // centering x and b
+  orthog1f(n, b);
+  rightMultWithVectorFFFused(A, n, x, Ax);
+  orthog1f(n, Ax); // centering Ax
+  vectorsSubtractionF(n, b, Ax, st.r);
+  copyVectorF(n, st.r, st.p);
+  st.rR = vectorsInnerProductF(n, st.r, st.r);
+  return st;
+}
+
+/**
+ * One iteration: the step along `p`, then (unless last) the new residual and
+ * search direction.
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ */
+function cgIteration(A: Float32Array, x: Float32Array, st: CgState, last: boolean): number {
+  const { n, r, p, Ap } = st;
+  orthog1f(n, p);
+  orthog1f(n, x);
+  orthog1f(n, r);
+  rightMultWithVectorFFFused(A, n, p, Ap);
+  orthog1f(n, Ap); // centering Ap
+  const pAp = vectorsInnerProductF(n, p, Ap);
+  if (pAp === 0) return CgStep.STOP;
+  const alpha = st.rR / pAp;
+  vectorsMultAdditionFused(n, x, fr(alpha), p); // derive new x
+  if (last) return CgStep.CONTINUE;
+  vectorsMultAdditionFused(n, r, fr(-alpha), Ap);
+  const rRNew = vectorsInnerProductF(n, r, r);
+  if (st.rR === 0) {
+    agerrorf(ZERO_LENGTH_MESSAGE);
+    return CgStep.ERROR;
+  }
+  const beta = fr(rRNew / st.rR);
+  st.rR = rRNew;
+  for (let j = 0; j < n; j++) p[j] = fmaf(beta, p[j]!, r[j]!);
+  return CgStep.CONTINUE;
+}
+
+/**
+ * Solve `A*x = b` by conjugate gradients, `A` packed symmetric; `x` and `b` are
+ * centred. Returns 1 on an unexpected zero residual, else 0.
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
+ */
+export function conjugateGradientMkernelFused(
+  A: Float32Array, x: Float32Array, b: Float32Array, n: number, o: CgMkernelOptions,
+): number {
+  const st = initialState(A, x, b, n);
+  for (let i = 0; i < o.maxIterations && maxAbsF(n, st.r) > o.tol; i++) {
+    const step = cgIteration(A, x, st, i >= o.maxIterations - 1);
+    if (step === CgStep.STOP) break;
+    if (step === CgStep.ERROR) return 1;
+  }
+  return 0;
+}

package/src/layout/neato/conjgrad.ts

@@ -1,4 +1,19 @@
 // SPDX-License-Identifier: EPL-2.0
+import { agerrorf } from '../../common/agerr.js';
+import type { VtxData } from './dijkstra.js';
+import {
+  BLOCK_NONE,
+  copyVector,
+  innerProduct,
+  maxAbs,
+  orthog1,
+  rightMultWithVector,
+  rightMultWithVectorF,
+  vectorsAddition,
+  vectorsScalarMult,
+  vectorsSubtraction,
+} from './matrix-ops.js';
+
 /**
  * Conjugate gradient solvers for packed symmetric float matrices.
  * @see lib/neatogen/conjgrad.c
@@ -157,3 +172,196 @@ export function conjugateGradientMkernel(
   }
   return 0;
 }
+
+// ---------------------------------------------------------------------------
+// Double-precision solvers (conjugate_gradient, conjugate_gradient_f)
+// ---------------------------------------------------------------------------
+
+/**
+ * Unfused block widths of the 16.1 arm64 `-O3 -flto=thin` build, which inlines
+ * `vectors_inner_product` into `conjugate_gradient` and compiles each of the
+ * three call sites differently (disassembly of `libgvplugin_neato_layout`):
+ * the initial `r.r` is vectorized in blocks of 4, `p.Ap` in blocks of 8, and
+ * the in-loop `r.r` is a plain scalar loop. In a vectorized block the products
+ * are rounded before the in-order adds; the scalar loop contracts to fmadd.
+ */
+const BLOCK_INITIAL_RR = 4;
+const BLOCK_P_AP = 8;
+
+/** Working vectors of `conjugate_gradient`. @internal */
+interface CgWork {
+  r: Float64Array;
+  p: Float64Array;
+  Ap: Float64Array;
+  alphap: Float64Array;
+}
+
+/**
+ * One CG step after `x += alpha*p`: update residual and direction.
+ * Returns the new `r.r`, or null for C's `goto cleanup0` (rv = 1).
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient
+ */
+function cgNextDirection(n: number, w: CgWork, alpha: number, rR: number): number | null {
+  vectorsScalarMult(n, w.Ap, alpha, w.Ap);
+  vectorsSubtraction(n, w.r, w.Ap, w.r); // fast computation of r, the residual
+  const rRNew = innerProduct(n, w.r, w.r, BLOCK_NONE);
+  if (rR === 0) {
+    agerrorf('conjugate_gradient: unexpected length 0 vector\n');
+    return null;
+  }
+  const beta = rRNew / rR;
+  vectorsScalarMult(n, w.p, beta, w.p);
+  vectorsAddition(n, w.r, w.p, w.p);
+  return rRNew;
+}
+
+/**
+ * Residual setup of `conjugate_gradient`: `r = orth_b - A x`, `p = r`; `x` and
+ * `b` are orthogonalized against 1.
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient
+ */
+function cgStart(A: VtxData[], x: Float64Array, b: Float64Array, n: number): CgWork {
+  const w: CgWork = {
+    r: new Float64Array(n), p: new Float64Array(n),
+    Ap: new Float64Array(n), alphap: new Float64Array(n),
+  };
+  const Ax = new Float64Array(n);
+  const orthB = Float64Array.from(b.subarray(0, n));
+  orthog1(n, orthB);
+  orthog1(n, x);
+  rightMultWithVector(A, n, x, Ax);
+  vectorsSubtraction(n, orthB, Ax, w.r);
+  w.p.set(w.r.subarray(0, n));
+  return w;
+}
+
+/**
+ * Solve `A x = b` by conjugate gradients; `x` and `b` are orthogonalized
+ * against 1. Returns C's `rv` (1 on the zero-length-residual failure).
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient
+ */
+export function conjugateGradient(
+  A: VtxData[],
+  x: Float64Array,
+  b: Float64Array,
+  n: number,
+  tol: number,
+  maxIterations: number,
+): number {
+  const w = cgStart(A, x, b, n);
+  let rR = innerProduct(n, w.r, w.r, BLOCK_INITIAL_RR);
+
+  for (let i = 0; i < maxIterations && maxAbs(n, w.r) > tol; i++) {
+    rightMultWithVector(A, n, w.p, w.Ap);
+    const pAp = innerProduct(n, w.p, w.Ap, BLOCK_P_AP);
+    if (pAp === 0) break;
+    const alpha = rR / pAp;
+    vectorsScalarMult(n, w.p, alpha, w.alphap); // derive new x
+    vectorsAddition(n, x, w.alphap, x);
+    if (i < maxIterations - 1) { // not last iteration
+      const next = cgNextDirection(n, w, alpha, rR);
+      if (next === null) return 1;
+      rR = next;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Block widths of conjugate_gradient_f's inlined sites in the same build:
+ * the initial `A x` and the in-loop `A p` row reductions and the initial
+ * `r.r` are blocks of 4, `p.Ap` blocks of 8, the in-loop `r.r` scalar.
+ * Verified bit for bit against the oracle's own libneatogen.a over random
+ * float matrices (n = 5..40, ortho1 on and off).
+ */
+const CGF_BLOCK_AX = 4;
+const CGF_BLOCK_AP = 4;
+const CGF_BLOCK_INITIAL_RR = 4;
+const CGF_BLOCK_P_AP = 8;
+
+/** Work vectors of one conjugate_gradient_f call. @internal */
+interface CgfState {
+  r: Float64Array;
+  p: Float64Array;
+  Ap: Float64Array;
+  alphap: Float64Array;
+  rr: number;
+}
+
+/**
+ * Residual setup: r = orth_b - A x, p = r. `x` is centred when `ortho1`.
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_f
+ */
+function cgfInit(
+  A: readonly Float32Array[], x: Float64Array, b: Float64Array, n: number, ortho1: boolean,
+): CgfState {
+  const orthB = new Float64Array(n);
+  copyVector(n, b, orthB);
+  if (ortho1) {
+    orthog1(n, orthB);
+    orthog1(n, x);
+  }
+  const Ax = new Float64Array(n);
+  rightMultWithVectorF(A, n, x, Ax, CGF_BLOCK_AX);
+  const r = new Float64Array(n);
+  vectorsSubtraction(n, orthB, Ax, r);
+  const p = new Float64Array(n);
+  copyVector(n, r, p);
+  return {
+    r, p, Ap: new Float64Array(n), alphap: new Float64Array(n),
+    rr: innerProduct(n, r, r, CGF_BLOCK_INITIAL_RR),
+  };
+}
+
+/**
+ * Residual and direction update of a non-last iteration; returns C's `rv`
+ * (1 after reporting a zero-length residual).
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_f
+ */
+function cgfUpdate(n: number, alpha: number, st: CgfState): number {
+  vectorsScalarMult(n, st.Ap, alpha, st.Ap);
+  vectorsSubtraction(n, st.r, st.Ap, st.r);
+  const rrNew = innerProduct(n, st.r, st.r, BLOCK_NONE);
+  if (st.rr === 0) {
+    agerrorf('conjugate_gradient: unexpected length 0 vector\n');
+    return 1;
+  }
+  const beta = rrNew / st.rr;
+  st.rr = rrNew;
+  vectorsScalarMult(n, st.p, beta, st.p);
+  vectorsAddition(n, st.r, st.p, st.p);
+  return 0;
+}
+
+/** Stopping rule and centring of {@link conjugateGradientF} (C's trailing parameters). */
+export interface CgfOptions {
+  tol: number;
+  maxIterations: number;
+  ortho1: boolean;
+}
+
+/**
+ * Solves A x = b for a float** matrix with double x, b (x, b centred when
+ * `ortho1`). Returns 0, or 1 after a zero-length residual (callers test `< 0`).
+ * @see lib/neatogen/conjgrad.c:conjugate_gradient_f
+ */
+export function conjugateGradientF(
+  A: readonly Float32Array[],
+  x: Float64Array,
+  b: Float64Array,
+  n: number,
+  opts: CgfOptions,
+): number {
+  const { tol, maxIterations, ortho1 } = opts;
+  const st = cgfInit(A, x, b, n, ortho1);
+  for (let i = 0; i < maxIterations && maxAbs(n, st.r) > tol; i++) {
+    rightMultWithVectorF(A, n, st.p, st.Ap, CGF_BLOCK_AP);
+    const pAp = innerProduct(n, st.p, st.Ap, CGF_BLOCK_P_AP);
+    if (pAp === 0) break;
+    const alpha = st.rr / pAp;
+    vectorsScalarMult(n, st.p, alpha, st.alphap);
+    vectorsAddition(n, x, st.alphap, x);
+    if (i < maxIterations - 1 && cgfUpdate(n, alpha, st) === 1) return 1;
+  }
+  return 0;
+}