# How are parameters evaluated for a Plot in Manipulate

I am trying to get my head around how Manipulate evaluates functions in a Plot. I have read the introduction to Manipulate, and introduction to Dynamic, but I still can't figure it.

For my specific example, I have a function bigA parameterised by m1 and m2 (this relates to question),

bigA[t_]:= (m1+m2) ((m1 m2 t)/(m1+m2)^3)^0.25


So when I try to plot it in Manipulate,

Manipulate[
Plot[bigA[t], {t, 1, 10}],
{{m1, 1.4}, 0.8, 3},
{{m2, 1.4}, 0.8, 3}]


Nothing appears. I presume this is because m1 and m2 aren't being evaluated. But I don't know what the order is supposed to be.

# Edit

The thing is, this seems to work when I Evaluate and don't plot, i.e,

Manipulate[Evaluate@bigA[t],
{{m1, 1.4}, 0.8, 3},
{{m2, 1.4}, 0.8, 3}]


So couldn't I just stick a Plot command in there somewhere?

• I think, this discussion is strongly relevant, even though not being specifically about Manipulate, since your real question is on how to properly localize variables in functions definitions - as the answers posted already also indicate. Sep 14, 2012 at 15:13
• Related: (8625) Feb 11, 2017 at 0:55

The problem is that inside the Manipulate, m1 and m2 are replaced with localized versions (as in Module) rather than assigned (as in Block). Since the m1 and m2 from bigA are outside the Manipulate, and bigA[t] is evaluated only after the replacement of m1 and m2 inside the Manipulate, they are not affected by the manipulation.

The best solution is to give m1 and m2 as extra arguments:

bigA[t_, m1_, m2_] := (m1+m2) ((m1 m2 t)/(m1+m2)^3)^0.25
Manipulate[Plot[bigA[t, m1, m2], {t, 1, 10}],
{{m1, 1.4}, 0.8, 3},
{{m2, 1.4}, 0.8, 3}]


If for some reason you cannot do that, you can also use replacement rules as follows:

bigA[t_] := (m1+m2) ((m1 m2 t)/(m1+m2)^3)^0.25
Manipulate[Plot[bigA[t]/.{m1->mm1,m2->mm2}, {t, 1, 10}],
{{mm1, 1.4}, 0.8, 3},
{{mm2, 1.4}, 0.8, 3}]


This works because ReplaceAll (/.) does the replacements only after the left hand side has been evaluated, and the mm1 and mm2 are now inside the Manipulate, so they can be properly localized.

By adding Evaluate@ at the beginning of the argument to Manipulate, you override Mathematica's order of evaluation. So with

Manipulate[Evaluate@bigA[t],
{{m1, 1.4}, 0.8, 3},
{{m2, 1.4}, 0.8, 3}]


Mathematica first evaluates bigA[t] to (m1+m2) ((m1 m2 t)/(m1+m2)^3)^0.25, and only then proceeds to evaluate the Manipulate, which therefore sees the m1 and m2.

Now this will not work with Plot, because the whole Plot statement will be executed, before Manipulate will have a chance to insert m1 and m2. So when Plot evaluates bigA[t], it will receive an expression containing m1 and m2 instead of a number, and thus produce an empty graph. This graph (which no longer contains any trace of m1 or m2) will then be passed to Manipulate. Of course replacing m1 and m2 at this stage doesn't work, because they already vanished.

So in essence, while without Evaluate, m1 and m2 are substituted too late, with Evaluate@Plot they are consumed too early.

Now you might have the idea to use Manipulate[Plot[Evaluate@bigA[t],...],...] instead, in order to evaluate bigA[t] (to get m1 and m2 visible) but not Plot (because that only works after m1 and m2 got a value). However that doesn't work either, because Evaluate only affects order of evaluation when it appears as immediate argument of the expression being evaluated. So while evaluating Manipulate, the Evaluate in the argument of Plot is not considered. It will be considered at the time Plot is evaluated, but at that time it's already too late.

• Thanks @celtschk, what about the case where I evaluate the function, but don't plot it (please see my edited question above). Why would this work, but not the plot? Sep 14, 2012 at 7:41
• @ShaunH: That works because you added an explicit Evaluate here, overriding the standard order of evaluation. Note however that this works only if the Evaluate is top-level on the Manipulate argument. Sep 14, 2012 at 7:51
• ok thanks for the explanation on how Evaluate works. That really did confuse me. So basically, it only works at the top level. Ok, so I will just have to define the parameters as variables. Sep 14, 2012 at 8:21
• Shouldn't the first Manipulate not have bigA[t,m1,m2] instead of bigA[t]? May 20, 2013 at 10:09
• @SjoerdC.deVries: Yes, you're right. I'll correct this. May 30, 2013 at 18:01

