@graphty/layout 1.1.1 → 1.2.1

package/src/layouts/specialized/spectral.ts

@@ -0,0 +1,128 @@
+/**
+ * Spectral layout algorithm using eigenvectors of the graph Laplacian
+ */
+
+import { Graph, Node, Edge, PositionMap } from '../../types';
+import { _processParams } from '../../utils/params';
+import { getNodesFromGraph, getEdgesFromGraph } from '../../utils/graph';
+import { rescaleLayout } from '../../utils/rescale';
+
+/**
+ * Position nodes in a spectral layout using eigenvectors of the graph Laplacian.
+ * 
+ * @param G - Graph
+ * @param scale - Scale factor for positions
+ * @param center - Coordinate pair around which to center the layout
+ * @param dim - Dimension of layout
+ * @returns Positions dictionary keyed by node
+ */
+export function spectralLayout(
+  G: Graph,
+  scale: number = 1,
+  center: number[] | null = null,
+  dim: number = 2
+): PositionMap {
+  const processed = _processParams(G, center, dim);
+  const graph = processed.G;
+  center = processed.center;
+
+  const nodes = getNodesFromGraph(graph);
+
+  if (nodes.length <= 2) {
+    if (nodes.length === 0) {
+      return {};
+    } else if (nodes.length === 1) {
+      return { [nodes[0]]: center };
+    } else {
+      return {
+        [nodes[0]]: center.map(v => v - scale),
+        [nodes[1]]: center.map(v => v + scale)
+      };
+    }
+  }
+
+  // Create adjacency matrix
+  const N = nodes.length;
+  const nodeIndices: Record<Node, number> = {};
+  nodes.forEach((node: Node, i: number) => { nodeIndices[node] = i; });
+
+  const A = Array(N).fill(0).map(() => Array(N).fill(0));
+  const edges = getEdgesFromGraph(graph);
+
+  for (const [source, target] of edges) {
+    const i = nodeIndices[source];
+    const j = nodeIndices[target];
+    A[i][j] = 1;
+    A[j][i] = 1; // Make symmetric for undirected graphs
+  }
+
+  // Create Laplacian matrix: L = D - A where D is degree matrix
+  const L = Array(N).fill(0).map(() => Array(N).fill(0));
+  for (let i = 0; i < N; i++) {
+    // Compute degree (sum of row)
+    L[i][i] = A[i].reduce((sum, val) => sum + val, 0);
+    for (let j = 0; j < N; j++) {
+      L[i][j] -= A[i][j];
+    }
+  }
+
+  // Compute eigenvectors using power iteration method
+  // We need the smallest non-zero eigenvectors of L
+  const eigenvectors: number[][] = [];
+
+  // For each dimension, find an eigenvector
+  for (let d = 0; d < dim; d++) {
+    let vector = Array(N).fill(0).map(() => Math.random() - 0.5);
+
+    // Orthogonalize against previous eigenvectors
+    for (const ev of eigenvectors) {
+      const dot = vector.reduce((acc, val, idx) => acc + val * ev[idx], 0);
+      vector = vector.map((val, idx) => val - dot * ev[idx]);
+    }
+
+    // Normalize
+    const norm = Math.sqrt(vector.reduce((acc, val) => acc + val * val, 0));
+    vector = vector.map(val => val / norm);
+
+    // Apply shifted inverse iteration to find smallest non-zero eigenvector
+    // This is a simplification of the actual algorithm
+    for (let iter = 0; iter < 100; iter++) {
+      // Apply Laplacian
+      const newVec = Array(N).fill(0);
+      for (let i = 0; i < N; i++) {
+        for (let j = 0; j < N; j++) {
+          newVec[i] += L[i][j] * vector[j];
+        }
+      }
+
+      // Orthogonalize against the constant vector (eigenvector with eigenvalue 0)
+      const mean = newVec.reduce((acc, val) => acc + val, 0) / N;
+      newVec.forEach((val, idx, arr) => { arr[idx] = val - mean; });
+
+      // Normalize
+      const newNorm = Math.sqrt(newVec.reduce((acc, val) => acc + val * val, 0));
+      if (newNorm < 1e-10) continue; // Skip if vector is close to zero
+
+      vector = newVec.map(val => val / newNorm);
+    }
+
+    eigenvectors.push(vector);
+  }
+
+  // Create position array from eigenvectors
+  const positions: number[][] = Array(N).fill(0).map(() => Array(dim).fill(0));
+  for (let i = 0; i < N; i++) {
+    for (let d = 0; d < dim; d++) {
+      positions[i][d] = eigenvectors[d][i];
+    }
+  }
+
+  // Rescale and create position dictionary
+  const scaledPositions = rescaleLayout(positions as any, scale);
+  const pos: PositionMap = {};
+  nodes.forEach((node: Node, i: number) => {
+    pos[node] = (scaledPositions as number[][])[i].map((val: number, j: number) => val + center[j]);
+  });
+
+  return pos;
+}

