X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Ffloat.pure.lisp;h=7e6d5fd61b4a80a7ae4eac52de2a53bdf777b795;hb=e1905b479292158bd2bacdebb81e27b4da041097;hp=be2a6073790023a5713003ddd28a24c58c88a156;hpb=079ef9dad558ca07cb8178ef428bf738112174fa;p=sbcl.git diff --git a/tests/float.pure.lisp b/tests/float.pure.lisp index be2a607..7e6d5fd 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,18 +82,123 @@ ;;; 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)))) -#-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))) + +(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 + (funcall + (compile + nil + '(lambda (p1) + (declare (optimize (speed 3) (safety 2) (debug 3) (space 0)) + (type complex p1)) + (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 :mips)) + (assert (typep (nth-value + 1 + (ignore-errors + (sb-sys:without-interrupts + (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))))))) + + +#-x86-64 +(with-test (:name :nan-comparisons) + (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))))))