Changeset 1769

Timestamp:

2015-06-15T10:04:45-07:00 (10 years ago)

Author:

Marek Rychlik

Message:

* empty log message *

File:

• branches/f4grobner/mx-grobner.lisp (modified) (3 diffs)

branches/f4grobner/mx-grobner.lisp

@@ -456 +456 @@
     (poly-exact-divide ring-and-order f g)))
 
-#|
 (defmfun $poly_normal_form (f fl vars)
-  (with-parsed-polynomials ((vars) :polynomials (f)
+  (with-ring-and-order ((vars) :polynomials (f)
                                    :poly-lists (fl)
                                    :value-type :polynomial)
-    (normal-form +maxima-ring+ f (remzero fl) nil)))
+    (normal-form ring-and-order f (remzero fl) nil)))
 
 (defmfun $poly_buchberger_criterion (g vars)
-  (with-parsed-polynomials ((vars) :poly-lists (g) :value-type :logical)
-    (buchberger-criterion +maxima-ring+ g)))
+  (with-ring-and-order ((vars) :poly-lists (g) :value-type :logical)
+    (buchberger-criterion ring-and-order g)))
 
 (defmfun $poly_buchberger (fl vars)
-  (with-parsed-polynomials ((vars) :poly-lists (fl) :value-type :poly-list)
-    (buchberger +maxima-ring+  (remzero fl) 0 nil)))
+  (with-ring-and-order ((vars) :poly-lists (fl) :value-type :poly-list)
+    (buchberger ring-and-order  (remzero fl) 0 nil)))
 
 (defmfun $poly_reduction (plist vars)
-  (with-parsed-polynomials ((vars) :poly-lists (plist)
-                                   :value-type :poly-list)
-    (reduction +maxima-ring+ plist)))
+  (with-ring-and-order ((vars) :poly-lists (plist)
+                                   :value-type :poly-list)
+    (reduction ring-and-order plist)))
 
 (defmfun $poly_minimization (plist vars)
-  (with-parsed-polynomials ((vars) :poly-lists (plist)
+  (with-ring-and-order ((vars) :poly-lists (plist)
                                    :value-type :poly-list)
     (minimization plist)))
 
 (defmfun $poly_normalize_list (plist vars)
-  (with-parsed-polynomials ((vars) :poly-lists (plist)
-                                   :value-type :poly-list)
-    (poly-normalize-list +maxima-ring+ plist)))
+  (with-ring-and-order ((vars) :poly-lists (plist)
+                                   :value-type :poly-list)
+    (poly-normalize-list ring-and-order plist)))
 
 (defmfun $poly_grobner (f vars)
-  (with-parsed-polynomials ((vars) :poly-lists (f)
-                                   :value-type :poly-list)
-    (grobner +maxima-ring+ (remzero f))))
+  (with-ring-and-order ((vars) :poly-lists (f)
+                                   :value-type :poly-list)
+    (grobner ring-and-order (remzero f))))
 
 (defmfun $poly_reduced_grobner (f vars)
-  (with-parsed-polynomials ((vars) :poly-lists (f)
-                                   :value-type :poly-list)
-    (reduced-grobner +maxima-ring+ (remzero f))))
+  (with-ring-and-order ((vars) :poly-lists (f)
+                                   :value-type :poly-list)
+    (reduced-grobner ring-and-order (remzero f))))
 
 (defmfun $poly_depends_p (p var mvars
@@ -504 +503 @@
 
 (defmfun $poly_elimination_ideal (flist k vars)
-  (with-parsed-polynomials ((vars) :poly-lists (flist)
-                                   :value-type :poly-list)
-    (elimination-ideal +maxima-ring+ flist k nil 0)))
+  (with-ring-and-order ((vars) :poly-lists (flist)
+                                   :value-type :poly-list)
+    (elimination-ideal ring-and-order flist k nil 0)))
 
 (defmfun $poly_colon_ideal (f g vars)
-  (with-parsed-polynomials ((vars) :poly-lists (f g) :value-type :poly-list)
-    (colon-ideal +maxima-ring+ f g nil)))
+  (with-ring-and-order ((vars) :poly-lists (f g) :value-type :poly-list)
+    (colon-ideal ring-and-order f g nil)))
 
 (defmfun $poly_ideal_intersection (f g vars)
-  (with-parsed-polynomials ((vars) :poly-lists (f g) :value-type :poly-list)  
-    (ideal-intersection +maxima-ring+ f g nil)))
+  (with-ring-and-order ((vars) :poly-lists (f g) :value-type :poly-list)  
+    (ideal-intersection ring-and-order f g nil)))
 
 (defmfun $poly_lcm (f g vars)
-  (with-parsed-polynomials ((vars) :polynomials (f g) :value-type :polynomial)
-    (poly-lcm +maxima-ring+ f g)))
+  (with-ring-and-order ((vars) :polynomials (f g) :value-type :polynomial)
+    (poly-lcm ring-and-order f g)))
 
 (defmfun $poly_gcd (f g vars)
@@ -524 +523 @@
 
 (defmfun $poly_grobner_equal (g1 g2 vars)
-  (with-parsed-polynomials ((vars) :poly-lists (g1 g2))
-    (grobner-equal +maxima-ring+ g1 g2)))
+  (with-ring-and-order ((vars) :poly-lists (g1 g2))
+    (grobner-equal ring-and-order g1 g2)))
 
 (defmfun $poly_grobner_subsetp (g1 g2 vars)
-  (with-parsed-polynomials ((vars) :poly-lists (g1 g2))
-    (grobner-subsetp +maxima-ring+ g1 g2)))
+  (with-ring-and-order ((vars) :poly-lists (g1 g2))
+    (grobner-subsetp ring-and-order g1 g2)))
 
 (defmfun $poly_grobner_member (p g vars)
-  (with-parsed-polynomials ((vars) :polynomials (p) :poly-lists (g))
-    (grobner-member +maxima-ring+ p g)))
+  (with-ring-and-order ((vars) :polynomials (p) :poly-lists (g))
+    (grobner-member ring-and-order p g)))
 
 (defmfun $poly_ideal_saturation1 (f p vars)
-  (with-parsed-polynomials ((vars) :poly-lists (f) :polynomials (p)
-                                   :value-type :poly-list)
-    (ideal-saturation-1 +maxima-ring+ f p 0)))
+  (with-ring-and-order ((vars) :poly-lists (f) :polynomials (p)
+                                   :value-type :poly-list)
+    (ideal-saturation-1 ring-and-order f p 0)))
 
 (defmfun $poly_saturation_extension (f plist vars new-vars)
-  (with-parsed-polynomials ((vars new-vars)
+  (with-ring-and-order ((vars new-vars)
                             :poly-lists (f plist)
                             :value-type :poly-list)
-    (saturation-extension +maxima-ring+ f plist)))
+    (saturation-extension ring-and-order f plist)))
 
 (defmfun $poly_polysaturation_extension (f plist vars new-vars)
-  (with-parsed-polynomials ((vars new-vars)
+  (with-ring-and-order ((vars new-vars)
                             :poly-lists (f plist)
                             :value-type :poly-list)
-    (polysaturation-extension +maxima-ring+ f plist)))
+    (polysaturation-extension ring-and-order f plist)))
 
 (defmfun $poly_ideal_polysaturation1 (f plist vars)
-  (with-parsed-polynomials ((vars) :poly-lists (f plist)
-                                   :value-type :poly-list)
-    (ideal-polysaturation-1 +maxima-ring+ f plist 0 nil)))
+  (with-ring-and-order ((vars) :poly-lists (f plist)
+                                   :value-type :poly-list)
+    (ideal-polysaturation-1 ring-and-order f plist 0 nil)))
 
 (defmfun $poly_ideal_saturation (f g vars)
-  (with-parsed-polynomials ((vars) :poly-lists (f g)
+  (with-ring-and-order ((vars) :poly-lists (f g)
                                    :value-type  :poly-list)
-    (ideal-saturation +maxima-ring+ f g 0 nil)))
+    (ideal-saturation ring-and-order f g 0 nil)))
 
 (defmfun $poly_ideal_polysaturation (f ideal-list vars)
-  (with-parsed-polynomials ((vars) :poly-lists (f)
+  (with-ring-and-order ((vars) :poly-lists (f)
                                    :poly-list-lists (ideal-list)
                                    :value-type :poly-list)
-    (ideal-polysaturation +maxima-ring+ f ideal-list 0 nil)))
+    (ideal-polysaturation ring-and-order f ideal-list 0 nil)))
 
 (defmfun $poly_lt (f vars)
-  (with-parsed-polynomials ((vars) :polynomials (f) :value-type :polynomial)
+  (with-ring-and-order ((vars) :polynomials (f) :value-type :polynomial)
     (make-poly-from-termlist (list (poly-lt f)))))
 
 (defmfun $poly_lm (f vars)
-  (with-parsed-polynomials ((vars) :polynomials (f) :value-type :polynomial)
-    (make-poly-from-termlist (list (make-term (poly-lm f) (funcall (ring-unit +maxima-ring+)))))))
-
-|#
+  (with-ring-and-order ((vars) :polynomials (f) :value-type :polynomial)
+    (make-poly-from-termlist (list (make-term (poly-lm f) (funcall (ring-unit ring-and-order)))))))
+