February 2026 - cmucl-cvs - mailman3.common-lisp.net

[Git][cmucl/cmucl][issue-425-correctly-rounded-math-functions-single-float] 2 commits: Add tests for %powf based on the tests for %pow
by Raymond Toy (＠rtoy) 19 Feb '26

19 Feb '26

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl Commits: a5f3dc8a by Raymond Toy at 2026-02-18T19:22:08-08:00 Add tests for %powf based on the tests for %pow There are currently many failed tests: (FDLIBM-TESTS::%POWF.CASE.13 FDLIBM-TESTS::%POWF.CASE.12 FDLIBM-TESTS::%POWF.CASE.9 FDLIBM-TESTS::%POWF.CASE.8 FDLIBM-TESTS::%POWF.CASE.5 FDLIBM-TESTS::%POWF.CASE.4 FDLIBM-TESTS::%POWF.CASE.3) - - - - - 59387511 by Raymond Toy at 2026-02-18T19:41:20-08:00 Use single-float versions of qNaN and sNaN In a few places we forgot to use the single-float versions of `*qnan*` and `*snan*`. This fixes many tests, but we still fail (FDLIBM-TESTS::%POWF.CASE.13 FDLIBM-TESTS::%POWF.CASE.12 FDLIBM-TESTS::%POWF.CASE.8 FDLIBM-TESTS::%POWF.CASE.5) These signal division-by-zero instead of silently returning an infinity. - - - - - 1 changed file: - tests/fdlibm.lisp Changes: ===================================== tests/fdlibm.lisp ===================================== @@ -1062,6 +1062,14 @@ (assert-equal 1d0 (kernel:%pow ext:double-float-negative-infinity 0d0))) +(define-test %powf.case.1 + (:tag :fdlibm) + ;; anything ^ 0 is 1 + (assert-equal 1f0 + (kernel:%powf ext:single-float-positive-infinity 0f0)) + (assert-equal 1f0 + (kernel:%powf ext:single-float-negative-infinity 0f0))) + (define-test %pow.case.2 (:tag :fdlibm) ;; anything ^ 1 is itself @@ -1070,6 +1078,14 @@ (assert-equal ext:double-float-negative-infinity (kernel:%pow ext:double-float-negative-infinity 1d0))) +(define-test %powf.case.2 + (:tag :fdlibm) + ;; anything ^ 1 is itself + (assert-equal ext:single-float-positive-infinity + (kernel:%powf ext:single-float-positive-infinity 1f0)) + (assert-equal ext:single-float-negative-infinity + (kernel:%powf ext:single-float-negative-infinity 1f0))) + (define-test %pow.case.3 (:tag :fdlibm) ;; anything ^ NaN is NaN @@ -1078,6 +1094,14 @@ (assert-true (ext:float-nan-p (kernel:%pow ext:double-float-positive-infinity *qnan*)))) +(define-test %powf.case.3 + (:tag :fdlibm) + ;; anything ^ NaN is NaN + (assert-true (ext:float-nan-p + (kernel:%powf (float pi 1f0) *qnan-single-float*))) + (assert-true (ext:float-nan-p + (kernel:%powf ext:single-float-positive-infinity *qnan-single-float*)))) + (define-test %pow.case.4 (:tag :fdlibm) ;; NaN ^ non-zero is NaN @@ -1086,6 +1110,14 @@ (assert-true (ext:float-nan-p (kernel:%pow *qnan* ext:double-float-positive-infinity)))) +(define-test %powf.case.4 + (:tag :fdlibm) + ;; NaN ^ non-zero is NaN + (assert-true (ext:float-nan-p + (kernel:%powf *qnan-single-float* (float pi 1f0)))) + (assert-true (ext:float-nan-p + (kernel:%powf *qnan-single-float* ext:single-float-positive-infinity)))) + (define-test %pow.case.5 (:tag :fdlibm) ;; (|x| > 1) ^ +inf is +inf @@ -1094,6 +1126,14 @@ (assert-equal ext:double-float-positive-infinity (kernel:%pow (- pi) ext:double-float-positive-infinity))) +(define-test %powf.case.5 + (:tag :fdlibm) + ;; (|x| > 1) ^ +inf is +inf + (assert-equal ext:single-float-positive-infinity + (kernel:%powf (float pi 1f0) ext:single-float-positive-infinity)) + (assert-equal ext:single-float-positive-infinity + (kernel:%powf (float (- pi) 1f0) ext:single-float-positive-infinity))) + (define-test %pow.case.6 (:tag :fdlibm) ;; (|x| > 1) ^ -inf is +0 @@ -1102,6 +1142,14 @@ (assert-equal +0d0 (kernel:%pow (- pi) ext:double-float-negative-infinity))) +(define-test %powf.case.6 + (:tag :fdlibm) + ;; (|x| > 1) ^ -inf is +0 + (assert-equal +0f0 + (kernel:%powf (float pi 1f0) ext:single-float-negative-infinity)) + (assert-equal +0f0 + (kernel:%powf (float (- pi) 1f0) ext:single-float-negative-infinity))) + (define-test %pow.case.7 (:tag :fdlibm) ;; (|x| < 1) ^ +inf is +0 @@ -1110,6 +1158,14 @@ (assert-equal +0d0 (kernel:%pow -0.5d0 ext:double-float-positive-infinity))) +(define-test %powf.case.7 + (:tag :fdlibm) + ;; (|x| < 1) ^ +inf is +0 + (assert-equal +0f0 + (kernel:%powf 0.5f0 ext:single-float-positive-infinity)) + (assert-equal +0f0 + (kernel:%powf -0.5f0 ext:single-float-positive-infinity))) + (define-test %pow.case.8 (:tag :fdlibm) ;; (|x| < 1) ^ -inf is +inf @@ -1118,6 +1174,14 @@ (assert-equal ext:double-float-positive-infinity (kernel:%pow -0.5d0 ext:double-float-negative-infinity))) +(define-test %powf.case.8 + (:tag :fdlibm) + ;; (|x| < 1) ^ -inf is +inf + (assert-equal ext:single-float-positive-infinity + (kernel:%powf 0.5f0 ext:single-float-negative-infinity)) + (assert-equal ext:single-float-positive-infinity + (kernel:%powf -0.5f0 ext:single-float-negative-infinity))) + (define-test %pow.case.9 (:tag :fdlibm) ;; std::pow says 1^exp is 1 for any exp, including NaN. (-1)^(+/-inf) @@ -1159,6 +1223,47 @@ (assert-true (ext:float-nan-p (kernel:%pow -1d0 ext:double-float-negative-infinity)))))) +(define-test %powf.case.9 + (:tag :fdlibm) + ;; std::pow says 1^exp is 1 for any exp, including NaN. (-1)^(+/-inf) + ;; is 1. No errors signaled. + #+core-math + (progn + (assert-equal 1f0 + (kernel:%powf 1f0 ext:single-float-positive-infinity)) + (assert-equal 1f0 + (kernel:%powf 1f0 ext:single-float-negative-infinity)) + (assert-equal 1f0 + (kernel:%powf 1f0 *qnan-single-float*)) + (assert-equal 1f0 + (kernel:%powf -1f0 ext:single-float-positive-infinity)) + (assert-equal 1f0 + (kernel:%powf -1f0 ext:single-float-negative-infinity))) + #-core-math + ;; +-1 ^ +-inf is NaN. + ;; + ;; But the implementation signals invalid operation, so we need to + ;; check for that. + ;; + (progn + (assert-error 'floating-point-invalid-operation + (kernel:%powf 1f0 ext:single-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%powf 1f0 ext:single-float-negative-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%powf -1f0 ext:single-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%powf -1f0 ext:single-float-negative-infinity)) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p + (kernel:%powf 1f0 ext:single-float-positive-infinity))) + (assert-true (ext:float-nan-p + (kernel:%powf 1f0 ext:single-float-negative-infinity))) + (assert-true (ext:float-nan-p + (kernel:%powf -1f0 ext:single-float-positive-infinity))) + (assert-true (ext:float-nan-p + (kernel:%powf -1f0 ext:single-float-negative-infinity)))))) + (define-test %pow.case.10 (:tag :fdlibm) ;; +0 ^ (+anything except 0, Nan) is +0 @@ -1167,6 +1272,14 @@ (assert-equal +0d0 (kernel:%pow +0d0 ext:double-float-positive-infinity))) +(define-test %powf.case.10 + (:tag :fdlibm) + ;; +0 ^ (+anything except 0, Nan) is +0 + (assert-equal +0f0 + (kernel:%powf +0f0 10f0)) + (assert-equal +0f0 + (kernel:%powf +0f0 ext:single-float-positive-infinity))) + (define-test %pow.case.11 (:tag :fdlibm) ;; +0 ^ (+anything except 0, Nan, odd integer) is +0 @@ -1175,6 +1288,14 @@ (assert-equal +0d0 (kernel:%pow -0d0 ext:double-float-positive-infinity))) +(define-test %powf.case.11 + (:tag :fdlibm) + ;; +0 ^ (+anything except 0, Nan, odd integer) is +0 + (assert-equal +0f0 + (kernel:%powf -0f0 10f0)) + (assert-equal +0f0 + (kernel:%powf -0f0 ext:single-float-positive-infinity))) + (define-test %pow.case.12 (:tag :fdlibm) ;; +0 ^ (-anything except 0, Nan) is +inf @@ -1189,6 +1310,22 @@ (assert-equal ext:double-float-positive-infinity (kernel:%pow +0d0 ext:double-float-negative-infinity))) +(define-test %powf.case.12 + (:tag :fdlibm) + ;; +0 ^ (-anything except 0, Nan) is +inf + ;; + ;; But fdlibm signals error for (+0)^(-10) instead of returning inf. Check this. + #+nil + (assert-error 'division-by-zero + (kernel:%powf +0f0 -10f0)) + #+nil + (ext:with-float-traps-masked (:divide-by-zero) + (assert-equal ext:single-float-positive-infinity + (kernel:%powf +0f0 -10f0))) + ;; No signals here. + (assert-equal ext:single-float-positive-infinity + (kernel:%powf +0f0 ext:single-float-negative-infinity))) + (define-test %pow.case.13 (:tag :fdlibm) ;; -0 ^ (-anything except 0, Nan, odd integer) is +inf @@ -1203,24 +1340,56 @@ (assert-equal ext:double-float-positive-infinity (kernel:%pow +0d0 ext:double-float-negative-infinity))) +(define-test %powf.case.13 + (:tag :fdlibm) + ;; -0 ^ (-anything except 0, Nan, odd integer) is +inf + ;; + ;; But (-0)^(-10) signals division by zero + (assert-error 'division-by-zero + (kernel:%powf -0f0 -10f0)) + (ext:with-float-traps-masked (:divide-by-zero) + (assert-equal ext:single-float-positive-infinity + (kernel:%powf -0f0 -10f0))) + ;; But no error here. + (assert-equal ext:single-float-positive-infinity + (kernel:%powf +0f0 ext:single-float-negative-infinity))) + (define-test %pow.case.14 (:tag :fdlibm) ;; -0 ^ (odd integer) = -( +0 ^ (odd integer)) (assert-equal (- (kernel:%pow +0d0 5d0)) (kernel:%pow -0d0 5d0))) +(define-test %powf.case.14 + (:tag :fdlibm) + ;; -0 ^ (odd integer) = -( +0 ^ (odd integer)) + (assert-equal (- (kernel:%powf +0f0 5f0)) + (kernel:%powf -0f0 5f0))) + (define-test %pow.case.15 (:tag :fdlibm) ;; +inf ^ (+anything except 0, NaN) is +inf (assert-equal ext:double-float-positive-infinity (kernel:%pow ext:double-float-positive-infinity pi))) +(define-test %powf.case.15 + (:tag :fdlibm) + ;; +inf ^ (+anything except 0, NaN) is +inf + (assert-equal ext:single-float-positive-infinity + (kernel:%powf ext:single-float-positive-infinity (float pi 1f0)))) + (define-test %pow.case.16 (:tag :fdlibm) ;; +inf ^ (-anything except 0, NaN) is +0 (assert-equal +0d0 (kernel:%pow ext:double-float-positive-infinity (- pi)))) +(define-test %powf.case.16 + (:tag :fdlibm) + ;; +inf ^ (-anything except 0, NaN) is +0 + (assert-equal +0f0 + (kernel:%powf ext:single-float-positive-infinity (float (- pi) 1f0)))) + (define-test %pow.case.17 (:tag :fdlibm) ;; -inf ^ (anything) = -0 ^ (-anything) @@ -1232,6 +1401,17 @@ (assert-equal (kernel:%pow -0d0 pi) (kernel:%pow ext:double-float-negative-infinity (- pi)))) +(define-test %powf.case.17 + (:tag :fdlibm) + ;; -inf ^ (anything) = -0 ^ (-anything) + (assert-equal (ext:with-float-traps-masked (:divide-by-zero) + ;; This produces a divide-by-zero error so mask it + ;; to get a value. + (kernel:%powf -0f0 (float (- pi) 1f0))) + (kernel:%powf ext:single-float-negative-infinity (float pi 1f0))) + (assert-equal (kernel:%powf -0f0 (float pi 1f0)) + (kernel:%powf ext:single-float-negative-infinity (float (- pi) 1f0)))) + (define-test %pow.case.18 (:tag :fdlibm) ;; (-anything) ^ integer is (-1)^integer * (+anything ^ integer) @@ -1242,6 +1422,16 @@ (kernel:%pow base (coerce power 'double-float)) base power)))) +(define-test %powf.case.18 + (:tag :fdlibm) + ;; (-anything) ^ integer is (-1)^integer * (+anything ^ integer) + (dolist (base '(-2f0 -10f0)) + (dolist (power '(5 -5)) + (assert-equal (* (expt -1 power) + (kernel:%powf (- base) (coerce power 'single-float))) + (kernel:%powf base (coerce power 'single-float)) + base power)))) + (define-test %pow.case.19 (:tag :fdlibm) ;; (-anything except 0 and inf) ^ non-integer is NaN @@ -1252,3 +1442,14 @@ (ext:with-float-traps-masked (:invalid) (assert-true (ext:float-nan-p (kernel:%pow -2d0 1.5d0))))) + +(define-test %powf.case.19 + (:tag :fdlibm) + ;; (-anything except 0 and inf) ^ non-integer is NaN + ;; + ;; But this signals invalid, so check for that too. + (assert-error 'floating-point-invalid-operation + (kernel:%powf -2f0 1.5f0)) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p + (kernel:%powf -2f0 1.5f0))))) View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/84314210c115db75920939… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/84314210c115db75920939… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][master] Update list of fixed tickets
by Raymond Toy (＠rtoy) 18 Feb '26

18 Feb '26

Raymond Toy pushed to branch master at cmucl / cmucl Commits: 3434a963 by Raymond Toy at 2026-02-18T10:53:11-08:00 Update list of fixed tickets [skip-ci] - - - - - 1 changed file: - src/general-info/release-22a.md Changes: ===================================== src/general-info/release-22a.md ===================================== @@ -28,20 +28,35 @@ public domain. * #373: Add macros to handle temp files and directories * #387: Update CLX from upstream to version from 2024-09-11 * #408: Add C functions to get user name and home dir + * #424: Use fdlibm `hypot` to implement the `hypot` function + instead of using the version from libm. + * #426: Type `float-modes` is incorrect for x87 FPU modes * #428: Add some constants for common values in irrat.lisp + * #431: `set-floating-point-modes` incorrectly clears out x87 + precision and rounding modes * #437: Use `realpath` to find the lisp executable + * #441: Fedora 42 unable to compile core-math pow.c function + * #443: cim-info.tar.bz2 missing from cmucl.org * #444: `unix-stat` and friends return wrong timestamp + * #446: Simplify getting the errno values. * #449: Touch 64-bit timestamp.txt with desired time for testing * #446: Use C compiler to get errno values to update UNIX defpackage with errno symbols + * #452: Move bin/errno-foo.lisp to src/tools. * #453: Use correct flags for analyzer and always save logs. + * #454: `make-pathname` signals errors for "silly" values. * #456: Improve accuracy for division of complex double-floats using Baudin and Smith's robust complex division algorithm with improvements by Patrick McGehearty. - * #458: Spurious overflow in double-double-float multiply - * #459: Improve accuracy for division of complex + * #457: `delete-directory` was not returning anything so you + couldn't tell if it succeeded or not. + * #458: Spurious overflow in double-double-float multiply. + * #459: Improve accuracy for division of complex. double-double-floats. The same algorithm is used here as for #456. + * #460: Unit tests were not being recognized as failing on CI. + * #463: `double-double-float` is missing comparison operations + between `double-double-float` and `double-float` * Other changes: * Improvements to the PCL implementation of CLOS: * Changes to building procedure: View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/3434a96310bce31753072e7… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/3434a96310bce31753072e7… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-425-correctly-rounded-math-functions-single-float] 3 commits: Fix #473: Signal underflow with core-math exp
by Raymond Toy (＠rtoy) 18 Feb '26

18 Feb '26

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl Commits: 9bf28346 by Raymond Toy at 2026-02-18T07:18:07-08:00 Fix #473: Signal underflow with core-math exp - - - - - b26718dd by Raymond Toy at 2026-02-18T07:18:07-08:00 Merge branch 'issue-473-make-cr-exp-signal-underflow' into 'master' Fix #473: Signal underflow with core-math exp Closes #473 See merge request cmucl/cmucl!351 - - - - - 84314210 by Raymond Toy at 2026-02-18T07:19:08-08:00 Merge branch 'master' into issue-425-correctly-rounded-math-functions-single-float - - - - - 0 changed files: Changes: View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/7fa0f3c1b96345e130abba… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/7fa0f3c1b96345e130abba… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][master] 2 commits: Fix #473: Signal underflow with core-math exp
by Raymond Toy (＠rtoy) 18 Feb '26

18 Feb '26

Raymond Toy pushed to branch master at cmucl / cmucl Commits: 9bf28346 by Raymond Toy at 2026-02-18T07:18:07-08:00 Fix #473: Signal underflow with core-math exp - - - - - b26718dd by Raymond Toy at 2026-02-18T07:18:07-08:00 Merge branch 'issue-473-make-cr-exp-signal-underflow' into 'master' Fix #473: Signal underflow with core-math exp Closes #473 See merge request cmucl/cmucl!351 - - - - - 2 changed files: - src/lisp/irrat.c - tests/fdlibm.lisp Changes: ===================================== src/lisp/irrat.c ===================================== @@ -40,7 +40,7 @@ extern void cr_sincos(double, double *, double *); */ #define MAYBE_SIGNAL_INVALID(test, val) \ - if ((test)) { \ + if ((test)) { \ return fdlibm_setexception(val, FDLIBM_INVALID); \ } @@ -197,6 +197,27 @@ double lisp_exp(double x) { #ifdef FEATURE_CORE_MATH + /* + * For consistency, silently return NaN when x is NaN. Do not + * signal an invalid operation, even if invalid operation trap is + * enabled. This is what fdlibm does, and also what many of the + * other core-math routines do. + */ + + if (isnan(x)) { + return x; + } + + /* + * Can't depend on cr_exp to signal underflow. It seems the + * underflow has been constant-folded to zero. Hence, check for + * underflow here and explicitly signal an underflow. The + * constant here is from core-math exp.c. + */ + if (x <= -0x1.74910d52d3052p+9) { + return fdlibm_setexception(0.0, FDLIBM_UNDERFLOW); + } + return cr_exp(x); #else return __ieee754_exp(x); ===================================== tests/fdlibm.lisp ===================================== @@ -210,13 +210,9 @@ (ext:with-float-traps-masked (:overflow) (assert-equal ext:double-float-positive-infinity (kernel:%exp 710d0))) - (let ((modes (ext:get-floating-point-modes))) - (unwind-protect - (progn - (ext:set-floating-point-modes :traps '(:underflow)) - (assert-error 'floating-point-underflow - (kernel:%exp -1000d0))) - (apply #'ext:set-floating-point-modes modes))) + (ext:with-float-traps-enabled (:underflow) + (assert-error 'floating-point-underflow + (kernel:%exp -1000d0))) (let ((x (scale-float 1d0 -29)) (x0 0d0)) ;; exp(x) = x, |x| < 2^-28, with inexact exception unlees x = 0 View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/53a087cadc014ec991da88… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/53a087cadc014ec991da88… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-425-correctly-rounded-math-functions-single-float] 4 commits: Fix #473: Signal underflow with cr_exp
by Raymond Toy (＠rtoy) 18 Feb '26

18 Feb '26

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl Commits: d2210864 by Raymond Toy at 2026-02-16T14:31:08-08:00 Fix #473: Signal underflow with cr_exp Explicitly signal underflow (if enabled) when calling `kernel:%exp` with an arg that would cause exp to underflow. The constant used is taken from the source code for core-math exp.c. Update the in fdlibm to use `with-float-traps-enabled` instead of the weird way we were doing it. - - - - - c84c6c27 by Raymond Toy at 2026-02-16T18:52:48-08:00 Make core-math exp silently return NaN when given NaN This makes exp match what many other core-math routines do with NaN, like log, sin, tan, and sinh, which silently return NaN. This also makes it match what fdlibm does, as mentioned in the comments in e_exp.c. - - - - - 72096452 by Raymond Toy at 2026-02-17T10:51:19-08:00 Merge branch 'master' into issue-473-make-cr-exp-signal-underflow - - - - - 7fa0f3c1 by Raymond Toy at 2026-02-17T19:59:33-08:00 Merge branch 'issue-473-make-cr-exp-signal-underflow' into issue-425-correctly-rounded-math-functions-single-float - - - - - 2 changed files: - src/lisp/irrat.c - tests/fdlibm.lisp Changes: ===================================== src/lisp/irrat.c ===================================== @@ -62,7 +62,7 @@ extern void cr_sincosf(float, float *, float *); */ #define MAYBE_SIGNAL_INVALID(test, val) \ - if ((test)) { \ + if ((test)) { \ return fdlibm_setexception(val, FDLIBM_INVALID); \ } @@ -221,6 +221,27 @@ double lisp_exp(double x) { #ifdef FEATURE_CORE_MATH + /* + * For consistency, silently return NaN when x is NaN. Do not + * signal an invalid operation, even if invalid operation trap is + * enabled. This is what fdlibm does, and also what many of the + * other core-math routines do. + */ + + if (isnan(x)) { + return x; + } + + /* + * Can't depend on cr_exp to signal underflow. It seems the + * underflow has been constant-folded to zero. Hence, check for + * underflow here and explicitly signal an underflow. The + * constant here is from core-math exp.c. + */ + if (x <= -0x1.74910d52d3052p+9) { + return fdlibm_setexception(0.0, FDLIBM_UNDERFLOW); + } + return cr_exp(x); #else return __ieee754_exp(x); ===================================== tests/fdlibm.lisp ===================================== @@ -420,13 +420,9 @@ (ext:with-float-traps-masked (:overflow) (assert-equal ext:double-float-positive-infinity (kernel:%exp 710d0))) - (let ((modes (ext:get-floating-point-modes))) - (unwind-protect - (progn - (ext:set-floating-point-modes :traps '(:underflow)) - (assert-error 'floating-point-underflow - (kernel:%exp -1000d0))) - (apply #'ext:set-floating-point-modes modes))) + (ext:with-float-traps-enabled (:underflow) + (assert-error 'floating-point-underflow + (kernel:%exp -1000d0))) (let ((x (scale-float 1d0 -29)) (x0 0d0)) ;; exp(x) = x, |x| < 2^-28, with inexact exception unlees x = 0 View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/6f4d5ebb83aba92d1cc3b7… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/6f4d5ebb83aba92d1cc3b7… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-425-correctly-rounded-math-functions-single-float] 3 commits: Add tests for %expf based on %exp
by Raymond Toy (＠rtoy) 18 Feb '26

18 Feb '26

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl Commits: 696befd2 by Raymond Toy at 2026-02-17T17:36:10-08:00 Add tests for %expf based on %exp Basic conversion of the tests for %exp. Just needed to adjust some of the limits. And for whatever reason, cr_expf does signal underflow, unlike cr_exp - - - - - 089707d3 by Raymond Toy at 2026-02-17T17:38:51-08:00 Add tests for %logf based on %log Basic conversion of the tests for %exp; nothing special needed. - - - - - 6f4d5ebb by Raymond Toy at 2026-02-17T17:50:41-08:00 Add tests for %acosf, %asinf, %atanf, %log10f Basic translation of existing tests. Nothing special needed. - - - - - 1 changed file: - tests/fdlibm.lisp Changes: ===================================== tests/fdlibm.lisp ===================================== @@ -440,6 +440,39 @@ (assert-error 'floating-point-inexact (kernel:%exp x))))) +(define-test %expf.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-overflow + (kernel:%expf 89f0)) + (assert-true (ext:float-nan-p (kernel:%expf *qnan-single-float*))) + (assert-error 'floating-point-invalid-operation + (kernel:%expf *snan-single-float*)) + (assert-equal ext:single-float-positive-infinity + (kernel:%expf ext:single-float-positive-infinity)) + (assert-equal 0f0 + (kernel:%expf -200f0)) + (ext:with-float-traps-masked (:overflow) + (assert-equal ext:single-float-positive-infinity + (kernel:%expf 89f0))) + (ext:with-float-traps-enabled (:underflow) + (assert-error 'floating-point-underflow + (kernel:%expf -200f0))) + + (let ((x (scale-float 1f0 -13)) + (x0 0f0)) + ;; exp(x) = 1 + x, |x| < 2^-12, with inexact exception unlees x = + ;; 0. The actual threshold is closer to sqrt(2*eps) or about + ;; 2.44e-4, about 2^-12 + (ext:with-float-traps-enabled (:inexact) + ;; This must not throw an inexact exception because the result + ;; is exact when the arg is 0. + (assert-eql 1f0 (kernel:%expf x0))) + (ext:with-float-traps-enabled (:inexact) + ;; This must throw an inexact exception for non-zero x even + ;; though the result is exactly x. + (assert-error 'floating-point-inexact + (kernel:%expf x))))) + (define-test %log.exception (:tag :fdlibm) (assert-error 'division-by-zero @@ -460,6 +493,26 @@ (assert-true (ext:float-nan-p (kernel:%log -1d0))) (assert-true (ext:float-nan-p (kernel:%log *snan*))))) +(define-test %logf.exception + (:tag :fdlibm) + (assert-error 'division-by-zero + (kernel:%logf 0f0)) + (assert-error 'division-by-zero + (kernel:%logf -0f0)) + (assert-error 'floating-point-invalid-operation + (kernel:%logf -1f0)) + (assert-error 'floating-point-invalid-operation + (kernel:%logf *snan-single-float*)) + (assert-true (ext:float-nan-p (kernel:%logf *qnan-single-float*))) + (ext:with-float-traps-masked (:divide-by-zero) + (assert-equal ext:single-float-negative-infinity + (kernel:%logf 0f0)) + (assert-equal ext:single-float-negative-infinity + (kernel:%logf -0f0))) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%logf -1f0))) + (assert-true (ext:float-nan-p (kernel:%logf *snan-single-float*))))) + (define-test %acos.exceptions (:tag :fdlibm) (assert-error 'floating-point-invalid-operation @@ -470,6 +523,16 @@ (assert-true (ext:float-nan-p (kernel:%acos 2d0))) (assert-true (ext:float-nan-p (kernel:%acos -2d0))))) +(define-test %acosf.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-invalid-operation + (kernel:%acosf 2f0)) + (assert-error 'floating-point-invalid-operation + (kernel:%acosf -2f0)) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%acosf 2f0))) + (assert-true (ext:float-nan-p (kernel:%acosf -2f0))))) + (define-test %asin.exceptions (:tag :fdlibm) (assert-error 'floating-point-invalid-operation @@ -480,6 +543,16 @@ (assert-true (ext:float-nan-p (kernel:%asin 2d0))) (assert-true (ext:float-nan-p (kernel:%asin -2d0))))) +(define-test %asinf.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-invalid-operation + (kernel:%asinf 2f0)) + (assert-error 'floating-point-invalid-operation + (kernel:%asinf -2f0)) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%asinf 2f0))) + (assert-true (ext:float-nan-p (kernel:%asinf -2f0))))) + (define-test %atan.exceptions (:tag :fdlibm) (assert-error 'floating-point-invalid-operation @@ -500,6 +573,26 @@ (assert-error 'floating-point-inexact (kernel:%atan x))))) +(define-test %atanf.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-invalid-operation + (kernel:%atanf *snan-single-float*)) + (assert-true (ext:float-nan-p (kernel:%atanf *qnan-single-float*))) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%atanf *snan-single-float*)))) + ;; atan(x) = x for small x, signaling inexact except when x = 0. + (let ((x (scale-float 1f0 -30)) + (x0 0f0)) + (ext:with-float-traps-enabled (:inexact) + ;; This must not throw an inexact exception because the result + ;; is exact when the arg is 0. + (assert-eql 0f0 (kernel:%atanf x0))) + (ext:with-float-traps-enabled (:inexact) + ;; This must throw an inexact exception for non-zero x even + ;; though the result is exactly x. + (assert-error 'floating-point-inexact + (kernel:%atanf x))))) + (define-test %log10.exceptions (:tag :fdlibm) ;; %log10(2^k) = k @@ -521,6 +614,27 @@ (ext:with-float-traps-masked (:invalid) (assert-true (ext:float-nan-p (kernel:%log10 -1d0))))) +(define-test %log10f.exceptions + (:tag :fdlibm) + ;; %log10(2^k) = k + (dotimes (k 23) + (assert-equalp k + (kernel:%log10f (float (expt 10 k) 1f0)))) + (assert-error 'division-by-zero + (kernel:%log10f 0f0)) + (assert-error 'floating-point-invalid-operation + (kernel:%log10f -1f0)) + (assert-true (ext:float-nan-p (kernel:%log10f *qnan-single-float*))) + (assert-equal ext:single-float-positive-infinity + (kernel:%log10f ext:single-float-positive-infinity)) + (ext:with-float-traps-masked (:divide-by-zero) + (assert-equal ext:single-float-negative-infinity + (kernel:%log10f 0f0)) + (assert-equal ext:single-float-negative-infinity + (kernel:%log10f -0f0))) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%log10f -1f0))))) + (define-test %scalbn.exceptions (:tag :fdlibm) (let ((modes (ext:get-floating-point-modes))) View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/2ab4931b78072be1ba6997… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/2ab4931b78072be1ba6997… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-425-correctly-rounded-math-functions-single-float] 3 commits: Add tests for %acoshf and %asinhf based on %acosh and %asinh
by Raymond Toy (＠rtoy) 18 Feb '26

18 Feb '26

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl Commits: b19caf9d by Raymond Toy at 2026-02-17T15:12:47-08:00 Add tests for %acoshf and %asinhf based on %acosh and %asinh Didn't need to do anything really special except the test for inexact can have a smaller value since we only have single-float precision. - - - - - b9039cc2 by Raymond Toy at 2026-02-17T15:15:52-08:00 Add tests for %atanhf based on %atanh Didn't need to do anything really special. - - - - - 2ab4931b by Raymond Toy at 2026-02-17T16:09:27-08:00 Add tests for %expm1f and %log1pf based on %expm1 and %log1p Straightforward update but noticed that expm1 and expm1f were not signaling overflow for +inf. Have the wrappers check for that. Add tests for this. Also, expm1 doesn't seem to signal inexact, but expm1f does. Not sure why. - - - - - 2 changed files: - src/lisp/irrat.c - tests/fdlibm.lisp Changes: ===================================== src/lisp/irrat.c ===================================== @@ -287,6 +287,10 @@ double lisp_expm1(double x) { #ifdef FEATURE_CORE_MATH + if (isinf(x) == 1) { + return fdlibm_setexception(x, FDLIBM_OVERFLOW); + } + return cr_expm1(x); #else return fdlibm_expm1(x); @@ -539,6 +543,10 @@ float lisp_expm1f(float x) { #ifdef FEATURE_CORE_MATH + if (isinf(x) == 1) { + return fdlibm_setexception(x, FDLIBM_OVERFLOW); + } + return cr_expm1f(x); #else return (float) fdlibm_expm1((double) x); ===================================== tests/fdlibm.lisp ===================================== @@ -198,6 +198,18 @@ (ext:with-float-traps-masked (:invalid) (assert-true (ext:float-nan-p (kernel:%acosh 0d0))))) +(define-test %acoshf.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-overflow + (kernel:%acoshf ext:single-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%acoshf 0f0)) + (ext:with-float-traps-masked (:overflow) + (assert-equal ext:single-float-positive-infinity + (kernel:%acoshf ext:single-float-positive-infinity))) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%acoshf 0f0))))) + (define-test %asinh.exceptions (:tag :fdlibm) (assert-error 'floating-point-invalid-operation @@ -219,12 +231,43 @@ (ext:with-float-traps-enabled (:inexact) ;; This must not throw an inexact exception because the result ;; is exact when the arg is 0. - (assert-eql 0d0 (asinh x0))) + (assert-eql 0d0 (kernel:%asinh x0))) (ext:with-float-traps-enabled (:inexact) ;; This must throw an inexact exception for non-zero x even ;; though the result is exactly x. (assert-error 'floating-point-inexact - (asinh x))))) + (kernel:%asinh x))))) + +(define-test %asinh.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-invalid-operation + (kernel:%asinhf *snan-single-float*)) + (assert-error 'floating-point-overflow + (kernel:%asinhf ext:single-float-positive-infinity)) + (assert-error 'floating-point-overflow + (kernel:%asinhf ext:single-float-negative-infinity)) + (assert-true (ext:float-nan-p (kernel:%asinhf *qnan-single-float*))) + (ext:with-float-traps-masked (:overflow) + (assert-equal ext:single-float-positive-infinity + (kernel:%asinhf ext:single-float-positive-infinity)) + (assert-error ext:single-float-negative-infinity + (kernel:%asinhf ext:single-float-negative-infinity))) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%asinhf *snan-single-float*)))) + ;; asinh(x) = x - x^3/6 + o(x^5). For small enough x, asinh(x) = x + ;; but we should signal inexact for those cases, except for when x = + ;; 0. The threshold is approximately 2^-17. + (let ((x (scale-float 1f0 -17)) + (x0 0f0)) + (ext:with-float-traps-enabled (:inexact) + ;; This must not throw an inexact exception because the result + ;; is exact when the arg is 0. + (assert-eql 0f0 (kernel:%asinhf x0))) + (ext:with-float-traps-enabled (:inexact) + ;; This must throw an inexact exception for non-zero x even + ;; though the result is exactly x. + (assert-error 'floating-point-inexact + (kernel:%asinhf x))))) (define-test %atanh.exceptions (:tag :fdlibm) @@ -245,11 +288,30 @@ (assert-equal ext:double-float-negative-infinity (kernel:%atanh -1d0)))) +(define-test %atanh.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-invalid-operation + (kernel:%atanhf 2f0)) + (assert-error 'floating-point-invalid-operation + (kernel:%atanhf -2f0)) + (assert-error 'division-by-zero + (kernel:%atanhf 1f0)) + (assert-error 'division-by-zero + (kernel:%atanhf -1f0)) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%atanhf 2f0))) + (assert-true (ext:float-nan-p (kernel:%atanhf -2f0)))) + (ext:with-float-traps-masked (:divide-by-zero) + (assert-equal ext:single-float-positive-infinity + (kernel:%atanhf 1f0)) + (assert-equal ext:single-float-negative-infinity + (kernel:%atanhf -1f0)))) + (define-test %expm1.exceptions (:tag :fdlibm) (assert-error 'floating-point-overflow (kernel:%expm1 709.8d0)) - (assert-equal ext:double-float-positive-infinity + (assert-error 'floating-point-overflow (kernel:%expm1 ext:double-float-positive-infinity)) (assert-error 'floating-point-invalid-operation (kernel:%expm1 *snan*)) @@ -260,13 +322,36 @@ ) (ext:with-float-traps-masked (:invalid) (assert-true (ext::float-nan-p (kernel:%expm1 *snan*)))) - ;; expm1(x) = -1 for x < -56*log(2), signaling inexact + ;; expm1(x) = -1 for x < -56*log(2), signaling inexact. #-core-math (let ((x (* -57 (log 2d0)))) (ext:with-float-traps-enabled (:inexact) (assert-error 'floating-point-inexact (kernel:%expm1 x))))) +(define-test %expm1f.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-overflow + (kernel:%expm1f 709.8f0)) + (assert-error 'floating-point-overflow + (kernel:%expm1f ext:single-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%expm1f *snan-single-float*)) + (assert-true (ext:float-nan-p (kernel:%expm1f *qnan-single-float*))) + (ext:with-float-traps-masked (:overflow) + (assert-equal ext:single-float-positive-infinity + (kernel:%expm1f 709.8f0)) + ) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext::float-nan-p (kernel:%expm1f *snan-single-float*)))) + ;; expm1(x) = -1 for negative enough x. When x = -26*log(2), exp(x) + ;; is about 1.49e-8, which is smaller than single-float-epsilon so + ;; expm1(x) = -1. + (let ((x (log (scale-float 1f0 -26)))) + (ext:with-float-traps-enabled (:inexact) + (assert-error 'floating-point-inexact + (kernel:%expm1f x))))) + (define-test %log1p.exceptions (:tag :fdlibm) (assert-error 'floating-point-invalid-operation @@ -294,6 +379,33 @@ (assert-error 'floating-point-inexact (kernel:%log1p x))))) +(define-test %log1pf.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-invalid-operation + (kernel:%log1pf -2f0)) + (assert-error #-core-math 'floating-point-overflow + #+core-math 'division-by-zero + (kernel:%log1pf -1f0)) + (assert-true (ext:float-nan-p (kernel:%log1pf *qnan-single-float*))) + (ext:with-float-traps-masked (#-core-math :overflow + #+core-math :divide-by-zero) + (assert-equal ext:single-float-negative-infinity + (kernel:%log1pf -1f0))) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%log1pf *snan-single-float*)))) + ;; log1p(x) = x for |x| < 2^-54, signaling inexact except for x = 0. + (let ((x (scale-float 1f0 -55)) + (x0 0f0)) + (ext:with-float-traps-enabled (:inexact) + ;; This must not throw an inexact exception because the result + ;; is exact when the arg is 0. + (assert-eql 0f0 (kernel:%log1pf x0))) + (ext:with-float-traps-enabled (:inexact) + ;; This must throw an inexact exception for non-zero x even + ;; though the result is exactly x. + (assert-error 'floating-point-inexact + (kernel:%log1pf x))))) + (define-test %exp.exceptions (:tag :fdlibm) (assert-error 'floating-point-overflow View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/c916a9f722169965a54544… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/c916a9f722169965a54544… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-425-correctly-rounded-math-functions-single-float] 3 commits: Add tests for %sinhf, based on %sinh
by Raymond Toy (＠rtoy) 17 Feb '26

