# How can I use parts of lists with Dynamic?

I'm a newbie - what am I doing wrong? I want to use parts of lists (vectors) in calculations but Mathematica will not evaluate anything that involves parts of lists that update dynamically. Is there a way round this?

Example 1 (can't add u[]+u[]):

{Slider[Dynamic[a], {0, 10, 1}], Dynamic[a]}

u = Dynamic@{a, a + 1}
u[] + u[]

Out= {2,3}
Out= Dynamic
Out= List
During evaluation of In:= Part::partw: Part 2 of {2,3} does not exist. >>
Out= {({2,3})[]+7,({2,3})[]+8}


Example 2 (can't add v[]+v[]):

{Slider[Dynamic[a], {0, 10, 1}], Dynamic[a]}

v = {Dynamic[a], Dynamic[a + 1]}
v[] + v[]

Out= {2,3}
Out= List
Out= 3+2


Example 3 (w[] + w[] doesn't update dynamically):

{Slider[Dynamic[a], {0, 10, 1}], Dynamic[a]}

w = {a, a + 1}
Dynamic[w] (* doesn't update *)
w[] + w[](* doesn't update *)

Out= {4,5}
Out= {4,5}
Out= 9

• Hi, welcome to Mathematica.SE, please consider taking the tour so you learn the basics of the site. Once you gain enough reputation by making good questions you will be able to vote up and down both questions and answers. When you see good ones, please vote them up by clicking the grey triangles, because the credibility of the system is based on the reputation gained by users sharing their knowledge. As you receive help, try to give it too, by answering questions in your area of expertise. – rhermans Nov 25 '14 at 22:52
• w := {a, a + 1}; Dynamic[ w[] + w[] ] – Kuba Nov 25 '14 at 22:57
• Please take a look at tutorial: IntroductionToDynamic. – Kuba Nov 25 '14 at 23:00
• Thank you. The delayed assignment makes all the difference, which sort of makes sense though it's stretching my understanding. I've looked at every Dynamic tutorial I can find but it still seems a bit random (though this is probably because Mathematica as a whole is still new to me). – Adam Nieman Nov 26 '14 at 1:34

{Slider[Dynamic[a], {0, 10, 1}], Dynamic[a]}

Dynamic[u = {a, a + 1}]
Dynamic[u[] + u[]]


## Edit

Regarding Kuba's comment

So is pure code an educational answer then?

No, of course it is not and most of my answers reflect that I care about this. Let me make some extensions to my answer by going through your examples and explaining in detail what goes wrong:

### Example 1:

{Slider[Dynamic[a], {0, 10, 1}], Dynamic[a]}
u = Dynamic[{a, a + 1}]


When you first evaluate this, then you see the slider and the output {0,1}. What you have to understand is, that although you see a list of numbers, this is only the display form of a much more complex expression. In fact, if you evaluate u // InputForm, you see that u is not a list of numbers, but still Dynamic[{a, a + 1}].

The front end transforms this into the dynamically changing list of numbers for you, but only for displaying purpose. If you now try to use u[] you basically extract the {a, a+1} part, because this is the first element of the expression Dynamic[{a,a+1}]. This is, because a has a value, instantly converted into {0,1}

u[]
(* {0, 1} *)


It should be clear now, that u[] doesn't exists, because the expression Dynamic[{a,a+1}] has only one argument. Therefore you get the error message. If you want to add the two values inside Dynamic, you still can do this. You only have to keep the Dynamic intact and everything will work. Let me give an example where you see what happens:

Plus @@@ dynamic[{myA, myA + 1}]
(* dynamic[1 + 2 myA] *)


When you think of your original expression, chances are good that this does the thing you tried with u[]+u[] and the wrapping dynamic will still be there. Let's try it:

Plus@@@u
(* after moving the slider: 7 *)


I hope this clears the situation a bit.

### Example 2:

Your second example has exactly the same problem:

v = {Dynamic[a], Dynamic[a + 1]}
v[] + v[]


Again, keep in mind that the Dynamic doesn't go away. You just don't see it anymore, but it is still there! So if you want a non-dynamic version of your sum, you need to access the inner parts of the two Dynamic:

v[[1, 1]] + v[[2, 1]]
(* 7 here *)


If you want a dynamically changing sum, you have to keep the Dynamic wrapped around your expression. One way is the replacement

v /. {Dynamic[first_], Dynamic[last_]} :> Dynamic[first + last]


### Example 3:

In your third example, unfortunately everything is too late. In the moment you evaluate

w = {a, a + 1}


the right hand side is evaluated. Since a has a value, w is assigned a list of numbers and does never know that you want it to depend on a. The workaround was already given by Kuba.

• Without any comments it may be misleading, as soon as Dynamic[u = {a, a + 1}] scrolls out of the view... :) – Kuba Nov 25 '14 at 23:07
• @Kuba That's one of the first lessons you have to learn, that things with Dynamic only make sense when they are displayed. You could use a single Dynamic and pack assignment and access of u[[..]] into one place, or you use delayed assignment as you showed. But currently, the question lacks of the information, what he tries to achieve. – halirutan Nov 25 '14 at 23:14
• This way makes less intuitive sense to me, but I suppose it works the same way as the SetDelayed. The reason I need dynamic access to parts of lists is I'm trying to do some astronomy using sidereal time as a dynamic variable that determines the orientation of all sorts of planes and vectors. – Adam Nieman Nov 26 '14 at 1:36
• @halirutan that is the comment I was looking for :) My point was that OP is clearly new and not aware of the basic concepts of Dynamic. So is pure code an educational answer then? – Kuba Nov 26 '14 at 8:49
• @Kuba Better now? – halirutan Dec 4 '14 at 1:24