Manipulate with explicit updates

Question

I want to use Manipulate (I am open to other alternatives) to apply one of two different functions f or g to a set of values. The issue is that, I want to update the evaluation only when the user clicks on one of the button f or g. I came up with the following work around but I wonder if there is a better/standard way to implement such a thing?

Module[{val},
 Manipulate[
  val = Switch[op, "f", op = ""; f[x], "g", op = ""; g[x], "", val]; 
  val, {x, {1, 2, 3}, Setter}, {op, {"f", "g"}, Setter}, 
  TrackedSymbols -> {op}]
 ]

As a side question: is there any way to tell Manipulate to ignore the current evaluation and keep the last evaluated value?

jVincent · Accepted Answer · 2012-10-15T12:08:58.700

7

While your solution works, I personally find it a bit off, since you are actually trying to have dynamic controls for a variable, who's state you immediately change away from the dynamic value just to use it to trigger an event. In short, you want to have one of two actions associated with the button presses, and could code this explicitly using a custom control, rather then indirectly implementing it in the guise of a dynamic controller with an added added event trigger somewhere else. Here is an example of a custom control implementing the events directly:

  Manipulate[
  val,
  {x, {1, 2, 3}, Setter},
  {{val, 0, "operator"}, 
           Row[{ Button["Call f", val = f[x]], 
                 Button["Call g", val = g[x]]}] &}
  ]

Here I added a new scoped variable since the spec for Manipulate needs to associate a variable with the custom control, even though it's not actually controlling any variable. If you wanted access to the operator that performed the last call, you could associate that variable with it.

edited Oct 15 '12 at 12:08

answered Oct 15 '12 at 08:58

jVincent

14,766
1
42
74

