math.ln

pub fn ln(x: f64) -> f64

fune!(math.ln@^1);  // then call ln(…)

// Derived from fdlibm e_log.c.
// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
// Developed at SunSoft, a Sun Microsystems, Inc. business.
// Permission to use, copy, modify, and distribute this
// software is freely granted, provided that this notice
// is preserved.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

// fdlibm's split of ln 2: the high part has trailing zero bits, so e * LN2_HI
// is exact for any exponent a double can have.
const LN2_HI: f64 = 6.93147180369123816490e-01;
const LN2_LO: f64 = 1.90821492927058770002e-10;
const SQRT2: f64 = 1.4142135623730951;

/// Natural logarithm using only +, -, * and /.
///
/// `f64::ln` calls the platform's maths library, whose last bit may differ
/// from JavaScript's and Python's. This follows the same steps in the same
/// order as the other two, so all three return the same double.
///
/// # Panics
/// Panics unless `x` is finite and greater than zero.
pub fn ln(x: f64) -> f64 {
    if !x.is_finite() || x <= 0.0 {
        panic!("ln is only defined for finite numbers greater than zero, received {}", x);
    }
    let mut m = x;
    let mut e = 0i64;
    while m >= 2.0 {
        m /= 2.0;
        e += 1;
    }
    while m < 1.0 {
        m *= 2.0;
        e -= 1;
    }
    if m > SQRT2 {
        m /= 2.0;
        e += 1;
    }
    let f = m - 1.0;
    let s = f / (2.0 + f);
    let z = s * s;
    let mut p = 1.0 / 25.0;
    p = 1.0 / 23.0 + z * p;
    p = 1.0 / 21.0 + z * p;
    p = 1.0 / 19.0 + z * p;
    p = 1.0 / 17.0 + z * p;
    p = 1.0 / 15.0 + z * p;
    p = 1.0 / 13.0 + z * p;
    p = 1.0 / 11.0 + z * p;
    p = 1.0 / 9.0 + z * p;
    p = 1.0 / 7.0 + z * p;
    p = 1.0 / 5.0 + z * p;
    p = 1.0 / 3.0 + z * p;
    let lnm = 2.0 * s + 2.0 * s * (z * p);
    let ef = e as f64;
    ef * LN2_HI + (ef * LN2_LO + lnm)
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Float(ln(args[0].as_f64()))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Rust package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add math.ln

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./math.ln-1.0.1-rust.fune, or fetch it from a terminal with fune pull math.ln@1.0.1:rust.

The whole function, every language, is one file too: math.ln-1.0.1.fune, 10,563 bytes, sha256 fcc649f7bc35683193541d1555c0148e1698113437f262b6ec72d5868216ca15. It installs into a project of any language.

// fune: before math.ln

// fune: after math.ln

// fune: step math.ln after <n|label>

More from the author

## Method

1. Write x = m x 2^e with m in (sqrt(1/2), sqrt(2)], by halving or doubling, which is exact for every double, subnormals included. 2. With s = (m - 1) / (m + 1), |s| < 0.172, ln m = 2 atanh s = 2s (1 + s²/3 + s⁴/5 + ... + s²⁴/25), summed by Horner's rule. 3. ln x = e ln 2 + ln m, with ln 2 split into a high part whose trailing bits are zero (so e x high is exact) and a low correction, as in fdlibm.

The result is within 2 units in the last place of the true logarithm over the whole positive range (checked against a correctly rounded reference), and bit-identical in all three languages because every step is an IEEE operation performed in the same order. `ln(1)` is exactly 0.

Zero, negative numbers, infinity and NaN are errors.

Sources: W. J. Cody and W. Waite, *Software Manual for the Elementary Functions* (1980); Sun Microsystems fdlibm, `e_log.c` (the ln 2 split).

## Notices

Derived from fdlibm e_log.c. Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. Developed at SunSoft, a Sun Microsystems, Inc. business. Permission to use, copy, modify, and distribute this software is freely granted, provided that this notice is preserved.

The same notice heads each implementation file.

1.0.1 adds its attribution notices (NOTICE). The code is unchanged apart from that notice at the top of each implementation file; the tests are unchanged.

Files