GAMMALN

What it does

GAMMALN(x)

GAMMALN(x) returns the natural logarithm of the gamma function:

GAMMALN(x)  =  ln Γ(x)  =  ln ∫₀^∞ t^{x−1} e^{−t} dt        for x > 0

Domain: the positive reals. Excel does not expose the negative-argument branch (where Γ alternates sign and its logarithm is complex), so the documented domain is x > 0 with #NUM! outside it. Note this makes GAMMALN a restriction of LN(GAMMA(x)), not an equivalent: the latter is defined on more of the line and overflows on far less of it.

Range and shape. ln Γ is strictly convex on (0, ∞) — this is the Bohr–Mollerup characterisation, and it is the property that makes ln Γ the natural object rather than Γ. It falls from +∞ at x → 0⁺ to a single minimum near x ≈ 1.4616 (value ≈ −0.1214) and rises thereafter without bound. It has exactly two zeros, at x = 1 and x = 2, because Γ(1) = Γ(2) = 1. Those two zeros are the source of the function's only real accuracy trap; see Numerical notes.

The identities.

ln Γ(x + 1)  =  ln x  +  ln Γ(x)                      (recurrence)
ln Γ(n)      =  ln (n − 1)!                           for positive integers n
ln Γ(x)      ~ (x − ½) ln x − x + ½ ln(2π) + 1/(12x) − 1/(360x³) + …   (Stirling, A&S 6.1.40)

Microsoft states the integer relation from the other side: "The number e raised to the GAMMALN(i) power, where i is an integer, returns the same result as (i − 1)!" That is exact as mathematics and, as with GAMMA, is a floating-point claim about the round trip rather than a guarantee — exp(lnΓ(i)) need not land on the integer.

Why this function exists at all. Γ overflows binary64 a little above x ≈ 171.6; ln Γ stays comfortably finite until x is astronomically large. Every ratio of gamma functions — binomial coefficients, beta functions, distribution normalising constants, multinomials — should be computed as a difference of log-gammas and exponentiated once at the end, if at all. That is the entire practical argument for the function, and it is why GAMMALN appears far more often than GAMMA in careful spreadsheet work.

Arguments

Try it

Quirks

Result and edge cases

Returns Number.

• Small positive x behaves like −ln x: ln Γ(x) = −ln x − γx + O(x²). At the bottom of the double range the value is large and finite, which is the good news GAMMALN exists to deliver — where GAMMA overflows, GAMMALN still answers.
• x ≤ 0 is documented #NUM!, including the poles and the whole negative axis where the real logarithm of Γ does not exist.
• Array arguments lift elementwise through the module's broadcast helper.

Errors

As documented by Microsoft:

How to implement

Numerical notes

The classical design is a three-region split. Every serious implementation of ln Γ does the same three things, and their boundaries are the implementation's fingerprint:

1. Small x — use the recurrence to lift x into the well-behaved region: ln Γ(x) = ln Γ(x + 1) − ln x. This is essential because the Lanczos and rational forms both degrade as x → 0, and the reciprocal singularity is best handled by an explicit ln x term.
2. The middle, roughly [1, 8] — a minimax rational or Chebyshev approximation. Cody & Hillstrom's 1967 Chebyshev approximations are the classical answer and the ancestor of SPECFUN's ALGAMA/DLGAMA, of fdlibm's lgamma, and of most libm implementations. Excel differs here: from 3 to 8 it uses a stored recurrence (FN-GAMMALN-001).
3. Large x — Stirling's asymptotic series (A&S 6.1.40), typically with terms through 1/x⁷ or so, above a seam around x = 8 to 12.

The two zeros are the trap. Because ln Γ vanishes at x = 1 and x = 2, the relative error near those points is unbounded for any implementation that computes the value directly: the answer is a small number obtained by cancelling large terms, and the surviving digits are few. fdlibm handles this by evaluating a polynomial in (x − 1) or (x − 2) directly near each zero, so that the small quantity is the argument rather than a difference. An implementation that skips that step will produce residuals that spike sharply in two narrow bands and look fine everywhere else — which is exactly the pattern that makes a coarse accuracy sweep miss the problem.

Argument reduction is the other half. The recurrence multiplies by x, so lifting a small argument requires computing ln x accurately and subtracting; near x = 1 that subtraction is itself a cancellation. The interaction of the reduction seam with the zero at x = 1 is the subtlest part of the whole function.

What upstream identified. The evidence records describe an identification campaign that pinned a structural form for Excel's surface — a threshold near 0.7, a seam at 8.0, and a Stirling form beyond it — and then fitted coefficients, with two held-out tests plus one fresh never-probed corpus used to decide which candidate landed. Two properties of that campaign matter to a reader and are stated in the records themselves. First, the held-out tests were held out from the coefficient fits, not from the structural identification: the threshold, the seam and the form were pinned on batteries surrounding those very rows. Second, the arguments in both held-out tests are GAMMALN.PRECISE captures, so the inheritance runs from .PRECISE to GAMMALN and not the other way — the surface with the fresh corpus of its own is this one, and the record says so explicitly.

Recommended practice. Prefer GAMMALN over LN(GAMMA(x)) unconditionally: it is defined on a larger useful range, it does not overflow where GAMMA does, and it avoids the exp-then-log round trip. Where a ratio of gammas is wanted, keep it in log space to the last step. Where an exact small factorial is wanted, use the integer route, not this one.

Rust code

59 gammaln "GAMMALN" (1, 1) [V "x"] |s, a, sv| { out(s, sd::gammaln_kernel(num_with_subnormal(s, a, 0)?)) }

No implementation has been published with a Handbook test suite for this function.

Version differences

The recorded environments below distinguish a reading from a same-input comparison. Counts describe captured inputs in each environment; overlapping captures and comparisons are not totals of unique worksheet calls.

• XC-GAMMALN-001: build 19929 versus build 20228; 1 same-input pairs, 0 differing answers. Compared axes: excel-build. Numeric answers were compared by their recorded binary64 bits; other answers by typed value.
• XC-GAMMALN-002: build 20131 versus build 20228; 13 same-input pairs, 0 differing answers. Compared axes: excel-build. Numeric answers were compared by their recorded binary64 bits; other answers by typed value.

Agreement on these compared inputs does not establish agreement on unmeasured inputs.

Recorded environments and comparison details.

Alternatives

Relationships

• GAMMA — the value rather than its logarithm. The two share a module and not a numeric path: upstream's landed log-gamma kernel is wired only to the two GAMMALN surfaces, and the source says so in as many words. LN(GAMMA(x)) and GAMMALN(x) are therefore different computations with different accuracy and different domains, and the first overflows where the second does not.
• FACT, COMBIN, MULTINOMIAL — combinatorial quantities better computed through this function than through GAMMA or FACT when the intermediate factorials would overflow. COMBIN(n,k) as EXP(GAMMALN(n+1) − GAMMALN(k+1) − GAMMALN(n−k+1)) is the standard rewrite, and it is less accurate for small n than an exact integer route — a real trade, not a free improvement.
• GAMMA.DIST, BETA.DIST, POISSON.DIST — consumers: their normalising constants are log-gammas.
• Module siblings: ERF, ERF.PRECISE, ERFC, ERFC.PRECISE, GAMMA, WEIBULL, WEIBULL.DIST.

Named variants

No named variants are recorded yet.