Subject headings: celestial mechanics—two-body problem—Kepler equation

The XML version of this document is available on the web at
http://www.alpheratz.net/murison/dynamics/twobody/KeplerIterations_summary.xml

The PDF version of this document is available on the web at
http://www.alpheratz.net/murison/dynamics/twobody/KeplerIterations_summary.pdf

1  Introduction

The Kepler equation relates the linearly advancing time to the nonlinear relative angular position between two bodies $m_1$ and $m_2$ in Keplerian motion about their center of mass. It is

where $E$ is the eccentric anomaly, $e$ is the orbital eccentricity, and $M\left(t\right)=n\left(t-\tau \right)$ is the mean anomaly, where $n=\sqrt{\raisebox{1ex}{$G(m_1+m_2)$}\!\left/ \!\raisebox{-1ex}{$a^3$}\right.}$ is the two-body mean motion with $\tau$ being the time of pericenter passage and $a$ the semimajor axis of the orbital ellipse. See Figure 1.

Figure 1:  The geometric relationship between the eccentric anomaly $E$ and the true anomaly $\theta$.

We will outline here the development of a numerical method for solving the Kepler equation. Ideally, a method should be practical in the sense that it should simultaneously try to (1) minimize the cpu time spent solving for $E$ and (2) minimize the programming complexity of the procedure. These two requirements tend to oppose each other, so we shall arrive at a suitable compromise. Fortunately, the compromise shown here is in fact ideal. A more detailed and comlete development will appear in another paper. The emphasis here is on immediate practicality.

The Kepler equation is transcendental, which means solutions must be found iteratively. Thus, any numerical procedure will have two tasks. First is the iterative loop wherein some refining algorithm is repeated until a satisfactory convergence is achieved. Generally, the higher the order of the algorithm, the fewer iterative passes needed. However, higher order brings with it a mushrooming expression complexity, which costs cpu time. Thus, for whatever algorithm one chooses, a certain (usually low) order will result in minimum cpu expenditure. The second task is to choose a starting value for the iterative loop. The better the initial approximation, the faster the loop will converge. The starting value method need not be the same as, or even remotely similar to, the iteration method. Similar to the iteration algorithm, there will be an ideal order for a given starting value approximation method that minimizes the cpu cost.

In what follows, we present a particularly simple starting value method, followed by what turns out to be a fast iteration method. In Section 5 we show results from work elsewhere that indicates the choice of order for each method summarized here is ideal, followed by a fast and fool-proof procedure that uses these methods. Fortunately, it is surprisingly simple and easy to adapt to any numerical computing language.

2  A Starting Value Method

Since we must solve the Kepler equation iteratively, it seems reasonable that the more accurate the starting value we feed to the iterative loop the better, at least until expression complexity becomes objectionable. Write the Kepler equation as

In the limit of zero eccentricity, we just have $E=M$. Thus, (2) suggests a simple iterative scheme for improving the starting approximation $E=M$. Write

where $E_0=M$. We can then iterate the recursive expression (3) to as many orders in $e$ as desired. For example, the third-order approximation is

An third-order pseudocode procedure for (4), optimized with respect to calculation time, is

KeplerStart3 := proc(e,M)

local t33, t35, t34;

t34 := e^2;

t35 := e*t34;

t33 := cos(M);

return M+(-1/2*t35+e+(t34+3/2*t33*t35)*t33)*sin(M);

end proc;

3  An Iteration Method

Since (1) is a transcendental equation, it must be solved iteratively, whether numerically or analytically. So we must search for an expression that, when given some $E$ that is in error, returns an approximation that reduces the error. It must also converge. To that end, write eq. (1) in the form

where the solution of $f\left(x\right)=0$ is $x=E$. Let $ϵ\equiv x-E$ be the error in the approximation of $E$ given by $x$. Then a Taylor expansion about $x=E$ yields

assuming $ϵ$ is small.

We may solve the first-order term of (6) for $ϵ$ to get

