[Maxima-commits] CVS: maxima/src expintegral.lisp,1.17,1.18

[Dieter K. <cra...@us...>]

Update of /cvsroot/maxima/maxima/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv14115

Modified Files:
	expintegral.lisp 
Log Message:
Implementing a simplim%function to handle specific values for the functions:

expintegral_e
expintegral_e1
expintegral_ei
expintegral_li
expintegral_ci
expintegral_chi

The simplim%function returns an appropriate infinity for the specific values 0 or 1 of the functions.

Index: expintegral.lisp
===================================================================
RCS file: /cvsroot/maxima/maxima/src/expintegral.lisp,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -d -r1.17 -r1.18
--- expintegral.lisp	18 May 2009 20:07:24 -0000	1.17
+++ expintegral.lisp	23 May 2009 20:13:24 -0000	1.18
@@ -196,6 +196,30 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;;; We support a simplim%function. The function is looked up in simplimit and 
+;;; handles specific values of the function.
+
+(defprop %expintegral_e simplim%expintegral_e simplim%function)
+
+(defun simplim%expintegral_e (expr var val)
+  ;; Look for the limit of the arguments.
+  (let ((a (limit (cadr expr) var val 'think))
+        (z (limit (caddr expr) var val 'think)))
+  (cond
+    ;; Handle an argument 0 at this place
+    ((or (zerop1 z)
+         (eq z '$zeroa)
+         (eq z '$zerob))
+     (cond ((member ($sign (add ($realpart a) -1)) '($neg $nz $zero))
+            '$infinity)
+           (t
+             (simplify (list '(%expintegral_e) a z)))))
+    (t
+     ;; All other cases are handled by the simplifier of the function.
+     (simplify (list '(%expintegral_e) a z))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (defun simp-expintegral-e (expr ignored z)
   (declare (ignore ignored))
   (twoargcheck expr)
@@ -217,7 +241,7 @@
            ((eq sgn '$pos)
             ;; we handle the special case E[v](0) = 1/(v-1), for realpart(v)>1
             (inv (add order -1)))
-           ((member sgn '($neg $zero))
+           ((member sgn '($neg $ nz $zero))
             (merror (intl:gettext "expintegral_e: expintegral_e(~:M,~:M) is undefined.") order arg))
            (t (eqtest (list '(%expintegral_e) order arg) expr)))))
 
@@ -910,6 +934,26 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;;; We support a simplim%function. The function is looked up in simplimit and 
+;;; handles specific values of the function.
+
+(defprop %expintegral_e1 simplim%expintegral_e1 simplim%function)
+
+(defun simplim%expintegral_e1 (expr var val)
+  ;; Look for the limit of the argument.
+  (let ((z (limit (cadr expr) var val 'think)))
+  (cond
+    ;; Handle an argument 0 at this place
+    ((or (zerop1 z)
+         (eq z '$zeroa)
+         (eq z '$zerob))
+     '$infinity)
+    (t
+     ;; All other cases are handled by the simplifier of the function.
+     (simplify (list '(%expintegral_e1) z))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (defun simp-expintegral_e1 (expr ignored z)
   (declare (ignore ignored))
   (oneargcheck expr)
@@ -1010,6 +1054,26 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;;; We support a simplim%function. The function is looked up in simplimit and 
+;;; handles specific values of the function.
+
+(defprop %expintegral_ei simplim%expintegral_ei simplim%function)
+
+(defun simplim%expintegral_ei (expr var val)
+  ;; Look for the limit of the arguments.
+  (let ((z (limit (cadr expr) var val 'think)))
+  (cond
+    ;; Handle an argument 0 at this place
+    ((or (zerop1 z)
+         (eq z '$zeroa)
+         (eq z '$zerob))
+     '$minf)
+    (t
+     ;; All other cases are handled by the simplifier of the function.
+     (simplify (list '(%expintegral_ei) z))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (defun simp-expintegral-ei (expr ignored z)
   (declare (ignore ignored))
   (oneargcheck expr)
@@ -1192,6 +1256,23 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;;; We support a simplim%function. The function is looked up in simplimit and 
+;;; handles specific values of the function.
+
+(defprop %expintegral_li simplim%expintegral_li simplim%function)
+
+(defun simplim%expintegral_li (expr var val)
+  ;; Look for the limit of the argument.
+  (let ((z (limit (cadr expr) var val 'think)))
+  (cond
+    ;; Handle an argument 1 at this place
+    ((onep1 z) '$minf)
+    (t
+     ;; All other cases are handled by the simplifier of the function.
+     (simplify (list '(%expintegral_li) z))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (defun simp-expintegral-li (expr ignored z)
   (declare (ignore ignored))
   (oneargcheck expr)
@@ -1640,6 +1721,26 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;;; We support a simplim%function. The function is looked up in simplimit and 
+;;; handles specific values of the function.
+
+(defprop %expintegral_ci simplim%expintegral_ci simplim%function)
+
+(defun simplim%expintegral_ci (expr var val)
+  ;; Look for the limit of the argument.
+  (let ((z (limit (cadr expr) var val 'think)))
+  (cond
+    ;; Handle an argument 0 at this place
+    ((or (zerop1 z)
+         (eq z '$zeroa)
+         (eq z '$zerob))
+     '$minf)
+    (t
+     ;; All other cases are handled by the simplifier of the function.
+     (simplify (list '(%expintegral_ci) z))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (defun simp-expintegral-ci (expr ignored z)
   (declare (ignore ignored))
   (oneargcheck expr)
@@ -1812,6 +1913,26 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;;; We support a simplim%function. The function is looked up in simplimit and 
+;;; handles specific values of the function.
+
+(defprop %expintegral_chi simplim%expintegral_chi simplim%function)
+
+(defun simplim%expintegral_chi (expr var val)
+  ;; Look for the limit of the argument.
+  (let ((z (limit (cadr expr) var val 'think)))
+  (cond
+    ;; Handle an argument 0 at this place
+    ((or (zerop1 z)
+         (eq z '$zeroa)
+         (eq z '$zerob))
+     '$minf)
+    (t
+     ;; All other cases are handled by the simplifier of the function.
+     (simplify (list '(%expintegral_chi) z))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (defun simp-expintegral-chi (expr ignored z)
   (declare (ignore ignored))
   (oneargcheck expr)