@calcit/ternary-tree 0.0.23 → 0.0.25

package/lib/map.mjs

@@ -159,24 +159,21 @@ export function initTernaryTreeMap(t) {
 }
 // use for..in for performance
 export function initTernaryTreeMapFromArray(t) {
-    let groupBuffers = {};
+    // Use Map instead of Record for better performance with numeric keys
+    let groupBuffers = new Map();
     let xs = [];
-    for (let idx = 0; idx < t.length; idx++) {
+    const length = t.length;
+    for (let idx = 0; idx < length; idx++) {
         let k = t[idx][0];
         let v = t[idx][1];
         let h = hashGenerator(k);
-        if (groupBuffers[h] != null) {
-            let branch = groupBuffers[h];
-            if (branch != null) {
-                branch.push([k, v]);
-            }
-            else {
-                throw new Error("Expected referece to pairs");
-            }
+        let branch = groupBuffers.get(h);
+        if (branch != null) {
+            branch.push([k, v]);
         }
         else {
             let pairs = [[k, v]];
-            groupBuffers[h] = pairs;
+            groupBuffers.set(h, pairs);
             xs.push({
                 hash: h,
                 pairs: pairs,
@@ -285,11 +282,15 @@ function collectHashSortedArray(tree, acc, idx) {
     else {
         switch (tree.kind) {
             case TernaryTreeKind.ternaryTreeLeaf: {
-                for (let i = 0; i < tree.elements.length; i++) {
-                    let item = tree.elements[i];
-                    acc[idx.value] = item;
-                    idx.value = idx.value + 1;
+                // Cache elements and current index to reduce property access
+                const elements = tree.elements;
+                const length = elements.length;
+                let currentIdx = idx.value;
+                for (let i = 0; i < length; i++) {
+                    acc[currentIdx] = elements[i];
+                    currentIdx++;
                 }
+                idx.value = currentIdx;
                 break;
             }
             case TernaryTreeKind.ternaryTreeBranch: {
@@ -317,8 +318,10 @@ function collectOrderedHashEntries(tree, acc, idx) {
     else {
         switch (tree.kind) {
             case TernaryTreeKind.ternaryTreeLeaf: {
-                acc[idx.value] = { hash: tree.hash, pairs: tree.elements };
-                idx.value = idx.value + 1;
+                // Cache current index to reduce property access
+                const currentIdx = idx.value;
+                acc[currentIdx] = { hash: tree.hash, pairs: tree.elements };
+                idx.value = currentIdx + 1;
                 break;
             }
             case TernaryTreeKind.ternaryTreeBranch: {
@@ -344,85 +347,88 @@ export function contains(originalTree, item) {
     if (originalTree == null) {
         return false;
     }
-    // TODO
     // reduce redundant computation by reusing hash result
     let hx = hashGenerator(item);
     let tree = originalTree;
     whileLoop: while (tree != null) {
         if (tree.kind === TernaryTreeKind.ternaryTreeLeaf) {
             if (hx === tree.hash) {
-                let size = tree.elements.length;
+                // Cache elements length to avoid repeated property access
+                const elements = tree.elements;
+                const size = elements.length;
                 for (let idx = 0; idx < size; idx++) {
-                    let pair = tree.elements[idx];
-                    if (dataEqual(pair[0], item)) {
+                    if (dataEqual(elements[idx][0], item)) {
                         return true;
                     }
                 }
             }
             return false;
         }
-        // echo "looking for: ", hx, " ", item, " in ", tree.formatInline(true)
-        if (tree.left == null) {
+        // Optimize branch navigation with early exits
+        const left = tree.left;
+        if (left == null) {
             return false;
         }
-        if (tree.left.kind === TernaryTreeKind.ternaryTreeLeaf) {
-            if (hx < tree.left.hash) {
+        if (left.kind === TernaryTreeKind.ternaryTreeLeaf) {
+            if (hx < left.hash) {
                 return false;
             }
-            if (tree.left.hash === hx) {
-                tree = tree.left;
-                continue whileLoop; // notice, it jumps to while loop
+            if (left.hash === hx) {
+                tree = left;
+                continue whileLoop;
             }
         }
         else {
-            if (hx < tree.left.minHash) {
+            if (hx < left.minHash) {
                 return false;
             }
-            if (hx <= tree.left.maxHash) {
-                tree = tree.left;
-                continue whileLoop; // notice, it jumps to while loop
+            if (hx <= left.maxHash) {
+                tree = left;
+                continue whileLoop;
             }
         }
-        if (tree.middle == null) {
+        const middle = tree.middle;
+        if (middle == null) {
             return false;
         }
-        if (tree.middle.kind === TernaryTreeKind.ternaryTreeLeaf) {
-            if (hx < tree.middle.hash) {
+        if (middle.kind === TernaryTreeKind.ternaryTreeLeaf) {
+            if (hx < middle.hash) {
                 return false;
             }
-            if (tree.middle.hash === hx) {
-                tree = tree.middle;
-                continue whileLoop; // notice, it jumps to while loop
+            if (middle.hash === hx) {
+                tree = middle;
+                continue whileLoop;
             }
         }
         else {
-            if (hx < tree.middle.minHash) {
+            if (hx < middle.minHash) {
                 return false;
             }
-            if (hx <= tree.middle.maxHash) {
-                tree = tree.middle;
-                continue whileLoop; // notice, it jumps to while loop
+            if (hx <= middle.maxHash) {
+                tree = middle;
+                continue whileLoop;
             }
         }
-        if (tree.right == null) {
+        const right = tree.right;
+        if (right == null) {
             return false;
         }
-        if (tree.right.kind === TernaryTreeKind.ternaryTreeLeaf) {
-            if (hx < tree.right.hash) {
+        if (right.kind === TernaryTreeKind.ternaryTreeLeaf) {
+            if (hx < right.hash) {
                 return false;
             }
-            if (tree.right.hash === hx) {
-                tree = tree.right;
-                continue whileLoop; // notice, it jumps to while loop
+            if (right.hash === hx) {
+                tree = right;
+                continue whileLoop;
             }
         }
         else {
-            if (hx < tree.right.minHash) {
+            if (hx < right.minHash) {
                 return false;
             }
-            if (hx <= tree.right.maxHash) {
-                tree = tree.right;
-                continue whileLoop; // notice, it jumps to while loop
+            if (hx <= right.maxHash) {
+                tree = right;
+                continue whileLoop;
             }
         }
         return false;
@@ -434,77 +440,81 @@ export function mapGetDefault(originalTree, item, v0) {
     let tree = originalTree;
     whileLoop: while (tree != null) {
         if (tree.kind === TernaryTreeKind.ternaryTreeLeaf) {
-            let size = tree.elements.length;
+            // Cache elements array to avoid repeated property access
+            const elements = tree.elements;
+            const size = elements.length;
             for (let i = 0; i < size; i++) {
-                let pair = tree.elements[i];
-                if (dataEqual(pair[0], item)) {
-                    return pair[1];
+                if (dataEqual(elements[i][0], item)) {
+                    return elements[i][1];
                 }
             }
             return v0;
         }
-        // echo "looking for: ", hx, " ", item, " in ", tree.formatInline
-        if (tree.left == null) {
+        // Cache tree children to avoid repeated property access
+        const left = tree.left;
+        if (left == null) {
             return v0;
         }
-        if (tree.left.kind == TernaryTreeKind.ternaryTreeLeaf) {
-            if (hx < tree.left.hash) {
+        if (left.kind == TernaryTreeKind.ternaryTreeLeaf) {
+            if (hx < left.hash) {
                 return v0;
             }
-            if (tree.left.hash === hx) {
-                tree = tree.left;
-                continue whileLoop; // notice, it jumps to while loop
+            if (left.hash === hx) {
+                tree = left;
+                continue whileLoop;
             }
         }
         else {
-            if (hx < tree.left.minHash) {
+            if (hx < left.minHash) {
                 return v0;
             }
-            if (hx <= tree.left.maxHash) {
-                tree = tree.left;
-                continue whileLoop; // notice, it jumps to while loop
+            if (hx <= left.maxHash) {
+                tree = left;
+                continue whileLoop;
             }
         }
-        if (tree.middle == null) {
+        const middle = tree.middle;
+        if (middle == null) {
             return v0;
         }
-        if (tree.middle.kind == TernaryTreeKind.ternaryTreeLeaf) {
-            if (hx < tree.middle.hash) {
+        if (middle.kind == TernaryTreeKind.ternaryTreeLeaf) {
+            if (hx < middle.hash) {
                 return v0;
             }
-            if (tree.middle.hash === hx) {
-                tree = tree.middle;
-                continue whileLoop; // notice, it jumps to while loop
+            if (middle.hash === hx) {
+                tree = middle;
+                continue whileLoop;
             }
         }
         else {
-            if (hx < tree.middle.minHash) {
+            if (hx < middle.minHash) {
                 return v0;
             }
-            if (hx <= tree.middle.maxHash) {
-                tree = tree.middle;
-                continue whileLoop; // notice, it jumps to while loop
+            if (hx <= middle.maxHash) {
+                tree = middle;
+                continue whileLoop;
             }
         }
-        if (tree.right == null) {
+        const right = tree.right;
+        if (right == null) {
             return v0;
         }
-        if (tree.right.kind == TernaryTreeKind.ternaryTreeLeaf) {
-            if (hx < tree.right.hash) {
+        if (right.kind == TernaryTreeKind.ternaryTreeLeaf) {
+            if (hx < right.hash) {
                 return v0;
             }
-            if (tree.right.hash === hx) {
-                tree = tree.right;
-                continue whileLoop; // notice, it jumps to while loop
+            if (right.hash === hx) {
+                tree = right;
+                continue whileLoop;
             }
         }
         else {
-            if (hx < tree.right.minHash) {
+            if (hx < right.minHash) {
                 return v0;
             }
-            if (hx <= tree.right.maxHash) {
-                tree = tree.right;
-                continue whileLoop; // notice, it jumps to while loop
+            if (hx <= right.maxHash) {
+                tree = right;
+                continue whileLoop;
             }
         }
         return v0;
@@ -1025,28 +1035,38 @@ export function dissocMap(tree, key) {
 function collectToPairsArray(acc, tree) {
     if (tree != null) {
         if (tree.kind === TernaryTreeKind.ternaryTreeLeaf) {
-            for (let i = 0; i < tree.elements.length; i++) {
-                let pair = tree.elements[i];
-                acc.push(pair);
+            // Cache elements array and use batch push for better performance
+            const elements = tree.elements;
+            const length = elements.length;
+            for (let i = 0; i < length; i++) {
+                acc.push(elements[i]);
             }
         }
         else {
-            if (tree.left != null) {
-                collectToPairsArray(acc, tree.left);
+            // Cache children to avoid repeated property access
+            const left = tree.left;
+            const middle = tree.middle;
+            const right = tree.right;
+            if (left != null) {
+                collectToPairsArray(acc, left);
             }
-            if (tree.middle != null) {
-                collectToPairsArray(acc, tree.middle);
+            if (middle != null) {
+                collectToPairsArray(acc, middle);
             }
-            if (tree.right != null) {
-                collectToPairsArray(acc, tree.right);
+            if (right != null) {
+                collectToPairsArray(acc, right);
             }
         }
     }
 }
 /** similar to `toPairs`, but using Array.push directly */
 export function toPairsArray(tree) {
-    let result = [];
-    collectToPairsArray(result, tree);
+    // Pre-allocate array with known size for better performance
+    const totalSize = mapLen(tree);
+    let result = new Array(totalSize);
+    let idx = { value: 0 };
+    // Use the more efficient collectHashSortedArray instead
+    collectHashSortedArray(tree, result, idx);
     return result;
 }
 export function* toPairs(tree) {
@@ -1254,10 +1274,13 @@ export function mapMapValues(tree, f) {
     }
     switch (tree.kind) {
         case TernaryTreeKind.ternaryTreeLeaf: {
-            let newElements = new Array(tree.elements.length);
-            let size = tree.elements.length;
+            // Cache elements array and pre-allocate result
+            const elements = tree.elements;
+            const size = elements.length;
+            let newElements = new Array(size);
             for (let idx = 0; idx < size; idx++) {
-                newElements[idx] = [tree.elements[idx][0], f(tree.elements[idx][1])];
+                const element = elements[idx];
+                newElements[idx] = [element[0], f(element[1])];
             }
             let result = {
                 kind: TernaryTreeKind.ternaryTreeLeaf,

package/lib/test-list-detailed-perf.d.mts

@@ -0,0 +1 @@
+export declare function runDetailedListPerformanceTests(): void;

package/lib/test-list-detailed-perf.mjs

@@ -0,0 +1,165 @@
+import { initTernaryTreeList, initTernaryTreeListFromRange, listGet, assocList, insert, listLen, indexOf, listToItems, prepend, concat, slice, } from "./list.mjs";
+function createTestListData(size) {
+    const data = [];
+    for (let i = 0; i < size; i++) {
+        data.push(i);
+    }
+    return data;
+}
+function measureTime(name, fn) {
+    const start = performance.now();
+    const result = fn();
+    const end = performance.now();
+    const duration = end - start;
+    console.log(`${name}: ${duration.toFixed(2)}ms`);
+    return [result, duration];
+}
+function repeatTest(times, fn) {
+    let totalTime = 0;
+    for (let i = 0; i < times; i++) {
+        const start = performance.now();
+        fn();
+        const end = performance.now();
+        totalTime += end - start;
+    }
+    return totalTime / times;
+}
+export function runDetailedListPerformanceTests() {
+    console.log("\n=== Detailed List Performance Tests ===");
+    console.log("Testing various operations with different list sizes to show optimization benefits\n");
+    const sizes = [500, 2000, 8000, 16000];
+    for (const size of sizes) {
+        console.log(`\n--- Performance Analysis: ${size} elements ---`);
+        const testData = createTestListData(size);
+        // Test list creation - should benefit from reduced overhead
+        const [treeList, creationTime] = measureTime(`Create list (${size})`, () => {
+            return initTernaryTreeList(testData);
+        });
+        // Test range creation
+        measureTime(`Range init (${size})`, () => {
+            return initTernaryTreeListFromRange(testData, 0, size);
+        });
+        // Test random access patterns - benefits from cached size calculations
+        const accessCount = Math.min(1000, size);
+        const indices = Array.from({ length: accessCount }, () => Math.floor(Math.random() * size));
+        const avgAccessTime = repeatTest(3, () => {
+            for (const idx of indices) {
+                listGet(treeList, idx);
+            }
+        });
+        console.log(`Random access avg (${accessCount} ops): ${avgAccessTime.toFixed(2)}ms`);
+        // Test sequential access
+        const avgSeqTime = repeatTest(3, () => {
+            for (let i = 0; i < Math.min(size, 1000); i++) {
+                listGet(treeList, i);
+            }
+        });
+        console.log(`Sequential access avg (${Math.min(size, 1000)} ops): ${avgSeqTime.toFixed(2)}ms`);
+        // Test structural modifications - heavily benefits from cached calculations
+        const modCount = Math.min(100, size / 10);
+        const avgAssocTime = repeatTest(3, () => {
+            let list = treeList;
+            for (let i = 0; i < modCount; i++) {
+                const idx = Math.floor(Math.random() * size);
+                list = assocList(list, idx, idx * 2);
+            }
+            return list;
+        });
+        console.log(`Assoc operations avg (${modCount} ops): ${avgAssocTime.toFixed(2)}ms`);
+        // Test insertions
+        const insertCount = Math.min(50, size / 20);
+        const avgInsertTime = repeatTest(3, () => {
+            let list = treeList;
+            for (let i = 0; i < insertCount; i++) {
+                const idx = Math.min(Math.floor(Math.random() * (size + i)), listLen(list));
+                list = insert(list, idx, i + size);
+            }
+            return list;
+        });
+        console.log(`Insert operations avg (${insertCount} ops): ${avgInsertTime.toFixed(2)}ms`);
+        // Test search operations - benefits from cached property access
+        const searchCount = Math.min(100, size / 10);
+        const searchValues = testData.slice(0, searchCount);
+        const avgSearchTime = repeatTest(3, () => {
+            for (const value of searchValues) {
+                indexOf(treeList, value);
+            }
+        });
+        console.log(`Search operations avg (${searchCount} ops): ${avgSearchTime.toFixed(2)}ms`);
+        // Test slicing - benefits from cached size calculations
+        const sliceCount = Math.min(20, size / 50);
+        const avgSliceTime = repeatTest(3, () => {
+            for (let i = 0; i < sliceCount; i++) {
+                const start = Math.floor((Math.random() * size) / 2);
+                const end = start + Math.floor((Math.random() * size) / 4);
+                slice(treeList, start, Math.min(end, size));
+            }
+        });
+        console.log(`Slice operations avg (${sliceCount} ops): ${avgSliceTime.toFixed(2)}ms`);
+        // Iteration performance
+        const avgIterTime = repeatTest(3, () => {
+            let count = 0;
+            for (const item of listToItems(treeList)) {
+                count++;
+            }
+            return count;
+        });
+        console.log(`Iterator traversal avg (${size} items): ${avgIterTime.toFixed(2)}ms`);
+        // Complex operation chains - should show cumulative benefits
+        measureTime(`Complex chain (${Math.floor(size / 100)} ops)`, () => {
+            let list = treeList;
+            const ops = Math.floor(size / 100);
+            for (let i = 0; i < ops; i++) {
+                // Prepend
+                list = prepend(list, -i);
+                // Random assoc
+                if (listLen(list) > 10) {
+                    const idx = Math.floor(Math.random() * Math.min(listLen(list), 100));
+                    list = assocList(list, idx, i * 1000);
+                }
+                // Random access
+                if (listLen(list) > 5) {
+                    listGet(list, Math.floor(Math.random() * Math.min(listLen(list), 50)));
+                }
+            }
+            return list;
+        });
+        console.log("");
+    }
+    // Stress test for deep operations
+    console.log("=== Stress Tests ===");
+    const largeList = initTernaryTreeList(createTestListData(50000));
+    measureTime("Deep list access stress", () => {
+        const samples = 1000;
+        for (let i = 0; i < samples; i++) {
+            const idx = Math.floor(Math.random() * 50000);
+            listGet(largeList, idx);
+        }
+    });
+    measureTime("Deep list modification stress", () => {
+        let list = largeList;
+        for (let i = 0; i < 100; i++) {
+            const idx = Math.floor(Math.random() * listLen(list));
+            list = assocList(list, idx, i * 10000);
+        }
+        return list;
+    });
+    // Memory efficiency test
+    console.log("\n=== Memory Efficiency Tests ===");
+    measureTime("Large tree creation (100k)", () => {
+        return initTernaryTreeList(createTestListData(100000));
+    });
+    // Test concatenation performance
+    console.log("\n=== Concatenation Performance ===");
+    const list1 = initTernaryTreeList(createTestListData(5000));
+    const list2 = initTernaryTreeList(createTestListData(5000));
+    const list3 = initTernaryTreeList(createTestListData(5000));
+    const list4 = initTernaryTreeList(createTestListData(5000));
+    measureTime("Concat 4 large lists (5k each)", () => {
+        return concat(concat(concat(list1, list2), list3), list4);
+    });
+    console.log("\n✅ Performance testing completed!");
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runDetailedListPerformanceTests();
+}

package/lib/test-list-perf.d.mts

@@ -0,0 +1 @@
+export declare function runListPerformanceTests(): void;