Very good to know. Thank you for the clarification!

On Tuesday, April 7, 2015 at 5:10:43 PM UTC-4, Milan Bouchet-Valat wrote:
>
> Le mardi 07 avril 2015 à 10:56 -0700, David Gold a écrit : 
> > Comprehensions may be what you are looking for: 
> > http://docs.julialang.org/en/latest/manual/arrays/#comprehensions. 
> > 
> > For your example, 
> > 
> > julia> v = [1, 2, 3, 4] # Set the vector v 
> > 4-element Array{Int64,1}: 
> >  1 
> >  2 
> >  3 
> >  4 
> > 
> > julia> A = [ j.*v[i] for j in 1:4, i in 1:length(v) ] # Create a 2d 
> > array A where A[i, j] is given by j times the ith element of v 
> > 4x4 Array{Any,2}: 
> >  1  2   3   4 
> >  2  4   6   8 
> >  3  6   9  12 
> >  4  8  12  16 
> > 
> > 
> > 
> > 
> > I believe that, by default, arrays created using comprehensions are of 
> > type Any. 
> Actually, comprehensions use type inference to choose the type of the 
> array. But it doesn't work well when non-const global variables are 
> involved. If you declare v as const you get an Array{Int}. You could 
> also wrap this inside a function and make v an argument. 
>
> Anyway, even inside functions, you're safer specifying the element type. 
>
> For details, see https://github.com/JuliaLang/julia/issues/7258 
>
>
> Regards 
>
> > If you want an array of a specific type -- say, integer in this case 
> > -- you can do 
> > 
> > A = Int[ j.*v[i] for j in 1:4, i in 1:length(v) ] 
> > 4x4 Array{Int64,2}: 
> >  1  2   3   4 
> >  2  4   6   8 
> >  3  6   9  12 
> >  4  8  12  16 
> > 
> > 
> > 
> > Is this what you're looking for? 
> > 
> > On Saturday, April 4, 2015 at 11:04:26 AM UTC-4, Tamas Papp wrote: 
> >         Hi, 
> >         
> >         Suppose I have a function that maps an atom of type T, eg 
> >         Float64, into 
> >         Vector{T}, and takes another argument n that determines its 
> >         length. 
> >         
> >         What is the idiomatic/fast way of collecting the values in the 
> >         columns 
> >         of a matrix? 
> >         
> >         Currently I am using this: 
> >         
> >         @doc """Map elements of `x` into columns of a matrix using 
> >         `f`. 
> >         Result is assumed to have the same element type as `x`.""" -> 
> >         function maptocols{T}(f,x::Vector{T},n) 
> >           k = length(x) 
> >           b = Array(T, n, k) 
> >           for j = 1:k 
> >             b[:,j] = f(x[j],n) 
> >           end 
> >           b 
> >         end 
> >         
> >         Eg 
> >         
> >         julia> maptocols((x,n) -> x.*[1:n;], [1,2,3,4], 4) 
> >         4x4 Array{Int64,2}: 
> >          1  2   3   4 
> >          2  4   6   8 
> >          3  6   9  12 
> >          4  8  12  16 
> >         
> >         which is OK but of course I would prefer a one-liner if there 
> >         is one 
> >         provided by the language (could not find it though). 
> >         
> >         Best, 
> >         
> >         Tamas 
>
>

Reply via email to