package/src/types/embedding.ts

@@ -0,0 +1,11 @@
+/**
+ * Embedding type for planar layout algorithms
+ */
+
+import { Node, Position } from './index';
+
+export interface Embedding {
+  nodeOrder: Node[];
+  faceList: Node[][];
+  nodePositions: Record<Node, Position>;
+}

package/src/types/graph.ts

@@ -0,0 +1,13 @@
+/**
+ * Core graph type definitions
+ */
+
+export type Node = string | number;
+
+export type Edge = [Node, Node];
+
+export type Graph = {
+  nodes: () => Node[];
+  edges: () => Edge[];
+  getEdgeData?: (source: Node, target: Node, attr: string) => any;
+};

package/src/types/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Re-export all type definitions
+ */
+
+export * from './graph';
+export * from './layout';
+export * from './embedding';

package/src/types/layout.ts

@@ -0,0 +1,9 @@
+/**
+ * Layout-specific type definitions
+ */
+
+import { Node } from './graph';
+
+export type Position = number[];
+
+export type PositionMap = Record<Node, Position>;

package/src/utils/graph.ts

@@ -0,0 +1,77 @@
+/**
+ * Graph utility functions
+ */
+
+import { Graph, Node, Edge } from '../types';
+
+/**
+ * Extract nodes from a graph object
+ * 
+ * @param G - Graph or list of nodes
+ * @returns Array of nodes
+ */
+export function getNodesFromGraph(G: Graph | Node[]): Node[] {
+  if (Array.isArray(G)) {
+    return G;
+  }
+  return G.nodes();
+}
+
+/**
+ * Extract edges from a graph object
+ * 
+ * @param G - Graph or list of nodes
+ * @returns Array of edges
+ */
+export function getEdgesFromGraph(G: Graph | Node[]): Edge[] {
+  if (Array.isArray(G)) {
+    return [];
+  }
+  return G.edges();
+}
+
+/**
+ * Get the degree of a node in the graph
+ * 
+ * @param graph - Graph object
+ * @param node - Node to get degree for
+ * @returns Degree of the node
+ */
+export function getNodeDegree(graph: Graph, node: Node): number {
+  if (!graph.edges) return 0;
+  
+  const edges = graph.edges();
+  let degree = 0;
+  
+  for (const [source, target] of edges) {
+    if (source === node || target === node) {
+      degree++;
+    }
+  }
+  
+  return degree;
+}
+
+/**
+ * Get the neighbors of a node in the graph
+ * 
+ * @param graph - Graph object
+ * @param node - Node to get neighbors for
+ * @returns Array of neighbor nodes
+ */
+export function getNeighbors(graph: Graph, node: Node): Node[] {
+  if (!graph.edges) return [];
+
+  const neighbors = new Set<Node>();
+  const edges = graph.edges();
+
+  for (const [source, target] of edges) {
+    if (source === node) {
+      neighbors.add(target);
+    } else if (target === node) {
+      neighbors.add(source);
+    }
+  }
+
+  return Array.from(neighbors);
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Re-export all utilities
+ */
+
+export * from './numpy';
+export * from './random';
+export * from './graph';
+export * from './params';
+export * from './rescale';

package/src/utils/numpy.ts

@@ -0,0 +1,108 @@
+/**
+ * NumPy-like array manipulation functions
+ * Maintains exact same functionality as original implementation
+ */
+
+export const np = {
+  zeros: function (shape: number | number[]): number | number[] | number[][] | any[] {
+    if (typeof shape === 'number') {
+      return Array(shape).fill(0);
+    }
+    if (shape.length === 1) {
+      return Array(shape[0]).fill(0);
+    }
+    return Array(shape[0]).fill(0).map(() => this.zeros(shape.slice(1)));
+  },
+
+  ones: function (shape: number | number[]): number | any[] {
+    if (typeof shape === 'number') {
+      return Array(shape).fill(1);
+    }
+    if (shape.length === 1) {
+      return Array(shape[0]).fill(1);
+    }
+    return Array(shape[0]).fill(1).map(() => this.ones(shape.slice(1)));
+  },
+
+  linspace: function (start: number, stop: number, num: number): number[] {
+    const step = (stop - start) / (num - 1);
+    return Array.from({ length: num }, (_, i) => start + i * step);
+  },
+
+  array: function (arr: any): any[] {
+    return Array.isArray(arr) ? [...arr] : [arr];
+  },
+
+  repeat: function (a: any, repeats: number): any[] {
+    const result: any[] = [];
+    for (let i = 0; i < repeats; i++) {
+      result.push(...np.array(a));
+    }
+    return result;
+  },
+
+  mean: function (arr: number[] | number[][], axis: number | null = null): number | number[] {
+    if (axis === null) {
+      const flatArr = Array.isArray(arr[0])
+        ? (arr as number[][]).flat(Infinity) as number[]
+        : arr as number[];
+      const sum = flatArr.reduce((a, b) => a + b, 0);
+      return sum / flatArr.length;
+    }
+
+    if (axis === 0) {
+      const result: number[] = [];
+      const matrix = arr as number[][];
+      for (let i = 0; i < matrix[0].length; i++) {
+        let sum = 0;
+        for (let j = 0; j < matrix.length; j++) {
+          sum += matrix[j][i];
+        }
+        result.push(sum / matrix.length);
+      }
+      return result;
+    }
+
+    return (arr as number[][]).map(row => np.mean(row) as number);
+  },
+
+  add: function (a: number | number[], b: number | number[]): number | number[] {
+    if (!Array.isArray(a) && !Array.isArray(b)) {
+      return a + b;
+    }
+    if (!Array.isArray(a)) {
+      return (b as number[]).map(val => a + val);
+    }
+    if (!Array.isArray(b)) {
+      return (a as number[]).map(val => val + b);
+    }
+    return (a as number[]).map((val, i) => val + (b as number[])[i]);
+  },
+
+  subtract: function (a: number | number[], b: number | number[]): number | number[] {
+    if (!Array.isArray(a) && !Array.isArray(b)) {
+      return a - b;
+    }
+    if (!Array.isArray(a)) {
+      return (b as number[]).map(val => a - val);
+    }
+    if (!Array.isArray(b)) {
+      return (a as number[]).map(val => val - b);
+    }
+    return (a as number[]).map((val, i) => val - (b as number[])[i]);
+  },
+
+  max: function (arr: number | number[]): number {
+    if (!Array.isArray(arr)) return arr;
+    return Math.max(...(arr as number[]).flat(Infinity) as number[]);
+  },
+
+  min: function (arr: number | number[]): number {
+    if (!Array.isArray(arr)) return arr;
+    return Math.min(...(arr as number[]).flat(Infinity) as number[]);
+  },
+
+  norm: function (arr: number[]): number {
+    return Math.sqrt(arr.reduce((sum, val) => sum + val * val, 0));
+  }
+};

package/src/utils/params.ts

@@ -0,0 +1,26 @@
+/**
+ * Parameter processing utilities
+ */
+
+import { Graph, Node } from '../types';
+
+/**
+ * Process and validate layout parameters
+ * Helper function similar to _process_params in Python version
+ * 
+ * @param G - Graph object or array of nodes
+ * @param center - Center coordinates or null
+ * @param dim - Dimension of layout
+ * @returns Processed parameters
+ */
+export function _processParams(G: Graph | Node[], center: number[] | null, dim: number): { G: Graph | Node[]; center: number[] } {
+  if (!center) {
+    center = Array(dim).fill(0);
+  }
+
+  if (center.length !== dim) {
+    throw new Error("length of center coordinates must match dimension of layout");
+  }
+
+  return { G, center };
+}

package/src/utils/random.ts

@@ -0,0 +1,53 @@
+/**
+ * Random number generator for seed-based randomization
+ * Maintains exact same functionality as original implementation
+ */
+
+export class RandomNumberGenerator {
+  private seed: number;
+  private m: number;
+  private a: number;
+  private c: number;
+  private _state: number;
+
+  constructor(seed?: number) {
+    this.seed = seed || Math.floor(Math.random() * 1000000);
+    this.m = 2 ** 35 - 31;
+    this.a = 185852;
+    this.c = 1;
+    this._state = this.seed % this.m;
+  }
+
+  _next(): number {
+    this._state = (this.a * this._state + this.c) % this.m;
+    return this._state / this.m;
+  }
+
+  rand(shape: number | number[] | null = null): number | number[] | number[][] {
+    if (shape === null) {
+      return this._next();
+    }
+
+    if (typeof shape === 'number') {
+      const result: number[] = [];
+      for (let i = 0; i < shape; i++) {
+        result.push(this._next());
+      }
+      return result;
+    }
+
+    if (shape.length === 1) {
+      const result: number[] = [];
+      for (let i = 0; i < shape[0]; i++) {
+        result.push(this._next());
+      }
+      return result;
+    }
+
+    const result: any[] = [];
+    for (let i = 0; i < shape[0]; i++) {
+      result.push(this.rand(shape.slice(1)));
+    }
+    return result;
+  }
+}

package/src/utils/rescale.ts

@@ -0,0 +1,137 @@
+/**
+ * Layout rescaling utilities
+ */
+
+import { PositionMap } from '../types';
+
+/**
+ * Returns scaled position array/dict to (-scale, scale) in all axes.
+ * 
+ * @param pos - Position dictionary or array
+ * @param scale - Scale factor for positions
+ * @param center - Coordinate pair around which to center the layout
+ * @returns Rescaled positions dictionary
+ */
+export function rescaleLayout(
+  pos: PositionMap | number[][],
+  scale: number = 1,
+  center: number[] = [0, 0]
+): PositionMap | number[][] {
+  // Check if pos is empty
+  if (Array.isArray(pos)) {
+    if (pos.length === 0) return [];
+  } else {
+    if (Object.keys(pos).length === 0) return {};
+  }
+
+  // Extract position values
+  const posValues: number[][] = Array.isArray(pos) ? pos : Object.values(pos);
+  const dim = posValues[0].length;
+
+  // Calculate center of positions
+  const posCenter = Array(dim).fill(0);
+  for (const p of posValues) {
+    for (let i = 0; i < dim; i++) {
+      posCenter[i] += p[i] / posValues.length;
+    }
+  }
+
+  // Center positions
+  let centeredPos: PositionMap | number[][] = {};
+  if (Array.isArray(pos)) {
+    centeredPos = pos.map(p => p.map((val, i) => val - posCenter[i]));
+  } else {
+    for (const [node, p] of Object.entries(pos)) {
+      (centeredPos as PositionMap)[node] = p.map((val, i) => val - posCenter[i]);
+    }
+  }
+
+  // Find maximum distance from center
+  let maxDistance = 0;
+  const centeredValues = Array.isArray(centeredPos) ? centeredPos : Object.values(centeredPos);
+  for (const p of centeredValues) {
+    const distance = Math.sqrt(p.reduce((sum, val) => sum + val * val, 0));
+    maxDistance = Math.max(maxDistance, distance);
+  }
+
+  // Rescale
+  let scaledPos: PositionMap | number[][] = Array.isArray(pos) ? [] : {};
+
+  if (maxDistance > 0) {
+    const scaleFactor = scale / maxDistance;
+
+    if (Array.isArray(pos)) {
+      (scaledPos as number[][]) = (centeredPos as number[][]).map(p =>
+        p.map((val, i) => val * scaleFactor + center[i])
+      );
+    } else {
+      for (const [node, p] of Object.entries(centeredPos as PositionMap)) {
+        (scaledPos as PositionMap)[node] = p.map((val, i) => val * scaleFactor + center[i]);
+      }
+    }
+  } else {
+    // All nodes at the same position
+    if (Array.isArray(pos)) {
+      (scaledPos as number[][]) = Array(pos.length).fill(0).map(() => [...center]);
+    } else {
+      for (const node of Object.keys(pos)) {
+        (scaledPos as PositionMap)[node] = [...center];
+      }
+    }
+  }
+
+  return scaledPos;
+}
+
+/**
+ * Return a dictionary of scaled positions centered at (0, 0).
+ * 
+ * @param pos - Dictionary of positions
+ * @param scale - Scale factor for positions
+ * @returns Dictionary of scaled positions
+ */
+export function rescaleLayoutDict(
+  pos: PositionMap,
+  scale: number = 1
+): PositionMap {
+  if (Object.keys(pos).length === 0) {
+    return {};
+  }
+
+  // Extract positions as array
+  const posArray = Object.values(pos);
+
+  // Find center of positions
+  const center: number[] = [];
+  for (let d = 0; d < posArray[0].length; d++) {
+    center[d] = posArray.reduce((sum, p) => sum + p[d], 0) / posArray.length;
+  }
+
+  // Center positions
+  const centeredPos: PositionMap = {};
+  for (const [node, p] of Object.entries(pos)) {
+    centeredPos[node] = p.map((val, d) => val - center[d]);
+  }
+
+  // Find maximum distance from center
+  let maxDist = 0;
+  for (const p of Object.values(centeredPos)) {
+    const dist = Math.sqrt(p.reduce((sum, val) => sum + val * val, 0));
+    maxDist = Math.max(maxDist, dist);
+  }
+
+  // Scale positions
+  const scaledPos: PositionMap = {};
+  if (maxDist > 0) {
+    for (const [node, p] of Object.entries(centeredPos)) {
+      scaledPos[node] = p.map(val => val * scale / maxDist);
+    }
+  } else {
+    // All points at the center
+    for (const node of Object.keys(centeredPos)) {
+      scaledPos[node] = Array(centeredPos[node].length).fill(0);
+    }
+  }
+
+  return scaledPos;
+}

package/test/arf-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('ARF Layout', () => {
   describe('Basic functionality', () => {

package/test/bfs-layout.test.ts

@@ -7,7 +7,7 @@ import {
   wheelGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('BFS Layout', () => {
   describe('Basic functionality', () => {

package/test/bipartite-layout.test.ts

@@ -2,7 +2,7 @@ import { describe, it, assert } from 'vitest';
 import { 
   bipartiteLayout,
   bipartiteGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Bipartite Layout', () => {
   describe('Basic functionality', () => {