an object oriented MATLAB toolbox for solving di erential equations on manifolds

an object oriented MATLAB toolbox for solving dierential equations on manifolds
an object oriented MATLAB toolbox for solving
dierential equations on manifolds
Kenth Eng
Department of Informatics, University of Bergen
N-5020 Bergen, Norway
Arne Marthinseny
Department of Mathematical Sciences, NTNU
N-7034 Trondheim, Norway
Hans Z. Munthe-Kaasz
Department of Informatics, University of Bergen
N-5020 Bergen, Norway
ISSN 0333-3590
February 1999
Department of Informatics, University of Bergen, Norway
We describe an object oriented MATLAB toolbox for solving dierential equations on
manifolds. The software reects recent development within the area of geometric integration.
Through the use of elements from dierential geometry, in particular Lie groups and homogeneous spaces, coordinate free formulations of numerical integrators are developed. The strict
mathematical denitions and results are well suited for implementation in an object oriented
language, and, due to its simplicity, the authors have chosen MATLAB as the working environment. The basic ideas of DiMan are presented, along with particular examples that
illustrate the working of and the theory behind the software package.
AMS Subject Classication: 65L06, 34A50
Key Words: geometric integration, numerical integration of ordinary dierential equations on
manifolds, numerical analysis, Lie groups, Lie algebras, homogeneous spaces, object oriented programming, MATLAB, free Lie algebras
Email: [email protected], WWW:
y Email: [email protected], WWW:
z Email: [email protected], WWW:
1 Introduction
2 Ordinary dierential equations on manifolds
3 Object orientation
2.1 Intuitive concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Denitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1 Object orientation and mathematics . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Object orientation in MATLAB and DiMan . . . . . . . . . . . . . . . . . . . . .
4 Objects in DiMan
The domain object . . .
The eld object . . . . .
The time stepper object
The ow object . . . . .
5 The structure of DiMan
A How to solve ODEs in DiMan
B An example using the free Lie algebra
C The numerical time steppers in DiMan
5.1 Functor classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5.2 Free Lie algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
A.1 How to get started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
A.2 How to solve dierential equations in DiMan { A 5-step procedure . . . . . . . . 14
A.3 A detailed example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1 Introduction
DiMan is an object oriented MATLAB [20] toolbox designed to solve dierential equations evolv-
ing on manifolds. The current version of the toolbox addresses primarily the solution of ordinary
dierential equations. The solution techniques implemented fall into the category of geometric
integrators { a very active area of research during the last few years. The essence of geometric
integration is to construct numerical methods that respect underlying constraints, for instance
the conguration space of a mechanical problem, and to render correctly geometric structures and
invariants important to the underlying continuous problem.
The main motivations behind the DiMan project are:
To create a uniform environment where new geometric integration methods can be developed
and compared.
To provide researchers outside the eld of geometric integration with a tool where they can
become familiar with these methods and apply them to new problems.
To serve as a tool for investigating the role of abstractions and coordinate free formulations in numerical software. DiMan is based on high level abstractions aimed at modeling
continuous mathematical structures, in a manner that is, to a large extent, independent of
particular representations. This is a novel approach to numerical computing which cannot
be investigated on a purely theoretical level. The development of practical software is an
essential part of this work.
DiMan is developed by support through the SYNODE project and the project Coordinate Free
Methods in Numerics, both projects partly sponsored by the Norwegian research council NFR.
Information about the SYNODE project, papers and other links are found at
DiMan can be down-loaded from the DiMan home-page at URL:
2 Ordinary dierential equations on manifolds
DiMan is based on recent developments within the area of generalized ordinary dierential equa-
tion solvers (Lie group integrators). The framework of these solvers is based on concepts from
dierential geometry. There exist a large number of excellent texts that cover introductory dierential geometry; among them are [1, 2, 18, 32, 33]. We will in this section briey review some of
this material, rst in an intuitive informal manner, then in a more precise language, and nally
we will illustrate the theory by some examples.
2.1 Intuitive concepts
The basic objects involved in the current Lie group integrators in DiMan are:
The domain where the equation evolves is a manifold, M, which should be thought of as a
linear or non-linear space looking locally like Rd. Globally it might be very dierent (e.g. a
sphere looks locally but not globally like R2).
We assume the existence of a set of operators G generating smooth motions on M. The
operators in G can be composed and inverted. G is called a Lie group, and the set of
motions is called a group action. The group action is used to advance the numerical solution
on M. The action should be `easy' to compute, should be able to generate movements in
the direction the dierential equation evolves, and should somehow capture some important
underlying feature of the dierential equations. If the action e.g. preserves the angular
momentum of a mechanical system, then also the numerical methods based on this action
will preserve this property. One might compare an action in the integration of dierential
equations with a preconditioner in an iterative solution of a linear equation system. Both the
action and the preconditioner should be easy to compute and they should somehow capture
some essential features of the system one wants to solve.
The Lie group G is associated with a linear space g, the Lie algebra of the group. The
algebra serves two dierent roles:
{ It represents locally all the tangents to G at any point. By dierentiating the action, we
obtain also a representation of tangents to M at any point. This gives us a canonical
representation of any dierential equation on M.
{ It can also be used as a at space to represent a local region on M where the dierential
equation evolves. Several of the new algorithms are based on (locally) `pulling' the
equation back from M to g, solving it on g, and pushing this local solution onto M to
advance the solution there.
In the pull back { push forward process described above, one can make many choices that
aect the numerical solution process, but not the canonical representation of the dierential
equation on M. Some choices are:
{ Numerical method on g. Runge{Kutta [23] methods and multi-step methods [9] might
be used.
{ A smooth local mapping from g to G is composed with the action of G on M to pull the
equation from M to g. A simple choice is the exponential mapping [23]. Other choices
are products of exponentials [29] and for quadratic groups Cayley transforms [15, 5, 19].
To obtain time-symmetric integrators one may use versions of these coordinates centered
at some (time symmetric) mid-point [8].
To sum up, this theory allow us to make a lot of choices with respect to representation of the
dierential equations and numerical solution techniques. A major goal of DiMan is to provide
a toolbox where various domains can be easily created and where one can juggle around with all
possible combinations of numerical solution techniques.
2.2 Denitions
We will dene the concepts above more precisely. A manifold is a topological space M equipped
with continuous local coordinate charts i : Ui M ! Rd such that all the overlap charts
ij : Rd ! Rd are dieomorphisms. The overlap charts (transition functions) ij are dened as
j ,i 1j (U \U ) , where ,i 1j (U \U ) means the restriction of ,i 1 to the set i (Ui \ Uj ). If p
is a point Sin M, we denote by TMjp the tangent space of M at p. The tangent bundle of M
is TM = p2M TMjp . A vector eld, X, on a manifold is a section of its tangent bundle, i.e.
to each point p 2 M it associates a vector X(p) 2 TMjp . In DiMan we use the term domain
interchangeably with the term dierentiable manifold.
A Lie group is a smooth manifold equipped with a group structure such that group multiplication
and group element inversion are smooth maps. Every group has an identity element, which we
will denote by e. An example of a well known Lie group is Euclidean space, Rn, equipped with
the group operation + (vector addition). The inverse element of u 2 Rn is ,u and the identity
element is e = 0. In this case the group operation is both associative and commutative, but in
general it is not commutative.
A Lie algebra is a vector space, g, equipped with a bilinear, skew-symmetric form, [; ] : g g ! g,
satisfying the Jacobi identity,
[u; [v; w]]+ [w; [u; v]]+ [v; [w; u]] = 0;
u; v; w 2 g:
We call [; ] the Lie bracket on g. When the vector space g is Rnn, a Lie algebra is formed by
taking the usual matrix commutator as the Lie bracket. The Lie algebra of a Lie group, G, can
be dened as the tangent space at the identity, g = TGje, equipped with a Lie bracket
@ 2 [u; v] = @[email protected]
t=s=0 g(t)h(s)g,1 (t);
where g(t); h(s) 2 G are two curves such that g(0) = h(0) = e, g0 (0) = u, and h0(0) = v. The
general linear group, denoted by GL(n), is the Lie group that consists of non-singular n n
matrices. The Lie algebra of this group, gl(n), is the vector space Rnn equipped with the matrix
commutator as Lie bracket.
A (left) action of a Lie group G on a manifold M is a smooth mapping : G M ! M such
that (e; m) = m for all m 2 M and (g; (h; m)) = (gh; m) for all g; h 2 G and m 2 M. Any
2 g specify a tangent m 2 TMjm at any point m 2 M via
d (g(t); m);
m = dt
where g(t) 2 G is a curve such that g(0) = e, g0 (0) = . One may write g(t) = exp(t), where
exp : g ! G is the exponential map [23], or g(t) = (t) for any smooth function : g ! G
such that (0) = e, 0(0) = I. This gives an identication 7! m 2 TMjm , which depends on
the choice of action , but not on the particular choice of . In DiMan it is assumed that the
dierential equation to be solved is presented in the following canonical form
y0 = F (t; y) = (t; y)y ;
y(0) 2 M;
for some function : R M ! g (see [28, 23, 5]). If (t; y) = (t), the equation is of Lie type or
linear type. Otherwise it is of general type. Equations of Lie type can be handled more eciently
than general type equations.
If the domain M and the algebra g are provided in DiMan, or if they can be constructed using
the functors in Section 5.1, the user only needs to supply the function . Otherwise DiMan can
be extended by adding new domains.
A large class of numerical algorithms are based on the assumption that the maps ((); m) can
be computed eciently. The RKMK methods in [23] are based on () = exp(). More general
's are discussed in [5].
The following commutative diagram, which is thoroughly discussed in [5], illustrates the relations
used as a framework these algorithms:
0 T
Tg ,T
! TM
du ,1 y0
?F (y)=
Here y0 2 M is the initial point, u 2 g , y0 (u) = (u; y0) and du,1 : g ! g is the right
trivialized tangent of . If = exp, then d,u 1 = d expu ,1 can be expressed in terms of Lie
brackets. For more general one needs an ecient algorithm for computing du,1 , see [5, 29] for
dierent choices. This yields the following algorithm:
Algorithm 2.1 Given a dierential equation in the form (1), this algorithm produces a q'th order
approximation to the solution, using step size h:
Find an approximation u1 u(t0 + h) by integrating the following dierential equation on g
u0 = d,u 1 t0 + t; ((u); y0) ;
u(t0) = 0;
from t0 to t0 + h using one step with a qth order Runge-Kutta method.
Advance the solution on M to y1 = ((u1); y0) y(t0 + h).
Repeat with new initial values y0 := y1 , t0 := t0 + h.
2.3 Examples
We will here just provide the most basic examples of dierential equations written in the form (1).
First, if M = Rn and (g; m) = g + m, then m = and (1) acquires the well known form
y0 (t) = (t; y);
2 Rn:
Another example that is frequently used to present Lie group methods is the matrix case, G GL(n), a matrix group, M = G and (g; m) = gm then m = m (matrix products), hence (1)
y0 (t) = (t; m)y(t):
In Appendix A.3 we give an example where G = SO(n), the set of orthogonal matrices, M = S n ,
the n-sphere (represented as n vectors with norm 1), and (g; m) = gm (matrix{vector product).
This yields the form
y0 (t) = (t; m)y(t);
where is a skew{symmetric matrix.
In [23] it is shown how isospectral ows, exponential integrators for sti systems, Riccati equations
and the setting of rigid frames can be phrased in this form. Isospectral problems is discussed in
detail in [35]. Lie{Poisson equations are discussed in [6] and the use of Toeplitz actions on heat
equations in [26]. In forthcoming papers, we will see how many other systems can be viewed in
this context.
3 Object orientation
As of today there is really no tradition in the numerical analysis community for using object oriented languages in the development of numerical software. While object oriented languages have
become ubiquitous in the computer science community, the classical computational mathematicians have been reluctant in adopting modern computer languages. We do not want to speculate
about the reason for this, but merely observe that most industry based numerical software is coded
The terms 'class' and 'object' are very likely to be among the rst words that you encounter in
reading a book about object orientation. For a computer scientist these terms are as natural as the
Butcher tableau is for a numerical analysist. In the next section we will give you a very rudimentary
explanation of these terms along with ideas describing why modern computer languages are so
well suited in capturing abstractions so omnipresent in pure mathematics. A somewhat random
reference on object orientation found in the authors' library is [16].
3.1 Object orientation and mathematics
A class is simply a collection of 'elements' with equal properties. In mathematical terms one would
say that a class is a set. The 'elements' of a class are usually called objects, and the common
properties of the objects specify the class. Mathematically, the properties of a class can be stated
as relations that the objects must satisfy in order to be a member of the class.
A very important and interesting aspect of object orientation is that it allows for information
hiding. An object typically consists of a public and a private part. The public part can be
accessed from the outside of the class, whereas the private part cannot. This enables us to hide
implementation specic issues for the particular class in the private part, and can easily make
changes to it, without altering the public interface of the class.
This then, naturally brings up the issue of specifying a class. A class specication can be divided
up into a 'what' part and a 'how' part. 'what' describes the interaction of the class with the
surroundings; what is the public interface of the class, what is the class supposed to do? 'How'
the class is implemented is an issue related to the private section of the class. The surroundings
do not need to know about implementational issues as long as the interaction of the class is as
specied by the public interface.
This distinction between 'what's and 'how's of objects (elements) is ubiquitous in pure mathematics. This is also the reason why abstract mathematical concepts are so well suited for implementation in object oriented programming languages, see [12, 25]. Coordinate free constructions
in mathematics, e.g. tensors, try to capture what the operation of an object is regardless of the
coordinate system. The tensor class is then specied by properties independent of the coordinate
systems, and the dierent choices of coordinates used in an actual implementation on a computer
is deferred to the private part of the class. Hence, a specication of a class emphasizes and extracts
the important features of a class, and this conforms very well with algebraic techniques so rampant
in pure mathematics.
Thinking in these terms give rise to the rather contradictory term 'coordinate free numerics'
[24, 25]. What is a coordinate free algorithm? The whole idea is to device algorithms specied
by algebraic operations not depending on the particular representation of the object. All the
methods in DiMan are dened on groups and they are all very good examples of coordinate free
algorithms. The group elements can have very dierent representations, but the algorithms are
all expressed through algebraically dened operations such as group multiplication and Lie-group
3.2 Object orientation in MATLAB and DiMan
The intention of this section is to give you an overview of the workings of the object oriented
environment in MATLAB and how this is used in DiMan. This account is by no means complete,
and we refer the interested reader to the MATLAB manual [20] and the DiMan manual [7] for
more information.
In MATLAB a class is dened by creating a directory @myclass, where myclass is the name of the
class. The prex @ is needed in order to tell MATLAB that this is a class directory. All the public
class functions are put in this directory, while the private class functions are put in a directory
@myclass/private. Where the le is located within the class directory tree distinguishes the
m-le from being a public or private function.
Every class must have its own unique constructor. The constructor is implemented in an m-le
called myclass.m, the same name as the class itself. In MATLAB a class object is represented as
a MATLAB struct, where a struct is the same as a struct in C or a record in PASCAL. This struct
can have an arbitrary number of elds. To turn a MATLAB struct into an object of @myclass
the function class must be called within the constructor m-le:
obj.field1 = n1;
obj.field2 = n2;
obj = class(obj,'myclass');
The user can not access the structure elds of the object directly in MATLAB. An attempt doing
this will result in an error. Hence, the elds of the object struct can be viewed as part of the
data representation of the object, and is private to the class. For the user to interact with the
information contained in the elds of the object struct, the class must have implemented public
m-les particularly doing this.
Public functions making up the interface of a class are naturally divided up into three categories:
constructors, observers, and generators. In MATLAB there is only one constructor, but in
other object oriented programming languages, like C++, it is possible to have more than one
constructor. The observers of a class are the public functions that extract information from the
class objects without altering the object itself. The generators of a class are those public functions
that change properties of the class objects, or create new objects of the same or other classes.
In DiMan you will typically nd this partition of the public functions when reading a class
In DiMan the object orientation is applied in several dierent ways. The domain points (elements
of a manifold) are treated as members of a class. Depending on the specic properties of the
domain, there are several types of domains implemented in DiMan. Each of the dierent types
of domains are collections of algebraically similar domain classes. The integration methods used
to solve the ODEs are called time steppers, and the dierent time stepper methods are treated as
dierent classes. Flows and vector elds are also implemented as two classes.
In DiMan 1.5 there are three categories of domains implemented: Homogeneous spaces, Lie
algebras, and Lie groups. Each domain category is further divided up into domain classes of
that particular type. Hence, each of the classes within a particular domain type have similar
characteristics, but there are dierences that partition them into individual classes. These similar
characteristics of the classes of a specic domain type are what denes the domain category.
Trying to dene and specify the domain category is done through the introduction of a virtual
superclass in each domain category. The virtual superclass denes and takes care of operations
that are common to all the classes in the domain category. This is obtained through the concept
of inheritance in object orientation. The virtual superclass is the parent class for all the other
classes in the domain category, and all the child classes inherit the parents' functions. This means
that one can apply the public functions of the virtual superclass to an object of a child class. If
the child class needs specically implemented versions of any of the public functions of the parent
class, this is achieved through overloading. Supply a public function to the child class with
a matching name, and MATLAB will use this version of the public function instead of the one
supplied by the parent class.
4 Objects in DiMan
In DiMan you will encounter 4 dierent types of objects: domain, eld, time stepper, and
ow objects. Each object is dened in such a way as to capture the mathematical essentials of
a manifold, the eld dening the dierential equation, the numerical time stepper algorithm, and
the ow operator, respectively. We will discuss each one of these objects in the following.
4.1 The domain object
Every domain object (e.g. objects of the type Lie algebra, Lie group, or homogeneous space) is
built up as a MATLAB struct with two elds: shape and data. Generically, every domain object
is represented as:
domainobject =
A domain object species a specic point in a specic manifold. It is often useful to create a single
class for representing a family of manifolds, e.g. all Lie algebras gl(n) are represented by the same
class @lagl. The shape species the particular manifold in the family (in this case n), while the
data part represents a particular point in this manifold (in this case n by n matrices. The shape
is in computer science called a dynamic subtyping of the class. If an object has an empty data
eld, it is taken to just represent the space (the subtype).
A second example is the dynamic subtyping of the homogeneous space @hmlie. This is the
homogeneous space obtained by any Lie group acting on itself by left multiplication. Considering
all the dierent Lie groups and Lie algebras, the shape is chosen to be an object of the particular
group or algebra. Since all Lie groups and Lie algebras themselves are dynamically subtyped, the
shape of @hmlie must be a Lie group or Lie algebra object with a preset shape. This is because
we need to know a 'size' measure on the domain objects that are acting on themselves.
The user cannot directly access the contents of the shape and data elds of a domain object, since
the elds belong to the private part of the domain class. In order to do this the user must use the
public functions getshape and getdata to return the contents of the elds, and setshape and
setdata to update the values of the private elds.
4.2 The eld object
A eld is dened over a manifold. Some examples of elds are vector elds, tensor elds, and
divergence free vector elds. A vector eld is a mathematical construction that to every element
of the manifold assigns a vector. Likewise; for a tensor eld a tensor is assigned to each element
of the manifold. From this it is natural to conclude, since the output from dierent elds is not
similar, that a generic eld object only contains information about the manifold over which the
eld is dened:
fieldobject =
To dene an ordinary dierential equation we only need the notion of a vector eld. Tensor elds
are mainly used in partial dierential equations. DiMan 1.5 is only devoted to the solution of
ODEs evolving on manifolds. Hence, the only eld class implemented is @vectorfield. The
generic representation of a vector eld object is:
vectorfieldobject =
Compared to the above eld object two more struct elds have been added in the vector eld object.
In DiMan 1.5 every vector eld over a manifold is represented by a function : R M ! g
as in (1). This function is called fm2g, (function from M to g). If the function fm2g is only
depending on time, the ODE is said to be linear or of Lie type, and general if the function fm2g
depends on both time and conguration. The eqntype provides this information.
4.3 The time stepper object
This is where all the numerics is hidden. A time stepper is the numerical algorithm used in
advancing the solution of the dierential equation one step along the integral curve of the ow.
There are dierent approaches in constructing these time steppers and a list of the available time
steppers in DiMan 1.5 is found in Appendix C.
4.4 The ow object
Mathematically, the ow is an operator dened by the vector eld. Given the ordinary dierential
y0 = F (y);
y(0) = p 2 M;
the ow operator of this dierential equation is the operator F;t : M ! M satisfying
dt F;t (p) = F(F;t(p)):
The classical solution of a dierential equation is an integral curve of the vector eld generating
the ow operator. This integral curve is found by evaluating the ow operator in the initial point
on the manifold.
The generic representation of a ow object is:
flowobject =
The ow object must of course know the vector eld dening it. Next, it needs to know a time
stepper object. The choice of time stepper species the numerical algorithm to be used in the
solution of the dierential equation. This is really all the information that the ow object needs to
know. However, for convenience, constants used in variable time stepping and nonlinear equation
solving is collected in the ow object in the third eld defaults. Unless the user changes any of
these constants with the setdefaults function, the default values set by the ow constructor will
be used.
5 The structure of DiMan
The philosophy used in designing DiMan is to respect the underlying continuous mathematics
to an as large extent as possible. Finding the continuous ow of a eld is equivalent of nding the
numerical solution of a dierential equation. The continuous ingredients of a dierential equation
are: domain, eld, and ow. The relationships among them are that the eld is dened over
the domain, and the ow is dened by the eld.
This general structure in the continuous case is reected in DiMan in the way the directories
are organized. In the DiMan root directory you will nd three directories each corresponding
to domain, eld, and ow, see Figure 1. There is also a fourth directory; auxiliary, which collects
things related to the non-mathematical workings of DiMan. The structure is very modular and
therefore it is very easy to add new classes.
The domain directory contains the domain categories, very important building blocks of DiMan.
Creating a domain category is done by creating a subdirectory in the domain directory. In DiMan
1.5 there are 3 domain categories implemented: homogeneous spaces, Lie algebras, and Lie groups.
The classes of a domain category are put in this subdirectory along with a virtual superclass
specifying the type of domain.
The field directory contains eld classes dened over domain classes. Think of this directory as
the eld category. In DiMan 1.5 there is only one eld class implemented: @vectorfield. This
is the only eld class needed in the solution of ordinary dierential equations. In order to solve
some partial dierential equations it is interesting to be able to dene tensor elds over manifolds.
When implemented the tensor eld class will be placed in the field directory in DiMan.
The flow directory collects classes pertinent to the continuous ow. The numerical methods are
treated as time steppers, and they are all placed in the subdirectory timesteppers found in the
flow directory. The ow class is a virtual superclass with no subclasses since all the numerics is
placed within the time steppers. The reason for this distinction between ow and time stepper
is an attempt to isolate features common to all the numerical methods (the time steppers), e.g.
variable time stepping, and place these features in the ow class.
The auxiliary directory includes 4 subdirectories that contain the DiMan documentation, command line examples, demos, and utility functions. As the name of this directory reects, the
content is not vital to the workings of DiMan.
Figure 1: Schematic picture of the structure in DiMan.
5.1 Functor classes
In DiMan the dierent domain types are viewed as categories. A function on a category is called
a functor. Examples of internal functors are the direct product, semi-direct product, and tangent
map. The direct product functor will take n domain classes as input, and create a new domain
object; the direct product of the domains. The semi-direct functor works in an analogous way. The
tangent functor takes a domain manifold and turns it into the tangent bundle of that manifold.
The tangent bundle is also a manifold; hence, it is a domain.
In DiMan we call classes that automatically generate new domains from other ones functor
classes. The choice of name should be clear from the above discussion. In DiMan 1.5 you will
nd one of the above functorial constructors implemented; the direct product of domains. The
functor classes in question are @ladirprod and @lgdirprod. A future release of DiMan will
include the semi-direct product functor and the tangent functor.
5.2 Free Lie algebras
Of all the Lie algebra classes in DiMan, the class @lafree (free Lie algebra) plays a special role. It
can be viewed as a `symbolic computation engine', capable of simplifying expressions involving Lie
brackets, by systematic use of skew-symmetry and the Jacobi identity. When a formal expression
is simplied, it may subsequently be evaluated in a concrete Lie algebra. Thus, this class is very
useful for developing and simplifying algorithms in Lie algebras. Furthermore, in Appendix B we
show that @lafree is very useful for another type of optimization, related to the fact that calls
to overloaded operators are handled very ineciently in MATLAB 5. More details on numerical
computations in free Lie algebras, complexity results, and applications to Lie group integrators
are found in [27].
Given an arbitrary index set I, either nite or countably innite. The following denition is
equivalent to the one in [32].
Denition 5.1 A Lie algebra g is free over the set I if:
i) For every i 2 I there corresponds an element Xi 2 g.
ii) For any Lie algebra h and any function i 7! Yi 2 h, there exists a unique Lie algebra
homomorphism : g ! h satisfying (Xi ) = Yi for all i 2 I .
In category theory, g is said to be a universal object, i.e. it contains a structure that is common to
all Lie algebras, but nothing more. Furthermore, computations in g can be applied in any concrete
Lie algebra h via the homomorphism .
Computationally it is useful to represent a free Lie algebra in terms of a basis. The most used
bases are the (classical) Hall basis and the Lyndon basis. They can both be regarded as generalized
Hall type bases [31]. The DiMan @lafree class is implemented using a Hall basis.
Example 5.2 If I = f1; 2; 3g, the (classical) Hall basis consisting of elements with length 4 is
given as:
[X1 ; X2 ] [X1 ; X3 ] [X2 ; X3 ]
[X1 ; [X1 ; X2 ]] [X1; [X1 ; X3 ]] [X2 ; [X1; X2 ]] [X2 ; [X1 ; X3 ]]
[X2 ; [X2 ; X3 ]] [X3; [X1 ; X2 ]] [X3 ; [X1; X3 ]] [X3 ; [X2 ; X3 ]]
[X1 ; [X1; [X1 ; X2 ]]]
[X2 ; [X1; [X1 ; X3 ]]]
[X2 ; [X2; [X2 ; X3 ]]]
[X3 ; [X2; [X1 ; X2 ]]]
[X3 ; [X3; [X1 ; X2 ]]]
[[X1; X2 ]; [X1 ; X3 ]]
[X1; [X1 ; [X1 ; X3 ]]]
[X2; [X2 ; [X1 ; X2 ]]]
[X3; [X1 ; [X1 ; X2 ]]]
[X3; [X2 ; [X1 ; X3 ]]]
[X3; [X3 ; [X1 ; X3 ]]]
[[X1; X2 ]; [X2; X3 ]]
[X2 ; [X1 ; [X1 ; X2 ]]]
[X2 ; [X2 ; [X1 ; X3 ]]]
[X3 ; [X1 ; [X1 ; X3 ]]]
[X3 ; [X2 ; [X2 ; X3 ]]]
[X3 ; [X3 ; [X2 ; X3 ]]]
[[X1 ; X3 ]; [X2; X3 ]]
Free Lie algebras are innite dimensional algebras, which for many numerical applications need
to be truncated according to some measure of the size of the terms. If is some small parameter
and each generator Xi has an order Xi = O(w ), then [Xi ; Xj ] = O(w +w ). Now we might
want to neglect all terms of order q or higher. Intuitively we form all brackets in a Hall basis and
remove all brackets of suciently high order. Mathematically this is a quotient construction on a
graded free Lie algebra. Let X1 ; : : : ; Xs be generators for a free Lie algebra g and let w1; : : : ; ws
be positive integers. We dene a grading of the Hall basis of g by
grade(Xi ) = wi
grade([hi; hj ]) = grade(hi ) + grade(hj ) for all hi ; hj 2 H,
where H denotes the Hall basis. Now let gq = spanf h 2 H j grade(h) q g. Clearly gq is an ideal
of g, and g=gq is the nite dimensional Lie algebra obtained by dropping all high order terms.
This construction can be dened independently on a particular choice of basis for g. In DiMan
we construct the object g=gq by issuing the command
objname = lafree(f[s; q];[w1; : : : ; ws]g):
In [27] we establish Witt-type formulas for computing the dimension of g=gq . A tutorial example
on using @lafree is given in Appendix B, where we apply this class in the construction of RKGL
type Lie group integrators for solving equations of Lie type.
A How to solve ODEs in DiMan
This appendix will teach you the basics of solving dierential equations in DiMan. The rst
section shows you how to initialize DiMan and get the toolbox up and running. The next section
describes a 5-step procedure to be followed when solving dierential equation in DiMan. Finally,
the last section takes you through a very detailed example showing you the 5-step procedure in
A.1 How to get started
The very rst thing to do is to initialize the DiMan toolbox. Make sure that you are located in
the DiMan directory, or that this directory is included in the MATLAB path. You can easily
include the following command in your startup.m le, or issue it at the MATLAB prompt:
>> addpath('/local/path/on/your/machine/DiffMan');
Initializing DiMan is done simply by typing the command:
>> dminit
The result of this command is that all necessary paths are set and DiMan is ready for use.
The DiMan facility dmtutorial will launch a window where you can choose to run dierent
kinds of tutorials. One of these tutorials will guide you through 'How to solve ODEs in DiMan '.
This is the 5-step procedure presented in the next section. The other tutorials will guide you
through other important aspects of the DiMan toolbox essential to the user.
dmhelp is a substantially improved version of the helpwin facility in MATLAB. dmhelp will launch
a DiMan help window where you can get help on every function and class in DiMan, and also
every other function in MATLAB. Hence, when working with DiMan you are urged to use dmhelp
instead of the MATLAB functions helpwin and help.
The MATLAB demo utility will include DiMan among its toolboxes. Running the DiMan
demos is another convenient way of launching the DiMan tutorials, and running all the DiMan
command line examples.
A.2 How to solve dierential equations in DiMan { A 5-step procedure
Once DiMan is initialized you can start solving dierential equations.
In DiMan we are exclusively working with objects, and these objects are members of dierent
classes. To create an object of a particular class, invoke the constructor of that class. The
constructor always has the same name as the class.
The 5-step procedure for solving dierential equations in DiMan is the following:
1) Construct an initial domain object y in a homogeneous space. In order to solve an
initial value problem, DiMan needs to know an initial condition. The initial domain object
serves this purpose.
2) Construct a vector eld object vf over the domain object y. DiMan nds numerically the integral curve of this vector eld through the initial domain object. A vector eld
object consists of three parts: domain, eqntype, and fm2g. Set these properties of the vector
eld object by the functions setdomain, seteqntype, and setfm2g. You retrieve them with
the corresponding get functions.
3) Construct a time stepper object ts. The time stepper class determines the numerical
method used to advance the numerical solution along the integral line. A time stepper
object consists of two parts: coordinate and method. Set these properties of the time
stepper object by the functions setcoordinate and setmethod. You retrieve them with the
corresponding get functions.
4) Construct a ow object f. The ow object is dened by the vector eld object. Since we
are doing numerical computations the ow object also needs to know how to step forward,
hence the ow object f also needs to know the time stepper object. To set the two properties
of the ow object use the functions setvectorfield and settimestepper. You retrieve
them with the corresponding get functions.
5) Solve the ODE. Solving the ODE dened by the ow object in DiMan is simply done by
evaluating the ow object at the initial domain object, start time, end time, and step size:
>> output = (y,tstart,tfinal,h);
Variable step size is indicated by using negative values for h. The initial step then be of length jhj.
The struct output consists of three elds: output.y is a vector of domain objects, output.t is a
vector of time points, and output.rej is a vector indicating rejection of a time step in variable
time stepping.
Detailed mathematical information and denitions of ows and vector elds are found in Section 2.
The 5-step procedure will be detailed out on an example in the next section.
A.3 A detailed example
Consider solving the following dierential equation on the sphere S 2 :
t ,0:4 cos(t)
dy = 4 ,0t
0:1t 5 y(t);
y(0) = 405 ;
0:4 cos(t) ,0:1t
where y 2 R3 is a vector of unit length, and the matrix on the right hand side is a map from R
into so(3).
The homogeneous manifold in question is @hmnsphere which consists of the sphere manifold S 2 ,
the Lie algebra of O(3) which is so(3), and the action : (v; m) ! exp(v) m of so(3) on S 2 . The
elements of the manifold S 2 are vectors of unit length.
Step #1: Construct an initial domain object y in @hmnsphere
The initial domain object is created by calling the constructor of @hmnsphere. This constructor
can take an integer or an laso object as an argument and thereby specifying the shape of the
manifold object.
>> y = hmnsphere(3)
y =
Class: hmnsphere
Shape-object information:
Class: laso
Shape: 3
The shape of an object in @hmnsphere consists of an object in the Lie algebra laso. The integer
supplied to the constructor sets the shape of this Lie algebra object that comprises the shape of
the @hmnsphere object. If an argument to the constructor is not supplied, the shape can be set
later by use of the setshape function.
As mentioned in the beginning of this Section, the data representation of an object in @hmnsphere
is a vector of unit length. If the initial condition for the ODE on the sphere is the North pole, the
data of the initial object must be set equal to the North pole vector.
>> setdata(y,[0 0 1]');
>> y
y =
Class: hmnsphere
Shape-object information:
Class: laso
Shape: 3
The rst step is now completed.
Step #2: Construct a vector eld object vf over the domain object y
A vector eld is dened over a domain. The constructor of @vectorfield is called with the domain
object as input:
>> vf = vectorfield(y)
vf =
Class: vectorfield
Domain: hmnsphere
Shape-object information:
Class: laso
Shape: 3
Eqn type:
Already, vf contains a lot of information. Since the domain object was supplied as an argument for the vector eld constructor, the domain information is already set. The shape of the
@hmnsphere object is an laso object, and the information about this Lie algebra object is displayed as Shape-object information. Further, the equation type of the generator map for the
vector eld is set to be 'General'. This is the default value. However, equation (2) is of Lie type,
so the type should be changed to 'Linear' in order to speed up the calculations.
>> seteqntype(vf,'Linear');
The generator map of equation (2) is the matrix on the right hand side of the equation. The m-le
vfex5.m contains the necessary MATLAB code to implement the generator map.
>> setfm2g(vf,'vfex5');
How does this m-le vfex5.m look like? To view the le you can type type vfex5.m at the
MATLAB prompt, or use dmhelp and push the button View src. Any way the output is:
function [la] = vfex5(t,y)
% VFEX5 - Generator map from RxM to liealgebra. Linear type.
la = liealgebra(y);
dat = [0 t -0.4*cos(t); -t 0 .1*t; .4*cos(t) -.1*t 0];
All the generator map function les that you write on your own must have this generic structure:
The le must support two arguments; the rst is a scalar { time, and the second is a domain
object from the homogeneous space. Output must be a Lie algebra object. To nd the correct Lie
algebra of the domain object call liealgebra(y), which will return an object in the correct Lie
algebra with preset shape information. Edit the data dat, and call setdata(la,dat) in order to
set the data representation of the Lie algebra object.
Now the vector eld object vf displays as:
>> vf
vf =
Class: vectorfield
Domain: hmnsphere
Shape-object information:
Class: laso
Shape: 3
Map fm2g:
Eqn type:
Step #3: Construct a time stepper object ts
The time stepper class decides which numerical method to use for advancing along the integral
curve of the vector eld. Calling any of the time stepper constructors will return a time stepper
object with default coordinate and method. If the user prefers other coordinates or another
method, these can be changed through the functions setcoordinate and setmethod. To get an
overview of the dierent time steppers type dmhelp timestepper in MATLAB. In our example
we want to use an RKMK method:
>> ts =
ts =
In case of @tsrkmk the default coordinate is exp and the default method is RK4. For a discussion
of the possible choices of coordinates, see [7]. For each time stepper class there is a whole lot of
methods to choose from. None of these methods can be used for all the dierent time stepper
classes and DiMan will issue an error message if a wrong selection is made.
In our example we are not satised with only the standard 4th-order RK4 method, we want the
more accurate answer supplied by the 6th-order Butcher method:
>> setmethod(ts,'butcher6')
>> ts
ts =
Class: tsrkmk
Coord.: exp
Method: butcher6
To get information about the dierent methods while running DiMan, type dmhelp setmethod.
Step #4: Construct a ow object f
The ow object is constructed from the vector eld object vf and the time stepper object ts
already created. Just calling the @flow constructor will create an object with a default time
stepper. The default time stepper preset in the ow object f is only a matter of convenience, and
must not be confused with the time stepper object created in Step #3.
>> f = flow
f =
Class: flow
Timestepper class: tsrkmk
In our example we have created another time stepper object ts that we want to use instead of the
default time stepper object supplied by the @flow constructor. To change the time stepper of the
ow object f to ts, call the function settimestepper:
>> settimestepper(f,ts)
A ow is dened as the ow of some vector eld. Hence, our ow object f must have information
about this vector eld.
>> setvectorfield(f,vf)
>> f
f =
Class: flow
Vector field information:
Equation type:
Map defining DE: vfex5
Timestepper class: tsrkmk
Now the ow object has the necessary information and we can go on to the next, and nal, step
in the 5-step solution procedure.
Step #5: Solve the ODE
Solving equation (2) with the RKMK method is done by evaluating the ow object with four
arguments: initial domain object, start time, end time, and step size.
>> curve
curve =
= f(y,0,5,0.05)
[1x61 hmnsphere]
[1x61 double
[1x61 double
The output curve is a MATLAB struct with the three elds: y, t, and rej. curve.y is a vector
of objects from the homogeneous space upon which the problem is modeled. curve.t is a vector
of scalars, the time points. curve.rej is a vector of integers indicating if a step was rejected or
not. In our example curve.rej is the zero vector, since we did not use variable time stepping.
Calling getdata(curve.y) will access the actual data representations of all the @hmnsphere objects. In this case this output will be a vector three times the length of the scalar vector curve.t.
To get the 3-vectors corresponding to each time point, the output from getdata(curve.y) must
be reshaped into a 3length(t) matrix where each column corresponds to a time point. To plot
the data we can do the following:
t = curve.t;
a = getdata(curve.y);
a = reshape(a,3,length(t));
In Figure 2 the solution of the problem is plotted.
This detailed example is found as Example 5 in the DiMan toolbox and runs by typing:
>> dmex5
What's next?: Solve the same problem with a dierent time stepper
To use another time stepper to solve equation (2) we must repeat steps #3 through #5. We must
create a new time stepper object, put this into the existing ow object, and evaluate the ow
again. To use the Crouch-Grossman method we do the following:
>> ts2 = tscg
Figure 2: Plot of the solution of (2).
ts2 =
Class: tscg
Coord.: exp
Method: CG3a
>> settimestepper(f,ts2)
>> f
f =
Class: flow
Vector field information:
Equation type:
Map defining DE: vfex5
Timestepper class: tscg
>> curve = f(y,0,5,0.05);
To plot the solution we just repeat the above plotting commands. The solution is the same, except
from the fact that we have used a third-order method. This solution is not as accurate as the
solution obtained by the 6th-order Butcher method used in the RKMK time stepper.
B An example using the free Lie algebra
The commands given below reect the basic operations of Denition 5.1.
: : : ,wp]});
Generate a free Lie algebra from p symbols with grades w1,w2, : : : ,wp. All terms of total
grade greater than q are set to 0.
>> fla = lafree({[p,q],[w1,w2,
>> Xi = basis(fla,i);
Return the 'th Hall basis element in fla. If 1 i p, return the i'th generator Xi .
>> X+Y; r*X; [X,Y];
Basic computations in the free Lie algebra.
: : : ,Yp);
If is an element of a free Lie algebra, and Y1,Y2, : : : ,Yp are the elements of any DiMan
Lie algebra, this will evaluate the expression E, using the data set Y1,Y2, : : : ,Yp in place
of the generating set. This corresponds to the homomorphism : g ! h in Denition 5.1.
One may also write Z = eval(E,Y); where Y(i) = Yi;.
>> Z = eval(E,Y1,Y2,
As an example of the use of this class we will consider the construction of Runge{Kutta{Gauss{
Legendre (RKGL) type integrators for equations of Lie type (or linear type). To make things
simple, consider a matrix equation
y0 (t) = f(t)y(t);
y(t0 ) = y0 ;
where y(t) is a curve on a matrix Lie group and f(t) is a curve in the Lie algebra. It is well
known [23] that the solution for suciently small t can be written as
y(t) = exp((t))y0 ;
where (t) satisfy
0(t) = dexp,(1t)(f(t));
(t0 ) = 0:
RKGL methods are s-stage implicit methods of order 2s. For equations of Lie type, where f = f(t),
the problem of solving implicit equations can be solved once and for all by a computation in a free
Lie algebra. We seek an expression for (t0 + h) in terms of the s quantities ki = hf(t0 + ci ). To
develop a general integration scheme, we may regard ki as being generators of a free Lie algebra,
and nd an expression for (t0 + h) by solving the implicit RK equations in the free Lie algebra.
If this is done in a straightforward manner, the number of commutators involved in the expression
for (t0 + h) turns out to be very large. In [27], we show that this can be overcome by changing
the basis for the free Lie algebra. We introduce a new set of generators X1 ; : : : ; Xs as
ki = Vi;j Xj ;
where Vi;j = (ci , 1=2)j ,1 is a Vandermonde matrix. After this change of variables, it can be
shown that Xi = O(hi ), thus X1 ; : : : ; Xs generate a graded free Lie algebra with the grading
wi = i.
In Figure 3 we show the computation of . A 6'th order method is obtained by
[sig; c; W; s] = rkgllmethod(6);
which yields (numerically) the result:
1 X3 , 1 [X1 ; X2] + 1 [X2 ; X3] + 1 [X1; [X1; X3 ]] , : : :
sig = X1 + 12
1 [X2; [X1; X2 ]] + 1 [X1; [X1; [X1; X2 ]]]
, 240
5,p15 1 5+p15720T
0 100 21 100 1
B p5 0 p155 CA
W = @ , 15
, 203
Figure 4 shows how these data are used in a simple timestepper. A major part of the computation
is the evaluation of the expression sig on the data X, s = eval(sig; X);. Once the expression for
sig is known, this line could have been written out explicitly, e.g. as
s = X(1) + X(3) (1=12) , [X(1); X(2)] (1=12) + :
% RKGLLMETHOD - Construct q'th order RKGL-Lie integrator
function [sig,c,W,s] = rkgllmethod(q)
% coeffs. for classical s-stage q'th order RKGL
A,b,c,s = rkglcoeff(q);
% change basis with Vandermonde matrix
V = vander(c-1/2); V = V(:,s:-1:1);
W = inv(V);
laf = lafree( [s,q],[1:s] );
for i = 1:s,
k(i) = zero(laf);
for j = 1:s, k(i) = k(i)+V(i,j)*basis(laf,j); end;
% solve implicit RK step in laf by fixpoint iteration
u = zeros(laf,s);
for ord = 1:q,
for i = 1:s, ktild(i) = dexpinv(u(i),k(i),q); end;
for i = 1:s, u(i) = A(i,:)*ktild; end;
sig = b*ktild;
Figure 3: Construction of q'th order RKGL-Lie integrator.
However, the eval function allows optimizations that are lost in an explicit expansion. When eval
is called, the expression is analyzed and the computation is optimized. So, if a given commutator
1 [X2 ; [X1; X2]], the eval
appears several places in the same expression, like 121 [X1; X2 ] + , 240
function will only compute [X1 ; X2] once. An even more signicant optimization is related to the
overhead of calling overloaded operators. If a bracket [X1 ; X2] is called in MATLAB, then the
system rst has to gure out in which Lie algebra Xi belongs, and then call the corresponding
commutator. In the current version of MATLAB, there is a large overhead associated with this
handling of overloaded operators. The eval function, on the other hand, is implemented such that
the job of guring out which algebra is involved is only done once. We have seen that for small
matrices this optimization trick yields codes running up to ten times faster!
C The numerical time steppers in DiMan
The development of DiMan is an ongoing project, and the numerical time steppers implemented
are subject to change in the future. Version 1.5 of DiMan includes the following time steppers:
tscg: the Crouch-Grossman methods [4, 30].
tsfer: the Fer expansion methods [10, 13, 34].
tsmagnus: the Magnus series methods [17, 14, 34].
tsqq: quadrature methods for quadratic Lie groups [19].
tsrk: classical Runge-Kutta methods. These methods are well-known to the ordinary dierential
equation community and the classical references include [3, 11].
f, y0, t0, h, q.
= rkgllmethod(q)
t = t0; y = y0;
for istp = 1:nstp,
for i = 1:s, k(i) = h*f(t+c(i)*h); end;
for i = 1:s, X(i) = W(i,:)*k; end;
s = eval(sig,X);
y = exp(s)*y;
t = t+h;
Figure 4: Simple RKGL-Lie timestepper.
tsrkmk: Runge-Kutta methods of Munthe-Kaas type. A large number of papers discuss these
methods, but the trilogy where the methods were derived is [21, 22, 23].
In future releases, general linear methods as well as linear multistep methods will be included in
DiMan, both as classical methods [11] and in a generalized setting [9].
[1] R. Abraham and J. E. Marsden. Foundations of Mechanics. Addison-Wesley, second edition,
[2] R. Abraham, J. E. Marsden, and T. S. Ratiu. Manifolds, Tensor Analysis, and Applications.
AMS 75. Springer-Verlag, second edition, 1988.
[3] J. C. Butcher. The Numerical Analysis of Ordinary Dierential Equations. Wiley, 1987.
[4] P. E. Crouch and R. Grossman. Numerical integration of ordinary dierential equations on
manifolds. J. Nonlinear Sci., 3:1{33, 1993.
[5] K. Eng. On the construction of geometric integrators in the RKMK class. Technical Report
No. 158, Department of Informatics, University of Bergen, Norway, 1998.
[6] K. Eng and S. Faltinsen. Integrating Lie{Poisson systems with the RKMK method. In
preparation. 1999.
[7] K. Eng, A. Marthinsen, and H. Munthe-Kaas. DiMan | an object oriented MATLAB
toolbox for solving dierential equations on manifolds: User's Guide. Version 1.5. Available
on WWW at
[8] K. Eng, H. Z. Munthe-Kaas, and A. Zanna. On the time symmetry of Lie group integrators.
In preparation. 1999.
[9] S. Faltinsen, A. Marthinsen, and H. Munthe-Kaas. Multistep methods integrating ordinary
dierential equations on manifolds. Manuscript, 1999.
[10] F. Fer. Resolution del l`equation matricielle U_ = pU par produit inni d`exponentielles
matricielles. Bull. Classe des Sci. Acad. Royal Belg., 44:818{829, 1958.
[11] E. Hairer, S. P. Nrsett, and G. Wanner. Solving Ordinary Dierential Equations I, Nonsti
Problems. Springer-Verlag, second revised edition, 1993.
[12] M. Haveraaen, V. Madsen, and H. Munthe-Kaas. Algebraic programming technology for partial dierential equations. In Proceedings of Norsk Informatikk Konferanse (NIK), Trondheim,
Norway, 1992. Tapir.
[13] A. Iserles. Solving linear ordinary dierential equations by exponentials of iterated commutators. Numer. Math., 45:183{199, 1984.
[14] A. Iserles and S. P. Nrsett. On the solution of linear dierential equations in Lie groups.
Technical Report 1997/NA3, Department of Applied Mathematics and Theoretical Physics,
University of Cambridge, England, 1997. To appear in Philosophical Transactions of the
Royal Society.
[15] D. Lewis and J. C. Simo. Conserving algorithms for the dynamics of Hamiltonian systems of
Lie groups. J. Nonlinear Sci., 4:253{299, 1994.
[16] S. B. Lippman. C++ Primer. Addison Wesley, second edition, 1991.
[17] W. Magnus. On the exponential solution of dierential equations for a linear operator. Comm.
Pure and Appl. Math., VII:649{673, 1954.
[18] J. E. Marsden and T. S. Ratiu. Introduction to Mechanics and Symmetry. Springer-Verlag,
[19] A. Marthinsen and B. Owren. Quadrature methods based on the Cayley transform. Technical Report Numerics No. 1/1999, The Norwegian University of Science and Technology,
Trondheim, Norway, 1999.
[20] The MathWorks, Inc., 24 Prime Park Way, Natick, MA 01760-1500. Using MATLAB, 5.2
edition, April 1998.
[21] H. Munthe-Kaas. Lie{Butcher theory for Runge{Kutta methods. BIT, 35(4):572{587, 1995.
[22] H. Munthe-Kaas. Runge{Kutta methods on Lie groups. BIT, 38(1):92{111, 1998.
[23] H. Munthe-Kaas. High order Runge{Kutta methods on manifolds. Applied Numerical Mathematics, 29:115{127, 1999.
[24] H. Munthe-Kaas and M. Haveraaen. Coordinate free numerics; Part 1: How to avoid indexwrestling in tensor computations. Technical Report No. 101, Department of Informatics,
University of Bergen, Norway, 1995.
[25] H. Munthe-Kaas and M. Haveraaen. Coordinate free numerics | Closing the gap between
'Pure' and 'Applied' mathematics? In Proceedings of ICIAM-95, Zeitschrift fur Angewandte
Mathematik und Mechanik (ZAMM), Berlin, 1996. Akademie Verlag.
[26] H. Munthe-Kaas and E. Lodden. Explicit Lie group integrators for heat equations. In preparation. 1999.
[27] H. Munthe-Kaas and B. Owren. Computations in a free Lie algebra. Technical Report No. 148,
Department of Informatics, University of Bergen, Norway, 1998. To appear in Philosophical
Transactions of the Royal Society.
[28] H. Munthe-Kaas and A. Zanna. Numerical integration of dierential equations on homogeneous manifolds. In F. Cucker and M. Shub, editors, Foundations of Computational Mathematics, pages 305{315. Springer Verlag, 1997.
[29] B. Owren and A. Marthinsen. Lie group integrators based on canonical coordinates of the
second kind. In preparation. 1999.
[30] B. Owren and A. Marthinsen. Runge{Kutta methods adapted to manifolds and based on
rigid frames. BIT, 39(1):116{142, 1999.
[31] C. Reutenauer. Free Lie Algebras. Number 7 in London Mathematical Society Monographs,
New Series. London Mathematical Society, 1993.
[32] V. S. Varadarajan. Lie Groups, Lie Algebras, and Their Representations. GTM 102. SpringerVerlag, 1984.
[33] F. W. Warner. Foundations of Dierentiable Manifolds and Lie Groups. GTM 94. SpringerVerlag, 1983.
[34] A. Zanna. Collocation and relaxed collocation for the Fer and the Magnus expansions. Technical Report 1997/NA17, Department of Applied Mathematics and Theoretical Physics, University of Cambridge, England, 1997.
[35] A. Zanna. On the Numerical Solution of Isospectral Flows. PhD thesis, Cambridge University,
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF