oct-cvs March 2011

oct-cvs@common-lisp.net

1 participants
36 discussions

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. af9fc6fcdb824757c5aeeadc6ccae2098d243313
by Raymond Toy 29 Mar '11

29 Mar '11

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. 08d254374188f97026d114451bba5d839dbdad11
by Raymond Toy 29 Mar '11

29 Mar '11

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. c31b1cdd112f26334b7762014d3afb781917ebda
by Raymond Toy 29 Mar '11

29 Mar '11

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. a44327a2532c5afc3cbcb1194aa1f15b6dccd2cb
by Raymond Toy 25 Mar '11

25 Mar '11

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "OCT: A portable Lisp implementation for quad-double precision floats". The branch, master has been updated via a44327a2532c5afc3cbcb1194aa1f15b6dccd2cb (commit) via 7fa2a4c33e7542f3538bfcfd15cba833120b0daf (commit) via bed5763d1250d8b3b3793861f6e17449c49dd15b (commit) via 70745f486e3ee012f02c080de0cf9daf00f37375 (commit) from cc23f1098858d652c66728ea85c1c331bfb0fbb8 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit a44327a2532c5afc3cbcb1194aa1f15b6dccd2cb Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 24 23:01:51 2011 -0400 Update required accuracy for elliptic-pi.n0.q. diff --git a/rt-tests.lisp b/rt-tests.lisp index ecb401a..c0b59fb 100644 --- a/rt-tests.lisp +++ b/rt-tests.lisp @@ -1037,7 +1037,7 @@ for epi = (elliptic-pi n phi 0) for true = (/ (atan (* (tan phi) (sqrt (- 1 n)))) (sqrt (- 1 n))) - for result = (check-accuracy 208 epi true) + for result = (check-accuracy 204 epi true) unless (eq nil result) append (list (list (list k n phi) result))) nil) commit 7fa2a4c33e7542f3538bfcfd15cba833120b0daf Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 24 23:01:08 2011 -0400 Add DOMAIN-ERROR condition; fix bug in FRESNEL-S-SERIES. qd-methods.lisp: o Define DOMAIN-ERROR condition to allow signaling errors for incorrect domains. qd-gamma.lisp: o Signal domain error in CF-INCOMPLETE-GAMMA-TAIL if necessary. o Fix bug in FRESNEL-S-SERIES. We were comparing a real against a complex. diff --git a/qd-gamma.lisp b/qd-gamma.lisp index 74a9032..78b5a99 100644 --- a/qd-gamma.lisp +++ b/qd-gamma.lisp @@ -235,6 +235,11 @@ ;; ;; See http://functions.wolfram.com/06.06.10.0003.01 (defun cf-incomplete-gamma-tail (a z) + (when (and (zerop (imagpart z)) (minusp (realpart z))) + (error 'domain-error + :function-name 'cf-incomplete-gamma-tail + :format-arguments (list 'z z) + :format-control "Argument ~S should not be on the negative real axis: ~S")) (/ (* (expt z a) (exp (- z))) (let ((z-a (- z a))) @@ -391,7 +396,7 @@ (sum 0) (term pi/2)) (loop for k2 from 0 by 2 - until (< (abs term) (* eps sum)) + until (< (abs term) (* eps (abs sum))) do (incf sum (/ term (+ 3 k2 k2))) (setf term (/ (* term factor) diff --git a/qd-methods.lisp b/qd-methods.lisp index 29b296d..e4df131 100644 --- a/qd-methods.lisp +++ b/qd-methods.lisp @@ -1123,3 +1123,14 @@ the same precision as the argument. The argument can be complex.")) (defmethod float-pi ((z qd-complex)) +pi+) + +(define-condition domain-error (simple-error) + ((function-name :accessor condition-function-name + :initarg :function-name)) + (:report (lambda (condition stream) + (format stream "Domain Error for function ~S:~&" + (condition-function-name condition)) + (pprint-logical-block (stream nil :per-line-prefix " ") + (apply #'format stream + (simple-condition-format-control condition) + (simple-condition-format-arguments condition)))))) \ No newline at end of file commit bed5763d1250d8b3b3793861f6e17449c49dd15b Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 24 14:48:55 2011 -0400 Fix incomplete-gamma-tail for negative reals, use series for Fresnel S for small arg and update tests. qd-gamma.lisp: o INCOMPLETE-GAMMA-TAIL was hanging for arguments on the negative real axis. Use INCOMPLETE-GAMMA in this case too. o Add the series expansion for Fresnel S and use it for evaluating it for small arguments. We were losing accuracy with the existing algorithm. rt-tests.lisp: o Update thresholds for elliptic-pi-n0.d, elliptic-pi.n2.q, theta3.1.d. o Fix typo in test name. gamma-incomplete-tail.1.q should have been 2.q. o Add tests for gamma-incomplete-tail for arguments on the negative real axis. o Add tests for Fresnel S. diff --git a/qd-gamma.lisp b/qd-gamma.lisp index c0cacaa..74a9032 100644 --- a/qd-gamma.lisp +++ b/qd-gamma.lisp @@ -288,10 +288,17 @@ (let* ((prec (float-contagion a z)) (a (apply-contagion a prec)) (z (apply-contagion z prec))) - (if (and (realp a) (realp z)) + (if (and (zerop (imagpart a)) + (zerop (imagpart z))) ;; For real values, we split the result to compute either the - ;; tail directly or from gamma(a) - incomplete-gamma - (if (> (abs z) (abs (- a 1))) + ;; tail directly from the continued fraction or from gamma(a) + ;; - incomplete-gamma. The continued fraction doesn't + ;; converge on the negative real axis, so we can't use that + ;; there. And accuracy appears to be better if z is "small". + ;; We take this to mean |z| < |a-1|. Note that |a-1| is the + ;; peak of the integrand. + (if (and (> (abs z) (abs (- a 1))) + (not (minusp (realpart z)))) (cf-incomplete-gamma-tail a z) (- (gamma a) (incomplete-gamma a z))) (cf-incomplete-gamma-tail a z)))) @@ -364,27 +371,90 @@ (* (expt z (- v 1)) (incomplete-gamma-tail (- 1 v) z))) +;; Series for Fresnel S +;; +;; S(z) = z^3*sum((%pi/2)^(2*k+1)(-z^4)^k/(2*k+1)!/(4*k+3), k, 0, inf) +;; +;; Compute as +;; +;; S(z) = z^3*sum(a(k)/(4*k+3), k, 0, inf) +;; +;; where +;; +;; a(k+1) = -a(k) * (%pi/2)^2 * z^4 / (2*k+2) / (2*k+3) +;; +;; a(0) = %pi/2. +(defun fresnel-s-series (z) + (let* ((pi/2 (* 1/2 (float-pi z))) + (factor (- (* (expt z 4) pi/2 pi/2))) + (eps (epsilon z)) + (sum 0) + (term pi/2)) + (loop for k2 from 0 by 2 + until (< (abs term) (* eps sum)) + do + (incf sum (/ term (+ 3 k2 k2))) + (setf term (/ (* term factor) + (* (+ k2 2) + (+ k2 3))))) + (* sum (expt z 3)))) + (defun fresnel-s (z) "Fresnel S: S(z) = integrate(sin(%pi*t^2/2), t, 0, z) " - (let ((sqrt-pi (sqrt (float-pi z)))) + (let ((prec (float-contagion z)) + (sqrt-pi (sqrt (float-pi z)))) (flet ((fs (z) ;; Wolfram gives ;; ;; S(z) = (1+%i)/4*(erf(c*z) - %i*erf(conjugate(c)*z)) ;; ;; where c = sqrt(%pi)/2*(1+%i). - (* #c(1/4 1/4) - (- (erf (* #c(1/2 1/2) sqrt-pi z)) - (* #c(0 1) - (erf (* #c(1/2 -1/2) sqrt-pi z))))))) - (if (realp z) - ;; FresnelS is real for a real argument. And it is odd. - (if (minusp z) - (- (realpart (fs (- z)))) - (realpart (fs z))) - (fs z))))) + ;; + ;; But for large z, we should use erfc. Then + ;; S(z) = 1/2 - (1+%i)/4*(erfc(c*z) - %i*erfc(conjugate(c)*z)) + (if (and t (> (abs z) 2)) + (- 1/2 + (* #c(1/4 1/4) + (- (erfc (* #c(1/2 1/2) sqrt-pi z)) + (* #c(0 1) + (erfc (* #c(1/2 -1/2) sqrt-pi z)))))) + (* #c(1/4 1/4) + (- (erf (* #c(1/2 1/2) sqrt-pi z)) + (* #c(0 1) + (erf (* #c(1/2 -1/2) sqrt-pi z))))))) + (rfs (z) + ;; When z is real, recall that erf(conjugate(z)) = + ;; conjugate(erf(z)). Then + ;; + ;; S(z) = 1/2*(realpart(erf(c*z)) - imagpart(erf(c*z))) + ;; + ;; But for large z, we should use erfc. Then + ;; + ;; S(z) = 1/2 - 1/2*(realpart(erfc(c*z)) - imagpart(erf(c*z))) + (if (> (abs z) 2) + (let ((s (erfc (* #c(1/2 1/2) sqrt-pi z)))) + (- 1/2 + (* 1/2 (- (realpart s) (imagpart s))))) + (let ((s (erf (* #c(1/2 1/2) sqrt-pi z)))) + (* 1/2 (- (realpart s) (imagpart s))))))) + ;; For small z, the erf terms above suffer from subtractive + ;; cancellation. So use the series in this case. Some simple + ;; tests were done to determine that for double-floats we want + ;; to use the series for z < 1 to give max accuracy. For + ;; qd-real, the above formula is good enough for z > 1d-5. + (if (< (abs z) (ecase prec + (single-float 1.5f0) + (double-float 1d0) + (qd-real #q1))) + (fresnel-s-series z) + (if (realp z) + ;; FresnelS is real for a real argument. And it is odd. + (if (minusp z) + (- (rfs (- z))) + (rfs z)) + (fs z)))))) (defun fresnel-c (z) "Fresnel C: diff --git a/rt-tests.lisp b/rt-tests.lisp index 5f4cdd5..ecb401a 100644 --- a/rt-tests.lisp +++ b/rt-tests.lisp @@ -1000,7 +1000,7 @@ for epi = (elliptic-pi n phi 0) for true = (/ (atan (* (tan phi) (sqrt (- 1 n)))) (sqrt (- 1 n))) - for result = (check-accuracy 47.5 epi true) + for result = (check-accuracy 46.5 epi true) unless (eq nil result) append (list (list (list k n phi) result))) nil) @@ -1059,7 +1059,7 @@ for epi = (elliptic-pi n phi 0) for true = (/ (atanh (* (tan phi) (sqrt (- n 1)))) (sqrt (- n 1))) - for result = (check-accuracy 206 epi true) + for result = (check-accuracy 202 epi true) ;; Not sure if this formula holds when atanh gives a complex ;; result. Wolfram doesn't say when (and (not (complexp true)) result) @@ -1075,7 +1075,7 @@ for m = (random 1d0) for t3 = (elliptic-theta-3 0 (elliptic-nome m)) for true = (sqrt (/ (* 2 (elliptic-k m)) (float-pi m))) - for result = (check-accuracy 51 t3 true) + for result = (check-accuracy 50.5 t3 true) when result append (list (list (list k m) result))) nil) @@ -1213,15 +1213,74 @@ nil) (rt:deftest gamma-incomplete-tail.1.q - (let* ((z 5d0) + (let* ((z #q5) (gi (incomplete-gamma-tail 2 z)) (true (* (+ z 1) (exp (- z))))) - (check-accuracy 212 gi true)) + (check-accuracy 207 gi true)) nil) -(rt:deftest gamma-incomplete-tail.1.q +(rt:deftest gamma-incomplete-tail.2.q (let* ((z #q(1 5)) (gi (incomplete-gamma-tail 2 z)) (true (* (+ z 1) (exp (- z))))) (check-accuracy 206 gi true)) nil) + +(rt:deftest gamma-incomplete-tail.3.d + (let* ((z -5d0) + (gi (incomplete-gamma-tail 2 z)) + (true (* (+ z 1) (exp (- z))))) + (check-accuracy 52 gi true)) + nil) + +(rt:deftest gamma-incomplete-tail.3.q + (let* ((z #q-5) + (gi (incomplete-gamma-tail 2 z)) + (true (* (+ z 1) (exp (- z))))) + (check-accuracy 206 gi true)) + nil) + + +;; Fresnel integrals. +;; +;; For x small, Fresnel +;; +;; S(z) = %pi/6*z^3*(1 - %pi^2*z^4/56 + %pi^4*z^8/2040 - ...) +;; +(defun fresnel-s-series (z) + (let* ((fpi (float-pi z)) + (z^3 (expt z 3)) + (z^4 (* z^3 z))) + (* fpi 1/6 z^3 + (+ 1 (/ (* fpi fpi z^4) + -56) + (/ (* (expt fpi 4) (expt z^4 2)) + 7040))))) + +(rt:deftest fresnel-s.1d + (let* ((z 1d-3) + (s (fresnel-s z)) + (true (fresnel-s-series z))) + (check-accuracy 52 s true)) + nil) + +(rt:deftest fresnel-s.2d + (let* ((z #c(1d-3 1d-3)) + (s (fresnel-s z)) + (true (fresnel-s-series z))) + (check-accuracy 52 s true)) + nil) + +(rt:deftest fresnel-s.1q + (let* ((z #q1q-20) + (s (fresnel-s z)) + (true (fresnel-s-series z))) + (check-accuracy 212 s true)) + nil) + +(rt:deftest fresnel-s.2q + (let* ((z #q(1q-3 1q-3)) + (s (fresnel-s z)) + (true (fresnel-s-series z))) + (check-accuracy 212 s true)) + nil) commit 70745f486e3ee012f02c080de0cf9daf00f37375 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 24 14:25:53 2011 -0400 qd-gamma depends on qd-reader. diff --git a/oct.asd b/oct.asd index e4011a9..7df866c 100644 --- a/oct.asd +++ b/oct.asd @@ -66,7 +66,7 @@ (:file "qd-theta" :depends-on ("qd-methods" "qd-reader")) (:file "qd-gamma" - :depends-on ("qd-methods")) + :depends-on ("qd-methods" "qd-reader")) )) (defmethod perform ((op test-op) (c (eql (find-system :oct)))) ----------------------------------------------------------------------- Summary of changes: oct.asd | 2 +- qd-gamma.lisp | 103 +++++++++++++++++++++++++++++++++++++++++++++++------- qd-methods.lisp | 11 ++++++ rt-tests.lisp | 73 +++++++++++++++++++++++++++++++++++---- 4 files changed, 167 insertions(+), 22 deletions(-) hooks/post-receive -- OCT: A portable Lisp implementation for quad-double precision floats

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. cc23f1098858d652c66728ea85c1c331bfb0fbb8
by Raymond Toy 22 Mar '11

