Is there a way to continuously update only *some* variables in Manipulate?

Question

I have a Manipulate control, the main element of which is a single slider. Moving the one slider triggers calls to two functions - one which is evaluated very quickly, the other more slowly. I'd like to see 'live' update ( i.e. ContinuousAction->True ) for the fast one, but would only like to update the slow one when the mouse is released. Is there a simple way to achieve this?

Thanks in advance!

Answer 1

Yes. Each control can have its own ContinuousAction option. As follows:

Manipulate[{x, y, z},
 {{x, 0, "x"}, 0, 10, 1, ContinuousAction -> True},
 {{y, 0, "y"}, 0, 10, 1, ContinuousAction -> False},
 {{z, 0, "z"}, 0, 10, 1},
 ContinuousAction -> True
 ]

The inner options take over from the common options. So in the above, z will use True but y will use False since it is an inner option.

Update this is a follow up on the comment below. I am not quite sure what is the problem we are solving exactly. But I think then what you want is simply to use ControlActive

http://reference.wolfram.com/mathematica/ref/ControlActive.html

ControlActive can be used to switch between a faster computation to be 
done while controls like sliders are being moved, and a slower 
computation to be done once the controls are released.

If this sounds like what you want, I'll be happy to make you an example using it if you tell me more about what these actions you want to do, which one is slow and which is fast. (help also have more examples on it, but feel free to follow up if it is not clear)

I understood the question first as you have 2 control variables and want to control each on its own.

Answer 2

This is not a full answer to your question, however I'd just like to add how this can be solved outside of Manipulate, perhaps someone can translate this into using Manipulate. As I understand it you problem is that you dynamically display both fast[a] and slow[a] while interactively updating a, which means the control waits for slow[a] to finish constantly. You can avoid this by making another variable that's only updated upon completion and then use that for the slow update:

  fast[a_] := a
  slow[a_] := (Pause[0.5]; a)

So rather than having

 {Dynamic@fast[a], Dynamic@slow[a]}]
 Slide[Dynamic[a],{0,1}]

You should have

 Slider[Dynamic[a, {(a = #) &, (b = #) &}], {0, 1}]
 {Dynamic@fast[a], Dynamic@slow[a]}]

Updated

to correct error caught by Mr. Wizard. Previusly used Dynamic[{fast[a],slow[b]}] to see the results which defies the point of letting them update independently.

Answer 3

What you could do as well to indicate progress whilst your slow function is running:

Manipulate[ControlActive["calculating...", Pause[.5]; x], {x, 0, 1} ]

I did put here Pause[] as a replacement.

A more elaborate example would be the color curve of a complex phase (although this is no problem for Mathematica), but it shows the idea:

Manipulate[
  ControlActive["calculating...", _; 
  Plot[Abs[Zeta[1/2 + I a*t]], {t, -20, 20}, 
  ColorFunction -> Function[{t}, Hue[Rescale[Arg[Zeta[1/2 + I t]], {-Pi, Pi}]]], 
  ColorFunctionScaling -> False, Filling -> Axis]], {a, 1, 2}]