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/mx-grobner.lisp@ 1720

Last change on this file since 1720 was 1720, checked in by Marek Rychlik, 10 years ago

* empty log message *
File size: 19.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
23;;
24;; Load this file into Maxima to bootstrap the Grobner package.
25;; NOTE: This file does use symbols defined by Maxima, so it
26;; will not work when loaded in Common Lisp.
27;;
28;; DETAILS: This file implements an interface between the Grobner
29;; basis package NGROBNER, which is a pure Common Lisp package, and
30;; Maxima. NGROBNER for efficiency uses its own representation of
31;; polynomials. Thus, it is necessary to convert Maxima representation
32;; to the internal representation and back. The facilities to do so
33;; are implemented in this file.
34;;
35;; Also, since the NGROBNER package consists of many Lisp files, it is
36;; necessary to load the files. It is possible and preferrable to use
37;; ASDF for this purpose. The default is ASDF. It is also possible to
38;; simply used LOAD and COMPILE-FILE to accomplish this task.
39;;
40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
41
42(in-package :maxima)
43
44(macsyma-module cgb-maxima)
45
46
47(eval-when
48 #+gcl (load eval)
49 #-gcl (:load-toplevel :execute)
50 (format t "~&Loading maxima-grobner ~a ~a~%"
51 "$Revision: 2.0 $" "$Date: 2015/06/02 0:34:17 $"))
52
53;;FUNCTS is loaded because it contains the definition of LCM
54($load "functs")
55#+sbcl(progn (require 'asdf) (load "ngrobner.asd")(asdf:load-system :ngrobner))
56
57(use-package :ngrobner)
58
59
60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
61;;
62;; Maxima expression ring
63;;
64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
65;;
66;; This is how we perform operations on coefficients
67;; using Maxima functions.
68;;
69;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
70
71(defparameter +maxima-ring+
72 (make-ring
73 ;;(defun coeff-zerop (expr) (meval1 `(($is) (($equal) ,expr 0))))
74 :parse #'(lambda (expr)
75 (when modulus (setf expr ($rat expr)))
76 expr)
77 :unit #'(lambda () (if modulus ($rat 1) 1))
78 :zerop #'(lambda (expr)
79 ;;When is exactly a maxima expression equal to 0?
80 (cond ((numberp expr)
81 (= expr 0))
82 ((atom expr) nil)
83 (t
84 (case (caar expr)
85 (mrat (eql ($ratdisrep expr) 0))
86 (otherwise (eql ($totaldisrep expr) 0))))))
87 :add #'(lambda (x y) (m+ x y))
88 :sub #'(lambda (x y) (m- x y))
89 :uminus #'(lambda (x) (m- x))
90 :mul #'(lambda (x y) (m* x y))
91 ;;(defun coeff-div (x y) (cadr ($divide x y)))
92 :div #'(lambda (x y) (m// x y))
93 :lcm #'(lambda (x y) (meval1 `((|$LCM|) ,x ,y)))
94 :ezgcd #'(lambda (x y) (apply #'values (cdr ($ezgcd ($totaldisrep x) ($totaldisrep y)))))
95 ;; :gcd #'(lambda (x y) (second ($ezgcd x y)))))
96 :gcd #'(lambda (x y) ($gcd x y))))
97
98;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
99;;
100;; Maxima expression parsing
101;;
102;;
103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
104;;
105;; Functions and macros dealing with internal representation
106;; structure.
107;;
108;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
109
110(defun equal-test-p (expr1 expr2)
111 (alike1 expr1 expr2))
112
113(defun coerce-maxima-list (expr)
114 "Convert a Maxima list to Lisp list."
115 (cond
116 ((and (consp (car expr)) (eql (caar expr) 'mlist)) (cdr expr))
117 (t expr)))
118
119(defun free-of-vars (expr vars) (apply #'$freeof `(,@vars ,expr)))
120
121;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
122;;
123;; Order utilities
124;;
125;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
126
127(defun find-ring-by-name (ring)
128 "This function returns the ring structure bases on input symbol."
129 (cond
130 ((null ring) nil)
131 ((symbolp ring)
132 (case ring
133 ((maxima-ring :maxima-ring #:maxima-ring $expression_ring #:expression_ring)
134 +maxima-ring+)
135 ((ring-of-integers :ring-of-integers #:ring-of-integers $ring_of_integers) +ring-of-integers+)
136 (otherwise
137 (mtell "~%Warning: Ring ~M not found. Using default.~%" ring))))
138 (t
139 (mtell "~%Ring specification ~M is not recognized. Using default.~%" ring)
140 nil)))
141
142(defun find-order-by-name (order)
143 "This function returns the order function bases on its name."
144 (cond
145 ((null order) nil)
146 ((symbolp order)
147 (case order
148 ((lex :lex $lex #:lex)
149 #'lex>)
150 ((grlex :grlex $grlex #:grlex)
151 #'grlex>)
152 ((grevlex :grevlex $grevlex #:grevlex)
153 #'grevlex>)
154 ((invlex :invlex $invlex #:invlex)
155 #'invlex>)
156 (otherwise
157 (mtell "~%Warning: Order ~M not found. Using default.~%" order))))
158 (t
159 (mtell "~%Order specification ~M is not recognized. Using default.~%" order)
160 nil)))
161
162(defun find-ring-and-order-by-name (&optional
163 (ring (find-ring-by-name $poly_coefficient_ring))
164 (order (find-order-by-name $poly_monomial_order))
165 (primary-elimination-order (find-order-by-name $poly_primary_elimination_order))
166 (secondary-elimination-order (find-order-by-name $poly_secondary_elimination_order))
167 &aux
168 (ring-and-order (make-ring-and-order
169 :ring ring
170 :order order
171 :primary-elimination-order primary-elimination-order
172 :secondary-elimination-order secondary-elimination-order)))
173 "Build RING-AND-ORDER structure from Maxima-level switches."
174 ring-and-order)
175
176(defun maxima->poly (expr vars
177 &optional
178 (ring-and-order (find-ring-and-order-by-name))
179 &aux
180 (vars (coerce-maxima-list vars))
181 (ring (ro-ring ring-and-order)))
182 "Convert a maxima polynomial expression EXPR in variables VARS to
183internal form. This works by first converting the expression to Lisp,
184and then evaluating the expression using polynomial arithmetic
185implemented by the POLYNOMIAL package."
186 (labels ((parse (arg) (maxima->poly arg vars ring-and-order))
187 (parse-list (args) (mapcar #'parse args)))
188 (cond
189 ((eql expr 0) (make-poly-zero))
190 ((member expr vars :test #'equal-test-p)
191 (let ((pos (position expr vars :test #'equal-test-p)))
192 (make-poly-variable ring (length vars) pos)))
193 ((free-of-vars expr vars)
194 ;;This means that variable-free CRE and Poisson forms will be converted
195 ;;to coefficients intact
196 (coerce-coeff ring expr vars))
197 (t
198 (case (caar expr)
199 (mplus (reduce #'(lambda (x y) (poly-add ring-and-order x y)) (parse-list (cdr expr))))
200 (mminus (poly-uminus ring (parse (cadr expr))))
201 (mtimes
202 (if (endp (cddr expr)) ;unary
203 (parse (cdr expr))
204 (reduce #'(lambda (p q) (poly-mul ring-and-order p q)) (parse-list (cdr expr)))))
205 (mexpt
206 (cond
207 ((member (cadr expr) vars :test #'equal-test-p)
208 ;;Special handling of (expt var pow)
209 (let ((pos (position (cadr expr) vars :test #'equal-test-p)))
210 (make-poly-variable ring (length vars) pos (caddr expr))))
211 ((not (and (integerp (caddr expr)) (plusp (caddr expr))))
212 ;; Negative power means division in coefficient ring
213 ;; Non-integer power means non-polynomial coefficient
214 (mtell "~%Warning: Expression ~%~M~%contains power which is not a positive integer. Parsing as coefficient.~%"
215 expr)
216 (coerce-coeff ring expr vars))
217 (t (poly-expt ring (parse (cadr expr)) (caddr expr)))))
218 (mrat (parse ($ratdisrep expr)))
219 (mpois (parse ($outofpois expr)))
220 (otherwise
221 (coerce-coeff ring expr vars)))))))
222
223(defun maxima->poly-list (expr vars
224 &optional
225 (ring-and-order (find-ring-and-order-by-name)))
226 "Convert a Maxima representation of a list of polynomials to the internal form."
227 (case (caar expr)
228 (mlist (mapcar #'(lambda (p)
229 (maxima->poly p vars ring-and-order))
230 (cdr expr)))
231 (otherwise (merror "Expression ~M is not a list of polynomials in variables ~M."
232 expr vars))))
233
234(defun maxima->poly-list-of-lists (poly-list-of-lists vars
235 &optional
236 (ring-and-order (find-ring-and-order-by-name)))
237 "Parse a Maxima representation of a list of lists of polynomials."
238 (mapcar #'(lambda (g) (maxima->poly-list g vars ring-and-order))
239 (coerce-maxima-list poly-list-of-lists)))
240
241
242
243;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
244;;
245;; Conversion from internal form to Maxima general form
246;;
247;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
248
249(defun maxima-head ()
250 (if $poly_return_term_list
251 '(mlist)
252 '(mplus)))
253
254(defun poly->maxima (poly-type object vars)
255 (case poly-type
256 (:polynomial
257 `(,(maxima-head) ,@(mapcar #'(lambda (term) (poly->maxima :term term vars)) (poly-termlist object))))
258 (:poly-list
259 `((mlist) ,@(mapcar #'(lambda (p) ($ratdisrep (poly->maxima :polynomial p vars))) object)))
260 (:term
261 `((mtimes) ,($ratdisrep (term-coeff object))
262 ,@(mapcar #'(lambda (var power) `((mexpt) ,var ,power))
263 vars (monom->list (term-monom object)))))
264 ;; Assumes that Lisp and Maxima logicals coincide
265 (:logical object)
266 (otherwise
267 object)))
268
269
270#|
271
272
273;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
274;;
275;; Unary and binary operation definition facility
276;;
277;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
278
279(defmacro define-unop (maxima-name fun-name
280 &optional (documentation nil documentation-supplied-p))
281 "Define a MAXIMA-level unary operator MAXIMA-NAME corresponding to unary function FUN-NAME."
282 `(defun ,maxima-name (p vars
283 &aux
284 (vars (coerce-maxima-list vars))
285 (p (parse-poly p vars)))
286 ,@(when documentation-supplied-p (list documentation))
287 (coerce-to-maxima :polynomial (,fun-name +maxima-ring+ p) vars)))
288
289(defmacro define-binop (maxima-name fun-name
290 &optional (documentation nil documentation-supplied-p))
291 "Define a MAXIMA-level binary operator MAXIMA-NAME corresponding to binary function FUN-NAME."
292 `(defmfun ,maxima-name (p q vars
293 &aux
294 (vars (coerce-maxima-list vars))
295 (p (parse-poly p vars))
296 (q (parse-poly q vars)))
297 ,@(when documentation-supplied-p (list documentation))
298 (coerce-to-maxima :polynomial (,fun-name +maxima-ring+ p q) vars)))
299
300
301;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
302;;
303;; Facilities for evaluating Grobner package expressions
304;; within a prepared environment
305;;
306;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
307
308(defmacro with-monomial-order ((order) &body body)
309 "Evaluate BODY with monomial order set to ORDER."
310 `(let ((*monomial-order* (or (find-order ,order) *monomial-order*)))
311 . ,body))
312
313(defmacro with-coefficient-ring ((ring) &body body)
314 "Evaluate BODY with coefficient ring set to RING."
315 `(let ((+maxima-ring+ (or (find-ring ,ring) +maxima-ring+)))
316 . ,body))
317
318(defmacro with-ring-and-order ((ring order) &body body)
319 "Evaluate BODY with monomial order set to ORDER and coefficient ring set to RING."
320 `(let ((*monomial-order* (or (find-order ,order) *monomial-order*))
321 (+maxima-ring+ (or (find-ring ,ring) +maxima-ring+)))
322 . ,body))
323
324(defmacro with-elimination-orders ((primary secondary elimination-order)
325 &body body)
326 "Evaluate BODY with primary and secondary elimination orders set to PRIMARY and SECONDARY."
327 `(let ((*primary-elimination-order* (or (find-order ,primary) *primary-elimination-order*))
328 (*secondary-elimination-order* (or (find-order ,secondary) *secondary-elimination-order*))
329 (*elimination-order* (or (find-order ,elimination-order) *elimination-order*)))
330 . ,body))
331
332
333;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
334;;
335;; Maxima-level interface functions
336;;
337;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
338
339;; Auxillary function for removing zero polynomial
340(defun remzero (plist) (remove #'poly-zerop plist))
341
342;;Simple operators
343
344(define-binop $poly_add poly-add
345 "Adds two polynomials P and Q")
346
347(define-binop $poly_subtract poly-sub
348 "Subtracts a polynomial Q from P.")
349
350(define-binop $poly_multiply poly-mul
351 "Returns the product of polynomials P and Q.")
352
353(define-binop $poly_s_polynomial spoly
354 "Returns the syzygy polynomial (S-polynomial) of two polynomials P and Q.")
355
356(define-unop $poly_primitive_part poly-primitive-part
357 "Returns the polynomial P divided by GCD of its coefficients.")
358
359(define-unop $poly_normalize poly-normalize
360 "Returns the polynomial P divided by the leading coefficient.")
361
362;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
363;;
364;; Macro facility for writing Maxima-level wrappers for
365;; functions operating on internal representation
366;;
367;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
368
369(defmacro with-parsed-polynomials (((maxima-vars &optional (maxima-new-vars nil new-vars-supplied-p))
370 &key (polynomials nil)
371 (poly-lists nil)
372 (poly-list-lists nil)
373 (value-type nil))
374 &body body
375 &aux (vars (gensym))
376 (new-vars (gensym)))
377 `(let ((,vars (coerce-maxima-list ,maxima-vars))
378 ,@(when new-vars-supplied-p
379 (list `(,new-vars (coerce-maxima-list ,maxima-new-vars)))))
380 (coerce-to-maxima
381 ,value-type
382 (with-coefficient-ring ($poly_coefficient_ring)
383 (with-monomial-order ($poly_monomial_order)
384 (with-elimination-orders ($poly_primary_elimination_order
385 $poly_secondary_elimination_order
386 $poly_elimination_order)
387 (let ,(let ((args nil))
388 (dolist (p polynomials args)
389 (setf args (cons `(,p (parse-poly ,p ,vars)) args)))
390 (dolist (p poly-lists args)
391 (setf args (cons `(,p (parse-poly-list ,p ,vars)) args)))
392 (dolist (p poly-list-lists args)
393 (setf args (cons `(,p (parse-poly-list-list ,p ,vars)) args))))
394 . ,body))))
395 ,(if new-vars-supplied-p
396 `(append ,vars ,new-vars)
397 vars))))
398
399
400;;Functions
401
402(defmfun $poly_expand (p vars)
403 "This function is equivalent to EXPAND(P) if P parses correctly to a polynomial.
404If the representation is not compatible with a polynomial in variables VARS,
405the result is an error."
406 (with-parsed-polynomials ((vars) :polynomials (p)
407 :value-type :polynomial)
408 p))
409
410(defmfun $poly_expt (p n vars)
411 (with-parsed-polynomials ((vars) :polynomials (p) :value-type :polynomial)
412 (poly-expt +maxima-ring+ p n)))
413
414(defmfun $poly_content (p vars)
415 (with-parsed-polynomials ((vars) :polynomials (p))
416 (poly-content +maxima-ring+ p)))
417
418(defmfun $poly_pseudo_divide (f fl vars
419 &aux (vars (coerce-maxima-list vars))
420 (f (parse-poly f vars))
421 (fl (parse-poly-list fl vars)))
422 (multiple-value-bind (quot rem c division-count)
423 (poly-pseudo-divide +maxima-ring+ f fl)
424 `((mlist)
425 ,(coerce-to-maxima :poly-list quot vars)
426 ,(coerce-to-maxima :polynomial rem vars)
427 ,c
428 ,division-count)))
429
430(defmfun $poly_exact_divide (f g vars)
431 (with-parsed-polynomials ((vars) :polynomials (f g) :value-type :polynomial)
432 (poly-exact-divide +maxima-ring+ f g)))
433
434(defmfun $poly_normal_form (f fl vars)
435 (with-parsed-polynomials ((vars) :polynomials (f)
436 :poly-lists (fl)
437 :value-type :polynomial)
438 (normal-form +maxima-ring+ f (remzero fl) nil)))
439
440(defmfun $poly_buchberger_criterion (g vars)
441 (with-parsed-polynomials ((vars) :poly-lists (g) :value-type :logical)
442 (buchberger-criterion +maxima-ring+ g)))
443
444(defmfun $poly_buchberger (fl vars)
445 (with-parsed-polynomials ((vars) :poly-lists (fl) :value-type :poly-list)
446 (buchberger +maxima-ring+ (remzero fl) 0 nil)))
447
448(defmfun $poly_reduction (plist vars)
449 (with-parsed-polynomials ((vars) :poly-lists (plist)
450 :value-type :poly-list)
451 (reduction +maxima-ring+ plist)))
452
453(defmfun $poly_minimization (plist vars)
454 (with-parsed-polynomials ((vars) :poly-lists (plist)
455 :value-type :poly-list)
456 (minimization plist)))
457
458(defmfun $poly_normalize_list (plist vars)
459 (with-parsed-polynomials ((vars) :poly-lists (plist)
460 :value-type :poly-list)
461 (poly-normalize-list +maxima-ring+ plist)))
462
463(defmfun $poly_grobner (f vars)
464 (with-parsed-polynomials ((vars) :poly-lists (f)
465 :value-type :poly-list)
466 (grobner +maxima-ring+ (remzero f))))
467
468(defmfun $poly_reduced_grobner (f vars)
469 (with-parsed-polynomials ((vars) :poly-lists (f)
470 :value-type :poly-list)
471 (reduced-grobner +maxima-ring+ (remzero f))))
472
473(defmfun $poly_depends_p (p var mvars
474 &aux (vars (coerce-maxima-list mvars))
475 (pos (position var vars)))
476 (if (null pos)
477 (merror "~%Variable ~M not in the list of variables ~M." var mvars)
478 (poly-depends-p (parse-poly p vars) pos)))
479
480(defmfun $poly_elimination_ideal (flist k vars)
481 (with-parsed-polynomials ((vars) :poly-lists (flist)
482 :value-type :poly-list)
483 (elimination-ideal +maxima-ring+ flist k nil 0)))
484
485(defmfun $poly_colon_ideal (f g vars)
486 (with-parsed-polynomials ((vars) :poly-lists (f g) :value-type :poly-list)
487 (colon-ideal +maxima-ring+ f g nil)))
488
489(defmfun $poly_ideal_intersection (f g vars)
490 (with-parsed-polynomials ((vars) :poly-lists (f g) :value-type :poly-list)
491 (ideal-intersection +maxima-ring+ f g nil)))
492
493(defmfun $poly_lcm (f g vars)
494 (with-parsed-polynomials ((vars) :polynomials (f g) :value-type :polynomial)
495 (poly-lcm +maxima-ring+ f g)))
496
497(defmfun $poly_gcd (f g vars)
498 ($first ($divide (m* f g) ($poly_lcm f g vars))))
499
500(defmfun $poly_grobner_equal (g1 g2 vars)
501 (with-parsed-polynomials ((vars) :poly-lists (g1 g2))
502 (grobner-equal +maxima-ring+ g1 g2)))
503
504(defmfun $poly_grobner_subsetp (g1 g2 vars)
505 (with-parsed-polynomials ((vars) :poly-lists (g1 g2))
506 (grobner-subsetp +maxima-ring+ g1 g2)))
507
508(defmfun $poly_grobner_member (p g vars)
509 (with-parsed-polynomials ((vars) :polynomials (p) :poly-lists (g))
510 (grobner-member +maxima-ring+ p g)))
511
512(defmfun $poly_ideal_saturation1 (f p vars)
513 (with-parsed-polynomials ((vars) :poly-lists (f) :polynomials (p)
514 :value-type :poly-list)
515 (ideal-saturation-1 +maxima-ring+ f p 0)))
516
517(defmfun $poly_saturation_extension (f plist vars new-vars)
518 (with-parsed-polynomials ((vars new-vars)
519 :poly-lists (f plist)
520 :value-type :poly-list)
521 (saturation-extension +maxima-ring+ f plist)))
522
523(defmfun $poly_polysaturation_extension (f plist vars new-vars)
524 (with-parsed-polynomials ((vars new-vars)
525 :poly-lists (f plist)
526 :value-type :poly-list)
527 (polysaturation-extension +maxima-ring+ f plist)))
528
529(defmfun $poly_ideal_polysaturation1 (f plist vars)
530 (with-parsed-polynomials ((vars) :poly-lists (f plist)
531 :value-type :poly-list)
532 (ideal-polysaturation-1 +maxima-ring+ f plist 0 nil)))
533
534(defmfun $poly_ideal_saturation (f g vars)
535 (with-parsed-polynomials ((vars) :poly-lists (f g)
536 :value-type :poly-list)
537 (ideal-saturation +maxima-ring+ f g 0 nil)))
538
539(defmfun $poly_ideal_polysaturation (f ideal-list vars)
540 (with-parsed-polynomials ((vars) :poly-lists (f)
541 :poly-list-lists (ideal-list)
542 :value-type :poly-list)
543 (ideal-polysaturation +maxima-ring+ f ideal-list 0 nil)))
544
545(defmfun $poly_lt (f vars)
546 (with-parsed-polynomials ((vars) :polynomials (f) :value-type :polynomial)
547 (make-poly-from-termlist (list (poly-lt f)))))
548
549(defmfun $poly_lm (f vars)
550 (with-parsed-polynomials ((vars) :polynomials (f) :value-type :polynomial)
551 (make-poly-from-termlist (list (make-term (poly-lm f) (funcall (ring-unit +maxima-ring+)))))))
552
553|#
Note: See TracBrowser for help on using the repository browser.