22 Mar '11

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "OCT: A portable Lisp implementation for quad-double precision floats". The branch, master has been updated via cc23f1098858d652c66728ea85c1c331bfb0fbb8 (commit) via 6b8dc51d96004406780ec1faa2cd4ce3b127c287 (commit) via 97bc71a13186735474eba77043d685b0bd0a00d6 (commit) via 50fc6412a3effd9bea8f3e481f7c35c3c911f856 (commit) from d17228b86105b8a6ac652459b1100266ad0311b3 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit cc23f1098858d652c66728ea85c1c331bfb0fbb8 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Mar 21 19:39:24 2011 -0400 Move the uses of foo-t before the use of foo-t. diff --git a/qd.lisp b/qd.lisp index fb3e4e1..9f1ec3d 100644 --- a/qd.lisp +++ b/qd.lisp @@ -409,11 +409,6 @@ If TARGET is given, TARGET is destructively modified to contain the result." ;; which don't do a very good job with dataflow. CMUCL is one of ;; those compilers. -(defun add-qd (a b &optional (target #+oct-array (%make-qd-d 0d0 0d0 0d0 0d0))) - "Return the sum of the %QUAD-DOUBLE numbers A and B. -If TARGET is given, TARGET is destructively modified to contain the result." - (add-qd-t a b target)) - (defun add-qd-t (a b target) (declare (type %quad-double a b #+oct-array target) @@ -476,6 +471,12 @@ If TARGET is given, TARGET is destructively modified to contain the result." (%store-qd-d target (+ a0 b0) 0d0 0d0 0d0) (%store-qd-d target s0 s1 s2 s3))))))))))) +(defun add-qd (a b &optional (target #+oct-array (%make-qd-d 0d0 0d0 0d0 0d0))) + "Return the sum of the %QUAD-DOUBLE numbers A and B. +If TARGET is given, TARGET is destructively modified to contain the result." + (add-qd-t a b target)) + + (defun neg-qd-t (a target) (declare (type %quad-double a #+oct-array target) #+(and cmu (not oct-array)) (ignore target)) @@ -666,11 +667,6 @@ If TARGET is given, TARGET is destructively modified to contain the result." ;; Clisp says ;; 14.142135623730950488016887242096980785696718753769480731766797379908L0 -(defun mul-qd (a b &optional (target #+oct-array (%make-qd-d 0d0 0d0 0d0 0d0))) - "Returns the product of the %QUAD-DOUBLE numbers A and B. -If TARGET is given, TARGET is destructively modified to contain the result." - (mul-qd-t a b target)) - (defun mul-qd-t (a b target) (declare (type %quad-double a b #+oct-array target) (optimize (speed 3) @@ -736,6 +732,10 @@ If TARGET is given, TARGET is destructively modified to contain the result." (%store-qd-d target p0 0d0 0d0 0d0) (%store-qd-d target r0 r1 s0 s1)))))))))))))) +(defun mul-qd (a b &optional (target #+oct-array (%make-qd-d 0d0 0d0 0d0 0d0))) + "Returns the product of the %QUAD-DOUBLE numbers A and B. +If TARGET is given, TARGET is destructively modified to contain the result." + (mul-qd-t a b target)) ;; This is the non-sloppy version. I think this works just fine, but ;; since qd defaults to the sloppy multiplication version, we do the @@ -838,11 +838,6 @@ If TARGET is given, TARGET is destructively modified to contain the result." (multiple-value-call #'%make-qd-d (renorm-5 p0 p1 s0 t0 t1)))))))))))))))))))) -(defun sqr-qd (a &optional (target #+oct-array (%make-qd-d 0d0 0d0 0d0 0d0))) - "Return the square of the %QUAD-DOUBLE number A. If TARGET is also given, -it is destructively modified with the result." - (sqr-qd-t a target)) - (defun sqr-qd-t (a target) "Square A" (declare (type %quad-double a #+oct-array target) @@ -890,12 +885,11 @@ it is destructively modified with the result." (multiple-value-bind (a0 a1 a2 a3) (renorm-5 p0 p1 p2 p3 p4) (%store-qd-d target a0 a1 a2 a3))))))))) - -(defun div-qd (a b &optional (target #+oct-array (%make-qd-d 0d0 0d0 0d0 0d0))) - "Return the quotient of the two %QUAD-DOUBLE numbers A and B. -If TARGET is given, it destrutively modified with the result." - (div-qd-t a b target)) +(defun sqr-qd (a &optional (target #+oct-array (%make-qd-d 0d0 0d0 0d0 0d0))) + "Return the square of the %QUAD-DOUBLE number A. If TARGET is also given, +it is destructively modified with the result." + (sqr-qd-t a target)) #+nil (defun div-qd-t (a b target) @@ -948,6 +942,11 @@ If TARGET is given, it destrutively modified with the result." (renorm-4 q0 q1 q2 q3) (%store-qd-d target q0 q1 q2 q3)))))))) +(defun div-qd (a b &optional (target #+oct-array (%make-qd-d 0d0 0d0 0d0 0d0))) + "Return the quotient of the two %QUAD-DOUBLE numbers A and B. +If TARGET is given, it destrutively modified with the result." + (div-qd-t a b target)) + (declaim (inline invert-qd)) (defun invert-qd (v) commit 6b8dc51d96004406780ec1faa2cd4ce3b127c287 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Sat Mar 19 11:38:43 2011 -0400 Add rem and mod functions that were left out. diff --git a/qd-methods.lisp b/qd-methods.lisp index cbf0daa..29b296d 100644 --- a/qd-methods.lisp +++ b/qd-methods.lisp @@ -671,6 +671,12 @@ underlying floating-point format" (ceiling x y) (floor x y))) +(defun rem (x y) + (nth-value 1 (truncate x y))) + +(defun mod (x y) + (nth-value 1 (floor x y))) + (defun ftruncate (x &optional (y 1)) (if (minusp x) (fceiling x y) diff --git a/qd-package.lisp b/qd-package.lisp index b102435..7db5cd3 100644 --- a/qd-package.lisp +++ b/qd-package.lisp @@ -188,6 +188,8 @@ #:ftruncate #:round #:fround + #:rem + #:mod #:realpart #:imagpart #:conjugate @@ -258,6 +260,8 @@ #:ftruncate #:round #:fround + #:rem + #:mod #:realpart #:imagpart #:conjugate commit 97bc71a13186735474eba77043d685b0bd0a00d6 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Fri Mar 18 09:06:10 2011 -0400 Add series for incomplete-gamma for when the fraction is slow. o Add series for incomplete gamma function for small a and z. Needed because the continued fraction is slow in this range. o In INCOMPLETE-GAMMA-TAIL, call INCOMPLETE-GAMMA instead of CF-INCOMPLETE-GAMMA just in case a and z are small. o In INCOMPLETE-GAMMA, use the series for small a and z. o Simplify evaluation of Si(z) when z is real. diff --git a/qd-gamma.lisp b/qd-gamma.lisp index a6fc7cf..c0cacaa 100644 --- a/qd-gamma.lisp +++ b/qd-gamma.lisp @@ -265,6 +265,21 @@ #'(lambda (n) (- (* z (+ a n)))))))))) +;; Series expansion for incomplete gamma. Intended for |a|<1 and +;; |z|<1. The series is +;; +;; g(a,z) = z^a * sum((-z)^k/k!/(a+k), k, 0, inf) +(defun s-incomplete-gamma (a z) + (let ((-z (- z)) + (eps (epsilon z))) + (loop for k from 0 + for term = 1 then (* term (/ -z k)) + for sum = (/ a) then (+ sum (/ term (+ a k))) + when (< (abs term) (* (abs sum) eps)) + return (* sum (expt z a))))) + + + ;; Tail of the incomplete gamma function. (defun incomplete-gamma-tail (a z) "Tail of the incomplete gamma function defined by: @@ -276,9 +291,9 @@ (if (and (realp a) (realp z)) ;; For real values, we split the result to compute either the ;; tail directly or from gamma(a) - incomplete-gamma - (if (> z (- a 1)) + (if (> (abs z) (abs (- a 1))) (cf-incomplete-gamma-tail a z) - (- (gamma a) (cf-incomplete-gamma a z))) + (- (gamma a) (incomplete-gamma a z))) (cf-incomplete-gamma-tail a z)))) (defun incomplete-gamma (a z) @@ -288,13 +303,18 @@ (let* ((prec (float-contagion a z)) (a (apply-contagion a prec)) (z (apply-contagion z prec))) - (if (and (realp a) (realp z)) - (if (< z (- a 1)) - (cf-incomplete-gamma a z) - (- (gamma a) (cf-incomplete-gamma-tail a z))) - (if (< (abs z) (abs a)) - (cf-incomplete-gamma a z) - (- (gamma a) (cf-incomplete-gamma-tail a z)))))) + (if (and (< (abs a) 1) (< (abs z) 1)) + (s-incomplete-gamma a z) + (if (and (realp a) (realp z)) + (if (< z (- a 1)) + (cf-incomplete-gamma a z) + (- (gamma a) (cf-incomplete-gamma-tail a z))) + ;; The continued fraction doesn't converge very fast if a + ;; and z are small. In this case, use the series + ;; expansion instead, which converges quite rapidly. + (if (< (abs z) (abs a)) + (cf-incomplete-gamma a z) + (- (gamma a) (cf-incomplete-gamma-tail a z))))))) (defun erf (z) "Error function: @@ -405,9 +425,20 @@ (- (log -iz) (log iz))))))) (if (realp z) - (if (< z 0) - (- (sin-integral (- z))) - (si z)) + ;; Si is odd and real for real z. In this case, we have + ;; + ;; Si(x) = %i/2*(gamma_inc_tail(0, -%i*x) - gamma_inc_tail(0, %i*x) - %i*%pi) + ;; = %pi/2 + %i/2*(gamma_inc_tail(0, -%i*x) - gamma_inc_tail(0, %i*x)) + ;; But gamma_inc_tail(0, conjugate(z)) = conjugate(gamma_inc_tail(0, z)), so + ;; + ;; Si(x) = %pi/2 + imagpart(gamma_inc_tail(0, %i*x)) + (cond ((< z 0) + (- (sin-integral (- z)))) + ((= z 0) + (* 0 z)) + (t + (+ (* 1/2 (float-pi z)) + (imagpart (incomplete-gamma-tail 0 (complex 0 z)))))) (si z)))) (defun cos-integral (z) commit 50fc6412a3effd9bea8f3e481f7c35c3c911f856 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 17 23:12:30 2011 -0400 Implement Si and Ci, sin and cos integrals. diff --git a/qd-gamma.lisp b/qd-gamma.lisp index dfc87a6..a6fc7cf 100644 --- a/qd-gamma.lisp +++ b/qd-gamma.lisp @@ -387,4 +387,49 @@ (- (realpart (fs (- z)))) (realpart (fs z))) (fs z))))) - \ No newline at end of file + +(defun sin-integral (z) + "Sin integral: + + Si(z) = integrate(sin(t)/t, t, 0, z)" + ;; Wolfram has + ;; + ;; Si(z) = %i/2*(gamma_inc_tail(0, -%i*z) - gamma_inc_tail(0, %i*z) + log(-%i*z)-log(%i*z)) + ;; + (flet ((si (z) + (* #c(0 1/2) + (let ((iz (* #c(0 1) z)) + (-iz (* #c(0 -1) z))) + (+ (- (incomplete-gamma-tail 0 -iz) + (incomplete-gamma-tail 0 iz)) + (- (log -iz) + (log iz))))))) + (if (realp z) + (if (< z 0) + (- (sin-integral (- z))) + (si z)) + (si z)))) + +(defun cos-integral (z) + "Cos integral: + + Ci(z) = integrate((cos(t) - 1)/t, t, 0, z) + log(z) + gamma + + where gamma is Euler-Mascheroni constant" + ;; Wolfram has + ;; + ;; Ci(z) = log(z) - 1/2*(gamma_inc_tail(0, -%i*z) + gamma_inc_tail(0, %i*z) + log(-%i*z)+log(%i*z)) + ;; + (flet ((ci (z) + (- (log z) + (* 1/2 + (let ((iz (* #c(0 1) z)) + (-iz (* #c(0 -1) z))) + (+ (+ (incomplete-gamma-tail 0 -iz) + (incomplete-gamma-tail 0 iz)) + (+ (log -iz) + (log iz)))))))) + (if (and (realp z) (plusp z)) + (realpart (ci z)) + (ci z)))) + \ No newline at end of file ----------------------------------------------------------------------- Summary of changes: qd-gamma.lisp | 96 +++++++++++++++++++++++++++++++++++++++++++++++++------ qd-methods.lisp | 6 +++ qd-package.lisp | 4 ++ qd.lisp | 39 +++++++++++----------- 4 files changed, 115 insertions(+), 30 deletions(-) hooks/post-receive -- OCT: A portable Lisp implementation for quad-double precision floats

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. d17228b86105b8a6ac652459b1100266ad0311b3
by Raymond Toy 18 Mar '11

18 Mar '11

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. 46e7193fb5b2fad35e67366ff375d9ebbb524c5c
by Raymond Toy 17 Mar '11

17 Mar '11

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "OCT: A portable Lisp implementation for quad-double precision floats". The branch, master has been updated via 46e7193fb5b2fad35e67366ff375d9ebbb524c5c (commit) via 8227b233c4ba1f58d7928cdd5020201a5465c10d (commit) via 9d3c8cf17f1d644be01749fe91484c514eb80d3c (commit) via b725d6ef804b369ede3bc4bf037bd746a5d32406 (commit) from a40062c6860e8e778c1b15a48c2687c6cd2f5334 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 46e7193fb5b2fad35e67366ff375d9ebbb524c5c Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 17 13:37:29 2011 -0400 Implement exponential integral E. diff --git a/qd-gamma.lisp b/qd-gamma.lisp index 4781167..a25bc7d 100644 --- a/qd-gamma.lisp +++ b/qd-gamma.lisp @@ -333,3 +333,11 @@ (+ 1 (/ (incomplete-gamma 1/2 (* z z)) (sqrt (float-pi z)))))) + +(defun exp-integral-e (v z) + "Exponential integral E: + + E(v,z) = integrate(exp(-t)/t^v, t, 1, inf)" + ;; Wolfram gives E(v,z) = z^(v-1)*gamma_incomplete_tail(1-v,z) + (* (expt z (- v 1)) + (incomplete-gamma-tail (- 1 v) z))) commit 8227b233c4ba1f58d7928cdd5020201a5465c10d Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 17 13:20:43 2011 -0400 Implement erfc; fix erf(-z), add comments. o Was returning the wrong value for erf(-z). Use erf(-z) = - erf(z). o Add implementation of erfc. o Document code and algorithms a bit better. diff --git a/qd-gamma.lisp b/qd-gamma.lisp index dbdd4c7..4781167 100644 --- a/qd-gamma.lisp +++ b/qd-gamma.lisp @@ -267,6 +267,9 @@ ;; Tail of the incomplete gamma function. (defun incomplete-gamma-tail (a z) + "Tail of the incomplete gamma function defined by: + + integrate(t^(a-1)*exp(-t), t, z, inf)" (let* ((prec (float-contagion a z)) (a (apply-contagion a prec)) (z (apply-contagion z prec))) @@ -279,6 +282,9 @@ (cf-incomplete-gamma-tail a z)))) (defun incomplete-gamma (a z) + "Incomplete gamma function defined by: + + integrate(t^(a-1)*exp(-t), t, 0, z)" (let* ((prec (float-contagion a z)) (a (apply-contagion a prec)) (z (apply-contagion z prec))) @@ -289,5 +295,41 @@ (cf-incomplete-gamma a z)))) (defun erf (z) - (/ (incomplete-gamma 1/2 (* z z)) - (sqrt (float-pi z)))) + "Error function: + + erf(z) = 2/sqrt(%pi)*sum((-1)^k*z^(2*k+1)/k!/(2*k+1), k, 0, inf) + + For real z, this is equivalent to + + erf(z) = 2/sqrt(%pi)*integrate(exp(-t^2), t, 0, z) for real z." + ;; + ;; Erf is an odd function: erf(-z) = -erf(z) + (if (minusp (realpart z)) + (- (erf (- z))) + (/ (incomplete-gamma 1/2 (* z z)) + (sqrt (float-pi z))))) + +(defun erfc (z) + "Complementary error function: + + erfc(z) = 1 - erf(z)" + ;; Compute erfc(z) via 1 - erf(z) is not very accurate if erf(z) is + ;; near 1. Wolfram says + ;; + ;; erfc(z) = 1 - sqrt(z^2)/z * (1 - 1/sqrt(pi)*gamma_incomplete_tail(1/2, z^2)) + ;; + ;; For real(z) > 0, sqrt(z^2)/z is 1 so + ;; + ;; erfc(z) = 1 - (1 - 1/sqrt(pi)*gamma_incomplete_tail(1/2,z^2)) + ;; = 1/sqrt(pi)*gamma_incomplete_tail(1/2,z^2) + ;; + ;; For real(z) < 0, sqrt(z^2)/z is -1 so + ;; + ;; erfc(z) = 1 + (1 - 1/sqrt(pi)*gamma_incomplete_tail(1/2,z^2)) + ;; = 1 + 1/sqrt(pi)*gamma_incomplete(1/2,z^2) + (if (>= (realpart z) 0) + (/ (incomplete-gamma-tail 1/2 (* z z)) + (sqrt (float-pi z))) + (+ 1 + (/ (incomplete-gamma 1/2 (* z z)) + (sqrt (float-pi z)))))) commit 9d3c8cf17f1d644be01749fe91484c514eb80d3c Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 17 11:41:45 2011 -0400 Add implementation for incomplete gamma and erf, with tests. qd-gamma.lisp: o Add implementation for Lentz's algorithm for evaluating continued fractions. o Implement incomplete-gamma and incomplete-gamma-tail using continued fractions. o Implement erf rt-tests.lisp: o Add tests diff --git a/qd-gamma.lisp b/qd-gamma.lisp index bb9004a..dbdd4c7 100644 --- a/qd-gamma.lisp +++ b/qd-gamma.lisp @@ -168,3 +168,126 @@ (defmethod gamma ((z qd-complex)) (gamma-aux z 39 32)) + +;; Lentz's algorithm for evaluating continued fractions. +;; +;; Let the continued fraction be: +;; +;; a1 a2 a3 +;; b0 + ---- ---- ---- +;; b1 + b2 + b3 + +;; +(defun lentz (bf af) + (flet ((value-or-tiny (v) + (if (zerop v) + (etypecase v + ((or double-float cl:complex) + least-positive-normalized-double-float) + ((or qd-real qd-complex) + (make-qd least-positive-normalized-double-float))) + v))) + (let* ((f (value-or-tiny (funcall bf 0))) + (c f) + (d 0) + (eps (epsilon f))) + (loop + for j from 1 + for an = (funcall af j) + for bn = (funcall bf j) + do (progn + (setf d (value-or-tiny (+ bn (* an d)))) + (setf c (value-or-tiny (+ bn (/ an c)))) + (setf d (/ d)) + (let ((delta (* c d))) + (setf f (* f delta)) + (when (<= (abs (- delta 1)) eps) + (return))))) + f))) + +;; Continued fraction for erf(b): +;; +;; z[n] = 1+2*n-2*z^2 +;; a[n] = 4*n*z^2 +;; +;; This works ok, but has problems for z > 3 where sometimes the +;; result is greater than 1. +#+nil +(defun erf (z) + (let* ((z2 (* z z)) + (twoz2 (* 2 z2))) + (* (/ (* 2 z) + (sqrt (float-pi z))) + (exp (- z2)) + (/ (lentz #'(lambda (n) + (- (+ 1 (* 2 n)) + twoz2)) + #'(lambda (n) + (* 4 n z2))))))) + +;; Tail of the incomplete gamma function: +;; integrate(x^(a-1)*exp(-x), x, z, inf) +;; +;; The continued fraction, valid for all z except the negative real +;; axis: +;; +;; b[n] = 1+2*n+z-a +;; a[n] = n*(a-n) +;; +;; See http://functions.wolfram.com/06.06.10.0003.01 +(defun cf-incomplete-gamma-tail (a z) + (/ (* (expt z a) + (exp (- z))) + (let ((z-a (- z a))) + (lentz #'(lambda (n) + (+ n n 1 z-a)) + #'(lambda (n) + (* n (- a n))))))) + +;; Incomplete gamma function: +;; integrate(x^(a-1)*exp(-x), x, 0, z) +;; +;; The continued fraction, valid for all z except the negative real +;; axis: +;; +;; b[n] = n - 1 + z + a +;; a[n] = -z*(a + n) +;; +;; See http://functions.wolfram.com/06.06.10.0005.01. We modified the +;; continued fraction slightly and discarded the first quotient from +;; the fraction. +(defun cf-incomplete-gamma (a z) + (/ (* (expt z a) + (exp (- z))) + (let ((za1 (+ z a 1))) + (- a (/ (* a z) + (lentz #'(lambda (n) + (+ n za1)) + #'(lambda (n) + (- (* z (+ a n)))))))))) + +;; Tail of the incomplete gamma function. +(defun incomplete-gamma-tail (a z) + (let* ((prec (float-contagion a z)) + (a (apply-contagion a prec)) + (z (apply-contagion z prec))) + (if (and (realp a) (realp z)) + ;; For real values, we split the result to compute either the + ;; tail directly or from gamma(a) - incomplete-gamma + (if (> z (- a 1)) + (cf-incomplete-gamma-tail a z) + (- (gamma a) (cf-incomplete-gamma a z))) + (cf-incomplete-gamma-tail a z)))) + +(defun incomplete-gamma (a z) + (let* ((prec (float-contagion a z)) + (a (apply-contagion a prec)) + (z (apply-contagion z prec))) + (if (and (realp a) (realp z)) + (if (< z (- a 1)) + (cf-incomplete-gamma a z) + (- (gamma a) (cf-incomplete-gamma-tail a z))) + (cf-incomplete-gamma a z)))) + +(defun erf (z) + (/ (incomplete-gamma 1/2 (* z z)) + (sqrt (float-pi z)))) diff --git a/rt-tests.lisp b/rt-tests.lisp index 59d798f..5f4cdd5 100644 --- a/rt-tests.lisp +++ b/rt-tests.lisp @@ -1111,7 +1111,7 @@ for m = (random #q1) for t3 = (elliptic-theta-2 0 (elliptic-nome m)) for true = (sqrt (/ (* 2 (sqrt m) (elliptic-k m)) (float-pi m))) - for result = (check-accuracy 206 t3 true) + for result = (check-accuracy 205 t3 true) when result append (list (list (list k m) result))) nil) @@ -1195,3 +1195,33 @@ when result append (list (list (list k y) result))) nil) + +;; gamma_incomplete(2,z) = integrate(t*exp(-t), t, z, inf) +;; = (z+1)*exp(-z) +(rt:deftest gamma-incomplete-tail.1.d + (let* ((z 5d0) + (gi (incomplete-gamma-tail 2 z)) + (true (* (+ z 1) (exp (- z))))) + (check-accuracy 52 gi true)) + nil) + +(rt:deftest gamma-incomplete-tail.2.d + (let* ((z #c(1 5d0)) + (gi (incomplete-gamma-tail 2 z)) + (true (* (+ z 1) (exp (- z))))) + (check-accuracy 50 gi true)) + nil) + +(rt:deftest gamma-incomplete-tail.1.q + (let* ((z 5d0) + (gi (incomplete-gamma-tail 2 z)) + (true (* (+ z 1) (exp (- z))))) + (check-accuracy 212 gi true)) + nil) + +(rt:deftest gamma-incomplete-tail.1.q + (let* ((z #q(1 5)) + (gi (incomplete-gamma-tail 2 z)) + (true (* (+ z 1) (exp (- z))))) + (check-accuracy 206 gi true)) + nil) commit b725d6ef804b369ede3bc4bf037bd746a5d32406 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Mar 17 11:38:43 2011 -0400 Add missing methods for QEXPT. o We weren't handling the case of (expt real qd-complex). Add a method for this and other missing methods for QEXPT. o Move float contagion stuff from the end to the beginning so we can use it in this file. diff --git a/qd-methods.lisp b/qd-methods.lisp index 9341311..cbf0daa 100644 --- a/qd-methods.lisp +++ b/qd-methods.lisp @@ -29,6 +29,59 @@ ;; We should do something better than this. (make-instance 'qd-real :value (rational-to-qd x))) +;; Determine which of x and y has the higher precision and return the +;; value of the higher precision number. If both x and y are +;; rationals, just return 1f0, for a single-float value. +(defun float-contagion-2 (x y) + (etypecase x + (cl:rational + (etypecase y + (cl:rational + 1f0) + (cl:float + y) + (qd-real + y))) + (single-float + (etypecase y + ((or cl:rational single-float) + x) + ((or double-float qd-real) + y))) + (double-float + (etypecase y + ((or cl:rational single-float double-float) + x) + (qd-real + y))) + (qd-real + x))) + +;; Return a floating point (or complex) type of the highest precision +;; among all of the given arguments. +(defun float-contagion (&rest args) + ;; It would be easy if we could just add the args together and let + ;; normal contagion do the work, but we could easily introduce + ;; overflows or other errors that way. So look at each argument and + ;; determine the precision and choose the highest precision. + (let ((complexp (some #'complexp args)) + (max-type + (etypecase (reduce #'float-contagion-2 (mapcar #'realpart (if (cdr args) + args + (list (car args) 0)))) + (single-float 'single-float) + (double-float 'double-float) + (qd-real 'qd-real)))) + max-type)) + +(defun apply-contagion (number precision) + (etypecase number + ((or cl:real qd-real) + (coerce number precision)) + ((or cl:complex qd-complex) + (complex (coerce (realpart number) precision) + (coerce (imagpart number) precision))))) + (defmethod add1 ((a number)) (cl::1+ a)) @@ -425,10 +478,13 @@ underlying floating-point format" (defmethod qexpt ((x number) (y number)) (cl:expt x y)) -(defmethod qexpt ((x qd-real) (y real)) - (exp (* y (log x)))) +(defmethod qexpt ((x number) (y qd-real)) + (exp (* y (log (apply-contagion x 'qd-real))))) + +(defmethod qexpt ((x number) (y qd-complex)) + (exp (* y (log (apply-contagion x 'qd-real))))) -(defmethod qexpt ((x real) (y qd-real)) +(defmethod qexpt ((x qd-real) (y real)) (exp (* y (log x)))) (defmethod qexpt ((x qd-real) (y cl:complex)) @@ -437,12 +493,6 @@ underlying floating-point format" :imag (qd-value (imagpart y))) (log x)))) -(defmethod qexpt ((x cl:complex) (y qd-real)) - (exp (* y - (log (make-instance 'qd-complex - :real (qd-value (realpart x)) - :imag (qd-value (imagpart x))))))) - (defmethod qexpt ((x qd-real) (y qd-real)) ;; x^y = exp(y*log(x)) (exp (* y (log x)))) @@ -451,6 +501,15 @@ underlying floating-point format" (make-instance 'qd-real :value (npow (qd-value x) y))) +(defmethod qexpt ((x qd-complex) (y number)) + (exp (* y (log x)))) + +(defmethod qexpt ((x qd-complex) (y qd-real)) + (exp (* y (log x)))) + +(defmethod qexpt ((x qd-complex) (y qd-complex)) + (exp (* y (log x)))) + (declaim (inline expt)) (defun expt (x y) (qexpt x y)) @@ -1058,56 +1117,3 @@ the same precision as the argument. The argument can be complex.")) (defmethod float-pi ((z qd-complex)) +pi+) -;; Determine which of x and y has the higher precision and return the -;; value of the higher precision number. If both x and y are -;; rationals, just return 1f0, for a single-float value. -(defun float-contagion-2 (x y) - (etypecase x - (cl:rational - (etypecase y - (cl:rational - 1f0) - (cl:float - y) - (qd-real - y))) - (single-float - (etypecase y - ((or cl:rational single-float) - x) - ((or double-float qd-real) - y))) - (double-float - (etypecase y - ((or cl:rational single-float double-float) - x) - (qd-real - y))) - (qd-real - x))) - -;; Return a floating point (or complex) type of the highest precision -;; among all of the given arguments. -(defun float-contagion (&rest args) - ;; It would be easy if we could just add the args together and let - ;; normal contagion do the work, but we could easily introduce - ;; overflows or other errors that way. So look at each argument and - ;; determine the precision and choose the highest precision. - (let ((complexp (some #'complexp args)) - (max-type - (etypecase (reduce #'float-contagion-2 (mapcar #'realpart (if (cdr args) - args - (list (car args) 0)))) - (single-float 'single-float) - (double-float 'double-float) - (qd-real 'qd-real)))) - max-type)) - -(defun apply-contagion (number precision) - (etypecase number - ((or cl:real qd-real) - (coerce number precision)) - ((or cl:complex qd-complex) - (complex (coerce (realpart number) precision) - (coerce (imagpart number) precision))))) - ----------------------------------------------------------------------- Summary of changes: qd-gamma.lisp | 173 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ qd-methods.lisp | 130 ++++++++++++++++++++++-------------------- rt-tests.lisp | 32 ++++++++++- 3 files changed, 272 insertions(+), 63 deletions(-) hooks/post-receive -- OCT: A portable Lisp implementation for quad-double precision floats

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. a40062c6860e8e778c1b15a48c2687c6cd2f5334
by Raymond Toy 16 Mar '11

