1
$\begingroup$

I feel like this should have a simple answer but I haven't found anything that works. The toy example of what I want is as follows:

testx = 1;
testy = 2;
testlist = {testx, testy};

And I'm looking for a function that I could use on testlist (f[testlist]) that will return {testx, testy} in their unevaluated symbols or strings.

I've tried OwnValues, Values, Variables, Information, and various others along with their permutations. My intuition says that some combination of pure functions could do what I want, but I'm still very unsure of how to use most of them.

Edit*

Some context for this problem: I am procedurally defining a function (for example):

func = Sum[ToExpression["a"<>ToString[i]],{i, 1, large_number}]

Separately I generate a list of the variable names which occur in the defintion, like shown above, except in this case it would appear as

varsList = {a1, a2, ... , a<large_number>}

And I wish to be able to procedurally select the string or undeclared variable symbol from varsList for use in manipulate.

Edit 2*

I'm doing a terrible job asking this question. What I'm attempting to do is use the answer provided here, which allows for manually adjusting parameters within manipulate and then using those manually determined values as starting values for a fit, finally feeding the best-fit values back into the current values for the parameters and allowing for subsequent manual control.

Except in my case, the function must have variable number of parameters. I already procedurally generate my function (as above). But am stuck on how to generate the Sequence of parameters inside manipulate, as well as how to call the symbols for resetting their values to those of the best-fit results. That is the ultimate goal and apparently my previous attempts are not possible.

Final Edit*

I've improved the manipulate functionality shown here to also include procedural generation of a function with variable number of parameters.

