Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

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).

share|improve this question
    
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. –  Mike Honeychurch Nov 30 '12 at 21:39
3  
A structuring along the lines of Manipulate[Module[...],mnaipulatevars...] often can be used for this purpose. This is often done in Demonstrations. –  Daniel Lichtblau Dec 1 '12 at 21:06
add comment

2 Answers

up vote 12 down vote accepted

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.
  • Re-evaluate your notebook.

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).

share|improve this answer
    
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. –  murray Dec 2 '12 at 19:57
2  
@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. –  John Fultz Dec 2 '12 at 21:12
    
@JohnFultz: This is very helpful. Thanks! –  JohnD Dec 23 '12 at 21:59
add comment

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]
    }]
 ]

enter image description here

share|improve this answer
    
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. –  JohnD Nov 30 '12 at 23:41
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.