Fix #76

Note that I made AbstractDataArray inherit from StoredArray instead
of AbstractArray, since both DataArray and PooledDataArray are
StoredArrays. DataArray should probably inherit from DenseArray, and
the inheritance should probably be on those types and not
AbstractDataArray, but we don't have multiple inheritance, so this
seems like the way to go for now.

Author: simonster

src/abstractdataarray.jl

@@ -2,7 +2,7 @@
 #'
 #' An AbstractDataArray is an Array whose entries can take on
 #' values of type `T` or the value `NA`.
-abstract AbstractDataArray{T, N} <: AbstractArray{T, N}
+abstract AbstractDataArray{T, N} <: StoredArray{T, N}
 
 #' @description
 #'

src/operators.jl

@@ -364,10 +364,9 @@ for f in unary_operators
     @eval $(f)(d::NAtype) = NA
 end
 
-# Unary operators, DataArrays. Definitions in base should be adequate
-# for AbstractDataArrays. These are just optimizations
-Base.(:!)(d::DataArray{Bool}) = DataArray(!d.data, copy(d.na))
-Base.(:-)(d::DataArray) = DataArray(-d.data, copy(d.na))
+# Unary operators, DataArrays.
+@dataarray_unary Base.(:(-)) Any T
+@dataarray_unary Base.(:(!)) Bool T
 
 # Treat ctranspose and * in a special way
 for (f, elf) in ((:(Base.ctranspose), :conj), (:(Base.transpose), :identity))

test/operators.jl

@@ -70,27 +70,29 @@ module TestOperators
     end
 
     # transpose and ctranpose on DataVectors and DataMatrices
-    for a in ([1, 2, 3, 4], [1.0+1.0im, 2.0-2.0im, 3.0+3.0im, 4.0-4.0im],
-              [1 2; 3 4], [1.0+1.0im 2.0-2.0im; 3.0+3.0im 4.0-4.0im])
-    end
     for (da, dat) in ((@data([5, 2, 3, 4]), @data([5 2 3 4])),
                       (@data([1.0+1.0im, 5.0, 3.0+3.0im, 4.0-4.0im]), @data([1.0+1.0im 5.0 3.0+3.0im 4.0-4.0im])),
                       (@data([1 2; 5 4]), @data([1 5; 2 4])),
                       (@data([1.0+1.0im 2.0-2.0im; 3.0+3.0im 5.0]), @data([1.0+1.0im 3.0+3.0im; 2.0-2.0im 5.0])))
         # Test for both bits and non-bits types
         for da in (da, convert(DataArray{Number}, da))
-            # No NA
-            @test isequal(da.', dat)
-            @test isequal(da', conj(dat))
-
-            # With NA
-            # XXX we should fix indexing so that vec isn't necessary
-            da[vec(da .== 5)] = NA
-            dat[vec(dat .== 5)] = NA
-            # Make sure that NAs are undefined in the non-bits array
-            da = conj(conj(da))
-            @test isequal(da.', dat)
-            @test isequal(da', conj(dat))
+            let da = copy(da), dat = copy(dat)
+                # No NA
+                @test isequal(da.', dat)
+                @test isequal(da', conj(dat))
+
+                # With NA
+                # XXX we should fix indexing so that this isn't necessary
+                for i = 1:length(da)
+                    da[i] == 5 && (da[i] = NA)
+                    dat[i] == 5 && (dat[i] = NA)
+                end
+
+                # Make sure that NAs are undefined in the non-bits array
+                da = conj(conj(da))
+                @test isequal(da.', dat)
+                @test isequal(da', conj(dat))
+            end
         end
     end