close Warning: Can't synchronize with repository "(default)" (The repository directory has changed, you should resynchronize the repository with: trac-admin $ENV repository resync '(default)'). Look in the Trac log for more information.

source: branches/f4grobner/monom.lisp@ 3615

Last change on this file since 3615 was 3615, checked in by Marek Rychlik, 9 years ago

* empty log message *

File size: 20.9 KB
Line 
1;;; -*- Mode: Lisp -*-
2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3;;;
4;;; Copyright (C) 1999, 2002, 2009, 2015 Marek Rychlik <rychlik@u.arizona.edu>
5;;;
6;;; This program is free software; you can redistribute it and/or modify
7;;; it under the terms of the GNU General Public License as published by
8;;; the Free Software Foundation; either version 2 of the License, or
9;;; (at your option) any later version.
10;;;
11;;; This program is distributed in the hope that it will be useful,
12;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14;;; GNU General Public License for more details.
15;;;
16;;; You should have received a copy of the GNU General Public License
17;;; along with this program; if not, write to the Free Software
18;;; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19;;;
20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
21
22(defpackage "MONOM"
23 (:use :cl :copy)
24 (:export "MONOM"
25 "TERM"
26 "EXPONENT"
27 "MONOM-DIMENSION"
28 "MONOM-EXPONENTS"
29 "UNIVERSAL-EQUALP"
30 "MONOM-ELT"
31 "TOTAL-DEGREE"
32 "SUGAR"
33 "MULTIPLY-BY"
34 "DIVIDE-BY"
35 "DIVIDE"
36 "MULTIPLY-2"
37 "MULTIPLY"
38 "DIVIDES-P"
39 "DIVIDES-LCM-P"
40 "LCM-DIVIDES-LCM-P"
41 "LCM-EQUAL-LCM-P"
42 "DIVISIBLE-BY-P"
43 "REL-PRIME-P"
44 "UNIVERSAL-LCM"
45 "UNIVERSAL-GCD"
46 "DEPENDS-P"
47 "LEFT-TENSOR-PRODUCT-BY"
48 "RIGHT-TENSOR-PRODUCT-BY"
49 "LEFT-CONTRACT"
50 "MAKE-MONOM-VARIABLE"
51 "->LIST"
52 "LEX>"
53 "GRLEX>"
54 "REVLEX>"
55 "GREVLEX>"
56 "INVLEX>"
57 "REVERSE-MONOMIAL-ORDER"
58 "MAKE-ELIMINATION-ORDER-FACTORY"
59 "UNARY-MINUS")
60 (:documentation
61 "This package implements basic operations on monomials, including
62various monomial orders.
63
64DATA STRUCTURES: Conceptually, monomials can be represented as lists:
65
66 monom: (n1 n2 ... nk) where ni are non-negative integers
67
68However, lists may be implemented as other sequence types, so the
69flexibility to change the representation should be maintained in the
70code to use general operations on sequences whenever possible. The
71optimization for the actual representation should be left to
72declarations and the compiler.
73
74EXAMPLES: Suppose that variables are x and y. Then
75
76 Monom x*y^2 ---> (1 2) "))
77
78(in-package :monom)
79
80(proclaim '(optimize (speed 3) (space 0) (safety 0) (debug 0)))
81
82(deftype exponent ()
83 "Type of exponent in a monomial."
84 'fixnum)
85
86(defclass monom ()
87 ((exponents :initarg :exponents :accessor monom-exponents
88 :documentation "The powers of the variables."))
89 ;; default-initargs are not needed, they are handled by SHARED-INITIALIZE
90 ;;(:default-initargs :dimension 'foo :exponents 'bar :exponent 'baz)
91 (:documentation
92 "Implements a monomial, i.e. a product of powers
93of variables, like X*Y^2."))
94
95(defmethod print-object ((self monom) stream)
96 (print-unreadable-object (self stream :type t :identity t)
97 (with-accessors ((exponents monom-exponents))
98 self
99 (format stream "EXPONENTS=~A"
100 exponents))))
101
102(defmethod initialize-instance :after ((self monom)
103 &key
104 (dimension 0 dimension-supplied-p)
105 (exponents nil exponents-supplied-p)
106 (exponent 0)
107 &allow-other-keys
108 )
109 "The following INITIALIZE-INSTANCE method allows instance initialization
110of a MONOM in a style similar to MAKE-ARRAY, e.g.:
111
112 (MAKE-INSTANCE :EXPONENTS '(1 2 3)) --> #<MONOM EXPONENTS=#(1 2 3)>
113 (MAKE-INSTANCE :DIMENSION 3) --> #<MONOM EXPONENTS=#(0 0 0)>
114 (MAKE-INSTANCE :DIMENSION 3 :EXPONENT 7) --> #<MONOM EXPONENTS=#(7 7 7)>
115
116If both DIMENSION and EXPONENTS are supplied, they must be compatible,
117i.e. the length of EXPONENTS must be equal DIMENSION. If EXPONENTS
118is not supplied, a monom with repeated value EXPONENT is created.
119By default EXPONENT is 0, which results in a constant monomial.
120"
121 (cond
122 (exponents-supplied-p
123 (when (and dimension-supplied-p
124 (/= dimension (length exponents)))
125 (error "EXPONENTS (~A) must have supplied length DIMENSION (~A)"
126 exponents dimension))
127 (let ((dim (length exponents)))
128 (setf (slot-value self 'exponents) (make-array dim :initial-contents exponents))))
129 (dimension-supplied-p
130 ;; when all exponents are to be identical
131 (setf (slot-value self 'exponents) (make-array (list dimension)
132 :initial-element exponent
133 :element-type 'exponent)))
134 (t
135 (error "Initarg DIMENSION or EXPONENTS must be supplied."))))
136
137(defgeneric monom-dimension (m)
138 (:method ((m monom))
139 (length (monom-exponents m))))
140
141(defgeneric universal-equalp (object1 object2)
142 (:documentation "Returns T iff OBJECT1 and OBJECT2 are equal.")
143 (:method ((object1 cons) (object2 cons)) (equalp object1 object2))
144 (:method ((object1 number) (object2 number)) (= object1 object2))
145 (:method ((m1 monom) (m2 monom))
146 "Returns T iff monomials M1 and M2 have identical EXPONENTS."
147 (equalp (monom-exponents m1) (monom-exponents m2))))
148
149(defgeneric monom-elt (m index)
150 (:documentation "Return the power in the monomial M of variable number INDEX.")
151 (:method ((m monom) index)
152 "Return the power in the monomial M of variable number INDEX."
153 (with-slots (exponents)
154 m
155 (elt exponents index))))
156
157(defgeneric (setf monom-elt) (new-value m index)
158 (:documentation "Set the power in the monomial M of variable number INDEX.")
159 (:method (new-value (m monom) index)
160 (with-slots (exponents)
161 m
162 (setf (elt exponents index) new-value))))
163
164(defgeneric total-degree (m &optional start end)
165 (:documentation "Return the total degree of a monomoal M. Optinally, a range
166of variables may be specified with arguments START and END.")
167 (:method ((m monom) &optional (start 0) (end (monom-dimension m)))
168 (declare (type fixnum start end))
169 (with-slots (exponents)
170 m
171 (reduce #'+ exponents :start start :end end))))
172
173(defgeneric sugar (m &optional start end)
174 (:documentation "Return the sugar of a monomial M. Optinally, a range
175of variables may be specified with arguments START and END.")
176 (:method ((m monom) &optional (start 0) (end (monom-dimension m)))
177 (declare (type fixnum start end))
178 (total-degree m start end)))
179
180(defgeneric multiply-by (self other)
181 (:documentation "Multiply SELF by OTHER, return SELF.")
182 (:method ((self number) (other number)) (* self other))
183 (:method ((self monom) (other monom))
184 (with-slots ((exponents1 exponents))
185 self
186 (with-slots ((exponents2 exponents))
187 other
188 (unless (= (length exponents1) (length exponents2))
189 (error "Incompatible dimensions"))
190 (map-into exponents1 #'+ exponents1 exponents2)))
191 self))
192
193(defgeneric divide-by (self other)
194 (:documentation "Divide SELF by OTHER, return SELF.")
195 (:method ((self number) (other number)) (/ self other))
196 (:method ((self monom) (other monom))
197 (with-slots ((exponents1 exponents))
198 self
199 (with-slots ((exponents2 exponents))
200 other
201 (unless (= (length exponents1) (length exponents2))
202 (error "divide-by: Incompatible dimensions."))
203 (unless (every #'>= exponents1 exponents2)
204 (error "divide-by: Negative power would result."))
205 (map-into exponents1 #'- exponents1 exponents2)))
206 self))
207
208(defmethod copy-instance :around ((object monom) &rest initargs &key &allow-other-keys)
209 "An :AROUND method of COPY-INSTANCE. It replaces
210exponents with a fresh copy of the sequence."
211 (declare (ignore object initargs))
212 (let ((copy (call-next-method)))
213 (setf (monom-exponents copy) (copy-seq (monom-exponents copy)))
214 copy))
215
216(defun multiply-2 (object1 object2)
217 "Multiply OBJECT1 by OBJECT2"
218 (multiply-by (copy-instance object1) (copy-instance object2)))
219
220(defun multiply (&rest factors)
221 "Non-destructively multiply list FACTORS."
222 (reduce #'multiply-2 factors))
223
224(defun divide (numerator &rest denominators)
225 "Non-destructively divide object NUMERATOR by product of DENOMINATORS."
226 (divide-by (copy-instance numerator) (apply #'multiply denominators)))
227
228(defgeneric divides-p (object1 object2)
229 (:documentation "Returns T if OBJECT1 divides OBJECT2.")
230 (:method ((m1 monom) (m2 monom))
231 "Returns T if monomial M1 divides monomial M2, NIL otherwise."
232 (with-slots ((exponents1 exponents))
233 m1
234 (with-slots ((exponents2 exponents))
235 m2
236 (every #'<= exponents1 exponents2)))))
237
238(defgeneric divides-lcm-p (object1 object2 object3)
239 (:documentation "Returns T if OBJECT1 divides LCM(OBJECT2,OBJECT3), NIL otherwise.")
240 (:method ((m1 monom) (m2 monom) (m3 monom))
241 "Returns T if monomial M1 divides LCM(M2,M3), NIL otherwise."
242 (with-slots ((exponents1 exponents))
243 m1
244 (with-slots ((exponents2 exponents))
245 m2
246 (with-slots ((exponents3 exponents))
247 m3
248 (every #'(lambda (x y z) (<= x (max y z)))
249 exponents1 exponents2 exponents3))))))
250
251(defgeneric lcm-divides-lcm-p (object1 object2 object3 object4)
252 (:method ((m1 monom) (m2 monom) (m3 monom) (m4 monom))
253 "Returns T if monomial LCM(M1,M2) divides LCM(M3,M4), NIL otherwise."
254 (with-slots ((exponents1 exponents))
255 m1
256 (with-slots ((exponents2 exponents))
257 m2
258 (with-slots ((exponents3 exponents))
259 m3
260 (with-slots ((exponents4 exponents))
261 m4
262 (every #'(lambda (x y z w) (<= (max x y) (max z w)))
263 exponents1 exponents2 exponents3 exponents4)))))))
264
265(defgeneric monom-lcm-equal-lcm-p (object1 object2 object3 object4)
266 (:method ((m1 monom) (m2 monom) (m3 monom) (m4 monom))
267 "Returns T if monomial LCM(M1,M2) equals LCM(M3,M4), NIL otherwise."
268 (with-slots ((exponents1 exponents))
269 m1
270 (with-slots ((exponents2 exponents))
271 m2
272 (with-slots ((exponents3 exponents))
273 m3
274 (with-slots ((exponents4 exponents))
275 m4
276 (every
277 #'(lambda (x y z w) (= (max x y) (max z w)))
278 exponents1 exponents2 exponents3 exponents4)))))))
279
280(defgeneric divisible-by-p (object1 object2)
281 (:documentation "Return T if OBJECT1 is divisible by OBJECT2.")
282 (:method ((m1 monom) (m2 monom))
283 "Returns T if monomial M1 is divisible by monomial M2, NIL otherwise."
284 (with-slots ((exponents1 exponents))
285 m1
286 (with-slots ((exponents2 exponents))
287 m2
288 (every #'>= exponents1 exponents2)))))
289
290(defgeneric rel-prime-p (object1 object2)
291 (:documentation "Returns T if objects OBJECT1 and OBJECT2 are relatively prime.")
292 (:method ((m1 monom) (m2 monom))
293 "Returns T if two monomials M1 and M2 are relatively prime (disjoint)."
294 (with-slots ((exponents1 exponents))
295 m1
296 (with-slots ((exponents2 exponents))
297 m2
298 (every #'(lambda (x y) (zerop (min x y))) exponents1 exponents2)))))
299
300(defgeneric universal-lcm (object1 object2)
301 (:documentation "Returns the multiple of objects OBJECT1 and OBJECT2.")
302 (:method ((m1 monom) (m2 monom))
303 "Returns least common multiple of monomials M1 and M2."
304 (with-slots ((exponents1 exponents))
305 m1
306 (with-slots ((exponents2 exponents))
307 m2
308 (let* ((exponents (copy-seq exponents1)))
309 (map-into exponents #'max exponents1 exponents2)
310 (make-instance 'monom :exponents exponents))))))
311
312
313(defgeneric universal-gcd (object1 object2)
314 (:documentation "Returns GCD of objects OBJECT1 and OBJECT2")
315 (:method ((m1 monom) (m2 monom))
316 "Returns greatest common divisor of monomials M1 and M2."
317 (with-slots ((exponents1 exponents))
318 m1
319 (with-slots ((exponents2 exponents))
320 m2
321 (let* ((exponents (copy-seq exponents1)))
322 (map-into exponents #'min exponents1 exponents2)
323 (make-instance 'monom :exponents exponents))))))
324
325(defgeneric depends-p (object k)
326 (:documentation "Returns T iff object OBJECT depends on variable K.")
327 (:method ((m monom) k)
328 "Return T if the monomial M depends on variable number K."
329 (declare (type fixnum k))
330 (with-slots (exponents)
331 m
332 (plusp (elt exponents k)))))
333
334(defgeneric left-tensor-product-by (self other)
335 (:documentation "Returns a tensor product SELF by OTHER, stored into
336 SELF. Return SELF.")
337 (:method ((self monom) (other monom))
338 (with-slots ((exponents1 exponents))
339 self
340 (with-slots ((exponents2 exponents))
341 other
342 (setf exponents1 (concatenate 'vector exponents2 exponents1))))
343 self))
344
345(defgeneric right-tensor-product-by (self other)
346 (:documentation "Returns a tensor product of OTHER by SELF, stored
347 into SELF. Returns SELF.")
348 (:method ((self monom) (other monom))
349 (with-slots ((exponents1 exponents))
350 self
351 (with-slots ((exponents2 exponents))
352 other
353 (setf exponents1 (concatenate 'vector exponents1 exponents2))))
354 self))
355
356(defgeneric left-contract (self k)
357 (:documentation "Drop the first K variables in object SELF.")
358 (:method ((self monom) k)
359 "Drop the first K variables in monomial M."
360 (declare (fixnum k))
361 (with-slots (exponents)
362 self
363 (setf exponents (subseq exponents k)))
364 self))
365
366(defun make-monom-variable (nvars pos &optional (power 1)
367 &aux (m (make-instance 'monom :dimension nvars)))
368 "Construct a monomial in the polynomial ring
369RING[X[0],X[1],X[2],...X[NVARS-1]] over the (unspecified) ring RING
370which represents a single variable. It assumes number of variables
371NVARS and the variable is at position POS. Optionally, the variable
372may appear raised to power POWER. "
373 (declare (type fixnum nvars pos power) (type monom m))
374 (with-slots (exponents)
375 m
376 (setf (elt exponents pos) power)
377 m))
378
379(defgeneric ->list (object)
380 (:method ((m monom))
381 "A human-readable representation of a monomial M as a list of exponents."
382 (coerce (monom-exponents m) 'list)))
383
384;; pure lexicographic
385(defgeneric lex> (p q &optional start end)
386 (:documentation "Return T if P>Q with respect to lexicographic
387order, otherwise NIL. The second returned value is T if P=Q,
388otherwise it is NIL.")
389 (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension p)))
390 (declare (type fixnum start end))
391 (do ((i start (1+ i)))
392 ((>= i end) (values nil t))
393 (cond
394 ((> (monom-elt p i) (monom-elt q i))
395 (return-from lex> (values t nil)))
396 ((< (monom-elt p i) (monom-elt q i))
397 (return-from lex> (values nil nil)))))))
398
399;; total degree order, ties broken by lexicographic
400(defgeneric grlex> (p q &optional start end)
401 (:documentation "Return T if P>Q with respect to graded
402lexicographic order, otherwise NIL. The second returned value is T if
403P=Q, otherwise it is NIL.")
404 (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension p)))
405 (declare (type monom p q) (type fixnum start end))
406 (let ((d1 (total-degree p start end))
407 (d2 (total-degree q start end)))
408 (declare (type fixnum d1 d2))
409 (cond
410 ((> d1 d2) (values t nil))
411 ((< d1 d2) (values nil nil))
412 (t
413 (lex> p q start end))))))
414
415;; reverse lexicographic
416(defgeneric revlex> (p q &optional start end)
417 (:documentation "Return T if P>Q with respect to reverse
418lexicographic order, NIL otherwise. The second returned value is T if
419P=Q, otherwise it is NIL. This is not and admissible monomial order
420because some sets do not have a minimal element. This order is useful
421in constructing other orders.")
422 (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension p)))
423 (declare (type fixnum start end))
424 (do ((i (1- end) (1- i)))
425 ((< i start) (values nil t))
426 (declare (type fixnum i))
427 (cond
428 ((< (monom-elt p i) (monom-elt q i))
429 (return-from revlex> (values t nil)))
430 ((> (monom-elt p i) (monom-elt q i))
431 (return-from revlex> (values nil nil)))))))
432
433
434;; total degree, ties broken by reverse lexicographic
435(defgeneric grevlex> (p q &optional start end)
436 (:documentation "Return T if P>Q with respect to graded reverse
437lexicographic order, NIL otherwise. The second returned value is T if
438P=Q, otherwise it is NIL.")
439 (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension p)))
440 (declare (type fixnum start end))
441 (let ((d1 (total-degree p start end))
442 (d2 (total-degree q start end)))
443 (declare (type fixnum d1 d2))
444 (cond
445 ((> d1 d2) (values t nil))
446 ((< d1 d2) (values nil nil))
447 (t
448 (revlex> p q start end))))))
449
450(defgeneric invlex> (p q &optional start end)
451 (:documentation "Return T if P>Q with respect to inverse
452lexicographic order, NIL otherwise The second returned value is T if
453P=Q, otherwise it is NIL.")
454 (:method ((p monom) (q monom) &optional (start 0) (end (monom-dimension p)))
455 (declare (type fixnum start end))
456 (do ((i (1- end) (1- i)))
457 ((< i start) (values nil t))
458 (declare (type fixnum i))
459 (cond
460 ((> (monom-elt p i) (monom-elt q i))
461 (return-from invlex> (values t nil)))
462 ((< (monom-elt p i) (monom-elt q i))
463 (return-from invlex> (values nil nil)))))))
464
465(defun reverse-monomial-order (order)
466 "Create the inverse monomial order to the given monomial order ORDER."
467 #'(lambda (p q &optional (start 0) (end (monom-dimension q)))
468 (declare (type monom p q) (type fixnum start end))
469 (funcall order q p start end)))
470
471;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
472;;
473;; Order making functions
474;;
475;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
476
477;; This returns a closure with the same signature
478;; as all orders such as #'LEX>.
479(defun make-elimination-order-factory-1 (&optional (secondary-elimination-order #'lex>))
480 "It constructs an elimination order used for the 1-st elimination ideal,
481i.e. for eliminating the first variable. Thus, the order compares the degrees of the
482first variable in P and Q first, with ties broken by SECONDARY-ELIMINATION-ORDER."
483 #'(lambda (p q &optional (start 0) (end (monom-dimension p)))
484 (declare (type monom p q) (type fixnum start end))
485 (cond
486 ((> (monom-elt p start) (monom-elt q start))
487 (values t nil))
488 ((< (monom-elt p start) (monom-elt q start))
489 (values nil nil))
490 (t
491 (funcall secondary-elimination-order p q (1+ start) end)))))
492
493;; This returns a closure which is called with an integer argument.
494;; The result is *another closure* with the same signature as all
495;; orders such as #'LEX>.
496(defun make-elimination-order-factory (&optional
497 (primary-elimination-order #'lex>)
498 (secondary-elimination-order #'lex>))
499 "Return a function with a single integer argument K. This should be
500the number of initial K variables X[0],X[1],...,X[K-1], which precede
501remaining variables. The call to the closure creates a predicate
502which compares monomials according to the K-th elimination order. The
503monomial orders PRIMARY-ELIMINATION-ORDER and
504SECONDARY-ELIMINATION-ORDER are used to compare the first K and the
505remaining variables, respectively, with ties broken by lexicographical
506order. That is, if PRIMARY-ELIMINATION-ORDER yields (VALUES NIL T),
507which indicates that the first K variables appear with identical
508powers, then the result is that of a call to
509SECONDARY-ELIMINATION-ORDER applied to the remaining variables
510X[K],X[K+1],..."
511 #'(lambda (k)
512 (cond
513 ((<= k 0)
514 (error "K must be at least 1"))
515 ((= k 1)
516 (make-elimination-order-factory-1 secondary-elimination-order))
517 (t
518 #'(lambda (p q &optional (start 0) (end (monom-dimension p)))
519 (declare (type monom p q) (type fixnum start end))
520 (multiple-value-bind (primary equal)
521 (funcall primary-elimination-order p q start k)
522 (if equal
523 (funcall secondary-elimination-order p q k end)
524 (values primary nil))))))))
525
526(defclass term (monom)
527 ((coeff :initarg :coeff :accessor term-coeff))
528 (:default-initargs :coeff nil)
529 (:documentation "Implements a term, i.e. a product of a scalar
530and powers of some variables, such as 5*X^2*Y^3."))
531
532(defmethod print-object ((self term) stream)
533 (print-unreadable-object (self stream :type t :identity t)
534 (with-accessors ((exponents monom-exponents)
535 (coeff term-coeff))
536 self
537 (format stream "EXPONENTS=~A COEFF=~A"
538 exponents coeff))))
539
540(defmethod universal-equalp ((term1 term) (term2 term))
541 "Returns T if TERM1 and TERM2 are equal as MONOM, and coefficients
542are UNIVERSAL-EQUALP."
543 (and (call-next-method)
544 (universal-equalp (term-coeff term1) (term-coeff term2))))
545
546(defmethod update-instance-for-different-class :after ((old monom) (new term) &key)
547 (setf (term-coeff new) 1))
548
549(defmethod multiply-by :before ((self term) (other term))
550 "Destructively multiply terms SELF and OTHER and store the result into SELF.
551It returns SELF."
552 (setf (term-coeff self) (multiply-by (term-coeff self) (term-coeff other))))
553
554(defmethod left-tensor-product-by :before ((self term) (other term))
555 (setf (term-coeff self) (multiply-by (term-coeff self) (term-coeff other))))
556
557(defmethod right-tensor-product-by :before ((self term) (other term))
558 (setf (term-coeff self) (multiply-by (term-coeff self) (term-coeff other))))
559
560(defmethod divide-by :before ((self term) (other term))
561 (setf (term-coeff self) (divide-by (term-coeff self) (term-coeff other))))
562
563(defgeneric unary-minus (self)
564 (:documentation "Negate object SELF and return it.")
565 (:method ((self number)) (- self))
566 (:method ((self term))
567 (setf (term-coeff self) (unary-minus (term-coeff self)))
568 self))
569
570(defgeneric universal-zerop (self)
571 (:method ((self term))
572 (universal-zerop (term-coeff self))))
Note: See TracBrowser for help on using the repository browser.