archaeopteryx 3.5.0 → 3.5.1

package/README.md

@@ -296,8 +296,11 @@ so every branch and position is scored by how far the tip pairs' ancestors
 fall from that halfway point, and the root goes where that deviation is
 smallest [1]. It has been compared with other rooting methods on prokaryotic
 gene families [2]. It needs branch lengths and at least three tips, and is
-offered only then. The algorithm is the desktop Archaeopteryx's, and gives
-the same roots; it runs in O(n²) time and O(n) memory (the 13,246-tip H5N1
+offered only then. Tip pairs closer than 1/100,000 of the tree's diameter
+(identical sequences, or FastTree's 5 × 10⁻⁹ stand-in for a zero branch) are
+left out of the deviation sums: their deviation measures noise, and summing
+it would swamp the precision of all the others. The algorithm is the desktop
+Archaeopteryx's, and gives the same roots; it runs in O(n²) time and O(n) memory (the 13,246-tip H5N1
 demo tree roots in 0.4 s, measured in Node).
 
 Every internal branch then carries its **MAD value**: the root-mean-square

package/archaeopteryx.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.5.0
+// v 3.5.1
 // 2026-09-10
 //
 // Archaeopteryx.js is a software tool for the visualization and
@@ -103,7 +103,7 @@ function (root, d3, forester, phyloXml) {
     // IIFE's own function name -- a plain object says what it is.)
     let archaeopteryx = {};
 
-    const VERSION = '3.5.0';
+    const VERSION = '3.5.1';
     const WEBSITE = 'https://cmzmasek.github.io/archaeopteryx-js/';
     const DESKTOP_WEBSITE = 'https://cmzmasek.github.io/archaeopteryx/';
     const SOURCE_WEBSITE = 'https://github.com/cmzmasek/archaeopteryx-js';

package/forester.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.5.0
+// v 3.5.1
 // 2026-09-10
 //
 // forester.js is a general suite for dealing with phylogenetic trees.
@@ -455,6 +455,14 @@
     forester.MAD_CONFIDENCE_TYPE = 'MAD';
 
     const MAD_EPSILON = 1e-9;
+    // Tip pairs closer than this share of the tree's diameter are left out of
+    // every sum, like pairs at distance 0. Their 1/d^2 terms (tips 1e-8 apart,
+    // as FastTree's 5e-9 "zero" branches make them, reach 1e16) cancel
+    // catastrophically in the subtractions below and swamp every other pair:
+    // MAD then answered differently from every rooting, and re-rooting moved
+    // the root back and forth. The diameter does not depend on the rooting, so
+    // neither does the cut. Joint with the desktop (Christian, 2026-09-14).
+    const MAD_NEAR_FRACTION = 1e-5;
 
     /**
      * Roots the tree by Minimal Ancestor Deviation (Tria, Landan & Dagan,
@@ -472,6 +480,11 @@
      * and the root's branch carries the smallest. Pendant branches get none,
      * and MAD values from an earlier run are replaced.
      *
+     * Tip pairs closer than 1e-5 of the tree's diameter (identical sequences,
+     * FastTree's 5e-9 "zero" branches) are left out of the deviation sums:
+     * their deviation measures noise, and their terms would swamp the
+     * precision of all the others.
+     *
      * A no-op for fewer than three tips or a tree without branch lengths.
      * O(n^2) time and O(n) memory: the desktop fills an n x n distance matrix
      * only to sum its columns (1.4 GB at 13,000 tips), so the column sums are
@@ -513,6 +526,27 @@
         if (maxDepth <= 0) {
             return false;   // no usable branch lengths
         }
+        // the diameter, the longest tip-to-tip path: at every node, its two
+        // longest paths down through different children
+        let longestDown = new Float64Array(m);
+        let diameter = 0;
+        for (let q = 0; q < m; ++q) {
+            let k = post[q];
+            let first = 0;
+            let second = 0;
+            for (let c = 0; c < kids[k].length; ++c) {
+                let path = longestDown[kids[k][c]] + madLength(pre[kids[k][c]]);
+                if (path > first) {
+                    second = first;
+                    first = path;
+                } else if (path > second) {
+                    second = path;
+                }
+            }
+            longestDown[k] = first;
+            diameter = Math.max(diameter, first + second);
+        }
+        let nearEps = Math.max(MAD_EPSILON, MAD_NEAR_FRACTION * diameter);
         let tipDepth = new Float64Array(n);
         for (let i = 0; i < n; ++i) {
             tipDepth[i] = depth[tipPos[i]];
@@ -529,7 +563,7 @@
         let w2 = new Float64Array(m);      // sum_{i!=j in subtree} (2*depth[j]/d - 1)^2   (j second)
         let col0 = new Float64Array(n);
         let colInv = new Float64Array(n);
-        let partners = new Int32Array(n);   // the tips each tip is apart from (d > MAD_EPSILON)
+        let partners = new Int32Array(n);   // the tips each tip is counted against (d > nearEps)
         for (let q = 0; q < m; ++q) {
             let k = post[q];
             let ch = kids[k];
@@ -554,7 +588,7 @@
                         for (let j = lo[ch[b]]; j < hi[ch[b]]; ++j) {
                             let dj = tipDepth[j];
                             let dij = (di - dm) + (dj - dm);
-                            if (dij > MAD_EPSILON) {
+                            if (dij > nearEps) {
                                 let inv = 1.0 / dij;
                                 let inv2 = inv * inv;
                                 let dev = (2.0 * (di - dm) * inv) - 1.0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archaeopteryx",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "description": "Archaeopteryx.js is a software tool for the visualization and analysis of highly annotated phylogenetic trees.",
   "main": "archaeopteryx.js",
   "types": "archaeopteryx.d.ts",