bitarray indexing: sync with array + refactor

* Use setindex_shape_check and DimensionMismatch instead
  of generic errors; this (and a couple of extra minor fixes)
  makes BitArrays behave like Arrays (again)
* Move portions of the indexing code to multidimensional.jl
* Restrict signatures so as to avoid to_index and convert, then
  create very generic methods which do the conversion and the
  dispatch: this greatly simplifies the logic and removes most
  of the need for disambiguation. Should also improve code
  generation.

Author: carlobaldassi

base/bitarray.jl

@@ -217,9 +217,10 @@ falses(args...) = fill!(BitArray(args...), false)
 trues(args...) = fill!(BitArray(args...), true)
 
 function one(x::BitMatrix)
-    m, n = size(x)
-    a = falses(size(x))
-    for i = 1 : min(m,n)
+    m,n = size(x)
+    m == n || throw(DimensionMismatch("multiplicative identity defined only for square matrices"))
+    a = falses(n, n)
+    for i = 1:n
         a[i,i] = true
     end
     return a
@@ -258,7 +259,7 @@ end
 
 function reshape{N}(B::BitArray, dims::NTuple{N,Int})
     if prod(dims) != length(B)
-        error("new dimensions $(dims) inconsistent with the array length $(length(B))")
+        throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $(length(B))"))
     end
     Br = BitArray{N}(ntuple(N,i->0)...)
     Br.chunks = B.chunks
@@ -320,18 +321,7 @@ end
 convert{N}(::Type{BitArray{N}}, B::BitArray{N}) = B
 
 reinterpret{N}(::Type{Bool}, B::BitArray, dims::NTuple{N,Int}) = reinterpret(B, dims)
-function reinterpret{N}(B::BitArray, dims::NTuple{N,Int})
-    if prod(dims) != length(B)
-        error("new dimensions $(dims) are inconsistent with array length $(length(B))")
-    end
-    A = BitArray{N}(ntuple(N,i->0)...)
-    A.chunks = B.chunks
-    A.len = prod(dims)
-    if N != 1
-        A.dims = dims
-    end
-    return A
-end
+reinterpret{N}(B::BitArray, dims::NTuple{N,Int}) = reshape(B, dims)
 
 # shorthand forms BitArray <-> Array
 bitunpack{N}(B::BitArray{N}) = convert(Array{Bool,N}, B)
@@ -359,9 +349,7 @@ function getindex_unchecked(Bc::Vector{Uint64}, i::Int)
 end
 
 function getindex(B::BitArray, i::Int)
-    if i < 1 || i > length(B)
-        throw(BoundsError())
-    end
+    1 <= i <= length(B) || throw(BoundsError())
     return getindex_unchecked(B.chunks, i)
 end
 
@@ -372,58 +360,6 @@ getindex(B::BitArray) = getindex(B, 1)
 # 0d bitarray
 getindex(B::BitArray{0}) = getindex_unchecked(B.chunks, 1)
 
-function getindex(B::BitArray, i1::Real, i2::Real)
-    #checkbounds(B, i0, i1) # manually inlined for performance
-    i1, i2 = to_index(i1, i2)
-    l1 = size(B,1)
-    1 <= i1 <= l1 || throw(BoundsError())
-    return B[i1 + l1*(i2-1)]
-end
-function getindex(B::BitArray, i1::Real, i2::Real, i3::Real)
-    #checkbounds(B, i0, i1, i2) # manually inlined for performance
-    i1, i2, i3 = to_index(i1, i2, i3)
-    l1 = size(B,1)
-    1 <= i1 <= l1 || throw(BoundsError())
-    l2 = size(B,2)
-    1 <= i2 <= l2 || throw(BoundsError())
-    return B[i1 + l1*((i2-1) + l2*(i3-1))]
-end
-function getindex(B::BitArray, i1::Real, i2::Real, i3::Real, i4::Real)
-    #checkbounds(B, i1, i2, i3, i4)
-    i1, i2, i3, i4 = to_index(i1, i2, i3, i4)
-    l1 = size(B,1)
-    1 <= i1 <= l1 || throw(BoundsError())
-    l2 = size(B,2)
-    1 <= i2 <= l2 || throw(BoundsError())
-    l3 = size(B,3)
-    1 <= i3 <= l3 || throw(BoundsError())
-    return B[i1 + l1*((i2-1) + l2*((i3-1) + l3*(i4-1)))]
-end
-
-function getindex(B::BitArray, I::Real...)
-    #checkbounds(B, I...) # inlined for performance
-    #I = to_index(I) # inlined for performance
-    ndims = length(I)
-    i = to_index(I[1])
-    l = size(B,1)
-    1 <= i <= l || throw(BoundsError())
-    index = i
-    stride = 1
-    for k = 2:ndims-1
-        stride *= l
-        i = to_index(I[k])
-        l = size(B,k)
-        1 <= i <= l || throw(BoundsError())
-        index += (i-1) * stride
-    end
-    stride *= l
-    i = to_index(I[ndims])
-    index += (i-1) * stride
-    return B[index]
-end
-
-# note: the Range1{Int} case is still handled by the version above
-#       (which is fine)
 function getindex{T<:Real}(B::BitArray, I::AbstractVector{T})
     X = BitArray(length(I))
     lB = length(B)
