As I’ve written about here and elsewhere, the following simple approximations are fairly accurate.

log₁₀ x ≈ (x-1)/(x+1)

log_e x ≈ 2 (x – 1)/(x + 1)

log₂ x ≈ 3(x – 1)/(x + 1)

It’s a little surprising that each is as accurate as it is, but it’s also surprising that the approximations for log_e and log_e are small integer multiples of the approximation for log₁₀.

Logarithms in all bases are proportional: If b and β are two bases, then for all x,

log_β(x) = log_b(x) / log_b(β).

So it’s not surprising that the approximations above are proportional. But the proportionality constants are not what the equation above would predict.

There are a couple things going on. First, these approximations are intended for rough mental calculations, so round numbers are desirable. Second, we want to minimize the error over some range. The approximation for log_b(x) needs to work over the interval from 1/√b to √b. The approximations don’t work outside this range, but they don’t need to since you can always reduce the problem to computing logs in this interval. These two goals work together.

We could make the log₁₀ x approximation more accurate near 1 if we multiplied it by 0.9. That would make the approximation a little harder to use, but it wouldn’t improve the accuracy over the interval 1/√10 to √10. The constant 1 works just as well as 0.9, and it’s easier to multiply by 1.

Here’s a plot of the approximation errors. Notice that different bases are plotted over different ranges since the log for each base b needs to work from 1/√b to √b.

Ronald Doerfler presents a simple approximation for the cosine of an angle in degrees in his book Dead Reckoning.

cos d° ≈ 1 − d(d + 1)/7000

The approximation is good to about three digits for angles between 0° and 40°.

Although cosine is an even function, the approximation above is not, and the error is larger for negative angles. But there’s no need to use negative values since cos(-d) = cos(d). Just compute the cosine of the absolute value of the angle.

The simplest thing to do would have been to use a Taylor approximation, but Taylor approximations don’t work well over a large interval; they’re excessively accurate near the middle and not accurate enough at the ends. The error at 40° would have been 100x larger. Also, the Taylor approach would have required multiplying or dividing by a more mentally demanding number than 7000.

If we wanted to come up with a quadratic approximation for a computer rather than for a human, we could squeeze out more accuracy. The error curve over the interval [0, 40] dips down significantly more than it goes up. An optimal approximation would go up and down about the same amount.

Related posts

• Mentally calculate logs
• Mentally calculate the gamma function
• Mentally computing scientific calculator functions

A few weeks ago I wrote several blog posts about very simple approximations that are surprisingly accurate. These approximations are valid over a limited range, but with range reduction they can be used over the full range of the functions.

In this post I want to look again at

and

Padé approximation

It turns out that the approximations above are both Padé approximants [1], rational functions that match the first few terms of the power series of the function being approximated.

“First few” means up to degree m + n where m is the degree of the numerator and n is the degree of the denominator. In our examples, m = n = 1, and so the series terms up to order 2 match.

Luck

The approximations I wrote about before were derived by solving for a constant that made the approximation error vanish at the ends of the interval of interest. Note that there’s no interval in the definition of a Padé approximant.

Also, the constants that I derived were rounded in order to have something easy to compute mentally. The approximation for log, for example, works out to have a factor of 2.0413, but I rounded it to 2 for convenience.

And yet the end result is exactly was exactly a Padé approximant.

Exp

First let’s look at the exponential function. We can see that the series for our approximation and for exp match up to x².

The error in the Padé approximation for exp is less than the error in the 2nd order power series approximation for all x less than around 0.78.

Log

Here again we see that our function and our approximation have series that agree up to the x² terms.

The error in the Padé approximation for log is less than the error in the 2nd order power series approximation for all x

[1] The other approximations I presented in that series are not Padé approximations.

A while back I presented a very simple algorithm for computing natural logs:

log(x) ≈ (2x − 2)/(x + 1)

for x between exp(−0.5) and exp(0.5). It’s accurate enough for quick mental estimates.

I recently found an approximation by Ronald Doerfler that is a little more complicated but much more accurate:

log(x) ≈ 6(x − 1)/(x + 1 + 4√x)

for x in the same range. This comes from Doerfler’s book Dead Reckoning.

It requires calculating a square root, and in exchange for this complication gives about three orders of magnitude better approximation. You could use it, for example, on a calculator that has a square root key but not log key. Or if you’re dead reckoning, you need to take a square root by hand.

Here’s a plot of the error for both approximations.

The simpler approximation has error about 10⁻² on each end, whereas Doerfler’s algorithm has error about 10⁻⁵ on each end.

If you can reduce your range to [−1/√2, √2] by pulling out powers of 2 first and remembering the value of log(2), then Doerfler’s algorithm is about six times more accurate.

By the way, you might wonder where Doerfler’s approximation comes from. It’s not recognizable as, say, a series expansion. It comes from doing Richardson extrapolation, but algebraically simplified rather than expressing it as an algorithm.

This post looks at some common approximations and determines the range over which they have an error of less than 1 percent. So everywhere in this post “≈” means “with relative error less than 1%.”

Whether 1% relative error is good enough completely depends on context.

Constants

The familiar approximations for π and e are good to within 1%: π ≈ 22/7 and e ≈ 19/7. (OK, the approximation for e isn’t so familiar, but it should be.)

