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@ 1686

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

* empty log message *
File size: 19.7 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 maxima->poly (expr vars
163 &optional
164 (ring (find-ring-by-name $poly_coefficient_ring))
165 (order (find-order-by-name $poly_monomial_order))
166 (primary-elimination-order (find-order-by-name $poly_primary_elimination_order))
167 (secondary-elimination-order (find-order-by-name $poly_secondary_elimination_order))
168 &aux
169 (vars (coerce-maxima-list vars))
170 (ring-and-order (make-ring-and-order
171 :ring ring
172 :order order
173 :primary-elimination-order primary-elimination-order
174 :secondary-elimination-order secondary-elimination-order))
175 (ring (ro-ring ring-and-order)))
176 "Convert a maxima polynomial expression EXPR in variables VARS to
177internal form. This works by first converting the expression to Lisp,
178and then evaluating the expression using polynomial arithmetic
179implemented by the POLYNOMIAL package."
180 (labels ((parse (arg) (maxima->poly arg vars ring order
181 primary-elimination-order
182 secondary-elimination-order))
183 (parse-list (args) (mapcar #'parse args)))
184 (cond
185 ((eql expr 0) (make-poly-zero))
186 ((member expr vars :test #'equal-test-p)
187 (let ((pos (position expr vars :test #'equal-test-p)))
188 (make-poly-variable (ro-ring ring-and-order) (length vars) pos)))
189 ((free-of-vars expr vars)
190 ;;This means that variable-free CRE and Poisson forms will be converted
191 ;;to coefficients intact
192 (coerce-coeff (ro-ring ring-and-order) expr vars))
193 (t
194 (case (caar expr)
195 (mplus (reduce #'(lambda (x y) (poly-add ring-and-order x y)) (parse-list (cdr expr))))
196 (mminus (poly-uminus (ro-ring ring-and-order) (parse (cadr expr))))
197 (mtimes
198 (if (endp (cddr expr)) ;unary
199 (parse (cdr expr))
200 (reduce #'(lambda (p q) (poly-mul ring-and-order p q)) (parse-list (cdr expr)))))
201 (mexpt
202 (cond
203 ((member (cadr expr) vars :test #'equal-test-p)
204 ;;Special handling of (expt var pow)
205 (let ((pos (position (cadr expr) vars :test #'equal-test-p)))
206 (make-poly-variable (ro-ring ring-and-order) (length vars) pos (caddr expr))))
207 ((not (and (integerp (caddr expr)) (plusp (caddr expr))))
208 ;; Negative power means division in coefficient ring
209 ;; Non-integer power means non-polynomial coefficient
210 (mtell "~%Warning: Expression ~%~M~%contains power which is not a positive integer. Parsing as coefficient.~%"
211 expr)
212 (coerce-coeff (ro-ring ring-and-order) expr vars))
213 (t (poly-expt (ro-ring ring-and-order) (parse (cadr expr)) (caddr expr)))))
214 (mrat (parse ($ratdisrep expr)))
215 (mpois (parse ($outofpois expr)))
216 (otherwise
217 (coerce-coeff (ro-ring ring-and-order) expr vars)))))))
218
219#|
220
221(defun parse-poly-list (expr vars)
222 "Parse a Maxima representation of a list of polynomials."
223 (case (caar expr)
224 (mlist (mapcar #'(lambda (p) (parse-poly p vars)) (cdr expr)))
225 (t (merror "Expression ~M is not a list of polynomials in variables ~M."
226 expr vars))))
227
228(defun parse-poly-list-list (poly-list-list vars)
229 "Parse a Maxima representation of a list of lists of polynomials."
230 (mapcar #'(lambda (g) (parse-poly-list g vars)) (coerce-maxima-list poly-list-list)))
231
232
233;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
234;;
235;; Conversion from internal form to Maxima general form
236;;
237;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
238
239(defun maxima-head ()
240 (if $poly_return_term_list
241 '(mlist)
242 '(mplus)))
243
244(defun coerce-to-maxima (poly-type object vars)
245 (case poly-type
246 (:polynomial
247 `(,(maxima-head) ,@(mapcar #'(lambda (term) (coerce-to-maxima :term term vars)) (poly-termlist object))))
248 (:poly-list
249 `((mlist) ,@(mapcar #'(lambda (p) (funcall *ratdisrep-fun* (coerce-to-maxima :polynomial p vars))) object)))
250 (:term
251 `((mtimes) ,(funcall *ratdisrep-fun* (term-coeff object))
252 ,@(mapcar #'(lambda (var power) `((mexpt) ,var ,power))
253 vars (coerce (term-monom object) 'list))))
254 ;; Assumes that Lisp and Maxima logicals coincide
255 (:logical object)
256 (otherwise
257 object)))
258
259
260;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
261;;
262;; Unary and binary operation definition facility
263;;
264;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
265
266(defmacro define-unop (maxima-name fun-name
267 &optional (documentation nil documentation-supplied-p))
268 "Define a MAXIMA-level unary operator MAXIMA-NAME corresponding to unary function FUN-NAME."
269 `(defun ,maxima-name (p vars
270 &aux
271 (vars (coerce-maxima-list vars))
272 (p (parse-poly p vars)))
273 ,@(when documentation-supplied-p (list documentation))
274 (coerce-to-maxima :polynomial (,fun-name +maxima-ring+ p) vars)))
275
276(defmacro define-binop (maxima-name fun-name
277 &optional (documentation nil documentation-supplied-p))
278 "Define a MAXIMA-level binary operator MAXIMA-NAME corresponding to binary function FUN-NAME."
279 `(defmfun ,maxima-name (p q vars
280 &aux
281 (vars (coerce-maxima-list vars))
282 (p (parse-poly p vars))
283 (q (parse-poly q vars)))
284 ,@(when documentation-supplied-p (list documentation))
285 (coerce-to-maxima :polynomial (,fun-name +maxima-ring+ p q) vars)))
286
287
288;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
289;;
290;; Facilities for evaluating Grobner package expressions
291;; within a prepared environment
292;;
293;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
294
295(defmacro with-monomial-order ((order) &body body)
296 "Evaluate BODY with monomial order set to ORDER."
297 `(let ((*monomial-order* (or (find-order ,order) *monomial-order*)))
298 . ,body))
299
300(defmacro with-coefficient-ring ((ring) &body body)
301 "Evaluate BODY with coefficient ring set to RING."
302 `(let ((+maxima-ring+ (or (find-ring ,ring) +maxima-ring+)))
303 . ,body))
304
305(defmacro with-ring-and-order ((ring order) &body body)
306 "Evaluate BODY with monomial order set to ORDER and coefficient ring set to RING."
307 `(let ((*monomial-order* (or (find-order ,order) *monomial-order*))
308 (+maxima-ring+ (or (find-ring ,ring) +maxima-ring+)))
309 . ,body))
310
311(defmacro with-elimination-orders ((primary secondary elimination-order)
312 &body body)
313 "Evaluate BODY with primary and secondary elimination orders set to PRIMARY and SECONDARY."
314 `(let ((*primary-elimination-order* (or (find-order ,primary) *primary-elimination-order*))
315 (*secondary-elimination-order* (or (find-order ,secondary) *secondary-elimination-order*))
316 (*elimination-order* (or (find-order ,elimination-order) *elimination-order*)))
317 . ,body))
318
319
320;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
321;;
322;; Maxima-level interface functions
323;;
324;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
325
326;; Auxillary function for removing zero polynomial
327(defun remzero (plist) (remove #'poly-zerop plist))
328
329;;Simple operators
330
331(define-binop $poly_add poly-add
332 "Adds two polynomials P and Q")
333
334(define-binop $poly_subtract poly-sub
335 "Subtracts a polynomial Q from P.")
336
337(define-binop $poly_multiply poly-mul
338 "Returns the product of polynomials P and Q.")
339
340(define-binop $poly_s_polynomial spoly
341 "Returns the syzygy polynomial (S-polynomial) of two polynomials P and Q.")
342
343(define-unop $poly_primitive_part poly-primitive-part
344 "Returns the polynomial P divided by GCD of its coefficients.")
345
346(define-unop $poly_normalize poly-normalize
347 "Returns the polynomial P divided by the leading coefficient.")
348
349;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
350;;
351;; Macro facility for writing Maxima-level wrappers for
352;; functions operating on internal representation
353;;
354;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
355
356(defmacro with-parsed-polynomials (((maxima-vars &optional (maxima-new-vars nil new-vars-supplied-p))
357 &key (polynomials nil)
358 (poly-lists nil)
359 (poly-list-lists nil)
360 (value-type nil))
361 &body body
362 &aux (vars (gensym))
363 (new-vars (gensym)))
364 `(let ((,vars (coerce-maxima-list ,maxima-vars))
365 ,@(when new-vars-supplied-p
366 (list `(,new-vars (coerce-maxima-list ,maxima-new-vars)))))
367 (coerce-to-maxima
368 ,value-type
369 (with-coefficient-ring ($poly_coefficient_ring)
370 (with-monomial-order ($poly_monomial_order)
371 (with-elimination-orders ($poly_primary_elimination_order
372 $poly_secondary_elimination_order
373 $poly_elimination_order)
374 (let ,(let ((args nil))
375 (dolist (p polynomials args)
376 (setf args (cons `(,p (parse-poly ,p ,vars)) args)))
377 (dolist (p poly-lists args)
378 (setf args (cons `(,p (parse-poly-list ,p ,vars)) args)))
379 (dolist (p poly-list-lists args)
380 (setf args (cons `(,p (parse-poly-list-list ,p ,vars)) args))))
381 . ,body))))
382 ,(if new-vars-supplied-p
383 `(append ,vars ,new-vars)
384 vars))))
385
386
387;;Functions
388
389(defmfun $poly_expand (p vars)
390 "This function is equivalent to EXPAND(P) if P parses correctly to a polynomial.
391If the representation is not compatible with a polynomial in variables VARS,
392the result is an error."
393 (with-parsed-polynomials ((vars) :polynomials (p)
394 :value-type :polynomial)
395 p))
396
397(defmfun $poly_expt (p n vars)
398 (with-parsed-polynomials ((vars) :polynomials (p) :value-type :polynomial)
399 (poly-expt +maxima-ring+ p n)))
400
401(defmfun $poly_content (p vars)
402 (with-parsed-polynomials ((vars) :polynomials (p))
403 (poly-content +maxima-ring+ p)))
404
405(defmfun $poly_pseudo_divide (f fl vars
406 &aux (vars (coerce-maxima-list vars))
407 (f (parse-poly f vars))
408 (fl (parse-poly-list fl vars)))
409 (multiple-value-bind (quot rem c division-count)
410 (poly-pseudo-divide +maxima-ring+ f fl)
411 `((mlist)
412 ,(coerce-to-maxima :poly-list quot vars)
413 ,(coerce-to-maxima :polynomial rem vars)
414 ,c
415 ,division-count)))
416
417(defmfun $poly_exact_divide (f g vars)
418 (with-parsed-polynomials ((vars) :polynomials (f g) :value-type :polynomial)
419 (poly-exact-divide +maxima-ring+ f g)))
420
421(defmfun $poly_normal_form (f fl vars)
422 (with-parsed-polynomials ((vars) :polynomials (f)
423 :poly-lists (fl)
424 :value-type :polynomial)
425 (normal-form +maxima-ring+ f (remzero fl) nil)))
426
427(defmfun $poly_buchberger_criterion (g vars)
428 (with-parsed-polynomials ((vars) :poly-lists (g) :value-type :logical)
429 (buchberger-criterion +maxima-ring+ g)))
430
431(defmfun $poly_buchberger (fl vars)
432 (with-parsed-polynomials ((vars) :poly-lists (fl) :value-type :poly-list)
433 (buchberger +maxima-ring+ (remzero fl) 0 nil)))
434
435(defmfun $poly_reduction (plist vars)
436 (with-parsed-polynomials ((vars) :poly-lists (plist)
437 :value-type :poly-list)
438 (reduction +maxima-ring+ plist)))
439
440(defmfun $poly_minimization (plist vars)
441 (with-parsed-polynomials ((vars) :poly-lists (plist)
442 :value-type :poly-list)
443 (minimization plist)))
444
445(defmfun $poly_normalize_list (plist vars)
446 (with-parsed-polynomials ((vars) :poly-lists (plist)
447 :value-type :poly-list)
448 (poly-normalize-list +maxima-ring+ plist)))
449
450(defmfun $poly_grobner (f vars)
451 (with-parsed-polynomials ((vars) :poly-lists (f)
452 :value-type :poly-list)
453 (grobner +maxima-ring+ (remzero f))))
454
455(defmfun $poly_reduced_grobner (f vars)
456 (with-parsed-polynomials ((vars) :poly-lists (f)
457 :value-type :poly-list)
458 (reduced-grobner +maxima-ring+ (remzero f))))
459
460(defmfun $poly_depends_p (p var mvars
461 &aux (vars (coerce-maxima-list mvars))
462 (pos (position var vars)))
463 (if (null pos)
464 (merror "~%Variable ~M not in the list of variables ~M." var mvars)
465 (poly-depends-p (parse-poly p vars) pos)))
466
467(defmfun $poly_elimination_ideal (flist k vars)
468 (with-parsed-polynomials ((vars) :poly-lists (flist)
469 :value-type :poly-list)
470 (elimination-ideal +maxima-ring+ flist k nil 0)))
471
472(defmfun $poly_colon_ideal (f g vars)
473 (with-parsed-polynomials ((vars) :poly-lists (f g) :value-type :poly-list)
474 (colon-ideal +maxima-ring+ f g nil)))
475
476(defmfun $poly_ideal_intersection (f g vars)
477 (with-parsed-polynomials ((vars) :poly-lists (f g) :value-type :poly-list)
478 (ideal-intersection +maxima-ring+ f g nil)))
479
480(defmfun $poly_lcm (f g vars)
481 (with-parsed-polynomials ((vars) :polynomials (f g) :value-type :polynomial)
482 (poly-lcm +maxima-ring+ f g)))
483
484(defmfun $poly_gcd (f g vars)
485 ($first ($divide (m* f g) ($poly_lcm f g vars))))
486
487(defmfun $poly_grobner_equal (g1 g2 vars)
488 (with-parsed-polynomials ((vars) :poly-lists (g1 g2))
489 (grobner-equal +maxima-ring+ g1 g2)))
490
491(defmfun $poly_grobner_subsetp (g1 g2 vars)
492 (with-parsed-polynomials ((vars) :poly-lists (g1 g2))
493 (grobner-subsetp +maxima-ring+ g1 g2)))
494
495(defmfun $poly_grobner_member (p g vars)
496 (with-parsed-polynomials ((vars) :polynomials (p) :poly-lists (g))
497 (grobner-member +maxima-ring+ p g)))
498
499(defmfun $poly_ideal_saturation1 (f p vars)
500 (with-parsed-polynomials ((vars) :poly-lists (f) :polynomials (p)
501 :value-type :poly-list)
502 (ideal-saturation-1 +maxima-ring+ f p 0)))
503
504(defmfun $poly_saturation_extension (f plist vars new-vars)
505 (with-parsed-polynomials ((vars new-vars)
506 :poly-lists (f plist)
507 :value-type :poly-list)
508 (saturation-extension +maxima-ring+ f plist)))
509
510(defmfun $poly_polysaturation_extension (f plist vars new-vars)
511 (with-parsed-polynomials ((vars new-vars)
512 :poly-lists (f plist)
513 :value-type :poly-list)
514 (polysaturation-extension +maxima-ring+ f plist)))
515
516(defmfun $poly_ideal_polysaturation1 (f plist vars)
517 (with-parsed-polynomials ((vars) :poly-lists (f plist)
518 :value-type :poly-list)
519 (ideal-polysaturation-1 +maxima-ring+ f plist 0 nil)))
520
521(defmfun $poly_ideal_saturation (f g vars)
522 (with-parsed-polynomials ((vars) :poly-lists (f g)
523 :value-type :poly-list)
524 (ideal-saturation +maxima-ring+ f g 0 nil)))
525
526(defmfun $poly_ideal_polysaturation (f ideal-list vars)
527 (with-parsed-polynomials ((vars) :poly-lists (f)
528 :poly-list-lists (ideal-list)
529 :value-type :poly-list)
530 (ideal-polysaturation +maxima-ring+ f ideal-list 0 nil)))
531
532(defmfun $poly_lt (f vars)
533 (with-parsed-polynomials ((vars) :polynomials (f) :value-type :polynomial)
534 (make-poly-from-termlist (list (poly-lt f)))))
535
536(defmfun $poly_lm (f vars)
537 (with-parsed-polynomials ((vars) :polynomials (f) :value-type :polynomial)
538 (make-poly-from-termlist (list (make-term (poly-lm f) (funcall (ring-unit +maxima-ring+)))))))
539
540|#
Note: See TracBrowser for help on using the repository browser.