@graphty/layout 1.1.1 → 1.2.1

package/src/generators/bipartite.ts

@@ -0,0 +1,45 @@
+/**
+ * Bipartite graph generation function
+ */
+
+import { Graph, Node, Edge } from '../types';
+
+/**
+ * Create a bipartite graph with two sets of nodes
+ * @param n1 - Number of nodes in first set
+ * @param n2 - Number of nodes in second set
+ * @param p - Probability of edge between nodes in different sets
+ * @param seed - Random seed for reproducibility
+ * @returns Graph object with bipartite structure and setA/setB properties
+ */
+export function bipartiteGraph(n1: number, n2: number, p: number, seed?: number): Graph & { setA: Node[], setB: Node[] } {
+  const setA: Node[] = Array.from({ length: n1 }, (_, i) => `A${i}`);
+  const setB: Node[] = Array.from({ length: n2 }, (_, i) => `B${i}`);
+  const nodes = [...setA, ...setB];
+  const edges: Edge[] = [];
+  
+  // Simple deterministic pseudo-random if seed provided
+  let currentSeed = seed;
+  let random = seed !== undefined 
+    ? () => {
+        currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+        return currentSeed / 233280;
+      }
+    : Math.random;
+  
+  // Only connect nodes between sets
+  for (const a of setA) {
+    for (const b of setB) {
+      if (random() < p) {
+        edges.push([a, b]);
+      }
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges,
+    setA,
+    setB
+  };
+}

package/src/generators/grid.ts

@@ -0,0 +1,42 @@
+/**
+ * Grid graph generation function
+ */
+
+import { Graph, Node, Edge } from '../types';
+
+/**
+ * Create a grid graph with rows x cols nodes
+ * @param rows - Number of rows
+ * @param cols - Number of columns
+ * @returns Graph object with grid topology
+ */
+export function gridGraph(rows: number, cols: number): Graph {
+  const nodes: Node[] = [];
+  const edges: Edge[] = [];
+  
+  // Create nodes
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      nodes.push(`${i},${j}`);
+    }
+  }
+  
+  // Create edges
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      // Connect to right neighbor
+      if (j < cols - 1) {
+        edges.push([`${i},${j}`, `${i},${j + 1}`]);
+      }
+      // Connect to bottom neighbor
+      if (i < rows - 1) {
+        edges.push([`${i},${j}`, `${i + 1},${j}`]);
+      }
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}

package/src/generators/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Re-export all graph generation functions
+ */
+
+export { 
+  completeGraph, 
+  cycleGraph, 
+  starGraph, 
+  wheelGraph 
+} from './basic';
+
+export { gridGraph } from './grid';
+export { randomGraph } from './random';
+export { bipartiteGraph } from './bipartite';
+export { scaleFreeGraph } from './scale-free';

package/src/generators/random.ts

@@ -0,0 +1,39 @@
+/**
+ * Random graph generation function
+ */
+
+import { Graph, Node, Edge } from '../types';
+
+/**
+ * Create a random graph with n nodes and given edge probability
+ * @param n - Number of nodes
+ * @param p - Probability of edge between any two nodes (0-1)
+ * @param seed - Random seed for reproducibility
+ * @returns Graph object with random edges
+ */
+export function randomGraph(n: number, p: number, seed?: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  // Simple deterministic pseudo-random if seed provided
+  let currentSeed = seed;
+  let random = seed !== undefined 
+    ? () => {
+        currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+        return currentSeed / 233280;
+      }
+    : Math.random;
+  
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (random() < p) {
+        edges.push([i, j]);
+      }
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}

package/src/generators/scale-free.ts