Also, the speed of light is c ≈ 300,000 km/s and the fine structure constant is α ≈ 1/137. See also Koide’s coincidence.

Trig functions

The following hold for angles in radians.

• sin x ≈ x for |x| < 0.244.
• cos x ≈ 1 − x²/2 for |x| < 0.662.
• tan x ≈ x for |x| < 0.173.

Inverse trig functions

Here again angles are in radians.

• arcsin x ≈ x for |x| < 0.242.
• arccos x ≈ π/2 − x for |x| < 0.4.
• arctan x ≈ x for |x| < 0.173.

Log

Natural log has the following useful approximation:

• log(1 + x) ≈ x for −0.0199 < x < 0.0200.

Factorial and gamma

Sterling’s approximation leads to the following.

• Γ(x) ≈ √(2π/x) (x/e)^x for x > 8.2876.
• n! ≈ √(2π/(n + 1)) ((n + 1)/e)⁽ⁿ⁺¹⁾ for n ≥ 8.

Commentary

Stirling’s approximation is different from the other approximations because it is an asymptotic approximation: it improves as its argument gets larger.

The rest of the approximations are valid over finite intervals. These intervals are symmetric when the function being approximated is symmetric, that is, even or odd. So, for example, it holds for sine but not for log.

For sine and tangent, and their inverses, the absolute error is O(x³) and the value is O(x), so the relative error is O(x²). [1]

The widest interval is for cosine. That’s because the absolute error and relative error are O(x⁴). [2]

The narrowest interval for is log(1 + x) due to lack of symmetry. The absolute error is O(x²), the value is O(x), and so the relative error is only O(x).

Verification

Here’s Python code to validate the claims above, assuming the maximum relative error always occurs on the ends, which it does in these examples. We only need to test one side of symmetric approximations to symmetric functions because they have symmetric error.

from numpy import *
from scipy.special import gamma

def sterling_gamma(x):
    return sqrt(2*pi/x)*(x/e)**x

id = lambda x: x

for f, approx, x in [
        (sin, id, 0.244),
        (tan, id, 0.173),
        (arcsin, id, 0.242),
        (arctan, id, 0.173),
        (cos, lambda x: 1 - 0.5*x*x, 0.662),
        (arccos, lambda x: 0.5*pi - x, 0.4),
        (log1p, id, 0.02),
        (log1p, id, -0.0199),
        (gamma, sterling_gamma, 8.2876)
    ]:
    assert( abs((f(x) - approx(x))/f(x)) < 0.01 )

Related posts

• Sine approximation for small angles
• Two useful asymptotic series
• Mentally computing scientific calculator functions

[1] Odd functions have only terms with odd exponents in their series expansion around 0. The error near 0 in a truncated series is roughly equal to the first series term not included. That’s why we get third order absolute error from a first order approximation.

[2] Even functions have only even terms in their series expansion, so our second order expansion for cosine has fourth order error. And because cos(0) = 1, the relative error is basically the absolute error near 0.

I find simple approximations more interesting than highly accurate approximations. Highly accurate approximations can be interesting too, in a different way. Somebody has to write the code to compute special functions to many decimal places, and sometimes that person has been me. But somewhat ironically, these complicated approximations are better known than simple approximations.

One reason I find simple approximations interesting is that they suggest further exploration. For example, the approximation for the perimeter of an ellipse here is interesting because of the connection to r-means. There are more accurate approximations, but not more interesting approximations, in my opinion.

Another reason I find simple approximations interesting is that if they are simple enough to be memorable and easy to evaluate, they’re useful for quick mental calculations.

I’ve written several posts about simple approximations, and this may be the last one, at least for a while. I’ve covered trig functions, logs and exponents. The most commonly used function I haven’t discussed is the gamma function, which I cover now.

Gamma

The most important function that’s not likely to be on a calculator is the gamma function Γ(x). This function comes up all the time in probability and statistics, as well as in other areas of math.

The gamma function satisfies

Γ(x + 1) = x Γ(x),

and so you can evaluate the function anywhere if you can evaluate it on an interval of length 1. For example, the next section gives an approximation on the interval [2, 3]. We could reduce calculating Γ(4.2) to a problem on that interval by

Γ(4.2) = 3.2 Γ(3.2) = 3.2 × 2.2 Γ(2.2)

Simple approximation

It turns out that

Γ(x) ≈ 2/(4 − x)

for 2 ≤ x ≤ 3. The approximation is exact on the end points, and the relative error is less than 0.9% over the interval.

An even simpler approximation over the interval [2, 3] is

Γ(x) ≈ x − 1.

It has a maximum relative error of about 13%, so it’s far less accurate, but it’s trivial to compute in your head.

Derivation

The way I found the rational approximation was to use Mathematica to find the best bilinear approximation using

    MiniMaxApproximation[Gamma[x], {x, {2, 3}, 1, 1}]

and rounding the coefficients. In hindsight, I could have simply used blinear interpolation. I did use linear interpolation to derive the approximation x − 1.

More gamma function posts

• Identities for gamma and related functions
• Code for computing the gamma function
• Asymptotic series for gamma function ratios
• Connecting the gamma constant, gamma function, and gamma distribution
• Mentally computing scientific calculator functions