MaplePrimes - answers and comments on Question, procedures within a list

Global and piecewise

Preben Alsholm — Mon, 24 Oct 2011 18:25:59 Z

The following works, but does it serve your needs?

Parameters2 := [ s = 1 ];
Functions2 := [ U = 'proc(c) global s; piecewise(s=1,log(c),(c^(1-s)-1)/(1-s)) end proc' ];
eval(eval(U(c), Functions2), Parameters2);

alternative

Joe Riel — Mon, 24 Oct 2011 18:59:14 Z

Rather then assigning Functions2, I'd consider doing

U := proc(c)
global s;
  if not [args]::list(numeric) then return 'procname'(args) end if;
  if s = 1 then 
     return log(c);
  else
     return (c^(1-s)-1)/(1-s);
  end if;
end proc:

Then

eval(U(c),Parameters2);
                                  0

variables and evaluation

Robert Israel — Tue, 25 Oct 2011 06:01:54 Z

You declared s as a local variable of U, while Parameters2 refers to the global variable s. These are not the same, and you shouldn't expect them to be the same. So evaluating U(c) with the global s=1 will not affect the result.

On the other hand, if you made s a global variable the situation becomes more subtle, and the sequence in which evaluation takes place becomes important. In this case what actually happens is that the procedure U is called first, and then the result of that is evaluated with s=1.

One way that almost works is to substitute into the function definition rather than the result of the function call.

> Parameters2 := [ s = 1 ];
Functions2 := [ U = proc(c) if s = 1 then log(c) else (c^(1-s)-1)/(1-s) end if end proc ];
eval(U(c),subs(Parameters2,Functions2));

Error, numeric exception: division by zero

The problem here is that when s=1 the (c^(1-s)-1)/(1-s) contains a division by 0 (even though that branch is not going to be taken, this causes a problem in trying to define the substituted procedure). A work-around is to rewrite it so that we don't have an "immediate" division by 0.

> Parameters2 := [ s = 1 ];
   Functions2 := [ U = proc(c) local one;
           if s = 1 then log(c) else one:= 1; (c^(1-s)-1)/(one-s) end if end proc ];
   eval(U(c),subs(Parameters2,Functions2));

parameters vs arguments

acer — Tue, 25 Oct 2011 09:03:14 Z

I feel that (in Maple, at least) the significant difference between parameters (inside a proc) and arguments (to that proc) lies more in how you expect to use them than it does in some special coding practice. There are always exceptions, of course, but my preference is to manage parameters as formal arguments.

There are a few minor sins which I think this helps avoid. (The severity of the sin varies with circumstance and context, of course.)

One of those is declaing globals in a proc, when it's not necessary.
[We've seen the worksheets here, that have procs each with 2 formal parameters and a dozen declared globals. And at worst the results are confusion as to which `x` is which, debugging nightmares, slow code, and certainly no evalhf'ability.]
Using a procedure without knowing why.
[We've seen this too on mapleprimes: it starts off simple, and then somehow quotes get added because they seem to help, and then before you know it you're creating a procedure which you only ever call once. At this point, the central threads of purpose may have been lost. NB. This case in point is not even close to the extreme, which is something like,
```
fexpr:=unapply(expr,x);
plot(fexpr(x),x=a..b);  # and fexpr is never again used
```
Having to do a full restart,or even just have Maple do more "work", just to make changes to an example. Or put another way: the less re-calculation required in order to re-run with different parameter values, the better. And re-creating a new instance of the whole procedure, just to use different parameter values, is certainly more re-calculation. (Yes, I realize that there may be other quite different memory management reasons why one has to do a full restart. But it still be be decent practice to not force the requirement...)

So I might try something like this:

restart:

U := proc(c, s) if s=1 then log(c); else (c^(1-s)-1)/(1-s); end if; end proc:

Parameters1 := [ s = 2 ]:
U(c, subs(Parameters1,s));

                              1    
                            - - + 1
                              c    

# And now, without having to re-create any procedure,

Parameters1 := [ s = 1 ]:
U(c, subs(Parameters1,s));

                             ln(c)

As a very minor quibble -- if I may offer more opinion on coding style -- I suggest trying to use different names for formal parameters than are expected to be used as supplied arguments. Fr example, to help keep thing straight in our heads,

restart:

U := proc(C, S) if S=1 then log(C); else (C^(1-S)-1)/(1-S); end if; end proc:

Parameters1 := [ s = 2 ]:
U(c, subs(Parameters1,s));
                              1    
                            - - + 1
                              c    
Parameters1 := [ s = 1 ]:
U(c, subs(Parameters1,s));
                             ln(c)

The formal parameters of procedure U are now named differently, and may help avoids some confusion, but the way that U gets called and the final form results are the same.

acer

%name and value

Joe Riel — Tue, 25 Oct 2011 10:16:47 Z

If the goal is to be able to manipulate an inert function call and various symbolic parameters, then later evaluate them, you could use the following technique.

s := 1;
U := proc(c) if s = 1 then log(c) else 1/(s-1) end if; end proc: # or whatever ...
y := %U(c)^2 + %s;   # use %U and %s rather than U and s
                                                    2
                                            y := %U(c)  + %s
value(y);
                                                    2
                                               ln(c)  + 1

thanks

PatrickT — Thu, 27 Oct 2011 03:45:20 Z

Preben, Joe, Robert, acer, thank you so much for your suggestions. This has been a very useful exchange, I have learned several things. I am particularly grateful for the pains you took to explaining the details of what was going on.

Preben, very interesting use of piecewise, your code is the shortest too, it does achieve what I was after.

Robert, I like that your method makes clear the order of evaluation, and it's nice to learn how to get around the division by zero, this trick will be potentially useful elsewhere.

Using subs I can also simplify the code in places where I intend to use both the functional forms and the parameter values at once, e.g.


model := subs(Parameters1,Functions);
eval(U(c), model); # clearer than eval(eval(...

  model := [U = proc (c) local one; if 2 = 1 then log(c) else one := 1; (1/c-1)/(one-2) end if end proc]

it helped me understand what was going on to actually see the statement if 2=1.

Joe, thanks, working out the meaning of the following line was well worth the effort, code that may prove useful in the future too,

if not [args]::list(numeric) then return 'procname'(args) end if;

acer, yes I fully agree with the practice of using different symbols in the definition of the proc and in its evaluation, I'll try to be consistent with that in the future. Thanks for your guidance.

Joe, I'm curious about the use of the percentage sign in front of a symbol, as in %s, I couldn't find documentation about this particular use of % ... Oh, wait! I do find information about it as I write, by searching ?value. Here:
<quote>

any function whose name starts with the % character, as in %F, is an inert representation for the function F. This feature provides inert representations for any Maple or user-defined function. [...] During computations, inert functions remain unevaluated (the operations they represent remain unperformed). The value command maps these inert functions [...] into the corresponding active functions.

<\quote>

Example: %Pi; value(%Pi);

A search for % returns "The Ditto Operators" section Maple's help pages. I don't see there a link to "value." This is, I think, a shortcoming of the ditto help page.

That's quite a few tricks to add to my bag. Thanks so much to all of you for your help.