X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Ffloat.pure.lisp;h=f0d9a5dc064f42379864c935622599af36ebff43;hb=c4b30c86e3dd1d1cc70c572a6cfffe8b84e9c34a;hp=dba1bedbf9d15835016ec533699e2eed65d0d91c;hpb=cacfac8c22699a62fefab099866b65f490478571;p=sbcl.git diff --git a/tests/float.pure.lisp b/tests/float.pure.lisp index dba1bed..f0d9a5d 100644 --- a/tests/float.pure.lisp +++ b/tests/float.pure.lisp @@ -6,7 +6,7 @@ ;;;; While most of SBCL is derived from the CMU CL system, the test ;;;; files (like this one) were written from scratch after the fork ;;;; from CMU CL. -;;;; +;;;; ;;;; This software is in the public domain and is provided with ;;;; absolutely no warranty. See the COPYING and CREDITS files for ;;;; more information. @@ -14,9 +14,9 @@ (cl:in-package :cl-user) (dolist (ifnis (list (cons single-float-positive-infinity - single-float-negative-infinity) - (cons double-float-positive-infinity - double-float-negative-infinity))) + single-float-negative-infinity) + (cons double-float-positive-infinity + double-float-negative-infinity))) (destructuring-bind (+ifni . -ifni) ifnis (assert (= (* +ifni 1) +ifni)) (assert (= (* +ifni -0.1) -ifni)) @@ -47,7 +47,7 @@ ;;; (Peter Van Eynde's ansi-test suite caught this, and Eric Marsden ;;; reported a fix for CMU CL, which was ported to sbcl-0.6.12.35.) (assert (typep (nth-value 1 (ignore-errors (float-radix "notfloat"))) - 'type-error)) + 'type-error)) (assert (typep (nth-value 1 (ignore-errors (funcall (fdefinition 'float-radix) "notfloat"))) @@ -82,21 +82,29 @@ ;;; bug found by Peter Seibel: scale-float was only accepting float ;;; exponents, when it should accept all integers. (also bug #269) (assert (= (multiple-value-bind (significand expt sign) - (integer-decode-float least-positive-double-float) - (* (scale-float (float significand 0.0d0) expt) sign)) - least-positive-double-float)) + (integer-decode-float least-positive-double-float) + (* (scale-float (float significand 0.0d0) expt) sign)) + least-positive-double-float)) (assert (= (multiple-value-bind (significand expt sign) - (decode-float least-positive-double-float) - (* (scale-float significand expt) sign)) - least-positive-double-float)) + (decode-float least-positive-double-float) + (* (scale-float significand expt) sign)) + least-positive-double-float)) (assert (= 0.0 (scale-float 1.0 most-negative-fixnum))) (assert (= 0.0d0 (scale-float 1.0d0 (1- most-negative-fixnum)))) -#-(or darwin x86-64) ;; bug 372 / 378 -(progn - (assert (raises-error? (scale-float 1.0 most-positive-fixnum) - floating-point-overflow)) - (assert (raises-error? (scale-float 1.0d0 (1+ most-positive-fixnum)) - floating-point-overflow))) + +(with-test (:name (:scale-float-overflow :bug-372) + :fails-on '(or :ppc :darwin)) ;; bug 372 + (progn + (assert (raises-error? (scale-float 1.0 most-positive-fixnum) + floating-point-overflow)) + (assert (raises-error? (scale-float 1.0d0 (1+ most-positive-fixnum)) + floating-point-overflow)))) + +;;; bug found by jsnell when nfroyd tried to implement better LOGAND +;;; type derivation. +(assert (= (integer-decode-float (coerce -1756510900000000000 + 'single-float)) + 12780299)) ;;; MISC.564: no out-of-line %ATAN2 for constant folding (assert (typep @@ -109,3 +117,130 @@ (phase (the (eql #c(1.0d0 2.0d0)) p1)))) #c(1.0d0 2.0d0)) 'double-float)) + +;;; More out of line functions (%COS, %SIN, %TAN) for constant folding, +;;; reported by Mika Pihlajamäki +(funcall (compile nil '(lambda () (cos (tan (round 0)))))) +(funcall (compile nil '(lambda () (sin (tan (round 0)))))) +(funcall (compile nil '(lambda () (tan (tan (round 0)))))) + +(with-test (:name (:addition-overflow :bug-372) + :fails-on '(or :ppc :darwin (and :x86 :netbsd))) + (assert (typep (nth-value + 1 + (ignore-errors + (sb-sys:without-interrupts + (sb-int:set-floating-point-modes :current-exceptions nil + :accrued-exceptions nil) + (loop repeat 2 summing most-positive-double-float) + (sleep 2)))) + 'floating-point-overflow))) + +;;; On x86-64 generating complex floats on the stack failed an aver in +;;; the compiler if the stack slot was the same as the one containing +;;; the real part of the complex. The following expression was able to +;;; trigger this in 0.9.5.62. +(with-test (:name :complex-float-stack) + (dolist (type '((complex double-float) + (complex single-float))) + (compile nil + `(lambda (x0 x1 x2 x3 x4 x5 x6 x7) + (declare (type ,type x0 x1 x2 x3 x4 x5 x6 x7)) + (let ((x0 (+ x0 x0)) + (x1 (+ x1 x1)) + (x2 (+ x2 x2)) + (x3 (+ x3 x3)) + (x4 (+ x4 x4)) + (x5 (+ x5 x5)) + (x6 (+ x6 x6)) + (x7 (+ x7 x7))) + (* (+ x0 x1 x2 x3) (+ x4 x5 x6 x7) + (+ x0 x2 x4 x6) (+ x1 x3 x5 x7) + (+ x0 x3 x4 x7) (+ x1 x2 x5 x6) + (+ x0 x1 x6 x7) (+ x2 x3 x4 x5))))))) + + +(with-test (:name :nan-comparisons + :fails-on '(or :sparc :mips)) + (sb-int:with-float-traps-masked (:invalid) + (macrolet ((test (form) + (let ((nform (subst '(/ 0.0 0.0) 'nan form))) + `(progn + (assert (eval ',nform)) + (assert (eval `(let ((nan (/ 0.0 0.0))) + ,',form))) + (assert (funcall + (compile nil `(lambda () ,',nform)))) + (assert (funcall + (compile nil `(lambda (nan) ,',form)) + (/ 0.0 0.0))))))) + (test (/= nan nan)) + (test (/= nan nan nan)) + (test (/= 1.0 nan 2.0 nan)) + (test (/= nan 1.0 2.0 nan)) + (test (not (= nan 1.0))) + (test (not (= nan nan))) + (test (not (= nan nan nan))) + (test (not (= 1.0 nan))) + (test (not (= nan 1.0))) + (test (not (= 1.0 1.0 nan))) + (test (not (= 1.0 nan 1.0))) + (test (not (= nan 1.0 1.0))) + (test (not (>= nan nan))) + (test (not (>= nan 1.0))) + (test (not (>= 1.0 nan))) + (test (not (>= 1.0 nan 0.0))) + (test (not (>= 1.0 0.0 nan))) + (test (not (>= nan 1.0 0.0))) + (test (not (<= nan nan))) + (test (not (<= nan 1.0))) + (test (not (<= 1.0 nan))) + (test (not (<= 1.0 nan 2.0))) + (test (not (<= 1.0 2.0 nan))) + (test (not (<= nan 1.0 2.0))) + (test (not (< nan nan))) + (test (not (< -1.0 nan))) + (test (not (< nan 1.0))) + (test (not (> nan nan))) + (test (not (> -1.0 nan))) + (test (not (> nan 1.0)))))) + +(with-test (:name :log-int/double-accuracy) + ;; we used to use single precision for intermediate results + (assert (eql 2567.6046442221327d0 + (log (loop for n from 1 to 1000 for f = 1 then (* f n) + finally (return f)) + 10d0))) + ;; both ways + (assert (eql (log 123123123.0d0 10) (log 123123123 10.0d0)))) + +(with-test (:name :log-base-zero-return-type) + (assert (eql 0.0f0 (log 123 (eval 0)))) + (assert (eql 0.0d0 (log 123.0d0 (eval 0)))) + (assert (eql 0.0d0 (log 123 (eval 0.0d0)))) + (let ((f (compile nil '(lambda (x y) + (declare (optimize speed)) + (etypecase x + (single-float + (etypecase y + (single-float (log x y)) + (double-float (log x y)))) + (double-float + (etypecase y + (single-float (log x y)) + (double-float (log x y))))))))) + (assert (eql 0.0f0 (funcall f 123.0 0.0))) + (assert (eql 0.0d0 (funcall f 123.0d0 0.0))) + (assert (eql 0.0d0 (funcall f 123.0d0 0.0d0))) + (assert (eql 0.0d0 (funcall f 123.0 0.0d0))))) + +;; Bug reported by Eric Marsden on July 15 2009. The compiler +;; used not to constant fold calls with arguments of type +;; (EQL foo). +(with-test (:name :eql-type-constant-fold) + (assert (equal '(FUNCTION (T) (VALUES (MEMBER T) &OPTIONAL)) + (sb-kernel:%simple-fun-type + (compile nil `(lambda (x) + (eql #c(1.0 2.0) + (the (eql #c(1.0 2.0)) + x))))))))