Lisp Formatting Polynomial

Question

I am representing sparse polynomials as lists of (coefficient, pairs). For example:

'((1 2) (3 6) (-20 48)) => x^2 + 3x^6 - 20x^48

I am new to Lisp formatting, but have come across some pretty nifty tools, such as (format nil "~:[+~;-~]" (> 0 coefficient)) to get the sign of the coefficient as text (I know, that's probably not idiomatic).

However, there are certain display problems when formatting single terms. For example, the following should all be true:

(1 0) => 1x^0 => 1    (reducible)
(1 1) => 1x^1 => x    (reducible)
(1 2) => 1x^2 => x^2  (reducible)
(2 0) => 2x^0 => 2    (reducible)
(2 1) => 2x^1 => 2x   (reducable)
(2 2) => 2x^2 => 2x^2 (this one is okay)

I'm wondering if there's a way to do this without a large series of if or cond macros - a way just to do this with a single format pattern. Everything works but the 'prettifying' the terms (the last line in FormatPolynomialHelper3 should do this).

(defun FormatPolynomial (p)
    "Readably formats the polynomial p."
    ; The result of FormatPolynomialHelper1 is a list of the form (sign formatted),
    ; where 'sign' is the sign of the first term and 'formatted' is the rest of the
    ; formatted polynomial. We make this a special case so that we can print a sign
    ; attached to the first term if it is negative, and leave it out otherwise. So,
    ; we format the first term to be either '-7x^20' or '7x^20', rather than having
    ; the minus or plus sign separated by a space.
    (destructuring-bind (sign formatted-poly) (FormatPolynomialHelper1 p)
        (cond
            ((string= formatted-poly "") (format nil "0"))
            (t                           (format nil "~:[~;-~]~a" (string= sign "-") formatted-poly)))))

; Helpers

(defun FormatPolynomialHelper1 (p)
    (reduce #'FormatPolynomialHelper2 (mapcar #'FormatPolynomialHelper3 p) :initial-value '("" "")))

(defun FormatPolynomialHelper2 (t1 t2)
    ; Reduces ((sign-a term-a) (sign-b term-b)) => (sign-b "term-b sign-a term-a"). As
    ; noted, this accumulates the formatted term in the variable t2, beginning with an
    ; initial value of "", and stores the sign of the leading term in the variable t1.
    ; The sign of the leading term is placed directly before the accumulated formatted
    ; term, ensuring that the signs are placed correctly before their coefficient. The
    ; sign of the the leading term of the polynomial (the last term that is processed)
    ; is available to the caller for special-case formatting.
    (list
        (first t2)
        (format nil "~@{~a ~}" (second t2) (first t1) (second t1))))

(defun FormatPolynomialHelper3 (tm)
    ; Properly formats a term in the form "ax^b", excluding parts of the form if they
    ; evaluate to one. For example, 1x^3 => x^3, 2x^1 => 2x, and 3x^0 => 3). The list
    ; is in the form (sign formatted), denoting the sign of the term, and the form of
    ; the term state above (the coefficient have forced absolute value).
    (list
        (format nil "~:[+~;-~]" (> 0 (first tm)))
        (format nil "~a~@[x^~a~]" (abs (first tm)) (second tm))))

EDIT: It's correctly been stated that output should not contain logic. Perhaps I was asking too specific of a question for my problem. Here is the logic that correctly formats a polynomial - but I'm looking for something cleaner, more readable, and more lisp-idiomatic (this is only my third day writing lisp).

(defun FormatPolynomialHelper3 (tm)
    ; Properly formats a term in the form "ax^b", excluding parts of the form if they
    ; evaluate to one. For example, 1x^3 => x^3, 2x^1 => 2x, and 3x^0 => 3). The list
    ; is in the form (sign formatted), denoting the sign of the term, and the form of
    ; the term state above (the coefficient have forced absolute value).
    (list
        (format nil "~:[+~;-~]"   (> 0 (first tm)))
        (cond
            ((= 0 (second tm))      (format nil "~a" (abs (first tm))))
            ((= 1 (abs (first tm))) (cond
                ((= 1 (second tm))  (format nil "x"))
                (t                  (format nil "x^~a" (second tm)))))
            ((= 1 (second tm))      (format nil "~ax" (abs (first tm))))
            (t                      (format nil "~ax^~a" (abs (first tm)) (second tm))))))

Answer 1

Answer:

I would not put this logic into FORMAT statements. Only if you want to encrypt your code or create more maintenance work for yourself. Good Lisp code is self-documenting. FORMAT statements are never self-documenting.

Before printing I would first simplify the polynomial. For example removing every term which is multiplied by zero.

((0 10) (1 2)) -> ((1 2))

Then if the multiplier is 1 can be tested in a normal COND or CASE statement.

Also make sure that you never use CAR, CDR, FIRST, SECOND with a self-made data structure. The components of a polynomial should mostly be accessed by self-documenting functions hiding most of the implementation details.

I would write it without FORMAT:

Example code:

(defun term-m (term)
  (first term))

(defun term-e (term)
  (second term))

(defun simplify-polynomial (p)
  (remove-if #'zerop (sort p #'> :key #'term-e)
             :key #'term-m))

(defun write-term (m e start-p stream)
  ; sign or operator
  (cond ((and (minusp m) start-p)
         (princ "-" stream))
        ((not start-p)
         (princ (if (plusp m) " + " " - ") stream)))
  ; m
  (cond ((not (= (abs m) 1))
         (princ (abs m) stream)))
  (princ "x" stream)
  ; e
  (cond ((not (= 1 e))
         (princ "^" stream)
         (princ e stream))))

(defun write-polynomial (p &optional (stream *standard-output*))
  (loop for (m e) in (simplify-polynomial p)
        for start-p = t then nil
        do (write-term m e start-p stream)))

Example use:

CL-USER 14 > (write-polynomial '((1 2) (3 6) (-20 48)))
-20x^48 + 3x^6 + x^2