@graphty/layout 1.2.0 → 1.2.2

package/examples/multipartite-layout.html

@@ -171,10 +171,13 @@
             multipartiteLayout,
             scaleFreeGraph,
             starGraph,
-            randomGraph,
+            randomGraph
+        } from "./layout.js";
+        
+        import { 
             groupNodes,
             findBestRoot
-        } from "./layout.js";
+        } from "./layout-helpers.js";
         
         let currentGraph = null;
         let currentLayers = null;
@@ -307,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);
@@ -328,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);
             });
         }
@@ -336,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 = {};
@@ -349,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>
@@ -365,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/shell-layout.html

@@ -146,10 +146,12 @@
         import { 
             shellLayout, 
             scaleFreeGraph,
-            randomGraph,
+            randomGraph
+        } from "./layout.js";
+        import {
             groupNodes,
             findBestRoot
-        } from "./layout.js";
+        } from "./layout-helpers.js";
         
         let currentGraph = null;
         

package/examples/spring-layout.html

@@ -286,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);
             

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@graphty/layout",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "graph layout algorithms based on networkx",
-  "main": "dist/layout.js",
+  "main": "dist/src/index.js",
   "type": "module",
   "directories": {
     "example": "examples"
@@ -14,7 +14,7 @@
     "test:coverage": "vitest run --coverage",
     "prepare": "husky",
     "build": "tsc",
-    "build:examples": "npm run build && cp dist/layout.js examples/layout.js",
+    "build:examples": "npm run build && node build-examples-script.js",
     "watch": "tsc --watch",
     "dev": "tsc --watch",
     "commit": "cz",

package/src/algorithms/index.ts

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

package/src/algorithms/optimization/index.ts

@@ -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

@@ -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];
+}

package/src/algorithms/optimization/lbfgs.ts

@@ -0,0 +1,68 @@
+/**
+ * L-BFGS optimization utilities
+ */
+
+/**
+ * Compute the search direction using L-BFGS approximation
+ * 
+ * @param grad - Current gradient
+ * @param sList - List of position differences (s_k)
+ * @param yList - List of gradient differences (y_k)
+ * @param m - Memory size
+ * @returns Direction vector
+ */
+export function _lbfgsDirection(
+  grad: number[],
+  sList: number[][],
+  yList: number[][],
+  m: number
+): number[] {
+  if (sList.length === 0) {
+    // First iteration - use negative gradient
+    return grad.map(g => -g);
+  }
+
+  const q = grad.slice();
+  const alpha = Array(sList.length).fill(0);
+  const rho: number[] = [];
+
+  // Compute rho values
+  for (let i = 0; i < sList.length; i++) {
+    const s = sList[i];
+    const y = yList[i];
+    rho.push(1 / y.reduce((sum, val, j) => sum + val * s[j], 0));
+  }
+
+  // Forward pass
+  for (let i = sList.length - 1; i >= 0; i--) {
+    const s = sList[i];
+    alpha[i] = rho[i] * s.reduce((sum, val, j) => sum + val * q[j], 0);
+    for (let j = 0; j < q.length; j++) {
+      q[j] -= alpha[i] * yList[i][j];
+    }
+  }
+
+  // Scale initial Hessian approximation
+  let gamma = 1;
+  if (sList.length > 0 && yList.length > 0) {
+    const y = yList[yList.length - 1];
+    const s = sList[sList.length - 1];
+    gamma = s.reduce((sum, val, i) => sum + val * y[i], 0) /
+      y.reduce((sum, val) => sum + val * val, 0);
+  }
+
+  // Initialize direction with scaled negative gradient
+  const direction = q.map(val => -gamma * val);
+
+  // Backward pass
+  for (let i = 0; i < sList.length; i++) {
+    const s = sList[i];
+    const y = yList[i];
+    const beta = rho[i] * y.reduce((sum, val, j) => sum + val * direction[j], 0);
+    for (let j = 0; j < direction.length; j++) {
+      direction[j] += s[j] * (alpha[i] - beta);
+    }
+  }
+
+  return direction;
+}

package/src/algorithms/optimization/line-search.ts

@@ -0,0 +1,50 @@
+/**
+ * Line search optimization utilities
+ */
+
+/**
+ * Backtracking line search to find step size
+ * 
+ * @param x - Current position
+ * @param direction - Search direction
+ * @param f - Function value at current position
+ * @param grad - Gradient at current position
+ * @param func - Function to evaluate cost
+ * @param alpha0 - Initial step size
+ * @returns Optimal step size
+ */
+export function _backtrackingLineSearch(
+  x: number[],
+  direction: number[],
+  f: number,
+  grad: number[],
+  func: (x: number[]) => number,
+  alpha0: number
+): number {
+  const c1 = 1e-4;
+  const c2 = 0.9;
+  const initialSlope = grad.reduce((sum, g, i) => sum + g * direction[i], 0);
+
+  if (initialSlope >= 0) {
+    return 1e-8;  // Direction is not a descent direction
+  }
+
+  let alpha = alpha0;
+  const maxIter = 20;
+
+  for (let i = 0; i < maxIter; i++) {
+    // Try step
+    const newX = x.map((val, i) => val + alpha * direction[i]);
+    const newF = func(newX);
+
+    // Check sufficient decrease condition (Armijo condition)
+    if (newF <= f + c1 * alpha * initialSlope) {
+      return alpha;
+    }
+
+    // Reduce step size
+    alpha *= c2;
+  }
+
+  return alpha;  // Return last alpha even if not optimal
+}

package/src/algorithms/optimization/types.ts

@@ -0,0 +1,8 @@
+/**
+ * Type definitions for optimization algorithms
+ */
+
+import { Node } from '../../types';
+
+// Type definitions for distance structure used in Kamada-Kawai
+export type DistanceMap = Record<Node, Record<Node, number>>;

package/src/algorithms/planarity/check.ts

@@ -0,0 +1,38 @@
+/**
+ * Main planarity checking function
+ */
+
+import { Graph, Node, Edge, Embedding } from '../../types';
+import { isK5, isK33 } from './special-graphs';
+import { lrPlanarityTest } from './lr-test';
+import { createTriangulationEmbedding } from './embedding';
+
+/**
+ * Check if graph is planar using a simplified version of Boyer-Myrvold algorithm.
+ * Returns planarity and embedding information.
+ * 
+ * @param G - Graph
+ * @param nodes - List of nodes
+ * @param edges - List of edges
+ * @returns Object containing isPlanar flag and embedding
+ */
+export function checkPlanarity(
+  G: Graph,
+  nodes: Node[],
+  edges: Edge[]
+): { isPlanar: boolean; embedding: Embedding | null } {
+  // For small graphs (n <= 4), all are planar
+  if (nodes.length <= 4) {
+    return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges) };
+  }
+
+  // For K5 (complete graph with 5 nodes) and K3,3 (complete bipartite with 3,3 nodes)
+  // these are not planar by Kuratowski's theorem
+  if (isK5(nodes, edges) || isK33(nodes, edges)) {
+    return { isPlanar: false, embedding: null };
+  }
+
+  // For other graphs, use LR algorithm (Left-Right Planarity Test)
+  const result = lrPlanarityTest(nodes, edges);
+  return result;
+}