make count(f,itr) count the number of nonzero values (fixes #20404), elim countnz in favor of count(itr) (fixes #20403)

Author: stevengj

base/abstractarray.jl

@@ -1095,7 +1095,7 @@ function cat_t(dims, T::Type, X...)
     catdims = dims2cat(dims)
     shape = cat_shape(catdims, (), map(cat_size, X)...)
     A = cat_similar(X[1], T, shape)
-    if T <: Number && countnz(catdims) > 1
+    if T <: Number && count(catdims) > 1
         fill!(A, zero(T))
     end
     return _cat(A, shape, catdims, X...)

base/array.jl

@@ -1393,7 +1393,7 @@ julia> find(A)
 ```
 """
 function find(A)
-    nnzA = countnz(A)
+    nnzA = count(A)
     I = Vector{Int}(nnzA)
     count = 1
     inds = _index_remapper(A)
@@ -1438,7 +1438,7 @@ julia> findn(A)
 ```
 """
 function findn(A::AbstractMatrix)
-    nnzA = countnz(A)
+    nnzA = count(A)
     I = similar(A, Int, nnzA)
     J = similar(A, Int, nnzA)
     count = 1
@@ -1470,7 +1470,7 @@ julia> findnz(A)
 ```
 """
 function findnz{T}(A::AbstractMatrix{T})
-    nnzA = countnz(A)
+    nnzA = count(A)
     I = zeros(Int, nnzA)
     J = zeros(Int, nnzA)
     NZs = Array{T,1}(nnzA)

base/bitarray.jl

@@ -1565,9 +1565,9 @@ julia> ror(A,5)
 """
 ror(B::BitVector, i::Integer) = ror!(similar(B), B, i)
 
-## countnz & find ##
+## count & find ##
 
-function countnz(B::BitArray)
+function count(B::BitArray)
     n = 0
     Bc = B.chunks
     @inbounds for i = 1:length(Bc)
@@ -1728,7 +1728,7 @@ end
 
 function find(B::BitArray)
     l = length(B)
-    nnzB = countnz(B)
+    nnzB = count(B)
     I = Array{Int}(nnzB)
     nnzB == 0 && return I
     Bc = B.chunks
@@ -1762,7 +1762,7 @@ end
 findn(B::BitVector) = find(B)
 
 function findn(B::BitMatrix)
-    nnzB = countnz(B)
+    nnzB = count(B)
     I = Array{Int}(nnzB)
     J = Array{Int}(nnzB)
     count = 1
@@ -1784,7 +1784,7 @@ end
 ## Reductions ##
 
 sum(A::BitArray, region) = reducedim(+, A, region)
-sum(B::BitArray) = countnz(B)
+sum(B::BitArray) = count(B)
 
 function all(B::BitArray)
     isempty(B) && return true

base/bool.jl

@@ -76,6 +76,7 @@ signbit(x::Bool) = false
 sign(x::Bool) = x
 abs(x::Bool) = x
 abs2(x::Bool) = x
+iszero(x::Bool) = !x
 
 <(x::Bool, y::Bool) = y&!x
 <=(x::Bool, y::Bool) = y|!x

base/deprecated.jl

@@ -1224,6 +1224,8 @@ function (::Type{Matrix})()
     return Matrix(0, 0)
 end
 
+@deprecate countnz(itr) count(itr)
+
 for name in ("alnum", "alpha", "cntrl", "digit", "number", "graph",
              "lower", "print", "punct", "space", "upper", "xdigit")
     f = Symbol("is",name)

base/exports.jl

@@ -531,7 +531,6 @@ export
     minmax,
     ndims,
     nonzeros,
-    countnz,
     ones,
     parent,
     parentindexes,

base/linalg/bitarray.jl

@@ -134,7 +134,7 @@ end
 
 ## Structure query functions
 
-issymmetric(A::BitMatrix) = size(A, 1)==size(A, 2) && countnz(A - A.')==0
+issymmetric(A::BitMatrix) = size(A, 1)==size(A, 2) && count(A - A.')==0
 ishermitian(A::BitMatrix) = issymmetric(A)
 
 function nonzero_chunks(chunks::Vector{UInt64}, pos0::Int, pos1::Int)

base/linalg/generic.jl

@@ -440,7 +440,7 @@ function vecnorm(itr, p::Real=2)
         return vecnormInf(itr)
     elseif p == 0
         return convert(typeof(float(real(zero(eltype(itr))))),
-               countnz(itr))
+               count(itr))
     elseif p == -Inf
         return vecnormMinusInf(itr)
     else

base/multidimensional.jl

@@ -276,7 +276,7 @@ wrapped with `LogicalIndex` upon calling `to_indices`.
 immutable LogicalIndex{T, A<:AbstractArray{Bool}} <: AbstractVector{T}
     mask::A
     sum::Int
-    LogicalIndex(mask::A) = new(mask, countnz(mask))
+    LogicalIndex(mask::A) = new(mask, count(mask))
 end
 LogicalIndex(mask::AbstractVector{Bool}) = LogicalIndex{Int, typeof(mask)}(mask)
 LogicalIndex{N}(mask::AbstractArray{Bool, N}) = LogicalIndex{CartesianIndex{N}, typeof(mask)}(mask)
@@ -467,7 +467,7 @@ end
 
 @generated function findn{T,N}(A::AbstractArray{T,N})
     quote
-        nnzA = countnz(A)
+        nnzA = count(A)
         @nexprs $N d->(I_d = Array{Int}(nnzA))
         k = 1
         @nloops $N i A begin
@@ -1066,7 +1066,7 @@ end
 
 @generated function findn{N}(B::BitArray{N})
     quote
-        nnzB = countnz(B)
+        nnzB = count(B)
         I = ntuple(x->Array{Int}(nnzB), $N)
         if nnzB > 0
             count = 1

base/reduce.jl

@@ -348,7 +348,7 @@ julia> sum(1:20)
 ```
 """
 sum(a) = mapreduce(identity, +, a)
-sum(a::AbstractArray{Bool}) = countnz(a)
+sum(a::AbstractArray{Bool}) = count(a)
 
 
 # Kahan (compensated) summation: O(1) error growth, at the expense
@@ -637,42 +637,37 @@ function contains(eq::Function, itr, x)
     return false
 end
 
-
-## countnz & count
-
 """
     count(p, itr) -> Integer
+    count(itr)
 
-Count the number of elements in `itr` for which predicate `p` returns `true`.
+Count the number of elements in `itr` for which the function `p` returns
+a nonzero value (or returns `true`, for boolean `p`) according to the
+[`iszero`](@ref) function.  `count(itr)` is equivalent to `p = identity`,
+i.e. it counts the number of nonzero (or `true`) elements of `itr`.
 
 ```jldoctest
 julia> count(i->(4<=i<=6), [2,3,4,5,6])
 3
-```
-"""
-function count(pred, itr)
-    n = 0
-    for x in itr
-        n += pred(x)
-    end
-    return n
-end
-
-"""
-    countnz(A) -> Integer
-
-Counts the number of nonzero values in array `A` (dense or sparse). Note that this is not a constant-time operation.
-For sparse matrices, one should usually use [`nnz`](@ref), which returns the number of stored values.
 
-```jldoctest
 julia> A = [1 2 4; 0 0 1; 1 1 0]
 3×3 Array{Int64,2}:
  1  2  4
  0  0  1
  1  1  0
 
-julia> countnz(A)
+julia> count(A)
 6
 ```
 """
-countnz(a) = count(x -> x != 0, a)
+function count end
+
+function count{F}(pred::F, itr)
+    n = 0
+    for x in itr
+        n += !iszero(pred(x))
+    end
+    return n
+end
+
+count(itr) = count(identity, itr)

base/sparse/sparse.jl

@@ -14,7 +14,7 @@ import Base.LinAlg: At_ldiv_B!, Ac_ldiv_B!
 
 import Base: @get!, acos, acosd, acot, acotd, acsch, asech, asin, asind, asinh,
     atan, atand, atanh, broadcast!, chol, conj!, cos, cosc, cosd, cosh, cospi, cot,
-    cotd, coth, countnz, csc, cscd, csch, ctranspose!, diag, diff, done, dot, eig,
+    cotd, coth, count, csc, cscd, csch, ctranspose!, diag, diff, done, dot, eig,
     exp10, exp2, eye, findn, floor, hash, indmin, inv, issymmetric, istril, istriu,
     log10, log2, lu, next, sec, secd, sech, show, sin,
     sinc, sind, sinh, sinpi, squeeze, start, sum, summary, tan,

base/sparse/sparsematrix.jl

@@ -43,7 +43,7 @@ julia> nnz(A)
 ```
 """
 nnz(S::SparseMatrixCSC) = Int(S.colptr[end]-1)
-countnz(S::SparseMatrixCSC) = countnz(S.nzval)
+count(S::SparseMatrixCSC) = count(S.nzval)
 
 """
     nonzeros(A)
@@ -1740,7 +1740,7 @@ indmax(A::SparseMatrixCSC) = findmax(A)[2]
 #all(A::SparseMatrixCSC{Bool}, region) = reducedim(all,A,region,true)
 #any(A::SparseMatrixCSC{Bool}, region) = reducedim(any,A,region,false)
 #sum(A::SparseMatrixCSC{Bool}, region) = reducedim(+,A,region,0,Int)
-#sum(A::SparseMatrixCSC{Bool}) = countnz(A)
+#sum(A::SparseMatrixCSC{Bool}) = count(A)
 
 ## getindex
 function rangesearch(haystack::Range, needle)

base/sparse/sparsevector.jl

@@ -30,7 +30,7 @@ SparseVector{Tv,Ti}(n::Integer, nzind::Vector{Ti}, nzval::Vector{Tv}) =
 length(x::SparseVector) = x.n
 size(x::SparseVector) = (x.n,)
 nnz(x::SparseVector) = length(x.nzval)
-countnz(x::SparseVector) = countnz(x.nzval)
+count(x::SparseVector) = count(x.nzval)
 nonzeros(x::SparseVector) = x.nzval
 nonzeroinds(x::SparseVector) = x.nzind
 

doc/src/manual/arrays.md

@@ -743,7 +743,7 @@ In some applications, it is convenient to store explicit zero values in a `Spars
 mutating operations). Such explicitly stored zeros are treated as structural nonzeros by many
 routines. The [`nnz()`](@ref) function returns the number of elements explicitly stored in the
 sparse data structure, including structural nonzeros. In order to count the exact number of actual
-values that are nonzero, use [`countnz()`](@ref), which inspects every stored element of a sparse
+values that are nonzero, use [`count()`](@ref), which inspects every stored element of a sparse
 matrix.
 
 ### Sparse matrix constructors

doc/src/stdlib/arrays.md

@@ -11,7 +11,7 @@ Base.length(::AbstractArray)
 Base.eachindex
 Base.linearindices
 Base.linearindexing
-Base.countnz
+Base.count
 Base.conj!
 Base.stride
 Base.strides

test/arrayops.jl

@@ -4,7 +4,7 @@
 
 @testset "basics" begin
     @test length([1, 2, 3]) == 3
-    @test countnz([1, 2, 3]) == 3
+    @test count([1, 2, 3]) == 3
 
     let a = ones(4), b = a+a, c = a-a
         @test b[1] === 2. && b[2] === 2. && b[3] === 2. && b[4] === 2.

test/bitarray.jl

@@ -466,20 +466,20 @@ timesofar("constructors")
         @check_bit_operation setindex!(b1, true, t1) BitMatrix
 
         t1 = bitrand(n1, n2)
-        b2 = bitrand(countnz(t1))
+        b2 = bitrand(count(t1))
         @check_bit_operation setindex!(b1, b2, t1) BitMatrix
 
         m1 = rand(1:n1)
         m2 = rand(1:n2)
         t1 = bitrand(n1)
