Approximating Runge-Kutta matrices by triangular matrices

The implementation of implicit Runge-Kutta methods requires the solution of large systems of non-linear equations. Normally these equations are solved by a modified Newton process, which can be very expensive for problems of high dimension. The recently proposed triangularly implicit iteration methods for ODE-IVP solvers [5] substitute the Runge-Kutta matrixA in the Newton process for a triangular matrixT that approximatesA, hereby making the method suitable for parallel implementation. The matrixT is constructed according to a simple procedure, such that the stiff error components in the numerical solution are strongly damped. In this paper we prove for a large class of Runge-Kutta methods that this procedure can be carried out and that the diagnoal entries ofT are positive. This means that the linear systems that are to be solved have a non-singular matrix. The research reported in this paper was supported by STW (Dutch Foundation for Technical Sciences).     

Convergence of parallel multistep hybrid methods for singular perturbation problems

Parallel multistep hybrid methods (PHMs) can be implemented in parallel with two processors, accordingly have almost the same computational speed per integration step as BDF methods of the same order with the same stepsize. But PHMs have better stability properties than BDF methods of the same order for stiff differential equations. In the present paper, we give some results on error analysis of A(α)-stable PHMs for the initial value problems of ordinary differential equations in singular perturbation form. Our convergence results are similar to those of linear multistep methods (such as BDF methods), i.e. the convergence orders are equal to their classical convergence orders, and no order reduction occurs. Some numerical examples also confirm our results.     

Implicit peer methods for large stiff ODE systems

Implicit two-step peer methods are introduced for the solution of large stiff systems. Although these methods compute s-stage approximations in each time step one-by-one like diagonally-implicit Runge-Kutta methods the order of all stages is the same due to the two-step structure. The nonlinear stage equations are solved by an inexact Newton method using the Krylov solver FOM (Arnoldi??s method). The methods are zero-stable for arbitrary step size sequences. We construct different methods having order p=s in the multi-implicit case and order p=s?1 in the singly-implicit case with arbitrary step sizes and s??5. Numerical tests in Matlab for several semi-discretized partial differential equations show the efficiency of the methods compared to other Krylov codes.     

Parallel start for explicit parallel two-step peer methods

Explicit parallel two-step peer methods use s stages with essentially identical properties. They are quite efficient in solving standard nonstiff initial value problems and may obtain a parallel speed-up near s on s processors for expensive problems. The two-step structure requires s???1 initial approximations which have been computed by one-step methods in earlier versions. We now present a self-contained starting procedure using parallel Euler steps in the initial interval. Low order error terms introduced by this step are eliminated by special coefficient sets increasing the order to s after s???2 time steps. An estimate for the initial stepsize is discussed, as well. Parallel OpenMP experiments with realistic problems demonstrate the efficiency compared to standard codes.     

A family of explicit parallel Runge-Kutta-Nyström methods

A procedure for the construction of high-order explicit parallel Runge-Kutta-Nyström (RKN) methods for solving second-order nonstiff initial value problems (IVPs) is analyzed. The analysis reveals that starting the procedure with a reference symmetric RKN method it is possible to construct high-order RKN schemes which can be implemented in parallel on a small number of processors. These schemes are defined by means of a convex combination of k disjoint s_i-stage explicit RKN methods which are constructed by connecting s_i steps of a reference explicit symmetric method. Based on the reference second-order Störmer-Verlet methods we derive a family of high-order explicit parallel schemes which can be implemented in variable-step codes without additional cost. The numerical experiments carried out show that the new parallel schemes are more efficient than some sequential and parallel codes proposed in the scientific literature for solving second-order nonstiff IVPs.     

Implementation of simultaneous memory address access in models that forbid it

Models of synchronized parallel computation in which all the processors have access to a common memory are considered. We focus on algorithms in models that allow simultaneous access to the same memory location, for both read and write instructions. Assume that such an algorithm uses p processors, d time units, and s memory space. We present a universal algorithm that implements this algorithm in models that forbid simultaneous access to the same memory location, using p processors, O(dlog²p) time units, and O (s + p) memory space his implementation algorithm is shown to compare favorably with its conventional naive counterpart, as the extra memory space it requires is independent of the implemented algorithm.     

Parallel linear system solvers for Runge-Kutta methods

