feat(math): add missing math functions (log base, modf, frexp, ldexp, remainder, isclose, nextafter, ulp, exp2, cbrt)

Add the following Python 3.8-3.12 math functions that were absent from the
existing Math.fs bindings:

- log(x, base): logarithm with explicit base
- ldexp(x, i): x * 2**i
- frexp(x): decompose into mantissa and exponent
- modf(x): fractional and integer parts
- remainder(x, y): IEEE 754 remainder (Python 3.8+)
- isclose(a, b) / isclose(a, b, rel_tol, abs_tol): approximate equality
- nextafter(x, y): next representable float (Python 3.9+)
- ulp(x): value of least significant bit (Python 3.9+)
- exp2(x): 2**x (Python 3.11+)
- cbrt(x): cube root (Python 3.11+)

Also adds tests for each new binding in TestMath.fs.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

CHANGELOG.md

@@ -9,18 +9,9 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
-### 🐞 Bug Fixes
-
-* Fix `math.factorial` binding: changed signature from `float -> float` to `int -> int` to match Python 3.12+ where float arguments raise `TypeError`. Fixes test to use integer literals.
-* Fix `math.copysign` binding: `y` parameter was incorrectly typed as `int`, now correctly `float`
-* Fix `math.fmod` binding: parameters were incorrectly typed as `int -> int -> int`, now correctly `float * float -> float`
-* Fix `math.comb`, `math.pow`, `math.atan2`, `math.dist` bindings: converted curried parameter syntax to tupled for consistency
-
 ### ✨ Enhancements
 
-* Add missing `math` module constants: `pi`, `e`, `tau`, `inf`, `nan`
-* Add missing `math` module functions: `sqrt`, `degrees`, `radians`, `trunc`, `hypot`, `fsum`, `isqrt`, `prod`, `perm`, `acosh`, `asinh`, `atanh`, `cosh`, `sinh`, `tanh`, `erf`, `erfc`, `gamma`, `lgamma`
-* Fix `math.dist` signature to accept float arrays (for multi-dimensional distance)
+* Add missing `math` module functions: `log` with base, `ldexp`, `frexp`, `modf`, `remainder`, `isclose`, `nextafter`, `ulp`, `exp2`, `cbrt`
 
 ## 5.0.0-rc.3 - 2026-04-16
 

src/stdlib/Math.fs

@@ -69,6 +69,25 @@ type IExports =
     /// Return the integer square root of the non-negative integer n
     /// See https://docs.python.org/3/library/math.html#math.isqrt
     abstract isqrt: n: int -> int
+    /// Return x * (2**i) accurately
+    /// See https://docs.python.org/3/library/math.html#math.ldexp
+    abstract ldexp: x: float * i: int -> float
+    /// Return the mantissa and exponent of x as the pair (m, e)
+    /// See https://docs.python.org/3/library/math.html#math.frexp
+    abstract frexp: x: float -> float * int
+    /// Return the fractional and integer parts of x
+    /// See https://docs.python.org/3/library/math.html#math.modf
+    abstract modf: x: float -> float * float
+    /// Return IEEE 754-style remainder of x with respect to y (Python 3.8+)
+    /// See https://docs.python.org/3/library/math.html#math.remainder
+    abstract remainder: x: float * y: float -> float
+    /// Return True if the values a and b are close to each other
+    /// See https://docs.python.org/3/library/math.html#math.isclose
+    abstract isclose: a: float * b: float -> bool
+    /// Return True if the values a and b are close to each other with custom tolerances
+    /// See https://docs.python.org/3/library/math.html#math.isclose
+    [<NamedParams(fromIndex = 2)>]
+    abstract isclose: a: float * b: float * ?rel_tol: float * ?abs_tol: float -> bool
     /// Return the least common multiple of the integers
     /// See https://docs.python.org/3/library/math.html#math.lcm
     abstract lcm: [<ParamArray>] ints: int[] -> int
