How to write FUNCTIONS in maple
Mathematical functions of one or more variables may be defined as follows:
f:=(x_1,x_2...x_n) -> function definition
e.g.
f:=(x,y,z) -> x^2+sin(y*z);
defines f as a function of the 3 variables x,y,z.
To evaluate the function at a given point, we just call the function as
we normally would passing argument values:
f(2,1,3);
Operations such as differentiation are treated differently from those of
ordinar y algebraic expressions.
For example, to differentiate the expression d:=x^2*y+z*sin(y*z), we can
use diff as follows:
diff(d,z)
which gives us
sin(y*z)+z*y*cos(y*z)
However if we had the function
f:=(x,y,z) -> x^2*y+z*sin(y*z)
then using diff(f,z) gives us zero. In order to differentiate the
function, we have to specify the arguments since Maple would treat f as
a symbol in and of itself and return 0.
Thus the proper expression would be
diff(f(x,y,z),z)
A common problem among many users who use Maple to do differentiation of
mathematical functions is in the evaluation of the derivatives of
functions at points.
Say for example, we wished to evaluate the derivative of f at the points
(x1,y1,z1). If we tried to define a new function in terms of the diff
function, viz
r:=(x,y,z) -> diff(f(x,y,z),z)
we would get the result
r:=(x,y,z) -> diff(f(x,y,z),z)
and evaluating at the point (Pi,Pi,Pi) we would get
3*Pi^2+sin(Pi^2)+2*Pi^2*cos(Pi^2)
which is clearly wrong. This is due to the fact that in defining r as
above results in delayed evaluation of the expression and substitues the
values of the args before differentiation which results in Maple
treating Pi as a symbolic variable with which to differentiate r with
respect to.
The way to solve this would be to use the **unapply** operator, viz
r:=unapply(diff(f(x,y,z),z),x,y,z);
and evaulating r(Pi,Pi,Pi), we obtain
sin(Pi^2)+Pi^2*cos(Pi^2)
which is indeed correct.
A few notes on unapply, adapted (and corrected) from the ?unapply
help page:
- The result of unapply(expr,x) is a functional operator. Applying this
operator to x gives the original expression.
unapply(expr,x)(x) ==> eval(expr)
- Typically, for a function f(x):
unapply(f(x),x) ==> f
although this depends somewhat on the evaluation of f(x). A safer
statement would be:
unapply('f'(x),x) ==> f
- unapply should be used whenever it is desired to construct an operator using
contents of variables or evaluated expressions.
- unapply implements (almost) the lambda-expressions of lambda calculus.
The scoping behaviour of unbound names is not the same in the
lambda calculus.
|
