Merge pull request #150 from yesimon/convert

Replace array with Base.convert

Author: simonster

src/dataarray.jl

@@ -328,80 +328,74 @@ end
 
 #' @description
 #'
-#' Turn a DataArray into an Array. Raises an error if NA's are encountered.
+#' Convert a DataArray{T} to an Array{S}. Throws an `NAException`
+#' if the input contains `NA` values that prohibit conversion.
 #'
-#' @param da::DataArray{T} DataArray that will be converted to an Array.
+#' @param da::DataArray{T} The DataArray that will be converted.
 #'
-#' @returns a::Array{T} Array containing values of `da`.
+#' @returns a::Array{S} The (possibly type-converted) elements of
+#'         `da` if none were `NA`.
 #'
 #' @examples
 #'
-#' dv = @data [1, 2, 3, 4]
-#' v = array(dv)
+#' da = @data [1 2; 3 NA]
+#' a = convert(Array{Float64}, da)
 #'
-#' dm = @data [1 2; 3 4]
-#' m = array(dm)
-function array{T}(da::DataArray{T}) # -> Array{T}
-    res = Array(T, size(da))
-    for i in 1:length(da)
-        if da.na[i]
-            throw(NAException())
-        else
-            res[i] = da.data[i]
-        end
+#' da = @data [1 2; 3 4]
+#' a = convert(Array{Float64}, da)
+function Base.convert{S, T, N}(::Type{Array{S, N}},
+                               x::DataArray{T, N}) # -> Array{S, N}
+    if anyna(x)
+        err = "Cannot convert DataArray with NA's to desired type"
+        throw(NAException(err))
+    else
+        return convert(Array{S, N}, x.data)
     end
-    return res
 end
 
-#' @description
-#'
-#' Turn a DataArray into an Array. Replace any NA's with the value
-#' of second argument, `replacement`.
-#'
-#' @param da::DataArray{T} DataArray that will be converted to an Array.
-#' @param replacement::T Value that will replace NA's in `da`.
-#'
-#' @returns a::Array{T} Array containing values of `da` plus replacements.
-#'
-#' @examples
-#'
-#' dv = @data [1, 2, NA, 4]
-#' v = array(dv, 3)
-#'
-#' dm = @data [1 2; NA 4]
-#' m = array(dm, 3)
-function array{T}(da::DataArray{T}, replacement::T) # -> Array{T}
-    res = Array(T, size(da))
+function Base.convert{S, T, N}(::Type{Array{S}}, da::DataArray{T, N})
+    return convert(Array{S, N}, da)
+end
+
+function Base.convert{T}(::Type{Vector}, dv::DataVector{T})
+    return convert(Array{T, 1}, dv)
+end
+
+function Base.convert{T}(::Type{Matrix}, dm::DataMatrix{T})
+    return convert(Array{T, 2}, dm)
+end
+
+function Base.convert{T, N}(::Type{Array}, da::DataArray{T, N})
+    return convert(Array{T, N}, da)
+end
+
+function Base.convert{S, T, N}(
+    ::Type{Array{S, N}},
+    da::DataArray{T, N},
+    replacement::Any
+) # -> Array{S, N}
+    replacementS = convert(S, replacement)
+    res = Array(S, size(da))
     for i in 1:length(da)
         if da.na[i]
-            res[i] = replacement
+            res[i] = replacementS
         else
             res[i] = da.data[i]
         end
     end
     return res
 end
 
-#' @description
-#'
-#' Turn a DataArray into an Array. Replace any NA's with the value
-#' of second argument, `replacement`.
-#'
-#' @param da::DataArray{T} DataArray that will be converted to an Array.
-#' @param replacement::Any Value that will replace NA's in `da`.
-#'        Converted to the `eltype`, `T`, of `da`.
-#'
-#' @returns a::Array{T} Array containing values of `da` plus replacements.
-#'
-#' @examples
-#'
-#' dv = @data [1, 2, NA, 4]
-#' v = array(dv, 3)
-#'
-#' dm = @data [1 2; NA 4]
-#' m = array(dm, 3)
-function array{T}(da::DataArray{T}, replacement::Any) # -> Array{T}
-    return array(da, convert(T, replacement))
+function Base.convert{T}(::Type{Vector}, dv::DataVector{T}, replacement::Any)
+    return convert(Array{T, 1}, dv, replacement)
+end
+
+function Base.convert{T}(::Type{Matrix}, dm::DataMatrix{T}, replacement::Any)
+    return convert(Array{T, 2}, dm, replacement)
+end
+
+function Base.convert{T, N}(::Type{Array}, da::DataArray{T, N}, replacement::Any)
+    return convert(Array{T, N}, da, replacement)
 end
 
 #' @description