@@ -0,0 +1,72 @@
+/**
+ * Scale-free graph generation function
+ */
+
+import { Graph, Node, Edge } from '../types';
+
+/**
+ * Create a scale-free graph using Barabási-Albert model
+ * @param n - Total number of nodes
+ * @param m - Number of edges to attach from new node
+ * @param seed - Random seed for reproducibility
+ * @returns Graph object with scale-free properties
+ */
+export function scaleFreeGraph(n: number, m: number, seed?: number): Graph {
+  if (m >= n) {
+    throw new Error('m must be less than n');
+  }
+  
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  const degrees = new Array(n).fill(0);
+  
+  // Simple deterministic pseudo-random if seed provided
+  let currentSeed = seed;
+  let random = seed !== undefined 
+    ? () => {
+        currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+        return currentSeed / 233280;
+      }
+    : Math.random;
+  
+  // Start with complete graph of m+1 nodes
+  for (let i = 0; i <= m; i++) {
+    for (let j = i + 1; j <= m; j++) {
+      edges.push([i, j]);
+      degrees[i]++;
+      degrees[j]++;
+    }
+  }
+  
+  // Add remaining nodes
+  for (let i = m + 1; i < n; i++) {
+    const targets = new Set<number>();
+    const totalDegree = degrees.reduce((sum, d) => sum + d, 0);
+    
+    // Choose m targets based on preferential attachment
+    while (targets.size < m) {
+      let r = random() * totalDegree;
+      let cumSum = 0;
+      
+      for (let j = 0; j < i; j++) {
+        cumSum += degrees[j];
+        if (r <= cumSum && !targets.has(j)) {
+          targets.add(j);
+          break;
+        }
+      }
+    }
+    
+    // Add edges to targets
+    for (const target of targets) {
+      edges.push([i, target]);
+      degrees[i]++;
+      degrees[target]++;
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Main entry point for @graphty/layout
+ * 
+ * This file exports the complete public API, maintaining
+ * compatibility with the original layout.ts file.
+ */
+
+// Re-export all types
+export * from './types';
+
+// Re-export utilities that are part of the public API
+export { rescaleLayout, rescaleLayoutDict } from './utils/rescale';
+
+// Re-export all layout algorithms
+export * from './layouts';
+
+// Re-export all graph generation functions
+export * from './generators';

package/src/layouts/basic/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Basic layout algorithms
+ */
+
+export { randomLayout } from './random';

package/src/layouts/basic/random.ts

@@ -0,0 +1,32 @@
+/**
+ * Random layout algorithm
+ */
+
+import { Graph, Node, PositionMap } from '../../types';
+import { _processParams } from '../../utils/params';
+import { getNodesFromGraph } from '../../utils/graph';
+import { RandomNumberGenerator } from '../../utils/random';
+
+/**
+ * Position nodes uniformly at random in the unit square.
+ * 
+ * @param G - Graph or list of nodes
+ * @param center - Coordinate pair around which to center the layout
+ * @param dim - Dimension of layout
+ * @param seed - Random seed for reproducible layouts
+ * @returns Positions dictionary keyed by node
+ */
+export function randomLayout(G: Graph | Node[], center: number[] | null = null, dim: number = 2, seed: number | null = null): PositionMap {
+  const processed = _processParams(G, center, dim);
+  const nodes = getNodesFromGraph(processed.G);
+  center = processed.center;
+
+  const rng = new RandomNumberGenerator(seed ?? undefined);
+  const pos: PositionMap = {};
+
+  nodes.forEach((node: Node) => {
+    pos[node] = (rng.rand(dim) as number[]).map((val: number, i: number) => val + center[i]);
+  });
+
+  return pos;
+}

package/src/layouts/force-directed/arf.ts

@@ -0,0 +1,130 @@
+import type { Graph, Node, PositionMap } from '../../types';
+import { getNodesFromGraph, getEdgesFromGraph } from '../../utils/graph';
+import { RandomNumberGenerator } from '../../utils/random';
+import { randomLayout } from '../basic/random';
+
+/**
+ * Layout algorithm with attractive and repulsive forces (ARF).
+ * 
+ * @param G - Graph
+ * @param pos - Initial positions for nodes
+ * @param scaling - Scale factor for positions
+ * @param a - Strength of springs between connected nodes (should be > 1)
+ * @param maxIter - Maximum number of iterations
+ * @param seed - Random seed for initial positions
+ * @returns Positions dictionary keyed by node
+ */
+export function arfLayout(
+  G: Graph,
+  pos: PositionMap | null = null,
+  scaling: number = 1,
+  a: number = 1.1,
+  maxIter: number = 1000,
+  seed: number | null = null
+): PositionMap {
+  if (a <= 1) {
+    throw new Error("The parameter a should be larger than 1");
+  }
+
+  const nodes = getNodesFromGraph(G);
+  const edges = getEdgesFromGraph(G);
+
+  if (nodes.length === 0) {
+    return {};
+  }
+
+  // Initialize positions if not provided
+  if (!pos) {
+    pos = randomLayout(G, null, 2, seed);
+  } else {
+    // Make sure all nodes have positions
+    const rng = new RandomNumberGenerator(seed ?? undefined);
+    const defaultPos: PositionMap = {};
+    nodes.forEach((node: Node) => {
+      if (!pos![node]) {
+        defaultPos[node] = [(rng.rand() as number), (rng.rand() as number)];
+      }
+    });
+    pos = { ...pos, ...defaultPos };
+  }
+
+  // Create node index mapping
+  const nodeIndex: Record<Node, number> = {};
+  nodes.forEach((node: Node, i: number) => {
+    nodeIndex[node] = i;
+  });
+
+  // Create positions array
+  const positions: number[][] = nodes.map((node: Node) => [...pos![node]]);
+
+  // Initialize spring constant matrix
+  const N = nodes.length;
+  const K = Array(N).fill(0).map(() => Array(N).fill(1));
+
+  // Set diagonal to zero (no self-attraction)
+  for (let i = 0; i < N; i++) {
+    K[i][i] = 0;
+  }
+
+  // Set stronger attraction between connected nodes
+  for (const [source, target] of edges) {
+    if (source === target) continue;
+
+    const i = nodeIndex[source];
+    const j = nodeIndex[target];
+    K[i][j] = a;
+    K[j][i] = a;
+  }
+
+  // Calculate rho (scale factor)
+  const rho = scaling * Math.sqrt(N);
+
+  // Optimization loop
+  const dt = 1e-3;  // Time step
+  const etol = 1e-6;  // Error tolerance
+  let error = etol + 1;
+  let nIter = 0;
+
+  while (error > etol && nIter < maxIter) {
+    // Calculate changes for each node
+    const change = Array(N).fill(0).map(() => [0, 0]);
+
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++) {
+        if (i === j) continue;
+
+        // Calculate difference vector
+        const diff = positions[i].map((coord, dim) => coord - positions[j][dim]);
+
+        // Calculate distance (with minimum to avoid division by zero)
+        const dist = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0)) || 0.01;
+
+        // Calculate attractive and repulsive forces
+        for (let d = 0; d < diff.length; d++) {
+          change[i][d] += K[i][j] * diff[d] - (rho / dist) * diff[d];
+        }
+      }
+    }
+
+    // Update positions
+    for (let i = 0; i < N; i++) {
+      for (let d = 0; d < positions[i].length; d++) {
+        positions[i][d] += change[i][d] * dt;
+      }
+    }
+
+    // Calculate error (sum of force magnitudes)
+    error = change.reduce((sum, c) =>
+      sum + Math.sqrt(c.reduce((s, v) => s + v * v, 0)), 0);
+
+    nIter++;
+  }
+
+  // Convert positions array back to object
+  const finalPos: PositionMap = {};
+  nodes.forEach((node: Node, i: number) => {
+    finalPos[node] = positions[i];
+  });
+
+  return finalPos;
+}