Differential D25303 Diff 73199 head/math/maxima/files/extra-patch-src_hayat.lisp

Changeset View

Standalone View

head/math/maxima/files/extra-patch-src_hayat.lisp

	--- src/hayat.lisp.orig 2019-10-21 03:38:59 UTC			--- src/hayat.lisp.orig 2020-05-21 06:20:25 UTC
	+++ src/hayat.lisp			+++ src/hayat.lisp
	@@ -2205,6 +2205,25 @@			@@ -2205,6 +2205,25 @@
	(or (alike1 (exp-pt (get-datum (datum-var (car l)))) (exp-pt (car l)))			(or (alike1 (exp-pt (get-datum (datum-var (car l)))) (exp-pt (car l)))
	(return () ))))			(return () ))))

	+;; Patch borrowed from SageMath: 0001-taylor2-Avoid-blowing-the-stack-when-diff-expand-isn			+;; Patch borrowed from SageMath: 0001-taylor2-Avoid-blowing-the-stack-when-diff-expand-isn
	+;;			+;;
	+;; SUBTREE-SEARCH			+;; SUBTREE-SEARCH
	Show All 11 Lines
	+(defun subtree-search (branch tree &optional (test 'equalp))			+(defun subtree-search (branch tree &optional (test 'equalp))
	+ (unless (atom tree)			+ (unless (atom tree)
	+ (if (find branch tree :test test) (list tree)			+ (if (find branch tree :test test) (list tree)
	+ (mapcan (lambda (child) (subtree-search branch child test)) tree))))			+ (mapcan (lambda (child) (subtree-search branch child test)) tree))))
	+			+
	(defun taylor2 (e)			(defun taylor2 (e)
	(let ((last-exp e)) ;; lexp-non0 should be bound here when needed			(let ((last-exp e)) ;; lexp-non0 should be bound here when needed
	(cond ((assolike e tlist) (var-expand e 1 () ))			(cond ((assolike e tlist) (var-expand e 1 () ))
	@@ -2248,9 +2267,32 @@			@@ -3032,7 +3051,21 @@
	((null l) t)
	(or (free e (car l)) (return ()))))
	(newsym e))
	- (t (let ((exact-poly () )) ; Taylor series aren't exact
	- (taylor2 (diff-expand e tlist)))))))
	+ (t
	+ ;; When all else fails, call diff-expand to try to expand e around the
	+ ;; point as a Taylor series by taking repeated derivatives. This might
	+ ;; fail, unfortunately: If a required derivative doesn't exist, then
	+ ;; DIFF-EXPAND will return a form of the form "f'(x)" with the
	+ ;; variable, rather than the expansion point in it.
	+ ;;
	+ ;; Sometimes this works - in particular, if there is a genuine pole at
	+ ;; the point, we end up passing a sum of terms like x^(-k) to a
	+ ;; recursive invocation and all is good. Unfortunately, it can also
	+ ;; fail. For example, if e is abs(sin(x)) and we try to expand to first
	+ ;; order, the expression "1/1(cos(x)sin(x)/abs(sin(x)))*x^1+0" is
	+ ;; returned. If we call taylor2 on that, we will end up recursing and
	+ ;; blowing the stack. To avoid doing so, error out if EXPANSION
	+ ;; contains E as a subtree. However, don't error if it occurs as an
	+ ;; argument to %DERIVATIVE (in which case, we might well be fine). This
	+ ;; happens from things like taylor(log(f(x)), x, x0, 1).

	+ (let* ((exact-poly nil) ; (Taylor series aren't exact)
	+ (expansion (diff-expand e tlist)))
	+ (when (find-if (lambda (subtree)
	+ (not (eq ($op subtree) '%derivative)))
	+ (subtree-search e expansion))
	+ (exp-pt-err))
	+ (taylor2 expansion))))))
	+
	(defun compatvarlist (a b c d)
	(cond ((null a) t)
	((or (null b) (null c) (null d)) () )
	@@ -3024,7 +3066,21 @@
	(and (or (member '$inf pt-list :test #'eq) (member '$minf pt-list :test #'eq))			(and (or (member '$inf pt-list :test #'eq) (member '$minf pt-list :test #'eq))
	(unfam-sing-err)))			(unfam-sing-err)))

	-(defun diff-expand (exp l) ;l is tlist			-(defun diff-expand (exp l) ;l is tlist
	+;; DIFF-EXPAND			+;; DIFF-EXPAND
	+;;			+;;
	+;; Expand EXP in the variables as specified in L, which is a list of tlists. If			+;; Expand EXP in the variables as specified in L, which is a list of tlists. If
	+;; L is a singleton, this just works by the classic Taylor expansion:			+;; L is a singleton, this just works by the classic Taylor expansion:
	Show All 14 Lines