Implement complete Fenwick tree with correct signatures and comprehensive tests

Rescued from queen-3589, which also carried another bee's commits. Only the paths this issue declared were taken.

Closes #3589

Author: Trinity Bee

specs/tri/trees/fenwick_tree.t27

@@ -20,67 +20,205 @@ module TriFenwick;
     // 3. Core Functions
     // ═══════════════════════════════════════════════════════════
 
-    // init(allocator: std.mem.Allocator) → void
-    fn init(allocator: std.mem.Allocator) -> void {
-        // TODO: Implement from .tri spec
+    fn lowest_bit(i: usize) -> usize {
+        return i & (~i + 1);  // i & (-i) kept inside usize
     }
 
-    // build(allocator: std.mem.Allocator) → void
-    fn build(allocator: std.mem.Allocator) -> void {
-        // TODO: Implement from .tri spec
+    // init(allocator: std.mem.Allocator, size: usize) → FenwickTree
+    fn init(allocator: std.mem.Allocator, size: usize) -> FenwickTree {
+        const data = allocator.alloc(i64, size + 1);
+        var i: usize = 0;
+        while (i < size + 1) : (i += 1) {
+            data[i] = 0;
+        }
+        return FenwickTree{ .data = data, .size = size, .allocator = allocator };
     }
 
-    // query(tree: *FenwickTree) → void
-    fn query(tree: *FenwickTree) -> void {
-        // TODO: Implement from .tri spec
+    // build(allocator: std.mem.Allocator, values: []const i64) → FenwickTree
+    fn build(allocator: std.mem.Allocator, values: []const i64) -> FenwickTree {
+        var tree = init(allocator, values.len);
+        var i: usize = 0;
+        while (i < values.len) : (i += 1) {
+            tree.data[i + 1] = values[i];
+        }
+        var j: usize = 1;
+        while (j <= tree.size) : (j += 1) {
+            const parent = j + lowest_bit(j);
+            if (parent <= tree.size) {
+                tree.data[parent] = tree.data[parent] + tree.data[j];
+            }
+        }
+        return tree;
     }
 
-    // range_query(tree: *FenwickTree) → void
-    fn range_query(tree: *FenwickTree) -> void {
-        // TODO: Implement from .tri spec
+    // query(tree: *FenwickTree, index: usize) → i64
+    fn query(tree: *FenwickTree, index: usize) -> i64 {
+        if (index >= tree.size) {
+            return 0;
+        }
+        var i: usize = index + 1;
+        var sum: i64 = 0;
+        while (i > 0) : (i -= lowest_bit(i)) {
+            sum = sum + tree.data[i];
+        }
+        return sum;
     }
 
-    // update(tree: *FenwickTree) → void
-    fn update(tree: *FenwickTree) -> void {
-        // TODO: Implement from .tri spec
+    // range_query(tree: *FenwickTree, from: usize, to: usize) → i64
+    fn range_query(tree: *FenwickTree, from: usize, to: usize) -> i64 {
+        if (from > to || to >= tree.size) {
+            return 0;
+        }
+        if (from == 0) {
+            return query(tree, to);
+        }
+        return query(tree, to) - query(tree, from - 1);
+    }
+
+    // update(tree: *FenwickTree, index: usize, delta: i64) → void
+    fn update(tree: *FenwickTree, index: usize, delta: i64) -> void {
+        if (index >= tree.size) {
+            return;
+        }
+        var i: usize = index + 1;
+        while (i <= tree.size) : (i += lowest_bit(i)) {
+            tree.data[i] = tree.data[i] + delta;
+        }
     }
 
     // deinit(tree: *FenwickTree) → void
     fn deinit(tree: *FenwickTree) -> void {
-        // TODO: Implement from .tri spec
+        tree.allocator.free(tree.data);
+        tree.data = &[_]i64{};
+        tree.size = 0;
     }
 
     // ═══════════════════════════════════════════════════════════
     // TDD: Tests (from .tri behaviors)
     // ═══════════════════════════════════════════════════════════
 
-    test init_basic_case
-        given input = default_input()
-        when result = init(input)
-        then result != undefined
+    test "lowest_bit_isolates_the_low_set_bit" {
+        assert(lowest_bit(1) == 1);
+        assert(lowest_bit(6) == 2);
+        assert(lowest_bit(8) == 8);
+        assert(lowest_bit(12) == 4);
+    }
+
+    test "init_allocates_size_plus_one_slots_all_zero" {
+        var tree = init(std.heap.page_allocator, 5);
+        assert(tree.data.len == 6);
+        assert(tree.size == 5);
+        assert(tree.data[0] == 0);
+        assert(tree.data[1] == 0);
+        assert(tree.data[2] == 0);
+        assert(tree.data[3] == 0);
+        assert(tree.data[4] == 0);
+        assert(tree.data[5] == 0);
+        deinit(&tree);
+    }
+
+    test "the_sentinel_slot_stays_zero_after_build" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        assert(tree.data[0] == 0);
+        deinit(&tree);
+    }
 
-    test build_basic_case
-        given input = default_input()
-        when result = build(input)
-        then result != undefined
+    test "build_fills_the_tree_array_with_the_expected_partial_sums" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        assert(tree.data.len == 9);
+        assert(tree.data[0] == 0);
+        assert(tree.data[1] == 3);
+        assert(tree.data[2] == 5);
+        assert(tree.data[3] == -1);
+        assert(tree.data[4] == 10);
+        assert(tree.data[5] == 5);
+        assert(tree.data[6] == 9);
+        assert(tree.data[7] == -3);
+        assert(tree.data[8] == 19);
+        deinit(&tree);
+    }
 
-    test query_basic_case
-        given input = default_input()
-        when result = query(input)
-        then result != undefined
+    test "query_returns_the_inclusive_prefix_sum" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        assert(query(&tree, 0) == 3);
+        assert(query(&tree, 4) == 15);
+        assert(query(&tree, 7) == 19);
+        deinit(&tree);
+    }
 
-    test range_query_basic_case
-        given input = default_input()
-        when result = range_query(input)
-        then result != undefined
+    test "query_at_index_zero_returns_the_first_element" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        assert(query(&tree, 0) == 3);
+        deinit(&tree);
+    }
 
-    test update_basic_case
-        given input = default_input()
-        when result = update(input)
-        then result != undefined
+    test "query_past_the_last_index_returns_zero" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        assert(query(&tree, 8) == 0);
+        assert(query(&tree, 100) == 0);
+        deinit(&tree);
+    }
 