We can use this as the kernel of a first-order iterative scheme. Suppose we start with an initial guess, $x=x_0$. Then $x_1=x_0+ϵ$ should be a better approximation for $E$ than $x_0$, and so on. Thus, we posit the first-order iterative procedure

where the choice of starting value for $x_0$ will be discussed below. We have in (8) a single-step first-order iterative method for estimating $E_{n+1}=E_n-{ϵ}_n$. A pseudocode procedure for (8) is

eps1 := proc(e,M,x)

return (x-e*sin(x)-M)/(1-e*cos(x));

end proc;

At second order, (6) in Horner form is

We may rearrange $f\left(x-ϵ\right)=0$ given by (9) into the suggestive form

Hence, let us create a second-order iterative scheme by writing, in analogy to (8),

We can create a two-step iterative procedure out of this by first calculating ${ϵ}_n$ given by (8) and then ${ϵ}_{n+1}$ given by (11). We can also just skip the intermediate step by substituting (7) directly for ${ϵ}_n$ in (11). Then the single-step iteration is

An optimized pseudocode procedure for (12) is

eps2 := proc(e,M,x)

local t1, t2, t3;

t1 := -1+e*cos(x);

t2 := e*sin(x);

t3 := -x+t2+M;

return t3/(1/2*t3*t2/t1+t1);

end proc;

The third-order approximation of $f\left(E\right)=f\left(x-ϵ\right)$ in Horner form is

Setting this to zero and solving for the "top-level" $ϵ$ on the right-hand side, we have

We may use (12) for ${ϵ}_n$ in (14) for a two-step method, or (8) for ${ϵ}_n$ in (11) and then that result for ${ϵ}_n$ in (14) for a three-step method. Alternatively, we can just substitute (12) for ${ϵ}_n$ directly in into (14) for a one-step third-order method. An optimized pseudocode representation for the latter is

eps3 := proc(e,M,x)

local t1, t2, t3, t4, t5, t6;

t1 := cos(x);

t2 := -1+e*t1;

t3 := sin(x);

t4 := e*t3;

t5 := -x+t4+M;

t6 := t5/(1/2*t5*t4/t2+t2);

return t5/((1/2*t3 - 1/6*t1*t6)*e*t6+t2);

end proc;

One may continue in this fashion to higher orders.

4  Converting between True and Eccentric Anomaly

If one needs to work with true anomaly $\theta$ rather than eccentric anomaly, the conversion can be derived from inspection of Figure 1. From the figure, the magnitude of the position vector can be written

Again from inspection of Figure 1, we may write

From (16) one can then easily derive

Inverting eqs. (17), we can go the other direction with

Hence, we can, if necessary, use our iterative procedures to solve the Kepler equation for $E$, then use (17) to convert to $\theta$.

5  Summary: A Useful Numerical Method

Figure 2:  Contours, as a function of starting value order (Nstart) and iteration order (Niter), of the amount of cpu time expended to perform, at each $\left(N_{\mathrm{iter}},N_{\mathrm{start}}\right)$ point, 160,000 solutions of the Kepler equation on an evenly-spaced $400\times 400$ grid over the domain $\{\mathrm{ℝ}\times \mathrm{ℝ}:e\in \left[0,1\right),M\in \left[0,\pi \right]\}$. It appears that third order for each method is near-optimal.

Extensive numerical tests (see Figure 2) indicate that third order for both starting value and iteration, using the methods shown previously, is the most optimal with respect to time spent calculating.

Here then is a procedure to numerically solve the Kepler equation that makes use of the optimized third-order iteration and starting value methods:

KeplerSolve := proc( e, M, tol:=1.0e-14 )

local dE, E, E0, Mnorm, count;

global Estart3, eps3;

Mnorm := fmod(M,2*Pi);

E0 := KeplerStart3(e,Mnorm);

dE := tol + 1;

count := 0;

while dE > tol do

E := E0 - eps3(e,Mnorm,E0);

dE := abs(E-E0);

E0 := E;

count := count + 1;

if count=100 then

print "Astounding! KeplerSolve failed to converge!";

break;

end if;

end do;

return E;

end proc;