If the nonlinear systems arising in implicit Runge-Kutta methods like the Radau IIA methods are iterated by (modified) Newton, then we have to solve linear systems whose matrix of coefficients is of the form I-A hJ with A the Runge-Kutta matrix and J an approximation to the Jacobian of the righthand side function of the system of differential equations. For larger systems of differential equations, the solution of these linear systems by a direct linear solver is very costly, mainly because of the LU-decompositions. We try to reduce these costs by solving the linear systems by a second (inner) iteration process. This inner iteration process is such that each inner iteration again requires the solution of a linear system. However, the matrix of coefficients in these new linear systems is of the form I - B hJ where B is similar to a diagonal matrix with positive diagonal entries. Hence, after performing a similarity transformation, the linear systems are decoupled into s subsystems, so that the costs of the LU-decomposition are reduced to the costs of s LU-decompositions of dimension d. Since these LU-decompositions can be computed in parallel, the effective LU-costs on a parallel computer system are reduced by a factor s ³ . It will be shown that matrices B can be constructed such that the inner iterations converge whenever A and J have their eigenvalues in the positive and nonpositive halfplane, respectively. The theoretical results will be illustrated by a few numerical examples. A parallel implementation on the four-processor Cray-C98/4256 shows a speed-up ranging from at least 2.4 until at least 3.1 with respect to RADAU5 applied in one-processor mode.     

Diagonalizable Extended Backward Differentiation Formulas

We generalize the extended backward differentiation formulas (EBDFs) introduced by Cash and by Psihoyios and Cash so that the system matrix in the modified Newton process can be block-diagonalized, enabling an efficient parallel implementation. The purpose of this paper is to justify the use of diagonalizable EBDFs on parallel computers and to offer a starting point for the development of a variable stepsize-variable order method. We construct methods which are L-stable up to order p = 6 and which have the same computational complexity per processor as the conventional BDF methods. Numerical experiments with the order 6 method show that a speedup factor of between 2 and 4 on four processors can be expected.     

An improved approximate Newton method for implicit Runge-Kutta formulas

Implicit Runge-Kutta (IRK) methods (such as the s-stage Radau IIA method with s=3,5, or 7) for solving stiff ordinary differential equation systems have excellent stability properties and high solution accuracy orders, but their high computing costs in solving their nonlinear stage equations have seriously limited their applications to large scale problems. To reduce such a cost, several approximate Newton algorithms were developed, including a commonly used one called the simplified Newton method. In this paper, a new approximate Jacobian matrix and two new test rules for controlling the updating of approximate Jacobian matrices are proposed, yielding an improved approximate Newton method. Theoretical and numerical analysis show that the improved approximate Newton method can significantly improve the convergence and performance of the simplified Newton method.     

Efficient implementation of symplectic implicit Runge-Kutta schemes with simplified Newton iterations

We are concerned with the efficient implementation of symplectic implicit Runge-Kutta (IRK) methods applied to systems of Hamiltonian ordinary differential equations by means of Newton-like iterations. We pay particular attention to time-symmetric symplectic IRK schemes (such as collocation methods with Gaussian nodes). For an s-stage IRK scheme used to integrate a \(\dim \)-dimensional system of ordinary differential equations, the application of simplified versions of Newton iterations requires solving at each step several linear systems (one per iteration) with the same \(s\dim \times s\dim \) real coefficient matrix. We propose a technique that takes advantage of the symplecticity of the IRK scheme to reduce the cost of methods based on diagonalization of the IRK coefficient matrix. This is achieved by rewriting one step of the method centered at the midpoint on the integration subinterval and observing that the resulting coefficient matrix becomes similar to a skew-symmetric matrix. In addition, we propose a C implementation (based on Newton-like iterations) of Runge-Kutta collocation methods with Gaussian nodes that make use of such a rewriting of the linear system and that takes special care in reducing the effect of round-off errors. We report some numerical experiments that demonstrate the reduced round-off error propagation of our implementation.     

A PARALLEL COMPUTATION SCHEME FOR IMPLICIT RUNGE-KUTTA METHODS AND THE ITERATIVELY B-CONVERGENCE OF ITS NEWTON ITERATIVE PROCESS

In this paper, based on the implicit Runge-Kutta(IRK) methods, we derive a class of parallel scheme that can be implemented on the parallel computers with Ns(N is a positive even number) processors efficiently, and discuss the iteratively B-convergence of the Newton iterative process for solving the algebraic equations of the scheme, secondly we present a strategy providing initial values parallelly for the iterative process. Finally, some numerical results show that our parallel scheme is higher efficient as N is not so large.     

New linear codes over GF(8)

