@graphty/layout 1.2.8 → 1.3.2

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

@@ -2,155 +2,146 @@
  * 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';
+import { Edge,Graph, Node } from "../../types";
+import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
+import { _lbfgsDirection } from "./lbfgs";
+import { _backtrackingLineSearch } from "./line-search";
+import { DistanceMap } from "./types";
 
 /**
  * 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;
+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;
+            }
+        }
     }
 
-    distances[source][target] = edgeWeight;
-    distances[target][source] = edgeWeight;  // Assuming undirected graph
-  }
+    // 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];
+    // 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;
+    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];
-    }
+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
+    const 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);
+        // 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]));
+        // 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();
-    }
+        // 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;
+        // 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));
-  }
+    // 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;
+    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
@@ -158,74 +149,74 @@ export function _kamadaKawaiSolve(
  * @returns Array with [cost, gradient]
  */
 export function _kamadaKawaiCostfn(
-  posVec: number[],
-  invDist: number[][],
-  meanWeight: number,
-  dim: number
+    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];
+    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;
+    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);
+    // 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 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;
-      }
+
+    // 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];
-}
+    return [cost, grad];
+}

package/src/algorithms/optimization/lbfgs.ts

@@ -4,65 +4,58 @@
 
 /**
  * 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[] = [];
+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);
+    }
 
-  // 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));
-  }
+    const q = grad.slice();
+    const alpha = Array(sList.length).fill(0);
+    const rho: number[] = [];
 
-  // 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];
+    // 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));
     }
-  }
 
-  // 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);
-  }
+    // 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];
+        }
+    }
 
-  // Initialize direction with scaled negative gradient
-  const direction = q.map(val => -gamma * val);
+    // 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);
+    }
 
-  // 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);
+    // 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;
-}
+    return direction;
+}

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

@@ -4,7 +4,6 @@
 
 /**
  * Backtracking line search to find step size
- * 
  * @param x - Current position
  * @param direction - Search direction
  * @param f - Function value at current position
@@ -14,37 +13,37 @@
  * @returns Optimal step size
  */
 export function _backtrackingLineSearch(
-  x: number[],
-  direction: number[],
-  f: number,
-  grad: number[],
-  func: (x: number[]) => number,
-  alpha0: number
+    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);
+    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
-  }
+    if (initialSlope >= 0) {
+        return 1e-8; // Direction is not a descent direction
+    }
 
-  let alpha = alpha0;
-  const maxIter = 20;
+    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);
+    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;
-    }
+        // Check sufficient decrease condition (Armijo condition)
+        if (newF <= f + c1 * alpha * initialSlope) {
+            return alpha;
+        }
 
-    // Reduce step size
-    alpha *= c2;
-  }
+        // Reduce step size
+        alpha *= c2;
+    }
 
-  return alpha;  // Return last alpha even if not optimal
-}
+    return alpha; // Return last alpha even if not optimal
+}

package/src/algorithms/optimization/types.ts

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

package/src/algorithms/planarity/check.ts

@@ -2,37 +2,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';
+import { Edge, Embedding,Graph, Node } from "../../types";
+import { createTriangulationEmbedding } from "./embedding";
+import { lrPlanarityTest } from "./lr-test";
+import { isK5, isK33 } from "./special-graphs";
 
 /**
  * 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
+ * @param seed - Random seed for deterministic embedding generation
  * @returns Object containing isPlanar flag and embedding
  */
 export function checkPlanarity(
-  G: Graph,
-  nodes: Node[],
-  edges: Edge[]
+    G: Graph,
+    nodes: Node[],
+    edges: Edge[],
+    seed: number | null = null,
 ): { 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 small graphs (n <= 4), all are planar
+    if (nodes.length <= 4) {
+        return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges, seed) };
+    }
 
-  // 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 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;
-}
+    // For other graphs, use LR algorithm (Left-Right Planarity Test)
+    const result = lrPlanarityTest(nodes, edges, seed);
+    return result;
+}