16 Mar '11

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "OCT: A portable Lisp implementation for quad-double precision floats". The branch, master has been updated via a40062c6860e8e778c1b15a48c2687c6cd2f5334 (commit) via a666f3923b82be0eb435ddd3e9b20697097fafe0 (commit) via a93aca9a6cfdb5b1305cb2570eea23e6f44b51c0 (commit) from c6f0a5ef00138c7f504432e0d0f485c23328274a (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit a40062c6860e8e778c1b15a48c2687c6cd2f5334 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Wed Mar 16 19:43:54 2011 -0400 Add gamma and log-gamma functions; work in progress. oct.asd: o Add qd-gamma.lisp. The implementations need some work. The accuracy is less than desired because gamma(2.0) /= 1. It's close but not quite right. rt-tests.lisp: o Basic tests of the gamma function. Accuracy is not as good as we would ike. qd-gamma.lisp: o New file for implementation of gamma function. diff --git a/oct.asd b/oct.asd index 89b56ee..e4011a9 100644 --- a/oct.asd +++ b/oct.asd @@ -65,6 +65,8 @@ :depends-on ("qd-methods" "qd-reader")) (:file "qd-theta" :depends-on ("qd-methods" "qd-reader")) + (:file "qd-gamma" + :depends-on ("qd-methods")) )) (defmethod perform ((op test-op) (c (eql (find-system :oct)))) diff --git a/qd-gamma.lisp b/qd-gamma.lisp new file mode 100644 index 0000000..bb9004a --- /dev/null +++ b/qd-gamma.lisp @@ -0,0 +1,170 @@ +;;;; -*- Mode: lisp -*- +;;;; +;;;; Copyright (c) 2011 Raymond Toy +;;;; Permission is hereby granted, free of charge, to any person +;;;; obtaining a copy of this software and associated documentation +;;;; files (the "Software"), to deal in the Software without +;;;; restriction, including without limitation the rights to use, +;;;; copy, modify, merge, publish, distribute, sublicense, and/or sell +;;;; copies of the Software, and to permit persons to whom the +;;;; Software is furnished to do so, subject to the following +;;;; conditions: +;;;; +;;;; The above copyright notice and this permission notice shall be +;;;; included in all copies or substantial portions of the Software. +;;;; +;;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +;;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +;;;; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +;;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +;;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +;;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +;;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +;;;; OTHER DEALINGS IN THE SOFTWARE. + +(in-package #:oct) + +(eval-when (:compile-toplevel :load-toplevel :execute) + (setf *readtable* *oct-readtable*)) + +;; For log-gamma we use the asymptotic formula +;; +;; log(gamma(z)) ~ (z - 1/2)*log(z) + log(2*%pi)/2 +;; + sum(bern(2*k)/(2*k)/(2*k-1)/z^(2k-1), k, 1, inf) +;; +;; = (z - 1/2)*log(z) + log(2*%pi)/2 +;; + 1/12/z*(1 - 1/30/z^2 + 1/105/z^4 + 1/140/z^6 + ... +;; + 174611/10450/z^18 + ...) +;; +;; For double-floats, let's stop the series at the power z^18. The +;; next term is 77683/483/z^20. This means that for |z| > 8.09438, +;; the series has double-float precision. +;; +;; For quad-doubles, let's stop the series at the power z^62. The +;; next term is about 6.364d37/z^64. So for |z| > 38.71, the series +;; has quad-double precision. +(defparameter *log-gamma-asymp-coef* + #(-1/30 1/105 -1/140 1/99 -691/30030 1/13 -3617/10200 43867/20349 + -174611/10450 77683/483 -236364091/125580 657931/25 -3392780147/7830 + 1723168255201/207669 -7709321041217/42160 151628697551/33 + -26315271553053477373/201514950 154210205991661/37 + -261082718496449122051/1758900 1520097643918070802691/259161 + -2530297234481911294093/9890 25932657025822267968607/2115 + -5609403368997817686249127547/8725080 19802288209643185928499101/539 + -61628132164268458257532691681/27030 29149963634884862421418123812691/190323 + -354198989901889536240773677094747/31900 + 2913228046513104891794716413587449/3363 + -1215233140483755572040304994079820246041491/16752085350 + 396793078518930920708162576045270521/61 + -106783830147866529886385444979142647942017/171360 + 133872729284212332186510857141084758385627191/2103465 + )) + +#+nil +(defun log-gamma-asymp-series (z nterms) + ;; Sum the asymptotic formula for n terms + ;; + ;; 1 + sum(c[k]/z^(2*k+2), k, 0, nterms) + (let ((z2 (* z z)) + (sum 1) + (term 1)) + (dotimes (k nterms) + (setf term (* term z2)) + (incf sum (/ (aref *log-gamma-asymp-coef* k) term))) + sum)) + +(defun log-gamma-asymp-series (z nterms) + (loop with y = (* z z) + for k from 1 to nterms + for x = 0 then + (setf x (/ (+ x (aref *log-gamma-asymp-coef* (- nterms k))) + y)) + finally (return (+ 1 x)))) + + +(defun log-gamma-asymp-principal (z nterms log2pi/2) + (+ (- (* (- z 1/2) + (log z)) + z) + log2pi/2)) + +(defun log-gamma-asymp (z nterms log2pi/2) + (+ (log-gamma-asymp-principal z nterms log2pi/2) + (* 1/12 (/ (log-gamma-asymp-series z nterms) z)))) + +(defun log2pi/2 (precision) + (ecase precision + (single-float + (coerce (/ (log (* 2 pi)) 2) 'single-float)) + (double-float + (coerce (/ (log (* 2 pi)) 2) 'double-float)) + (qd-real + (/ (log +2pi+) 2)))) + +(defun log-gamma-aux (z limit nterms) + (let ((precision (float-contagion z))) + (cond ((minusp (realpart z)) + ;; Use reflection formula if realpart(z) < 0 + ;; log(gamma(-z)) = log(pi)-log(-z)-log(sin(pi*z))-log(gamma(z)) + ;; Or + ;; log(gamma(z)) = log(pi)-log(-z)-log(sin(pi*z))-log(gamma(-z)) + (- (apply-contagion (log pi) precision) + (log (- z)) + (apply-contagion (log (sin (* pi z))) precision) + (log-gamma (- z)))) + (t + (let ((absz (abs z))) + (cond ((>= absz limit) + ;; Can use the asymptotic formula directly with 9 terms + (log-gamma-asymp z nterms (log2pi/2 precision))) + (t + ;; |z| is too small. Use the formula + ;; log(gamma(z)) = log(gamma(z+1)) - log(z) + (- (log-gamma (+ z 1)) + (log z))))))))) + +(defmethod log-gamma ((z cl:number)) + (log-gamma-aux z 9 9)) + +(defmethod log-gamma ((z qd-real)) + (log-gamma-aux z 26 26)) + +(defmethod log-gamma ((z qd-complex)) + (log-gamma-aux z 26 26)) + +(defun gamma-aux (z limit nterms) + (let ((precision (float-contagion z))) + (cond ((minusp (realpart z)) + ;; Use reflection formula if realpart(z) < 0: + ;; gamma(-z) = -pi*csc(pi*z)/gamma(z+1) + ;; or + ;; gamma(z) = pi*csc(pi*z)/gamma(1-z) + (/ (float-pi z) + (sin (* (float-pi z) z)) + (gamma-aux (- 1 z) limit nterms))) + (t + (let ((absz (abs z))) + (cond ((>= absz limit) + ;; Use log gamma directly: + ;; log(gamma(z)) = principal part + 1/12/z*(series part) + ;; so + ;; gamma(z) = exp(principal part)*exp(1/12/z*series) + (exp (log-gamma z)) + #+nil + (* (exp (log-gamma-asymp-principal z nterms + (log2pi/2 precision))) + (exp (* 1/12 (/ (log-gamma-asymp-series z nterms) z))))) + (t + ;; 1 <= |z| <= limit + ;; gamma(z) = gamma(z+1)/z + (/ (gamma-aux (+ 1 z) limit nterms) z)))))))) + +(defmethod gamma ((z cl:number)) + (gamma-aux z 9 9)) + +(defmethod gamma ((z qd-real)) + (gamma-aux z 39 32)) + +(defmethod gamma ((z qd-complex)) + (gamma-aux z 39 32)) + diff --git a/rt-tests.lisp b/rt-tests.lisp index c624f4a..59d798f 100644 --- a/rt-tests.lisp +++ b/rt-tests.lisp @@ -1141,3 +1141,57 @@ when result append (list (list (list k m) result))) nil) + +(rt:deftest gamma.1.d + (let ((g (gamma 0.5d0)) + (true (sqrt pi))) + ;; This should give full accuracy but doesn't. + (check-accuracy 51 g true)) + nil) + +(rt:deftest gamma.1.q + (let ((g (gamma #q0.5)) + (true (sqrt +pi+))) + ;; This should give full accuracy but doesn't. + (check-accuracy 197 g true)) + nil) + +(rt:deftest gamma.2.d + (loop for k from 0 below 100 + for y = (+ 1 (random 100d0)) + for g = (abs (gamma (complex 0 y))) + for true = (sqrt (/ pi y (sinh (* pi y)))) + for result = (check-accuracy 45 g true) + when result + append (list (list (list k y) result))) + nil) + +(rt:deftest gamma.2.q + (loop for k from 0 below 100 + for y = (+ 1 (random #q100)) + for g = (abs (gamma (complex 0 y))) + for true = (sqrt (/ +pi+ y (sinh (* +pi+ y)))) + for result = (check-accuracy 196 g true) + when result + append (list (list (list k y) result))) + nil) + +(rt:deftest gamma.3.d + (loop for k from 0 below 100 + for y = (+ 1 (random 100d0)) + for g = (abs (gamma (complex 1/2 y))) + for true = (sqrt (/ pi (cosh (* pi y)))) + for result = (check-accuracy 44 g true) + when result + append (list (list (list k y) result))) + nil) + +(rt:deftest gamma.3.q + (loop for k from 0 below 100 + for y = (+ 1 (random #q100)) + for g = (abs (gamma (complex 1/2 y))) + for true = (sqrt (/ +pi+ (cosh (* +pi+ y)))) + for result = (check-accuracy 196 g true) + when result + append (list (list (list k y) result))) + nil) commit a666f3923b82be0eb435ddd3e9b20697097fafe0 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Wed Mar 16 19:41:33 2011 -0400 QCOMPLEX takes two required args now. Fixes issues like (complex 1/2 #q1), which was signaling an error. qd-class.lisp: o Update defgeneric for QCOMPLEX for two required args. qd-methods.lisp: o Update existing QCOMPLEX methods to take two args. o Add methods to QCOMPLEX to handle the missing cases. diff --git a/qd-class.lisp b/qd-class.lisp index 2134ef7..43cc2e9 100644 --- a/qd-class.lisp +++ b/qd-class.lisp @@ -203,8 +203,8 @@ (defgeneric qexpt (x y) (:documentation "X^Y")) -(defgeneric qcomplex (x &optional y) - (:documentation "Create a complex number with components X and Y. If Y not given, assume 0")) +(defgeneric qcomplex (x y) + (:documentation "Create a complex number with components X and Y.")) (defgeneric qinteger-decode-float (f) (:documentation "integer-decode-float")) diff --git a/qd-methods.lisp b/qd-methods.lisp index fa27ce2..9341311 100644 --- a/qd-methods.lisp +++ b/qd-methods.lisp @@ -507,13 +507,21 @@ underlying floating-point format" (return nil))) (return nil)))) -(defmethod qcomplex ((x real) &optional y) - (cl:complex x (if y y 0))) +(defmethod qcomplex ((x cl:real) (y cl:real)) + (cl:complex x y)) -(defmethod qcomplex ((x qd-real) &optional y) +(defmethod qcomplex ((x cl:real) (y qd-real)) + (qcomplex (make-qd x) y)) + +(defmethod qcomplex ((x qd-real) (y qd-real)) + (make-instance 'qd-complex + :real (qd-value x) + :imag (qd-value y))) + +(defmethod qcomplex ((x qd-real) (y cl:real)) (make-instance 'qd-complex :real (qd-value x) - :imag (if y (qd-value y) +qd-zero+))) + :imag (make-qd-d y))) (defun complex (x &optional (y 0)) (qcomplex x y)) commit a93aca9a6cfdb5b1305cb2570eea23e6f44b51c0 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Tue Mar 15 13:14:05 2011 -0400 Move float-contagion stuff to qd-methods. diff --git a/qd-elliptic.lisp b/qd-elliptic.lisp index 385f00f..475763b 100644 --- a/qd-elliptic.lisp +++ b/qd-elliptic.lisp @@ -29,59 +29,6 @@ (declaim (inline descending-transform ascending-transform)) -;; Determine which of x and y has the higher precision and return the -;; value of the higher precision number. If both x and y are -;; rationals, just return 1f0, for a single-float value. -(defun float-contagion-2 (x y) - (etypecase x - (cl:rational - (etypecase y - (cl:rational - 1f0) - (cl:float - y) - (qd-real - y))) - (single-float - (etypecase y - ((or cl:rational single-float) - x) - ((or double-float qd-real) - y))) - (double-float - (etypecase y - ((or cl:rational single-float double-float) - x) - (qd-real - y))) - (qd-real - x))) - -;; Return a floating point (or complex) type of the highest precision -;; among all of the given arguments. -(defun float-contagion (&rest args) - ;; It would be easy if we could just add the args together and let - ;; normal contagion do the work, but we could easily introduce - ;; overflows or other errors that way. So look at each argument and - ;; determine the precision and choose the highest precision. - (let ((complexp (some #'complexp args)) - (max-type - (etypecase (reduce #'float-contagion-2 (mapcar #'realpart (if (cdr args) - args - (list (car args) 0)))) - (single-float 'single-float) - (double-float 'double-float) - (qd-real 'qd-real)))) - max-type)) - -(defun apply-contagion (number precision) - (etypecase number - ((or cl:real qd-real) - (coerce number precision)) - ((or cl:complex qd-complex) - (complex (coerce (realpart number) precision) - (coerce (imagpart number) precision))))) - ;;; Jacobian elliptic functions (defun ascending-transform (u m) diff --git a/qd-methods.lisp b/qd-methods.lisp index 814672c..fa27ce2 100644 --- a/qd-methods.lisp +++ b/qd-methods.lisp @@ -1048,4 +1048,58 @@ the same precision as the argument. The argument can be complex.")) (float pi (realpart z))) (defmethod float-pi ((z qd-complex)) - +pi+) \ No newline at end of file + +pi+) + +;; Determine which of x and y has the higher precision and return the +;; value of the higher precision number. If both x and y are +;; rationals, just return 1f0, for a single-float value. +(defun float-contagion-2 (x y) + (etypecase x + (cl:rational + (etypecase y + (cl:rational + 1f0) + (cl:float + y) + (qd-real + y))) + (single-float + (etypecase y + ((or cl:rational single-float) + x) + ((or double-float qd-real) + y))) + (double-float + (etypecase y + ((or cl:rational single-float double-float) + x) + (qd-real + y))) + (qd-real + x))) + +;; Return a floating point (or complex) type of the highest precision +;; among all of the given arguments. +(defun float-contagion (&rest args) + ;; It would be easy if we could just add the args together and let + ;; normal contagion do the work, but we could easily introduce + ;; overflows or other errors that way. So look at each argument and + ;; determine the precision and choose the highest precision. + (let ((complexp (some #'complexp args)) + (max-type + (etypecase (reduce #'float-contagion-2 (mapcar #'realpart (if (cdr args) + args + (list (car args) 0)))) + (single-float 'single-float) + (double-float 'double-float) + (qd-real 'qd-real)))) + max-type)) + +(defun apply-contagion (number precision) + (etypecase number + ((or cl:real qd-real) + (coerce number precision)) + ((or cl:complex qd-complex) + (complex (coerce (realpart number) precision) + (coerce (imagpart number) precision))))) + ----------------------------------------------------------------------- Summary of changes: oct.asd | 2 + qd-class.lisp | 4 +- qd-elliptic.lisp | 53 ----------------- qd-gamma.lisp | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ qd-methods.lisp | 72 +++++++++++++++++++++-- rt-tests.lisp | 54 +++++++++++++++++ 6 files changed, 295 insertions(+), 60 deletions(-) create mode 100644 qd-gamma.lisp hooks/post-receive -- OCT: A portable Lisp implementation for quad-double precision floats

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. c6f0a5ef00138c7f504432e0d0f485c23328274a
by Raymond Toy 15 Mar '11

15 Mar '11

1 0

[oct-scm] [oct-git]OCT: A portable Lisp implementation for quad-double precision floats branch master updated. d2650578689f51edbdc8f0c588fcf330134490c6
by Raymond Toy 14 Mar '11

14 Mar '11

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "OCT: A portable Lisp implementation for quad-double precision floats". The branch, master has been updated via d2650578689f51edbdc8f0c588fcf330134490c6 (commit) via d6439bd96cf670d4b164cb78dff2358293539c83 (commit) from 8ade177a0ce9bbb89b963ff29e46f38f377e9530 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit d2650578689f51edbdc8f0c588fcf330134490c6 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Mar 14 08:44:47 2011 -0400 Move +pi+ and friends to its own file. qd-const2.lisp: o New file containing +pi+ and friends qd-methods.lisp: o Removed constants. oct.asd: o Add qd-const2.lisp diff --git a/oct.asd b/oct.asd index b1c41f2..89b56ee 100644 --- a/oct.asd +++ b/oct.asd @@ -52,6 +52,7 @@ :depends-on ("qd" "qd-const")) (:file "qd-class" :depends-on ("qd-fun")) + (:file "qd-const2" :depends-on ("qd-class")) (:file "qd-methods" :depends-on ("qd-class")) (:file "qd-reader" diff --git a/qd-const2.lisp b/qd-const2.lisp new file mode 100644 index 0000000..2ad911d --- /dev/null +++ b/qd-const2.lisp @@ -0,0 +1,84 @@ +;;;; -*- Mode: lisp -*- +;;;; +;;;; Copyright (c) 2007, 2008, 2011 Raymond Toy +;;;; +;;;; Permission is hereby granted, free of charge, to any person +;;;; obtaining a copy of this software and associated documentation +;;;; files (the "Software"), to deal in the Software without +;;;; restriction, including without limitation the rights to use, +;;;; copy, modify, merge, publish, distribute, sublicense, and/or sell +;;;; copies of the Software, and to permit persons to whom the +;;;; Software is furnished to do so, subject to the following +;;;; conditions: +;;;; +;;;; The above copyright notice and this permission notice shall be +;;;; included in all copies or substantial portions of the Software. +;;;; +;;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +;;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +;;;; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +;;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +;;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +;;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +;;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +;;;; OTHER DEALINGS IN THE SOFTWARE. + +(in-package #:oct) + +(defconstant +pi+ + (make-instance 'qd-real :value octi:+qd-pi+) + "Pi represented as a QD-REAL") + +(defconstant +pi/2+ + (make-instance 'qd-real :value octi:+qd-pi/2+) + "Pi/2 represented as a QD-REAL") + +(defconstant +pi/4+ + (make-instance 'qd-real :value octi:+qd-pi/4+) + "Pi/4 represented as a QD-REAL") + +(defconstant +2pi+ + (make-instance 'qd-real :value octi:+qd-2pi+) + "2*pi represented as a QD-REAL") + +(defconstant +log2+ + (make-instance 'qd-real :value octi:+qd-log2+) + "Natural log of 2 represented as a QD-REAL") + +;; How do we represent infinity for a QD-REAL? For now, we just make +;; the QD-REAL whose most significant part is infinity. Currently +;; only supported on CMUCL. +#+cmu +(defconstant +quad-double-float-positive-infinity+ + (make-instance 'qd-real :value (make-qd-d ext:double-float-positive-infinity)) + "One representation of positive infinity for QD-REAL") + +#+cmu +(defconstant +quad-double-float-negative-infinity+ + (make-instance 'qd-real :value (make-qd-d ext:double-float-negative-infinity)) + "One representation of negative infinity for QD-REAL") + +(defconstant +most-positive-quad-double-float+ + (make-instance 'qd-real + :value (octi::%make-qd-d most-positive-double-float + (cl:scale-float most-positive-double-float (cl:* 1 -53)) + (cl:scale-float most-positive-double-float (cl:* 2 -53)) + (cl:scale-float most-positive-double-float (cl:* 3 -53)))) + "Most positive representable QD-REAL") + +(defconstant +least-positive-quad-double-float+ + (make-instance 'qd-real + :value (make-qd-d least-positive-double-float)) + "Least positive QD-REAL") + +;; Not sure this is 100% correct, but I think if the first component +;; is any smaller than this, the last component would no longer be a +;; normalized double-float. +(defconstant +least-positive-normalized-quad-double-float+ + (make-instance 'qd-real + :value (make-qd-d (cl:scale-float least-positive-normalized-double-float (cl:* 3 53)))) + "Least positive normalized QD-REAL") + +(defconstant +qd-real-one+ + (make-instance 'qd-real :value (make-qd-d 1d0)) + "QD-REAL representation of 1") diff --git a/qd-methods.lisp b/qd-methods.lisp index 966d85f..814672c 100644 --- a/qd-methods.lisp +++ b/qd-methods.lisp @@ -25,65 +25,6 @@ (in-package #:oct) -(defconstant +pi+ - (make-instance 'qd-real :value octi:+qd-pi+) - "Pi represented as a QD-REAL") - -(defconstant +pi/2+ - (make-instance 'qd-real :value octi:+qd-pi/2+) - "Pi/2 represented as a QD-REAL") - -(defconstant +pi/4+ - (make-instance 'qd-real :value octi:+qd-pi/4+) - "Pi/4 represented as a QD-REAL") - -(defconstant +2pi+ - (make-instance 'qd-real :value octi:+qd-2pi+) - "2*pi represented as a QD-REAL") - -(defconstant +log2+ - (make-instance 'qd-real :value octi:+qd-log2+) - "Natural log of 2 represented as a QD-REAL") - -;; How do we represent infinity for a QD-REAL? For now, we just make -;; the QD-REAL whose most significant part is infinity. Currently -;; only supported on CMUCL. -#+cmu -(defconstant +quad-double-float-positive-infinity+ - (make-instance 'qd-real :value (make-qd-d ext:double-float-positive-infinity)) - "One representation of positive infinity for QD-REAL") - -#+cmu -(defconstant +quad-double-float-negative-infinity+ - (make-instance 'qd-real :value (make-qd-d ext:double-float-negative-infinity)) - "One representation of negative infinity for QD-REAL") - -(defconstant +most-positive-quad-double-float+ - (make-instance 'qd-real - :value (octi::%make-qd-d most-positive-double-float - (cl:scale-float most-positive-double-float (cl:* 1 -53)) - (cl:scale-float most-positive-double-float (cl:* 2 -53)) - (cl:scale-float most-positive-double-float (cl:* 3 -53)))) - "Most positive representable QD-REAL") - -(defconstant +least-positive-quad-double-float+ - (make-instance 'qd-real - :value (make-qd-d least-positive-double-float)) - "Least positive QD-REAL") - -;; Not sure this is 100% correct, but I think if the first component -;; is any smaller than this, the last component would no longer be a -;; normalized double-float. -(defconstant +least-positive-normalized-quad-double-float+ - (make-instance 'qd-real - :value (make-qd-d (cl:scale-float least-positive-normalized-double-float (cl:* 3 53)))) - "Least positive normalized QD-REAL") - -(defconstant +qd-real-one+ - (make-instance 'qd-real :value (make-qd-d 1d0)) - "QD-REAL representation of 1") - - (defmethod make-qd ((x cl:rational)) ;; We should do something better than this. (make-instance 'qd-real :value (rational-to-qd x))) commit d6439bd96cf670d4b164cb78dff2358293539c83 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Mar 14 08:43:05 2011 -0400 Fix typo; update required accuracy. o The names of the elliptic functions changed and we forgot to update the tests to use the new names. o Reduce required accuracy of some tests. diff --git a/rt-tests.lisp b/rt-tests.lisp index 129506a..c624f4a 100644 --- a/rt-tests.lisp +++ b/rt-tests.lisp @@ -966,7 +966,7 @@ for n = (random 1d0) for epi = (elliptic-pi n (/ pi 2) 0) for true = (/ pi (* 2 (sqrt (- 1 n)))) - for result = (check-accuracy 49 epi true) + for result = (check-accuracy 47 epi true) unless (eq nil result) append (list (list (list k n) result))) nil) @@ -976,7 +976,7 @@ for n = (random #q1) for epi = (elliptic-pi n (/ (float-pi n) 2) 0) for true = (/ (float-pi n) (* 2 (sqrt (- 1 n)))) - for result = (check-accuracy 209 epi true) + for result = (check-accuracy 208 epi true) unless (eq nil result) append (list (list (list k n) result))) nil) @@ -1073,7 +1073,7 @@ ;; sqrt(2*K/%pi) = theta3(0,q) (loop for k from 0 below 100 for m = (random 1d0) - for t3 = (theta3 0 (elliptic-nome m)) + for t3 = (elliptic-theta-3 0 (elliptic-nome m)) for true = (sqrt (/ (* 2 (elliptic-k m)) (float-pi m))) for result = (check-accuracy 51 t3 true) when result @@ -1085,7 +1085,7 @@ ;; sqrt(2*K/%pi) = theta3(0,q) (loop for k from 0 below 100 for m = (random #q1) - for t3 = (theta3 0 (elliptic-nome m)) + for t3 = (elliptic-theta-3 0 (elliptic-nome m)) for true = (sqrt (/ (* 2 (elliptic-k m)) (float-pi m))) for result = (check-accuracy 206 t3 true) when result @@ -1097,7 +1097,7 @@ ;; sqrt(2*sqrt(m)*K/%pi) = theta2(0,q) (loop for k from 0 below 100 for m = (random 1d0) - for t3 = (theta2 0 (elliptic-nome m)) + for t3 = (elliptic-theta-2 0 (elliptic-nome m)) for true = (sqrt (/ (* 2 (sqrt m) (elliptic-k m)) (float-pi m))) for result = (check-accuracy 49 t3 true) when result @@ -1109,7 +1109,7 @@ ;; sqrt(2*sqrt(m)*K/%pi) = theta2(0,q) (loop for k from 0 below 100 for m = (random #q1) - for t3 = (theta2 0 (elliptic-nome m)) + for t3 = (elliptic-theta-2 0 (elliptic-nome m)) for true = (sqrt (/ (* 2 (sqrt m) (elliptic-k m)) (float-pi m))) for result = (check-accuracy 206 t3 true) when result @@ -1121,7 +1121,7 @@ ;; sqrt(2*sqrt(1-m)*K/%pi) = theta2(0,q) (loop for k from 0 below 100 for m = (random 1d0) - for t3 = (theta4 0 (elliptic-nome m)) + for t3 = (elliptic-theta-4 0 (elliptic-nome m)) for true = (sqrt (/ (* 2 (sqrt (- 1 m)) (elliptic-k m)) (float-pi m))) for result = (check-accuracy 49 t3 true) @@ -1134,7 +1134,7 @@ ;; sqrt(2*sqrt(1-m)*K/%pi) = theta2(0,q) (loop for k from 0 below 100 for m = (random #q1) - for t3 = (theta4 0 (elliptic-nome m)) + for t3 = (elliptic-theta-4 0 (elliptic-nome m)) for true = (sqrt (/ (* 2 (sqrt (- 1 m)) (elliptic-k m)) (float-pi m))) for result = (check-accuracy 204 t3 true) ----------------------------------------------------------------------- Summary of changes: oct.asd | 1 + qd-const2.lisp | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ qd-methods.lisp | 59 -------------------------------------- rt-tests.lisp | 16 +++++----- 4 files changed, 93 insertions(+), 67 deletions(-) create mode 100644 qd-const2.lisp hooks/post-receive -- OCT: A portable Lisp implementation for quad-double precision floats

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

oct-cvs March 2011