@graphty/layout 1.2.8 → 1.3.2

package/src/utils/random.ts

@@ -3,51 +3,68 @@
  * Maintains exact same functionality as original implementation
  */
 
+/**
+ * A deterministic random number generator based on a linear congruential generator (LCG) algorithm.
+ * Provides consistent random sequences when initialized with the same seed.
+ */
 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;
-  }
+    private seed: number;
+    private m: number;
+    private a: number;
+    private c: number;
+    private _state: number;
 
-  rand(shape: number | number[] | null = null): number | number[] | number[][] {
-    if (shape === null) {
-      return this._next();
+    /**
+     * Creates a new random number generator instance.
+     * @param seed - Initial seed value for the generator. If not provided, uses a random seed.
+     */
+    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;
     }
 
-    if (typeof shape === 'number') {
-      const result: number[] = [];
-      for (let i = 0; i < shape; i++) {
-        result.push(this._next());
-      }
-      return result;
+    /**
+     * Generates the next random number in the sequence.
+     * @returns A random number between 0 and 1.
+     */
+    _next(): number {
+        this._state = (this.a * this._state + this.c) % this.m;
+        return this._state / this.m;
     }
 
-    if (shape.length === 1) {
-      const result: number[] = [];
-      for (let i = 0; i < shape[0]; i++) {
-        result.push(this._next());
-      }
-      return result;
-    }
+    /**
+     * Generates random numbers according to the specified shape.
+     * @param shape - Determines the output format: null for single number, number for 1D array, array for multi-dimensional array.
+     * @returns A random number, 1D array, or multi-dimensional array depending on the shape parameter.
+     */
+    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)));
+        const result: any[] = [];
+        for (let i = 0; i < shape[0]; i++) {
+            result.push(this.rand(shape.slice(1)));
+        }
+        return result;
     }
-    return result;
-  }
-}
+}

package/src/utils/rescale.ts

@@ -2,211 +2,206 @@
  * Layout rescaling utilities
  */
 
-import { PositionMap } from '../types';
+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[] | null = null
+    pos: PositionMap | number[][],
+    scale: number = 1,
+    center: number[] | null = null,
 ): 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;