To do so required applying Hold to the function and its variables, but this alone was not enough because any attempt to redefine the variables on the LHS of an equation was met with simply trying to define a number as another number. The solution was then to construct the line of code I wanted to run entirely as a string, then Evaluate[ToExpression[[]] it. Code below should run as is, the 4 in testplotfit[] may be changed to any positive integer between 1 and 10 currently, determined by the internal clear command. I truly do wonder why there is no better, or at least more well-known, way to procedurally redefine previously assigned variables.

data = Table[{x, 
    8 x^3 - 7 x^2 - 10 x + 1 + RandomReal[{-5, 5}]}, {x, -2, 2, 0.1}];


function[terms_] := 
  Sum[ToExpression["a" <> ToString[i]]*x^(i - 1), {i, terms}];
functiontemp[terms_] := 
  Sum[ToExpression["b" <> ToString[i]]*x^(i - 1), {i, terms}];

testplotfit[terms_] := DynamicModule[{(*sol, solString*)},
   ClearAll[Evaluate[Sequence @@ Table["a" <> ToString[i], {i, 10}]]];
   funcString = TextString[function[terms]];
   vars = 
    Thread[Hold@Evaluate[DeleteCases[Variables[function[terms]], x]]];
   varsString = ToString[vars[[All, 1]]];
   tempvars = 
    Table[ToExpression["b" <> ToString[i]], {i, Length[vars]}];
   solString = ConstantArray["blank", terms];

   Manipulate[
      If[computeFlag == True,
       Evaluate[
        sol = 
          FindFit[data, functiontemp[terms], 
           Table[{tempvars[[i]], ReleaseHold[vars[[i]]]}, {i, 
             Length[vars]}], x];
        ];
       Evaluate[
        ToExpression[
         varsString <> " = " <>(*ToString[solString]*)
          ToString[tempvars /. sol]]];
       computeFlag = False;
       ];

      Column[
       {Dynamic[Button["Compute", computeFlag = True]],
        Show[
         Plot[#, {x, -2, 2}, PlotStyle -> Black],
         ListPlot[data, PlotStyle -> Red],
         ImageSize -> 300,
         PlotRange -> {{-2.05, 2.05}, All}]}
       ]

      (*;sol*),

      {{computeFlag, False}, ControlType -> None},
      Evaluate[
       Sequence @@ 
        Table[{{i, 1}, -10, 10, Appearance -> "Open"}, {i, 
          vars[[All, 1]]}]],
      LocalizeVariables -> False
      ] &@function[terms] (*end of Manipulate*)
   ];

testplotfit[4]
$\endgroup$
  • 2
    $\begingroup$ This is not possible. The moment you evaluate the line testlist = {testx, testy}, the values for testx and testy are inserted and `testlist itself has no knowledge where the inserted 1 and 2 came from.. $\endgroup$ – halirutan Oct 21 '16 at 2:23
  • $\begingroup$ Do you want the polynomial in the FindFit expression to be of variable degree? $\endgroup$ – user31159 Oct 21 '16 at 11:59
  • $\begingroup$ Also, when do you want its degree to be determined? Before calling the Manipulate, meaning that you will be able to play with a given number of variables in Manipulate (number that could possibly change with another call to the function), or within the Manipulate, meaning that you could add or remove degrees in your polynomial and subsequently adjust a varying number of variables in the Manipulate window? $\endgroup$ – user31159 Oct 21 '16 at 12:02
  • $\begingroup$ @xavier Essentially yes to your first question, my actual function would be somewhat different but similar in principle. Sticking with this example, I currently determine the order when I first call the manipulate using something like manipulateFunction[polynomialDegree_] := Manipulate[defineFunction := ... But the problem I don't know how to address is that I need to be able to call the variable names which are in defineFunction in order to initialize them (within manipulate) or set them to the best-fit value. In calling them they always assume the current numerical value... $\endgroup$ – Erik Farr Oct 21 '16 at 17:54
  • $\begingroup$ If you define testlist before testx and testy, or use SetDelayed ( testlist := {testx, testy} ) this question becomes a duplicate of my self-answered How do I evaluate only one step of an expression? $\endgroup$ – Mr.Wizard Oct 22 '16 at 11:29
1
$\begingroup$

Why not use 'Hold' ?

testx = 1; testy = 2; testlist = Hold@{testx, testy}
Hold[{testx, testy}]
Thread[%]
{Hold[testx], Hold[testy]}

For the variable names, I would use :

Names["a*"]
{"a1", "a2", "a3", "a4"}

which gives a list of variable names as strings. Those can be turned into variables by

ToExpression

$\endgroup$
  • $\begingroup$ I'm very close to getting this implementation to work. The last piece I need is to be able to call testx and testy and redefine them. For example, in addition to your first code block, I want to be able to then call testx and testy through their testlist definition and redefine them to be 3 and 4 respectively. I'll mark this as the answer shortly since it does address the first of my questions. $\endgroup$ – Erik Farr Oct 21 '16 at 19:55
  • $\begingroup$ Further clarifying the previous comment: is there a way to procedurally call testx and testy on the LHS of an equation in order to give them new values once they have already been assigned 1 and 2? Any attempt to call the variable outside of Hold will replace it with its current value, but Hold[testx]=3 cannot be assigned a new value in the same way that testx=3 can be. Please let me know if you'd like further clarification. $\endgroup$ – Erik Farr Oct 21 '16 at 20:14
  • $\begingroup$ You can format inline code and code blocks by selecting the code and clicking the {} button above the edit window. The edit window help button ? is also useful for learning how to format your questions and answers. You may also find this meta Q&A helpful $\endgroup$ – Michael E2 Oct 22 '16 at 12:46
  • $\begingroup$ You can first Clear the current values, and then assign new ones: ReleaseHold[Map[Clear, testlist, {2}]]. $\endgroup$ – Wouter Oct 22 '16 at 13:28
2
$\begingroup$

Please don't use this in practice, but as an exercise here is literal solution to your original question. This requires an input history long enough to contain the set line.

$HistoryLength = 100;

testx = 1;
testy = 2;
testlist = {testx, testy};

Attributes[fn] = HoldFirst;
fn[s_Symbol] :=
 Cases[Reverse @ DownValues @ In, (Set | SetDelayed)[HoldPattern[s], body_] :> 
    HoldForm[body], {1, -1}, 1][[1]]

fn[testlist]
{testx, testy}   (* wrapped in HoldForm *)

Reference: $HistoryLength, In, HoldForm, Attributes, HoldFirst

For a more practical approach you may find these questions helpful:

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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