LN

What it does

LN(number)

LN(number) returns the natural logarithm of a positive number. It answers the question “what exponent of e gives this number?” Microsoft documents it as the inverse of EXP. Use it for multiplicative growth, log returns and transformations of positive data.

Try it

=LN(8) is about 2.079441541679836. Dividing by LN(2) converts that exponent to base two: =LN(8)/LN(2) is about 3. =LN(1) returns zero.

For a growth factor of 1.25, =LN(1.25) gives a continuously compounded rate of about 0.2231435513142098. These are rounded mathematical examples; they do not promise a particular last bit on every machine.

Quirks

The documented domain is positive real numbers. The current calculation code returns #NUM! for zero or a negative value; Microsoft's opened function page does not specify that error code. Numeric conversion and elementwise array handling happen outside the logarithm kernel.

If you form LN(1+x) for a tiny x, the addition may already have rounded to 1, so LN receives exactly one and returns zero. A more accurate logarithm cannot recover a perturbation lost before the call. PMT uses a separate small-rate series for this reason.

Recorded answers differ between two machines for some identical inputs; their Excel builds and operating systems also differ. A host-native logarithm is therefore an implementation choice with an environment scope. The old battery also admits a subnormal directly to the kernel while a separate Excel input route flushed that value to zero: those are different input paths, not an established contradiction in LN itself.

How to implement

The current compatibility implementation evaluates an x87 instruction chain, rather than calling the language's log:

1. Convert the accepted binary64 input exactly to an extended value with a 64-bit significand. Reject x<=0 at the worksheet surface; return zero for x=1.
2. Load the resident extended constant ln(2). In the source model it is the exact binary value 0xB17217F7D1CF79AC * 2^-64; do not replace it with a binary64 constant.
3. Evaluate the modeled FYL2X instruction with that constant and x, meaning the instruction's approximation to ln(2)*log2(x). Keep the instruction result extended until the final assignment.
4. Store once to binary64 with round-to-nearest, ties-to-even. Apply the worksheet error and input policies outside this kernel.

For x=1, step 1 returns 0 without a transcendental call. For x=8, step 3 uses log2(8)=3; the result is near 3*ln(2), giving about 2.079441541679836 after storage.

This specifies the chain but leaves an instruction model to implement. The product has native x87 and software backends; the CPU's approximation and the software model are not justified by substituting an ideally rounded mathematical logarithm. The fingerprint work identifies constants within declared instruction models on measured discriminants. Private instruction internals, unmeasured input regions and agreement across CPUs remain outside that result.

Rust code

26 ln "LN" (1, 1) [V "number"] |s, a, sv| { unary(s, a, k::ln_fn::ln_kernel) }

pub fn ln_kernel(n: f64) -> Result<f64, WorksheetErrorCode> {
    if n <= 0.0 {
        return Err(WorksheetErrorCode::Num);
    }
    // Excel's LN is the x87 `fldln2` + `fyl2x` fused op; match it bit-for-bit.
    Ok(crate::ported::excel_numeric::excel_log(n))
}

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-LN-001: build 19929 versus build 20430; 2 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-LN-002: build 20131 versus build 18429; 52 same-input pairs, 17 differing answers. Compared axes: cpu, excel-build, os. Numeric answers were compared by their recorded binary64 bits; other answers by typed value.

The differing machines changed Excel build and other recorded environment properties together. These observations do not isolate a build-only or CPU-only cause. The linked record retains each input, answer, and recheck status.

A recorded example, XD-LN-001: the input 3.677168983357276e-222 has bits 0x11f544676cf1bf2f. On 2026-07-03, build 20131 on AMD Ryzen 7 4800H with Radeon Graphics returned -509.8717474865596 (0xc07fddf2ad7e124d). On the other machine, 2026-07-05, build 18429 on Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz returned -509.87174748655957 (0xc07fddf2ad7e124c). These answers differ by one unit in the last place. Each machine ran this probe once; no repeat is recorded. The input was placed in a cell through Range.Value2 and its round trip was checked, rather than entered as a rounded decimal formula literal.

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

Recorded environments and comparison details.

Retained controls from the indexed captures:

These are earlier recorded answers, not new Excel runs or an additional cross-build comparison. The function JSON retains each source locator, exact argument bits where available, and input-route status. Call notation does not imply that captured binary64 values were entered as decimal formula literals.

Recorded variants

Alternatives

Use LOG for an explicit base, LOG10 for base ten, and IMLN for a principal complex logarithm. EXP converts a natural-log result back to a positive scale. For tiny financial rates, see the separate series in PMT before constructing 1+rate.

Named variants

No named variants are recorded yet.