%
% LaTeX source file
%
\documentstyle[12pt,fullpage]{article}
% \documentstyle[12pt,dina4]{article}
\begin{document}
%
\font\mengft=cmss9 scaled \magstep1
\def \nzo{\hbox{\mengft{I \hskip -1.7mm N}$_0$}}
%
\newenvironment{listvar}[3]%
{\begin{list}{}
{\settowidth{\labelwidth}{#2 #1}
\setlength{\leftmargin}{\labelwidth}
\addtolength{\leftmargin}{\labelsep}
\parsep 0.2ex plus 0.1ex minus 0.1ex
\itemsep 0.0ex #3
\renewcommand{\makelabel}[1]{#2 ##1\hfill}}}%
{\end{list}}
%
\title{A Maple package for transforming sequences, series and functions}
\author{J. Grotendorst\\
        Zentralinstitut f\"ur Angewandte Mathematik\\
        Forschungszentrum J\"ulich GmbH\\
        Postfach 1913\\
        D-5170 J\"ulich\\
        Fed. Rep. Germany}
\date{}
\maketitle
The program TRANS is defined
as a MAPLE package, i.e. an entire collection of new
MAPLE functions can be loaded very quickly with just one MAPLE
command, namely the {\bf with} command. Executing the command:
\[\begin{array}{l}
 {\bf with}{\tt(TRANS)}; \rightarrow\\
                                     \\
 {\tt [tay, thetit, lev, sidi, rich, rho,}\\
 {\tt asy, theta, aitken, gb, eps, rhoit]}
\end{array}\]
causes a table (named TRANS) to be loaded.
The indices of the table are the various MAPLE function names
and the table entry for each index is the corresponding
code of the function.
If the package TRANS is loaded
via the {\bf with} command, then the simple function names
{\tt thetit}, {\tt lev}, etc.
may be used; otherwise, the long-form notation {\tt TRANS[thetit]},
etc. would have to be used as function name.
The programs
\begin{eqnarray}
{\bf thetit, lev, sidi, rich, rho,}\nonumber\\
{\bf theta, aitken, gb, eps, rhoit}
\end{eqnarray}
represent the implementations of recursive algorithms for the
transformation of sequences.
These programs are input-directed, i.e.
the elements $s_{n}$ with $n = 0, 1, 2, ...$ of the
sequence to be transformed have to be computed and then read in
successively starting with $s_{0}$.
Whenever a new sequence element
$s_{n}$ is computed the MAPLE procedure has to be called again and
a new approximation to the limit of the sequence is returned.
The MAPLE functions listed in (1) work for symbolic as well as
numerical sequences. A main difference between symbolic and numerical
algorithms is the intermediate expression growth in symbolic
calculations. To reduce the growth of intermediate expressions
every new rational approximant calculated in the above procedures
is normalized, i.e. the rational function has the form
numerator/denominator,
where the numerator and denominator are relatively prime
polynomials.
In the following we list the obligatory input parameters of the
MAPLE procedures in (1):
\begin{listvar}{aitken}{\bf}{\it}
\item[eps]    (sofn, n,    arr1)
\item[aitken] (sofn, n,    arr1)
\item[thetit] (sofn, n,    arr1)
\item[theta]  (sofn, n,    arr1, arr2)
\item[rho]    (sofn, xofn  n,    arr1, arr2)
\item[rhoit]  (sofn, xofn  n,    arr1, arr2)
\item[rich]   (sofn, xofn  n,    arr1, arr2)
\item[gb]     (sofn, aofn  n,    arr1, arr2)
\item[lev]    (sofn, aofn  n,    arr1, arr2, typ)
\item[sidi]   (sofn, aofn  n,    arr1, arr2, typ)
\end{listvar}
The meaning of the formal parameters is as follows
\begin{listvar}{array}{\it}{\rm}
\item[sofn] element $s_{n}$ of the sequence $\{s_{n}\}_{n \geq 0}$
\item [xofn] element $x_{n}$ of the auxiliary sequence
\item [aofn] term $a_{n}={s}_{n}-{s}_{n-1}$ (of a series)
\item [n]    number of the last sequence element
\item [arr1] 1-dimensional array to store intermediate
             elements of the table of transforms
\item [arr2] 1-dimensional array to store intermediate
             elements of the table of transforms
\item [typ]  typ of transformation:
\item []     u, t, d, v in case of function {\bf lev}
\item []     su, st, sd, sv in case of function {\bf sidi}
\end{listvar}
The programs {\bf tay} and {\bf asy} of the package TRANS
are designed for the symbolic transformation of given
Taylor expansions or asymptotic expansions with fixed truncation
order. Program {\bf tay} has the following input parameters:
\begin{listvar}{Obligatory:}{\it}{\rm}
\item[Obligatory:]
\item[s]
taylor series. s has to be the first actual parameter and must be
of type ``series''.
\item[Optional:]
\item[typ]
typ of transformation
\item[norder]
order of transformation (default: number of terms of the
taylor series)
\item[expts]
list with expansion points of data type ``real constant''
for segmented approximation
(default: [ ], empty list)
\item[switch]
switch for the generation of a FORTRAN function: fort or
nofort (default: nofort)
\item[precision]
type of the FORTRAN function: single or double (default:
single)
\item[evalorder]
computational form for the rational function:
horner or confrac (default: horner)
\item[fn]
filename for the FORTRAN function program. fn has to be of data type
``string'' (default: \`{}\`{}).
\end{listvar}
Formal parameters of procedure {\bf asy}:
\begin{listvar}{Obligatory:}{\it}{\rm}
\item[Obligatory:]
\item[s]
asymptotic series. s has to be in sum-of-products form rather
than of type series. s has to be the first actual parameter.
\item[var:]
independent variable; var has to be the second parameter.
\item[Optional:]
\item[typ]
typ of transformation
\item[norder]
order of transformation (default: number of terms of the
asymptotic series)
\item[switch]
switch for the generation of a FORTRAN function: fort or
nofort (default: nofort)
\item[precision]
type of the FORTRAN function: single or double (default:
single)
\item[evalorder]
computational form for the rational function:
horner or confrac (default: horner)
\item[fn]
filename for the FORTRAN function program (default:
\`{}\`{}).
\end{listvar}
The order of the optional parameters in {\bf tay} and {\bf asy} is
arbitrary.
In both procedures the formal input parameter {\it typ}
for the typ of transformation can have one of the following values:
\begin{listvar}{thetit}{\tt}{\rm}
\item[u]      {\em u} transformation
\item[t]      {\em t} transformation
\item[d]      {\em d} transformation
\item[v]      {\em v} transformation
\item[su]     {\em su} transformation
\item[st]     {\em st} transformation
\item[sd]     {\em sd} transformation
\item[sv]     {\em sv} transformation
\item[sh]     Shanks transformation
\item[gb]     Germain-Bonne transformation
\item[rho]    $\varrho$ transformation
\item[rhoit]  iterated ${\varrho}_{2}$ transformation
\item[r]      Richardson extrapolation process
\item[theta]  $\vartheta$ algorithm
\item[thetit] iterated $\vartheta_{2}$ algorithm
\item[at]     iterated Aitken transformation
\end{listvar}
In case of the Richardson extrapolation (r), $\varrho$ transformation
(rho) or iterated $\varrho_{2}$ transformation (rhoit)
 the user can specify a list of auxiliary parameters
$x_{n},\ n\in\nzo $
(default: $x_{n} = 1/(n+1),\ n\in\nzo$,
for the Richardson extrapolation process,
and $x_{n} = n+1,\ n\in\nzo$,
for the $\varrho$ transformation and the iterated $\varrho_{2}$
transformation).
Then the first element in the list characterizes the type of the
transformation, i.e. it must be equal to \`{}r\`{}, \`{}rho\`{}
or \`{}rhoit\`{}.
In MAPLE a list is an ordered sequence of expressions surrounded
by brackets $[ \ldots ]$ or, alternatively, by $(| \ldots |)$.
The main structure of {\bf tay}
and {\bf asy} is as follows: First it is checked whether forbidden
actual parameters were used as input parameters.
If an error occurs at this level the procedure terminates after an
error message. Then the sequence transformation specified via the
input parameter {\it typ} is performed
by calling the appropriate procedure.
Finally, the resulting expression returned by this subprocedure
is normalized and, if specified by the user,
translated into a FORTRAN function program. The FORTRAN functions
can be generated as single (7 significant decimal digits)
or double precision  (16 significant dicimal digits) functions.
In order to optimize the numerical evaluation of
rational functions two computational methods are supported:
(i) numerator and denominator polynomials are evaluated using nested
Horner rules, (ii) the associated continued fraction of the
rational function is evaluated.
Furthermore, procedure {\bf tay} supports segmented rational
approximation
to improve the quality of the approximation over the whole interval.
With both procedures
{\bf tay} and {\bf asy} there is associated a
remember table, i.e. whenever the value of
one of these procedures is computed, the MAPLE system makes an entry
in a table ``remembering'' the value of the procedure for the
given arguments. When the procedure is called again with the same
arguments, the MAPLE system retrieves the result from the procedure's
remember table. In this way, it is possible to avoid redundant
computations.
\end{document}