Rename dropna() to dropnull() but keep it

Author: nalimilan

src/DataArrays.jl

@@ -26,6 +26,7 @@ module DataArrays
            DataArray,
            DataMatrix,
            DataVector,
+           dropnull,
            EachFailNull,
            EachDropNull,
            EachReplaceNull,

src/abstractdataarray.jl

@@ -49,26 +49,26 @@ true
 Base.isnull(a::AbstractArray{T}, i::Real) where {T} = Null <: T ? isa(a[i], Null) : false # -> Bool
 
 """
-    dropna(v::AbstractVector) -> AbstractVector
+    dropnull(v::AbstractVector) -> AbstractVector
 
 Return a copy of `v` with all `null` elements removed.
 
 # Examples
 
 ```jldoctest
-julia> dropna(@data [null, 1, null, 2])
+julia> dropnull(@data [null, 1, null, 2])
 2-element Array{Int64,1}:
  1
  2
 
-julia> dropna([4, 5, 6])
+julia> dropnull([4, 5, 6])
 3-element Array{Int64,1}:
  4
  5
  6
 ```
 """
-dropna(v::AbstractVector) = copy(v) # -> AbstractVector
+dropnull(v::AbstractVector) = copy(v) # -> AbstractVector
 
 # Iterators
 # TODO: Use values()

src/dataarray.jl

