Multiple Plots inside a Manipulate with different dynamic variables on their x-axes

Question

I have an expression with lots of variables, and I would like to make several plots of the expression, where the axis in each is a different variable. The idea is to put them side by side inside a Manipulate structure that lets me move around the values of the rest. But I am having problems with order of evaluation, because sometimes the value of x gets substituted in before Plot gets a hold of it.

Here is an example. Let's say my expression is x^y. The following code works perfectly, and is an example of what I am trying to make more modular:

Manipulate[
 GraphicsRow[{
   Plot[x^y, {x, .1, 2}, AxesLabel -> {"x"}] , 
   Plot[x^y, {y, .1, 2}, AxesLabel -> {"y"}] }],
 {x, .1, 2}, {y, .1, 2}]

It works, I believe, because the first Plot looks for its variable x and scopes the x in x^y as local (something like FE`x$$1010 before Manipulate gets to substitute in the value from the slider. (Is this right?)

Now, in my application, the expressions to be plotted, and the variables and range against which to plot, are more dynamic. Here is my failed attempt at this:

With[{exprsToPlot = {x^y, x^y}, 
      plotRangeSpecs = {{x, .1, 2}, {y, .1, 2}}}, 
  Manipulate[
    MapThread[Plot,  {exprsToPlot, plotRangeSpecs}],
    {x, .1, 2}, {y, .1, 2}  ] ]

(I left out the AxesLabel because I'd first like to get the basic piece to work, though if any solution-writer wants to make that and other plot options work, I'd be impressed.)

I also tried using Thread instead of MapThread, which actually mostly works, while throwing errors:

With[{exprsToPlot = {x^y, x^y}, 
    plotRangeSpecs = {{x, .1, 2}, {y, .1, 2}}}, 
  Manipulate[  Thread[Plot[exprsToPlot, plotRangeSpecs]]

I think the solution involves holding the variable to plot (x and y respectively) but not the others, I haven't been able to implement this. I tried to make my own version of MapThread with the attribute HoldAll, but that won't do because the variables other than the x-axis ones (y and x, respectively) do need to be substituted for their values from the sliders before Plot gets a hold of them.

It would be ideal if the solution could take named arguments in a list too, as in setting plotLabels={"title1", "title2"}, and having plotLabels be another list argument passed to Plot. But Thread isn't set up to deal with named arguments, as far as I know.

Also, in my example I plotted the same x^y in both figures, but in general the entries of exprsToPlot may not be the same.

Answer 1

From the OP comments the slices (or contours) of a multi-dimensional function is what is being sought.

A way to do this is the have each Plot in Manipulate set as Dynamic on the variables not on the x-axis. Such that, as these variables are adjusted the contour in the variable on the x-axis updates.

For example, for $f(x,y,z) =z\sin(x)-y$ the contours in $x$, $y$, and $z$ can be obtained from:

Manipulate[
 Row[
  Plot[Last@#, {var, -4, 4},
      PlotRange -> {{-4, 4}, {-10, 10}},
      ImageSize -> Medium,
      Epilog -> {Red, PointSize[.02], Point[{First@#, f[x, y, z]}]}] &
   /@ {{x, f[var, y, z]}, {y, f[x, var, z]}, {z, f[x, y, var]}}
  ],
 Evaluate[
  Sequence @@ ({#, -4, 4, Appearance -> "Labeled"} & /@ {x, y, z})],
 Initialization :> {f[x_, y_, z_] := z Sin[x] - y}]

Hope this helps.

Answer 2

As you've noticed both Plot and Manipulate are scoping constructs. And the problem is that you want to manipulate expressions that contain variables which are meant to be scoped and where is a naming conflict.

What you want probably is possible but I think the fastest solution is just to avoid naming conflicts:

With[{
  exprsToPlot = {xp^y, x^yp},
  plotRangeSpecs = {{xp, .1, 2}, {yp, .1, 2}}},
 Manipulate[
  MapThread[Plot, {exprsToPlot, plotRangeSpecs}], 
  {x, .1, 2}, {y, .1, 2}
 ]
]

Answer 3

Both Edmund's and Kuba's answers provided the key, which was just to substitute a different variable (like var or xp) that Manipulate won't touch. With that key, I created something more modular, using a Module structure to specify just once at the top which plots to make:

ClearAll[f];
Module[{vars, varsAsPattern, varsToPlot, varFnSeq},
 vars = {x, y, z};         (*input to fn f*)
 varsToPlot = {x, z}; (*which Plots to make*)

 varsAsPattern = Sequence @@ (Pattern[#, _] & /@ vars);
 varFnSeq = 
  Table[{thisVar, ToString@thisVar, vars /. thisVar -> var},
    {thisVar, varsToPlot}];

 With[
  {vars = vars, varFnSeq = varFnSeq, varsAsPattern = varsAsPattern},
  Manipulate[
   Row[
    Function[{input},
      Plot[f @@ (Last@input), {var, -4, 4},
       PlotRange -> {{-4, 4}, {-10, 10}},
       ImageSize -> Medium,
       AxesLabel -> List@input[[2]],
       Epilog -> {Red, PointSize[.02], Point[{First@input, f @@ vars}]}  ]]
     /@ varFnSeq  ] ,
   Evaluate[
    Sequence @@ ({#, -4, 4, Appearance -> "Labeled"} & /@ vars)],
   Initialization :> {f[varsAsPattern] := z Sin[x] - y}
   ] ]  ]

A few points about this:

• The idea is to specify which plots to make just once at the top, with varsToPlot.
• This leaks the function f, as does the original solution.

About why I wrote it this way:

• The With[{vars=vars, ...}, ...] structure ensures that those expressions are substituted in before any other evaluation happens. (I can't find a reference for this usage, but this is a good starting point.)
• Creating varsAsPattern (the sequence x_, y_, z_ in this case) allows f to be initialized below without passing any variable like x that Manipulate will try to substitute into.
• I used the Function[{input}, ...] structure because using slots (#) led to errors once I wrote List@ #[[2]].
• While writing this, sometimes editing it would give errors of unmatched braces, and a fix was to delete then re-type the closing ] corresponding to Row[. Weird.

It shouldn't be too difficult to further extend this into a function. And in fact it may be easier because you could define the function f , rather than initialize it at the bottom based on an expression (so no need for varsAsPattern).