GitLab

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.

@@ -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);

@@ -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

Raymond Toy pushed to branch issue-425-correctly-rounded-math-functions-single-float at cmucl / cmucl

Commits:

2 changed files:

Changes: