Welcome to the homepage of Ulrich Mutze

July 2011

Contact information

Am Bahndamm 22/1
D-73342 Bad Ditzenbach

phone:+49(0)7335 5786
email: ulrichmutze at gmx dot de

Graphics of the month

Time Evolution of a Symmetric System from the Wolfram Demonstrations Project by Ulrich Mutze

Graphics of the month archive

Latest versions of electronic articles on Computation Inspired Physics, mainly dealing with computational methods for Classical Mechanics and Quantum Mechanics

The originals are all in the preprint archive of the International Association of Mathematical Physics.

Predicting Classical Motion Directly from the Action Principle II
keywords: Kepler equation, unharmonic oscillator, symplectic integrator, planetary motion
Predicting Classical Motion Directly from the Action Principle III

keywords: motive force function, local action principle, parabolic path, midpoint rule, integrator

A Simple Variational Integrator for General Holonomic Mechanical Systems

keywords: direct midpoint method, smooth interpolation, small step action principle, Birkhoff-Witt basis

The Fundamental Theorem of Calculus in Rⁿ

keywords: anti-derivative, repeated integrals, electrostatic potential, charge patch, Mathematica

Quaternions - Redundancy + Efficiency = Ternions

keywords: rotation vectors, Euler-Rodrigues parameters, computer graphics

The direct midpoint method as a quantum mechanical integrator

keywords: discrete Laplacian, finite-dimensional quantum mechanics, scattering, energy conservation, unitarity

The direct midpoint method as a quantum mechanical integrator II

keywords: leap-frog method, Chebyshev method, time-dependent Hamilton, reversible, symplectic

Polyspherical grains and their dynamics

keywords: Euler-Rodrigues parameters, random generator, surface roughness, energy restoration, PaLa program

Separated quantum dynamics

keywords: adjacent non-identical particles, TDHF, fast integrator, spin chain, energy conservation, norm conservation

An asynchronous leap-frog method

keywords:leap-frog integrator, numerical initial value problem, Kepler oscillator, (skew-)symplectic integrator, numerical interaction picture

Quantum Image Dynamics - an entertainment application of separated quantum dynamics

keywords: asynchronous leap-frog integrator, image manipulation, animation

Precision-dependent symmetry breaking in simulated motion of polyspherical grains

keywords: rigid body dynamics, multiple precision arithmetic, mirror symmetry, polyspherical particles

Higher-dimensional antiderivatives and the efficient computation of electrostatic potentials

keywords: fundamental theorem of calculus, discrete Greens's theorem

Pedagogical remarks on mathematical or physical topics

On Vectors, Points, Rotations, and Rigid Bodies (a living document) including a probably novel Hamiltonian formulation of rigid body dynamics based on Euler-Rodrigues parameters as generalized coordinates.
Mathe mit Sahne (a living essay on mathematical foundations, in German)

Work in progress or recently finished

Integrating multiple precision arithmetic (based on MPFR C++ by Pavel Holoborodko) into my class system described below. Heureka! Today (2009-02-24) first successful run of the PaLa program (dynamics of polyspherical particles) with mpfr::mpreal instead of double: The run with double was by a factor of 13.5 faster than the run with multiple precision arithmetic. I consider this factor not at all disappointing since at least a linear growth of computation time with precision has to be accepted anyway. Presently there is too little experience to give more than a very crude orientation. A version of the class system that compiles without a warning with g++ 3.4.4 cygming special, and without relevant warnings, with Microsoft Visual C++ 2008 Express Edition, is given as a huge listing in current version. This document will be updated in some minor respects in the next future. Then it will be made public also in the form of source code. For the files which constitute the PaLa program, this did happen today (2009-05-21): see pala.zip . (finished)
Comparing dynamics of polyspherical particles with 10 and 32 digits precision, symmetry_lost_movie (finished)
How reversible integrators work for non-reversible differential equations such as the "leaking bucket equation" dh/dt = - Θ(h)|h|^1/2 ? ( Here Θ is the step function Θ(h) := h > 0 ? 1 : 0 . ) Given a trajectory of the system which starts with h=1 we follow it till h=0 (then the bucket is empty) and, further, some arbitrary span of time. If the trajectory was computed with the the asynchronous leapfrog method we can take the final state and evolve it back in exact agreement with the forward evolution. Along this reversed trajectory the bucket will start to get filled exactly at the point in time matching the previous point of running out of water. How this can be ? It works since the state description according to the asynchronous leapfrog method contains in addition to the water level a second quantity. In most cases, this quantity behaves like Δh/Δt. However, when h approaches the value 0 on a trajectory of our leaking bucket equation, the steepness of the right-hand side of this equation makes this second quantity oscillate (this reminds me of the "Zitterbewegung" of the Dirac electron) and it is only the mean value over two consecutive steps which resembles Δh/Δt. This oscillation, together with a small linear trend, carries the information concerning the moment of emptying. This phenomenon does not involve numbers of unusual size, and no multiple precision arithmetic is needed. Recently I modeled the situation in Mathematica as leaking_bucket.nb which, however, requires Mathematica to be installed on your computer. A non-interactive PDF version of it can be found here. Meanwhile also my contribution Leaking Bucket Equation and Reversibility to the Wolfram Demonstrations Project got published (2010-05-18, submitted 2010-01-22). (finished)
In addition to the leaking bucket equation, I studied the exploding equation dh/dt = h², for which the exact solution runs into infinity at finite time. For initial condition t₀ = 0, h₀ = 1, which I chose, this is at t_crit = 1. The asynchronous leapfrog algorithm, however, never encounters undefined quantities and thus allows defining the trajectory for arbitrarily large t. I did that for a few integration steps beyond t_crit, actually till t = 1.01, with a step size of 10^-3 getting up to very large values of h: log₁₀(log₁₀(h)) ∼ 2.9 --- and evolved the trajectory back to the initial state. For this to work, a precision of 1400 decimal places was necessary! Extending the leapfrog trajectory considerably beyond the t_crit cannot be done with multiple precision systems in which the number of decimal places can be represented as a 64 bit integer. If one would remove this obstacle, one would encounter new ones with unrealizable storage size and computation time. This is how finite mathemathics tells us that the trajectory has left the realm of practical considerations for t > t_crit. The potential size of finite numbers holds stronger threats than the mathematical ∞! The code used for this investigation is in file smallexperiments.cpp, functions test18(), test19(), and the definition of classes Bucket and Rocket preceding these functions. It is reproduced in section smallexperments.cpp of current version . Recently I modeled also this situation in Mathematica as exploding.nb. A non-interactive PDF version of it can be found here. Meanwhile also my contribution Integrating 'Beyond Infinity' and Back to the Wolfram Demonstrations Project got published (2010-08-14). (finished)
Modification of the class system by unifying the two array template classes Vl and V into a new single V with enhanced functionality. The range of valid indexes of a vector is now defined to be an instance of class IvZ, which describes finite contiguous sets of integers. An instance of V<X> behaves very much like a function IvZ → X. (finished)
Extension of the class system by adding class templates
F1_1<X,P1,Y>, F2_1<X,P1,P2,Y>, F2_2<X,P1,P2,Y>, ..., F4_1<X,P1,P2,P3,P4,Y>, ..., F4_4<X,P1,P2,P3,P4,Y>
for functions that depend on parameters and for which any parameter can be made to play the role of a function argument. Given a function
Y f(X const& x, P1 const& p1, ..., P4 const& p4)
one may form functions of type
F<X,Y>, F<P1,Y>, ..., F<P4,Y>
which depend on the remaining arguments of f as parameters. This allows a complicated equation between several quantities (e.g. the interaction energy as a function of the states of the interacting subsystems) to be coded once, and nevertheless to be considered as a function of any of its arguments, not only of the the one which happens to hold the first position in the list
x, p1, ..., p4.
An example for the syntax is
F<P2,Y> f2 = F4_2<X, P1, P2, P3, P4, Y>(x, p1, p3, p4)(f)
(finished)
Making Vr<X> a ring if X is a ring. Solution is now in file cpm1/cpmgaz.h as class GaZ<X>. GaZ stands for group algebra of Z. Together with all the other cpm source files this class can be downloaded from here (finished 2011-08-04)
Create a Wolfram Demonstration concerning the stability behavior of the ODE y'=z y, where z is a complex number, and the integrators are asynchronous leapfrog and Stoermer Verlet (finished 2011-09-09)
Visualization of n-particle wave functions along the lines drawn in The direct midpoint method as a quantum mechanical integrator
Exchanging the role of vertices and lines in graphs as an expanding process that starts at a single line. This will provide a dynamical system that works for arbitrary graphs. Visualization is the main issue here
Visualize the argument that the group SO(3) is 2-fold connected
Add a type-union template to the classes
Create a Wolfram Demonstration that shows how fast a group of particles, which move in parallel, reach thermal equilibrium when suddenly inclosed in a box (which makes particles collide) (joint work with Stephan Leibbrandt submitted 2012-02-29, published 2012-04-07, finished). Aiming for speed of execution we asked Mathematica to compile the most time-critical functions and this turned out to reduce execution time by an exciting factor 16.
Extend the work Predicting Classical Motion Directly from the Action Principle II and specialize the work A Simple Variational Integrator for General Holonomic Mechanical Systems to systems of rigid bodies. Do the symbolic calculations with Mathematica instead of Form

Physics animations

Talks

Curriculum vitae

curriculum vitae

Picture Gallery

Publications

Cornell University press release

Center for Advanced Computing

Scientific Software by Ulrich Mutze

is a small and clean sub-language of C++

particularly suited for physical and mathematical modeling and visualization
supports multiple precision arithmetic (via MPFC++) and parallel computing (via MPI)
implements reference counting, copy on write, and safe indexing for all its array types
treats functions as values
employes short names which result from descriptive full names by a simple deterministic abbreviation scheme
side effects of function calls can be read off the function's name
comes with a large collection of classes for physics, mathematics, graphics, and imaging
consider the metamorphosis between the two intended meanings of the logo:

= C + − = C plus minus = C Plus Minus = CPM = Classes for Physics and Mathematics =

Classes for Physics and Mathematics

line graphics capability

A diagram which symbolizes the Multiple Path Method. Here is a listing of the code which defines the diagram. It mainly uses the classes Wrt and LineArt, methods to combine such objects into a single one that can be moved in 3D space as a whole and then can again be combined with further objects to a single object that can be moved as a whole ... When, in 1999, I tried to create such a diagram with the commercial drawing program that was available within my Company, the program always crashed long before the work was completed. Notice that file cpmlineartcpp.h, which contains the definition all letters (latin and greek, lower case and upper case, punctuation and special symbols) is with 63 kB the largest of the CPM files. A further diagram which illustrates lines and areal color.
How the action principle determines the system path for given initial conditions.

stereo (anaglyph) imaging capability

By editing file cpmconfig.ini one now can vary the colors used in creating stereo images. This allows minimizing color crosstalk for ones own red-green(blue) glasses. Here is a version (with spherical particles instead of polyspherical ones) of Fig. 1 of Precision-dependent symmetry breaking in simulated motion of polyspherical grains which gives a clearer effect than the original for my red-green glasses branded Apramax. This functionality was suggested by Bernhard Mutze.

software descriptions

On the project
The tutorial
Listing of the basic classes
Listing of all classes, last version without multiple precision arithmetic last version with lean vector template Vl current version

code and Linux binaries

All sources and 5 selected projects cpmSourceAndProjects.zip
Who considers using should also consider to send me a mail so that I can help to make this a success.

Free Ruby code

Applied Mathematics coded in Ruby. So far, only very limited material is presented, all collected in a Ruby module named AppMath. This is intended as a field of experimentation to find out and define coding conventions and tools which allow algorithms of applied mathematics and physics to be written in a manner that the precision, that is the number of digits allowed for the significand of a real number, is completely open. In the present system, one needs a single statement R.prec = 100 (for instance) to enforce throughout a floating point number representation using 100 decimal digits for the significand of a real number. A statement R.prec = 0 lets all real values represented by the standard Ruby type Float. Notice that this is a fixation that is valid for all floating point calculations, so that the precision has not to be inputted in each function call. The user-interface is very much simpler than that of the GMP library. Efficient arbitrary precision arithmetic is a very special topic. The deeper functionality of class R (a class, what else?) is implemented on the basis of class BigDecimal and module BigMath created by Shigeo Kobayashi. What I added was an implementation of all elementary transcendental functions by rapidly convergent series and a unification of R and Float (by extending the interface of Float) so that in designing an algorithm one has not to decide which kind of floating point machinery (and precision) to use for execution. Notice that in R (and in the extended Float)the traditional functions are methods, so that we write x.sin and not sin(x). It is hard to believe how much this adds to the readability of algorithms! The easiest way to test the present code system is to download the zip-file all files zipped and to unpack it into a directory from which you can access ruby.exe. For some programs one needs also Tk. There are presently three applications rnum_app.rb, linalg_app.rb, and kepler_2d_app.rb which allow several selections. For a fast and convenient information, visit the auto-generated documentation files (rdoc files) for the various *.rb files to which the following points refer. Notice that this kind of documentation allows reading the code for all methods and other definitions. That of method step! of class AppMath::Kepler2D is particularly beautyful.
Real number class R for arbitrary precision arithmetic and transcendental functions. rdoc files
Complex number class C for arbitrary precision complex arithmetic and transcendental functions. rdoc files
Extending class Float in order to provide all methods of R rdoc files
Classes Vec and Mat of vectors and matrices which cooperate with R and C. Includes singular value decomposition (SVD) of real matrices (unfortunately not yet for complex matrices). rdoc files
Classes Graph and Graphs for graphical representation of functions via Tk. It is striking to see the standard functions like sin or erf be graphically represented (see the screen shot functions) when the algorithms for their evaluation are forced to use only two-digits accuracy! rdoc files
Class Iv of real intervals rdoc files
Class Ran of random generators rdoc files
Classes R2 and Kep2D dealing with the two-dimensional Kepler problem. Here, the quantities, which for exact dynamics are constant in time (energy, angular momentum, Runge-Lenz vector) are shown graphically for a time-discrete simulation by means of the direct midpoint integrator. See the screen shot Kepler. It turns out that the non-constancy of the angular momentum in the simulation is always by numerical noice (and thus becomes arbitrarily small by working with 100 digits, 200 ditgits, .... For the other quantities there are deviations from constancy which are due to the integrator mehod. These become aritrarily small only if the time step of the simulation becomes aritrarily small. rdoc files
Now all this stuff is also on the RubyForge server packaged as a gem named appmath-0.0.1.gem which is very conveniently installed on any computer which runs RubyGem. See Applied Mathematics.

Alpinism

My climbing routes (in German)

Last modification: 2012-04-26 14:57:04 +0200