@@ -537,37 +531,6 @@ end
 #                    ::Type{T}) = promote_rule(S, T)
 # promote_rule{T}(::Type{AbstractDataArray{T}}, ::Type{T}) = T
 
-#' @description
-#'
-#' Convert a DataArray{T} to an Array{S}. Throws an `NAException`
-#' if the input contains `NA` values that prohibit conversion.
-#'
-#' @param da::DataArray{T} The DataArray that will be converted.
-#'
-#' @returns a::Array{S} The (possibly type-converted) elements of
-#'         `da` if none were `NA`.
-#'
-#' @examples
-#'
-#' da = @data [1 2; 3 NA]
-#' a = convert(Array{Float64}, da)
-#'
-#' da = @data [1 2; 3 4]
-#' a = convert(Array{Float64}, da)
-function Base.convert{S, T, N}(::Type{Array{S, N}},
-                               x::DataArray{T, N}) # -> Array{S, N}
-    if anyna(x)
-        err = "Cannot convert DataArray with NA's to desired type"
-        throw(NAException(err))
-    else
-        return convert(Array{S, N}, x.data)
-    end
-end
-Base.convert{S,T,N}(::Type{Array{S}}, x::DataArray{T,N}) =
-    convert(Array{S,N}, x)
-Base.convert{T,N}(::Type{Array}, x::DataArray{T,N}) =
-    convert(Array{T,N}, x)
-
 #' @description
 #'
 #' Convert an Array{T} to a DataArray{S}.

src/deprecated.jl

@@ -2,3 +2,115 @@
 #       when the deprecation is removed
 import Base.@deprecate
 @deprecate (/)(x::Union(NAtype,Number),A::AbstractDataArray)    x ./ A
+
+#' @description
+#'
+#' Turn a DataArray into an Array. Raises an error if NA's are encountered.
+#'
+#' @param da::DataArray{T} DataArray that will be converted to an Array.
+#'
+#' @returns a::Array{T} Array containing values of `da`.
+#'
+#' @examples
+#'
+#' dv = @data [1, 2, 3, 4]
+#' v = convert(Vector, dv)
+#'
+#' dm = @data [1 2; 3 4]
+#' m = convert(Matrix, dm)
+function array{T}(da::DataArray{T}) # -> Array{T}
+    Base.depwarn(
+        """
+        array(da::DataArray{T}) is deprecated.
+        Use convert(Array, da).
+        """,
+        :array
+    )
+    res = Array(T, size(da))
+    for i in 1:length(da)
+        if da.na[i]
+            throw(NAException())
+        else
+            res[i] = da.data[i]
+        end
+    end
+    return res
+end
+
+#' @description
+#'
+#' Turn a DataArray into an Array. Replace any NA's with the value
+#' of second argument, `replacement`.
+#'
+#' @param da::DataArray{T} DataArray that will be converted to an Array.
+#' @param replacement::T Value that will replace NA's in `da`.
+#'
+#' @returns a::Array{T} Array containing values of `da` plus replacements.
+#'
+#' @examples
+#'
+#' dv = @data [1, 2, NA, 4]
+#' v = convert(Vector, dv, 3)
+#'
+#' dm = @data [1 2; NA 4]
+#' m = convert(Matrix, dm, 3)
+function array{T}(da::DataArray{T}, replacement::Any) # -> Array{T}
+    Base.depwarn(
+        """
+        array(da::DataArray{T}, replacement::Any) is deprecated.
+        Use convert(Array, da, replacement) instead.
+        """,
+        :array
+    )
+    res = Array(T, size(da))
+    replacementT = convert(T, replacement)
+    for i in 1:length(da)
+        if da.na[i]
+            res[i] = replacementT
+        else
+            res[i] = da.data[i]
+        end
+    end
+    return res
+end
+
+# Turn a PooledDataArray into an Array. Fail on NA
+function array{T, R}(da::PooledDataArray{T, R})
+    Base.depwarn(
+        """
+        array(pda::PooledDataArray{T, R}) is deprecated.
+        Use convert(Array, pda) instead.
+        """,
+        :array
+    )
+    n = length(da)
+    res = Array(T, size(da))
+    for i in 1:n
+        if da.refs[i] == zero(R)
+            throw(NAException())
+        else
+            res[i] = da.pool[da.refs[i]]
+        end
+    end
+    return res
+end
+
+function array{T, R}(da::PooledDataArray{T, R}, replacement::T)
+    Base.depwarn(
+        """
+        array(pda::PooledDataArray{T, R}, replacement::T) is deprecated.
+        Use convert(Array, pda, replacement) instead.
+        """,
+        :array
+    )
+    n = length(da)
+    res = Array(T, size(da))
+    for i in 1:n
+        if da.refs[i] == zero(R)
+            res[i] = replacement
+        else
+            res[i] = da.pool[da.refs[i]]
+        end
+    end
+    return res
+end

