@graphty/layout 1.1.1 → 1.2.1

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

package/src/algorithms/planarity/embedding.ts

@@ -0,0 +1,216 @@
+/**
+ * Embedding functions for planar graphs
+ */
+
+import { Node, Edge, Embedding, PositionMap } from '../../types';
+
+/**
+ * Create a triangulation-based embedding for a planar graph
+ * 
+ * @param nodes - List of nodes
+ * @param edges - List of edges
+ * @returns Embedding object
+ */
+export function createTriangulationEmbedding(
+  nodes: Node[],
+  edges: Edge[]
+): Embedding {
+  // Create a simple embedding using the incremental approach
+  const embedding: Embedding = {
+    nodeOrder: [...nodes],
+    faceList: [],
+    nodePositions: {}
+  };
+
+  // Create a map of adjacent nodes
+  const adjMap: Record<Node, Set<Node>> = {};
+  for (const node of nodes) {
+    adjMap[node] = new Set<Node>();
+  }
+
+  for (const [u, v] of edges) {
+    adjMap[u].add(v);
+    adjMap[v].add(u);
+  }
+
+  // Create outer face as a cycle (if possible)
+  const outerFace = findCycle(nodes, edges, adjMap) || nodes;
+  embedding.faceList.push(outerFace);
+
+  // Position nodes on a convex polygon (outer face)
+  const n = outerFace.length;
+  for (let i = 0; i < n; i++) {
+    const angle = 2 * Math.PI * i / n;
+    embedding.nodePositions[outerFace[i]] = [Math.cos(angle), Math.sin(angle)];
+  }
+
+  // Position interior nodes using barycentric coordinates
+  const interiorNodes = nodes.filter(node => !embedding.nodePositions[node]);
+
+  for (const node of interiorNodes) {
+    const neighbors = Array.from(adjMap[node]);
+
+    if (neighbors.length === 0) {
+      // Isolated node, place at center
+      embedding.nodePositions[node] = [0, 0];
+    } else {
+      // Average position of neighbors that have positions
+      let xSum = 0, ySum = 0, count = 0;
+
+      for (const neighbor of neighbors) {
+        if (embedding.nodePositions[neighbor]) {
+          xSum += embedding.nodePositions[neighbor][0];
+          ySum += embedding.nodePositions[neighbor][1];
+          count++;
+        }
+      }
+
+      if (count > 0) {
+        // Place slightly away from center to avoid overlaps
+        const jitter = 0.1 * Math.random();
+        embedding.nodePositions[node] = [
+          xSum / count + jitter * (Math.random() - 0.5),
+          ySum / count + jitter * (Math.random() - 0.5)
+        ];
+      } else {
+        // No neighbors have positions yet, place randomly inside unit circle
+        const r = 0.5 * Math.random();
+        const angle = 2 * Math.PI * Math.random();
+        embedding.nodePositions[node] = [r * Math.cos(angle), r * Math.sin(angle)];
+      }
+    }
+  }
+
+  return embedding;
+}
+
+/**
+ * Find a simple cycle in the graph (for outer face)
+ * 
+ * @param nodes - List of nodes
+ * @param edges - List of edges
+ * @param adjMap - Adjacency map
+ * @returns Cycle as array of nodes, or null if none found
+ */
+export function findCycle(
+  nodes: Node[],
+  edges: Edge[],
+  adjMap: Record<Node, Set<Node>>
+): Node[] | null {
+  if (nodes.length === 0) return null;
+  if (nodes.length <= 2) return nodes; // Not a real cycle but handle it
+
+  // Try to find a Hamiltonian cycle for simplicity (for small graphs)
+  if (nodes.length <= 8) {
+    const visited = new Set<Node>();
+    const path: Node[] = [];
+
+    function hamiltonianCycleDFS(node: Node): boolean {
+      path.push(node);
+      visited.add(node);
+
+      if (path.length === nodes.length) {
+        // Check if it's a cycle (last node connects to first)
+        if (adjMap[node].has(path[0])) {
+          return true;
+        }
+        // Not a cycle
+        visited.delete(node);
+        path.pop();
+        return false;
+      }
+
+      for (const neighbor of adjMap[node]) {
+        if (!visited.has(neighbor)) {
+          if (hamiltonianCycleDFS(neighbor)) {
+            return true;
+          }
+        }
+      }
+
+      visited.delete(node);
+      path.pop();
+      return false;
+    }
+
+    if (hamiltonianCycleDFS(nodes[0])) {
+      return path;
+    }
+  }
+
+  // Fallback: try to find any cycle using DFS
+  const visited = new Set<Node>();
+  const parent: Record<Node, Node | null> = {};
+  let cycleFound: Node[] | null = null;
+
+  function findCycleDFS(node: Node, parentNode: Node | null): boolean {
+    visited.add(node);
+
+    for (const neighbor of adjMap[node]) {
+      if (neighbor === parentNode) continue;
+
+      if (visited.has(neighbor)) {
+        // Found a cycle
+        cycleFound = constructCycle(node, neighbor, parent);
+        return true;
+      }
+
+      parent[neighbor] = node;
+      if (findCycleDFS(neighbor, node)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  function constructCycle(u: Node, v: Node, parent: Record<Node, Node | null>): Node[] {
+    const cycle: Node[] = [v, u];
+    let current = u;
+
+    while (parent[current] !== undefined && parent[current] !== v) {
+      current = parent[current]!;
+      cycle.push(current);
+    }
+
+    return cycle;
+  }
+
+  // Try to find a cycle
+  for (const node of nodes) {
+    if (!visited.has(node)) {
+      parent[node] = null;
+      if (findCycleDFS(node, null)) {
+        break;
+      }
+    }
+  }
+
+  return cycleFound || nodes; // Fallback to all nodes if no cycle found
+}
+
+/**
+ * Convert a combinatorial embedding to node positions
+ * 
+ * @param embedding - The embedding object
+ * @param nodes - List of nodes
+ * @returns Dictionary mapping nodes to positions
+ */
+export function combinatorialEmbeddingToPos(
+  embedding: Embedding,
+  nodes: Node[]
+): PositionMap {
+  const pos: PositionMap = {};
+
+  // Use the positions from the embedding
+  for (const node of nodes) {
+    if (embedding.nodePositions[node]) {
+      pos[node] = embedding.nodePositions[node];
+    } else {
+      // Fallback for any nodes without positions
+      pos[node] = [0, 0];
+    }
+  }
+
+  return pos;
+}

package/src/algorithms/planarity/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Re-export all planarity algorithms
+ */
+
+export { checkPlanarity } from './check';
+export { isK5, isK33, tryFindBipartitePartition } from './special-graphs';
+export { lrPlanarityTest } from './lr-test';
+export { 
+  createTriangulationEmbedding, 
+  findCycle, 
+  combinatorialEmbeddingToPos 
+} from './embedding';

package/src/algorithms/planarity/lr-test.ts

@@ -0,0 +1,70 @@
+/**
+ * Left-Right Planarity Test implementation
+ */
+
+import { Node, Edge, Embedding } from '../../types';
+import { createTriangulationEmbedding } from './embedding';
+
+/**
+ * Left-Right Planarity Test for general graphs
+ *
+ * @param nodes - List of nodes
+ * @param edges - List of edges
+ * @returns Object containing isPlanar flag and embedding
+ */
+export function lrPlanarityTest(
+  nodes: Node[],
+  edges: Edge[]
+): { isPlanar: boolean; embedding: Embedding | null } {
+  // Create adjacency list for the graph
+  const adjList: Record<Node, Node[]> = {};
+  for (const node of nodes) {
+    adjList[node] = [];
+  }
+
+  for (const [u, v] of edges) {
+    adjList[u].push(v);
+    adjList[v].push(u);
+  }
+
+  // Step 1: Perform DFS to get an st-numbering (ordering of nodes)
+  const visited = new Set<Node>();
+  const ordering: Node[] = [];
+
+  function dfs(node: Node): void {
+    visited.add(node);
+    ordering.push(node);
+
+    for (const neighbor of adjList[node]) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor);
+      }
+    }
+  }
+
+  // Start DFS from first node
+  dfs(nodes[0]);
+
+  // If the graph is disconnected, it's still planar but we need to handle each component
+  if (ordering.length < nodes.length) {
+    // Create a simple triangulation embedding for disconnected graphs
+    return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges) };
+  }
+
+  // Step 2: For a general implementation, we'll use a simplified approach
+  // since this would normally require implementing the entire LR algorithm
+
+  // For this implementation, since we can't fully implement Boyer-Myrvold,
+  // we'll create a reasonable planar embedding for most planar graphs
+
+  // We assume the graph is planar if it's sparse enough (|E| <= 3|V| - 6)
+  // This is a necessary but not sufficient condition for planar graphs
+  if (edges.length > 3 * nodes.length - 6) {
+    return { isPlanar: false, embedding: null };
+  }
+
+  // Create a planar embedding using a triangulation approach
+  const embedding = createTriangulationEmbedding(nodes, edges);
+
+  return { isPlanar: true, embedding };
+}

