@aiquants/virtualscroll 1.18.5 → 1.19.0

package/src/useFenwickMapTree.huge.spec.ts

@@ -0,0 +1,388 @@
+import { act, renderHook } from "@testing-library/react"
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest"
+import { FenwickMapTree, useFenwickMapTree } from "./useFenwickMapTree.ts"
+
+let warnSpy: ReturnType<typeof vi.spyOn> | undefined
+
+beforeAll(() => {
+    warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+})
+
+afterAll(() => {
+    warnSpy?.mockRestore()
+    warnSpy = undefined
+})
+
+const MAX_SAFE_BIG = BigInt(Number.MAX_SAFE_INTEGER)
+const EXACT_SIZE = Number.MAX_SAFE_INTEGER
+const SHRUNK_SIZE = Number(MAX_SAFE_BIG - 64n)
+const HEAD_INDEX = 0
+const SECOND_INDEX = 1
+const MID_INDEX = Number(MAX_SAFE_BIG - 512n)
+const BEFORE_MID_INDEX = MID_INDEX - 1
+const PRE_TAIL_INDEX = Number(MAX_SAFE_BIG - 8n)
+const BEFORE_PRE_TAIL_INDEX = PRE_TAIL_INDEX - 1
+const TAIL_INDEX = Number(MAX_SAFE_BIG - 1n)
+const BEFORE_TAIL_INDEX = TAIL_INDEX - 1
+const SAMPLE_RANGE_NEAR_TAIL = {
+    from: Number(MAX_SAFE_BIG - 16n),
+    to: TAIL_INDEX,
+}
+
+describe("FenwickMapTree (最大安全整数近傍)", () => {
+    it("最大安全整数サイズで基礎的な取得ができる", () => {
+        const tree = new FenwickMapTree(EXACT_SIZE, 0)
+
+        expect(tree.getSize()).toBe(EXACT_SIZE)
+        expect(tree.getTotal()).toBe(0)
+        expect(tree.get(HEAD_INDEX)).toBe(0)
+        expect(tree.get(TAIL_INDEX)).toBe(0)
+    })
+
+    it("最大安全整数サイズで複数インデックスを更新しても累積和が安全に計算できる", () => {
+        const tree = new FenwickMapTree(EXACT_SIZE, 0)
+
+        tree.update(HEAD_INDEX, 5)
+        tree.update(SECOND_INDEX, 3)
+        tree.update(MID_INDEX, 4)
+        tree.update(PRE_TAIL_INDEX, 7)
+        tree.update(TAIL_INDEX, 9)
+
+        expect(tree.prefixSum(HEAD_INDEX).cumulative).toBe(5)
+        expect(tree.prefixSum(SECOND_INDEX).cumulative).toBe(8)
+        expect(tree.prefixSum(MID_INDEX).cumulative).toBe(12)
+        expect(tree.prefixSum(PRE_TAIL_INDEX).cumulative).toBe(19)
+        expect(tree.prefixSum(TAIL_INDEX).cumulative).toBe(28)
+        expect(tree.getTotal()).toBe(28)
+    })
+
+    it("最大安全整数サイズで findIndexAtOrAfter が閾値に対応する", () => {
+        const tree = new FenwickMapTree(EXACT_SIZE, 0)
+
+        tree.update(HEAD_INDEX, 5)
+        tree.update(SECOND_INDEX, 3)
+        tree.update(MID_INDEX, 4)
+        tree.update(PRE_TAIL_INDEX, 7)
+        tree.update(TAIL_INDEX, 9)
+
+        expect(tree.findIndexAtOrAfter(1).index).toBe(HEAD_INDEX)
+        expect(tree.findIndexAtOrAfter(8).index).toBe(SECOND_INDEX)
+        expect(tree.findIndexAtOrAfter(12).index).toBe(MID_INDEX)
+        expect(tree.findIndexAtOrAfter(19).index).toBe(PRE_TAIL_INDEX)
+        expect(tree.findIndexAtOrAfter(28).index).toBe(TAIL_INDEX)
+        expect(tree.findIndexAtOrAfter(29).index).toBe(-1)
+    })
+
+    it("最大安全整数サイズで findIndexAtOrBefore が閾値に対応する", () => {
+        const tree = new FenwickMapTree(EXACT_SIZE, 0)
+
+        tree.update(HEAD_INDEX, 5)
+        tree.update(SECOND_INDEX, 3)
+        tree.update(MID_INDEX, 4)
+        tree.update(PRE_TAIL_INDEX, 7)
+        tree.update(TAIL_INDEX, 9)
+
+        expect(tree.findIndexAtOrBefore(4).index).toBe(-1)
+        expect(tree.findIndexAtOrBefore(5).index).toBe(HEAD_INDEX)
+        expect(tree.findIndexAtOrBefore(8).index).toBe(BEFORE_MID_INDEX)
+        expect(tree.findIndexAtOrBefore(12).index).toBe(BEFORE_PRE_TAIL_INDEX)
+        expect(tree.findIndexAtOrBefore(19).index).toBe(BEFORE_TAIL_INDEX)
+        expect(tree.findIndexAtOrBefore(28).index).toBe(TAIL_INDEX)
+    })
+
+    it("巨大サイズで updates がまとめて適用される", () => {
+        const tree = new FenwickMapTree(EXACT_SIZE, 0)
+
+        tree.updates([
+            { index: HEAD_INDEX, value: 6 },
+            { index: MID_INDEX, value: 4 },
+            { index: TAIL_INDEX, value: 8 },
+        ])
+
+        expect(tree.get(HEAD_INDEX)).toBe(6)
+        expect(tree.prefixSum(MID_INDEX).cumulative).toBe(10)
+        expect(tree.prefixSum(TAIL_INDEX).cumulative).toBe(18)
+        expect(tree.getTotal()).toBe(18)
+    })
+
+    it("巨大サイズで updateDelta が差分を加算できる", () => {
+        const tree = new FenwickMapTree(EXACT_SIZE, 0)
+
+        tree.updateDelta(TAIL_INDEX, 5)
+        tree.updateDelta(TAIL_INDEX, 3)
+        tree.updateDelta(HEAD_INDEX, 4)
+
+        expect(tree.get(TAIL_INDEX)).toBe(8)
+        expect(tree.prefixSum(TAIL_INDEX).cumulative).toBe(12)
+        expect(tree.getTotal()).toBe(12)
+    })
+
+    it("巨大サイズで changeSize を縮小すると範囲外デルタが除去される", () => {
+        const tree = new FenwickMapTree(EXACT_SIZE, 0)
+
+        tree.update(HEAD_INDEX, 5)
+        tree.update(TAIL_INDEX, 9)
+
+        tree.changeSize(SHRUNK_SIZE)
+
+        expect(tree.getSize()).toBe(SHRUNK_SIZE)
+        expect(() => tree.get(TAIL_INDEX)).toThrow()
+        expect(tree.getTotal()).toBe(5)
+    })
+
+    it("巨大サイズで changeSize を拡大した後でも更新ができる", () => {
+        const tree = new FenwickMapTree(SHRUNK_SIZE, 0)
+
+        tree.update(HEAD_INDEX, 5)
+
+        tree.changeSize(EXACT_SIZE)
+        tree.update(TAIL_INDEX, 11)
+
+        expect(tree.getSize()).toBe(EXACT_SIZE)
+        expect(tree.get(TAIL_INDEX)).toBe(11)
+        expect(tree.prefixSum(TAIL_INDEX).cumulative).toBe(16)
+    })
+
+    it("巨大サイズで rebuildTree を呼んでも合計値が維持される", () => {
+        const tree = new FenwickMapTree(EXACT_SIZE, 0)
+
+        tree.update(HEAD_INDEX, 5)
+        tree.update(PRE_TAIL_INDEX, 7)
+
+        tree.rebuildTree()
+
+        expect(tree.get(HEAD_INDEX)).toBe(5)
+        expect(tree.get(PRE_TAIL_INDEX)).toBe(7)
+        expect(tree.getTotal()).toBe(12)
+    })
+
+    it("巨大サイズで valueFn による遅延具現化が機能する", () => {
+        const tree = new FenwickMapTree(
+            EXACT_SIZE,
+            (index) => {
+                if (index === HEAD_INDEX) {
+                    return 4
+                }
+                if (index === TAIL_INDEX) {
+                    return 6
+                }
+                return 0
+            },
+            { sampleRange: { from: 0, to: 16 }, materialize: false },
+        )
+
+        const head = tree.get(HEAD_INDEX, { materializeOption: { materialize: true } })
+        const tail = tree.get(TAIL_INDEX, { materializeOption: { materialize: true, ranges: [SAMPLE_RANGE_NEAR_TAIL] } })
+        const total = tree.getTotal({ materializeOption: { materialize: true, ranges: [SAMPLE_RANGE_NEAR_TAIL] } })
+
+        expect(head).toBe(4)
+        expect(tail).toBe(6)
+        expect(total).toBe(10)
+    })
+
+    it("巨大サイズの +1 末尾追記でも delta と total が正確 (回帰: r3 監査所見)", () => {
+        const tree = new FenwickMapTree(SHRUNK_SIZE, 0)
+        tree.update(HEAD_INDEX, 5)
+        tree.update(SHRUNK_SIZE - 1, 7)
+
+        tree.changeSize(SHRUNK_SIZE + 1)
+
+        expect(tree.getSize()).toBe(SHRUNK_SIZE + 1)
+        expect(tree.getTotal()).toBe(12)
+        expect(tree.prefixSum(SHRUNK_SIZE).cumulative).toBe(12)
+        expect(tree.get(SHRUNK_SIZE)).toBe(0)
+    })
+
+    it("巨大サイズ (bigint 探索パス) の findIndexAtOrAfter は materialize:true でも契約を満たし連続呼び出しで安定する (回帰: r3 監査所見)", () => {
+        // size >= 2^30 で _findIndexLarge (bigint 二分探索) に委譲されるパスの検証
+        const size = 0x80000000 // 2^31
+        const valueFn = (index: number) => (index === 500 ? 10 : 100)
+        const tree = new FenwickMapTree(size, valueFn, { sampleRange: { from: 0, to: 99 }, materialize: true })
+        const opts = { materializeOption: { materialize: true, ranges: [{ from: 0, to: 99 }] } }
+
+        const first = tree.findIndexAtOrAfter(50100, opts)
+        const second = tree.findIndexAtOrAfter(50100, opts)
+
+        // AtOrAfter 契約: cumulative は target 以上
+        expect(first.cumulative).toBeGreaterThanOrEqual(50100)
+        // 同一引数の連続呼び出しは同一結果 (探索後の木変異によるドリフトがない)
+        expect(second.index).toBe(first.index)
+        expect(second.cumulative).toBe(first.cumulative)
+    })
+
+    it("巨大サイズ (bigint 探索パス) の未発見時は小サイズパスと同一契約で cumulative などが undefined になる (回帰: r4 監査所見)", () => {
+        // 旧実装は bestResult ?? lastResult のフォールバックにより、未発見 (index=-1) でも
+        // 最後にプローブした位置の cumulative/currentValue/safeIndex が載っていた
+        // (AtOrBefore の未発見時は cumulative > target という契約矛盾の値になる)。
+        const size = 0x40000000 // 2^30 (bigint 探索パスの下限)
+        const tree = new FenwickMapTree(size, 10)
+
+        // AtOrAfter: total を超える target は未発見
+        const after = tree.findIndexAtOrAfter(Number.MAX_SAFE_INTEGER)
+        expect(after.index).toBe(-1)
+        expect(after.cumulative).toBeUndefined()
+        expect(after.currentValue).toBeUndefined()
+        expect(after.safeIndex).toBeUndefined()
+
+        // AtOrBefore: どの累積和よりも小さい target は未発見
+        const before = tree.findIndexAtOrBefore(-1)
+        expect(before.index).toBe(-1)
+        expect(before.cumulative).toBeUndefined()
+        expect(before.currentValue).toBeUndefined()
+        expect(before.safeIndex).toBeUndefined()
+
+        // 小サイズパスと同一契約であることの対照確認
+        const small = new FenwickMapTree(1000, 10)
+        const smallAfter = small.findIndexAtOrAfter(Number.MAX_SAFE_INTEGER)
+        expect(smallAfter.index).toBe(-1)
+        expect(smallAfter.cumulative).toBeUndefined()
+        expect(smallAfter.safeIndex).toBeUndefined()
+    })
+
+    it("巨大サイズで materialize 範囲を指定して prefixSum が反映される", () => {
+        const tree = new FenwickMapTree(
+            EXACT_SIZE,
+            (index) => {
+                if (index === PRE_TAIL_INDEX) {
+                    return 7
+                }
+                if (index === TAIL_INDEX) {
+                    return 5
+                }
+                return 0
+            },
+            { sampleRange: SAMPLE_RANGE_NEAR_TAIL, materialize: false },
+        )
+
+        const prefix = tree.prefixSum(TAIL_INDEX, { materializeOption: { materialize: true, ranges: [SAMPLE_RANGE_NEAR_TAIL] } })
+
+        expect(prefix.currentValue).toBe(5)
+        expect(prefix.cumulative).toBe(12)
+        expect(prefix.total).toBe(12)
+    })
+})
+
+describe("useFenwickMapTree (最大安全整数近傍)", () => {
+    it("最大安全整数サイズで同一パラメーターならインスタンスが安定する", () => {
+        const { result, rerender } = renderHook<FenwickMapTree, { size: number; value: number | ((index: number) => number) }>(({ size, value }) => useFenwickMapTree(size, value), {
+            initialProps: { size: EXACT_SIZE, value: 0 },
+        })
+
+        const first = result.current
+
+        rerender({ size: EXACT_SIZE, value: 0 })
+
+        expect(result.current).toBe(first)
+    })
+
+    it("最大安全整数サイズでサイズが変わっても同じインスタンスになる（安定性保証）", () => {
+        const { result, rerender } = renderHook<FenwickMapTree, { size: number; value: number | ((index: number) => number) }>(({ size, value }) => useFenwickMapTree(size, value), {
+            initialProps: { size: EXACT_SIZE, value: 0 },
+        })
+
+        const first = result.current
+
+        rerender({ size: SHRUNK_SIZE, value: 0 })
+
+        expect(result.current).toBe(first)
+    })
+
+    it("最大安全整数サイズで valueFn が変わっても同じインスタンスになる（安定性保証）", () => {
+        const { result, rerender } = renderHook<FenwickMapTree, { size: number; value: number | ((index: number) => number) }>(({ size, value }) => useFenwickMapTree(size, value), {
+            initialProps: { size: EXACT_SIZE, value: 0 },
+        })
+
+        const first = result.current
+
+        rerender({
+            size: EXACT_SIZE,
+            value: (index: number) => {
+                if (index === HEAD_INDEX) {
+                    return 2
+                }
+                return 0
+            },
+        })
+
+        expect(result.current).toBe(first)
+    })
+
+    it("最大安全整数サイズで返却されたツリーが更新を反映する", () => {
+        const { result } = renderHook(() => useFenwickMapTree(EXACT_SIZE, 0))
+
+        act(() => {
+            result.current.update(HEAD_INDEX, 5)
+            result.current.update(TAIL_INDEX, 9)
+        })
+
+        expect(result.current.get(HEAD_INDEX)).toBe(5)
+        expect(result.current.get(TAIL_INDEX)).toBe(9)
+        expect(result.current.prefixSum(TAIL_INDEX).cumulative).toBe(14)
+    })
+})
+
+describe("FenwickMapTree (100 Billion items & 1 Trillion items)", () => {
+    const HUNDRED_BILLION = 100_000_000_000
+
+    it("works without infinite loop for 100 Billion items", () => {
+        // Initialize with default item size 20
+        const tree = new FenwickMapTree(HUNDRED_BILLION, 20)
+
+        // This operation triggers _findIndex or _findIndexLarge
+        // Before fix: loop around 2^31 -> hang
+        // After fix: uses _findIndexLarge -> success
+
+        // Target 1000.
+        // Index 49: cumulative = (49+1)*20 = 1000. 1000 >= 1000. Found.
+        const targetOffset = 20 * 50
+        const result = tree.findIndexAtOrAfter(targetOffset)
+
+        expect(result.index).toBe(49)
+        expect(result.cumulative).toBe(targetOffset)
+    })
+
+    it("works for size just related to bitwise boundary (3 Billion)", () => {
+        const THREE_BILLION = 3_000_000_000
+        const tree = new FenwickMapTree(THREE_BILLION, 10)
+        // 10 * 60 = 600.
+        // Index 59: (59+1)*10 = 600.
+        const result = tree.findIndexAtOrAfter(10 * 60)
+        expect(result.index).toBe(59)
+    })
+
+    it("(a) does not hang at the 2^30 bitwise-doubling boundary", () => {
+        // size = 2^30 はビット倍加ループが Int32 オーバーフローする中間域。
+        // 修正前: bit << 1 が -2^31 に化けて無限ループ (タイムアウト)。
+        const tree = new FenwickMapTree(0x40000000, 10) // 2^30 = 1,073,741,824
+        // index 9: cumulative = (9+1)*10 = 100 >= 100
+        const result = tree.findIndexAtOrAfter(100)
+        expect(result.index).toBe(9)
+        expect(result.cumulative).toBe(100)
+    })
+
+    it("(a) does not hang for sizes in [2^30, 2^31-1] (max 32-bit signed)", () => {
+        const tree = new FenwickMapTree(0x7fffffff, 10) // 2^31 - 1 = 2,147,483,647
+        const result = tree.findIndexAtOrAfter(100)
+        expect(result.index).toBe(9)
+        expect(result.cumulative).toBe(100)
+
+        const before = tree.findIndexAtOrBefore(100)
+        expect(before.index).toBe(9)
+    })
+
+    it("works for 1 Trillion items (1,000,000,000,000)", () => {
+        const TRILLION = 1_000_000_000_000
+        // Need to ensure total height fits in safe integer.
+        // MAX safe integer ~9 Quadrillion.
+        // 1 Trillion * 25 = 25 Trillion on safe side.
+        const itemSize = 25
+        const tree = new FenwickMapTree(TRILLION, itemSize)
+
+        const indexToFind = 500_000_000_000 // 500 Billion
+        const targetOffset = itemSize * (indexToFind + 1)
+        const result = tree.findIndexAtOrAfter(targetOffset)
+
+        expect(result.index).toBe(indexToFind)
+        expect(result.cumulative).toBe(targetOffset)
+    })
+})