How can I create a custom control which evaluates to a list of values or replacements?

Question

I have a set of variables which are used in various places in my calculations (solving a system, initial conditions, etc.). In order to make this easier to deal with, I want to make a control-like thing which makes them easier to manipulate, rather than just using long lists of unlabeled values such as

calculateValues[{0, 0, π, 0.5, 3}]

So far I have something like this:

This clearly doesn't work, and I expect in order to get it working properly I'll need to use Interpretation or more Dynamic incantations, but I can't figure out exactly what needs to happen. Any advice would be appreciated. Thanks in advance!

Answer 1

You could do

myControl[varNames_List, start_: 0] := 
 myControl[varNames, ConstantArray[start, Length@varNames]]

myControl[varNames_List, start_List] := 
 Interpretation[{vars = start}, 
  Panel[Grid[{varNames, 
     Array[InputField[Dynamic@vars[[#]], 
        FieldSize -> {{0, Infinity}, 1}] &, Length@vars]}]], vars]

Now you can run that function to create a control myControl["a"~CharacterRange~"g"]. Each instance will have its own values and they all evaluate to their values when supplied as input

Answer 2

You could use interpretation.

Here's the idea.

SetAttributes[makeDynamicPanel, HoldFirst]
makeDynamicPanel[x_, defaultValue_] :=
 Module[{y},
    y = 
       Interpretation[
          Panel@InputField[Dynamic[x]]
          ,
          x
       ];
    x = defaultValue;
    y
 ]

Then you do for example

makeDynamicPanel[z, {0, 0, π, 0.5, 3}]

and you get a panel that allows to edit the value of z and can be used as argument to your function, you can even do for example panel + 2 and get a valid value, it's quite practical.

Answer 3

I would suggest using another list (vals) to store values for the variables vars. To set up a list of controllers (InputFields here) programmatically, some clever construct is required. Here I used an explicit Function call to save the changed value of the $i^{th}$ element of vals inside the Dynamic (as the # stands for the index of the list element, not the actual controller value, which is denoted as $x), but this can also be achieved using With.

calculateValues[v_List] := Plus @@ (v^Range@Length@v);

vars = {a, b, c, d, e};
vals = {1, 2, 3, 4, 5};

Panel[
 Grid[{
   Text /@ vars,
   InputField[Dynamic[vals[[#]], Function[{$x}, vals[[#]] = $x]], 
      FieldSize -> {{0, Infinity}, 1}] & /@ Range@Length@vals
   }]]

Dynamic@vals

{1, 2, 3, 4, 5}

calculateValues@vars

a + b^2 + c^3 + d^4 + e^5

Dynamic[calculateValues@vars /. Thread[vars -> vals]]

3413