Missing method convert{T}(Vector{T}, ::Range)

[kuanxu]

I'm not sure if this is a bug or I am missing something in v0.4.0:

julia> x = linspace(0, 2, 4)
linspace(0.0,2.0,4)

julia> convert(Array{BigFloat}, x)
ERROR: MethodError: `convert` has no method matching convert(::Type{Array{BigFloat,N}}, ::LinSpace{Float64})
This may have arisen from a call to the constructor Array{BigFloat,N}(...),
since type constructors fall back to convert methods.
Closest candidates are:
  call{T}(::Type{T}, ::Any)
  convert{T,n}(::Type{Array{T,N}}, ::Array{T,n})
  convert{T,n,S}(::Type{Array{T,N}}, ::Array{S,n})

Compare with v0.3.8:

julia> x = linspace(0, 2, 4)
4-element Array{Float64,1}:
 0.0     
 0.666667
 1.33333
 2.0     

julia> convert(Array{BigFloat}, x)
4-element Array{BigFloat,1}:
 0e+00                                                     
 6.6666666666666662965923251249478198587894439697265625e-01
 1.3333333333333332593184650249895639717578887939453125e+00
 2e+00  

I'm new to Julia. So, bear me if I'm wrong.

[pao]

linspace() produces an object that is not an array. There was recently an extensive discussion about this on julia-users: https://groups.google.com/forum/#!topic/julia-users/qPqgJS-usrU

So you will be fine if you collect(x) before converting.

If you have follow-up questions, please post them to the mailing list. Thanks!

[simonster]

We currently only have convert{T}(Vector{T}, ::Range{T}). We could implement convert{T}(Vector{T}, ::Range) and convert{T}(Array{T}, ::Range) if we wanted to, though. Is there any reason not to?

[nalimilan]

Indeed, the recent thread about this on julia-users made it clear that LinSpace should behave as much as possible like a standard array. This seems to include conversion.

[jiahao]

Cross-ref #10064

[stevengj]

Shouldn't we just have

convert{T}(::Type{Array{T}}, X::AbstractArray) = copy!(Array(T, size(X)), X)

? We shouldn't need a convert method specifically for ranges.

[simonster]

Yes, that seems right. We also probably want
convert{T,S,N}(::Type{Array{T,N}}, X::AbstractArray{S,N}) = ...

[gdevanla]

@simonster Shouldn't the second case just be:
convert{T, N}(::Type{Array{T,N}}, X::AbstractArray) = copy!(Array{T}(N), X)

I believe AbstractArray in the second argument should take care of all ranks of arrays. The only other reason we would want the definition you suggested would be to enforce the equality of rank. Is that correct?

Also, can I add this method to array.jl?

[stevengj]

@gdevania, @simonster was suggesting the case where you specify the dimensionality of the destination array explicitly, in which case the convert function should require that it matches the dimensionality of X (which it does, in @simonster's type signature).

Also, note that Array{T}(N) creates an array of length N, not dimension N; you want Array(T, size(X)) as in my example.

Basically, we just need a PR that adds two methods:

convert{T}(::Type{Array{T}}, X::AbstractArray) = copy!(Array(T, size(X)), X)
convert{T,S,N}(::Type{Array{T,N}}, X::AbstractArray{S,N}) = copy!(Array(T, size(X)), X)

[JeffBezanson]

Closed by #13683