Work in progress or recently finished

Integrating multiple precision arithmetic (based on MPFR C++ by Pavel Holoborodko) into my class system cpm

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 cpm

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 cpm

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 cpm

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 cpm

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 (finished 2013-05-22)

Add a type-union template to the cpm

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

Create a version of the Cpm class system in which also the basic numerical types are represented as classes and which thus has an even more uniform syntax. This is presently my favorite work since I observed that with the most recent g++ compiler there is only an ignorable performance penalty for this new lean and clean class system. I hope to publish the basic part of the systen in 2012. Presently I'm implementing relativistic kinematics (classes for Minkowski space, its tangent space, the Poincaré group and its Lie algebra). The exponential function from Lie algebra to Lie group is implemented by solving a initial value problem of a first-order ODE and the asynchronous leapfrog integrator turns out to work perfectly also in this case.

Create a version of the Cpm class system in which real numbers are implemented as long double, selectable by defining or undefining macro CPM_LONG. (finished 2013-03-24).

Publish a comprehensive description of the Averaged Densified Asynchronous Leapfrog Method (ADALF) in arXiv ( finished 2013-11-26)

Study the implementation of interactive dynamical systems in Mathematica within the limitations imposed by the CDF format. Publish such a system as a Wolfram demonstration Swingboat Ride ( finished 2014-04-17)

Today, i.e. 2020-06-14, I decided to continue the worklog after a long pause. As the publication list shows with the 12 enties 45 - 56 I did not stop working on topics of computational physics. Since C++ did several steps forward with C++11 and some prelimiary C++20 becoming available some modernizing of my cpm

class system took place. The work which is cited in this monumental article now is available as a C++ project dirac that can be built in a Linux environment from the provided source code and the provided makefile.

2020-06-25: A Ruby script is finished which automatically builds and runs my 6 test projects (tut1, tut2, chebyshew, pala, vqm2, dirac) for four different representations of real numbers (double, long double, boost multiprecision, mpreal multiprecision) each. If a modification of the C+- classes doesn't make such a super run (over night!) fail I expect that the modification was OK.

2023-01-24: The work on the CrossWay system had led to valuable insights on debugging. valgrind turned out to be of great help. This is my commandline:

valgrind --tool=memcheck --leak-check=full -s ./classicalcrossway

The working directory for the bash is convenienltly set to the location of the executable, 'classicalcrossway' in our present case. Starting from my home directory ~ I thus have to enter

cd Desktop/e/cpm/classical

to reach this place. So far I did not get hints as to the location of my errors (even when compiling under '-g' but the opportunity see whether there is an error or leaking memory blocks is extremely valuable. So far I had the opinion that having constructors and destructors in all my classes would reliably prevent memory leaks. I had to learn that it is not impossible to have errors in constructor code and destructor code. An example for leaking constructor code is by self-created idiom for defining constructors in terms of other constructors:

X::X(B b){ A a=expession1(b); *this = X(a); }

where X::X(A a) was defined earlier. A way to achieve the same thing without any danger of leaking is to define a static make-function

static X X::make(B b){ return X(expression1(b)); }

Instead of giving the function the suggestive name 'make' we could choose even more suggestive names like 'makeFromB' or B2X (B to X), ...

The problem with destructor code was in my array class

template class V&<;T&>;{ std::vector* p_; ~V(){ p_ -> ~std::vector();} ... };; where in cases that T is not a basic type some destructive handling of *p_ should be done.

2023-02-17: Since a few weeks everybody has free reading access (which includes downloading) to all content of my website. This should reduce the time needed to keep this content in a useful form. Recently I learned how to create videos from series of ppm-files (the only image file type which the C+- tools create directly). A few such videos have been added to the Physics animations section, and some are planned to follow.