npm - @graphty/layout - Versions diffs - 1.1.1 → 1.2.1 - Mend

@graphty/layout 1.1.1 → 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (100) hide show

package/.env.example +11 -0
package/.github/workflows/ci.yml +3 -7
package/CHANGELOG.md +14 -0
package/DEPLOYMENT.md +59 -0
package/README.md +54 -1
package/dist/vitest.config.js +2 -2
package/dist/vitest.config.js.map +1 -1
package/examples/3d-force-directed.html +611 -0
package/examples/3d-kamada-kawai.html +379 -0
package/examples/3d-layout-comparison.html +448 -0
package/examples/3d-spherical-layout.html +319 -0
package/examples/arf-layout.html +13 -1
package/examples/bfs-layout.html +38 -32
package/examples/bipartite-layout.html +16 -4
package/examples/circular-layout.html +14 -2
package/examples/forceatlas2-layout.html +118 -151
package/examples/index.html +75 -0
package/examples/kamada-kawai-layout.html +13 -1
package/{dist → examples}/layout-helpers.js +58 -29
package/examples/multipartite-layout.html +44 -54
package/examples/planar-layout.html +13 -1
package/examples/random-layout.html +13 -1
package/examples/shell-layout.html +16 -2
package/examples/spectral-layout.html +13 -1
package/examples/spiral-layout.html +13 -1
package/examples/spring-layout.html +15 -13
package/package.json +6 -3
package/src/algorithms/index.ts +6 -0
package/src/algorithms/optimization/index.ts +12 -0
package/src/algorithms/optimization/kamada-kawai-solver.ts +231 -0
package/src/algorithms/optimization/lbfgs.ts +68 -0
package/src/algorithms/optimization/line-search.ts +50 -0
package/src/algorithms/optimization/types.ts +8 -0
package/src/algorithms/planarity/check.ts +38 -0
package/src/algorithms/planarity/embedding.ts +216 -0
package/src/algorithms/planarity/index.ts +12 -0
package/src/algorithms/planarity/lr-test.ts +70 -0
package/src/algorithms/planarity/special-graphs.ts +126 -0
package/src/generators/basic.ts +93 -0
package/src/generators/bipartite.ts +45 -0
package/src/generators/grid.ts +42 -0
package/src/generators/index.ts +15 -0
package/src/generators/random.ts +39 -0
package/src/generators/scale-free.ts +72 -0
package/src/index.ts +18 -0
package/src/layouts/basic/index.ts +5 -0
package/src/layouts/basic/random.ts +32 -0
package/src/layouts/force-directed/arf.ts +130 -0
package/src/layouts/force-directed/forceatlas2.ts +407 -0
package/src/layouts/force-directed/fruchterman-reingold.ts +164 -0
package/src/layouts/force-directed/index.ts +9 -0
package/src/layouts/force-directed/kamada-kawai.ts +112 -0
package/src/layouts/force-directed/spring.ts +35 -0
package/src/layouts/geometric/circular.ts +77 -0
package/src/layouts/geometric/index.ts +7 -0
package/src/layouts/geometric/shell.ts +80 -0
package/src/layouts/geometric/spiral.ts +93 -0
package/src/layouts/hierarchical/bfs.ts +81 -0
package/src/layouts/hierarchical/bipartite.ts +94 -0
package/src/layouts/hierarchical/index.ts +7 -0
package/src/layouts/hierarchical/multipartite.ts +88 -0
package/src/layouts/index.ts +9 -0
package/src/layouts/specialized/index.ts +6 -0
package/src/layouts/specialized/planar.ts +65 -0
package/src/layouts/specialized/spectral.ts +128 -0
package/src/types/embedding.ts +11 -0
package/src/types/graph.ts +13 -0
package/src/types/index.ts +7 -0
package/src/types/layout.ts +9 -0
package/src/utils/graph.ts +77 -0
package/src/utils/index.ts +9 -0
package/src/utils/numpy.ts +108 -0
package/src/utils/params.ts +26 -0
package/src/utils/random.ts +53 -0
package/src/utils/rescale.ts +137 -0
package/test/arf-layout.test.ts +1 -1
package/test/bfs-layout.test.ts +1 -1
package/test/bipartite-layout.test.ts +1 -1
package/test/circular-layout.test.ts +145 -3
package/test/forceatlas2-layout.test.ts +1 -1
package/test/fruchterman-reingold-layout.test.ts +1 -1
package/test/graph-generators.test.ts +1 -1
package/test/kamada-kawai-layout.test.ts +273 -1
package/test/multipartite-layout.test.ts +1 -1
package/test/planar-layout.test.ts +1 -1
package/test/random-layout.test.ts +1 -1
package/test/rescale-layout.test.ts +1 -1
package/test/shell-layout.test.ts +1 -1
package/test/spectral-layout.test.ts +1 -1
package/test/spiral-layout.test.ts +1 -1
package/test/spring-layout.test.ts +1 -1
package/vite.config.js +36 -0
package/vitest.config.ts +2 -2
package/dist/layout-helpers.d.ts +0 -123
package/dist/layout-helpers.js.map +0 -1
package/dist/layout.d.ts +0 -275
package/dist/layout.js +0 -2280
package/dist/layout.js.map +0 -1
package/layout-helpers.ts +0 -559
package/layout.ts +0 -2867

package/examples/multipartite-layout.html CHANGED Viewed

@@ -1,6 +1,18 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+  <!-- Eruda Mobile Console -->
+  <script src="https://cdn.jsdelivr.net/npm/eruda@3/eruda.min.js"></script>
+  <script>
+    // Initialize Eruda console for mobile debugging
+    if (typeof eruda !== "undefined") {
+      eruda.init();
+      // Auto-show on mobile devices
+      if (/mobile|android|ios|iphone|ipad|ipod/i.test(navigator.userAgent.toLowerCase())) {
+        eruda.show();
+      }
+    }
+  </script>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Multipartite Layout Test</title>
@@ -159,10 +171,13 @@
             multipartiteLayout,
             scaleFreeGraph,
             starGraph,
-            randomGraph,
+            randomGraph
+        } from "./layout.js";
+        import {
             groupNodes,
             findBestRoot
-        } from '../dist/layout.js';
+        } from "./layout-helpers.js";
         let currentGraph = null;
         let currentLayers = null;
@@ -209,46 +224,6 @@
                     return { nodes: () => nodes, edges: () => edges };
             }
         }
-                    break;
-                case 'hierarchical':
-                    // Hierarchical connections (each node connects to nodes in the next layer)
-                    for (let layer = 0; layer < numLayers - 1; layer++) {
-                        const currentLayer = layers[layer];
-                        const nextLayer = layers[layer + 1];
-                        currentLayer.forEach((node1, idx) => {
-                            // Connect to 1-2 nodes in the next layer
-                            const connections = Math.min(2, nextLayer.length);
-                            for (let c = 0; c < connections; c++) {
-                                const targetIdx = (idx + c) % nextLayer.length;
-                                edges.push([node1, nextLayer[targetIdx]]);
-                            }
-                        });
-                    }
-                    break;
-                case 'complete':
-                    // Each layer is fully connected to the next
-                    for (let layer = 0; layer < numLayers - 1; layer++) {
-                        const currentLayer = layers[layer];
-                        const nextLayer = layers[layer + 1];
-                        currentLayer.forEach(node1 => {
-                            nextLayer.forEach(node2 => {
-                                edges.push([node1, node2]);
-                            });
-                        });
-                    }
-                    break;
-            }
-            return {
-                nodes: () => allNodes,
-                edges: () => edges,
-                layers
-            };
-        }
         function visualizeGraph(graph, positions) {
             const svg = document.getElementById('graph-svg');
@@ -335,11 +310,13 @@
                 // Determine color based on layer
                 let nodeColor = '#666';
-                Object.entries(graph.layers).forEach(([layerIdx, layerNodes]) => {
-                    if (layerNodes.includes(node)) {
-                        nodeColor = layerColors[layerIdx % layerColors.length];
-                    }
-                });
+                if (currentLayers) {
+                    currentLayers.forEach((layerNodes, layerIdx) => {
+                        if (layerNodes.includes(node)) {
+                            nodeColor = layerColors[layerIdx % layerColors.length];
+                        }
+                    });
+                }
                 const circle = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
                 circle.setAttribute('cx', x);
@@ -356,7 +333,7 @@
                 text.setAttribute('text-anchor', 'middle');
                 text.setAttribute('font-size', '9');
                 text.setAttribute('fill', 'white');
-                text.textContent = node.replace(/L\d+N/, '');
+                text.textContent = String(node).replace(/L\d+N/, '') || String(node);
                 svg.appendChild(text);
             });
         }
