Search code examples
maple

How do I use value of variable in Maple

How do I get Maple to give the value of a variable in the RHS of an expression, rather than treat it as a variable in an expression. In the following code I want a list of three functions of x which are quadratics with different offsets, but it's not what I get:

ix := [-1,0,1]:
b := []:
for a in ix
do
  b := [op(b),x->(x-a)^2];
end do;

and the output is

Maple output

while I would like it to be (for the last line)

b := [ x -> (x+1)^2, x -> x^2, x -> (x-1)^2 ]
Solution

  • Your problem is that you are trying to use values for a in the construction of the body of a procedure, and not the "RHS of an expression" as you stated.

    Try not to use the term "function" in this context, as it just muddles the distinction between expression and procedure.

    Here is a way to get the values from ix as replacements for a in a generated list of procedures with (x-a)^2 in the body.

    restart;
ix := [-1,0,1]:

b := []:
for a in ix do
  b := [op(b), unapply((x-a)^2,x)];
end do:
b;

    [x -> (x+1)^2, x -> x^2, x -> (x-1)^2]

    It is inefficient to construct lists in this way, by repeatedly concatenating them. Since that practice scales badly in performance you really ought to drop it as a practice.

    You can construct the whole list with one call to seq.

    Flist := [ seq( unapply((x-a)^2,x), a in ix ) ]:

Flist;

    [x -> (x+1)^2, x -> x^2, x -> (x-1)^2]

    Here, Flist is a list of procedures, each of which can be evaluated at a value by calling it with an argument.

    Flist[1];

              x -> (x+1)^2

Flist[3](3.4);

                  5.76

#plot(Flist, -2..2);

    Note: Procedures which display with the arrow notation x -> ... are called operators.

    For fun, here are equivalents, using expressions,

    Elist := [ seq( (x-a)^2, a in ix ) ]:

Elist;

        [       2   2         2]
        [(x + 1) , x , (x - 1) ]

Elist[1];

                       2
                (x + 1) 

eval(Elist[3], x=3.4);

                  5.76

#plot(Elist, x=-2..2);

    There are other ways to generate the procedures, with values of a in the body being specified programmatically. The unapply command is not the only possible mechanism, although it is the easiest for your example.

    Another way is to substitute, for example,

    generic := x -> (x-_dummy)^2:

Hlist := [ seq( subs(_dummy=a, eval(generic)), a in ix ) ]:

Hlist;

    [x -> (x+1)^2, x -> x^2, x -> (x-1)^2]