# Extract vector of values from vector of T

Imagine I have

``````type T
x::Array{Float64,1}
f::Array{Float64,1}
T()=new(zeros(3),zeros(2))
end

v=Array{T}(10)
``````

I would then like to write something like

``````x1[1:10]=v[1:10].x[1]
``````

this doesn’t work because “type Array has no field x”. I can certainly extract all the x[1] from the individual members of the array v and put them in a vector x1 with a loop but I was wondering if there is a more Julia-esque way of doing it.

``````v=Array{T}(10)
``````

Note that this doesn’t create any `T` objects (elements of `v` are `#undef`). You probably want

``````v = [T() for _ = 1 : 10]
``````

Then to get the `x1`s you can do e.g.

``````map(t -> t.x[1], v)
``````

or

``````(t -> t.x[1]).(v)
``````
1 Like

Interestingly, this is a good example of why the `Array` constructors have been changed in 0.7. In 0.7, to declare `v` the way you did you’d have to explicitly do

``````v = Array{T}(undef, 10)
``````
1 Like

`v = Array{T}(undef, 10)`

Fixed that for you

Oh god, did this seriously just get changed? I had done so much inserting of `uninitialized`… When did this happen?

https://github.com/JuliaLang/julia/pull/26316

Search and replacing `uninitialized´ should be fairly easy though.
Took me only a few minutes for whole of Base.

Well, not sure I would have voted for `undef` but `uninitialized` is definitely one of the hardest words to type in the English language, so I’m not complaining.

1 Like

Yes, I knew that my elements of v are #undef, just wanted to keep the description to a minimum. The interesting part for me was the

map(t → t.x[1], v)

Thanks! (for all the help I am receiving here I owe you all beer/coffee/whatever… ring a bell if you ever come to Padua/Venice, Italy)

1 Like

By the way, all of the suggestions here are good ones, but it’s worth noting that they’re all just helpful shortcuts for extracting each `x` element in a loop. One of the nicest things about Julia is that your first instinct (“extract all the x[1] from the individual members of the array v and put them in a vector x1 with a loop”) is basically the right thing to do and will be just as efficient as the “built-in” solutions like `map`. The `map` function is just nice because it creates that loop for you and makes the intent of your code clear.

3 Likes

This is a lengthy thread, but you might find the discussion interesting

1 Like