A couple of tips:

• Make sure you evaluate the function - best way is to put it in Initialization :> ...
• Rather keep parameters m1, m2 as arguments
• Fix PlotRange to see function change, not the axes scale
• Use SaveDefinitions -> True so interface will remember your defined function when you reopen notebook

I updated the code below to encompass your derivative question:

Manipulate[Plot[Evaluate@{bigA[t, m1, m2], D[bigA[t, m1, m2], t]}, {t, 1, 10},
PlotRange -> {0, 3}, Filling -> 0], {{m1, 1.4}, 0.8, 3}, {{m2, 1.4}, 0.8, 3},
Initialization :> (bigA[t_, m1_, m2_] := (m1 + m2) ((m1 m2 t)/(m1 + m2)^3)^0.25),
SaveDefinitions -> True] • Thanks @Vitaliy. So the key change here is to put the parameters m1 and m2 as functions, right? I guess that is just the way you should do things in Mathematica. But for some reason it doesn't seem right to me. For example, if I wanted to differentiate bigA with respect to t, would m1 and m2 still be kept symbolic? Sep 14, 2012 at 7:31
• @ShaunH (1) you mean m1 and m2 as "variables", - and the answer is yes, celtschk in his answer has good explanation. (2) yes, m1 and m2 would still be kept symbolic, in Mathematica by default almost everything is symbolic, unless defined to be numeric. I updated the code to illustrate this by adding the computation and graph of derivative Sep 14, 2012 at 7:44
• Sorry, I meant variables, not functions. You've almost sold me that this should be the way to go, except for one thing. It seems to work when you Evaluate, but not plot (see my edit to the original question). Isn't there someway we could just include an Evaluate command and keep m1, m2 as parameters? Sep 14, 2012 at 7:50

Manipulate does not temporarily change the global value of its variables, as does Table and Do. Compare:

Dynamic[x]
Do[Pause, {x, 0, 10}]


With:

Dynamic[x]
Manipulate[x, {x, 0, 10}]


Since your definition of bigA relies on Global symbols m1 and m2 you must manually change these values, e.g. using Block:

bigA[t_] := (m1 + m2) ((m1 m2 t)/(m1 + m2)^3)^0.25

Manipulate[
Block[{m1 = mm1, m2 = mm2},
Plot[bigA[t], {t, 1, 10}]
],
{{mm1, 1.4}, 0.8, 3},
{{mm2, 1.4}, 0.8, 3}
]


Or you could insert the definition of bigA into manipulate using With so that it appears explicitly (assuming no global values for m1, m2, or t):

With[{x = bigA[t]},
Manipulate[
Plot[x, {t, 1, 10}],
{{m1, 1.4}, 0.8, 3},
{{m2, 1.4}, 0.8, 3}
]
]


Simpler and cleaner is to just parametrize m1 and m2 as belisarius shows.

For example you can do the following to get proper localization

bigA[t_, m1_, m2_] := (m1 + m2) ((m1 m2 t)/(m1 + m2)^3)^0.25
Manipulate[
Plot[bigA[t, m1, m2], {t, 1, 10}],
{{m1, 1.4}, 0.8, 3},
{{m2, 1.4}, 0.8, 3}]


This works and is very simple!!

bigA[t_] := (m1 + m2) ((m1 m2 t)/(m1 + m2)^3)^0.25;
Manipulate[
Plot[#, {t, 1, 10}],
{{m1, 1.4}, 0.8, 3},
{{m2, 1.4}, 0.8, 3}] &@bigA[t]


Copy-paste the definition of the function (or evaluate it and copy the resulting code) to inside the plot. In other words

Manipulate[
Plot[(m1+m2) ((m1 m2 t)/(m1+m2)^3)^0.25, {t, 1, 10}],
{{m1, 1.4}, 0.8, 3},
{{m2, 1.4}, 0.8, 3}]
`

I understand that this is not the neatest solution, but the big elephant in the room is that this is by far the simplest and most convenient way to circumvent this limitation.