# Localizing variables within a Manipulate

I have a notebook with several examples of very similar computations, each involving the same variable/parameter names of the ingredients used in a final Manipulate. For example,

(* example 1 *)
c = 1;
L = 1;
f[x_] = 180 x^4 (1 - x);
g[x_] = 1;
\[Lambda][n_] = ((n \[Pi])/L)^2;
a[n_] = 2/L  Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
b[n_] = 2/(L Sqrt[\[Lambda][n]] c) Integrate[g[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
u[x_, t_] = Sum[(a[i] Cos[Sqrt[\[Lambda][i]] c t] +
b[i] Sin[Sqrt[\[Lambda][i]] c t]) Sin[Sqrt[\[Lambda][i]] x], {i, 1, 10}];

Manipulate[Plot[u[x, t], {x, 0, L}, PlotStyle -> {Thick, Blue}, PlotRange -> {-15, 15},
AxesLabel -> {x, "u"}], {t, 0, 5}]

followed by

(* example 2 *)
k = .2;
L = 1;
f[x_] = 180 x (1 - x)^4;
\[Lambda][n_] = (((2 n - 1) \[Pi])/(2 L))^2;
b[n_] = 2/L  Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
u[x_, t_] = Sum[b[i] Sin[Sqrt[\[Lambda][i]] x] Exp[-\[Lambda][i] k t], {i, 1, 10}];

Manipulate[Plot[u[x, t], {x, 0, L}, PlotStyle -> {Thick, Blue}, PlotRange -> {-1, 16},
AxesLabel -> {x, "u"}], {t, 0, 5}]

As discussed in the documentation, evaluating the second block of code dynamically updates the output of the first Manipulate since the underlying quantities being plotted share the name $u(x,t)$ (among other parts) in each.

My question then is, what are some good ways to mitigate this behavior other than:

1. Choosing distinct names for all underlying quantities for each problem. (This is intractable since I may have 10+ such exercises in each notebook.)
2. Disabling dynamic updating. (This is unsatisfying since the point here is to see the Manipulate "movies".)
3. Wrapping everything in a DynamicModule,

e.g.,

(* example 1a *)
DynamicModule[{a, b, c, f, g, L, \[Lambda], u},
c = 1;
L = 1;
f[x_] = 180 x^4 (1 - x);
g[x_] = 1;
\[Lambda][n_] = ((n \[Pi])/L)^2;
a[n_] = 2/L  Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
b[n_] = 2/(L Sqrt[\[Lambda][n]] c) Integrate[g[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
u[x_, t_] = Sum[(a[i] Cos[Sqrt[\[Lambda][i]] c t] +
b[i] Sin[Sqrt[\[Lambda][i]] c t]) Sin[Sqrt[\[Lambda][i]] x], {i, 1, 10}];

Manipulate[Plot[u[x, t], {x, 0, L}, PlotStyle -> {Thick, Blue}, PlotRange -> {-15, 15},
AxesLabel -> {x, "u"}], {t, 0, 5}]]

and then

(* example 2a *)
DynamicModule[{a, b, k, f, L, \[Lambda], u},
k = .2;
L = 1;
f[x_] = 180 x (1 - x)^4;
\[Lambda][n_] = (((2 n - 1) \[Pi])/(2 L))^2;
b[n_] = 2/L  Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
u[x_, t_] = Sum[b[i] Sin[Sqrt[\[Lambda][i]] x] Exp[-\[Lambda][i] k t], {i, 1, 10}];

Manipulate[Plot[u[x, t], {x, 0, L}, PlotStyle -> {Thick, Blue}, PlotRange -> {-1, 16},
AxesLabel -> {x, "u"}], {t, 0, 5}]]

This at least does what I am after: the variable/parameter names that are recycled across exercises are localized to its respective Manipulate. This just felt a little clunky and requires quite a bit of explanation to students about why we need to do this.

I was curious if there were other/better ways to accomplish this (that I could then share with them).

• given what you have experimented with as a solution, and given the simplicity of your Manipulate it is probably best to just use DynamicModule and do away with the Manipulate or vica versa. Commented Nov 30, 2012 at 21:39
• A structuring along the lines of Manipulate[Module[...],mnaipulatevars...] often can be used for this purpose. This is often done in Demonstrations. Commented Dec 1, 2012 at 21:06

In your notebook, do the following:

• Separate the examples into cell groups. You can use, e.g., Section or Subsection cells to do this.
• Choose the menu item Evaluation->Notebook's Default Context->Unique to Each Cell Group.

You'll now get the code isolation you're looking for. By using the menu item I point out, you're instructing the FE to automatically create and manage a guaranteed-unique context name for each cell group. You can see the results of this by evaluating \$Context in the various cell groups if you're interested in exploring how it works.

Note that, in addition to isolating the context, Mathematica also isolates the line numbering, the history (as accessible by %), and the context path (so a Needs called in one section will not make the package available to other sections or other notebooks).

• Is the "Unique to Each Cell Group" context choice new in Mathematica 9? (If not, I never noticed it before.) It can cure many ills -- and has the potential for really confusing things if invoked inadvertently, or invoked deliberately and then forgotten about. Commented Dec 2, 2012 at 19:57
• @murray No, it's been around for a while. It's used by default in the help viewer examples; that's how you don't end up with all kinds of variable over-scribbling in those examples. But I rarely point it out to users because it rarely answers a real-world need (as was the case here). More common would be notebook-level isolation...i.e., all inputs in a given notebook share a context, but the notebook is context-isolated from all other notebooks. Commented Dec 2, 2012 at 21:12
• @JohnFultz: This is very helpful. Thanks! Commented Dec 23, 2012 at 21:59

I haven't looked at whether your code is optimal, just localized everything and made it look like a Manipulate

DynamicModule[{a, b, k, f, L, \[Lambda], u, t},
k = .2;
L = 1;
f[x_] = 180 x (1 - x)^4;
\[Lambda][n_] = (((2 n - 1) \[Pi])/(2 L))^2;
b[n_] = 2/L Integrate[f[x] Sin[Sqrt[\[Lambda][n]] x], {x, 0, L}];
u[x_, t_] =
Sum[b[i] Sin[Sqrt[\[Lambda][i]] x] Exp[-\[Lambda][i] k t], {i, 1,
10}];

Panel@Column[{
Row[{"t", Spacer[5], Manipulator[Dynamic[t], {0, 5}]}],
Framed[
Dynamic@Plot[u[x, t], {x, 0, L},
ImageSize -> 400,
PlotStyle -> {Thick, Blue},
PlotRange -> {-1, 16},
AxesLabel -> {"x", "u"}],
Background -> White,
FrameStyle -> LightGray,
FrameMargins -> 10]
}]
]

• This is certainly different than my approach, but is there any upside to this vs. a simple Manipulate? I just want to make sure I understand your answer. Commented Nov 30, 2012 at 23:41