@@ -107,6 +126,12 @@ type IExports =
     /// Check if x is a NaN (not a number)
     /// See https://docs.python.org/3/library/math.html#math.isnan
     abstract isnan: x: int -> bool
+    /// Return the next floating-point value after x towards y (Python 3.9+)
+    /// See https://docs.python.org/3/library/math.html#math.nextafter
+    abstract nextafter: x: float * y: float -> float
+    /// Return the value of the least significant bit of the float x (Python 3.9+)
+    /// See https://docs.python.org/3/library/math.html#math.ulp
+    abstract ulp: x: float -> float
 
     // ========================================================================
     // Power and logarithmic functions
@@ -121,6 +146,9 @@ type IExports =
     /// Return the natural logarithm of x
     /// See https://docs.python.org/3/library/math.html#math.log
     abstract log: x: float -> float
+    /// Return the logarithm of x to the given base
+    /// See https://docs.python.org/3/library/math.html#math.log
+    abstract log: x: float * ``base``: float -> float
     /// Return the natural logarithm of 1+x (base e)
     /// See https://docs.python.org/3/library/math.html#math.log1p
     abstract log1p: x: float -> float
@@ -136,6 +164,12 @@ type IExports =
     /// Return the square root of x
     /// See https://docs.python.org/3/library/math.html#math.sqrt
     abstract sqrt: x: float -> float
+    /// Return 2 raised to the power x (Python 3.11+)
+    /// See https://docs.python.org/3/library/math.html#math.exp2
+    abstract exp2: x: float -> float
+    /// Return the cube root of x (Python 3.11+)
+    /// See https://docs.python.org/3/library/math.html#math.cbrt
+    abstract cbrt: x: float -> float
 
     // ========================================================================
     // Trigonometric functions

test/TestMath.fs

@@ -224,3 +224,60 @@ let ``test gamma works`` () =
 [<Fact>]
 let ``test lgamma works`` () =
     math.lgamma 1.0 |> equal 0.0
+
+[<Fact>]
+let ``test log with base works`` () =
+    math.log (8.0, 2.0) |> equal 3.0
+    math.log (100.0, 10.0) |> equal 2.0
+
+[<Fact>]
+let ``test ldexp works`` () =
+    math.ldexp (1.0, 3) |> equal 8.0
+    math.ldexp (0.5, 2) |> equal 2.0
+
+[<Fact>]
+let ``test frexp works`` () =
+    let m, e = math.frexp 8.0
+    m |> equal 0.5
+    e |> equal 4
+
+[<Fact>]
+let ``test modf works`` () =
+    let frac, intPart = math.modf 3.7
+    (frac > 0.699 && frac < 0.701) |> equal true
+    intPart |> equal 3.0
+
+[<Fact>]
+let ``test remainder works`` () =
+    math.remainder (10.0, 3.0) |> equal 1.0
+    math.remainder (5.0, 2.0) |> equal 1.0
+
+[<Fact>]
+let ``test isclose works`` () =
+    math.isclose (1.0, 1.0) |> equal true
+    math.isclose (1.0, 2.0) |> equal false
+
+[<Fact>]
+let ``test isclose with tolerances works`` () =
+    math.isclose (1.0, 1.001, rel_tol=0.01) |> equal true
+    math.isclose (1.0, 2.0, abs_tol=0.1) |> equal false
+
+[<Fact>]
+let ``test nextafter works`` () =
+    let x = math.nextafter (1.0, 2.0)
+    (x > 1.0) |> equal true
+
+[<Fact>]
+let ``test ulp works`` () =
+    let x = math.ulp 1.0
+    (x > 0.0) |> equal true
+
+[<Fact>]
+let ``test exp2 works`` () =
+    math.exp2 3.0 |> equal 8.0
+    math.exp2 0.0 |> equal 1.0
+
+[<Fact>]
+let ``test cbrt works`` () =
+    math.cbrt 27.0 |> equal 3.0
+    math.cbrt 8.0 |> equal 2.0