-    test deinit_basic_case
-        given input = default_input()
-        when result = deinit(input)
-        then result != undefined
+    test "range_query_is_inclusive_at_both_ends" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        assert(range_query(&tree, 2, 5) == 14);
+        deinit(&tree);
+    }
 
+    test "range_query_from_zero_equals_query" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        assert(range_query(&tree, 0, 4) == query(&tree, 4));
+        assert(range_query(&tree, 0, 7) == query(&tree, 7));
+        deinit(&tree);
+    }
+
+    test "range_query_with_from_greater_than_to_returns_zero" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        assert(range_query(&tree, 5, 2) == 0);
+        assert(range_query(&tree, 7, 3) == 0);
+        deinit(&tree);
+    }
+
+    test "update_touches_three_slots_and_moves_every_prefix_past_it" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        update(&tree, 2, 4);
+        assert(tree.data[3] == 3);
+        assert(tree.data[4] == 14);
+        assert(tree.data[8] == 23);
+        assert(tree.data[5] == 5);
+        assert(query(&tree, 4) == 19);
+        deinit(&tree);
+    }
+
+    test "update_past_the_last_index_changes_nothing" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        const old_data = tree.data[8];
+        update(&tree, 8, 10);
+        assert(tree.data[8] == old_data);
+        deinit(&tree);
+    }
+
+    test "deinit_leaves_an_empty_tree_and_is_idempotent" {
+        var tree = build(std.heap.page_allocator, &[_]i64{ 3, 2, -1, 6, 5, 4, -3, 3 });
+        deinit(&tree);
+        assert(tree.data.len == 0);
+        assert(tree.size == 0);
+        // Second deinit should be harmless
+        deinit(&tree);
+        assert(tree.data.len == 0);
+        assert(tree.size == 0);
+    }
+
+    test "a_zero_sized_tree_answers_zero_to_everything" {
+        var tree = init(std.heap.page_allocator, 0);
+        assert(tree.data.len == 1);
+        assert(tree.size == 0);
+        assert(query(&tree, 0) == 0);
+        assert(query(&tree, 100) == 0);
+        assert(range_query(&tree, 0, 0) == 0);
+        assert(range_query(&tree, 0, 100) == 0);
+        assert(range_query(&tree, 100, 200) == 0);
+        update(&tree, 0, 10);
+        assert(query(&tree, 0) == 0);
+        deinit(&tree);
+    }