@@ -364,9 +341,9 @@
         window.newGraph = function() {
             const numLayers = parseInt(document.getElementById('num-layers').value);
             const nodesPerLayer = parseInt(document.getElementById('nodes-per-layer').value);
-            const edgeType = document.getElementById('edge-type').value;
+            const graphType = document.getElementById('graph-type').value;
-            currentGraph = generateMultipartiteGraph(numLayers, nodesPerLayer, edgeType);
+            currentGraph = generateGraph(graphType, numLayers, nodesPerLayer);
             // Just visualize with random positions initially
             const positions = {};
@@ -377,13 +354,26 @@
                 ];
             });
+            // Generate layers for multipartite layout
+            const layerMethod = document.getElementById('layer-method').value;
+            if (layerMethod === 'bfs') {
+                const root = findBestRoot(currentGraph);
+                currentLayers = groupNodes(currentGraph, 'bfs', 0, { root });
+            } else if (layerMethod === 'degree') {
+                currentLayers = groupNodes(currentGraph, 'degree', numLayers);
+            } else {
+                // community-based
+                currentLayers = groupNodes(currentGraph, 'community', numLayers);
+            }
             visualizeGraph(currentGraph, positions);
             // Update layer info
             const infoDiv = document.getElementById('layers-info');
-            const layerInfo = Object.entries(currentGraph.layers).map(([idx, nodes]) =>
+            const layerInfo = currentLayers ? currentLayers.map((nodes, idx) =>
                 `Layer ${idx}: ${nodes.length} nodes`
-            ).join('<br>');
+            ).join('<br>') : 'No layers generated';
             infoDiv.innerHTML = `
                 <strong>Structure:</strong><br>
@@ -393,11 +383,11 @@
         };
         window.applyLayout = function() {
-            if(!currentGraph) return;
+            if(!currentGraph || !currentLayers) return;
             const alignment = document.getElementById('alignment').value;
-            const positions = multipartiteLayout(currentGraph, currentGraph.layers, alignment, 1, [0, 0]);
+            const positions = multipartiteLayout(currentGraph, currentLayers, alignment, 1, [0, 0]);
             visualizeGraph(currentGraph, positions);
         };

package/examples/planar-layout.html CHANGED Viewed

@@ -1,6 +1,18 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+  <!-- Eruda Mobile Console -->
+  <script src="https://cdn.jsdelivr.net/npm/eruda@3/eruda.min.js"></script>
+  <script>
+    // Initialize Eruda console for mobile debugging
+    if (typeof eruda !== "undefined") {
+      eruda.init();
+      // Auto-show on mobile devices
+      if (/mobile|android|ios|iphone|ipad|ipod/i.test(navigator.userAgent.toLowerCase())) {
+        eruda.show();
+      }
+    }
+  </script>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Planar Layout Test</title>
@@ -161,7 +173,7 @@
     </div>
     <script type="module">
-        import { planarLayout } from '../dist/layout.js';
+        import { planarLayout } from "./layout.js";
         let currentGraph = null;

package/examples/random-layout.html CHANGED Viewed

@@ -1,6 +1,18 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+  <!-- Eruda Mobile Console -->
+  <script src="https://cdn.jsdelivr.net/npm/eruda@3/eruda.min.js"></script>
+  <script>
+    // Initialize Eruda console for mobile debugging
+    if (typeof eruda !== "undefined") {
+      eruda.init();
+      // Auto-show on mobile devices
+      if (/mobile|android|ios|iphone|ipad|ipod/i.test(navigator.userAgent.toLowerCase())) {
+        eruda.show();
+      }
+    }
+  </script>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Random Layout Test</title>
@@ -142,7 +154,7 @@
     </div>
     <script type="module">
-        import { randomLayout } from '../dist/layout.js';
+        import { randomLayout } from "./layout.js";
         let currentGraph = null;

package/examples/shell-layout.html CHANGED Viewed

@@ -1,6 +1,18 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+  <!-- Eruda Mobile Console -->
+  <script src="https://cdn.jsdelivr.net/npm/eruda@3/eruda.min.js"></script>
+  <script>
+    // Initialize Eruda console for mobile debugging
+    if (typeof eruda !== "undefined") {
+      eruda.init();
+      // Auto-show on mobile devices
+      if (/mobile|android|ios|iphone|ipad|ipod/i.test(navigator.userAgent.toLowerCase())) {
+        eruda.show();
+      }
+    }
+  </script>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Shell Layout Test</title>
@@ -134,10 +146,12 @@
         import {
             shellLayout,
             scaleFreeGraph,
-            randomGraph,
+            randomGraph
+        } from "./layout.js";
+        import {
             groupNodes,
             findBestRoot
-        } from '../dist/layout.js';
+        } from "./layout-helpers.js";
         let currentGraph = null;

package/examples/spectral-layout.html CHANGED Viewed

@@ -1,6 +1,18 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+  <!-- Eruda Mobile Console -->
+  <script src="https://cdn.jsdelivr.net/npm/eruda@3/eruda.min.js"></script>
+  <script>
+    // Initialize Eruda console for mobile debugging
+    if (typeof eruda !== "undefined") {
+      eruda.init();
+      // Auto-show on mobile devices
+      if (/mobile|android|ios|iphone|ipad|ipod/i.test(navigator.userAgent.toLowerCase())) {
+        eruda.show();
+      }
+    }
+  </script>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Spectral Layout Test</title>
@@ -135,7 +147,7 @@
     </div>
     <script type="module">
-        import { spectralLayout } from '../dist/layout.js';
+        import { spectralLayout } from "./layout.js";
         let currentGraph = null;

package/examples/spiral-layout.html CHANGED Viewed

@@ -1,6 +1,18 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+  <!-- Eruda Mobile Console -->
+  <script src="https://cdn.jsdelivr.net/npm/eruda@3/eruda.min.js"></script>
+  <script>
+    // Initialize Eruda console for mobile debugging
+    if (typeof eruda !== "undefined") {
+      eruda.init();
+      // Auto-show on mobile devices
+      if (/mobile|android|ios|iphone|ipad|ipod/i.test(navigator.userAgent.toLowerCase())) {
+        eruda.show();
+      }
+    }
+  </script>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Spiral Layout Test</title>
@@ -171,7 +183,7 @@
     </div>
     <script type="module">
-        import { spiralLayout } from '../dist/layout.js';
+        import { spiralLayout } from "./layout.js";
         let currentGraph = null;

package/examples/spring-layout.html CHANGED Viewed

@@ -1,6 +1,18 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+  <!-- Eruda Mobile Console -->
+  <script src="https://cdn.jsdelivr.net/npm/eruda@3/eruda.min.js"></script>
+  <script>
+    // Initialize Eruda console for mobile debugging
+    if (typeof eruda !== "undefined") {
+      eruda.init();
+      // Auto-show on mobile devices
+      if (/mobile|android|ios|iphone|ipad|ipod/i.test(navigator.userAgent.toLowerCase())) {
+        eruda.show();
+      }
+    }
+  </script>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Spring Layout Test</title>
@@ -141,7 +153,7 @@
     </div>
     <script type="module">
-        import { springLayout } from '../dist/layout.js';
+        import { springLayout } from "./layout.js";
         let currentGraph = null;
@@ -274,17 +286,7 @@
             if(!currentGraph) return;
             const iterations = parseInt(document.getElementById('iterations').value);
-            const autoConfig = document.getElementById('auto-config').checked;
-            let k;
-            if (autoConfig && currentConfig) {
-                k = currentConfig.k;
-                // Update slider to show auto-configured value
-                document.getElementById('k-value').value = k;
-                document.getElementById('k-value-value').textContent = k.toFixed(2);
-            } else {
-                k = parseFloat(document.getElementById('k-value').value);
-            }
+            const k = parseFloat(document.getElementById('k-value').value);
             const positions = springLayout(currentGraph, k, null, null, iterations, 1, [0, 0], 2);
@@ -308,4 +310,4 @@
         newGraph();
     </script>
 </body>
-</html>
+</html>

package/package.json CHANGED Viewed

@@ -1,8 +1,8 @@
 {
   "name": "@graphty/layout",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "graph layout algorithms based on networkx",
-  "main": "dist/layout.js",
+  "main": "dist/src/index.js",
   "type": "module",
   "directories": {
     "example": "examples"
@@ -14,9 +14,12 @@
     "test:coverage": "vitest run --coverage",
     "prepare": "husky",
     "build": "tsc",
+    "build:examples": "npm run build && node build-examples-script.js",
     "watch": "tsc --watch",
     "dev": "tsc --watch",
-    "commit": "cz"
+    "commit": "cz",
+    "serve": "npm run build:examples && vite",
+    "examples": "npm run build:examples && vite"
   },
   "repository": {
     "type": "git",

package/src/algorithms/index.ts ADDED Viewed

@@ -0,0 +1,6 @@
+/**
+ * Re-export all algorithm utilities
+ */
+export * from './planarity';
+export * from './optimization';

package/src/algorithms/optimization/index.ts ADDED Viewed

@@ -0,0 +1,12 @@
+/**
+ * Re-export all optimization algorithms
+ */
+export type { DistanceMap } from './types';
+export {
+  _computeShortestPathDistances,
+  _kamadaKawaiSolve,
+  _kamadaKawaiCostfn
+} from './kamada-kawai-solver';
+export { _lbfgsDirection } from './lbfgs';
+export { _backtrackingLineSearch } from './line-search';

package/src/algorithms/optimization/kamada-kawai-solver.ts ADDED Viewed

@@ -0,0 +1,231 @@
+/**
+ * Kamada-Kawai layout algorithm optimization functions
+ */
+import { Graph, Node, Edge } from '../../types';
+import { DistanceMap } from './types';
+import { _lbfgsDirection } from './lbfgs';
+import { _backtrackingLineSearch } from './line-search';
+import { getNodesFromGraph, getEdgesFromGraph } from '../../utils/graph';
+/**
+ * Compute all-pairs shortest path distances for the graph
+ *
+ * @param G - NetworkX graph
+ * @param weight - Edge attribute for weight
+ * @returns Dictionary of dictionaries of shortest path distances
+ */
+export function _computeShortestPathDistances(
+  G: Graph,
+  weight: string
+): DistanceMap {
+  const distances: DistanceMap = {};
+  const nodes = getNodesFromGraph(G);
+  const edges = getEdgesFromGraph(G);
+  // Initialize distances with direct edges
+  for (const node of nodes) {
+    distances[node] = {};
+    distances[node][node] = 0;
+    for (const other of nodes) {
+      if (node !== other) {
+        distances[node][other] = Infinity;
+      }
+    }
+  }
+  // Add direct edges
+  for (const [source, target] of edges) {
+    // In a real implementation, we would get the weight from the graph
+    // For now, assume weight = 1 or use weight attribute if available
+    let edgeWeight = 1;
+    if (G.getEdgeData) {
+      edgeWeight = G.getEdgeData(source, target, weight) || 1;
+    }
+    distances[source][target] = edgeWeight;
+    distances[target][source] = edgeWeight;  // Assuming undirected graph
+  }
+  // Floyd-Warshall algorithm for all-pairs shortest paths
+  for (const k of nodes) {
+    for (const i of nodes) {
+      for (const j of nodes) {
+        if (distances[i][k] + distances[k][j] < distances[i][j]) {
+          distances[i][j] = distances[i][k] + distances[k][j];
+        }
+      }
+    }
+  }
+  return distances;
+}
+/**
+ * Solve the Kamada-Kawai layout optimization problem
+ *
+ * @param distMatrix - Matrix of desired distances between nodes
+ * @param positions - Initial node positions
+ * @param dim - Dimension of layout
+ * @returns Optimized node positions
+ */
+export function _kamadaKawaiSolve(
+  distMatrix: number[][],
+  positions: number[][],
+  dim: number
+): number[][] {
+  // Implementation of L-BFGS optimization for Kamada-Kawai
+  const nNodes = positions.length;
+  const meanWeight = 1e-3;
+  // Convert distances to inverse distances (with protection against division by zero)
+  const invDistMatrix = distMatrix.map(row =>
+    row.map(d => d === 0 ? 0 : 1 / (d + 1e-3))
+  );
+  // Flatten positions for optimization
+  let posVec = positions.flat();
+  // Optimization parameters
+  const maxIter = 500;
+  const gtol = 1e-5;
+  const m = 10;  // L-BFGS memory size
+  // Implement a simplified L-BFGS-B algorithm
+  let alpha = 1.0;
+  const oldValues: number[][] = [];
+  const oldGrads: number[][] = [];
+  for (let iter = 0; iter < maxIter; iter++) {
+    // Calculate cost and gradient
+    const [cost, grad] = _kamadaKawaiCostfn(posVec, invDistMatrix, meanWeight, dim);
+    // Compute search direction using L-BFGS approximation
+    const direction = _lbfgsDirection(grad, oldValues, oldGrads, m);
+    // Simple line search for step size
+    alpha = _backtrackingLineSearch(
+      posVec, direction, cost, grad,
+      (x: number[]) => _kamadaKawaiCostfn(x, invDistMatrix, meanWeight, dim)[0],
+      alpha
+    );
+    // Save current position and gradient for next iteration
+    const oldPos = [...posVec];
+    // Update position
+    for (let i = 0; i < posVec.length; i++) {
+      posVec[i] += alpha * direction[i];
+    }
+    // Calculate new gradient
+    const [, newGrad] = _kamadaKawaiCostfn(posVec, invDistMatrix, meanWeight, dim);
+    // Update L-BFGS memory
+    oldValues.push(posVec.map((val, i) => val - oldPos[i]));
+    oldGrads.push(newGrad.map((val, i) => val - grad[i]));
+    // Keep only m most recent updates
+    if (oldValues.length > m) {
+      oldValues.shift();
+      oldGrads.shift();
+    }
+    // Check convergence
+    const gradNorm = Math.sqrt(newGrad.reduce((sum, g) => sum + g * g, 0));
+    if (gradNorm < gtol) {
+      break;
+    }
+  }
+  // Reshape result back into positions array
+  const result: number[][] = [];
+  for (let i = 0; i < nNodes; i++) {
+    result.push(posVec.slice(i * dim, (i + 1) * dim));
+  }
+  return result;
+}
+/**
+ * Cost function and gradient for Kamada-Kawai layout algorithm
+ *
+ * @param posVec - Flattened position array
+ * @param invDist - Inverse distance matrix
+ * @param meanWeight - Weight for centering positions
+ * @param dim - Dimension of layout
+ * @returns Array with [cost, gradient]
+ */
+export function _kamadaKawaiCostfn(
+  posVec: number[],
+  invDist: number[][],
+  meanWeight: number,
+  dim: number
+): [number, number[]] {
+  const nNodes = invDist.length;
+  const positions: number[][] = [];
+  // Reshape flat vector into positions array
+  for (let i = 0; i < nNodes; i++) {
+    positions.push(posVec.slice(i * dim, (i + 1) * dim));
+  }
+  // Calculate cost
+  let cost = 0;
+  // Add mean position penalty term
+  const sumPos = Array(dim).fill(0);
+  for (let i = 0; i < nNodes; i++) {
+    for (let d = 0; d < dim; d++) {
+      sumPos[d] += positions[i][d];
+    }
+  }
+  cost += 0.5 * meanWeight * sumPos.reduce((sum, val) => sum + val * val, 0);
+  // Add distance penalty terms
+  for (let i = 0; i < nNodes; i++) {
+    for (let j = i + 1; j < nNodes; j++) {
+      // Calculate actual distance
+      const diff = positions[i].map((val, d) => val - positions[j][d]);
+      const distance = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0));
+      // Add penalty for difference between actual and ideal distance
+      const idealInvDist = invDist[i][j];
+      const offset = distance * idealInvDist - 1.0;
+      cost += 0.5 * offset * offset;
+    }
+  }
+  // Calculate gradient
+  const grad = new Array(posVec.length).fill(0);
+  // Add gradient of mean position penalty
+  for (let i = 0; i < nNodes; i++) {
+    for (let d = 0; d < dim; d++) {
+      grad[i * dim + d] += meanWeight * sumPos[d];
+    }
+  }
+  // Add gradient of distance penalties
+  for (let i = 0; i < nNodes; i++) {
+    for (let j = i + 1; j < nNodes; j++) {
+      // Calculate actual distance and direction
+      const diff = positions[i].map((val, d) => val - positions[j][d]);
+      const distance = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0)) || 1e-10;
+      const direction = diff.map(d => d / distance);
+      // Calculate contribution to gradient
+      const idealInvDist = invDist[i][j];
+      const offset = distance * idealInvDist - 1.0;
+      for (let d = 0; d < dim; d++) {
+        const force = idealInvDist * offset * direction[d];
+        grad[i * dim + d] += force;
+        grad[j * dim + d] -= force;
+      }
+    }
+  }
+  return [cost, grad];
+}