Changeset 2001 for branches/f4grobner

Timestamp:

2015-06-16T15:24:48-07:00 (10 years ago)

Author:

Marek Rychlik

Message:

* empty log message *

File:

• branches/f4grobner/pol.lisp (modified) (1 diff)

branches/f4grobner/pol.lisp

@@ -206 +206 @@
   (poly-lc (poly-eval expr nil ring order)))
 
-(defun spoly (ring-and-order f g
-              &aux
-                (ring (ro-ring ring-and-order)))
-  "It yields the S-polynomial of polynomials F and G."
-  (declare (type ring-and-order ring-and-order) (type poly f g))
-  (let* ((lcm (monom-lcm (poly-lm f) (poly-lm g)))
-          (mf (monom-div lcm (poly-lm f)))
-          (mg (monom-div lcm (poly-lm g))))
-    (declare (type monom mf mg))
-    (multiple-value-bind (c cf cg)
-        (funcall (ring-ezgcd ring) (poly-lc f) (poly-lc g))
-      (declare (ignore c))
-      (poly-sub 
-       ring-and-order
-       (scalar-times-poly ring cg (monom-times-poly mf f))
-       (scalar-times-poly ring cf (monom-times-poly mg g))))))
-
-
-(defun poly-primitive-part (ring p)
-  "Divide polynomial P with integer coefficients by gcd of its
-coefficients and return the result."
-  (declare (type ring ring) (type poly p))
-  (if (poly-zerop p)
-      (values p 1)
-    (let ((c (poly-content ring p)))
-      (values (make-poly-from-termlist 
-               (mapcar
-                #'(lambda (x)
-                    (make-term :monom (term-monom x)
-                               :coeff (funcall (ring-div ring) (term-coeff x) c)))
-                (poly-termlist p))
-               (poly-sugar p))
-              c))))
-
-(defun poly-content (ring p)
-  "Greatest common divisor of the coefficients of the polynomial P. Use the RING structure
-to compute the greatest common divisor."
-  (declare (type ring ring) (type poly p))
-  (reduce (ring-gcd ring) (mapcar #'term-coeff (rest (poly-termlist p))) :initial-value (poly-lc p)))
-
-(defun read-infix-form (&key (stream t))
-  "Parser of infix expressions with integer/rational coefficients
-The parser will recognize two kinds of polynomial expressions:
-
-- polynomials in fully expanded forms with coefficients
-  written in front of symbolic expressions; constants can be optionally
-  enclosed in (); for example, the infix form
-        X^2-Y^2+(-4/3)*U^2*W^3-5
-  parses to
-        (+ (- (EXPT X 2) (EXPT Y 2)) (* (- (/ 4 3)) (EXPT U 2) (EXPT W 3)) (- 5))
-
-- lists of polynomials; for example
-        [X-Y, X^2+3*Z]          
-  parses to
-          (:[ (- X Y) (+ (EXPT X 2) (* 3 Z)))
-  where the first symbol [ marks a list of polynomials.
-
--other infix expressions, for example
-        [(X-Y)*(X+Y)/Z,(X+1)^2]
-parses to:
-        (:[ (/ (* (- X Y) (+ X Y)) Z) (EXPT (+ X 1) 2))
-Currently this function is implemented using M. Kantrowitz's INFIX package."
-  (read-from-string
-   (concatenate 'string
-     "#I(" 
-     (with-output-to-string (s)
-       (loop
-         (multiple-value-bind (line eof)
-             (read-line stream t)
-           (format s "~A" line)
-           (when eof (return)))))
-     ")")))
+
         
-(defun read-poly (vars &key
-                         (stream t) 
-                         (ring +ring-of-integers+) 
-                         (order #'lex>))
-  "Reads an expression in prefix form from a stream STREAM.
-The expression read from the strem should represent a polynomial or a
-list of polynomials in variables VARS, over the ring RING.  The
-polynomial or list of polynomials is returned, with terms in each
-polynomial ordered according to monomial order ORDER."
-  (poly-eval (read-infix-form :stream stream) vars ring order))
-
-(defun string->poly (str vars 
-                     &optional
-                       (ring +ring-of-integers+) 
-                       (order #'lex>))
-  "Converts a string STR to a polynomial in variables VARS."
-  (with-input-from-string (s str)
-    (read-poly vars :stream s :ring ring :order order)))
-
-(defun poly->alist (p)
-  "Convert a polynomial P to an association list. Thus, the format of the
-returned value is  ((MONOM[0] . COEFF[0]) (MONOM[1] . COEFF[1]) ...), where
-MONOM[I] is a list of exponents in the monomial and COEFF[I] is the
-corresponding coefficient in the ring."
-  (cond
-    ((poly-p p)
-     (mapcar #'term->cons (poly-termlist p)))
-    ((and (consp p) (eq (car p) :[))
-     (cons :[ (mapcar #'poly->alist (cdr p))))))
-
-(defun string->alist (str vars
-                     &optional
-                       (ring +ring-of-integers+) 
-                       (order #'lex>))
-  "Convert a string STR representing a polynomial or polynomial list to
-an association list (... (MONOM . COEFF) ...)."
-  (poly->alist (string->poly str vars ring order)))
-
-(defun poly-equal-no-sugar-p (p q)
-  "Compare polynomials for equality, ignoring sugar."
-  (declare (type poly p q))
-  (equalp (poly-termlist p) (poly-termlist q)))
-
-(defun poly-set-equal-no-sugar-p (p q)
-  "Compare polynomial sets P and Q for equality, ignoring sugar."
-  (null (set-exclusive-or  p q :test #'poly-equal-no-sugar-p )))
-
-(defun poly-list-equal-no-sugar-p (p q)
-  "Compare polynomial lists P and Q for equality, ignoring sugar."
-  (every #'poly-equal-no-sugar-p p q))
-
-
+