@genome-spy/core 0.48.1 → 0.48.2

package/dist/src/utils/inertia.js

@@ -37,6 +37,10 @@ export default class Inertia {
     }
 
     cancel() {
+        if (this.lastValue === this.targetValue) {
+            return;
+        }
+
         // decelelerate rapidly
         this.targetValue = lerp([this.lastValue, this.targetValue], 0.3);
         this.smoother({ x: this.targetValue });

package/dist/src/utils/iterateNestedMaps.d.ts

@@ -3,9 +3,10 @@
  *
  * Yields arrays that contain the compound key and the grouped data items.
  *
- * @param {Map<any, any>} map The root
+ * @param {Map<any, T>} map The root
  * @param {any[]} [path] The path so far.
- * @returns {Generator<[any[], any[]]>}
+ * @returns {Generator<[any[], T]>}
+ * @template T
  */
-export default function iterateNestedMaps(map: Map<any, any>, path?: any[]): Generator<[any[], any[]]>;
+export default function iterateNestedMaps<T>(map: Map<any, T>, path?: any[]): Generator<[any[], T], any, any>;
 //# sourceMappingURL=iterateNestedMaps.d.ts.map

package/dist/src/utils/iterateNestedMaps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iterateNestedMaps.d.ts","sourceRoot":"","sources":["../../../src/utils/iterateNestedMaps.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,+CAJW,IAAI,GAAG,EAAE,GAAG,CAAC,SACb,GAAG,EAAE,GACH,UAAU,CAAC,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,CAarC"}
+{"version":3,"file":"iterateNestedMaps.d.ts","sourceRoot":"","sources":["../../../src/utils/iterateNestedMaps.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,sEAJW,GAAG,EAAE,mCAef"}

package/dist/src/utils/iterateNestedMaps.js

@@ -3,9 +3,10 @@
  *
  * Yields arrays that contain the compound key and the grouped data items.
  *
- * @param {Map<any, any>} map The root
+ * @param {Map<any, T>} map The root
  * @param {any[]} [path] The path so far.
- * @returns {Generator<[any[], any[]]>}
+ * @returns {Generator<[any[], T]>}
+ * @template T
  */
 export default function* iterateNestedMaps(map, path = []) {
     for (const [key, value] of map.entries()) {

package/dist/src/utils/radixSort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {number[]} arr An array of unsigned integers
+ */
+export default function radixSort(arr: number[]): number[];
+/**
+ * @param {number[]} arr An array of unsigned integers
+ */
+export function radixSortIntoLookupArray(arr: number[]): number[];
+//# sourceMappingURL=radixSort.d.ts.map

package/dist/src/utils/radixSort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radixSort.d.ts","sourceRoot":"","sources":["../../../src/utils/radixSort.js"],"names":[],"mappings":"AAKA;;GAEG;AACH,uCAFW,MAAM,EAAE,YAyDlB;AAaD;;GAEG;AACH,8CAFW,MAAM,EAAE,YAoDlB"}

package/dist/src/utils/radixSort.js

@@ -0,0 +1,130 @@
+const MAX_INTEGER = 2147483647;
+const MAX_INTEGER_DIGIT = getDigits([MAX_INTEGER]);
+
+// TODO: Optimize more! Some ideas: https://travisdowns.github.io/blog/2019/05/22/sorting.html
+
+/**
+ * @param {number[]} arr An array of unsigned integers
+ */
+export default function radixSort(arr) {
+    const maxDigits = getDigits(arr);
+
+    let buffer = new Array(arr.length);
+    let bufferPtr = buffer;
+    const counts = new Array(16);
+
+    for (let digitIndex = 0; digitIndex < maxDigits; digitIndex++) {
+        counts.fill(0);
+
+        const shift = digitIndex * 4;
+        const pow = Math.pow(16, digitIndex);
+
+        /**
+         * @param {*} i number
+         */
+        // eslint-disable-next-line no-loop-func
+        const getDigit = (/** @type {number} */ i) => {
+            const value = arr[i];
+
+            // Need hacks for large numbers because JS bitwise operators only work
+            // with 32-bit integers.
+            // TODO: This could be implemented in WASM for better performance as
+            // it would be able to use 64-bit integers.
+            if (digitIndex >= MAX_INTEGER_DIGIT) {
+                if (value > MAX_INTEGER) {
+                    return Math.floor(value / pow) % 16;
+                } else {
+                    return 0;
+                }
+            } else {
+                return (value >> shift) & 0xf;
+            }
+        };
+
+        // Count occurrences of each digit
+        for (let i = 0, n = arr.length; i < n; i++) {
+            counts[getDigit(i)]++;
+        }
+
+        // Prefix sum to get starting indexes
+        for (let i = 1; i < 16; i++) {
+            counts[i] += counts[i - 1];
+        }
+
+        // Sort based on current digit
+        for (let i = arr.length - 1; i >= 0; i--) {
+            bufferPtr[--counts[getDigit(i)]] = arr[i];
+        }
+
+        // Swap buffer and arr for next iteration
+        [arr, bufferPtr] = [bufferPtr, arr];
+    }
+
+    return arr;
+}
+
+/**
+ * @param {number[]} arr An array of unsigned integers
+ */
+function getDigits(arr) {
+    let max = 0;
+    for (let i = 0, n = arr.length; i < n; i++) {
+        max = Math.max(max, arr[i]);
+    }
+    return Math.floor(Math.log2(max) / 4) + 1;
+}
+
+/**
+ * @param {number[]} arr An array of unsigned integers
+ */
+export function radixSortIntoLookupArray(arr) {
+    const maxDigits = getDigits(arr);
+    let indexes = Array.from({ length: arr.length }, (_, i) => i);
+    let buffer = new Array(arr.length);
+    const counts = new Array(16);
+
+    for (let digitIndex = 0; digitIndex < maxDigits; digitIndex++) {
+        counts.fill(0);
+
+        const shift = digitIndex * 4;
+        const pow = Math.pow(16, digitIndex);
+
+        /**
+         * @param {*} i number
+         */
+        // eslint-disable-next-line no-loop-func
+        const getDigit = (i) => {
+            const value = arr[indexes[i]]; // Use index to access array value
+
+            if (digitIndex >= MAX_INTEGER_DIGIT) {
+                if (value > MAX_INTEGER) {
+                    return Math.floor(value / pow) % 16;
+                } else {
+                    return 0;
+                }
+            } else {
+                return (value >> shift) & 0xf;
+            }
+        };
+
+        // Count occurrences of each digit
+        for (let i = 0; i < arr.length; i++) {
+            counts[getDigit(i)]++;
+        }
+
+        // Prefix sum to get starting indexes
+        for (let i = 1; i < 16; i++) {
+            counts[i] += counts[i - 1];
+        }
+
+        // Sort indexes based on current digit
+        for (let i = arr.length - 1; i >= 0; i--) {
+            buffer[--counts[getDigit(i)]] = indexes[i];
+        }
+
+        // Swap buffer and indexes for next iteration
+        [indexes, buffer] = [buffer, indexes];
+    }
+
+    return indexes; // Return the sorted index array
+}

package/dist/src/utils/radixSort.test.js

@@ -0,0 +1,51 @@
+import { expect, test } from "vitest";
+import radixSort, { radixSortIntoLookupArray } from "./radixSort.js";
+
+/**
+ * Checks that numbers in an array are in ascending order.
+
+ * @param {number[]} arr An array of unsigned integers
+ */
+function isSorted(arr) {
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i - 1] > arr[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Generates a random array of unsigned integers.
+ *
+ * @param {number} length
+ */
+function generateArray(length) {
+    const arr = new Array(length);
+
+    for (let i = 0; i < length; i++) {
+        arr[i] = Math.floor(Math.random() * 10_000_000_000);
+    }
+
+    return arr;
+}
+
+test("Radix Sort correctly sorts numbers", () => {
+    expect(isSorted(radixSort([1, 2, 3]))).toBeTruthy();
+    expect(isSorted(radixSort([3, 2, 1]))).toBeTruthy();
+    expect(isSorted(radixSort([123, 1234567, 12, 1, 1234]))).toBeTruthy();
+    expect(isSorted(radixSort(generateArray(1_000_000)))).toBeTruthy();
+});
+
+test("Lookup", () => {
+    expect(radixSortIntoLookupArray([1, 2, 3])).toEqual([0, 1, 2]);
+    expect(radixSortIntoLookupArray([3, 2, 1])).toEqual([2, 1, 0]);
+    expect(radixSortIntoLookupArray([10000, 100, 1000, 10, 1])).toEqual([
+        4, 3, 1, 2, 0,
+    ]);
+
+    const arr = generateArray(1_000_000);
+    const lookup = radixSortIntoLookupArray(arr);
+    expect(isSorted(arr.map((_, i) => arr[lookup[i]]))).toBeTruthy();
+});

package/package.json

@@ -7,7 +7,7 @@
   },
   "contributors": [],
   "license": "MIT",
-  "version": "0.48.1",
+  "version": "0.48.2",
   "jsdelivr": "dist/bundle/index.js",
   "unpkg": "dist/bundle/index.js",
   "browser": "dist/bundle/index.js",
@@ -64,5 +64,5 @@
     "vega-scale": "^7.3.1",
     "vega-util": "^1.17.2"
   },
-  "gitHead": "f2e023ce43cf18091cb81140f5be1f59887271df"
+  "gitHead": "f2817f82263b92e453356083f2d770b8b236f77a"
 }