@@ -432,40 +368,34 @@ function getindex{T<:Real}(B::BitArray, I::AbstractVector{T})
     ind = 1
     for i in I
         # faster X[ind] = B[i]
-        i = to_index(i)
-        1 <= i <= lB || throw(BoundsError())
-        setindex_unchecked(Xc, getindex_unchecked(Bc, i), ind)
+        j = to_index(i)
+        1 <= j <= lB || throw(BoundsError())
+        setindex_unchecked(Xc, getindex_unchecked(Bc, j), ind)
         ind += 1
     end
     return X
 end
 
 # logical indexing
 
-function getindex_bool_1d(B::BitArray, I::AbstractArray{Bool})
-    n = sum(I)
-    X = BitArray(n)
-    lI = length(I)
-    if lI != length(B)
-        throw(BoundsError())
-    end
-    Xc = X.chunks
-    Bc = B.chunks
-    ind = 1
-    for i = 1:length(I)
-        if I[i]
-            # faster X[ind] = B[i]
-            setindex_unchecked(Xc, getindex_unchecked(Bc, i), ind)
-            ind += 1
+# (multiple signatures for disambiguation)
+for IT in [AbstractVector{Bool}, AbstractArray{Bool}]
+    @eval function getindex(B::BitArray, I::$IT)
+        checkbounds(B, I)
+        n = sum(I)
+        X = BitArray(n)
+        Xc = X.chunks
+        Bc = B.chunks
+        ind = 1
+        for i = 1:length(I)
+            if I[i]
+                # faster X[ind] = B[i]
+                setindex_unchecked(Xc, getindex_unchecked(Bc, i), ind)
+                ind += 1
+            end
         end
+        return X
     end
-    return X
-end
-
-# multiple signatures required for disambiguation
-# (see also getindex in multidimensional.jl)
-for BT in [BitVector, BitArray], IT in [Range1{Bool}, AbstractVector{Bool}, AbstractArray{Bool}]
-    @eval getindex(B::$BT, I::$IT) = getindex_bool_1d(B, I)
 end
 
 ## Indexing: setindex! ##
@@ -482,133 +412,31 @@ function setindex_unchecked(Bc::Array{Uint64}, x::Bool, i::Int)
     end
 end
 
+setindex!(B::BitArray, x::Bool) = setindex!(B, x, 1)
+
 function setindex!(B::BitArray, x::Bool, i::Int)
-    if i < 1 || i > length(B)
-        throw(BoundsError())
-    end
+    1 <= i <= length(B) || throw(BoundsError())
     setindex_unchecked(B.chunks, x, i)
     return B
 end
 