package/src/algorithms/planarity/special-graphs.ts

@@ -0,0 +1,126 @@
+/**
+ * Special graph detection functions for planarity testing
+ */
+
+import { Node, Edge } from '../../types';
+
+/**
+ * Check if graph is K5 (complete graph with 5 nodes)
+ * 
+ * @param nodes - List of nodes
+ * @param edges - List of edges
+ * @returns True if graph is K5
+ */
+export function isK5(nodes: Node[], edges: Edge[]): boolean {
+  if (nodes.length !== 5) return false;
+
+  // K5 has exactly 10 edges
+  if (edges.length !== 10) return false;
+
+  // Check if every pair of distinct nodes is connected
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const hasEdge = edges.some(
+        e => (e[0] === nodes[i] && e[1] === nodes[j]) ||
+          (e[0] === nodes[j] && e[1] === nodes[i])
+      );
+      if (!hasEdge) return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Check if graph is K3,3 (complete bipartite with 3,3 nodes)
+ * 
+ * @param nodes - List of nodes
+ * @param edges - List of edges
+ * @returns True if graph is K3,3
+ */
+export function isK33(nodes: Node[], edges: Edge[]): boolean {
+  if (nodes.length !== 6) return false;
+
+  // K3,3 has exactly 9 edges
+  if (edges.length !== 9) return false;
+
+  // Try to find a bipartite partition
+  const nodePartitions = tryFindBipartitePartition(nodes, edges);
+  if (!nodePartitions) return false;
+
+  const [part1, part2] = nodePartitions;
+
+  // Check if both partitions have size 3
+  if (part1.length !== 3 || part2.length !== 3) return false;
+
+  // Check if every node in part1 is connected to every node in part2
+  for (const n1 of part1) {
+    for (const n2 of part2) {
+      const hasEdge = edges.some(
+        e => (e[0] === n1 && e[1] === n2) ||
+          (e[0] === n2 && e[1] === n1)
+      );
+      if (!hasEdge) return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Try to find a bipartite partition of the nodes
+ * 
+ * @param nodes - List of nodes
+ * @param edges - List of edges
+ * @returns Array of two partitions, or null if not bipartite
+ */
+export function tryFindBipartitePartition(
+  nodes: Node[],
+  edges: Edge[]
+): [Node[], Node[]] | null {
+  const colorMap: Record<Node, number> = {};
+  const adjList: Record<Node, Node[]> = {};
+
+  // Create adjacency list
+  for (const node of nodes) {
+    adjList[node] = [];
+  }
+
+  for (const [u, v] of edges) {
+    adjList[u].push(v);
+    adjList[v].push(u);
+  }
+
+  // BFS to color nodes
+  const queue: Node[] = [nodes[0]];
+  colorMap[nodes[0]] = 0;
+
+  while (queue.length > 0) {
+    const node = queue.shift()!;
+    const nodeColor = colorMap[node];
+
+    for (const neighbor of adjList[node]) {
+      if (colorMap[neighbor] === undefined) {
+        colorMap[neighbor] = 1 - nodeColor; // Toggle color (0/1)
+        queue.push(neighbor);
+      } else if (colorMap[neighbor] === nodeColor) {
+        // Conflict: not bipartite
+        return null;
+      }
+    }
+  }
+
+  // Create partitions
+  const part0: Node[] = [];
+  const part1: Node[] = [];
+
+  for (const node of nodes) {
+    if (colorMap[node] === 0) {
+      part0.push(node);
+    } else {
+      part1.push(node);
+    }
+  }
+
+  return [part0, part1];
+}

package/src/generators/basic.ts

@@ -0,0 +1,93 @@
+/**
+ * Basic graph generation functions
+ */
+
+import { Graph, Node, Edge } from '../types';
+
+/**
+ * Create a complete graph with n nodes
+ * @param n - Number of nodes
+ * @returns Graph object with all nodes connected to all other nodes
+ */
+export function completeGraph(n: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      edges.push([i, j]);
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a cycle graph with n nodes
+ * @param n - Number of nodes
+ * @returns Graph object with nodes connected in a cycle
+ */
+export function cycleGraph(n: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  for (let i = 0; i < n; i++) {
+    edges.push([i, (i + 1) % n]);
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a star graph with n nodes (1 center + n-1 leaves)
+ * @param n - Total number of nodes
+ * @returns Graph object with star topology
+ */
+export function starGraph(n: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  // Connect all nodes to node 0 (center)
+  for (let i = 1; i < n; i++) {
+    edges.push([0, i]);
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a wheel graph with n nodes (1 center + n-1 rim nodes)
+ * @param n - Total number of nodes
+ * @returns Graph object with wheel topology
+ */
+export function wheelGraph(n: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  // Connect all rim nodes to center (node 0)
+  for (let i = 1; i < n; i++) {
+    edges.push([0, i]);
+  }
+  
+  // Connect rim nodes in a cycle
+  for (let i = 1; i < n - 1; i++) {
+    edges.push([i, i + 1]);
+  }
+  if (n > 2) {
+    edges.push([n - 1, 1]);
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}