2 How to use it

The most important operator is `TAYLOR'.   It is used as follows:

TAYLOR(EXP:exprn[,VAR:kernel, VAR:exprn,ORDER:integer]...):exprn

where EXP is the expression to be expanded. It can be any REDUCE object, even an expression containing other Taylor kernels. VAR is the kernel with respect to which EXP is to be expanded. VAR denotes the point about which and ORDER the order up to which expansion is to take place. If more than one (VAR, VAR0, ORDER) triple is specified TAYLOR will expand its first argument independently with respect to each variable in turn. For example,

  taylor(e^(x^2+y^2),x,0,2,y,0,2);

will calculate the Taylor expansion up to order . Note that once the expansion has been done it is not possible to calculate higher orders. Instead of a kernel, VAR may also be a list of kernels. In this case expansion will take place in a way so that the sum of the degrees of the kernels does not exceed ORDER. If VAR evaluates to the special identifier INFINITY TAYLOR tries to expand EXP in a series in 1/VAR.

The expansion is performed variable per variable, i.e. in the example above by first expanding with respect to x and then expanding every coefficient with respect to y.

   There are two extra operators to compute the Taylor expansions of implicit and inverse functions:

IMPLICIT_TAYLOR(F:exprn,VAR1,VAR2:kernel,
IMPLICIT_TAYLOR(VAR1,VAR2:exprn, ORDER:integer):exprn

takes a function F depending on two variables VAR1 and VAR2 and computes the Taylor series of the implicit function VAR2(VAR1) given by the equation F(VAR1,VAR2) = 0. For example,

  implicit_taylor(x^2 + y^2 - 1,x,y,0,1,5);

INVERSE_TAYLOR(F:exprn,VAR1,VAR2:kernel,
INVERSE_TAYLOR(VAR1:exprn, ORDER:integer):exprn

takes a function F depending on VAR1 and computes the Taylor series of the inverse of F with respect to VAR2. For example,

  inverse_taylor(exp(x)-1,x,y,0,8);

  When a Taylor kernel is printed, only a certain number of (non-zero) coefficients are shown. If there are more, an expression of the form (n terms) is printed to indicate how many non-zero terms have been suppressed. The number of terms printed is given by the value of the shared algebraic variable TAYLORPRINTTERMS. Allowed values are integers and the special identifier ALL. The latter setting specifies that all terms are to be printed. The default setting is 5.

  If the switch TAYLORKEEPORIGINAL is set to ON the original expression EXP is kept for later reference. It can be recovered by means of the operator

TAYLORORIGINAL(EXP:exprn):exprn

An error is signalled if EXP is not a Taylor kernel or if the original expression was not kept, i.e. if TAYLORKEEPORIGINAL was OFF during expansion. The template of a Taylor kernel, i.e.\ the list of all variables with respect to which expansion took place together with expansion point and order can be extracted using  

TAYLORTEMPLATE(EXP:exprn):list

This returns a list of lists with the three elements (VAR,VAR0,ORDER). As with TAYLORORIGINAL, an error is signalled if EXP is not a Taylor kernel.

TAYLORTOSTANDARD(EXP:exprn):exprn

converts all Taylor kernels in EXP into standard form and   resimplifies the result.

TAYLORSERIESP(EXP:exprn):boolean

may be used to determine if EXP is a Taylor kernel.   Note that this operator is subject to the same restrictions as, e.g., ORDP or NUMBERP, i.e. it may only be used in boolean expressions in IF or LET statements. Finally there is

TAYLORCOMBINE(EXP:exprn):exprn

which tries to combine all Taylor kernels found in EXP into one.   Operations currently possible are:  

• Addition, subtraction, multiplication, and division.
• Roots, exponentials, and logarithms.
• Trigonometric and hyperbolic functions and their inverses.

    If TAYLORKEEPORIGINAL is set to ON and if all Taylor kernels in exp have their original expressions kept TAYLORCOMBINE will also combine these and store the result as the original expression of the resulting Taylor kernel.   There is also the switch TAYLORAUTOEXPAND (see below).

There are a few restrictions to avoid mathematically undefined expressions: it is not possible to take the logarithm of a Taylor kernel which has no terms (i.e. is zero), or to divide by such a beast. There are some provisions made to detect singularities during expansion: poles that arise because the denominator has zeros at the expansion point are detected and properly treated, i.e. the Taylor kernel will start with a negative power. (This is accomplished by expanding numerator and denominator separately and combining the results.) Essential singularities of the known functions (see above) are handled correctly.

  Differentiation of a Taylor expression is possible. If you differentiate with respect to one of the Taylor variables the order will decrease by one.

  Substitution is a bit restricted: Taylor variables can only be replaced by other kernels. There is one exception to this rule: you can always substitute a Taylor variable by an expression that evaluates to a constant. Note that REDUCE will not always be able to determine that an expression is constant.

  Only simple taylor kernels can be integrated. More complicated expressions that contain Taylor kernels as parts of themselves are automatically converted into a standard representation by means of the TAYLORTOSTANDARD operator. In this case a suitable warning is printed.

  It is possible to revert a Taylor series of a function f, i.e., to compute the first terms of the expansion of the inverse of f from the expansion of f. This is done by the operator

TAYLORREVERT(EXP:exprn,OLDVAR:kernel, NEWVAR:kernel):exprn

EXP must evaluate to a Taylor kernel with OLDVAR being one of its expansion variables. Example:

  taylor (u - u**2, u, 0, 5);
  taylorrevert (ws, u, x);

This package introduces a number of new switches:

 
• If you set TAYLORAUTOCOMBINE to ON REDUCE automatically combines Taylor expressions during the simplification process. This is equivalent to applying TAYLORCOMBINE to every expression that contains Taylor kernels. Default is ON.

   

• TAYLORAUTOEXPAND makes Taylor expressions ``contagious'' in the sense that TAYLORCOMBINE tries to Taylor expand all non-Taylor subexpressions and to combine the result with the rest. Default is OFF.

   

• TAYLORKEEPORIGINAL, if set to ON, forces the package to keep the original expression, i.e. the expression that was Taylor expanded. All operations performed on the Taylor kernels are also applied to this expression which can be recovered using the operator TAYLORORIGINAL. Default is OFF.

   

• TAYLORPRINTORDER, if set to ON, causes the remainder to be printed in big-O notation. Otherwise, three dots are printed. Default is ON.

   

• There is also the switch VERBOSELOAD. If it is set to ON REDUCE will print some information when the Taylor package is loaded. This switch is already present in PSL systems. Default is OFF.