Changeset 1010 for branches/f4grobner/parse.lisp

Timestamp:

2015-06-10T06:36:01-07:00 (9 years ago)

Author:

Marek Rychlik

Message:

* empty log message *

File:

• branches/f4grobner/parse.lisp (modified) (2 diffs)

branches/f4grobner/parse.lisp

@@ -284 +284 @@
        (otherwise
         (let ((r (mapcar
-                  #'(lambda (e) (poly-eval-1 e vars order ring))
+                  #'(lambda (e) (poly-eval-1 ring-and-order e vars))
                   (cdr expr))))
           (ecase (car expr)
-            (+ (reduce #'(lambda (p q) ($poly+ p q n order ring)) r))
+            (+ (reduce #'(lambda (p q) ($poly+ ring-and-order p q n)) r))
             (-
              (if (endp (cdr r))
-                 ($minus-poly (car r) n ring)
-                 ($poly- (car r)
-                         (reduce #'(lambda (p q) ($poly+ p q n order ring)) (cdr r))
-                         n
-                         order ring)))
+                 ($minus-poly ring (car r) n)
+                 ($poly- ring-and-order
+                         (car r)
+                         (reduce #'(lambda (p q) ($poly+ ring-and-order p q n)) (cdr r))
+                         n)))
             (*
-             (reduce #'(lambda (p q) ($poly* p q n order ring)) r))
+             (reduce #'(lambda (p q) ($poly* ring-and-order p q n)) r))
             )))))))
 
              
-(defun poly-eval (expr vars &optional (order #'lex>) (ring *coefficient-ring*))
+(defun poly-eval (expr vars 
+                  &optional (order #'lex>) (ring *coefficient-ring*)
+                  &aux 
+                    (ring-and-order (make-ring-and-order ring order)))
   "Evaluate an expression EXPR, which should be a polynomial
 expression or a list of polynomial expressions (a list of expressions
@@ -312 +315 @@
    ((numberp expr)
     (unless (zerop expr)
-      (list (cons (make-list (length vars) :initial-element 0) expr))))
+      (make-poly-from-termlist 
+       (list (make-term (make-monom :dimension (length vars)) expr)))))
    ((or (symbolp expr) (not (eq (car expr) :[)))
-    (poly-eval-1 expr vars order ring))
-   (t (cons '[ (mapcar #'(lambda (p) (poly-eval-1 p vars order ring)) (rest expr))))))
+    (poly-eval-1 ring-and-order expr vars))
+   (t (cons '[ (mapcar #'(lambda (p) (poly-eval-1 ring-and-order p vars)) (rest expr))))))