Ticket #1059: test-cl-float.lisp

;;; CL function test

(in-package :cl-user)

(defun point= (p1 p2)
  (flet ((1= (x y)
           (or (eql x y)
               (eql y '*))))
    (and (1= (first p1) (first p2))
         (1= (second p1) (second p2)))))

(defun validate-range (fn-name type point x-range &optional except (y-range x-range))
  (let ((n-errors 0))
    (flet ((report (reason x y)
             (when (< (incf n-errors) 10)
               (format t
                       "~&; ~A (~A (~A ~A ~A))~%"
                       reason
                       fn-name
                       type
                       x
                       y))))
      (do ((end-y (second y-range))
           (step-y (or (third y-range) 1))
           (y (first y-range) (+ y step-y)))
          ((> y end-y))
        (do ((y1 (funcall point y))
             (end-x (second x-range))
             (step-x (or (third x-range) 1))
             (x (first x-range) (+ x step-x)))
            ((> x end-x))
          (let ((x1 (funcall point x)))
            (when (and x1 y1)
              (let ((bad (find (list x1 y1) except :test #'point=)))
                (handler-case
                    (progn
                      (multiple-value-call fn-name (funcall type x1 y1))
                      (when bad
                        (report "No error at" x1 y1)))
                  (error ()
                    (unless bad
                      (report "Failed" x1 y1))))))))))
    (format t
            "~&; (~A (~A ~A) ~A ~A) - ~D total error~:P~%"
            fn-name
            type
            point
            x-range
            y-range
            n-errors)
    n-errors))

(defun power (x)
  (if (zerop x)
    x
    (let ((power (ash 1 (1- (abs x)))))
      (if (minusp x) (- power) power))))

(defun real-power (x)
  (float (power x) 1.0))

(defun dble-power (x)
  (float (power x) 1.0d0))

(defun inv-power (x)
  (let ((z (power x)))
    (unless (zerop z) (/ z))))

(defun inv-real-power (x)
  (let ((z (real-power x)))
    (unless (zerop z) (/ z))))

(defun inv-dble-power (x)
  (let ((z (dble-power x)))
    (unless (zerop z) (/ z))))

(defun dble-float (x)
  (float x 1.0d0))


(defun validate-spot (fn-name type x y &optional except)
  (let ((n-errors 0))
    (flet ((report (reason x y)
             (incf n-errors)
             (format t
                     "~&; ~A (~A (~A ~A ~A))~%"
                     reason
                     fn-name
                     type
                     x
                     y)))
      (dolist (pair (list (cons x y)
                          (cons x 0)
                          (cons x (- y))
                          (cons 0 (- y))
                          (cons (- x) (- y))
                          (cons (- x) 0)
                          (cons (- x) y)
                          (cons 0 y)
                          (cons y x)
                          (cons y 0)
                          (cons y (- x))
                          (cons 0 (- x))
                          (cons (- y) (- x))
                          (cons (- y) 0)
                          (cons (- y) x)
                          (cons 0 x))
                    n-errors)
        (let* ((x1 (car pair))
               (y1 (cdr pair))
               (bad (find (list x1 y1) except :test #'point=)))
          (handler-case
              (progn 
                (multiple-value-call fn-name (funcall type x1 y1))
                (when bad
                  (report "No error at" x1 y1)))
            (error ()
              (unless bad
                (report "Failed" x1 y1)))))))))

(defun validate-value (fn-name type x y value)
  (cond ((eql (multiple-value-call fn-name (funcall type x y)) value)
         0)
        (t
         (format t
                 "~&; (~A (~A ~A ~A)) /= ~A~%"
                 fn-name
                 type
                 x
                 y
                 value)
         1)))

;;; N.B. This assumes that 0.0 and -0.0 are in fact different!
(defun validate-branch-cut (fn-name type cut point v-range &optional end (o '(-0.0 0.0)))
  (let ((n-errors 0))
    (flet ((report (reason z1 z2)
             (when (< (incf n-errors) 10)
               (format t
                       "~&; ~A (~A ~A|~A)~%"
                       reason
                       fn-name
                       z1
                       z2)))
           (c (x y)
             (if (eq type :x)
               (if (eql y 0)
                 x
                 (complex x y))
               (complex y x))))
      (do ((end-v (second v-range))
           (step-v (or (third v-range) 1))
           (v (first v-range) (+ v step-v)))
          ((> v end-v) n-errors)
        (let* ((x (funcall point v))
               (z1 (c x (first o)))
               (z2 (c x (second o))))
          (handler-case
              (let ((v1 (funcall fn-name z1))
                    (v2 (funcall fn-name z2)))
                (when (if cut
                        (and (= v1 v2)
                             (if (find v end)
                               (and (if (zerop (realpart v1)) (eql (realpart v1) (realpart v2)) t)
                                    (if (zerop (imagpart v1)) (eql (imagpart v1) (imagpart v2)) t))
                               t))
                        (/= v1 v2))
                  (report (if cut "No branch cut at" "Discontinuous at") z1 z2)))
            (error ()
              (report "Failed" z1 z2))))))))

(defun validate-pole (fn-name z point v-range)
  (let ((n-errors 0))
    (labels ((epsilon (x)
               (typecase x
                 (single-float
                  (if (zerop x)
                    least-positive-single-float
                    (* x single-float-epsilon)))
                 (double-float
                  (if (zerop x)
                    least-positive-double-float
                    (* x double-float-epsilon)))
                 (t
                  (expt 2 -127))))
             (add1 (x o)
               (cond ((numberp o)
                      (+ x o))
                     ((zerop x)
                      (if (rationalp x)
                        0
                        (float (if (eq o '+) 0.0 -0.0) x)))
                     (t
                      x)))
             (add (c o)
               (complex (add1 (realpart c) (car o))
                        (add1 (imagpart c) (cdr o)))))
      (do ((dx (epsilon (realpart z)))
           (dy (epsilon (imagpart z)))
           (end-v (second v-range))
           (step-v (or (third v-range) 1))
           (v (first v-range) (+ v step-v)))
          ((> v end-v) n-errors)
        (let* ((delta (funcall point v))
               (delta-x (* delta dx))
               (delta-y (* delta dy)))
          (dolist (pair (list (cons delta-x delta-y)
                              (cons delta-x '+)
                              (cons delta-x '-)
                              (cons delta-x (- delta-y))
                              (cons '+ (- delta-y))
                              (cons '- (- delta-y))
                              (cons (- delta-x) (- delta-y))
                              (cons (- delta-x) '+)
                              (cons (- delta-x) '-)
                              (cons (- delta-x) delta-y)
                              (cons '+ delta-y)
                              (cons '- delta-y)))
            (let ((z1 (add z pair)))
              (handler-case
                  (funcall fn-name z1)
                (error ()
                  (when (< (incf n-errors) 10)
                    (format t
                            "~&; Failed (~A ~A)~%"
                            fn-name
                            z1)))))))))))

(defun summarise (&rest results)
  (let ((n-errors (apply #'+ results)))
    (format t "~&; TOTAL: ~D error~:P~%" n-errors)
    n-errors))


;;;
(summarise

(validate-range 'sqrt 'complex 'power '(-256 256 2))
(validate-range 'sqrt 'complex 'inv-power '(-256 256 2))
(validate-range 'sqrt 'complex 'real-power '(-128 128))
(validate-range 'sqrt 'complex 'inv-real-power '(-128 128))
(validate-range 'sqrt 'complex 'dble-power '(-1024 1024 8))
(validate-range 'sqrt 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'abs 'complex 'power '(-128 128))
(validate-range 'abs 'complex 'inv-power '(-128 128))
(validate-range 'abs 'complex 'real-power '(-128 128))
(validate-range 'abs 'complex 'inv-real-power '(-128 128))
(validate-range 'abs 'complex 'dble-power '(-1024 1024 8))
(validate-range 'abs 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'phase 'complex 'power '(-2048 2048 32))
(validate-range 'phase 'complex 'inv-power '(-2048 2048 32))
(validate-range 'phase 'complex 'real-power '(-128 128))
(validate-range 'phase 'complex 'inv-real-power '(-128 128))
(validate-range 'phase 'complex 'dble-power '(-1024 1024 8))
(validate-range 'phase 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'log 'complex 'power '(-128 128) '((0 0)))
(validate-range 'log 'complex 'inv-power '(-128 128))
(validate-range 'log 'complex 'real-power '(-128 128) '((0.0 0.0)))
(validate-range 'log 'complex 'inv-real-power '(-128 128))
(validate-range 'log 'complex 'dble-power '(-1020 1020 8))
(validate-range 'log 'complex 'inv-dble-power '(-1020 1020 8))
(validate-range 'log 'complex 'power '(-2040 2040 32))
(validate-range 'log 'complex 'inv-power '(-2040 2040 32))

(validate-range 'exp 'complex 'power '(-2048 -32 32) nil '(-2048 2048 32))
(validate-range 'exp 'complex 'power '(-31 7) nil '(-2048 2048 32))
(validate-range 'exp 'complex 'inv-power '(-2048 2048 32))
(validate-range 'exp 'complex 'real-power '(-128 7) nil '(-128 128))
(validate-range 'exp 'complex 'inv-real-power '(-128 128))
(validate-range 'exp 'complex 'dble-power '(-1024 0 8) nil '(-1024 1024 8))
(validate-range 'exp 'complex 'dble-power '(1 10) nil '(-1024 1024 8))
(validate-range 'exp 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'sin 'complex 'power '(-2048 2048 32) nil '(-7 7))
(validate-range 'sin 'complex 'inv-power '(-2048 2048 32))
(validate-range 'sin 'complex 'real-power '(-128 128) nil '(-7 7))
(validate-range 'sin 'complex 'inv-real-power '(-128 128))
(validate-range 'sin 'complex 'dble-power '(-1024 1024 8) nil '(-10 10))
(validate-range 'sin 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'cos 'complex 'power '(-2048 2048 32) nil '(-7 7))
(validate-range 'cos 'complex 'inv-power '(-2048 2048 32))
(validate-range 'cos 'complex 'real-power '(-128 128) nil '(-7 7))
(validate-range 'cos 'complex 'inv-real-power '(-128 128))
(validate-range 'cos 'complex 'dble-power '(-1024 1024 8) nil '(-10 10))
(validate-range 'cos 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'tan 'complex 'power '(-2048 2048 32))
(validate-range 'tan 'complex 'inv-power '(-2048 2048 32))
(validate-range 'tan 'complex 'real-power '(-128 128))
(validate-range 'tan 'complex 'inv-real-power '(-128 128))
(validate-range 'tan 'complex 'dble-power '(-1024 1024 8))
(validate-range 'tan 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'asin 'complex 'power '(-2048 2048 32))
(validate-range 'asin 'complex 'inv-power '(-2048 2048 32))
(validate-range 'asin 'complex 'real-power '(-128 128))
(validate-range 'asin 'complex 'inv-real-power '(-128 128))
(validate-range 'asin 'complex 'dble-power '(-1024 1024 8))
(validate-range 'asin 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'acos 'complex 'power '(-2048 2048 32))
(validate-range 'acos 'complex 'inv-power '(-2048 2048 32))
(validate-range 'acos 'complex 'real-power '(-128 128))
(validate-range 'acos 'complex 'inv-real-power '(-128 128))
(validate-range 'acos 'complex 'dble-power '(-1024 1024 8))
(validate-range 'acos 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'atan 'complex 'power '(-2048 2048 32))
(validate-range 'atan 'complex 'inv-power '(-2048 2048 32))
(validate-range 'atan 'complex 'real-power '(-128 128) '((0.0 1.0) (0.0 -1.0)))
(validate-range 'atan 'complex 'inv-real-power '(-128 128))
(validate-range 'atan 'complex 'dble-power '(-1024 1024 8))
(validate-range 'atan 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'atan 'values 'power '(-2048 2048 32))
(validate-range 'atan 'values 'inv-power '(-2048 2048 32))
(validate-range 'atan 'values 'real-power '(-128 128))
(validate-range 'atan 'values 'inv-real-power '(-128 128))
(validate-range 'atan 'values 'dble-power '(-1024 1024 8))
(validate-range 'atan 'values 'inv-dble-power '(-1024 1024 8))

(validate-range 'sinh 'complex 'power '(-7 7) nil '(-2048 2048 32))
(validate-range 'sinh 'complex 'inv-power '(-2048 2048 32))
(validate-range 'sinh 'complex 'real-power '(-7 7) nil '(-128 128))
(validate-range 'sinh 'complex 'inv-real-power '(-128 128))
(validate-range 'sinh 'complex 'dble-power '(-10 10) nil '(-1024 1024 8))
(validate-range 'sinh 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'cosh 'complex 'power '(-7 7) nil '(-2048 2048 32))
(validate-range 'cosh 'complex 'inv-power '(-2048 2048 32))
(validate-range 'cosh 'complex 'real-power '(-7 7) nil '(-128 128))
(validate-range 'cosh 'complex 'inv-real-power '(-128 128))
(validate-range 'cosh 'complex 'dble-power '(-10 10) nil '(-1024 1024 8))
(validate-range 'cosh 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'tanh 'complex 'power '(-2048 2048 32))
(validate-range 'tanh 'complex 'inv-power '(-2048 2048 32))
(validate-range 'tanh 'complex 'real-power '(-128 128))
(validate-range 'tanh 'complex 'inv-real-power '(-128 128))
(validate-range 'tanh 'complex 'dble-power '(-1024 1024 8))
(validate-range 'tanh 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'asinh 'complex 'power '(-2048 2048 32))
(validate-range 'asinh 'complex 'inv-power '(-2048 2048 32))
(validate-range 'asinh 'complex 'real-power '(-128 128))
(validate-range 'asinh 'complex 'inv-real-power '(-128 128))
(validate-range 'asinh 'complex 'dble-power '(-1024 1024 8))
(validate-range 'asinh 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'acosh 'complex 'power '(-2048 2048 32))
(validate-range 'acosh 'complex 'inv-power '(-2048 2048 32))
(validate-range 'acosh 'complex 'real-power '(-128 128))
(validate-range 'acosh 'complex 'inv-real-power '(-128 128))
(validate-range 'acosh 'complex 'dble-power '(-1024 1024 8))
(validate-range 'acosh 'complex 'inv-dble-power '(-1024 1024 8))

(validate-range 'atanh 'complex 'power '(-2048 2048 32))
(validate-range 'atanh 'complex 'inv-power '(-2048 2048 32))
(validate-range 'atanh 'complex 'real-power '(-128 128) '((1.0 0.0) (-1.0 0.0)))
(validate-range 'atanh 'complex 'inv-real-power '(-128 128))
(validate-range 'atanh 'complex 'dble-power '(-1024 1024 8))
(validate-range 'atanh 'complex 'inv-dble-power '(-1024 1024 8))

(validate-spot 'sqrt 'complex (expt 10 66) (expt 10 68))
(validate-spot 'sqrt 'complex (expt 10 -66) (expt 10 -68))
(validate-spot 'sqrt 'complex (expt 10 65) (expt 10 67))
(validate-spot 'sqrt 'complex (expt 10 -65) (expt 10 -67))
(validate-spot 'sqrt 'complex (/ (expt 10 65) 3) (expt 10 67))
(validate-spot 'sqrt 'complex most-positive-single-float most-positive-single-float)
(validate-spot 'sqrt 'complex least-positive-single-float most-positive-single-float)
(validate-spot 'sqrt 'complex least-positive-single-float least-positive-single-float)
(validate-spot 'sqrt 'complex most-positive-double-float most-positive-double-float)
(validate-spot 'sqrt 'complex least-positive-double-float least-positive-double-float)

(validate-spot 'log 'complex (expt 10 66) (expt 10 68))
(validate-spot 'log 'complex (expt 10 -66) (expt 10 -68))
(validate-spot 'log 'values 8.0d0 2 '((0 *)))
(validate-spot 'log 'values #c(2 3) #c(4.5 7.8) '((0 *)))
(validate-spot 'log 'complex 2 3)
(validate-spot 'log 'complex 2.0 3.0)
(validate-spot 'log 'complex 4.5 7.8)
(validate-spot 'log 'complex most-positive-single-float most-positive-single-float)
(validate-spot 'log 'complex least-positive-single-float most-positive-single-float)
(validate-spot 'log 'complex least-positive-single-float least-positive-single-float)
(validate-spot 'log 'complex most-positive-double-float most-positive-double-float)
(validate-spot 'log 'complex least-positive-double-float least-positive-double-float)

(validate-spot 'atan 'values (expt 10 66) (expt 10 68))
(validate-spot 'atan 'values (expt 10 -66) (expt 10 -68))
(validate-spot 'atan 'values 8.0d0 2)
(validate-spot 'atan 'values most-positive-single-float most-positive-single-float)
(validate-spot 'atan 'values least-positive-single-float least-positive-single-float)

(validate-value 'atan 'values 0.0 0.0 0.0)
(validate-value 'atan 'values 0.0 -0.0 (float pi 1.0))
(validate-value 'atan 'values -0.0 0.0 -0.0)
(validate-value 'atan 'values -0.0 -0.0 (- (float pi 1.0)))
(validate-value 'atan 'values 0.0d0 0.0d0 0.0d0)
(validate-value 'atan 'values 0.0d0 -0.0d0 pi)
(validate-value 'atan 'values -0.0d0 0.0d0 -0.0d0)
(validate-value 'atan 'values -0.0d0 -0.0d0 (- pi))

(validate-value 'phase 'complex 0.0 0.0 0.0)
(validate-value 'phase 'complex -0.0 0.0 (float pi 1.0))
(validate-value 'phase 'complex 0.0 -0.0 -0.0)
(validate-value 'phase 'complex -0.0 -0.0 (- (float pi 1.0)))
(validate-value 'phase 'complex 0.0d0 0.0d0 0.0d0)
(validate-value 'phase 'complex -0.0d0 0.0d0 pi)
(validate-value 'phase 'complex 0.0d0 -0.0d0 -0.0d0)
(validate-value 'phase 'complex -0.0d0 -0.0d0 (- pi))

(validate-branch-cut 'sqrt :x t 'real-power '(-8 0) '(0))
(validate-branch-cut 'sqrt :x nil 'real-power '(-8 0) nil '(0 0.0))
(validate-branch-cut 'sqrt :x nil 'real-power '(0 8))
(validate-branch-cut 'sqrt :y nil 'real-power '(-8 8))
(validate-branch-cut 'sqrt :x t 'dble-power '(-8 0) '(0))
(validate-branch-cut 'sqrt :x nil 'dble-power '(-8 0) nil '(0 0.0))
(validate-branch-cut 'sqrt :x nil 'dble-power '(0 8))
(validate-branch-cut 'sqrt :y nil 'dble-power '(-8 8))

(validate-branch-cut 'phase :x t 'real-power '(-8 0) '(0))
(validate-branch-cut 'phase :x nil 'real-power '(-8 0) nil '(0 0.0))
(validate-branch-cut 'phase :x nil 'real-power '(0 8))
(validate-branch-cut 'phase :y nil 'real-power '(-8 -1))
(validate-branch-cut 'phase :y nil 'real-power '(1 8))
(validate-branch-cut 'phase :x t 'dble-power '(-8 0) '(0))
(validate-branch-cut 'phase :x nil 'dble-power '(-8 0) nil '(0 0.0))
(validate-branch-cut 'phase :x nil 'dble-power '(0 8))
(validate-branch-cut 'phase :y nil 'dble-power '(-8 -1))
(validate-branch-cut 'phase :y nil 'dble-power '(1 8))

(validate-branch-cut 'log :x t 'real-power '(-8 -1))
(validate-branch-cut 'log :x nil 'real-power '(-8 -1) nil '(0 0.0))
(validate-branch-cut 'log :x nil 'real-power '(1 8))
(validate-branch-cut 'log :y nil 'real-power '(-8 -1))
(validate-branch-cut 'log :y nil 'real-power '(1 8))
(validate-branch-cut 'log :x t 'dble-power '(-8 -1))
(validate-branch-cut 'log :x nil 'dble-power '(-8 -1) nil '(0 0.0))
(validate-branch-cut 'log :x nil 'dble-power '(1 8))
(validate-branch-cut 'log :y nil 'dble-power '(-8 -1))
(validate-branch-cut 'log :y nil 'dble-power '(1 8))

(validate-branch-cut 'asin :x t 'real-power '(-8 -1) '(-1))
(validate-branch-cut 'asin :x t 'real-power '(1 8) '(1))
(validate-branch-cut 'asin :x nil 'float '(-1 1 1/10))
(validate-branch-cut 'asin :x nil 'real-power '(-8 -1) nil '(0 0.0))
(validate-branch-cut 'asin :x nil 'real-power '(1 8) nil '(0 -0.0))
(validate-branch-cut 'asin :y nil 'real-power '(-8 8))
(validate-branch-cut 'asin :x t 'dble-power '(-8 -1) '(-1))
(validate-branch-cut 'asin :x t 'dble-power '(1 8) '(1))
(validate-branch-cut 'asin :x nil 'dble-float '(-1 1 1/10))
(validate-branch-cut 'asin :x nil 'dble-power '(-8 -1) nil '(0 0.0))
(validate-branch-cut 'asin :x nil 'dble-power '(1 8) nil '(0 -0.0))
(validate-branch-cut 'asin :y nil 'dble-power '(-8 8))

(validate-branch-cut 'acos :x t 'real-power '(-8 -1) '(-1))
(validate-branch-cut 'acos :x t 'real-power '(1 8) '(1))
(validate-branch-cut 'acos :x nil 'float '(-1 1 1/10))
(validate-branch-cut 'acos :x nil 'real-power '(-8 -1) nil '(0 0.0))
(validate-branch-cut 'acos :x nil 'real-power '(1 8) nil '(0 -0.0))
(validate-branch-cut 'acos :y nil 'real-power '(-8 8))
(validate-branch-cut 'acos :x t 'dble-power '(-8 -1) '(-1))
(validate-branch-cut 'acos :x t 'dble-power '(1 8) '(1))
(validate-branch-cut 'acos :x nil 'dble-float '(-1 1 1/10))
(validate-branch-cut 'acos :x nil 'dble-power '(-8 -1) nil '(0 0.0))
(validate-branch-cut 'acos :x nil 'dble-power '(1 8) nil '(0 -0.0))
(validate-branch-cut 'acos :y nil 'dble-power '(-8 8))

(validate-branch-cut 'atan :y t 'real-power '(-8 -2))
(validate-branch-cut 'atan :y t 'real-power '(2 8))
(validate-branch-cut 'atan :y nil 'float '(-19/20 19/20 1/10))
(validate-branch-cut 'atan :y nil 'power '(-8 -2) nil '(0 -0.0))
(validate-branch-cut 'atan :y nil 'power '(2 8) nil '(0 0.0))
(validate-branch-cut 'atan :x nil 'real-power '(-8 8))
(validate-branch-cut 'atan :y t 'dble-power '(-8 -2))
(validate-branch-cut 'atan :y t 'dble-power '(2 8))
(validate-branch-cut 'atan :y nil 'dble-float '(-19/20 19/20 1/10))
(validate-branch-cut 'atan :x nil 'dble-power '(-8 8))

(validate-branch-cut 'asinh :y t 'real-power '(-8 -1) '(-1))
(validate-branch-cut 'asinh :y t 'real-power '(1 8) '(1))
(validate-branch-cut 'asinh :y nil 'float '(-1 1 1/10))
(validate-branch-cut 'asinh :y nil 'power '(-8 -1) nil '(0 -0.0))
(validate-branch-cut 'asinh :y nil 'power '(1 8) nil '(0 0.0))
(validate-branch-cut 'asinh :x nil 'real-power '(-8 8))
(validate-branch-cut 'asinh :y t 'dble-power '(-8 -1) '(-1))
(validate-branch-cut 'asinh :y t 'dble-power '(1 8) '(1))
(validate-branch-cut 'asinh :y nil 'dble-float '(-1 1 1/10))
(validate-branch-cut 'asinh :x nil 'dble-power '(-8 8))

(validate-branch-cut 'acosh :x t 'real-power '(-8 -1))
(validate-branch-cut 'acosh :x t 'float '(-1 1 1/10) '(1))
(validate-branch-cut 'acosh :x nil 'real-power '(-8 -1) nil '(0 0.0))
(validate-branch-cut 'acosh :x nil 'float '(-1 1 1/10) nil '(0 0.0))
(validate-branch-cut 'acosh :x nil 'real-power '(1 8))
(validate-branch-cut 'acosh :y nil 'real-power '(-8 -1))
(validate-branch-cut 'acosh :y nil 'real-power '(1 8))
(validate-branch-cut 'acosh :x t 'dble-power '(-8 -1))
(validate-branch-cut 'acosh :x t 'dble-float '(-1 1 1/10) '(1))
(validate-branch-cut 'acosh :x nil 'dble-power '(-8 -1) nil '(0 0.0))
(validate-branch-cut 'acosh :x nil 'dble-float '(-1 1 1/10) nil '(0 0.0))
(validate-branch-cut 'acosh :x nil 'dble-power '(1 8))
(validate-branch-cut 'acosh :y nil 'dble-power '(-8 -1))
(validate-branch-cut 'acosh :y nil 'dble-power '(1 8))

(validate-branch-cut 'atanh :x t 'real-power '(-8 -2))
(validate-branch-cut 'atanh :x t 'real-power '(2 8))
(validate-branch-cut 'atanh :x nil 'float '(-19/20 19/20 1/10))
(validate-branch-cut 'atanh :x nil 'real-power '(-8 -2) nil '(0 0.0))
(validate-branch-cut 'atanh :x nil 'real-power '(2 8) nil '(0 -0.0))
(validate-branch-cut 'atanh :y nil 'real-power '(-8 8))
(validate-branch-cut 'atanh :x t 'dble-power '(-8 -2))
(validate-branch-cut 'atanh :x t 'dble-power '(2 8))
(validate-branch-cut 'atanh :x nil 'dble-float '(-19/20 19/20 1/10))
(validate-branch-cut 'atanh :x nil 'dble-power '(-8 -2) nil '(0 0.0))
(validate-branch-cut 'atanh :x nil 'dble-power '(2 8) nil '(0 -0.0))
(validate-branch-cut 'atanh :y nil 'dble-power '(-8 8))

(validate-pole 'log 0.0 'power '(1 17))
(validate-pole 'log 0.0d0 'power '(1 33 2))
(validate-pole 'log 0 'power '(1 125 8))

(validate-pole 'atan #c(0.0 1.0) 'power '(1 17))
(validate-pole 'atan #c(0.0d0 1.0d0) 'power '(1 33 2))
(validate-pole 'atan #c(0 1) 'power '(1 125 8))
(validate-pole 'atan #c(0.0 -1.0) 'power '(1 17))
(validate-pole 'atan #c(0.0d0 -1.0d0) 'power '(1 33 2))
(validate-pole 'atan #c(0 -1) 'power '(1 125 8))

(validate-pole 'atanh 1.0 'power '(1 17))
(validate-pole 'atanh 1.0d0 'power '(1 33 2))
(validate-pole 'atanh 1 'power '(1 125 8))
(validate-pole 'atanh -1.0 'power '(1 17))
(validate-pole 'atanh -1.0d0 'power '(1 33 2))
(validate-pole 'atanh -1 'power '(1 125 8))

)