Changeset 3864

Timestamp:

2016-05-28T18:02:44-07:00 (8 years ago)

Author:

Marek Rychlik

Message:

* empty log message *

File:

• branches/f4grobner/symbolic-polynomial.lisp (modified) (2 diffs)

branches/f4grobner/symbolic-polynomial.lisp

@@ -62 +62 @@
   (assert (= (length (symbolic-poly-vars new)) (poly-dimension new))))
 
-(defgeneric poly-eval (expr vars order) 
-  (:documentation "Evaluate Lisp form EXPR to a polynomial or a list of polynomials in
+(defun poly-eval (expr vars order) 
+  "Evaluate Lisp form EXPR to a polynomial or a list of polynomials in
 variables VARS. Return the resulting polynomial or list of
 polynomials.  Standard arithmetical operators in form EXPR are
@@ -69 +69 @@
 resulting expression is evaluated, resulting in a polynomial or a list
 of polynomials in internal form. A similar operation in another computer
-algebra system could be called 'expand' or so.")
-  (:method ((expr symbolic-poly) vars order) expr)
-  (:method (expr vars order) 
-    (labels ((p-eval (p) (poly-eval p vars order))
-             (p-eval-scalar (p) (poly-eval p '() order))
-             (p-eval-list (plist) (mapcar #'p-eval plist)))
-      (cond 
-        ((eq expr 0) 
-         (make-instance 'symbolic-poly :dimension (length vars) :vars vars))
-        ((member expr vars :test #'equalp)
-         (let ((pos (position expr vars :test #'equalp)))
-           (make-poly-variable (length vars) pos)))
-        ((atom expr)
-         expr)
-        ((eq (car expr) +list-marker+)
-         (cons +list-marker+ (p-eval-list (cdr expr))))
-        (t
-         (case (car expr)
-           (+ (reduce #'add (p-eval-list (cdr expr))))
-           (- (apply #'subtract (p-eval-list (cdr expr))))
-           (*
-            (if (endp (cddr expr))      ;unary
-                (p-eval (cdr expr))
-                (reduce #'multiply (p-eval-list (cdr expr)))))
-           (/ 
-            ;; A polynomial can be divided by a scalar
-            (cond 
-              ((endp (cddr expr))
-               ;; A special case (/ ?), the inverse
-               (divide (cadr expr)))
-              (t
-               (let ((num (p-eval (cadr expr)))
-                     (denom-inverse (apply #'divide (mapcar #'p-eval-scalar (cddr expr)))))
-                 (multiply denom-inverse num)))))
-           (expt
-            (cond
-              ((member (cadr expr) vars :test #'equalp)
-               ;;Special handling of (expt var pow)
-               (let ((pos (position (cadr expr) vars :test #'equalp)))
-                 (make-poly-variable (length vars) pos (caddr expr))))
-              ((not (and (integerp (caddr expr)) (plusp (caddr expr))))
-               ;; Negative power means division in coefficient ring
-               ;; Non-integer power means non-polynomial coefficient
-               expr)
-              (t (universal-expt (p-eval (cadr expr)) (caddr expr)))))
-           (otherwise
-            expr)))))))
+algebra system could be called 'expand' or so."
+  (labels ((p-eval (p) (poly-eval p vars order))
+           (p-eval-scalar (p) (poly-eval p '() order))
+           (p-eval-list (plist) (mapcar #'p-eval plist)))
+    (cond 
+      ((eq expr 0) 
+       (make-instance 'symbolic-poly :dimension (length vars) :vars vars))
+      ((member expr vars :test #'equalp)
+       (let ((pos (position expr vars :test #'equalp)))
+         (make-poly-variable (length vars) pos)))
+      ((atom expr)
+       expr)
+      ((eq (car expr) +list-marker+)
+       (cons +list-marker+ (p-eval-list (cdr expr))))
+      (t
+       (case (car expr)
+         (+ (reduce #'add (p-eval-list (cdr expr))))
+         (- (apply #'subtract (p-eval-list (cdr expr))))
+         (*
+          (if (endp (cddr expr))        ;unary
+              (p-eval (cdr expr))
+              (reduce #'multiply (p-eval-list (cdr expr)))))
+         (/ 
+          ;; A polynomial can be divided by a scalar
+          (cond 
+            ((endp (cddr expr))
+             ;; A special case (/ ?), the inverse
+             (divide (cadr expr)))
+            (t
+             (let ((num (p-eval (cadr expr)))
+                   (denom-inverse (apply #'divide (mapcar #'p-eval-scalar (cddr expr)))))
+               (multiply denom-inverse num)))))
+         (expt
+          (cond
+            ((member (cadr expr) vars :test #'equalp)
+             ;;Special handling of (expt var pow)
+             (let ((pos (position (cadr expr) vars :test #'equalp)))
+               (make-poly-variable (length vars) pos (caddr expr))))
+            ((not (and (integerp (caddr expr)) (plusp (caddr expr))))
+             ;; Negative power means division in coefficient ring
+             ;; Non-integer power means non-polynomial coefficient
+             expr)
+            (t (universal-expt (p-eval (cadr expr)) (caddr expr)))))
+         (otherwise
+          expr))))))
 
 #|