-setindex!(B::BitArray, x) = setindex!(B, x, 1)
-
-setindex!(B::BitArray, x, i::Real) = setindex!(B, convert(Bool,x), to_index(i))
-
-function setindex!(B::BitArray, x, i1::Real, i2::Real)
-    #checkbounds(B, i0, i1) # manually inlined for performance
-    i1, i2 = to_index(i1, i2)
-    l1 = size(B,1)
-    1 <= i1 <= l1 || throw(BoundsError())
-    B[i1 + l1*(i2-1)] = x
-    return B
-end
-
-function setindex!(B::BitArray, x, i1::Real, i2::Real, i3::Real)
-    #checkbounds(B, i1, i2, i3) # manually inlined for performance
-    i1, i2, i3 = to_index(i1, i2, i3)
-    l1 = size(B,1)
-    1 <= i1 <= l1 || throw(BoundsError())
-    l2 = size(B,2)
-    1 <= i2 <= l2 || throw(BoundsError())
-    B[i1 + l1*((i2-1) + l2*(i3-1))] = x
-    return B
-end
-
-function setindex!(B::BitArray, x, i1::Real, i2::Real, i3::Real, i4::Real)
-    #checkbounds(B, i1, i2, i3, i4) # manually inlined for performance
-    i1, i2, i3, i4 = to_index(i1, i2, i3, i4)
-    l1 = size(B,1)
-    1 <= i1 <= l1 || throw(BoundsError())
-    l2 = size(B,2)
-    1 <= i2 <= l2 || throw(BoundsError())
-    l3 = size(B,3)
-    1 <= i3 <= l3 || throw(BoundsError())
-    B[i1 + l1*((i2-1) + l2*((i3-1) + l3*(i4-1)))] = x
-    return B
-end
-
-function setindex!(B::BitArray, x, i::Real, I::Real...)
-    #checkbounds(B, I...) # inlined for performance
-    #I = to_index(I) # inlined for performance
-    ndims = length(I) + 1
-    i = to_index(i)
-    l = size(B,1)
-    1 <= i <= l || throw(BoundsError())
-    index = i
-    stride = 1
-    for k = 2:ndims-1
-        stride *= l
-        l = size(B,k)
-        i = to_index(I[k-1])
-        1 <= i <= l || throw(BoundsError())
-        index += (i-1) * stride
-    end
-    stride *= l
-    i = to_index(I[ndims-1])
-    index += (i-1) * stride
-    B[index] = x
-    return B
-end
-
-function setindex!{T<:Real}(B::BitArray, X::AbstractArray, I::AbstractVector{T})
-    if length(X) != length(I); error("argument dimensions must match"); end
-    count = 1
-    for i in I
-        B[i] = X[count]
-        count += 1
-    end
-    return B
-end
-
-function setindex!(B::BitArray, X::AbstractArray, i0::Real)
-    if length(X) != 1
-        error("argument dimensions must match")
-    end
-    return setindex!(B, X[1], i0)
-end
-
-function setindex!(B::BitArray, X::AbstractArray, i0::Real, i1::Real)
-    if length(X) != 1
-        error("argument dimensions must match")
-    end
-    return setindex!(B, X[1], i0, i1)
-end
-
-function setindex!(B::BitArray, X::AbstractArray, I0::Real, I::Real...)
-    if length(X) != 1
-        error("argument dimensions must match")
-    end
-    return setindex!(B, X[1], i0, I...)
-end
-
-function setindex!{T<:Real}(B::BitArray, x, I::AbstractVector{T})
-    x = convert(Bool, x)
-    for i in I
-        B[i] = x
-    end
-    return B
-end
-
 # logical indexing
 
-function setindex_bool_1d(A::BitArray, x, I::AbstractArray{Bool})
-    if length(I) > length(A)
-        throw(BoundsError())
-    end
+function setindex!(A::BitArray, x, I::AbstractArray{Bool})
+    checkbounds(A, I)
+    y = convert(Bool, x)
     Ac = A.chunks
     for i = 1:length(I)
         if I[i]
-            # faster A[i] = x
-            setindex_unchecked(Ac, convert(Bool, x), i)
+            # faster A[i] = y
+            setindex_unchecked(Ac, y, i)
         end
     end
     A
 end
 
-function setindex_bool_1d(A::BitArray, X::AbstractArray, I::AbstractArray{Bool})
-    if length(I) > length(A)
-        throw(BoundsError())
-    end
+function setindex!(A::BitArray, X::AbstractArray, I::AbstractArray{Bool})
+    checkbounds(A, I)
     Ac = A.chunks
     c = 1
     for i = 1:length(I)
@@ -618,27 +446,10 @@ function setindex_bool_1d(A::BitArray, X::AbstractArray, I::AbstractArray{Bool})
             c += 1
         end
     end
-    A
-end
-
-# lots of definitions here are required just for disambiguation
-# (see also setindex! in multidimensional.jl)
-for XT in [BitArray, AbstractArray, Any]
-    for IT in [AbstractVector{Bool}, AbstractArray{Bool}]
-        @eval setindex!(A::BitArray, X::$XT, I::$IT) = setindex_bool_1d(A, X, I)
-    end
-
-    for IT in [Range1{Bool}, AbstractVector{Bool}], JT in [Range1{Bool}, AbstractVector{Bool}]
-        @eval setindex!(A::BitMatrix, x::$XT, I::$IT, J::$JT) = (A[find(I),find(J)] = x; A)
+    if length(X) != c-1
+        throw(DimensionMismatch("assigned $(length(X)) elements to length $(c-1) destination"))
     end
-
-    for IT in [Range1{Bool}, AbstractVector{Bool}], JT in [Real, Range1]
-        @eval setindex!(A::BitMatrix, x::$XT, I::$IT, J::$JT) = (A[find(I),J] = x; A)
-    end
-    @eval setindex!{T<:Real}(A::BitMatrix, x::$XT, I::AbstractVector{Bool}, J::AbstractVector{T}) = (A[find(I),J] = x; A)
-
-    @eval setindex!(A::BitMatrix, x::$XT, I::Real, J::AbstractVector{Bool}) = (A[I,find(J)] = x; A)
-    @eval setindex!{T<:Real}(A::BitMatrix, x::$XT, I::AbstractVector{T}, J::AbstractVector{Bool}) = (A[I,find(J)] = x; A)
+    A
 end
 
 ## Dequeue functionality ##