Don't require the element to be provided to percolate_down! and percolate_up!

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
 <!-- links end -->
 
+[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]
 =====================
 

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"

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])

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"