Let [n, k, d; q]-codes be linear codes of length n, dimension k and minimum Hamming distance d over GF(q). Let d₈(n, k) be the maximum possible minimum Hamming distance of a linear [n, k, d; 8]-code for given values of n and k. In this paper, eighteen new linear codes over GF(8) are constructed which improve the table of d₈(n, k) by Brouwer.     

A note on the efficient implementation of implicit methods for ODEs

The use of implicit methods for ODEs, e.g. implicit Runge-Kutta schemes, requires the solution of nonlinear systems of algebraic equations of dimension s · m, where m is the size of the continuous differential problem to be approximated. Usually, the solution of this system represents the most time-consuming section in the implementation of such methods. Consequently, the efficient solution of this section would improve their performance. In this paper, we propose a new iterative procedure to solve such equations on sequential computers.     

An improvement of the Griesmer bound for some small minimum distances

In this paper we give some lower and upper bounds for the smallest length n(k, d) of a binary linear code with dimension k and minimum distance d. The lower bounds improve the known ones for small d. In the last section we summarize what we know about n(8, d).     

Strong-stability-preserving 3-stage Hermite-Birkhoff time-discretization methods

Strong-stability-preserving (SSP) time-discretization methods have a nonlinear stability property that makes them particularly suitable for the integration of hyperbolic conservation laws. A collection of SSP explicit 3-stage Hermite-Birkhoff methods of orders 3 to 7 with nonnegative coefficients are constructed as k-step analogues of third-order Runge-Kutta methods, incorporating a function evaluation at two off-step points. Generally, these new methods have larger effective CFL coefficients than the hybrid methods of Huang with the same step number k. They have larger maximum scaled step sizes than hybrid methods on Burgers' equations.     

A generalized Conner-Floyd conjecture and the immersion problem for low 2-torsion lens spaces

Let α(d) denote the number of ones in the binary expansion of d. For 1?k?α(d) we prove that the 2(d+α(d)−k)+1-dimensional, 2^k-torsion lens space does not immerse in a Euclidian space of dimension 4d−2α(d) provided certain technical condition holds. The extra hypothesis is easily eliminated in the case k=1 recovering Davis’ strong non-immersion theorem for real projective spaces. For k>1 this is a deeper problem (solved only in part) that requires a close analysis of the interaction between the Brown-Peterson 2-series and its 2^k analogue. The methods are based on a partial generalization of the Brown-Peterson version for the Conner-Floyd conjecture used in this context to detect obstructions for the existence of Euclidian immersions.     

Parallel iteration across the steps of high-order Runge-Kutta methods for nonstiff initial value problems

For the parallel integration of nonstiff initial value problems (IVPs), three main approaches can be distinguished: approaches based on “parallelism across the problem”, on “parallelism across the method” and on “parallelism across the steps”. The first type of parallelism does not require special integration methods and can be exploited within any available IVP solver. The method-parallelism approach received much attention, particularly within the class of explicit Runge-Kutta methods originating from fixed point iteration of implicit Runge-Kutta methods of Gaussian type. The construction and implementation on a parallel machine of such methods is extremely simple. Since the computational work per processor is modest with respect to the number of data to be exchanged between the various processors, this type of parallelism is most suitable for shared memory systems. The required number of processors is roughly half the order of the generating Runge-Kutta method and the speed-up with respect to a good sequential IVP solver is about a factor 2. The third type of parallelism (step-parallelism) can be achieved in any IVP solver based on predictor-corrector iteration and requires the processors to communicate after each full iteration. If the iterations have sufficient computational volume, then the step-parallel approach may be suitable for implementation on distributed memory systems. Most step-parallel methods proposed so far employ a large number of processors, but lack the property of robustness, due to a poor convergence behaviour in the iteration process. Hence, the effective speed-up is rather poor. The dynamic step-parallel iteration process proposed in the present paper is less massively parallel, but turns out to be sufficiently robust to achieve speed-up factors up to 15.     

Linear spaces with small generated subspaces

The dimension of a linear space is the maximum positive integer d such that any d of its points generate a proper subspace. Given n, d, s, we consider linear spaces on n points such that any d points generate subspaces of size at most s. Certain design-theoretic constructions and applications are investigated. In particular, one consequence is the existence of proper n-edge-colourings of both Kn+1 (for n odd) and Kn,n with a constant bound on the length of two-colored cycles.     

Convergence results for multistep Runge-Kutta methods

Summary. Recently Ch. Lubich proved convergence results for Runge-Kutta methods applied to stiff mechanical systems. The present paper discusses the new ideas necessary to extend these results to general linear methods, in particular BDF and multistep Runge-Kutta methods. Received August 9, 1993 / Revised version received May 3, 1994