'
, D
Differential operator for functions
MuPAD® notebooks will be removed in a future release. Use MATLAB® live scripts instead.
MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.
f ' D(f
) D([n1, n2, …]
,f
)
D(f)
or, alternatively, f'
computes
the derivative of the univariate function f
.
D([n1, n2, ...], f)
computes the partial
derivative of
the multivariate function f(x_{1}, x_{2},
…).
MuPAD^{®} has two functions for differentiation: diff
and D
. D
represents
the differential operator that may be applied to functions; diff
is used to differentiate arithmetical expressions.
Mathematically, D(f)(x)
coincides with diff(f(x),
x)
; D([1, 2], f)(x, y)
coincides with diff(f(x,
y), x, y)
. Symbolic calls of D
and diff
can be converted
to one another via rewrite
.
Cf. Example 8.
D(f)
returns the derivative of
the univariate functionf
. f'
is
shorthand for D(f)
.
If f
is a multivariate function and denotes
the partial derivative of f
with respect to its nth
argument, then D([n1, n2, ...], f)
computes the
partial derivative .
Cf. Example 5. In particular, D([
], f)
returns f
itself.
It is assumed that partial derivatives commute. Internally, D([n1,
n2, ...], f)
is converted to D([m1, m2, ...], f)
,
where [m1, m2, ...]
= sort([n1, n2, ...])
.
f
may be any object which can represent a
function. In particular, f
may be a functional
expression built from simple functions by means of arithmetic operators
(+
, 
, *
, /
, ^
, @
, @@
).
Any identifier different from CATALAN, EULER,
and PI is
regarded as an “unknown” function; the same holds for
elements of kernel domains not explicitly mentioned on this page.
Cf. Example 1. Any number and each
of the three constant identifiers above is regarded as a constant
function. Cf. Example 2.
If f
is a list,
a set, a table,
or an array, then D
is
applied to each entry of f
. Cf. Example 3.
A polynomial f
of
type DOM_POLY
is
regarded as polynomial function, the indeterminates being the arguments
of the function. Cf. Example 6.
If f
is a function
environment, a procedure, then D
can
compute the derivative in some cases; see the “Background”
section below. If this is not possible, a symbolic D
call
is returned.
Higher partial derivatives D([n1], D([n2], f))
are
simplified to D([n1, n2], f)
. Cf. Example 7.
The derivative of a univariate function f —denoted
by D(f)
— is syntactically distinguished
from the partial derivative D([1], f)
with respect
to the first variable, even if f represents
a univariate function.
The usual rules of differentiation are implemented:
D(f + g) = D(f) + D(g)
,
D(f * g) = f * D(g) + g * D(f)
,
D(1/f) = D(f) / f^2
,
D(f @ g) = D(f) @ g * D(g)
.
Note that the composition of functions is written as f@g
and not as f(g)
.
In order to express the nth
derivative of a univariate function for symbolic n,
you can use the “repeated composition operator” @@
. Cf. Example 9.
D
uses option remember
.
D(f)
computes the derivative of the function f
:
D(sin), D(x > x^2), D(id)
D
also works for more complex functional
expressions:
D(sin @ exp + 2*(x > x*ln(x)) + id^2)
If f
is an identifier without a value, a
symbolic D
call is returned:
delete f: D(f + sin)
The same holds for objects of kernel type that cannot be regarded as functions:
D(NIL)
f'
is shorthand for D(f)
:
(f + sin)', (x > x^2)', id'
Constants are regarded as constant functions:
PI', 3', (1/2)'
The usual rules of differentiation are implemented. Note that
lists and sets may also be taken as input; in this case, D
is
applied to each element of the list or set:
delete f, g: D([f+g, f*g]); D({1/f, f@g})
The derivatives of most special functions of the library can
be computed. Again, id
denotes
the identity function:
D(tan); D(sin*cos); D(1/sin); D(sin@cos); D(2*sin + ln)
D
can also compute derivatives of procedures:
f := x > x^2: g := proc(x) begin tan(ln(x)) end: D(f), D(g)
We differentiate a function of two arguments by passing a list
of indices as first argument to D
. In the example
below, we first differentiate with respect to the second argument
and then differentiate the result with respect to the first argument:
D([1, 2], (x, y) > sin(x*y))
The order of the partial derivatives is not relevant:
D([2, 1], (x, y) > sin(x*y))
delete f, g:
A polynomial is regarded as a polynomial function:
D(poly(x^2 + 3*x + 2, [x]))
We differentiate the following bivariate polynomial f
twice
with respect to its second variable y
and once
with respect to its first variable x
:
f := poly(x^3*y^3, [x, y]): D([1, 2, 2], f) = diff(f, y, y, x)
delete f:
Nested calls to D
are flattened:
D([1], D([2], f))
However, this does not hold for calls with only one argument,
since D(f)
and D([1], f)
are
not considered to be the same:
D(D(f))
D
may only be applied to functions whereas diff
makes only sense
for expressions:
D(sin), diff(sin(x), x)
Applying D
to expressions and diff
to functions makes
no sense:
D(sin(x)), diff(sin, x)
rewrite
allows
to rewrite expressions with D
into diff
expression:
rewrite(D(f)(y), diff), rewrite(D(D(f))(y), diff)
The reverse conversion is possible as well:
map(%, rewrite, D)
Sometimes you may need the nth derivative of a function, where n is unknown. This can be achieved using the repeated composition operator. For example, let us write a function that computes the kth Taylor polynomial of a function f at a point x_{0} and uses x as variable for that polynomial:
kthtaylorpoly:= (f, k, x, x0) > _plus(((D@@n)(f)(x0) * (x  x0)^n / n!) $ n = 0..k): kthtaylorpoly(sin, 7, x, 0)
delete kthtaylorpoly:
Advanced users can extend D
to their own
special mathematical functions (see “Background” section
below). To this end, embed your mathematical function f,
say, into a function environmentf
and
implement the behavior of D
for this function as
the "D"
slot of the function environment. The slot
must handle two cases: it may be either called with only one argument
which equals f
, or with two arguments where the
second one equals f
. In the latter case, the first
argument is a list of arbitrary many indices; that is, the slot must
be able to handle higher partial derivatives also.
Suppose, for example, that we are given a function f(t, x, y),
and that we do not know anything about f except
that it is differentiable infinitely often and satisfies the partial
differential equation .
To make MuPAD eliminate derivatives with respect to t
,
we can do the following:
f := funcenv(f): f::D := proc(indexlist, ff) local n : DOM_INT, // Number of tderivatives. list_2_3 : DOM_LIST; // List of indices of 2's and 3's. // These remain unchanged. begin if args(0) <> 2 then error("Wrong number of arguments") end_if; n := nops(select(indexlist, _equal, 1)); list_2_3 := select(indexlist, _unequal, 1); // rewrite (d/dt)^n = (d^2/dx^2 + d^2/dy^2)^n _plus(binomial(n, k) * hold(D)(sort([2 $ 2*(nk), 3 $ 2*k].list_2_3), ff) $ k = 0..n) end_proc:
Now, partial derivatives with respect to the first argument t are rewritten by derivatives with respect to the second and third argument:
D([1], f^2)(t, x, y)
D([1, 2, 1], f)
delete f:

A function or a functional expression, an array, a list, a polynomial, a set, or a table 

Indices: positive integers 
function or
a functional expression. If f
is an array or a
list etc., a corresponding object containing the derivatives of the
entries is returned.
f
If f
is a domain or a function
environment with a slot"D"
,
this slot is called to compute the derivative. The slot procedure
has the same calling syntax as D
. In particular
—and in contrast to the slot"diff"
—
the slot must be able to compute higher partial derivatives because
the list of indices may have length greater than one. Cf. Example 10.
If f
is a procedure,
a function environment without a "D"
slot,
then f
is called with auxiliary identifiers as
arguments. The result of the call is then differentiated using the
function diff
.
If the result of diff
yields
an expression which can be regarded as function in the auxiliary identifers,
then this function is returned, otherwise an unevaluated call of D
is
returned.
Let us take the function environmentsin
as an example. It
has no "D"
slot, thus the procedure op(sin,
1)
, which is responsible for evaluating the sine function,
is used to compute D(sin)
, as follows. This procedure
is applied to an auxiliary identifier, say x
, and
differentiated with respect to this identifier via diff
. The result is diff(sin(x),
x) = cos(x)
. Via fp::expr_unapply
and fp::unapply
, the function cos
is computed as the
derivative of sin
.