@graphty/layout 1.2.8 → 1.3.2

package/src/layouts/specialized/spectral.ts

@@ -2,14 +2,13 @@
  * 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';
+import { Edge, Graph, Node, PositionMap } from "../../types";
+import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
+import { _processParams } from "../../utils/params";
+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
@@ -17,112 +16,124 @@ import { rescaleLayout } from '../../utils/rescale';
  * @returns Positions dictionary keyed by node
  */
 export function spectralLayout(
-  G: Graph,
-  scale: number = 1,
-  center: number[] | null = null,
-  dim: number = 2
+    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)
-      };
+    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 };
+        } 
+            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]);
+    // 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
     }
 
-    // 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++) {
+    // 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++) {
-          newVec[i] += L[i][j] * vector[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[][] = [];
 
-      // 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; });
+    // 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 newNorm = Math.sqrt(newVec.reduce((acc, val) => acc + val * val, 0));
-      if (newNorm < 1e-10) continue; // Skip if vector is close to zero
+        // 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);
+        }
 
-      vector = newVec.map(val => val / newNorm);
+        eigenvectors.push(vector);
     }
 
-    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];
+    // 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]);
-  });
+    // 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;
-}
+    return pos;
+}

package/src/types/embedding.ts

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

package/src/types/graph.ts

@@ -7,7 +7,7 @@ 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;
-};
+    nodes: () => Node[];
+    edges: () => Edge[];
+    getEdgeData?: (source: Node, target: Node, attr: string) => any;
+};

package/src/types/index.ts

@@ -2,6 +2,6 @@
  * Re-export all type definitions
  */
 
-export * from './graph';
-export * from './layout';
-export * from './embedding';
+export * from "./embedding";
+export * from "./graph";
+export * from "./layout";

package/src/types/layout.ts

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

package/src/utils/graph.ts

@@ -2,76 +2,72 @@
  * Graph utility functions
  */
 
-import { Graph, Node, Edge } from '../types';
+import { Edge,Graph, Node } 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();
+    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();
+    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++;
+    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;
+
+    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 [];
+    if (!graph.edges) {return [];}
 
-  const neighbors = new Set<Node>();
-  const edges = graph.edges();
+    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);
+    for (const [source, target] of edges) {
+        if (source === node) {
+            neighbors.add(target);
+        } else if (target === node) {
+            neighbors.add(source);
+        }
     }
-  }
 
-  return Array.from(neighbors);
-}
+    return Array.from(neighbors);
+}

package/src/utils/index.ts

@@ -2,8 +2,8 @@
  * Re-export all utilities
  */
 
-export * from './numpy';
-export * from './random';
-export * from './graph';
-export * from './params';
-export * from './rescale';
+export * from "./graph";
+export * from "./numpy";
+export * from "./params";
+export * from "./random";
+export * from "./rescale";

package/src/utils/numpy.ts

@@ -4,108 +4,112 @@
  */
 
 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)));
-  },
+    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)));
-  },
+    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[] {
-    if (num === 1) {
-      return [start];
-    }
-    const step = (stop - start) / (num - 1);
-    return Array.from({ length: num }, (_, i) => start + i * step);
-  },
+    linspace: function (start: number, stop: number, num: number): number[] {
+        if (num === 1) {
+            return [start];
+        }
+        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];
-  },
+    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;
-  },
+    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;
-    }
+    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];
+        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;
         }
-        result.push(sum / matrix.length);
-      }
-      return result;
-    }
 
-    return (arr as number[][]).map(row => np.mean(row) as number);
-  },
+        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]);
-  },
+    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).map((val) => val + b);
+        }
+        return (a).map((val, i) => val + (b)[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]);
-  },
+    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).map((val) => val - b);
+        }
+        return (a).map((val, i) => val - (b)[i]);
+    },
 
-  max: function (arr: number | number[]): number {
-    if (!Array.isArray(arr)) return arr;
-    return Math.max(...(arr as number[]).flat(Infinity) as number[]);
-  },
+    max: function (arr: number | number[]): number {
+        if (!Array.isArray(arr)) {return arr;}
+        return Math.max(...((arr).flat(Infinity)));
+    },
 
-  min: function (arr: number | number[]): number {
-    if (!Array.isArray(arr)) return arr;
-    return Math.min(...(arr as number[]).flat(Infinity) as number[]);
-  },
+    min: function (arr: number | number[]): number {
+        if (!Array.isArray(arr)) {return arr;}
+        return Math.min(...((arr).flat(Infinity)));
+    },
 
-  norm: function (arr: number[]): number {
-    return Math.sqrt(arr.reduce((sum, val) => sum + val * val, 0));
-  }
-};
+    norm: function (arr: number[]): number {
+        return Math.sqrt(arr.reduce((sum, val) => sum + val * val, 0));
+    },
+};

package/src/utils/params.ts

@@ -2,25 +2,28 @@
  * Parameter processing utilities
  */
 
-import { Graph, Node } from '../types';
+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);
-  }
+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");
-  }
+    if (center.length !== dim) {
+        throw new Error("length of center coordinates must match dimension of layout");
+    }
 
-  return { G, center };
-}
+    return { G, center };
+}