Changeset 3483

Timestamp:

2015-09-05T10:21:17-07:00 (9 years ago)

Author:

Marek Rychlik

Message:

* empty log message *

File:

• branches/f4grobner/monom.lisp (modified) (10 diffs)

branches/f4grobner/monom.lisp

@@ -340 +340 @@
 order, otherwise NIL.  The second returned value is T if P=Q,
 otherwise it is NIL.")
-  (:method ((p monom) (q monom) &optional (start 0) (end (r-dimension  p)))
+  (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension  p)))
     (declare (type fixnum start end))
     (do ((i start (1+ i)))
         ((>= i end) (values nil t))
       (cond
-        ((> (r-elt p i) (r-elt q i))
+        ((> (monom-elt p i) (monom-elt q i))
          (return-from lex> (values t nil)))
-        ((< (r-elt p i) (r-elt q i))
+        ((< (monom-elt p i) (monom-elt q i))
          (return-from lex> (values nil nil)))))))
 
@@ -355 +355 @@
 lexicographic order, otherwise NIL.  The second returned value is T if
 P=Q, otherwise it is NIL.")
-  (:method ((p monom) (q monom) &optional (start 0) (end (r-dimension  p)))
+  (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension  p)))
     (declare (type monom p q) (type fixnum start end))
-    (let ((d1 (r-total-degree p start end))
-          (d2 (r-total-degree q start end)))
+    (let ((d1 (monom-total-degree p start end))
+          (d2 (monom-total-degree q start end)))
       (declare (type fixnum d1 d2))
       (cond
@@ -373 +373 @@
 because some sets do not have a minimal element. This order is useful
 in constructing other orders.")
-  (:method ((p monom) (q monom) &optional (start 0) (end (r-dimension  p)))
+  (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension  p)))
     (declare (type fixnum start end))
     (do ((i (1- end) (1- i)))
@@ -379 +379 @@
       (declare (type fixnum i))
       (cond
-        ((< (r-elt p i) (r-elt q i))
+        ((< (monom-elt p i) (monom-elt q i))
          (return-from revlex> (values t nil)))
-        ((> (r-elt p i) (r-elt q i))
+        ((> (monom-elt p i) (monom-elt q i))
          (return-from revlex> (values nil nil)))))))
 
@@ -390 +390 @@
 lexicographic order, NIL otherwise. The second returned value is T if
 P=Q, otherwise it is NIL.")
-  (:method  ((p monom) (q monom) &optional (start 0) (end (r-dimension  p)))
+  (:method  ((p monom) (q monom) &optional (start 0) (end (monom-dimension  p)))
     (declare (type fixnum start end))
-    (let ((d1 (r-total-degree p start end))
-          (d2 (r-total-degree q start end)))
+    (let ((d1 (monom-total-degree p start end))
+          (d2 (monom-total-degree q start end)))
       (declare (type fixnum d1 d2))
       (cond
@@ -405 +405 @@
 lexicographic order, NIL otherwise The second returned value is T if
 P=Q, otherwise it is NIL.")
-  (:method ((p monom) (q monom) &optional (start 0) (end (r-dimension  p)))
+  (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension  p)))
     (declare  (type fixnum start end))
     (do ((i (1- end) (1- i)))
@@ -411 +411 @@
       (declare (type fixnum i))
       (cond
-        ((> (r-elt p i) (r-elt q i))
+        ((> (monom-elt p i) (monom-elt q i))
          (return-from invlex> (values t nil)))
-        ((< (r-elt p i) (r-elt q i))
+        ((< (monom-elt p i) (monom-elt q i))
          (return-from invlex> (values nil nil)))))))
 
 (defun reverse-monomial-order (order)
   "Create the inverse monomial order to the given monomial order ORDER."
-  #'(lambda (p q &optional (start 0) (end (r-dimension q))) 
+  #'(lambda (p q &optional (start 0) (end (monom-dimension q))) 
       (declare (type monom p q) (type fixnum start end))
       (funcall order q p start end)))
@@ -430 +430 @@
 ;; This returns a closure with the same signature
 ;; as all orders such as #'LEX>.
-(defun make-elimination-order-factory-1 (&optional (secondary-elimination-order #'lex>))
+(defun make-elimination-ordemonom-factory-1 (&optional (secondary-elimination-order #'lex>))
   "It constructs an elimination order used for the 1-st elimination ideal,
 i.e. for eliminating the first variable. Thus, the order compares the degrees of the
 first variable in P and Q first, with ties broken by SECONDARY-ELIMINATION-ORDER."
-  #'(lambda (p q &optional (start 0) (end (r-dimension p)))
+  #'(lambda (p q &optional (start 0) (end (monom-dimension p)))
       (declare (type monom p q) (type fixnum start end))
       (cond
-        ((> (r-elt p start) (r-elt q start))
+        ((> (monom-elt p start) (monom-elt q start))
          (values t nil))
-        ((< (r-elt p start) (r-elt q start))
+        ((< (monom-elt p start) (monom-elt q start))
          (values nil nil))
         (t 
@@ -447 +447 @@
 ;; The result is *another closure* with the same signature as all
 ;; orders such as #'LEX>.
-(defun make-elimination-order-factory (&optional 
+(defun make-elimination-ordemonom-factory (&optional 
                                          (primary-elimination-order #'lex>)
                                          (secondary-elimination-order #'lex>))
@@ -467 +467 @@
          (error "K must be at least 1"))
         ((= k 1)
-         (make-elimination-order-factory-1 secondary-elimination-order))
+         (make-elimination-ordemonom-factory-1 secondary-elimination-order))
         (t
-         #'(lambda (p q &optional (start 0) (end (r-dimension  p)))
+         #'(lambda (p q &optional (start 0) (end (monom-dimension  p)))
              (declare (type monom p q) (type fixnum start end))
              (multiple-value-bind (primary equal)