(assert (= (coerce 1/2 '(complex float)) #c(0.5 0.0)))
(assert (= (coerce 1.0d0 '(complex float)) #c(1.0d0 0.0d0)))
+;;; (COERCE #c(<RATIONAL> <RATIONAL>) '(complex float)) resulted in
+;;; an error up to 0.8.17.31
+(assert (= (coerce #c(1 2) '(complex float)) #c(1.0 2.0)))
+
;;; COERCE also sometimes failed to verify that a particular coercion
;;; was possible (in particular coercing rationals to bounded float
;;; types.
(let* ((x (random most-positive-fixnum))
(x2 (* x 2))
(x3 (* x 3)))
- (let ((fn (handler-bind (;; broken by rearrangement of
- ;; multiplication strength reduction in
- ;; sbcl-0.8.4.12
- #+nil
- (sb-ext:compiler-note #'error))
+ (let ((fn (handler-bind ((sb-ext:compiler-note
+ (lambda (c)
+ (when (<= x3 most-positive-fixnum)
+ (error c)))))
(compile nil
`(lambda (y)
(declare (optimize speed) (type (integer 0 3) y))
((1+ most-positive-fixnum) (1+ most-positive-fixnum) nil)
((1+ most-positive-fixnum) (1- most-negative-fixnum) t)
(1 (ash most-negative-fixnum 1) nil)
- (29 most-negative-fixnum t)
- (30 (ash most-negative-fixnum 1) t)
- (31 (ash most-negative-fixnum 1) t)
- (64 (ash most-negative-fixnum 36) nil)
- (65 (ash most-negative-fixnum 36) t)))
+ (#.(- sb-vm:n-word-bits sb-vm:n-lowtag-bits) most-negative-fixnum t)
+ (#.(1+ (- sb-vm:n-word-bits sb-vm:n-lowtag-bits)) (ash most-negative-fixnum 1) t)
+ (#.(+ 2 (- sb-vm:n-word-bits sb-vm:n-lowtag-bits)) (ash most-negative-fixnum 1) t)
+ (#.(+ sb-vm:n-word-bits 32) (ash most-negative-fixnum #.(+ 32 sb-vm:n-lowtag-bits 1)) nil)
+ (#.(+ sb-vm:n-word-bits 33) (ash most-negative-fixnum #.(+ 32 sb-vm:n-lowtag-bits 1)) t)))
(destructuring-bind (index int result) x
(assert (eq (eval `(logbitp ,index ,int)) result))))
;;; ASH of a negative bignum by a bignum count would erroneously
;;; return 0 prior to sbcl-0.8.4.4
(assert (= (ash (1- most-negative-fixnum) (1- most-negative-fixnum)) -1))
+
+;;; Whoops. Too much optimization in division operators for 0
+;;; divisor.
+(macrolet ((frob (name)
+ `(let ((fn (compile nil '(lambda (x)
+ (declare (optimize speed) (fixnum x))
+ (,name x 0)))))
+ (assert (raises-error? (funcall fn 1) division-by-zero)))))
+ (frob mod)
+ (frob truncate)
+ (frob rem)
+ (frob /)
+ (frob floor)
+ (frob ceiling))
+
+;; Check that the logic in SB-KERNEL::BASIC-COMPARE for doing fixnum/float
+;; comparisons without rationalizing the floats still gives the right anwers
+;; in the edge cases (had a fencepost error).
+(macrolet ((test (range type sign)
+ `(let (ints
+ floats
+ (start (- ,(find-symbol (format nil
+ "MOST-~A-EXACTLY-~A-FIXNUM"
+ sign type)
+ :sb-kernel)
+ ,range)))
+ (dotimes (i (1+ (* ,range 2)))
+ (let* ((x (+ start i))
+ (y (coerce x ',type)))
+ (push x ints)
+ (push y floats)))
+ (dolist (i ints)
+ (dolist (f floats)
+ (dolist (op '(< <= = >= >))
+ (unless (eq (funcall op i f)
+ (funcall op i (rationalize f)))
+ (error "(not (eq (~a ~a ~f) (~a ~a ~a)))~%"
+ op i f
+ op i (rationalize f)))
+ (unless (eq (funcall op f i)
+ (funcall op (rationalize f) i))
+ (error "(not (eq (~a ~f ~a) (~a ~a ~a)))~%"
+ op f i
+ op (rationalize f) i))))))))
+ (test 32 double-float negative)
+ (test 32 double-float positive)
+ (test 32 single-float negative)
+ (test 32 single-float positive))
+
+;; x86-64 sign-extension bug found using pfdietz's random tester.
+(assert (= 286142502
+ (funcall (lambda ()
+ (declare (notinline logxor))
+ (min (logxor 0 0 0 286142502))))))