-
-  // Fix Bug #1: Default center should match dimensionality
-  if (!center) {
-    center = Array(dim).fill(0);
-  }
-  
-  // Use the maximum dimension between positions and center
-  const targetDim = Math.max(dim, center.length);
-
-  // Calculate center of positions, handling NaN values (Bug #3)
-  const posCenter = Array(dim).fill(0);
-  const counts = Array(dim).fill(0);
-  
-  for (const p of posValues) {
-    for (let i = 0; i < dim; i++) {
-      if (!isNaN(p[i])) {
-        posCenter[i] += p[i];
-        counts[i]++;
-      }
-    }
-  }
-  
-  // Average by actual count, not total length
-  for (let i = 0; i < dim; i++) {
-    posCenter[i] = counts[i] > 0 ? posCenter[i] / counts[i] : 0;
-  }
-
-  // Center positions
-  let centeredPos: PositionMap | number[][] = {};
-  if (Array.isArray(pos)) {
-    centeredPos = pos.map(p => {
-      const centered = Array(targetDim).fill(0);
-      for (let i = 0; i < targetDim; i++) {
-        centered[i] = (i < p.length ? p[i] : 0) - (i < posCenter.length ? posCenter[i] : 0);
-      }
-      return centered;
-    });
-  } else {
-    for (const [node, p] of Object.entries(pos)) {
-      const centered = Array(targetDim).fill(0);
-      for (let i = 0; i < targetDim; i++) {
-        centered[i] = (i < p.length ? p[i] : 0) - (i < posCenter.length ? posCenter[i] : 0);
-      }
-      (centeredPos as PositionMap)[node] = centered;
-    }
-  }
-
-  // Find maximum distance from center, handling NaN values (Bug #3)
-  let maxDistance = 0;
-  const centeredValues = Array.isArray(centeredPos) ? centeredPos : Object.values(centeredPos);
-  for (const p of centeredValues) {
-    // Calculate distance, treating NaN as 0 for distance calculation
-    let sumSquares = 0;
-    for (const val of p) {
-      if (!isNaN(val)) {
-        sumSquares += val * val;
-      }
+    // Check if pos is empty
+    if (Array.isArray(pos)) {
+        if (pos.length === 0) {return [];}
+    } else {
+        if (Object.keys(pos).length === 0) {return {};}
     }
-    const distance = Math.sqrt(sumSquares);
-    if (!isNaN(distance)) {
-      maxDistance = Math.max(maxDistance, distance);
+
+    // Extract position values
+    const posValues: number[][] = Array.isArray(pos) ? pos : Object.values(pos);
+    const dim = posValues[0].length;
+
+    // Fix Bug #1: Default center should match dimensionality
+    if (!center) {
+        center = Array(dim).fill(0);
     }
-  }
 
-  // Rescale
-  let scaledPos: PositionMap | number[][] = Array.isArray(pos) ? [] : {};
+    // Use the maximum dimension between positions and center
+    const targetDim = Math.max(dim, center.length);
+
+    // Calculate center of positions, handling NaN values (Bug #3)
+    const posCenter = Array(dim).fill(0);
+    const counts = Array(dim).fill(0);
 
-  if (maxDistance > 0) {
-    const scaleFactor = scale / maxDistance;
+    for (const p of posValues) {
+        for (let i = 0; i < dim; i++) {
+            if (!isNaN(p[i])) {
+                posCenter[i] += p[i];
+                counts[i]++;
+            }
+        }
+    }
+
+    // Average by actual count, not total length
+    for (let i = 0; i < dim; i++) {
+        posCenter[i] = counts[i] > 0 ? posCenter[i] / counts[i] : 0;
+    }
 
+    // Center positions
+    let centeredPos: PositionMap | number[][] = {};
     if (Array.isArray(pos)) {
-      (scaledPos as number[][]) = (centeredPos as number[][]).map((p, idx) =>
-        p.map((val, i) => {
-          // Check if this dimension existed in the original position
-          const origPos = pos[idx];
-          if (i >= origPos.length) {
-            // This dimension was added, use center value
-            return center![i];
-          }
-          // Preserve NaN values (Bug #3)
-          if (isNaN(val)) return NaN;
-          return val * scaleFactor + center![i];
-        })
-      );
-    } else {
-      for (const [node, p] of Object.entries(centeredPos as PositionMap)) {
-        const origPos = pos[node];
-        (scaledPos as PositionMap)[node] = p.map((val, i) => {
-          // Check if this dimension existed in the original position
-          if (i >= origPos.length) {
-            // This dimension was added, use center value
-            return center![i];
-          }
-          // Preserve NaN values (Bug #3)
-          if (isNaN(val)) return NaN;
-          return val * scaleFactor + center![i];
+        centeredPos = pos.map((p) => {
+            const centered = Array(targetDim).fill(0);
+            for (let i = 0; i < targetDim; i++) {
+                centered[i] = (i < p.length ? p[i] : 0) - (i < posCenter.length ? posCenter[i] : 0);
+            }
+            return centered;
         });
-      }
+    } else {
+        for (const [node, p] of Object.entries(pos)) {
+            const centered = Array(targetDim).fill(0);
+            for (let i = 0; i < targetDim; i++) {
+                centered[i] = (i < p.length ? p[i] : 0) - (i < posCenter.length ? posCenter[i] : 0);
+            }
+            (centeredPos)[node] = centered;
+        }
     }
-  } else {
-    // All nodes at the same position - extend to target dimensionality
-    if (Array.isArray(pos)) {
-      (scaledPos as number[][]) = pos.map(p => {
-        const result = Array(targetDim);
-        for (let i = 0; i < targetDim; i++) {
-          if (i < p.length) {
-            result[i] = isNaN(p[i]) ? NaN : center![i];
-          } else {
-            result[i] = center![i];
-          }
+
+    // Find maximum distance from center, handling NaN values (Bug #3)
+    let maxDistance = 0;
+    const centeredValues = Array.isArray(centeredPos) ? centeredPos : Object.values(centeredPos);
+    for (const p of centeredValues) {
+        // Calculate distance, treating NaN as 0 for distance calculation
+        let sumSquares = 0;
+        for (const val of p) {
+            if (!isNaN(val)) {
+                sumSquares += val * val;
+            }
+        }
+        const distance = Math.sqrt(sumSquares);
+        if (!isNaN(distance)) {
+            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, idx) =>
+                p.map((val, i) => {
+                    // Check if this dimension existed in the original position
+                    const origPos = pos[idx];
+                    if (i >= origPos.length) {
+                        // This dimension was added, use center value
+                        return center[i];
+                    }
+                    // Preserve NaN values (Bug #3)
+                    if (isNaN(val)) {return NaN;}
+                    return val * scaleFactor + center[i];
+                }),
+            );
+        } else {
+            for (const [node, p] of Object.entries(centeredPos as PositionMap)) {
+                const origPos = pos[node];
+                (scaledPos as PositionMap)[node] = p.map((val, i) => {
+                    // Check if this dimension existed in the original position
+                    if (i >= origPos.length) {
+                        // This dimension was added, use center value
+                        return center[i];
+                    }
+                    // Preserve NaN values (Bug #3)
+                    if (isNaN(val)) {return NaN;}
+                    return val * scaleFactor + center[i];
+                });
+            }
         }
-        return result;
-      });
     } else {
-      for (const [node, p] of Object.entries(pos)) {
-        const result = Array(targetDim);
-        for (let i = 0; i < targetDim; i++) {
-          if (i < p.length) {
-            result[i] = isNaN(p[i]) ? NaN : center![i];
-          } else {
-            result[i] = center![i];
-          }
+        // All nodes at the same position - extend to target dimensionality
+        if (Array.isArray(pos)) {
+            (scaledPos as number[][]) = pos.map((p) => {
+                const result = Array(targetDim);
+                for (let i = 0; i < targetDim; i++) {
+                    if (i < p.length) {
+                        result[i] = isNaN(p[i]) ? NaN : center[i];
+                    } else {
+                        result[i] = center[i];
+                    }
+                }
+                return result;
+            });
+        } else {
+            for (const [node, p] of Object.entries(pos)) {
+                const result = Array(targetDim);
+                for (let i = 0; i < targetDim; i++) {
+                    if (i < p.length) {
+                        result[i] = isNaN(p[i]) ? NaN : center[i];
+                    } else {
+                        result[i] = center[i];
+                    }
+                }
+                (scaledPos as PositionMap)[node] = result;
+            }
         }
-        (scaledPos as PositionMap)[node] = result;
-      }
     }
-  }
 
-  return scaledPos;
+    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);
+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]);
     }
-  } else {
-    // All points at the center
-    for (const node of Object.keys(centeredPos)) {
-      scaledPos[node] = Array(centeredPos[node].length).fill(0);
+
+    // 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);
     }
-  }
 
-  return scaledPos;
-}
+    // 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;
+}