src/pooleddataarray.jl

@@ -459,7 +459,7 @@ end
 ##
 ##############################################################################
 
-Base.find(pdv::PooledDataVector{Bool}) = find(array(pdv, false))
+Base.find(pdv::PooledDataVector{Bool}) = find(convert(Vector{Bool}, pdv, false))
 
 ##############################################################################
 ##
@@ -763,33 +763,62 @@ Base.convert{T,R<:Integer,N}(::Type{DataArray}, pda::PooledDataArray{T,R,N}) =
 
 pdata(a::AbstractArray) = convert(PooledDataArray, a)
 
-# Turn a PooledDataArray into an Array. Fail on NA
-function array{T, R}(da::PooledDataArray{T, R})
-    n = length(da)
-    res = Array(T, size(da))
-    for i in 1:n
-        if da.refs[i] == zero(R)
+function Base.convert{S, T, R, N}(
+    ::Type{Array{S, N}},
+    pda::PooledDataArray{T, R, N}
+)
+    res = Array(S, size(pda))
+    for i in 1:length(pda)
+        if pda.refs[i] == zero(R)
             throw(NAException())
         else
-            res[i] = da.pool[da.refs[i]]
+            res[i] = pda.pool[pda.refs[i]]
         end
     end
     return res
 end
 
-function array{T, R}(da::PooledDataArray{T, R}, replacement::T)
-    n = length(da)
-    res = Array(T, size(da))
-    for i in 1:n
-        if da.refs[i] == zero(R)
-            res[i] = replacement
+function Base.convert{T, R}(::Type{Vector}, pdv::PooledDataVector{T, R})
+    return convert(Array{T, 1}, pdv)
+end
+
+function Base.convert{T, R}(::Type{Matrix}, pdm::PooledDataMatrix{T, R})
+    return convert(Array{T, 2}, pdm)
+end
+
+function Base.convert{T, R, N}(::Type{Array}, pda::PooledDataArray{T, R, N})
+    return convert(Array{T, N}, pda)
+end
+
+function Base.convert{S, T, R, N}(
+    ::Type{Array{S, N}},
+    pda::PooledDataArray{T, R, N},
+    replacement::Any
+)
+    res = Array(S, size(pda))
+    replacementS = convert(S, replacement)
+    for i in 1:length(pda)
+        if pda.refs[i] == zero(R)
+            res[i] = replacementS
         else
-            res[i] = da.pool[da.refs[i]]
+            res[i] = pda.pool[pda.refs[i]]
         end
     end
     return res
 end
 
+function Base.convert{T, R}(::Type{Vector}, pdv::PooledDataVector{T, R}, replacement::Any)
+    return convert(Array{T, 1}, pdv, replacement)
+end
+
+function Base.convert{T, R}(::Type{Matrix}, pdm::PooledDataMatrix{T, R}, replacement::Any)
+    return convert(Array{T, 2}, pdm, replacement)
+end
+
+function Base.convert{T, R, N}(::Type{Array}, pda::PooledDataArray{T, R, N}, replacement::Any)
+    return convert(Array{T, N}, pda, replacement)
+end
+
 function dropna{T}(pdv::PooledDataVector{T})
     n = length(pdv)
     res = Array(T, n)