@@ -242,7 +242,7 @@ function Base.convert{T, N}(::Type{Array}, da::DataArray{T, N}, replacement::Any
     return convert(Array{T, N}, da, replacement)
 end
 
-dropna(dv::DataVector) = dv.data[.!dv.na] # -> Vector
+dropnull(dv::DataVector) = dv.data[.!dv.na] # -> Vector
 
 Base.any(::typeof(isnull), da::DataArray) = any(da.na) # -> Bool
 Base.all(::typeof(isnull), da::DataArray) = all(da.na) # -> Bool

src/deprecated.jl

@@ -77,7 +77,7 @@ end
 @deprecate_binding NAtype Null
 @deprecate_binding NA null
 @deprecate isna isnull
-@deprecate dropna(x) collect(Nulls.drop(x))
+@deprecate dropna dropnull
 @deprecate padna padnull
 @deprecate each_failna Nulls.fail
 @deprecate each_dropna Nulls.skip
@@ -89,4 +89,3 @@ import SpecialFunctions: digamma, erf, erfc
 @deprecate digamma(x::Null) isnull(x) ? null : SpecialFunctions.digamma(x)
 @deprecate erf(x::Null) isnull(x) ? null : SpecialFunctions.erf(x)
 @deprecate erfc(x::Null) isnull(x) ? null : SpecialFunctions.erfc(x)
-

src/pooleddataarray.jl

@@ -372,7 +372,7 @@ function PooledDataArray(x::PooledDataArray{S,R,N},
 end
 
 myunique(x::AbstractVector) = unique(x)
-myunique(x::AbstractDataVector) = unique(dropna(x))
+myunique(x::AbstractDataVector) = unique(dropnull(x))
 
 """
     setlevels(x::PooledDataArray, newpool::Union{AbstractVector, Dict})
@@ -915,7 +915,7 @@ function Base.convert{T, R, N}(::Type{Array}, pda::PooledDataArray{T, R, N}, rep
     return convert(Array{T, N}, pda, replacement)
 end
 
-function dropna(pdv::PooledDataVector{T}) where T
+function dropnull(pdv::PooledDataVector{T}) where T
     n = length(pdv)
     res = Array{T}(n)
     total = 0

src/statistics.jl

@@ -41,8 +41,8 @@ StatsBase.describe(X::DataVector) = StatsBase.describe(STDOUT, X)
 function StatsBase.describe(io::IO, X::AbstractDataVector{T}) where T<:Real
     nacount = sum(isnull, X)
     pna = 100nacount/length(X)
-    if pna != 100 # describe will fail if dropna returns an empty vector
-        describe(io, dropna(X))
+    if pna != 100 # describe will fail if dropnull returns an empty vector
+        describe(io, dropnull(X))
     else
         println(io, "Summary Stats:")
         println(io, "Type:           $(T)")

test/data.jl

@@ -87,7 +87,7 @@
     # @test isequal(pdvstr .== "two", PooledDataVector[false, false, true, true, null, false, false])
 
     #test_group("DataVector to something else")
-    @test all(dropna(dvint) .== [1, 2, 4])
+    @test all(dropnull(dvint) .== [1, 2, 4])
     @test all(convert(Vector, dvint, 0) .== [1, 2, 0, 4])
     @test all(convert(Vector, dvany, 0) .== [1, 2, 0, 4])
     utf8three = convert(String, "three")
@@ -102,19 +102,19 @@
                           "Union{Nulls.Null, $Int}[1, 2, null, 4]")
 
     #test_group("PooledDataVector to something else")
-    @test all(dropna(pdvstr) .== ["one", "one", "two", "two", "one", "one"])
+    @test all(dropnull(pdvstr) .== ["one", "one", "two", "two", "one", "one"])
     @test all(convert(Vector, pdvstr, "nine") .== ["one", "one", "two", "two", "nine", "one", "one"])
     #@test all([length(i)::Int for i in pdvstr] .== [3, 3, 3, 3, 1, 3, 3])
     @test string(pdvstr[1:3]) == "[one, one, two]"
 
     #test_group("DataVector Filter and Replace")
-    @test isequal(dropna(dvint), [1, 2, 4])
+    @test isequal(dropnull(dvint), [1, 2, 4])
     @test isequal(convert(Vector, dvint, 7), [1, 2, 7, 4])
-    @test sum(dropna(dvint)) == 7
+    @test sum(dropnull(dvint)) == 7
     @test sum(convert(Vector, dvint, 7)) == 14
 
     #test_group("PooledDataVector Filter and Replace")
-    @test reduce(string, "", dropna(pdvstr)) == "oneonetwotwooneone"
+    @test reduce(string, "", dropnull(pdvstr)) == "oneonetwotwooneone"
     @test reduce(string, "", convert(Vector, pdvstr, "!")) == "oneonetwotwo!oneone"
 
     #test_group("DataVector assignment")

test/dataarray.jl

@@ -44,8 +44,8 @@
     x = @data [1, null, -2, 1, null, 4]
     @test isequal(unique(x), @data [1, null, -2, 4])
     @test isequal(unique(reverse(x)), @data [4, null, 1, -2])
-    @test isequal(unique(dropna(x)), @data [1, -2, 4])
-    @test isequal(unique(reverse(dropna(x))), @data [4, 1, -2])
+    @test isequal(unique(dropnull(x)), @data [1, -2, 4])
+    @test isequal(unique(reverse(dropnull(x))), @data [4, 1, -2])
     @test isequal(levels(x), @data [1, -2, 4])
     @test isequal(levels(reverse(x)), @data [4, 1, -2])
 

test/nas.jl

@@ -51,7 +51,7 @@
     end
 
     dv = DataArray(collect(1:6), fill(false, 6))
-    a = dropna(dv)
+    a = dropnull(dv)
     @test collect(Nulls.fail(dv)) == a
     @test collect(Nulls.skip(dv)) == a
     @test collect(Nulls.replace(dv, 4)) == a
@@ -67,7 +67,7 @@
         end
     end
 
-    a = dropna(dv)
+    a = dropnull(dv)
     @test_throws NullException for v in Nulls.fail(dv); end
     @test collect(Nulls.skip(dv)) == a
     @test collect(Nulls.replace(dv, 4)) == [4, 4, a..., 4]

test/newtests/dataarray.jl

@@ -119,11 +119,11 @@ module TestDataArrays
     convert(Vector, DataArray([1, 0, 3], [false, true, false]), -1)
     convert(Vector, DataArray([1, 2, 3], [false, false, false]), -1)
 
-    # dropna(da::DataArray)
-    dropna(DataArray([1, 0, 3], [false, true, false]))
-    dropna(DataArray([1, 2, 3], [false, false, false]))
-    # dropna{T}(da::AbstractDataVector{T})
-    # dropna(@data([1, null, 3]))
+    # dropnull(da::DataArray)
+    dropnull(DataArray([1, 0, 3], [false, true, false]))
+    dropnull(DataArray([1, 2, 3], [false, false, false]))
+    # dropnull{T}(da::AbstractDataVector{T})
+    # dropnull(@data([1, null, 3]))
 
     # Iterators
 

test/pooleddataarray.jl

@@ -3,14 +3,14 @@
     pcopy = copy(p)
     @test levels(p) == [1, 8, 9]
     @test levels(setlevels(p, ["a", "b", "c"])) == ["a", "b", "c"]
-    @test dropna(setlevels(p, (@data ["a", "b", null]))) == ["b", "a", "a"]
-    @test dropna(setlevels(p, (@data ["a", "b", "a"]))) == ["a", "a", "b", "a", "a"]
+    @test dropnull(setlevels(p, (@data ["a", "b", null]))) == ["b", "a", "a"]
+    @test dropnull(setlevels(p, (@data ["a", "b", "a"]))) == ["a", "a", "b", "a", "a"]
     @test levels(setlevels(p, (@data ["a", "b", "a"]))) == ["a", "b"]
     @test levels(setlevels(p, Dict([(1, 111)]))) == [111, 8, 9]
     @test levels(setlevels(p, Dict([(1, 111), (8, null)]))) == [111, 9]
     @test levels(PooledDataArray(p, [9, 8, 1])) == [9, 8, 1]
     @test levels(PooledDataArray(p, [9, 8])) == [9, 8]
-    @test dropna(PooledDataArray(p, [9, 8])) == [9, 9, 8]
+    @test dropnull(PooledDataArray(p, [9, 8])) == [9, 9, 8]
     @test levels(PooledDataArray(p, levels(p)[[3,2,1]])) == [9,8,1]
     v = collect(1:6)
     @test isequal(p, reorder(p))
@@ -29,14 +29,14 @@
     y = @pdata [1, null, -2, 1, null, 4, null]
     @test isequal(unique(y), @pdata [1, null, -2, 4])
     @test isequal(unique(reverse(y)), @data [null, 4, 1, -2])
-    @test isequal(unique(dropna(y)), @data [1, -2, 4])
-    @test isequal(unique(reverse(dropna(y))), @data [4, 1, -2])
+    @test isequal(unique(dropnull(y)), @data [1, -2, 4])
+    @test isequal(unique(reverse(dropnull(y))), @data [4, 1, -2])
 
     z = @pdata ["frank", null, "gertrude", "frank", null, "herbert", null]
     @test isequal(unique(z), @pdata ["frank", null, "gertrude", "herbert"])
     @test isequal(unique(reverse(z)), @pdata [null, "herbert", "frank", "gertrude"])
-    @test isequal(unique(dropna(z)), @pdata ["frank", "gertrude", "herbert"])
-    @test isequal(unique(reverse(dropna(z))), @pdata ["herbert", "frank", "gertrude"])
+    @test isequal(unique(dropnull(z)), @pdata ["frank", "gertrude", "herbert"])
+    @test isequal(unique(reverse(dropnull(z))), @pdata ["herbert", "frank", "gertrude"])
 
     # check case where only null occurs in final position
     @test isequal(unique(@pdata [1, 2, 1, null]), @pdata [1, 2, null])

test/reduce.jl

@@ -60,20 +60,20 @@ end
         da2 = copy(da)
         da2[1:2:end] = null
         @test isnull(sum(da2))
-        @test sum(da2; skipna=true) ≈ sum(dropna(da2))
+        @test sum(da2; skipna=true) ≈ sum(dropnull(da2))
 
         da2 = convert(DataArray{BigFloat}, da2)
         @test isnull(sum(da2))
-        @test sum(da2; skipna=true) ≈ sum(dropna(da2))
+        @test sum(da2; skipna=true) ≈ sum(dropnull(da2))
 
         da2 = copy(da)
         da2[2:2:end] = null
         @test isnull(sum(da2))
-        @test sum(da2; skipna=true) ≈ sum(dropna(da2))
+        @test sum(da2; skipna=true) ≈ sum(dropnull(da2))
 
         da2 = convert(DataArray{BigFloat}, da2)
         @test isnull(sum(da2))
-        @test sum(da2; skipna=true) ≈ sum(dropna(da2))
+        @test sum(da2; skipna=true) ≈ sum(dropnull(da2))
     end
 
     ## other reductions
@@ -96,20 +96,20 @@ end
             da2 = copy(da)
             da2[1:2:end] = null
             n > 0 && @test isnull(fn(da2))
-            @same_behavior fn(da2; skipna=true) fn(dropna(da2))
+            @same_behavior fn(da2; skipna=true) fn(dropnull(da2))
 
             da2 = convert(DataArray{BigFloat}, da2)
             n > 0 && @test isnull(fn(da2))
-            @same_behavior fn(da2; skipna=true) fn(dropna(da2))
+            @same_behavior fn(da2; skipna=true) fn(dropnull(da2))
 
             da2 = copy(da)
             da2[2:2:end] = null
             n > 1 && @test isnull(fn(da2))
-            @same_behavior fn(da2; skipna=true) fn(dropna(da2))
+            @same_behavior fn(da2; skipna=true) fn(dropnull(da2))
 
             da2 = convert(DataArray{BigFloat}, da2)
             n > 1 && @test isnull(fn(da2))
-            @same_behavior fn(da2; skipna=true) fn(dropna(da2))
+            @same_behavior fn(da2; skipna=true) fn(dropnull(da2))
         end
     end
 
@@ -140,8 +140,8 @@ end
     @same_behavior mean(da1, weights(da2.data); skipna=true) mean(da1.data, weights(da2.data))
 
     da1[1:3:end] = null
-    @same_behavior mean(da1, weights(da2); skipna=true) mean(dropna(da1), weights(da2.data[(!).(da1.na)]))
-    @same_behavior mean(da1, weights(da2.data); skipna=true) mean(dropna(da1), weights(da2.data[(!).(da1.na)]))
+    @same_behavior mean(da1, weights(da2); skipna=true) mean(dropnull(da1), weights(da2.data[(!).(da1.na)]))
+    @same_behavior mean(da1, weights(da2.data); skipna=true) mean(dropnull(da1), weights(da2.data[(!).(da1.na)]))
 
     da2[1:2:end] = null
     keep = .!da1.na .& .!da2.na

test/sort.jl

@@ -17,11 +17,11 @@
         ra = randn(n-nna)
         a[.!na] = ra
         for da in (DataArray(a, na), PooledDataArray(a, na), (pda = PooledDataArray(a, na); setlevels!(pda, shuffle!(pda.pool))))
-            @test isequal(sort(da), [DataArray(sort(dropna(da))); DataArray(T, nna)])
-            @test isequal(sort(da; lt=(x,y)->isless(x,y)), [DataArray(sort(dropna(da))); DataArray(T, nna)])
-            @test isequal(da[sortperm(da)], [DataArray(sort(dropna(da))); DataArray(T, nna)])
-            @test isequal(sort(da, rev=true), [DataArray(T, nna); DataArray(sort(dropna(da), rev=true))])
-            @test isequal(da[sortperm(da, rev=true)], [DataArray(T, nna); DataArray(sort(dropna(da), rev=true))])
+            @test isequal(sort(da), [DataArray(sort(dropnull(da))); DataArray(T, nna)])
+            @test isequal(sort(da; lt=(x,y)->isless(x,y)), [DataArray(sort(dropnull(da))); DataArray(T, nna)])
+            @test isequal(da[sortperm(da)], [DataArray(sort(dropnull(da))); DataArray(T, nna)])
+            @test isequal(sort(da, rev=true), [DataArray(T, nna); DataArray(sort(dropnull(da), rev=true))])
+            @test isequal(da[sortperm(da, rev=true)], [DataArray(T, nna); DataArray(sort(dropnull(da), rev=true))])
         end
     end
 end