Merge pull request JuliaCollections#538 from mortenpi/whitespace

Remove trailing whitespace and newlines

Author: oxinabox

Changelog.md

@@ -91,7 +91,7 @@ v0.4.2 / 2016-01-13
 ==================
 
   * Fix OrderedDict constructors (with tests)
-  * Add IntSet to DataStructures 
+  * Add IntSet to DataStructures
     (see #114, https://github.com/JuliaLang/julia/pull/10065)
   * Dead code, tree.jl removal
 
@@ -341,7 +341,7 @@ v0.2.5 / 2013-10-08
   * Revised implementation of Deque, without using Union(Nothing, DequeBlock).
   * Fixed the doc regarding API for heaps: binary_heap -> binary_{min|max}heap and mutable_binary_heap -> mutable_binary_{min|max}heap
   * Added 1 missing API call to the documentation
-  * Fixed bugs related to Dequeue functions front and back. 
+  * Fixed bugs related to Dequeue functions front and back.
     * Front would give garbage data when called on a newly created queue, and back when popping a queue from the front.
   * Implemented simple show method inside Dequeue to hide unnecessary (large!) implementation detail from the client, in particular when using REPL
 
@@ -374,4 +374,3 @@ v0.2.5 / 2013-10-08
   * add stack and queue (tested)
   * add Dequeue (tested)
   * Initial commit
-

benchmark/benchmarks.jl

@@ -108,4 +108,3 @@ SUITE["SparseIntSet"]["iterate two"] =
 
 SUITE["SparseIntSet"]["iterate two exclude one"] =
 	@benchmarkable iterate_two_exclude_one_bench(x,y,z) setup=x_y_z_setup
-

docs/src/heaps.md

@@ -55,7 +55,7 @@ h = MutableBinaryMaxHeap([1,4,3,2])    # create a mutable min/max heap from a ve
 ```
 
 ## Min-max heaps
-Min-max heaps maintain the minimum _and_ the maximum of a set, 
+Min-max heaps maintain the minimum _and_ the maximum of a set,
 allowing both to be retrieved in constant (`O(1)`) time.
 The min-max heaps in this package are subtypes of `AbstractMinMaxHeap <: AbstractHeap`
 and have the same interface as other heaps with the following additions:
@@ -73,7 +73,7 @@ popmax!(h, k)  # remove and return the largest k elements
 popall!(h)     # remove and return all the elements, sorted smallest to largest
 popall!(h, o)  # remove and return all the elements according to ordering o
 ```
-The usual `top(h)` and `pop!(h)` are defined to be `minimum(h)` and `popmin!(h)`, 
+The usual `top(h)` and `pop!(h)` are defined to be `minimum(h)` and `popmin!(h)`,
 respectively.
 
 This package includes an implementation of a binary min-max heap (`BinaryMinMaxHeap`).

docs/src/sorted_containers.md

@@ -452,7 +452,7 @@ end
 
 Here, `st1` and `st2` are semitokens that refer to the container `sc`.
 Token `(sc,st1)` may not be the before-start token and
-token `(sc,st2)` may not be the past-end token. 
+token `(sc,st2)` may not be the past-end token.
 It is acceptable for `(sc,st1)` to be the past-end token or `(sc,st2)`
 to be the before-start token or both (in these cases, the body is not executed).
 If `compare(sc,st1,st2)==1` then the body is not executed. A second
@@ -765,7 +765,7 @@ Lt((x,y) -> isless(lowercase(x),lowercase(y)))
 The ordering object is indicated in the above list of constructors in
 the `o` position (see above for constructor syntax).
 
-This approach may suffer from a performance hit because higher performance 
+This approach may suffer from a performance hit because higher performance
 may be possible if an equality method is also available as well as a
 less-than method.
 A more complicated but higher-performance method to implement

docs/src/sparse_int_set.md

@@ -1,8 +1,8 @@
 # DataStructures.SparseIntSet
 
 Implementation of a __Sparse Integer Set__, for background see [Sparse Sets](https://www.computist.xyz/2018/06/sparse-sets.html).
-Only positive non-zero `Int`s are allowed inside the set. 
+Only positive non-zero `Int`s are allowed inside the set.
 The idea is to have one **packed** `Vector` storing all the `Int`s contained in the set as to allow for fast iteration, and a sparse, paged **reverse** `Vector` with the position of a particular `Int` inside the **packed** `Vector`. This allows for very fast iteration, insertion and deletion of indices.
-Most behavior is similar to a normal `IntSet`, however `collect`, `first` and `last` are with respected to the **packed** vector, in which the ordering is not guaranteed. 
-The **reverse** `Vector` is paged, meaning that it is a `Vector{Vector{Int}}` where each of the `Vector{Int}`s has the length of one memory page of `Int`s. Every time an index that was not yet in the range of the already present pages, a new one will be created and added to the **reverse**, allowing for dynamical growth. 
-Popping the last `Int` of a particular page will automatically clean up the memory of that page. 
+Most behavior is similar to a normal `IntSet`, however `collect`, `first` and `last` are with respected to the **packed** vector, in which the ordering is not guaranteed.
+The **reverse** `Vector` is paged, meaning that it is a `Vector{Vector{Int}}` where each of the `Vector{Int}`s has the length of one memory page of `Int`s. Every time an index that was not yet in the range of the already present pages, a new one will be created and added to the **reverse**, allowing for dynamical growth.
+Popping the last `Int` of a particular page will automatically clean up the memory of that page.

src/circular_buffer.jl

@@ -1,8 +1,8 @@
 """
     CircularBuffer{T}(n)
 
-The CircularBuffer type implements a circular buffer of fixed capacity 
-where new items are pushed to the back of the list, overwriting values 
+The CircularBuffer type implements a circular buffer of fixed capacity
+where new items are pushed to the back of the list, overwriting values
 in a circular fashion.
 
 Allocate a buffer of elements of type `T` with maximum capacity `n`.
@@ -115,7 +115,7 @@ end
 """
     pushfirst!(cb, data)
 
-Insert one or more items at the beginning of CircularBuffer 
+Insert one or more items at the beginning of CircularBuffer
 and overwrite back if full.
 """
 function pushfirst!(cb::CircularBuffer, data)

src/container_loops.jl

@@ -258,20 +258,20 @@ onlysemitokens(ba::SAIterableTypesBase) = SAOnlySemiTokensIteration(ba)
 
 
 
-    
+
 function nexthelper(c::SAContainer, state::SAIterationState)
     sn = state.next
     (sn < 3 || !(sn in c.bt.useddatacells)) && throw(BoundsError())
     SAIterationState(nextloc0(c.bt, sn), state.final)
 end
 
 
-    
+
 getitem(::SDMIterableTypesBase, dt, sn) = dt.k => dt.d
 getitem(::SSIterableTypesBase, dt, sn) = dt.k
 getitem(::SDMKeyIteration, dt, sn) = dt.k
 getitem(::SDMValIteration, dt, sn) = dt.d
-getitem(::SDMSemiTokenIteration, dt, sn) = (IntSemiToken(sn), dt.k, dt.d) 
+getitem(::SDMSemiTokenIteration, dt, sn) = (IntSemiToken(sn), dt.k, dt.d)
 getitem(::SSSemiTokenIteration, dt, sn) = (IntSemiToken(sn), dt.k)
 getitem(::SDMSemiTokenKeyIteration, dt, sn) = (IntSemiToken(sn), dt.k)
 getitem(::SDMSemiTokenValIteration, dt, sn) = (IntSemiToken(sn), dt.d)

src/fenwick.jl

@@ -5,17 +5,17 @@ end
 
 """
     FenwickTree{T}(n)
-    
+
 Constructs a [`FenwickTree`](https://en.wikipedia.org/wiki/Fenwick_tree) of length `n`.
- 
+
 """
 FenwickTree{T}(n::Integer) where T = FenwickTree{T}(zeros(T, n), n)
 
 """
-    FenwickTree(counts::AbstractArray) 
-    
+    FenwickTree(counts::AbstractArray)
+
 Constructs a [`FenwickTree`](https://en.wikipedia.org/wiki/Fenwick_tree) from an array of `counts`
- 
+
 """
 function FenwickTree(a::AbstractVector{U}) where U
     n = length(a)
@@ -34,7 +34,7 @@ Base.eltype(::Type{FenwickTree{T}}) where T = T
 
 Increases the value of the [`FenwickTree`] by `val` from the index `ind` upto the length of the Fenwick Tree.
 
-""" 
+"""
 function inc!(ft::FenwickTree{T}, ind::Integer, val = 1) where T
     val0 = convert(T, val)
     i = ind
@@ -51,15 +51,15 @@ end
 
 Decreases the value of the [`FenwickTree`] by `val` from the index `ind` upto the length of the Fenwick Tree.
 
-""" 
+"""
 dec!(ft::FenwickTree, ind::Integer, val = 1 ) = inc!(ft, ind, -val)
 
 """
     incdec!(ft::FenwickTree{T}, left, right, val)
 
 Increases the value of the [`FenwickTree`] by `val` from the indices from `left` and decreases it from the `right`.
 
-"""    
+"""
 function incdec!(ft::FenwickTree{T}, left::Integer, right::Integer, val = one(T)) where T
     val0 = convert(T, val)
     inc!(ft, left, val0)
@@ -68,7 +68,7 @@ end
 
 """
     prefixsum(ft::FenwickTree{T}, ind)
-    
+
 Return the cumulative sum from index 1 upto `ind` of the [`FenwickTree`](@ref)
 
 # Examples
@@ -86,7 +86,7 @@ function prefixsum(ft::FenwickTree{T}, ind::Integer) where T
     i = ind
     n = ft.n
     @boundscheck 1 <= i <= n || throw(ArgumentError("$i should be in between 1 and $n"))
-    @inbounds while i > 0 
+    @inbounds while i > 0
         sum += ft.bi_tree[i]
         i -= i&(-i)
     end

src/heaps/minmax_heap.jl

@@ -6,9 +6,9 @@
 
 mutable struct BinaryMinMaxHeap{T} <: AbstractMinMaxHeap{T}
     valtree::Vector{T}
-    
+
     BinaryMinMaxHeap{T}() where {T} = new{T}(Vector{T}())
-    
+
     function BinaryMinMaxHeap(xs::AbstractVector{T}) where {T}
         valtree = _make_binary_minmax_heap(xs)
         new{T}(valtree)
@@ -41,7 +41,7 @@ function _minmax_heap_bubble_up!(A::AbstractVector, i::Integer)
             # bubble up min
             _minmax_heap_bubble_up!(A, i, Forward)
         end
-        
+
     else
         # max level
         if i > 1 && A[i] < A[hparent(i)]
@@ -55,7 +55,7 @@ function _minmax_heap_bubble_up!(A::AbstractVector, i::Integer)
             _minmax_heap_bubble_up!(A, i, Reverse)
         end
     end
-   return 
+   return
 end
 
 function _minmax_heap_bubble_up!(A::AbstractVector, i::Integer, o::Ordering, x=A[i])
@@ -67,7 +67,7 @@ function _minmax_heap_bubble_up!(A::AbstractVector, i::Integer, o::Ordering, x=A
             _minmax_heap_bubble_up!(A, gparent, o)
         end
     end
-    return          
+    return
 end
 
 function _minmax_heap_trickle_down!(A::AbstractVector, i::Integer)
@@ -80,7 +80,7 @@ function _minmax_heap_trickle_down!(A::AbstractVector, i::Integer)
 end
 
 function _minmax_heap_trickle_down!(A::AbstractVector, i::Integer, o::Ordering, x=A[i])
-                    
+
     if haschildren(i, A)
         # get the index of the extremum (min or max) descendant
         extremum = o === Forward ? minimum : maximum
@@ -106,7 +106,7 @@ function _minmax_heap_trickle_down!(A::AbstractVector, i::Integer, o::Ordering,
     end
     return
 end
-                    
+
 ################################################
 #
 # utilities
@@ -118,10 +118,10 @@ end
 @inline rchild(i) = 2*i+1
 @inline children(i) = (lchild(i), rchild(i))
 @inline hparent(i) = i ÷ 2
-@inline on_minlevel(i) = level(i) % 2 == 0 
+@inline on_minlevel(i) = level(i) % 2 == 0
 @inline haschildren(i, A) = lchild(i) ≤ length(A)
 @inline isgrandchild(j, i) = j > rchild(i)
-@inline hasgrandparent(i) = i ≥ 4 
+@inline hasgrandparent(i) = i ≥ 4
 
 """
     children_and_grandchildren(maxlen, i)
@@ -189,7 +189,7 @@ end
 
 """
     popmin!(h::BinaryMinMaxHeap) -> min
-                        
+
 Remove the minimum value from the heap.
 """
 function popmin!(h::BinaryMinMaxHeap)
@@ -204,19 +204,19 @@ function popmin!(h::BinaryMinMaxHeap)
     return x
 end
 
-                        
+
 """
     popmin!(h::BinaryMinMaxHeap, k::Integer) -> vals
-                        
+
 Remove up to the `k` smallest values from the heap.
 """
-@inline function popmin!(h::BinaryMinMaxHeap, k::Integer) 
+@inline function popmin!(h::BinaryMinMaxHeap, k::Integer)
     return [popmin!(h) for _ in 1:min(length(h), k)]
 end
 
 """
     popmax!(h::BinaryMinMaxHeap) -> max
-                        
+
 Remove the maximum value from the heap.
 """
 function popmax!(h::BinaryMinMaxHeap)
@@ -228,55 +228,54 @@ function popmax!(h::BinaryMinMaxHeap)
         @inbounds valtree[i] = y
         _minmax_heap_trickle_down!(valtree, i)
     end
-    return x    
+    return x
 end
 
 """
     popmax!(h::BinaryMinMaxHeap, k::Integer) -> vals
-                        
+
 Remove up to the `k` largest values from the heap.
 """
-@inline function popmax!(h::BinaryMinMaxHeap, k::Integer) 
-    return [popmax!(h) for _ in 1:min(length(h), k)]                    
+@inline function popmax!(h::BinaryMinMaxHeap, k::Integer)
+    return [popmax!(h) for _ in 1:min(length(h), k)]
 end
-                        
-                        
+
+
 function push!(h::BinaryMinMaxHeap, v)
-    valtree = h.valtree        
+    valtree = h.valtree
     push!(valtree, v)
     _minmax_heap_bubble_up!(valtree, length(valtree))
 end
 
 """
     top(h::BinaryMinMaxHeap)
-                        
+
 Get the top (minimum) of the heap.
 """
 @inline top(h::BinaryMinMaxHeap) = minimum(h)
 
-@inline function minimum(h::BinaryMinMaxHeap) 
+@inline function minimum(h::BinaryMinMaxHeap)
     valtree = h.valtree
     !isempty(h) || throw(ArgumentError("heap must be non-empty"))
     return @inbounds h.valtree[1]
 end
 
-@inline function maximum(h::BinaryMinMaxHeap) 
+@inline function maximum(h::BinaryMinMaxHeap)
     valtree = h.valtree
     !isempty(h) || throw(ArgumentError("heap must be non-empty"))
     return @inbounds maximum(valtree[1:min(end, 3)])
 end
-                        
+
 empty!(h::BinaryMinMaxHeap) = (empty!(h.valtree); h)
-                        
+
 
 """
     popall!(h::BinaryMinMaxHeap, ::Ordering = Forward)
-                        
+
 Remove and return all the elements of `h` according to
-the given ordering. Default is `Forward` (smallest to 
+the given ordering. Default is `Forward` (smallest to
 largest).
 """
 popall!(h::BinaryMinMaxHeap) = popall!(h, Forward)
 popall!(h::BinaryMinMaxHeap, ::ForwardOrdering) = popmin!(h, length(h))
 popall!(h::BinaryMinMaxHeap, ::ReverseOrdering) = popmax!(h, length(h))
-