MaplePrimes - answers and comments on Question, Function valued functions

Classical answer to classical question

Markiyan Hirnyk — Wed, 20 Jul 2011 23:58:50 Z

I think it was asked a lot. You don't define any function (Edit. or operator) h in such a way:

Download function.mw

PS. Also

>h(1);

h(1)

D not perfect

Preben Alsholm — Thu, 21 Jul 2011 10:33:10 Z

I agree that D(h) ought not return 0. Returning unevaluated would be OK.

restart;
#showstat(D);
f:=k->(y->y^k);
h:=z->f(2)(z);

# In the help page for D it is described as doing something like this:
D(h) = (q -> eval(diff(h(t),t), t=q));
#However, that is only meant to convey the idea as you see in the following (and by looking at the code for D using showstat(D)).
infolevel[D]:=5:
D(h)(w) = (q -> eval(diff(h(t),t), t=q))(w);
D: Applying D to h
D: Either a name or a procedure
D: Looking for D/h
D: Looking for diff/h
D: No pre-defined rules
D: Applying D to f
D: Either a name or a procedure
D: Looking for D/f
D: Looking for diff/f
D: No pre-defined rules
D: Applying D to f(2)
0 = 2 w
#If you redefine f in the following way (reminiscent of the way procedures returning procedures had to be handled many versions ago) then D(h) returns unevaluated
f:=proc(k) subs(_k=k,y->y^_k) end proc;

D(h)(w) = (q -> eval(diff(h(t),t), t=q))(w);
D: Applying D to h
D: Either a name or a procedure
D: Looking for D/h
D: Looking for diff/h
D: No pre-defined rules
D: Applying D to f
D: Either a name or a procedure
D: Looking for D/f
D: Looking for diff/f
D: No pre-defined rules
D: Applying D to subs
D: Either a name or a procedure
D: Looking for D/subs
D: Looking for diff/subs
D: No pre-defined rules
D(h)(w) = 2 w

for me it remains unclear

Axel Vogt — Thu, 21 Jul 2011 13:46:45 Z

For me it remains unclear, why as user I can not use the
usual notation as it is done in Mathematics:

k |-> (y |-> y^k)

Old code

Alejandro Jakubi — Thu, 28 Jul 2011 08:23:17 Z

Actually, D calls `PD/PD` (PD presumably stands for "partial derivative"), as it can be seen by tracing:

restart:
trace(`PD/PD`):
D(k -> (y -> y^k));
{--> enter PD/PD, args = k -> y -> y^k, 1, 1
[...]
<-- exit PD/PD (now in D/procedure) = k -> 0}
                                  0

And the PD routines are those making the actual computation, hence failing in this case of nested procedures:

`PD/PD`(k -> y -> y^k, 1, 1);
                                k -> 0

`PD/PD`(y -> y^k, 1, 1);
                                    k
                                   y  k
                              y -> ----
                                    y

Now, these routines seem quite old. On the one hand their copyright says 1992:

op(3,eval(`PD/PD`));
  Copyright (c) 1992 by the University of Waterloo. All rights reserved.

And on the other hand, they exhibit code based on the "hackware package", e.g.:

showstat(`PD/PD`,25);
`PD/PD` := proc(p, i, n)
local j, k, l, m, t, x, params, keyword_opts, types, locals, body, depends, derivs, temps, diffs, funcs, vars, lexicals, opts;
global `PD/CFOLD`, `PD/LOCALS`, `PD/SUBSTS`;
       ...
  25   body := pointto(disassemble(addressof(p))[6]);
       ...
end proc

which, I think, is quite outfashioned (probably used until the mid 90's).

So, in my interpretation, the main cause why such mathematical notation does not work is simply that the code supporting this area of symbolic computation has been basically frozen for over 15 years.

This does not answer my question. I still

steweb — Thu, 21 Jul 2011 00:48:01 Z

This does not answer my question. I still do not understand why my definition gives wrong results.

Why does

h:=z->z^2;

define an operator, but not

h:=z->f(2)(z);

even though maple tells me that f(2)(z) is z^2 ?

Explanation

Markiyan Hirnyk — Thu, 21 Jul 2011 01:37:18 Z

There is a difference between f(2)(t) and t^2.
> whattype(f(2));

procedure
Because z is symbolic, f(2)(z) cannot be evaluated in h:=z->f(2)(z).

Edit. In h : replaced by := .