16.20 DFPART: Derivatives of generic functions

This package supports computations with total and partial derivatives of formal function objects. Such computations can be useful in the context of differential equations or power series expansions.

Author: Herbert Melenk.

The package DFPART supports computations with total and partial derivatives of formal function objects. Such computations can be useful in the context of differential equations or power series expansions.

16.20.1 Generic Functions

A generic function is a symbol which represents a mathematical function. The minimal information about a generic function function is the number of its arguments. In order to facilitate the programming and for a better readable output this package assumes that the arguments of a generic function have default names such as f(x,y),q(rho,phi). A generic function is declared by prototype form in a statement

GENERIC_FUNCTION fname(arg1,arg2⋅⋅⋅argn);

where fname is the (new) name of a function and argi are symbols for its formal arguments. In the following fname is referred to as “generic function", arg1,arg2⋅⋅⋅argn as “generic arguments" and fname(arg1,arg2⋅⋅⋅argn) as “generic form". Examples:

   generic_function f(x,y);  
   generic_function g(z);

After this declaration REDUCE knows that

16.20.2 Partial Derivatives

The operator DFP represents a partial derivative:


where expr is a function expression and dfargi are the differentiation variables. Examples:


means ∂2f-
∂x∂y and


stands for ∂2f-
∂x∂y(u,v). For compatibility with the DF operator the differentiation variables need not be entered in list form; instead the syntax of DF can be used, where the function expression is followed by the differentiation variables, eventually with repetition numbers. Such forms are interenally converted to the above form with a list as second parameter.

The expression expr can be a generic function with or without arguments, or an arithmetic expression built from generic functions and other algebraic parts. In the second case the standard differentiation rules are applied in order to reduce each derivative expressions to a minimal form.

When the switch NAT is on partial derivatives of generic functions are printed in standard index notation, that is fxy for  2
∂∂xf∂y- and fxy(u,v) for   2
∂∂x∂fy(u,v). Therefore single characters should be used for the arguments whenever possible. Examples:

  generic_function f(x,y);  
  generic_function g(y);  
  F  *G()  
  F  *G() + F *G  
   XY        X  Y  

The difference between partial and total derivatives is illustrated by the following example:

  generic_function h(x);  
  F (X,H(X))*G(H(X))  
  F (X,H(X))*G(H(X)) + F (X,H(X))*H (X)*G(H(X))  
   X                    Y          X  
   + G (H(X))*H (X)*F(X,H(X))  
      Y        X

Cooperation of partial derivatives and Taylor series under a differential side relation ddqx = f(x,q):

  load_package taylor;  
  operator q;  
  let df(q(~x),x) => f(x,q(x));  
                         F (X0,Q(X0)) + F (X0,Q(X0))*F(X0,Q(X0))  
                          X              Y                         2  
Q(X0) + F(X0,Q(X0))*H + -----------------------------------------*H  
+ (F  (X0,Q(X0)) + F  (X0,Q(X0))*F(X0,Q(X0))  
    XX              XY  
    + F (X0,Q(X0))*F (X0,Q(X0)) + F  (X0,Q(X0))*F(X0,Q(X0))  
       X            Y              YX  
                               2               2                 3  
    + F  (X0,Q(X0))*F(X0,Q(X0))  + F (X0,Q(X0)) *F(X0,Q(X0)))/6*H  
       YY                           Y  
 + O(H )  

Normally partial differentials are assumed as non-commutative

  F   - F  
   XY    YX

However, a generic function can be declared to have globally interchangeable partial derivatives using the declaration DFP_COMMUTE which takes the name of a generic function or a generic function form as argument. For such a function differentiation variables are rearranged corresponding to the sequence of the generic variables.

  generic_function q(x,y);  
  dfp_commute q(x,y);  
  dfp(q(),{x,y,y}) + dfp(q(),{y,x,y}) + dfp(q(),{y,y,x});  

If only a part of the derivatives commute, this has to be declared using the standard REDUCE rule mechanism. Please note that then the derivative variables must be written as list.

16.20.3 Substitutions

When a generic form or a DFP expression takes part in a substitution the following steps are performed:

  1. The substitutions are performed for the arguments. If the argument list is empty the substitution is applied to the generic arguments of the function; if these change, the resulting forms are used as new actual arguments. If the generic function itself is not affected by the substitution, the process stops here.
  2. If the function name or the generic function form occurs as a left hand side in the substitution list, it is replaced by the corresponding right hand side.
  3. The new form is partially differentiated according to the list of partial derivative variables.
  4. The (eventually modified) actual parameters are substituted into the form for their corresponding generic variables. This substitution is done by name.


  generic_function f(x,y);  
  F  (X,10)  
  F  (10,10)  
  generic_function ff(y,z);  

The dataset dfpart.tst contains more examples, including a complete application for computing the coefficient equations for Runge-Kutta ODE solvers.