17 Feb '26

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl Commits: 18826ba4 by Raymond Toy at 2026-02-17T14:39:50-08:00 Add tests for %sinhf, based on %sinh - - - - - 11aada66 by Raymond Toy at 2026-02-17T14:45:19-08:00 Add tests for %sinhf based on %sinh Didn't need to do anything really special except the test for inexact can have a larger value since we only have single-float precision. - - - - - c916a9f7 by Raymond Toy at 2026-02-17T14:59:29-08:00 Add tests for %tanhf based on tanh Didn't need to do anything really special except the test for inexact can have a smaller value since we only have single-float precision. - - - - - 1 changed file: - tests/fdlibm.lisp Changes: ===================================== tests/fdlibm.lisp ===================================== @@ -115,6 +115,45 @@ (assert-error 'floating-point-inexact (kernel:%sinh x))))) +(define-test %sinhf.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-overflow + (kernel:%sinhf 100f0)) + (assert-error 'floating-point-overflow + (kernel:%sinhf -100f0)) + (assert-error 'floating-point-invalid-operation + (kernel:%sinhf *snan-single-float*)) + (assert-true (ext:float-nan-p (kernel:%sinhf *qnan-single-float*))) + + ;; Same, but with overflow's masked + (ext:with-float-traps-masked (:overflow) + (assert-equal ext:single-float-positive-infinity + (kernel:%sinhf 100f0)) + (assert-equal ext:single-float-negative-infinity + (kernel:%sinhf -100f0)) + (assert-equal ext:single-float-positive-infinity + (kernel:%sinhf ext:single-float-positive-infinity)) + (assert-equal ext:single-float-negative-infinity + (kernel:%sinhf ext:single-float-negative-infinity))) + ;; Test NaN + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%sinhf *qnan-single-float*)))) + ;; sinh(x) = x + x^3/6 + o(x^3). Thus, if |x| < 2^-17, sinh(x) = x, + ;; but we should signal inexact except if x is 0. We're not trying + ;; to get the exact value where sinh(x) = x. Just something + ;; obviously small enough. + (let ((x (scale-float 1f0 -29)) + (x0 0f0)) + (ext:with-float-traps-enabled (:inexact) + ;; This must not throw an inexact exception because the result + ;; is exact when the arg is 0. + (assert-eql 0f0 (kernel:%sinhf x0))) + (ext:with-float-traps-enabled (:inexact) + ;; This must throw an inexact exception for non-zero x even + ;; though the result is exactly x. + (assert-error 'floating-point-inexact + (kernel:%sinhf x))))) + (define-test %tanh.exceptions (:tag :fdlibm) (assert-true (ext:float-nan-p (kernel:%tanh *qnan*))) @@ -130,6 +169,23 @@ (assert-error 'floating-point-inexact (kernel:%tanh x))))) +(define-test %tanhf.exceptions + (:tag :fdlibm) + (assert-true (ext:float-nan-p (kernel:%tanhf *qnan-single-float*))) + (assert-error 'floating-point-invalid-operation + (kernel:%tanhf *snan-single-float*)) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%tanhf *snan-single-float*)))) + ;; tanhf(x) = +/- 1 for |x| > 9.1, raising inexact, always. The + ;; exact value from cr_tanhf appears to be 0x41102cb3u. That is + ;; 9.010913. + (let ((x 9.1f0)) + (ext:with-float-traps-enabled (:inexact) + ;; This must throw an inexact exception for non-zero x even + ;; though the result is exactly x. + (assert-error 'floating-point-inexact + (kernel:%tanhf x))))) + (define-test %acosh.exceptions (:tag :fdlibm) (assert-error 'floating-point-overflow View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/3e89a81cdee2de0d0f444d… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/3e89a81cdee2de0d0f444d… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-425-correctly-rounded-math-functions-single-float] 2 commits: Signal errors for singles as we do for double. Add tests for coshf
by Raymond Toy (＠rtoy) 17 Feb '26

17 Feb '26

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl Commits: 31c76e8b by Raymond Toy at 2026-02-17T14:21:27-08:00 Signal errors for singles as we do for double. Add tests for coshf For the the single-float core-math routines, add the corresponding error checks that we do for double-floats. Add tests for these exceptional cases for coshf, based on the same tests for cosh. Curiously, cr_cosh(inf) silently returns inf but cr_coshf(inf) signals a division by 0. So make this consistent by checking for infinity values and signaling an error if enabled. - - - - - 3e89a81c by Raymond Toy at 2026-02-17T14:29:31-08:00 cosh(+/-inf) = +inf if overflow is disabled. We accidentally returned -inf for cosh(-inf). Of course, it should be +inf. Update irrat.c for this and add tests for this too. ( - - - - - 2 changed files: - src/lisp/irrat.c - tests/fdlibm.lisp Changes: ===================================== src/lisp/irrat.c ===================================== @@ -163,6 +163,8 @@ double lisp_cosh(double x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_OVERFLOW(fabs(x)) + return cr_cosh(x); #else return __ieee754_cosh(x); @@ -319,6 +321,8 @@ float lisp_sinf(float x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_INVALID(isinf(x), x) + return cr_sinf(x); #else return (float) fdlibm_sin((double) x); @@ -329,6 +333,8 @@ float lisp_cosf(float x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_INVALID(isinf(x), x) + return cr_cosf(x); #else return (float) fdlibm_cos((double) x); @@ -339,6 +345,8 @@ float lisp_tanf(float x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_INVALID(isinf(x), x) + return cr_tanf(x); #else return (float) fdlibm_tan((double) x); @@ -389,6 +397,8 @@ float lisp_sinhf(float x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_OVERFLOW(x) + return cr_sinhf(x); #else return (float) __ieee754_sinh((double) x); @@ -399,6 +409,8 @@ float lisp_coshf(float x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_OVERFLOW(fabs(x)) + return cr_coshf(x); #else return (float) __ieee754_cosh((double) x); @@ -419,6 +431,8 @@ float lisp_asinhf(float x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_OVERFLOW(x) + return cr_asinhf(x); #else return (float) fdlibm_asinh((double) x); @@ -429,6 +443,10 @@ float lisp_acoshf(float x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_INVALID(x < 1, x) + + MAYBE_SIGNAL_OVERFLOW(x) + return cr_acoshf(x); #else return (float) __ieee754_acosh((double) x); ===================================== tests/fdlibm.lisp ===================================== @@ -8,14 +8,23 @@ (defparameter *qnan* (ext:with-float-traps-masked (:invalid) (* 0 ext:double-float-positive-infinity)) - "Some randon quiet MaN value") + "Some randon quiet double-float MaN value") + +(defparameter *qnan-single-float* + (ext:with-float-traps-masked (:invalid) + (* 0 ext:single-float-positive-infinity)) + "Some randon quiet single-float MaN value") (defparameter *snan* (kernel:make-double-float #x7ff00000 1) - "A randon signaling MaN value") + "A randon signaling double-float MaN value") + +(defparameter *snan-single-float* + (kernel:make-single-float #x7f800001) + "A randon signaling single-float MaN value") (define-test %cosh.exceptions - (:tag :fdlibm) + (:tag :fdlibm) (assert-error 'floating-point-overflow (kernel:%cosh 1000d0)) (assert-error 'floating-point-overflow @@ -23,6 +32,10 @@ (assert-error 'floating-point-invalid-operation (kernel:%cosh *snan*)) (assert-true (ext:float-nan-p (kernel:%cosh *qnan*))) + (assert-error 'floating-point-overflow + (kernel:%cosh ext:double-float-positive-infinity)) + (assert-error 'floating-point-overflow + (kernel:%cosh ext:double-float-negative-infinity)) ;; Same, but with overflow's masked (ext:with-float-traps-masked (:overflow) @@ -38,6 +51,34 @@ (ext:with-float-traps-masked (:invalid) (assert-true (ext:float-nan-p (kernel:%cosh *snan*))))) +(define-test %coshf.exceptions + (:tag :fdlibm) + (assert-error 'floating-point-overflow + (kernel:%coshf 100f0)) + (assert-error 'floating-point-overflow + (kernel:%coshf -100f0)) + (assert-error 'floating-point-invalid-operation + (kernel:%coshf *snan-single-float*)) + (assert-true (ext:float-nan-p (kernel:%coshf *qnan-single-float*))) + (assert-error 'floating-point-overflow + (kernel:%coshf ext:single-float-positive-infinity)) + (assert-error 'floating-point-overflow + (kernel:%coshf ext:single-float-negative-infinity)) + + ;; Same, but with overflow's masked + (ext:with-float-traps-masked (:overflow) + (assert-equal ext:single-float-positive-infinity + (kernel:%coshf 100f0)) + (assert-equal ext:single-float-positive-infinity + (kernel:%coshf -100f0)) + (assert-equal ext:single-float-positive-infinity + (kernel:%coshf ext:single-float-positive-infinity)) + (assert-equal ext:single-float-positive-infinity + (kernel:%coshf ext:single-float-negative-infinity))) + ;; Test NaN + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%coshf *snan-single-float*))))) + (define-test %sinh.exceptions (:tag :fdlibm) (assert-error 'floating-point-overflow @@ -47,6 +88,7 @@ (assert-error 'floating-point-invalid-operation (kernel:%sinh *snan*)) (assert-true (ext:float-nan-p (kernel:%sinh *qnan*))) + ;; Same, but with overflow's masked (ext:with-float-traps-masked (:overflow) (assert-equal ext:double-float-positive-infinity View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/70bd3787f0128805658e83… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/70bd3787f0128805658e83… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-425-correctly-rounded-math-functions-single-float] 13 commits: Fix #470: Fix unit test issues on Ubuntu CI
by Raymond Toy (＠rtoy) 17 Feb '26

17 Feb '26

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl Commits: f5a798b8 by Raymond Toy at 2026-02-05T17:51:48-08:00 Fix #470: Fix unit test issues on Ubuntu CI - - - - - 5b6d4d73 by Raymond Toy at 2026-02-05T17:51:48-08:00 Merge branch 'issue-470-ubuntu-ci-failures' into 'master' Fix #470: Fix unit test issues on Ubuntu CI Closes #470 See merge request cmucl/cmucl!348 - - - - - 772641b9 by Raymond Toy at 2026-02-05T19:39:14-08:00 Fix #469: Reenable cr_pow - - - - - 6ac1b6b4 by Raymond Toy at 2026-02-05T19:39:14-08:00 Merge branch 'issue-469-enable-cr-pow' into 'master' Fix #469: Reenable cr_pow Closes #469 and #470 See merge request cmucl/cmucl!346 - - - - - 9dec6e71 by Raymond Toy at 2026-02-16T07:40:15-08:00 Fix #468: Make core-math signal the same errors as fdlibm - - - - - ec7e3a25 by Raymond Toy at 2026-02-16T07:40:15-08:00 Merge branch 'issue-468-core-math-signals' into 'master' Fix #468: Make core-math signal the same errors as fdlibm Closes #468, #426, and #425 See merge request cmucl/cmucl!347 - - - - - 6494ef48 by Raymond Toy at 2026-02-16T07:44:39-08:00 Fix #471: Add tests for kernel:%pow - - - - - 69923013 by Raymond Toy at 2026-02-16T07:44:39-08:00 Merge branch 'issue-471-test-cases-for-pow' into 'master' Fix #471: Add tests for kernel:%pow Closes #471 See merge request cmucl/cmucl!349 - - - - - 98e777af by Raymond Toy at 2026-02-17T09:51:43-08:00 Merge branch 'master' into issue-425-correctly-rounded-math-functions-single-float - - - - - 1c92a62c by Raymond Toy at 2026-02-17T10:47:23-08:00 Fix #472: Ansi-tests test.log not found - - - - - 53a087ca by Raymond Toy at 2026-02-17T10:47:23-08:00 Merge branch 'issue-472-ansi-tests-test-log-not-found' into 'master' Fix #472: Ansi-tests test.log not found Closes #472 See merge request cmucl/cmucl!350 - - - - - 4a6755a1 by Raymond Toy at 2026-02-17T10:50:03-08:00 Use core-math powf in lisp_powf We can use core-math powf in lisp_powf since we've worked out the issues with core-math pow in lisp_pow. - - - - - 70bd3787 by Raymond Toy at 2026-02-17T13:34:41-08:00 Merge branch 'master' into issue-425-correctly-rounded-math-functions-single-float - - - - - 6 changed files: - .gitlab-ci.yml - bin/run-unit-tests.sh - src/lisp/irrat.c - tests/fdlibm.lisp - tests/issues.lisp - + tests/test-run-prog/ls-link Changes: ===================================== .gitlab-ci.yml ===================================== @@ -70,16 +70,16 @@ variables: stage: ansi-test artifacts: paths: - - ansi-test/test.out + - ansi-test.out script: - bin/run-ansi-tests.sh -l dist/bin/lisp - + - cp ../ansi-test/test.out ansi-test.out + # Default configuration for running unit tests. .unit_test_template: &unit_test_configuration stage: test artifacts: paths: - - ansi-test/test.out - test.log script: - echo LANG = $LANG @@ -147,7 +147,9 @@ linux:build: - job: linux:install artifacts: true variables: - CONFIG: "x86_linux_clang" + # Fedora 41 must build with gcc because the clang build fails some + # ansi-tests. See [#469]. + CONFIG: "x86_linux" # These rules is needed so that the static analyzer job can run on a # schedule because this is a prerequisite of the analyzer build. A # regular push or merge request does the normal stuff. @@ -171,7 +173,7 @@ linux:cross-build: - linux-4/lisp variables: # This must match the config used for the linux build! - CONFIG: "x86_linux_clang" + CONFIG: "x86_linux" needs: @@ -346,7 +348,10 @@ ubuntu:build: - job: ubuntu:install artifacts: true variables: - CONFIG: "x86_linux_clang" + # Build with gcc on Ubuntu 25.10. It produces a lisp than passes + # the ansi-tests. Clang seems to fail the ansi-tests WRITE.1, + # PRINT.1, and friends when cr_pow is used. + CONFIG: "x86_linux" ubuntu:test: <<: *unit_test_configuration ===================================== bin/run-unit-tests.sh ===================================== @@ -42,9 +42,9 @@ done shift $((OPTIND - 1)) # Create the test directory needed by the issue.45 test. -rm -rf test-tmp -mkdir test-tmp -ln -s /bin/ls test-tmp/ls-link +#rm -rf test-tmp +#mkdir test-tmp +#ln -s /bin/ls test-tmp/ls-link # Set the timestamps on 64-bit-timestamp-2038.txt and # 64-bit-timestamp-2106.txt, but only for OSes where we know this @@ -56,8 +56,9 @@ ln -s /bin/ls test-tmp/ls-link # tests/os.lisp. case `uname -s` in Linux) - touch -d "1 April 2038" tests/resources/64-bit-timestamp-2038.txt - touch -d "1 April 2106" tests/resources/64-bit-timestamp-2106.txt + # -t format is [[CC]YY]MMDDhhmm[.ss] + touch -t 203804010000 tests/resources/64-bit-timestamp-2038.txt + touch -t 210604010000 tests/resources/64-bit-timestamp-2106.txt ;; esac ===================================== src/lisp/irrat.c ===================================== @@ -61,10 +61,22 @@ extern void cr_sincosf(float, float *, float *); * Wrappers for the special functions */ +#define MAYBE_SIGNAL_INVALID(test, val) \ + if ((test)) { \ + return fdlibm_setexception(val, FDLIBM_INVALID); \ + } + +#define MAYBE_SIGNAL_OVERFLOW(x) \ + if (isinf(x)) { \ + return fdlibm_setexception(x, FDLIBM_OVERFLOW); \ + } + double lisp_sin(double x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_INVALID(isinf(x), x) + return cr_sin(x); #else return fdlibm_sin(x); @@ -75,6 +87,8 @@ double lisp_cos(double x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_INVALID(isinf(x), x) + return cr_cos(x); #else return fdlibm_cos(x); @@ -85,6 +99,8 @@ double lisp_tan(double x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_INVALID(isinf(x), x) + return cr_tan(x); #else return fdlibm_tan(x); @@ -135,6 +151,8 @@ double lisp_sinh(double x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_OVERFLOW(x) + return cr_sinh(x); #else return __ieee754_sinh(x); @@ -165,6 +183,8 @@ double lisp_asinh(double x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_OVERFLOW(x) + return cr_asinh(x); #else return fdlibm_asinh(x); @@ -175,6 +195,10 @@ double lisp_acosh(double x) { #ifdef FEATURE_CORE_MATH + MAYBE_SIGNAL_INVALID(x < 1, x) + + MAYBE_SIGNAL_OVERFLOW(x) + return cr_acosh(x); #else return __ieee754_acosh(x); @@ -224,13 +248,17 @@ lisp_log10(double x) double lisp_pow(double x, double y) { +#ifdef FEATURE_CORE_MATH /* - * cr_pow seems causes ansi-tests to fail in test WRITE.1 among - * others. Somewhere an invalid operation is occurring. Thus - * just use fdlibm for now until we can figure out what's causing - * the failure. + * cr_pow when compiled with older versions of gcc or clang can + * cause failures in the ansi-tests [#469]. Ubuntu 25.10 and Fedora 41 + * (gcc only) are known to have compilers that work well enough + * that the ansi-tests pass. */ + return cr_pow(x, y); +#else return __ieee754_pow(x, y); +#endif } double @@ -448,8 +476,17 @@ lisp_log10f(float x) } float -lisp_powf(double x, double y) +lisp_powf(float x, float y) { +#ifdef FEATURE_CORE_MATH + /* + * cr_pow when compiled with older versions of gcc or clang can + * cause failures in the ansi-tests [#469]. Ubuntu 25.10 and Fedora 41 + * (gcc only) are known to have compilers that work well enough + * that the ansi-tests pass. + */ + return cr_powf(x, y); +#else /* * cr_pow seems causes ansi-tests to fail in test WRITE.1 among * others. Somewhere an invalid operation is occurring. Thus @@ -457,6 +494,7 @@ lisp_powf(double x, double y) * the failure. */ return (float) __ieee754_pow((double) x, (double) y); +#endif } float ===================================== tests/fdlibm.lisp ===================================== @@ -90,12 +90,8 @@ (define-test %acosh.exceptions (:tag :fdlibm) - ;; Core-math returns infinity instead of signaling overflow. - #-core-math (assert-error 'floating-point-overflow (kernel:%acosh ext:double-float-positive-infinity)) - ;; Core-math currently returns QNaN - #-core-math (assert-error 'floating-point-invalid-operation (kernel:%acosh 0d0)) (ext:with-float-traps-masked (:overflow) @@ -108,12 +104,8 @@ (:tag :fdlibm) (assert-error 'floating-point-invalid-operation (kernel:%asinh *snan*)) - ;; Core-math returns the signed infinity instead of signaling an - ;; overflow. - #-core-math (assert-error 'floating-point-overflow (kernel:%asinh ext:double-float-positive-infinity)) - #-core-math (assert-error 'floating-point-overflow (kernel:%asinh ext:double-float-negative-infinity)) (assert-true (ext:float-nan-p (kernel:%asinh *qnan*))) @@ -218,7 +210,6 @@ (ext:with-float-traps-masked (:overflow) (assert-equal ext:double-float-positive-infinity (kernel:%exp 710d0))) - #-core-math (let ((modes (ext:get-floating-point-modes))) (unwind-protect (progn @@ -675,6 +666,14 @@ (define-test %cos.exceptions (:tag :fdlibm) + ;; cos(inf) signals invalid operation + (assert-error 'floating-point-invalid-operation + (kernel:%cos ext:double-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%cos ext:double-float-negative-infinity)) + ;; cos(nan) is NaN + (assert-true (ext:float-nan-p (kernel:%cos *qnan*))) + ;; cos(x) = 1 for |x| < 2^-27. Signal inexact unless x = 0 (let ((x (scale-float 1d0 -28)) (x0 0d0)) @@ -690,6 +689,14 @@ (define-test %sin.exceptions (:tag :fdlibm) + ;; sin(inf) signals invalid operation + (assert-error 'floating-point-invalid-operation + (kernel:%sin ext:double-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%sin ext:double-float-negative-infinity)) + ;; sin(nan) is NaN + (assert-true (ext:float-nan-p (kernel:%sin *qnan*))) + ;; sin(x) = x for |x| < 2^-27. Signal inexact unless x = 0 (let ((x (scale-float 1d0 -28)) (x0 0d0)) @@ -705,6 +712,14 @@ (define-test %tan.exceptions (:tag :fdlibm) + ;; tan(inf) signals invalid operation + (assert-error 'floating-point-invalid-operation + (kernel:%tan ext:double-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%tan ext:double-float-negative-infinity)) + ;; tan(nan) is NaN + (assert-true (ext:float-nan-p (kernel:%sin *qnan*))) + ;; tan(x) = x for |x| < 2^-28. Signal inexact unless x = 0 (let ((x (scale-float 1d0 -29)) (x0 0d0)) @@ -717,3 +732,203 @@ ;; though the result is exactly x. (assert-error 'floating-point-inexact (kernel:%tan x))))) + +;; Test cases from e_pow.c for fdlibm. +(define-test %pow.case.1 + (:tag :fdlibm) + ;; anything ^ 0 is 1 + (assert-equal 1d0 + (kernel:%pow ext:double-float-positive-infinity 0d0)) + (assert-equal 1d0 + (kernel:%pow ext:double-float-negative-infinity 0d0))) + +(define-test %pow.case.2 + (:tag :fdlibm) + ;; anything ^ 1 is itself + (assert-equal ext:double-float-positive-infinity + (kernel:%pow ext:double-float-positive-infinity 1d0)) + (assert-equal ext:double-float-negative-infinity + (kernel:%pow ext:double-float-negative-infinity 1d0))) + +(define-test %pow.case.3 + (:tag :fdlibm) + ;; anything ^ NaN is NaN + (assert-true (ext:float-nan-p + (kernel:%pow pi *qnan*))) + (assert-true (ext:float-nan-p + (kernel:%pow ext:double-float-positive-infinity *qnan*)))) + +(define-test %pow.case.4 + (:tag :fdlibm) + ;; NaN ^ non-zero is NaN + (assert-true (ext:float-nan-p + (kernel:%pow *qnan* pi))) + (assert-true (ext:float-nan-p + (kernel:%pow *qnan* ext:double-float-positive-infinity)))) + +(define-test %pow.case.5 + (:tag :fdlibm) + ;; (|x| > 1) ^ +inf is +inf + (assert-equal ext:double-float-positive-infinity + (kernel:%pow pi ext:double-float-positive-infinity)) + (assert-equal ext:double-float-positive-infinity + (kernel:%pow (- pi) ext:double-float-positive-infinity))) + +(define-test %pow.case.6 + (:tag :fdlibm) + ;; (|x| > 1) ^ -inf is +0 + (assert-equal +0d0 + (kernel:%pow pi ext:double-float-negative-infinity)) + (assert-equal +0d0 + (kernel:%pow (- pi) ext:double-float-negative-infinity))) + +(define-test %pow.case.7 + (:tag :fdlibm) + ;; (|x| < 1) ^ +inf is +0 + (assert-equal +0d0 + (kernel:%pow 0.5d0 ext:double-float-positive-infinity)) + (assert-equal +0d0 + (kernel:%pow -0.5d0 ext:double-float-positive-infinity))) + +(define-test %pow.case.8 + (:tag :fdlibm) + ;; (|x| < 1) ^ -inf is +inf + (assert-equal ext:double-float-positive-infinity + (kernel:%pow 0.5d0 ext:double-float-negative-infinity)) + (assert-equal ext:double-float-positive-infinity + (kernel:%pow -0.5d0 ext:double-float-negative-infinity))) + +(define-test %pow.case.9 + (:tag :fdlibm) + ;; std::pow says 1^exp is 1 for any exp, including NaN. (-1)^(+/-inf) + ;; is 1. No errors signaled. + #+core-math + (progn + (assert-equal 1d0 + (kernel:%pow 1d0 ext:double-float-positive-infinity)) + (assert-equal 1d0 + (kernel:%pow 1d0 ext:double-float-negative-infinity)) + (assert-equal 1d0 + (kernel:%pow 1d0 *qnan*)) + (assert-equal 1d0 + (kernel:%pow -1d0 ext:double-float-positive-infinity)) + (assert-equal 1d0 + (kernel:%pow -1d0 ext:double-float-negative-infinity))) + #-core-math + ;; +-1 ^ +-inf is NaN. + ;; + ;; But the implementation signals invalid operation, so we need to + ;; check for that. + ;; + (progn + (assert-error 'floating-point-invalid-operation + (kernel:%pow 1d0 ext:double-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%pow 1d0 ext:double-float-negative-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%pow -1d0 ext:double-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation + (kernel:%pow -1d0 ext:double-float-negative-infinity)) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p + (kernel:%pow 1d0 ext:double-float-positive-infinity))) + (assert-true (ext:float-nan-p + (kernel:%pow 1d0 ext:double-float-negative-infinity))) + (assert-true (ext:float-nan-p + (kernel:%pow -1d0 ext:double-float-positive-infinity))) + (assert-true (ext:float-nan-p + (kernel:%pow -1d0 ext:double-float-negative-infinity)))))) + +(define-test %pow.case.10 + (:tag :fdlibm) + ;; +0 ^ (+anything except 0, Nan) is +0 + (assert-equal +0d0 + (kernel:%pow +0d0 10d0)) + (assert-equal +0d0 + (kernel:%pow +0d0 ext:double-float-positive-infinity))) + +(define-test %pow.case.11 + (:tag :fdlibm) + ;; +0 ^ (+anything except 0, Nan, odd integer) is +0 + (assert-equal +0d0 + (kernel:%pow -0d0 10d0)) + (assert-equal +0d0 + (kernel:%pow -0d0 ext:double-float-positive-infinity))) + +(define-test %pow.case.12 + (:tag :fdlibm) + ;; +0 ^ (-anything except 0, Nan) is +inf + ;; + ;; But fdlibm signals error for (+0)^(-10) instead of returning inf. Check this. + (assert-error 'division-by-zero + (kernel:%pow +0d0 -10d0)) + (ext:with-float-traps-masked (:divide-by-zero) + (assert-equal ext:double-float-positive-infinity + (kernel:%pow +0d0 -10d0))) + ;; No signals here. + (assert-equal ext:double-float-positive-infinity + (kernel:%pow +0d0 ext:double-float-negative-infinity))) + +(define-test %pow.case.13 + (:tag :fdlibm) + ;; -0 ^ (-anything except 0, Nan, odd integer) is +inf + ;; + ;; But (-0)^(-10) signals division by zero + (assert-error 'division-by-zero + (kernel:%pow -0d0 -10d0)) + (ext:with-float-traps-masked (:divide-by-zero) + (assert-equal ext:double-float-positive-infinity + (kernel:%pow -0d0 -10d0))) + ;; But no error here. + (assert-equal ext:double-float-positive-infinity + (kernel:%pow +0d0 ext:double-float-negative-infinity))) + +(define-test %pow.case.14 + (:tag :fdlibm) + ;; -0 ^ (odd integer) = -( +0 ^ (odd integer)) + (assert-equal (- (kernel:%pow +0d0 5d0)) + (kernel:%pow -0d0 5d0))) + +(define-test %pow.case.15 + (:tag :fdlibm) + ;; +inf ^ (+anything except 0, NaN) is +inf + (assert-equal ext:double-float-positive-infinity + (kernel:%pow ext:double-float-positive-infinity pi))) + +(define-test %pow.case.16 + (:tag :fdlibm) + ;; +inf ^ (-anything except 0, NaN) is +0 + (assert-equal +0d0 + (kernel:%pow ext:double-float-positive-infinity (- pi)))) + +(define-test %pow.case.17 + (:tag :fdlibm) + ;; -inf ^ (anything) = -0 ^ (-anything) + (assert-equal (ext:with-float-traps-masked (:divide-by-zero) + ;; This produces a divide-by-zero error so mask it + ;; to get a value. + (kernel:%pow -0d0 (- pi))) + (kernel:%pow ext:double-float-negative-infinity pi)) + (assert-equal (kernel:%pow -0d0 pi) + (kernel:%pow ext:double-float-negative-infinity (- pi)))) + +(define-test %pow.case.18 + (:tag :fdlibm) + ;; (-anything) ^ integer is (-1)^integer * (+anything ^ integer) + (dolist (base '(-2d0 -10d0)) + (dolist (power '(5 -5)) + (assert-equal (* (expt -1 power) + (kernel:%pow (- base) (coerce power 'double-float))) + (kernel:%pow base (coerce power 'double-float)) + base power)))) + +(define-test %pow.case.19 + (:tag :fdlibm) + ;; (-anything except 0 and inf) ^ non-integer is NaN + ;; + ;; But this signals invalid, so check for that too. + (assert-error 'floating-point-invalid-operation + (kernel:%pow -2d0 1.5d0)) + (ext:with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p + (kernel:%pow -2d0 1.5d0))))) ===================================== tests/issues.lisp ===================================== @@ -436,7 +436,7 @@ (define-test issue.45 (:tag :issues) ;; This depends on run-tests to setup the test directory correctly! - (let* ((test-dir #p"test-tmp/") + (let* ((test-dir #p"tests/test-run-prog/") (test-dir-name (namestring test-dir))) (flet ((do-test (program) (with-output-to-string (s) ===================================== tests/test-run-prog/ls-link ===================================== @@ -0,0 +1,2 @@ +#! /bin/sh +exec /bin/ls "$@" View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/fdacacd73cee798c34401b… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/fdacacd73cee798c34401b… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0