-        b2 = bitrand(countnz(t1), m2)
+        b2 = bitrand(count(t1), m2)
         k2 = randperm(m2)
         @check_bit_operation setindex!(b1, b2, t1, 1:m2)       BitMatrix
         @check_bit_operation setindex!(b1, b2, t1, n2-m2+1:n2) BitMatrix
         @check_bit_operation setindex!(b1, b2, t1, k2)         BitMatrix
 
         t2 = bitrand(n2)
-        b2 = bitrand(m1, countnz(t2))
+        b2 = bitrand(m1, count(t2))
         k1 = randperm(m1)
         @check_bit_operation setindex!(b1, b2, 1:m1, t2)       BitMatrix
         @check_bit_operation setindex!(b1, b2, n1-m1+1:n1, t2) BitMatrix
@@ -1051,9 +1051,9 @@ end
 
 timesofar("datamove")
 
-@testset "countnz & find" begin
+@testset "count & find" begin
     for m = 0:v1, b1 in Any[bitrand(m), trues(m), falses(m)]
-        @check_bit_operation countnz(b1) Int
+        @check_bit_operation count(b1) Int
 
         @check_bit_operation findfirst(b1) Int
 

test/reduce.jl

@@ -258,15 +258,15 @@ immutable SomeFunctor end
 @test contains("quick fox", "fox") == true
 @test contains("quick fox", "lazy dog") == false
 
-# count & countnz
+# count & count
 
 @test count(x->x>0, Int[]) == 0
 @test count(x->x>0, -3:5) == 5
 
-@test countnz(Int[]) == 0
-@test countnz(Int[0]) == 0
-@test countnz(Int[1]) == 1
-@test countnz([1, 0, 2, 0, 3, 0, 4]) == 4
+@test count(Int[]) == 0
+@test count(Int[0]) == 0
+@test count(Int[1]) == 1
+@test count([1, 0, 2, 0, 3, 0, 4]) == 4
 
 
 ## cumsum, cummin, cummax