+1 (although I would use DynamicModule instead of Module – Ajasja Oct 15 '12 at 10:18
novar the Module variable is not the same as novar localized within Manipulate and is not needed. If you want val to be stored then it should be a DynamicModule. – Mike Honeychurch Oct 15 '12 at 10:40
@MikeHoneychurch Thanks, I actually thought it was DynamicModule, I copied the original code without noticing. – jVincent Oct 15 '12 at 10:48
1

no worries but novar in the DM is still redundant. – Mike Honeychurch Oct 15 '12 at 11:02
@MikeHoneychurch Indeed, Never though about the fact that novar is localized in Manipulate just like any other var. I suppose I didn't think it threw because I really wanted to not have a var at all. – jVincent Oct 15 '12 at 11:12
1

@jVincent: one of the strongest advantages of using buttons as you do is that you could use Method->"Queued" for them which would make this work even when the evaluation of f or g would take long enough for an abort of the dynamic (which might be the case from what the OP mentioned in a comment). As novar is just a dummy variable, you could use val instead there and get rid of the DynamicModule: `Manipulate[val, {x, {1, 2, 3}, Setter}, {{val, "please click button...", "operator"}, Row[{Button["Call f", val = f[x]], Button["Call g", val = g[x]]}] &}] – Albert Retey Oct 15 '12 at 12:06
@AlbertRetey Indeed, that does look better, and in a sense val does belong to those controls in that case, so it's conceptually better I think. I've updated my answer to reflect your improvement. – jVincent Oct 15 '12 at 12:08
@jVincent: honestly I don't think it is conceptually that much better: either way it's a "trick" to use a "hidden" variable (not a bad thing at all, but conceptually probably not straightforward either way). But it just seems shorter and if we need a variable there, why not making use of it? My actual concern was to emphazise that I think your solution has the advantage over the others that by using Method->"Queued" the OP can solve a problem that I could well imagine him to see in the near future. Actually the ButtonBar solution of kguler has the same property, even by default... – Albert Retey Oct 15 '12 at 12:23

score 3 · Answer 2 · answered Oct 15 '12 at 10:09

3

Three variations using SetterBar, ButtonBar and Setters:

SetterBar:

Manipulate[op, {x, {1, 2, 3}, SetterBar}, 
 {{op, f[1], "op"}, {"f", "g"},SetterBar[Dynamic@op, {(f[x]) ->"f", (g[x]) ->"g"}] &}, 
    TrackedSymbols -> {op}]

ButtonBar:

 Manipulate[op, {x, {1, 2, 3}, SetterBar}, 
 {{op, f[1], "op"}, {"f", "g"}, ButtonBar[{"f" :> (op = f[x]), "g" :>(op = g[x])}] &}, 
   TrackedSymbols -> {op}]

Two Setters:

 Manipulate[op, {x, {1, 2, 3}, SetterBar},
  Row[{Control[{{op, f[1], "op"}, {}, Setter[Dynamic[op], f[x], "f"] &}],
       Control[{{op, g[1], ""}, {}, Setter[Dynamic[op], g[x], "g"] &}]}], 
  TrackedSymbols -> {op}]

answered Oct 15 '12 at 10:09

kglr

394,356
18
477
896

I have mentioned the same thing for jVincents answer: the ButtonBar solution has the potential advantage over the Setter* solutions that it uses the Method->"Queued" option: that will prevent an early abort of the Manipulate when the evaluations of f and g take to long. This might be the case as the OP has mentioned somewhere that they are expensive... – Albert Retey Oct 15 '12 at 12:28
@Albert, I was just playing with that variation for the same reasons, as a possible answer to this related question which exactly about that issue. – kglr Oct 15 '12 at 12:36

score 3 · Answer 3 · answered Oct 16 '12 at 02:59

@Mohsen. Here is a cleaned up version of your original Manipulate. The Module wrapper is eliminated by introducing val as an invisible control. This is a common and useful way to introduce addition dynamic variables into a Manipulate expression.

Manipulate[
 If[op != "",
   val = Switch[op,
           "f", f[x],
           "g", g[x]];
   op = ""];
 val,
 {val, ControlType -> None},
 {x, {1, 2, 3}, Setter},
 {op, {"f", "g"}, Setter},
 TrackedSymbols -> {op},
 Initialization :> (op = ""; val = "";)]

It is also good to initialize op and val so that nothing is displayed until the first click is made on the "op" setter. With these minor changes your original approach is really quite valid.

Thank you! I didn't know about Initialization option. – Helium Oct 16 '12 at 03:20 — Helium, Oct 16 '12 at 03:20

score 1 · Answer 4 · answered Feb 29 '16 at 14:07

A related solution is to use the built-in option ContinuousAction. As the Manipulate documentation explains:

With the setting ContinuousAction->None, an explicit Update button is displayed, and expr is not reevaluated until this is clicked.

The Update button it makes is a tiny U in the top-right corner of the Manipulate box. While this isn't quite the f and g buttons that the OP requested, it is much simpler and will be useful for many applications.

Mike Honeychurch · Answer 5 · 2012-10-15T09:28:44.407

1

It looks like I misinterpreted what the OP wanted. So here is something that updates only when f or g is chosen. I've gone with DynamicModule because I find it more intuitive than Manipulate and stuck with the basic features of the OPs own implementation which will hopefully make it easy to follow.

DynamicModule[{op, x},

 Column[{
   SetterBar[Dynamic[x], {1, 2, 3}],
   SetterBar[Dynamic[op], {f, g}],
   Dynamic[op[x], TrackedSymbols :> {op}]

   }]
 ]

You can add control labelling, panes, backgrounds and so on but this is bare essentials.

edited Oct 15 '12 at 09:28

answered Oct 15 '12 at 07:21

Mike Honeychurch

37,541
3
85
158

This updates with every click; OP wants "to update the evaluation only when the user clicks on one of the buttons f or g". – kglr Oct 15 '12 at 08:19
@Mike: This is not what I am looking for, indeed. I want to update the result only if one of f or g are clicked. Your approach may result in the same result in theory, but it is not so practical because f and g are CPU intensive and/or stateful (by stateful I mean a function which has side effect, so calling f twice is different from calling it once). Also, using Manipulate[op[x],{x, {1, 2, 3}, Setter},{op, {f, g}, Setter},TrackedSymbols->{op}] doesn't work. – Helium Oct 15 '12 at 08:35

Manipulate with explicit updates

5 Answers5

Linked