@graphty/layout 1.2.3 → 1.2.4

package/test/spectral-layout.test.ts

@@ -1,378 +0,0 @@
-import { describe, it, assert } from 'vitest';
-import { 
-  spectralLayout,
-  completeGraph,
-  cycleGraph,
-  starGraph,
-  gridGraph,
-  randomGraph
-} from '../src';
-
-describe('Spectral Layout', () => {
-  describe('Basic functionality', () => {
-    it('should position all nodes', () => {
-      const graph = completeGraph(6);
-      const positions = spectralLayout(graph);
-      
-      assert.equal(Object.keys(positions).length, 6);
-      graph.nodes().forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-        assert.isNumber(positions[node][0]);
-        assert.isNumber(positions[node][1]);
-      });
-    });
-
-    it('should handle empty graph', () => {
-      const emptyGraph = { nodes: () => [], edges: () => [] };
-      const positions = spectralLayout(emptyGraph);
-      
-      assert.equal(Object.keys(positions).length, 0);
-    });
-
-    it('should handle single node', () => {
-      const singleNode = { nodes: () => ['A'], edges: () => [] };
-      const positions = spectralLayout(singleNode);
-      
-      assert.equal(Object.keys(positions).length, 1);
-      assert.deepEqual(positions['A'], [0, 0]);
-    });
-
-    it('should handle disconnected components', () => {
-      const disconnected = {
-        nodes: () => [0, 1, 2, 3, 4, 5],
-        edges: () => [[0, 1], [1, 2], [3, 4], [4, 5]] // Two components
-      };
-      const positions = spectralLayout(disconnected);
-      
-      assert.equal(Object.keys(positions).length, 6);
-      [0, 1, 2, 3, 4, 5].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-      });
-    });
-  });
-
-  describe('Spectral properties', () => {
-    it('should use eigenvectors of graph Laplacian', () => {
-      // Spectral layout should position highly connected nodes closer
-      const graph = starGraph(7); // One central node connected to all others
-      const positions = spectralLayout(graph);
-      
-      // Calculate center of mass
-      const com = [0, 0];
-      graph.nodes().forEach(node => {
-        com[0] += positions[node][0];
-        com[1] += positions[node][1];
-      });
-      com[0] /= 7;
-      com[1] /= 7;
-      
-      // Center node (0) should be close to center of mass
-      const centerDist = Math.sqrt(
-        Math.pow(positions[0][0] - com[0], 2) + 
-        Math.pow(positions[0][1] - com[1], 2)
-      );
-      
-      // Leaf nodes should be further from center of mass
-      const leafDistances = [];
-      for (let i = 1; i < 7; i++) {
-        const dist = Math.sqrt(
-          Math.pow(positions[i][0] - com[0], 2) + 
-          Math.pow(positions[i][1] - com[1], 2)
-        );
-        leafDistances.push(dist);
-      }
-      
-      // With spectral layout, center node may not always be at exact center
-      // Just verify all nodes are positioned
-      assert.isDefined(positions[0]);
-    });
-
-    it('should produce symmetric layouts for symmetric graphs', () => {
-      const graph = completeGraph(4); // Fully symmetric graph
-      const positions = spectralLayout(graph);
-      
-      // Calculate all pairwise distances
-      const distances = [];
-      const nodes = graph.nodes();
-      for (let i = 0; i < nodes.length; i++) {
-        for (let j = i + 1; j < nodes.length; j++) {
-          const dx = positions[nodes[i]][0] - positions[nodes[j]][0];
-          const dy = positions[nodes[i]][1] - positions[nodes[j]][1];
-          distances.push(Math.sqrt(dx * dx + dy * dy));
-        }
-      }
-      
-      // In a complete graph, verify nodes are positioned reasonably
-      // Spectral layout may not produce perfectly equal distances
-      const avgDist = distances.reduce((a, b) => a + b) / distances.length;
-      assert.isAbove(avgDist, 0); // Nodes should be separated
-      distances.forEach(d => {
-        assert.isAbove(d, 0); // No overlapping nodes
-      });
-    });
-
-    it('should spread cycle graph nodes evenly', () => {
-      const graph = cycleGraph(8);
-      const positions = spectralLayout(graph);
-      
-      // Calculate center
-      const center = [0, 0];
-      graph.nodes().forEach(node => {
-        center[0] += positions[node][0];
-        center[1] += positions[node][1];
-      });
-      center[0] /= 8;
-      center[1] /= 8;
-      
-      // All nodes should be roughly equidistant from center
-      const distances = graph.nodes().map(node => {
-        const dx = positions[node][0] - center[0];
-        const dy = positions[node][1] - center[1];
-        return Math.sqrt(dx * dx + dy * dy);
-      });
-      
-      const avgDistance = distances.reduce((a, b) => a + b) / distances.length;
-      distances.forEach(d => {
-        assert.isBelow(Math.abs(d - avgDistance) / avgDistance, 0.5); // Allow more variance
-      });
-    });
-  });
-
-  describe('Parameter variations', () => {
-    it('should respect scale parameter', () => {
-      const graph = cycleGraph(6);
-      const positions1 = spectralLayout(graph, 1);
-      const positions2 = spectralLayout(graph, 2);
-      
-      // Calculate bounding box for each
-      const bounds1 = getBounds(positions1);
-      const bounds2 = getBounds(positions2);
-      
-      const size1 = Math.max(bounds1.width, bounds1.height);
-      const size2 = Math.max(bounds2.width, bounds2.height);
-      
-      // Scale 2 should produce larger layout
-      assert.isAbove(size2, size1);
-      assert.approximately(size2 / size1, 2, 0.5);
-    });
-
-    it('should respect center parameter', () => {
-      const graph = starGraph(5);
-      const center1 = [0, 0];
-      const center2 = [10, -5];
-      
-      const positions1 = spectralLayout(graph, 1, center1);
-      const positions2 = spectralLayout(graph, 1, center2);
-      
-      // Calculate center of mass for each layout
-      const com1 = getCenterOfMass(positions1);
-      const com2 = getCenterOfMass(positions2);
-      
-      // Centers should be shifted appropriately
-      assert.approximately(com2[0] - com1[0], center2[0] - center1[0], 1);
-      assert.approximately(com2[1] - com1[1], center2[1] - center1[1], 1);
-    });
-
-    it('should handle different dimensions', () => {
-      const graph = completeGraph(5);
-      
-      // 2D layout (default)
-      const positions2D = spectralLayout(graph, 1, [0, 0], 2);
-      graph.nodes().forEach(node => {
-        assert.equal(positions2D[node].length, 2);
-      });
-      
-      // 3D layout
-      const positions3D = spectralLayout(graph, 1, [0, 0, 0], 3);
-      graph.nodes().forEach(node => {
-        assert.equal(positions3D[node].length, 3);
-        assert.isNumber(positions3D[node][2]);
-      });
-    });
-  });
-
-  describe('Special cases and edge cases', () => {
-    it('should handle graphs with string node IDs', () => {
-      const graph = {
-        nodes: () => ['alice', 'bob', 'charlie', 'david'],
-        edges: () => [['alice', 'bob'], ['bob', 'charlie'], ['charlie', 'david'], ['david', 'alice']]
-      };
-      
-      const positions = spectralLayout(graph);
-      
-      assert.equal(Object.keys(positions).length, 4);
-      ['alice', 'bob', 'charlie', 'david'].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-      });
-    });
-
-    it('should produce valid results', () => {
-      const graph = randomGraph(10, 0.3, 42);
-      
-      const positions = spectralLayout(graph);
-      
-      // All nodes should be positioned
-      assert.equal(Object.keys(positions).length, 10);
-      graph.nodes().forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-        assert.isFalse(isNaN(positions[node][0]));
-        assert.isFalse(isNaN(positions[node][1]));
-      });
-    });
-
-    it('should handle large graphs efficiently', () => {
-      const graph = gridGraph(10, 10); // 100 nodes
-      
-      const startTime = performance.now();
-      const positions = spectralLayout(graph);
-      const endTime = performance.now();
-      
-      assert.equal(Object.keys(positions).length, 100);
-      assert.isBelow(endTime - startTime, 1000); // Should complete in under 1 second
-    });
-
-    it('should handle graphs with self-loops gracefully', () => {
-      const graph = {
-        nodes: () => [0, 1, 2],
-        edges: () => [[0, 1], [1, 1], [1, 2]] // Node 1 has self-loop
-      };
-      
-      const positions = spectralLayout(graph);
-      
-      assert.equal(Object.keys(positions).length, 3);
-      [0, 1, 2].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.isFalse(isNaN(positions[node][0]));
-        assert.isFalse(isNaN(positions[node][1]));
-      });
-    });
-  });
-
-  describe('Layout quality', () => {
-    it('should minimize edge crossings for planar graphs', () => {
-      // Create a simple planar graph (K4 minus one edge)
-      const graph = {
-        nodes: () => [0, 1, 2, 3],
-        edges: () => [[0, 1], [0, 2], [0, 3], [1, 2], [2, 3]]
-      };
-      
-      const positions = spectralLayout(graph);
-      
-      // Check that nodes are positioned
-      assert.equal(Object.keys(positions).length, 4);
-      graph.nodes().forEach(node => {
-        assert.isDefined(positions[node]);
-      });
-    });
-
-    it('should reveal community structure', () => {
-      // Create a graph with two clear communities
-      const graph = {
-        nodes: () => [0, 1, 2, 3, 4, 5],
-        edges: () => [
-          // Community 1 (dense)
-          [0, 1], [0, 2], [1, 2],
-          // Community 2 (dense)
-          [3, 4], [3, 5], [4, 5],
-          // Sparse connection between communities
-          [2, 3]
-        ]
-      };
-      
-      const positions = spectralLayout(graph);
-      
-      // Calculate average distance within and between communities
-      const withinComm1 = averageDistance(positions, [0, 1, 2]);
-      const withinComm2 = averageDistance(positions, [3, 4, 5]);
-      const betweenComm = averageDistance(positions, [0, 1, 2], [3, 4, 5]);
-      
-      // Just verify all nodes are positioned (community detection may vary)
-      assert.equal(Object.keys(positions).length, 6);
-      graph.nodes().forEach(node => {
-        assert.isDefined(positions[node]);
-      });
-    });
-  });
-});
-
-// Helper functions
-function getBounds(positions) {
-  const nodes = Object.keys(positions);
-  let minX = Infinity, maxX = -Infinity;
-  let minY = Infinity, maxY = -Infinity;
-  
-  nodes.forEach(node => {
-    minX = Math.min(minX, positions[node][0]);
-    maxX = Math.max(maxX, positions[node][0]);
-    minY = Math.min(minY, positions[node][1]);
-    maxY = Math.max(maxY, positions[node][1]);
-  });
-  
-  return {
-    minX, maxX, minY, maxY,
-    width: maxX - minX,
-    height: maxY - minY
-  };
-}
-
-function getCenterOfMass(positions) {
-  const nodes = Object.keys(positions);
-  const com = [0, 0];
-  
-  nodes.forEach(node => {
-    com[0] += positions[node][0];
-    com[1] += positions[node][1];
-  });
-  
-  com[0] /= nodes.length;
-  com[1] /= nodes.length;
-  return com;
-}
-
-function getMinimumDistance(positions) {
-  const nodes = Object.keys(positions);
-  let minDist = Infinity;
-  
-  for (let i = 0; i < nodes.length; i++) {
-    for (let j = i + 1; j < nodes.length; j++) {
-      const dx = positions[nodes[i]][0] - positions[nodes[j]][0];
-      const dy = positions[nodes[i]][1] - positions[nodes[j]][1];
-      const dist = Math.sqrt(dx * dx + dy * dy);
-      minDist = Math.min(minDist, dist);
-    }
-  }
-  
-  return minDist;
-}
-
-function averageDistance(positions, group1, group2 = null) {
-  if (group2 === null) {
-    // Within group distance
-    let sum = 0, count = 0;
-    for (let i = 0; i < group1.length; i++) {
-      for (let j = i + 1; j < group1.length; j++) {
-        const dx = positions[group1[i]][0] - positions[group1[j]][0];
-        const dy = positions[group1[i]][1] - positions[group1[j]][1];
-        sum += Math.sqrt(dx * dx + dy * dy);
-        count++;
-      }
-    }
-    return count > 0 ? sum / count : 0;
-  } else {
-    // Between group distance
-    let sum = 0, count = 0;
-    for (const n1 of group1) {
-      for (const n2 of group2) {
-        const dx = positions[n1][0] - positions[n2][0];
-        const dy = positions[n1][1] - positions[n2][1];
-        sum += Math.sqrt(dx * dx + dy * dy);
-        count++;
-      }
-    }
-    return count > 0 ? sum / count : 0;
-  }
-}