Skip to content

Commit 48cdc2f

Browse files
stevengjstevengj
committed
deprecate bitpack/unpack in favor of BitArray/Array constructors
1 parent c204232 commit 48cdc2f

12 files changed

+118
-136
lines changed

‎base/bitarray.jl

+17-21
Original file line numberDiff line numberDiff line change
@@ -532,10 +532,6 @@ convert{T,N}(::Type{AbstractArray{T,N}}, B::BitArray{N}) = convert(Array{T,N}, B
532532
reinterpret{N}(::Type{Bool}, B::BitArray, dims::NTuple{N,Int}) = reinterpret(B, dims)
533533
reinterpret{N}(B::BitArray, dims::NTuple{N,Int}) = reshape(B, dims)
534534

535-
# shorthand forms BitArray <-> Array
536-
bitunpack{N}(B::BitArray{N}) = convert(Array{Bool,N}, B)
537-
bitpack{T,N}(A::AbstractArray{T,N}) = convert(BitArray{N}, A)
538-
539535
## Indexing: getindex ##
540536

541537
@inline function unsafe_bitgetindex(Bc::Vector{UInt64}, i::Int)
@@ -665,8 +661,8 @@ function append!(B::BitVector, items::BitVector)
665661
return B
666662
end
667663

668-
append!(B::BitVector, items::AbstractVector{Bool}) = append!(B, bitpack(items))
669-
append!(A::Vector{Bool}, items::BitVector) = append!(A, bitunpack(items))
664+
append!(B::BitVector, items::AbstractVector{Bool}) = append!(B, BitArray(items))
665+
append!(A::Vector{Bool}, items::BitVector) = append!(A, Array(items))
670666

671667
function prepend!(B::BitVector, items::BitVector)
672668
n0 = length(B)
@@ -687,8 +683,8 @@ function prepend!(B::BitVector, items::BitVector)
687683
return B
688684
end
689685

690-
prepend!(B::BitVector, items::AbstractVector{Bool}) = prepend!(B, bitpack(items))
691-
prepend!(A::Vector{Bool}, items::BitVector) = prepend!(A, bitunpack(items))
686+
prepend!(B::BitVector, items::AbstractVector{Bool}) = prepend!(B, BitArray(items))
687+
prepend!(A::Vector{Bool}, items::BitVector) = prepend!(A, Array(items))
692688

693689
function sizehint!(B::BitVector, sz::Integer)
694690
ccall(:jl_array_sizehint, Void, (Any, UInt), B.chunks, num_bit_chunks(sz))
@@ -1068,19 +1064,19 @@ end
10681064

10691065
for f in (:/, :\)
10701066
@eval begin
1071-
($f)(A::BitArray, B::BitArray) = ($f)(bitunpack(A), bitunpack(B))
1067+
($f)(A::BitArray, B::BitArray) = ($f)(Array(A), Array(B))
10721068
end
10731069
end
1074-
(/)(B::BitArray, x::Number) = (/)(bitunpack(B), x)
1075-
(/)(x::Number, B::BitArray) = (/)(x, bitunpack(B))
1070+
(/)(B::BitArray, x::Number) = (/)(Array(B), x)
1071+
(/)(x::Number, B::BitArray) = (/)(x, Array(B))
10761072

10771073
function div(A::BitArray, B::BitArray)
10781074
shp = promote_shape(size(A), size(B))
10791075
all(B) || throw(DivideError())
10801076
return reshape(copy(A), shp)
10811077
end
1082-
div(A::BitArray, B::Array{Bool}) = div(A, bitpack(B))
1083-
div(A::Array{Bool}, B::BitArray) = div(bitpack(A), B)
1078+
div(A::BitArray, B::Array{Bool}) = div(A, BitArray(B))
1079+
div(A::Array{Bool}, B::BitArray) = div(BitArray(A), B)
10841080
function div(B::BitArray, x::Bool)
10851081
return x ? copy(B) : throw(DivideError())
10861082
end
@@ -1100,8 +1096,8 @@ function mod(A::BitArray, B::BitArray)
11001096
all(B) || throw(DivideError())
11011097
return falses(shp)
11021098
end
1103-
mod(A::BitArray, B::Array{Bool}) = mod(A, bitpack(B))
1104-
mod(A::Array{Bool}, B::BitArray) = mod(bitpack(A), B)
1099+
mod(A::BitArray, B::Array{Bool}) = mod(A, BitArray(B))
1100+
mod(A::Array{Bool}, B::BitArray) = mod(BitArray(A), B)
11051101
function mod(B::BitArray, x::Bool)
11061102
return x ? falses(size(B)) : throw(DivideError())
11071103
end
@@ -1157,10 +1153,10 @@ for f in (:&, :|, :$)
11571153
Fc[end] &= _msk_end(F)
11581154
return F
11591155
end
1160-
($f)(A::DenseArray{Bool}, B::BitArray) = ($f)(bitpack(A), B)
1161-
($f)(B::BitArray, A::DenseArray{Bool}) = ($f)(B, bitpack(A))
1162-
($f)(x::Number, B::BitArray) = ($f)(x, bitunpack(B))
1163-
($f)(B::BitArray, x::Number) = ($f)(bitunpack(B), x)
1156+
($f)(A::DenseArray{Bool}, B::BitArray) = ($f)(BitArray(A), B)
1157+
($f)(B::BitArray, A::DenseArray{Bool}) = ($f)(B, BitArray(A))
1158+
($f)(x::Number, B::BitArray) = ($f)(x, Array(B))
1159+
($f)(B::BitArray, x::Number) = ($f)(Array(B), x)
11641160
end
11651161
end
11661162

@@ -1233,8 +1229,8 @@ end
12331229

12341230
(.*)(x::Bool, B::BitArray) = x & B
12351231
(.*)(B::BitArray, x::Bool) = B & x
1236-
(.*)(x::Number, B::BitArray) = x .* bitunpack(B)
1237-
(.*)(B::BitArray, x::Number) = bitunpack(B) .* x
1232+
(.*)(x::Number, B::BitArray) = x .* Array(B)
1233+
(.*)(B::BitArray, x::Number) = Array(B) .* x
12381234

12391235
## promotion to complex ##
12401236

‎base/broadcast.jl

+3-3
Original file line numberDiff line numberDiff line change
@@ -328,8 +328,8 @@ for (f, scalarf, bitf, bitfbody) in ((:.==, :(==), :biteq , :(~a $ b)),
328328
end
329329
F = BitArray(shape)
330330
Fc = F.chunks
331-
Ac = bitpack(A).chunks
332-
Bc = bitpack(B).chunks
331+
Ac = BitArray(A).chunks
332+
Bc = BitArray(B).chunks
333333
if !isempty(Ac) && !isempty(Bc)
334334
for i = 1:length(Fc) - 1
335335
Fc[i] = ($bitf)(Ac[i], Bc[i])
@@ -430,7 +430,7 @@ for (sigA, sigB) in ((BitArray, BitArray),
430430
(BitArray, AbstractArray{Bool}))
431431
@eval function (.*)(A::$sigA, B::$sigB)
432432
try
433-
return bitpack(A) & bitpack(B)
433+
return BitArray(A) & BitArray(B)
434434
catch
435435
return bitbroadcast(&, A, B)
436436
end

‎base/deprecated.jl

+2
Original file line numberDiff line numberDiff line change
@@ -1070,6 +1070,8 @@ end
10701070
@deprecate specialized_bitwise_unary(f::Function) f
10711071
@deprecate specialized_bitwise_binary(f::Function) f
10721072

1073+
@deprecate bitunpack(B::BitArray) Array(B)
1074+
@deprecate bitpack(A::AbstractArray) BitArray(A)
10731075

10741076
# During the 0.5 development cycle, do not add any deprecations below this line
10751077
# To be deprecated in 0.6

‎base/docs/helpdb/Base.jl

-14
Original file line numberDiff line numberDiff line change
@@ -4374,13 +4374,6 @@ Pick a random element or array of random elements from the set of values specifi
43744374
"""
43754375
rand
43764376

4377-
"""
4378-
bitpack(A::AbstractArray{T,N}) -> BitArray
4379-
4380-
Converts a numeric array to a packed boolean array.
4381-
"""
4382-
bitpack
4383-
43844377
"""
43854378
base(base, n, [pad])
43864379
@@ -8184,13 +8177,6 @@ all elements of the string.
81848177
"""
81858178
ispunct
81868179

8187-
"""
8188-
bitunpack(B::BitArray{N}) -> Array{Bool,N}
8189-
8190-
Converts a packed boolean array to an array of booleans.
8191-
"""
8192-
bitunpack
8193-
81948180
"""
81958181
size(A, [dim...])
81968182

‎base/exports.jl

-2
Original file line numberDiff line numberDiff line change
@@ -723,8 +723,6 @@ export
723723
full,
724724

725725
# bitarrays
726-
bitpack,
727-
bitunpack,
728726
falses,
729727
flipbits!,
730728
rol,

‎base/linalg/bitarray.jl

+5-5
Original file line numberDiff line numberDiff line change
@@ -69,11 +69,11 @@ end
6969
## diff and gradient
7070

7171
# TODO: this could be improved (is it worth it?)
72-
gradient(F::BitVector) = gradient(bitunpack(F))
73-
gradient(F::BitVector, h::Real) = gradient(bitunpack(F), h)
74-
gradient(F::Vector, h::BitVector) = gradient(F, bitunpack(h))
75-
gradient(F::BitVector, h::Vector) = gradient(bitunpack(F), h)
76-
gradient(F::BitVector, h::BitVector) = gradient(bitunpack(F), bitunpack(h))
72+
gradient(F::BitVector) = gradient(Array(F))
73+
gradient(F::BitVector, h::Real) = gradient(Array(F), h)
74+
gradient(F::Vector, h::BitVector) = gradient(F, Array(h))
75+
gradient(F::BitVector, h::Vector) = gradient(Array(F), h)
76+
gradient(F::BitVector, h::BitVector) = gradient(Array(F), Array(h))
7777

7878
## diag and related
7979

‎base/linalg/uniformscaling.jl

+6-6
Original file line numberDiff line numberDiff line change
@@ -25,16 +25,16 @@ zero{T}(::Type{UniformScaling{T}}) = UniformScaling(zero(T))
2525
zero{T}(J::UniformScaling{T}) = zero(UniformScaling{T})
2626

2727
(+)(J1::UniformScaling, J2::UniformScaling) = UniformScaling(J1.λ+J2.λ)
28-
(+){T}(B::BitArray{2},J::UniformScaling{T}) = bitunpack(B) + J
29-
(+)(J::UniformScaling, B::BitArray{2}) = J + bitunpack(B)
28+
(+){T}(B::BitArray{2},J::UniformScaling{T}) = Array(B) + J
29+
(+)(J::UniformScaling, B::BitArray{2}) = J + Array(B)
3030
(+)(J::UniformScaling, A::AbstractMatrix) = A + J
3131
(+)(J::UniformScaling, x::Number) = J.λ + x
3232
(+)(x::Number, J::UniformScaling) = x + J.λ
3333

3434
(-)(J::UniformScaling) = UniformScaling(-J.λ)
3535
(-)(J1::UniformScaling, J2::UniformScaling) = UniformScaling(J1.λ-J2.λ)
36-
(-)(B::BitArray{2}, J::UniformScaling) = bitunpack(B) - J
37-
(-)(J::UniformScaling, B::BitArray{2}) = J - bitunpack(B)
36+
(-)(B::BitArray{2}, J::UniformScaling) = Array(B) - J
37+
(-)(J::UniformScaling, B::BitArray{2}) = J - Array(B)
3838
(-)(J::UniformScaling, x::Number) = J.λ - x
3939
(-)(x::Number, J::UniformScaling) = x - J.λ
4040

@@ -119,8 +119,8 @@ end
119119
inv(J::UniformScaling) = UniformScaling(inv(J.λ))
120120

121121
*(J1::UniformScaling, J2::UniformScaling) = UniformScaling(J1.λ*J2.λ)
122-
*(B::BitArray{2}, J::UniformScaling) = *(bitunpack(B), J::UniformScaling)
123-
*(J::UniformScaling, B::BitArray{2}) = *(J::UniformScaling, bitunpack(B))
122+
*(B::BitArray{2}, J::UniformScaling) = *(Array(B), J::UniformScaling)
123+
*(J::UniformScaling, B::BitArray{2}) = *(J::UniformScaling, Array(B))
124124
*(A::AbstractMatrix, J::UniformScaling) = J.λ == 1 ? A : J.λ*A
125125
*(J::UniformScaling, A::AbstractVecOrMat) = J.λ == 1 ? A : J.λ*A
126126

‎test/arrayops.jl

+8-8
Original file line numberDiff line numberDiff line change
@@ -1264,21 +1264,21 @@ let x = fill(0.9, 1000)
12641264
end
12651265

12661266
#binary ops on bool arrays
1267-
A = bitunpack(trues(5))
1267+
A = Array(trues(5))
12681268
@test A + true == [2,2,2,2,2]
1269-
A = bitunpack(trues(5))
1269+
A = Array(trues(5))
12701270
@test A + false == [1,1,1,1,1]
1271-
A = bitunpack(trues(5))
1271+
A = Array(trues(5))
12721272
@test true + A == [2,2,2,2,2]
1273-
A = bitunpack(trues(5))
1273+
A = Array(trues(5))
12741274
@test false + A == [1,1,1,1,1]
1275-
A = bitunpack(trues(5))
1275+
A = Array(trues(5))
12761276
@test A - true == [0,0,0,0,0]
1277-
A = bitunpack(trues(5))
1277+
A = Array(trues(5))
12781278
@test A - false == [1,1,1,1,1]
1279-
A = bitunpack(trues(5))
1279+
A = Array(trues(5))
12801280
@test true - A == [0,0,0,0,0]
1281-
A = bitunpack(trues(5))
1281+
A = Array(trues(5))
12821282
@test false - A == [-1,-1,-1,-1,-1]
12831283

12841284
# simple transposes

0 commit comments

Comments
 (0)