A Maple V Package for the Analysis and. Version 1.0. Claus Bendtsen. Abstract

Transcription

1 A Maple V Package for the Analysis and Construction of Runge-Kutta Methods Version.0 Claus Bendtsen Abstract This package is for use with the Maple V symbolic computational software in order to ease the analysis and construction of Runge-Kutta methods. It consists of a number of functions for handling Butcher trees, analysis of stability properties for Runge-Kutta methods and tools for construction of methods with certain properties. UNIC (The Danish Computer Centre for Research and Education, DTU, Bldg. 304, DK-800 Lyngby, Denmark), Claus.Bendtsen@uni-c.dk

2 Copyright 99 by Claus Bendtsen. This package is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., Mass Ave, Cambridge, MA 039, USA.

3 Contents Introduction Obtaining and Installing the Package 3 An Example 4 The Butcher tree package 3 4. Introduction to the ButcherTree package : : : : : : : : : : : : : : : : : : : : 3 4. ButcherTree[alpha] { computes : : : : : : : : : : : : : : : : : : : : : : : : : ButcherTree[equal] { compare two trees : : : : : : : : : : : : : : : : : : : : : ButcherTree[gamma] { computes : : : : : : : : : : : : : : : : : : : : : : : : 4 4. ButcherTree[generate] { all trees up to given order : : : : : : : : : : : : : : : 4. ButcherTree[insert] { insert a tree into a list of trees : : : : : : : : : : : : : : 4. ButcherTree[listtdi] { dierentiate a list of trees : : : : : : : : : : : : : : : : 4.8 ButcherTree[occurences] { count number of occurences : : : : : : : : : : : : : 4.9 ButcherTree[order] { compute the order of a tree : : : : : : : : : : : : : : : : 4.0 ButcherTree[tdi] { dierentiate a tree : : : : : : : : : : : : : : : : : : : : : : The Runge-Kutta package. Introduction to the RungeKutta package : : : : : : : : : : : : : : : : : : : : :. RungeKutta[C] { simplifying condition C() : : : : : : : : : : : : : : : : : : : 8.3 RungeKutta[conditions] { order conditions : : : : : : : : : : : : : : : : : : : : 8.4 RungeKutta[dLaguerre] { derivative of Laguerre polynomials : : : : : : : : : 9. RungeKutta[dLegendre] { derivative of Legendre polynomials : : : : : : : : : 9. RungeKutta[error] { error constants : : : : : : : : : : : : : : : : : : : : : : : 0. RungeKutta[Gauss] { Gauss polynomials : : : : : : : : : : : : : : : : : : : : :.8 RungeKutta[Laguerre] { Laguerre polynomials : : : : : : : : : : : : : : : : :.9 RungeKutta[Legendre] { Legendre polynomials : : : : : : : : : : : : : : : : :.0 RungeKutta[Lobatto] { Lobatto polynomials : : : : : : : : : : : : : : : : : :. RungeKutta[order] { order of approximation to e z : : : : : : : : : : : : : : :. RungeKutta[Phi] { computes j : : : : : : : : : : : : : : : : : : : : : : : : : 3.3 RungeKutta[Psik] { Compute k : : : : : : : : : : : : : : : : : : : : : : : : : 3.4 RungeKutta[Q] { Q for B-stable methods : : : : : : : : : : : : : : : : : : : : 4. RungeKutta[quadrature] { quadrature constants : : : : : : : : : : : : : : : : 4. RungeKutta[Radau left] { Radau left polynomials : : : : : : : : : : : : : : :. RungeKutta[Radau right] { Radau right polynomials : : : : : : : : : : : : : :.8 RungeKutta[stabfnk] { stability function : : : : : : : : : : : : : : : : : : : : :.9 RungeKutta[stype] { check for stability properties : : : : : : : : : : : : : : :.0 RungeKutta[W] { W-transformation matrix : : : : : : : : : : : : : : : : : : :. RungeKutta[X] { compute X for the W-transformation : : : : : : : : : : : : : 8. RungeKutta[xi] { for the W-transformation : : : : : : : : : : : : : : : : : : 8 A Numerical Linear Algebra package 9. Introduction to the NumLinAlg package : : : : : : : : : : : : : : : : : : : : : 9. NumLinAlg[cholesky] { Cholesky factorization : : : : : : : : : : : : : : : : : : 9.3 NumLinAlg[diagonalm] { diagonal matrix : : : : : : : : : : : : : : : : : : : : 0 i

4 .4 NumLinAlg[eye] { identity matrix : : : : : : : : : : : : : : : : : : : : : : : : : 0. NumLinAlg[gramschmidt] { Gram Schmidt orthogonalization : : : : : : : : :. NumLinAlg[qr] { QR-factorization : : : : : : : : : : : : : : : : : : : : : : : :. NumLinAlg[unitv] { unit vector : : : : : : : : : : : : : : : : : : : : : : : : : : ii

5 INTRODUCTION Introduction When constructing and analyzing Runge-Kutta methods using a symbolic computational engine such as Maple V, one tend to use many of the same non-standard functions over and over again. This package is a collection of such functions which are especially useful wrt. Runge-Kutta methods. The package is composed of three subpackages namely a package for handling Butcher trees, a package specically for Runge Kutta methods and a package for numerical linear algebra, which contains a limited number of numerical rutines needed by the two other packages. Each of the functions in the package is documented in this paper, and since some functions are included mainly for internal use the might not seem relevant to an end user. Whenever a function is closely related to a reference this is given in order to provide understanding for the use of the function. I have tried to keep the layout of the documentation as close to that of the Maple documentation as possible in order to enhance the readability. Obtaining and Installing the Package The package can be optained by mailing the author or by anonymous FTP to ftp.uni-c.dk and is found in the directory uni-c/unicbe/maple. The package is developed for Maple V, release 3 (but might work on other versions). Install the package by unpacking the.m les in a directory. Then edit your maple initialization le ( ~ /.mapleinit on UNIX systems) and add something similar to the following: libname := libname,`/myhomedir/maple/packages`: readlib(butchertree): readlib(rungekutta): readlib(numlinalg): Now when you start up Maple the tables, ButcherTree, RungeKutta and NumLinAlg will be dened and you can access any of the package functions in the long form (for example ButcherTree[alpha](...)). You can also dene the entire package by issuing the with command. The package has been tested but might still have some bugs { I would appreciate comments, corrections and ideas to the package but do not provide any warranty what so ever. 3 An Example In the following an example is given on the construction of two th order SIRK methods. First the construction of a stiy accurate method: > with(linalg): > Digits:=0: Dene stability function > s := : > gam := 'gam': R := -sum('subs(z=/gam,dlaguerre(z,s,s-j))*(gam*z)^j',

6 3 AN EXAMPLE 'j'=0..s-)/(-z*gam)^s: Solve for eigenvalue so that R(z) has order : > gam := convert(fsolve(coeff(convert(taylor(r-exp(z),z,s+), polynom),z^),gam, ),rational); gam := Check that the order is correct, > p := order(r,z,'sloppy'); Calculate X for the W -transformation as described in [Ben], > g := denom(*(numer(r)-denom(r))/(numer(r)+denom(r))): > g := g/tcoeff(g): > Y := X(s,s-,0): Y[,]:=0: > x := subs(solve(coeffs(det(numlinalg[eye](s)-z*y)-g,z), convert(subvector(y,..s,s),set)),evalm(y)): x[,]:=/: Choose quadrature formula and perform W -transformation: > b:=evalf(quadrature(radau right,s)[]): > c:=evalf(quadrature(radau right,s)[]): > A:=evalf(evalm(W(c)&*x&*inverse(W(c)))): Test the computed method, > stype(a,b,'astable'); true > order(a,b); > order(a,b,sloppy); 0 So method is of order as expected. Now display method coecients: > convert(evalf(evalm(a),0),rational); ? ? ? ? ? ? ? ? ? = > convert(evalf(evalm(b),0),rational); h ; ; ; ; =i > convert(evalf(evalm(c),0),rational); h ; ; ; i ;

7 4 THE BUTCHER TREE PACKAGE 3 Now construct B-stable SIRK method instead of A-stable stiy accurate. > q := Q(R,z): > w := W(quadrature(Radau right,)[]): > A := evalf(evalm(w&*x(s,q)&*w^(-))): > b := quadrature(radau right,)[]: > stype(a,b,'bstable',sloppy); true > order(a,b,sloppy); Display method coecients (quadrature formula is unchanged): > convert(evalf(evalm(a),0),rational); ? ? ? ? ? ? ? ? If the quadrature formula is appropriately chosen, then the method can also be stiy accurate, [Benar]. It does however fall outside the scope of this example to do that. The above example is found in the le example.ms. 4 The Butcher tree package 4. Introduction to the ButcherTree package function(args) ButcherTree[function](args) To use a function from the Butcher tree package, either dene the function alone using the command with(butchertree,function), or dene all the functions in the package by using the command with(butchertree). Alternatively, invoke the function using the form ButcherTree[function]. This long form is necessary whenever there is a conict between a package function name and another function used in the same session. The functions available are: alpha equal gamma generate insert listtdi occurences order tdi Butcher trees are used for representing elementary dierentials { see e.g. [But8] for an extensive introduction. Trees are represented on the form,, [], [; ], [[]] and so forth.

8 4 THE BUTCHER TREE PACKAGE 4 4. ButcherTree[alpha] { computes alpha(t ) T { an unlabeled tree alpha computes for T, i.e. the number of possible dierent monotonic labellings of T. > with(butchertree): > T := generate(,last)[3]; > alpha(t); T := [; [[]]] 4 References: [HNW93, Def. II..] 4.3 ButcherTree[equal] { compare two trees equal(t,t ) T,T { unlabeled trees The function equal returns true if T and T are equivalent and false otherwise. Two trees are said to be equivalent if they correspond to the same elementary dierentials. > with(butchertree): > equal([tau,[[tau],tau]],[[tau,[tau]],tau]); true > equal([tau,tau],[[tau]]); false 4.4 ButcherTree[gamma] { computes gamma(t ) T { an unlabeled tree The function gamma computes for T, i.e. the product of the order of T and all orders appearing when the roots, one after another, are removed from T. > with(butchertree):

9 4 THE BUTCHER TREE PACKAGE > T := generate(,last)[3]; > gamma(t); T := [; [[]]] 30 References: [HNW93, Def. II..0] 4. ButcherTree[generate] { all trees up to given order generate(n) generate(n,option) n { an integer option { one of: all, allflat, last generate with no option or with the all option specied returns a list of sets of all trees of order up to n. The rst element of the list will be all trees of order, the second element all trees of order two and so forth. The allflat option forces the return value to be one set of all the trees rather than a list of sets. The last option causes only the set of trees of order n to be returned. > with(butchertree): > generate(4); [f g; f[]g; f[[]]; [; ]g; f[[[]]]; [; []]; [[; ]]; [; ; ]g] > generate(4,last); f[[[]]]; [; []]; [[; ]]; [; ; ]g 4. ButcherTree[insert] { insert a tree into a list of trees insert(l,t ) L { a list of trees T { an unlabeled tree The function, insert returns the list of trees, L with the tree T appended if it is not already in the list. Otherwise the list L is returned unchanged. > with(butchertree): > insert([[[tau]],[tau,tau]],[[tau]]); [[[]]; [; ]]

10 4 THE BUTCHER TREE PACKAGE > insert([[[tau]],[tau,tau]],[tau]); [[[]]; [; ]; []] 4. ButcherTree[listtdi] { dierentiate a list of trees listtdiff(l) L { a list of trees listtdiff computes the derivative of each tree in L and returns a set of all trees included in the derivative. If a tree occurs several times in the derivative it is only included once in the returned set. > with(butchertree): > listtdiff([[[tau]],[tau,tau]]); f[[[]]]; [; []]; [[; ]]; [; ; ]g See Also: tdiff 4.8 ButcherTree[occurences] { count number of occurences occurences(t,l) T { an unlabeled tree L { a list of unlabeled trees occurences counts the number of times the tree T occurs in the list of trees L. This is useful to determine the number of occurences of a subtree in a tree, since a tree in Maple representation is basically a list of subtrees. > with(butchertree): > occurences([tau],[tau,[tau],[[tau]],[tau]]); 4.9 ButcherTree[order] { compute the order of a tree order(t ) T { an unlabeled tree

11 THE RUNGE-KUTTA PACKAGE The function order returns the order of T. The order of a tree is equal to the number of vertices in the tree. > with(butchertree): > order([[[[tau,tau]]]]); References: [But8],[HNW93, Def. II..] See Also: generate 4.0 ButcherTree[tdi] { dierentiate a tree tdiff(t ) T { an unlabeled tree The function tdiff computes the derivative of T and returns a set of all trees included in the derivative. The dierent terms are basically computed by adding a branch to each vertex of the tree in turn. All returned trees are dierent, i.e. no tree in the returned set will be equivalent to another tree in the set. > with(butchertree): > tdiff([[tau]]); f[[[]]]; [; []]; [[; ]]g See Also: listtdiff The Runge-Kutta package. Introduction to the RungeKutta package function(args) RungeKutta[function](args) To use a function from the Runge-Kutta package, either dene the function alone using the command with(rungekutta,function), or dene all the functions in the package by using the command with(rungekutta). Alternatively, invoke the function using the form RungeKutta[function]. This long form is necessary whenever there is a conict between a package function name and another function used in the same session.

12 THE RUNGE-KUTTA PACKAGE 8 The functions available are: C conditions dlaguerre dlegendre error Gauss Laguerre Legendre Lobatto order Phi Psik Q quadrature Radau left Radau right stabfnk stype W X xi This package mainly provides functions for evaluating stability and order properties of Runge-Kutta methods as well as tools for the construction of implicit Runge-Kutta methods. A nice reference for understanding the functions is [HNW93, HW9]. Many of the functions assume C(), i.e. that the sum of all elements in a row of the Runge- Kutta matrix is equal to the corresponding internal point. Thus these functions often just use the Runge-Kutta matrix and the vector of the weights, b and not the internal points, c.. RungeKutta[C] { simplifying condition C() C(; A; c) { an integer A { a matrix c { a vector The function C compute the C() simplifying conditions for the Runge-Kutta method with coecient matrix, A and internal points given by c. > A := linalg[matrix](,): c := linalg[vector](): > C(,A,c); A; + A ;? c ; A ; + A ;? c ; A ; c + A ; c? c ; A ; c + A ; c? c References: [But4].3 RungeKutta[conditions] { order conditions conditions(p,a,b) conditions(p,a,b,c) p { an integer A { a matrix b,c { vectors

13 THE RUNGE-KUTTA PACKAGE 9 conditions generates the order conditions up to order p for the Runge-Kutta method with coecient matrix A and weights b. If c is specied the simplifying assumptions C() is used to simplify the generated conditions. > b := linalg[vector](): A:=linalg[matrix](,): > conditions(,a,b); b (A ; + A ; ) + b (A ; + A ; )? ; b + b? > c := linalg[vector](): > conditions(,a,b,c); b c + b c? ; b + b? See Also: ButcherTree[generate].4 RungeKutta[dLaguerre] { derivative of Laguerre polynomials dlaguerre(x,s,n) x { a variable s,n { integers dlaguerre computes the n'th derivative with respect to x of the s-degree Laguerre polynomial in x. If n is 0 the function just returns the s-degree Laguerre polynomial. > dlaguerre('x',3,);?3 + 3x? x See Also: dlegendre, Gauss, Laguerre, Legendre, Lobatto, Radau left, Radau right. RungeKutta[dLegendre] { derivative of Legendre polynomials dlegendre(x,s,n) x { a variable s,n { integers dlegendre computes the n'th derivative with respect to x of the s-degree, shifted and normalized Legendre polynomial in x.

14 THE RUNGE-KUTTA PACKAGE 0 If n is 0 the function just returns the s-degree shifted and normalized Legendre polynomial. > dlegendre('x',,); References: [HW9, p. 83] p (4x? ) See Also: dlaguerre, Gauss, Laguerre, Legendre, Lobatto, Radau left, Radau right. RungeKutta[error] { error constants error(r,z ) error(a,b,options) R { a stability function z { a variable A { a matrix b { a vector option { one or more of: sloppy, prec=x, coeffs, trees The function error computes the error constant (ie. the rst non-zero term of the taylor expansion) for a stability function given by R in z or a Runge-Kutta method given by A and b. If the option, 'sloppy' is specied then terms near zero are considered equal to zero which reduces the eect of rounding errors. If the option, 'prec=x' is given then terms less than e? x are considered zero. The option, 'coes' makes the function return all the error constants rather than just the non-zero term from the Taylor expansion. If in addition 'trees' is specied then the error constants are returned together with their corresponding Butcher trees. > error((+z/)/(-z/),z); > A := linalg[matrix](,,[[/4,/4-sqrt(3)/], [/4+sqrt(3)/,/4]]): b := linalg[vector](,[/,/]): > error(a,b,coeffs); References: [HNW93, Theo. II.3.] See Also: order? 9 ; 3 ; ;? 4 ;? 9 ; ; 3 ; 3 ;? 4

15 THE RUNGE-KUTTA PACKAGE. RungeKutta[Gauss] { Gauss polynomials Gauss(x,s) x { a variable s { an integer Gauss computes the s-degree Gauss polynomial in x. > Gauss('x',); (x? ) + 8x(x? ) + x See Also: dlaguerre, dlegendre, Laguerre, Legendre, Lobatto, Radau left, Radau right.8 RungeKutta[Laguerre] { Laguerre polynomials Laguerre(x,s) x { a variable s { an integer Laguerre computes the s-degree Laguerre polynomial in x. > Laguerre('x',3);? 3x + 3 x? x3 See Also: dlaguerre, dlegendre, Gauss, Legendre, Lobatto, Radau left, Radau right.9 RungeKutta[Legendre] { Legendre polynomials Legendre(x,s) x { a variable s { an integer Legendre computes the s-degree shifted and normalized Legendre polynomial in x.

16 THE RUNGE-KUTTA PACKAGE > Legendre('x',); p? (x? ) + 8x(x? ) + 3x References: [HW9, p. 83] See Also: dlaguerre, dlegendre, Gauss, Laguerre, Lobatto, Radau left, Radau right.0 RungeKutta[Lobatto] { Lobatto polynomials Lobatto(x,s) x { a variable s { an integer Lobatto computes the s-degree Lobatto polynomial in x. > Lobatto('x',3); x(x? ) + x (x? ) See Also: dlaguerre, dlegendre, Gauss, Laguerre, Legendre, Radau left, Radau right. RungeKutta[order] { order of approximation to e z order(r,z ) order(a,b) order(a,b,sloppy) order(a,b,prec=x) R { a stability function z { a variable A { a matrix b { a vector order computes the order at which the stability function R in z approximates the exponential function. If a Runge-Kutta method is specied rather than a stability function then the order of the specied method is returned. If the 'sloppy' argument is specied then order restrictions which are almost satised are not considered violated this reduces the eect of rounding errors. If the option, 'prec=x' is given then terms less than e? x are considered zero. > with(linalg):

17 THE RUNGE-KUTTA PACKAGE 3 > order((+z/)/(-z/),z); > A := matrix(,,[[/4+e-9,/4-sqrt(3)/], [/4+sqrt(3)/,/4]]): b := vector(,[/,/]): > order(a,b); > order(a,b,sloppy); 4. RungeKutta[Phi] { computes j Phi(j,T,A) Phi(j,T,A,c) j { an integer T { an unlabeled tree A { a matrix c { a vector The function Phi computes j (T ) for the tree T using the Runge-Kutta matrix A. If c is given then it is assumed that the sum of each row of A is equal to the corresponding element in c and this is used to simplify the returned expressions. > A := linalg[matrix](3,3): > Phi(,[[tau,tau]],A); A ; (A ; + A ; + A ;3 ) + A ; (A ; + A ; + A ;3 ) + A ;3 (A 3; + A 3; + A 3;3 ) > c := linalg[vector](3): > Phi(,[[tau,tau]],A,c); A ; c + A ; c + A ;3 c 3 References: [HNW93, Def. II..9].3 RungeKutta[Psik] { Compute k Psik(R,x ) Psik(R,x,k ) Psik(R,x,cfrac) Psik(R,x,k,cfrac) R { a stability function x { a variable k { an integer

18 THE RUNGE-KUTTA PACKAGE 4 The function Psik computes k for the stability function, R in x. If k is not specied then the maximum k is determined on basis of the order of the stability function. If the option 'cfrac' is specied then the continued fraction of is returned along with k. > Psik((+z/+z^/)/(-z/+z^/),z,'cfrac'); z z; + z > Psik((+*z/+z^/0)/(-3*z/+3*z^/0-z^3/0),z); z?0?0 + z > Psik((+*z/+z^/0)/(-3*z/+3*z^/0-z^3/0),z,); z(?0 + z)? 0? z + z References: [Hai8], [HW9, Theo. IV.3.8].4 RungeKutta[Q] { Q for B-stable methods Q(R,z ) R { a stability function z { a variable Q computes the matrix, Q for the stability function R in z. The computed Q can be used for constructing B-stable Runge-Kutta methods with R as stability function. It is generally not desirable that the stability function contains oating point numbers, since oating point numbers easily generate roundo errors when doing continued fraction expansions. It is therefore recommended to convert oating point numbers to rationals prior to using this function. > Q((+*z/+z^/0)/(-3*z/+3*z^/0-z^3/0),z); 0 References: [HW8], [Benar]. RungeKutta[quadrature] { quadrature constants quadrature(f,n)

19 THE RUNGE-KUTTA PACKAGE f { a polynomial function n { an integer quadrature computes the quadrature constants for a given polynomial of degree n, given by the polynomial function, f. > quadrature(radau right,4); [[:040 : : : ]; [: : :8948 : ]] See Also: Gauss, Lobatto, Radau left, Radau right. RungeKutta[Radau left] { Radau left polynomials Radau left(x,s) x { a variable s { an integer Radau left computes the s-degree Radau left polynomial in x. > Radau left('x',3); x(x? ) + x (x? ) + x 3 See Also: dlaguerre, dlegendre, Gauss, Laguerre, Legendre, Lobatto, Radau right. RungeKutta[Radau right] { Radau right polynomials Radau right(x,s) x { a variable s { an integer Radau right computes the s-degree Radau right polynomial in x. > Radau right('x',3); (x? ) 3 + x(x? ) + x (x? )

20 THE RUNGE-KUTTA PACKAGE See Also: dlaguerre, dlegendre, Gauss, Laguerre, Legendre, Lobatto, Radau left.8 RungeKutta[stabfnk] { stability function stabfnk(a,b,z ) A { a matrix b { a vector z { a name stabfnk generates the stability function in z for the Runge-Kutta method with matrix A and weights b. > A := linalg[matrix](,,[[/4,/4-sqrt(3)/], [/4+sqrt(3)/,/4]]): b := linalg[vector](,[/,/]): > stabfnk(a,b,z); + z + z? z + z.9 RungeKutta[stype] { check for stability properties stype(r,x,option ) stype(r,x,option,sloppy) stype(r,x,option,prec=x) stype(a,b,option ) stype(a,b,option,sloppy) stype(a,b,option,prec=x) R { a stability function x { a variable option { one of Aacceptable or Lacceptable A { a matrix b { a vector option { one of Astable, Bstable, Lstable or stiffly accurate The function stype checks a method or stability function for stability properties. If a stability function, R in x is supplied then this can be checked for A-acceptability and L-acceptability. If a Runge-Kutta method is supplied then this can be checked for A-, B- or L-stability or sti accuracy.

21 THE RUNGE-KUTTA PACKAGE If the option, 'sloppy' is specied then the computed results are allowed to deviate slightly from the stability demands required, in order to accept round-o errors. If the option, 'prec=x' is given then terms less than e? x are considered zero. > stype((+x/3)/(-*x/3+x^/),x,aacceptable); true > stype((-x/)/(+x/),x,aacceptable); false > stype((+x/3)/(-*x/3+x^/),x,lacceptable); true > stype((+x/)/(-x/),x,lacceptable); false > stype(linalg[matrix](,,[[0,0],[/,/]]), linalg[vector](,[/,/]),bstable); false > stype(linalg[matrix](,,[[0,0],[/,/]]), linalg[vector](,[/,/]),astable); true > stype(linalg[matrix](,,[[0,0],[/,/]]), linalg[vector](,[/,/]),lstable); false > stype(linalg[matrix](,,[[/,-/],[3/4,/4]]), linalg[vector](,[3/4,/4]),bstable); true > stype(linalg[matrix](,,[[/,-/],[3/4,/4]]), linalg[vector](,[3/4,/4]),lstable); true > stype(linalg[matrix](,,[[/,-/],[3/4,/4]]), linalg[vector](,[3/4,/4]),stiffly accurate); true.0 RungeKutta[W] { W-transformation matrix W(c) W(c,k ) W(c,b) c,b { a vectors k { an integer W generates the matrix, W for the W-transformation by evaluating the shifted, normalized Legendre polynomials for c. If k is specied only the rst k columns of W are generated and the remaining are left

22 THE RUNGE-KUTTA PACKAGE 8 unknown. If the vector, b with the weights of the quadrature formula is specied then W is orthogonalized wrt. the scalar product with weights given by b. If the quadrature formula is of suciently high order then the returned result is not changed by specifying b. > W(quadrature(Radau right,3)[]); 4?: p 3 :39389 p : p 3?: p : p 3 : p > W(quadrature(Radau right,3)[],quadrature(radau right,3)[]); : ?: p 3 :39389 p 3 4 : : p 3?: p : : p 3 : p References: [HW8], [HW9, p. 8{88] See Also: Legendre, X. RungeKutta[X] { compute X for the W-transformation X(s,,) X(s,Q) s,, { integers Q { a matrix X computes the matrix X for use with the W-transformation. The matrix is of dimension s and methods constructed with this matrix will satisfy the simplifyind conditions C() and D(). If the matrix Q is specied then X is returned with the maximum and and the matrix Q tted in the lower right part of X. 3 > X(3,,0); 4 References: [HW8], [HW9, p. 8{88] See Also: Q, W, xi? p 3 X;3 p 3 0 X;3 0 30p X3;3. RungeKutta[xi] { for the W-transformation xi(k ) 3

23 A NUMERICAL LINEAR ALGEBRA PACKAGE 9 k { an integer xi computes k for use with the W-transformation. > xi(3); p 3 0 References: [HW8], [HW9, p. 8{88] See Also: W, X A Numerical Linear Algebra package. Introduction to the NumLinAlg package function(args) NumLinAlg[function](args) To use a function from the package, either dene the function alone using the command with(numlinalg,function), or dene all the functions in the package by using the command with(numlinalg). Alternatively, invoke the function using the long form NumLinAlg[function]. This long form is necessary whenever there is a conict between a package function name and another function used in the same session. The functions available are: cholesky diagonalm gramschmidt eye qr unitv Most of the functions in this package are elementary, but convenient when working with linear algebra.. NumLinAlg[cholesky] { Cholesky factorization cholesky(m ) M { a matrix cholesky computes the Cholesky factorization of the matrix M. > with(numlinalg): > m := linalg[matrix](3,3,[[,,3],[,,4],[3,4,]]):

24 A NUMERICAL LINEAR ALGEBRA PACKAGE 0 > cholesky(m); ? 3 3 References: [GvL89].3 NumLinAlg[diagonalm] { diagonal matrix diagonalm(v ) v { a vector The function diagonalm generates a diagonal matrix with the diagonal equal to the vector, v. > with(numlinalg): > v := linalg[vector](4,[,,3,4]): > diagonalm(v); See Also: eye NumLinAlg[eye] { identity matrix eye(n) n { an integer eye generates the identity matrix of dimension n. > with(numlinalg): > eye(4); See Also: unitv

25 A NUMERICAL LINEAR ALGEBRA PACKAGE. NumLinAlg[gramschmidt] { Gram Schmidt orthogonalization gramschmidt(m ) gramschmidt(m,s) gramschmidt(m,s,...) M { a matrix s { a vector scalar product function gramschmidt perform Gram Schmidt orthogonalization on the matrix M. If no vector scalar product is supplied the standard dot product is used, < u; v >= u T v. An optionally supplied scalar product must have a calling sequence conform with that of linalg[dotprod]. The function diers from the linalg[gramschmidt] function by the use of an optional scalar product dierent from the standard vector dot product. Any additional arguments are passed on as the third argument to the scalar product function, s. > with(numlinalg): > m := linalg[matrix](3,3,[[,,3],[4,,],[,8,0]]): > m := gramschmidt(m); p p p p 9 p p p p m := ? p p p 3p? 33 9 > evalm(m&*linalg[transpose](m)); > mydotprod := proc(u,v) local i; sum('u[i]*v[i]*i','i'=..linalg[vectdim](u)); end: > m3 := gramschmidt(m,mydotprod); p p m3 := p 3 80? 80 > evalm(m3&*linalg[transpose](m3)); References: [GvL89] p p p 3 p 0 3 p 0 30p 3 0 0? 0 See Also: linalg[dotprod], linalg[gramschmidt] 3 3 3

26 A NUMERICAL LINEAR ALGEBRA PACKAGE. NumLinAlg[qr] { QR-factorization qr(m ) M { a matrix The function qr computes the QR-factorization for the matrix M and returns af list containing the two matrices Q and R. > with(numlinalg): > m := linalg[matrix](3,3,[[,,3],[4,,],[,8,0]]): > qr(m); ""?: : #?: ?: : :84984 ;?:84943?:30344?: References: [GvL89] "?8:403840?9:0398 ##?: : :04 0 0?: NumLinAlg[unitv] { unit vector unitv(n,k ) n,k { integers unitv generates the unit vector of length n with at element number k. > with(numlinalg): > unitv(4,); [ 0 0 0] See Also: eye

27 REFERENCES 3 References [Ben] [Benar] C. Bendtsen. On Implicit Runge-Kutta Methods with High Stage Order. Submitted to BIT, page?,? C. Bendtsen. On the Construction of Stiy Accurate and B-Stable Runge-Kutta Methods. BIT, To Appear. [But4] J. C. Butcher. Implicit Runge-Kutta Processes. Math. Comput., 8:0{4, 94. [But8] [GvL89] [Hai8] J. C. Butcher. The Numerical Analysis of Ordinary Dierential Equations. John Wiley & Sons, 98. G. H. Golub and C. G. van Loan. Matrix Computations. Johns Hopkins University Press, second edition, 989. E. Hairer. A- and B-Stability for Runge-Kutta Methods { Characterizations and Equivalence. Numer. Math., 48:383{389, 98. [HNW93] E. Hairer, S. P. Nrsett, and G. Wanner. Solving Ordinary Dierential Equations I. Nonsti Problems. Springer-Verlag, second edition, 993. [HW8] [HW9] E. Hairer and G. Wanner. Algebraically Stable and Implementable Runge-Kutta Methods of High Order. SIAM J. Numer. Anal., 8:098{08, Dec 98. E. Hairer and G. Wanner. Solving Ordinary Dierential Equations II. Sti and Dierential-Algebraic Problems. Springer-Verlag, 99.

28 Index j, 3 k, 3, 8 alpha, 3 ButcherTree, 3 alpha, 3 equal, 4 gamma, 4 generate, insert, listtdiff, occurences, order, tdiff, C, 8 cholesky, 9 conditions, 8 diagonalm, 0 dierentiate list of trees, tree, dlaguerre, 9 dlegendre, 9 equal, 4 error, 0 error constants, 0 eye, 0 factorization cholesky, 9 QR, gamma, 4 Gauss, 0 generate, gramschmidt, insert, installing, Laguerre, Legendre, listtdiff, Lobatto, matrix diagonal, 0 identity, 0 NumLinAlg, 9 cholesky, 9 diagonalm, 0 eye, 0 gramschmidt, qr, unitv, obtaining, occurences, order,, order conditions, 9 orthogonalization, package ButcherTree, 3 NumLinAlg, 9 RungeKutta, Phi, 3 polynomial Gauss, Laguerre, Legendre, Lobatto, Radau, Psik, 3 Q, 4 qr, quadrature, 4 Radau left, Radau right, RungeKutta, C, 8 conditions, 8 dlaguerre, 9 dlegendre, 9 error, 0 4

29 INDEX Gauss, 0 Laguerre, Legendre, Lobatto, order, Phi, 3 Psik, 3 Q, 4 quadrature, 4 Radau left, Radau right, stabfnk, stype, W, X, 8 xi, 8 simplifying condition, 8 stabfnk, stability function, properties, stype, tdiff, trees, 3 trees, all, unitv, W, W-transformation, X, 8 xi, 8