updates to prefix search and its keyed versions

Author: adolgert

src/prefixsearch/binarytreeprefixsearch.jl

@@ -200,9 +200,7 @@ Random.rand(rng::AbstractRNG, d::Random.SamplerTrivial{BinaryTreePrefixSearch{T}
     choose(d[], rand(rng, Uniform{T}(zero(T), d[].array[1])))
 
 
-Base.haskey(md::BinaryTreePrefixSearch, clock) = false
-
-function Base.haskey(pst::BinaryTreePrefixSearch{T}, clock::Int) where {T}
+function Base.haskey(pst::BinaryTreePrefixSearch{T}, clock::Integer) where {T}
     if 0 < clock ≤ length(pst)
         return getindex(pst, clock) > zero(T)
     else

test/test_keyedprefixsearch.jl

@@ -85,3 +85,94 @@ end
     keyed_scan = CompetingClocks.KeyedKeepPrefixSearch{String,typeof(prefix_tree)}(prefix_tree)
     scan_gymnasium(keyed_scan)
 end
+
+@safetestset keyedkeep_copy = "KeyedKeepPrefixSearch copy!" begin
+    using CompetingClocks
+
+    prefix_src = CompetingClocks.BinaryTreePrefixSearch{Float64}()
+    src = CompetingClocks.KeyedKeepPrefixSearch{String,typeof(prefix_src)}(prefix_src)
+    src["a"] = 1.0
+    src["b"] = 2.0
+    src["c"] = 3.0
+
+    prefix_dst = CompetingClocks.BinaryTreePrefixSearch{Float64}()
+    dst = CompetingClocks.KeyedKeepPrefixSearch{String,typeof(prefix_dst)}(prefix_dst)
+    dst["x"] = 0.0
+    dst["y"] = 0.0
+    dst["z"] = 0.0
+
+    copy!(dst, src)
+
+    @test dst["a"] == 1.0
+    @test dst["b"] == 2.0
+    @test dst["c"] == 3.0
+    @test length(dst) == 3
+end
+
+@safetestset keyedkeep_key_type = "KeyedKeepPrefixSearch key_type" begin
+    using CompetingClocks
+    using CompetingClocks: key_type
+
+    prefix = CompetingClocks.BinaryTreePrefixSearch{Float64}()
+    kp_string = CompetingClocks.KeyedKeepPrefixSearch{String,typeof(prefix)}(prefix)
+    @test key_type(kp_string) == String
+
+    prefix2 = CompetingClocks.BinaryTreePrefixSearch{Float64}()
+    kp_int = CompetingClocks.KeyedKeepPrefixSearch{Int,typeof(prefix2)}(prefix2)
+    @test key_type(kp_int) == Int
+end
+
+@safetestset keyedkeep_prefixenabled = "PrefixEnabled in and eltype" begin
+    using CompetingClocks
+    using CompetingClocks: enabled, isenabled
+
+    prefix = CompetingClocks.BinaryTreePrefixSearch{Float64}()
+    kp = CompetingClocks.KeyedKeepPrefixSearch{String,typeof(prefix)}(prefix)
+    kp["a"] = 1.0
+    kp["b"] = 0.0  # disabled (zero)
+    kp["c"] = 3.0
+
+    en = enabled(kp)
+
+    # Test `in` for PrefixEnabled
+    @test "a" in en
+    @test !("b" in en)  # zero value means not enabled
+    @test "c" in en
+    @test !("d" in en)  # not present
+
+    # Test eltype
+    @test eltype(typeof(en)) == String
+end
+
+@safetestset keyedremoval_key_time_type = "KeyedRemovalPrefixSearch key_type and time_type" begin
+    using CompetingClocks
+    using CompetingClocks: key_type, time_type
+
+    prefix = CompetingClocks.BinaryTreePrefixSearch{Float64}()
+    kp = CompetingClocks.KeyedRemovalPrefixSearch{String,typeof(prefix)}(prefix)
+
+    @test key_type(kp) == String
+    @test time_type(kp) == Float64
+end
+
+@safetestset keyedremoval_update_existing = "KeyedRemovalPrefixSearch update existing clock" begin
+    using CompetingClocks
+
+    prefix = CompetingClocks.BinaryTreePrefixSearch{Float64}()
+    kp = CompetingClocks.KeyedRemovalPrefixSearch{String,typeof(prefix)}(prefix)
+
+    # Add initial values
+    kp["a"] = 1.0
+    kp["b"] = 2.0
+
+    @test kp["a"] == 1.0
+    @test kp["b"] == 2.0
+
+    # Update existing clock (not delete and re-add, just update)
+    kp["a"] = 5.0
+    kp["b"] = 6.0
+
+    @test kp["a"] == 5.0
+    @test kp["b"] == 6.0
+    @test length(kp) == 2
+end

test/test_prefixsearch.jl

@@ -44,6 +44,58 @@ end
     end
 end
 
+@safetestset cumsumprefix_copy = "cumsum prefix copy!" begin
+    using CompetingClocks: CumSumPrefixSearch
+
+    src = CumSumPrefixSearch{Float64}()
+    for v in [1.0, 2.0, 3.0]
+        push!(src, v)
+    end
+    sum!(src)  # populate cumulant
+
+    dst = CumSumPrefixSearch{Float64}()
+    for v in [0.0, 0.0, 0.0]
+        push!(dst, v)
+    end
+
+    copy!(dst, src)
+
+    @test dst.array == src.array
+    @test dst.cumulant == src.cumulant
+    @test dst.dirty == src.dirty
+    @test length(dst) == length(src)
+end
+
+@safetestset cumsumprefix_time_type = "cumsum prefix time_type instance" begin
+    using CompetingClocks: CumSumPrefixSearch, time_type
+
+    ps_float = CumSumPrefixSearch{Float64}()
+    @test time_type(ps_float) == Float64
+
+    ps_float32 = CumSumPrefixSearch{Float32}()
+    @test time_type(ps_float32) == Float32
+end
+
+@safetestset cumsumprefix_isenabled = "cumsum prefix isenabled" begin
+    using CompetingClocks: CumSumPrefixSearch, isenabled
+
+    ps = CumSumPrefixSearch{Float64}()
+    push!(ps, 1.0)
+    push!(ps, 0.0)  # zero value
+    push!(ps, 3.0)
+
+    # Enabled clocks (positive value)
+    @test isenabled(ps, 1) == true
+    @test isenabled(ps, 3) == true
+
+    # Disabled clock (zero value)
+    @test isenabled(ps, 2) == false
+
+    # Out of bounds
+    @test isenabled(ps, 0) == false
+    @test isenabled(ps, 4) == false
+    @test isenabled(ps, -1) == false
+end
 
 @safetestset prefixsearch_structure = "test structure" begin
     using CompetingClocks: _btps_sizes
@@ -249,3 +301,76 @@ end
     @test length(btps1) == 0
     @test allocated(btps1) == Int(2^ceil(log2(cnt-1)))
 end
+
+@safetestset prefixsearch_time_type = "time_type instance method" begin
+    using CompetingClocks: BinaryTreePrefixSearch, time_type
+
+    btps_float = BinaryTreePrefixSearch{Float64}(4)
+    @test time_type(btps_float) == Float64
+
+    btps_int = BinaryTreePrefixSearch{Int64}(4)
+    @test time_type(btps_int) == Int64
+end
+
+@safetestset prefixsearch_choose_error = "choose errors on invalid value" begin
+    using CompetingClocks: BinaryTreePrefixSearch, choose, sum!
+
+    btps = BinaryTreePrefixSearch{Float64}(4)
+    push!(btps, 1.0)
+    push!(btps, 2.0)
+    push!(btps, 3.0)
+
+    total = sum!(btps)
+    @test total == 6.0
+
+    # Value equal to total should error
+    @test_throws ErrorException choose(btps, 6.0)
+
+    # Value greater than total should error
+    @test_throws ErrorException choose(btps, 7.0)
+end
+
+@safetestset prefixsearch_haskey = "haskey methods" begin
+    using CompetingClocks: BinaryTreePrefixSearch
+
+    btps = BinaryTreePrefixSearch{Float64}(4)
+    push!(btps, 1.0)
+    push!(btps, 0.0)  # zero value
+    push!(btps, 3.0)
+
+    # haskey with Int clock - positive value exists
+    @test haskey(btps, 1) == true
+    @test haskey(btps, 3) == true
+
+    # haskey with Int clock - zero value does not count as "has"
+    @test haskey(btps, 2) == false
+
+    # haskey with Int clock - out of bounds
+    @test haskey(btps, 0) == false
+    @test haskey(btps, 4) == false
+    @test haskey(btps, -1) == false
+
+    # haskey works with any Integer type
+    @test haskey(btps, Int32(1)) == true
+    @test haskey(btps, UInt(3)) == true
+end
+
+@safetestset prefixsearch_rand_sampler = "rand with SamplerTrivial" begin
+    using Random
+    using CompetingClocks: BinaryTreePrefixSearch
+
+    btps = BinaryTreePrefixSearch{Float64}(4)
+    push!(btps, 1.0)
+    push!(btps, 2.0)
+    push!(btps, 3.0)
+    push!(btps, 4.0)
+
+    rng = Xoshiro(12345)
+
+    # Sample multiple times and verify results are valid
+    for _ in 1:100
+        idx, remainder = rand(rng, btps)
+        @test 1 <= idx <= 4
+        @test remainder >= 0.0
+    end
+end

test/test_setofsets.jl

@@ -195,3 +195,41 @@ end
     @test !("baz" in sos)
     @test length(sos) == 4
 end
+
+@safetestset setofsets_union_two_sos = "SetOfSets union of two SetOfSets" begin
+    using CompetingClocks: SetOfSets
+
+    a = Set([1, 2])
+    b = Set([3, 4])
+    sos1 = SetOfSets([a, b])
+
+    c = Set([5, 6])
+    d = Set([7, 8])
+    sos2 = SetOfSets([c, d])
+
+    # Union of two SetOfSets
+    result = union(sos1, sos2)
+    @test result isa SetOfSets
+    @test Set(collect(result)) == Set(1:8)
+    @test length(result) == 8
+end
+
+@safetestset setofsets_isempty_method = "SetOfSets isempty" begin
+    using CompetingClocks: SetOfSets
+
+    # Non-empty SetOfSets
+    a = Set([1, 2])
+    b = Set([3, 4])
+    sos = SetOfSets([a, b])
+    @test !isempty(sos)
+
+    # Empty SetOfSets (no subsets)
+    empty_sos = SetOfSets(Set{Int}[])
+    @test isempty(empty_sos)
+
+    # SetOfSets with only empty subsets
+    empty_a = Set{Int}()
+    empty_b = Set{Int}()
+    sos_empty_subsets = SetOfSets([empty_a, empty_b])
+    @test isempty(sos_empty_subsets)
+end