diff --git a/CHANGELOG.md b/CHANGELOG.md index 496f4a1c..77c357a7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,13 @@ Starting from version 0.19.0, CHANGELOG.md is managed in a format that follows < [0.19.2]: https://github.com/JuliaCollections/DataStructures.jl/compare/v0.19.1...v0.19.2 +[0.19.3] +===================== + +## Fixed + +- Reintroduce a method for `percolate_up!` `percolate_down!` that doesn't require the element to be passed, which was unintentionally removed in 0.19.2 (JuliaCollections/DataStructures.jl#960). + [0.19.2] ===================== diff --git a/Project.toml b/Project.toml index 10108bc7..7f968035 100644 --- a/Project.toml +++ b/Project.toml @@ -1,6 +1,6 @@ name = "DataStructures" uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" -version = "0.19.2" +version = "0.19.3" [deps] OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" diff --git a/src/heaps/arrays_as_heaps.jl b/src/heaps/arrays_as_heaps.jl index c2e34625..1e53abfc 100644 --- a/src/heaps/arrays_as_heaps.jl +++ b/src/heaps/arrays_as_heaps.jl @@ -27,7 +27,7 @@ Base.@propagate_inbounds function percolate_down!(xs::AbstractArray, i::Integer, end @inbounds xs[i] = x end -Base.@propagate_inbounds percolate_down!(xs::AbstractArray, i::Integer, o::Ordering, len::Integer=length(xs)) = percolate_down!(xs, i, xs[i], o, len) +Base.@propagate_inbounds percolate_down!(xs::AbstractArray, i::Integer, o::Ordering=Forward, len::Integer=length(xs)) = percolate_down!(xs, i, xs[i], o, len) # Binary min-heap percolate up. @@ -41,7 +41,7 @@ Base.@propagate_inbounds function percolate_up!(xs::AbstractArray, i::Integer, x end @inbounds xs[i] = x end -Base.@propagate_inbounds percolate_up!(xs::AbstractArray, i::Integer, o::Ordering) = percolate_up!(xs, i, xs[i], o) +Base.@propagate_inbounds percolate_up!(xs::AbstractArray, i::Integer, o::Ordering=Forward) = percolate_up!(xs, i, xs[i], o) """ heappop!(v, [ord]) diff --git a/test/test_priority_queue.jl b/test/test_priority_queue.jl index 5094f18a..f5804e07 100644 --- a/test/test_priority_queue.jl +++ b/test/test_priority_queue.jl @@ -116,7 +116,7 @@ import Base.Order.Reverse Base.IteratorSize(i::EltypeUnknownIterator) = Base.IteratorSize(i.x) Base.length(i::EltypeUnknownIterator) = Base.length(i.x) Base.size(i::EltypeUnknownIterator) = Base.size(i.x) - + @test_nowarn PriorityQueue(Dict(zip(1:5, 2:6))) @test_nowarn PriorityQueue(EltypeUnknownIterator(Dict(zip(1:5, 2:6)))) @test_throws ArgumentError PriorityQueue(EltypeUnknownIterator(['a'])) @@ -133,7 +133,7 @@ import Base.Order.Reverse Base.IteratorSize(i::EltypeAnyIterator) = Base.IteratorSize(i.x) Base.length(i::EltypeAnyIterator) = Base.length(i.x) Base.size(i::EltypeAnyIterator) = Base.size(i.x) - + @test_nowarn PriorityQueue(EltypeAnyIterator(Dict(zip(1:5, 2:6)))) @test_throws ArgumentError PriorityQueue(EltypeAnyIterator(['a'])) end @@ -338,6 +338,89 @@ import Base.Order.Reverse @test isheap([1, 2, 3], Base.Order.Forward) @test !isheap([1, 2, 3], Base.Order.Reverse) end - end + @testset "percolate_down!" begin + @testset "Basic percolate down" begin + xs = [10, 2, 3, 4, 5] + DataStructures.percolate_down!(xs, 1, 10, Base.Order.Forward) + @test xs == [2, 4, 3, 10, 5] + end + + @testset "Element in correct position" begin + xs = [1, 2, 3, 4, 5] + DataStructures.percolate_down!(xs, 1, 1, Base.Order.Forward) + @test xs == [1, 2, 3, 4, 5] + end + + @testset "Reverse ordering" begin + xs = [1, 5, 4, 3, 2] + DataStructures.percolate_down!(xs, 1, 1, Base.Order.Reverse) + @test xs == [5, 3, 4, 1, 2] + end + + @testset "Custom length" begin + xs = [10, 2, 3, 4, 5] + DataStructures.percolate_down!(xs, 1, 10, Base.Order.Forward, 3) + @test xs == [2, 10, 3, 4, 5] + end + + @testset "Without explicit x parameter" begin + xs = [10, 2, 3, 4, 5] + DataStructures.percolate_down!(xs, 1, Base.Order.Forward) + @test xs == [2, 4, 3, 10, 5] + + xs = [10, 2, 3, 4, 5] + DataStructures.percolate_down!(xs, 1) + @test xs == [2, 4, 3, 10, 5] + end + + @testset "From middle position" begin + xs = [2, 0, 3, 4, 5] + DataStructures.percolate_down!(xs, 2, 10, Base.Order.Forward) + @test xs == [2, 4, 3, 10, 5] + end + end + + @testset "percolate_up!" begin + @testset "Basic percolate up" begin + xs = [1, 2, 3, 4, 0] + DataStructures.percolate_up!(xs, 5, 0, Base.Order.Forward) + @test xs == [0, 1, 3, 4, 2] + end + + @testset "Element in correct position" begin + xs = [1, 2, 3, 4, 5] + DataStructures.percolate_up!(xs, 5, 5, Base.Order.Forward) + @test xs == [1, 2, 3, 4, 5] + end + + @testset "Reverse ordering" begin + xs = [5, 4, 3, 2, 10] + DataStructures.percolate_up!(xs, 5, 10, Base.Order.Reverse) + @test xs == [10, 5, 3, 2, 4] + end + + @testset "Percolate to root" begin + xs = [2, 3, 4, 5, 1] + DataStructures.percolate_up!(xs, 5, 1, Base.Order.Forward) + @test xs == [1, 2, 4, 5, 3] + end + + @testset "Without explicit x parameter" begin + xs = [1, 2, 3, 4, 0] + DataStructures.percolate_up!(xs, 5, Base.Order.Forward) + @test xs == [0, 1, 3, 4, 2] + + xs = [1, 2, 3, 4, 0] + DataStructures.percolate_up!(xs, 5) + @test xs == [0, 1, 3, 4, 2] + end + + @testset "From middle position" begin + xs = [1, 5, 3, 10, 8] + DataStructures.percolate_up!(xs, 4, 0, Base.Order.Forward) + @test xs == [0, 1, 3, 5, 8] + end + end + end end # @testset "PriorityQueue"