;; This file:
;;   https://anggtwu.net/MAXIMA/dim-antideriv.lisp.html
;;   https://anggtwu.net/MAXIMA/dim-antideriv.lisp
;;           (find-angg "MAXIMA/dim-antideriv.lisp")
;; Author: Robert Dodier
;; Small changes by: Eduardo Ochs
;;
;; DIM-%ANTIDERIV -- 2-d pretty printer display for antiderivative-like expressions
;; copyright 2025 by Robert Dodier
;; I release this work under terms of the GNU General Public License, v2
;;
;; See: (find-maximamsg "59178281 202504 29" "RDodier: dim-antideriv.lisp")
;;      (find-maximamsg "59178287 202504 29" "Edrx: Thanks!!! =)")
;;      (find-maximamsg "59178856 202505 01" "Edrx: TeXmacs")
;;      (find-maximamsg "59266596 202511 30" "RDodier/Edrx: One less bug...")
;;      https://sourceforge.net/p/maxima/bugs/4639/ Edrx: a partial fix...
;;      https://sourceforge.net/p/maxima/bugs/4639/attachment/with-setq-width.png
;;      https://sourceforge.net/p/maxima/bugs/4639/attachment/without-setq-width.png
;;
;; Update, dec/2025: This code was my inspiration for edrxbox.lisp
;; and for my implementation of an "antideriv" written on top of
;; edrxbox.lisp - that I believe is more readable than this one.
;; See:
;;
;;   (find-angg "MAXIMA/edrxbox.lisp")
;;   (find-angg "MAXIMA/edrxbox-examples.lisp" "antideriv")

(if (not (fboundp 'display2d-unicode-enabled))
    (defun display2d-unicode-enabled () nil))


(defun dim-%antideriv (form result)

  (unless (= (length (cdr form)) 4)
    (return-from dim-%antideriv (dimension-function form result)))

  (let*
    ((args (rest form))
     (expr (first args))
     (my-var (second args))
     (lower-val (third args))
     (upper-val (fourth args))
     (lower-eqn (list '(mequal) my-var lower-val))
     (upper-eqn (list '(mequal) my-var upper-val))
     (vertical-bar-char (if (display2d-unicode-enabled)
			    at-char-unicode
			  (car (coerce $absboxchar 'list))))
     vertical-bar
     expr-result  
     lower-result
     upper-result
     expr-w  expr-h  expr-d
     lower-w lower-h lower-d
     upper-w upper-h upper-d)
    (declare (ignorable expr-w expr-h expr-d
			lower-w lower-h lower-d
			upper-w upper-h upper-d))

    (setq expr-result (dimension expr nil 'mparen 'mparen nil 0)
          expr-w width
	  expr-h height
	  expr-d depth)

    (setq lower-result (dimension-infix lower-eqn nil)
          lower-w width
	  lower-h height
	  lower-d depth)

    (setq upper-result (dimension-infix upper-eqn nil)
          upper-w width
	  upper-h height
	  upper-d depth)

    (setq vertical-bar (list 'd-vbar
                             (1+ (max expr-h upper-d))
                             (max (1+ expr-d) lower-h)
                             vertical-bar-char))

    (setq result (append (list (append (list (- lower-w) (max expr-h upper-d)) upper-result)
                               (append (list 0 (- (max (1+ expr-d) lower-h))) lower-result)
                               vertical-bar
                               (append (list 0 0) expr-result))
                         result))

    (format t "~S~%" result)

    (setq height (+ 1 (max expr-h upper-d) upper-h)
          depth (+ (max (1+ expr-d) lower-h) lower-d))

    ;; Edrx:
    (setq width (+ expr-w 1 (max upper-w lower-w)))

    (update-heights height depth)

    result))

(setf (get '%antideriv 'dimension) 'dim-%antideriv)
(setf (get '$antideriv 'dimension) 'dim-%antideriv) ; Edrx

#|
** Tests:
* (eepitch-oldmaxima)
* (eepitch-kill)
* (eepitch-oldmaxima)
* (eepitch-maxima)
* (eepitch-kill)
* (eepitch-maxima)
load ("dim-antideriv.lisp");
mybox(o) := [box(o)];

o0 : 23/3456;
antideriv (o0, u, a, b);




o1 : antideriv (F(u), u, a, b);
o2 : antideriv (F(u[k]), u[k], a[k], b[k]);
o3 : antideriv (a+b, u, z^2^n+y[k], x^2-z[k]);
o4 : antideriv (a+b, u, z^2^n+y[k], x^2-z[k[l[u]]]);

mybox(o1);
mybox(o2);
mybox(o3);
mybox(o4);

texput(antideriv, antideriv_tex);
antideriv_tex(o) :=
  block([fx,x,a,b], [fx,x,a,b]:args(o),
        format("\\left.~a\\right|_{~a=~a}^{~a=~a}",
               tex1(fx), tex1(x),tex1(a), tex1(x),tex1(b)));

antideriv_tex([f(x),x,a,b]);
tex1(antideriv(f(x),x,a,b));

to_lisp();

|#