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. The defaults are determined by various Maxima-level switches,
|
---|
174 | which are names of ring and orders."
|
---|
175 | ring-and-order)
|
---|
176 |
|
---|
177 | (defun maxima->poly (expr vars
|
---|
178 | &optional
|
---|
179 | (ring-and-order (find-ring-and-order-by-name))
|
---|
180 | &aux
|
---|
181 | (vars (coerce-maxima-list vars))
|
---|
182 | (ring (ro-ring ring-and-order)))
|
---|
183 | "Convert a maxima polynomial expression EXPR in variables VARS to
|
---|
184 | internal form. This works by first converting the expression to Lisp,
|
---|
185 | and then evaluating the expression using polynomial arithmetic
|
---|
186 | implemented by the POLYNOMIAL package."
|
---|
187 | (labels ((parse (arg) (maxima->poly arg vars ring-and-order))
|
---|
188 | (parse-list (args) (mapcar #'parse args)))
|
---|
189 | (cond
|
---|
190 | ((eql expr 0) (make-poly-zero))
|
---|
191 | ((member expr vars :test #'equal-test-p)
|
---|
192 | (let ((pos (position expr vars :test #'equal-test-p)))
|
---|
193 | (make-poly-variable ring (length vars) pos)))
|
---|
194 | ((free-of-vars expr vars)
|
---|
195 | ;;This means that variable-free CRE and Poisson forms will be converted
|
---|
196 | ;;to coefficients intact
|
---|
197 | (coerce-coeff ring expr vars))
|
---|
198 | (t
|
---|
199 | (case (caar expr)
|
---|
200 | (mplus (reduce #'(lambda (x y) (poly-add ring-and-order x y)) (parse-list (cdr expr))))
|
---|
201 | (mminus (poly-uminus ring (parse (cadr expr))))
|
---|
202 | (mtimes
|
---|
203 | (if (endp (cddr expr)) ;unary
|
---|
204 | (parse (cdr expr))
|
---|
205 | (reduce #'(lambda (p q) (poly-mul ring-and-order p q)) (parse-list (cdr expr)))))
|
---|
206 | (mexpt
|
---|
207 | (cond
|
---|
208 | ((member (cadr expr) vars :test #'equal-test-p)
|
---|
209 | ;;Special handling of (expt var pow)
|
---|
210 | (let ((pos (position (cadr expr) vars :test #'equal-test-p)))
|
---|
211 | (make-poly-variable ring (length vars) pos (caddr expr))))
|
---|
212 | ((not (and (integerp (caddr expr)) (plusp (caddr expr))))
|
---|
213 | ;; Negative power means division in coefficient ring
|
---|
214 | ;; Non-integer power means non-polynomial coefficient
|
---|
215 | (mtell "~%Warning: Expression ~%~M~%contains power which is not a positive integer. Parsing as coefficient.~%"
|
---|
216 | expr)
|
---|
217 | (coerce-coeff ring expr vars))
|
---|
218 | (t (poly-expt ring-and-order (parse (cadr expr)) (caddr expr)))))
|
---|
219 | (mrat (parse ($ratdisrep expr)))
|
---|
220 | (mpois (parse ($outofpois expr)))
|
---|
221 | (otherwise
|
---|
222 | (coerce-coeff ring expr vars)))))))
|
---|
223 |
|
---|
224 | (defun maxima->poly-list (expr vars
|
---|
225 | &optional
|
---|
226 | (ring-and-order (find-ring-and-order-by-name)))
|
---|
227 | "Convert a Maxima representation of a list of polynomials to the internal form."
|
---|
228 | (case (caar expr)
|
---|
229 | (mlist (mapcar #'(lambda (p)
|
---|
230 | (maxima->poly p vars ring-and-order))
|
---|
231 | (cdr expr)))
|
---|
232 | (otherwise (merror "Expression ~M is not a list of polynomials in variables ~M."
|
---|
233 | expr vars))))
|
---|
234 |
|
---|
235 | (defun maxima->poly-list-list (poly-list-of-lists vars
|
---|
236 | &optional
|
---|
237 | (ring-and-order (find-ring-and-order-by-name)))
|
---|
238 | "Parse a Maxima representation of a list of lists of polynomials."
|
---|
239 | (mapcar #'(lambda (g) (maxima->poly-list g vars ring-and-order))
|
---|
240 | (coerce-maxima-list poly-list-of-lists)))
|
---|
241 |
|
---|
242 |
|
---|
243 |
|
---|
244 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
245 | ;;
|
---|
246 | ;; Conversion from internal form to Maxima general form
|
---|
247 | ;;
|
---|
248 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
249 |
|
---|
250 | (defun maxima-head ()
|
---|
251 | (if $poly_return_term_list
|
---|
252 | '(mlist)
|
---|
253 | '(mplus)))
|
---|
254 |
|
---|
255 | (defun poly->maxima (poly-type object vars)
|
---|
256 | (case poly-type
|
---|
257 | (:custom object) ;Bypass processing
|
---|
258 | (:polynomial
|
---|
259 | `(,(maxima-head) ,@(mapcar #'(lambda (term) (poly->maxima :term term vars)) (poly-termlist object))))
|
---|
260 | (:poly-list
|
---|
261 | `((mlist) ,@(mapcar #'(lambda (p) ($ratdisrep (poly->maxima :polynomial p vars))) object)))
|
---|
262 | (:term
|
---|
263 | `((mtimes) ,($ratdisrep (term-coeff object))
|
---|
264 | ,@(mapcar #'(lambda (var power) `((mexpt) ,var ,power))
|
---|
265 | vars (monom->list (term-monom object)))))
|
---|
266 | ;; Assumes that Lisp and Maxima logicals coincide
|
---|
267 | (:logical object)
|
---|
268 | (otherwise
|
---|
269 | object)))
|
---|
270 |
|
---|
271 |
|
---|
272 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
273 | ;;
|
---|
274 | ;; Unary and binary operation definition facility
|
---|
275 | ;;
|
---|
276 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
277 |
|
---|
278 | (defmacro define-unop (maxima-name fun-name
|
---|
279 | &optional (documentation nil documentation-supplied-p))
|
---|
280 | "Define a MAXIMA-level unary operator MAXIMA-NAME corresponding to unary function FUN-NAME."
|
---|
281 | `(defun ,maxima-name (p vars
|
---|
282 | &aux
|
---|
283 | (vars (coerce-maxima-list vars))
|
---|
284 | (p (parse-poly p vars)))
|
---|
285 | ,@(when documentation-supplied-p (list documentation))
|
---|
286 | (coerce-to-maxima :polynomial (,fun-name +maxima-ring+ p) vars)))
|
---|
287 |
|
---|
288 | (defmacro define-binop (maxima-name fun-name
|
---|
289 | &optional (documentation nil documentation-supplied-p))
|
---|
290 | "Define a MAXIMA-level binary operator MAXIMA-NAME corresponding to binary function FUN-NAME."
|
---|
291 | `(defmfun ,maxima-name (p q vars
|
---|
292 | &aux
|
---|
293 | (vars (coerce-maxima-list vars))
|
---|
294 | (p (parse-poly p vars))
|
---|
295 | (q (parse-poly q vars)))
|
---|
296 | ,@(when documentation-supplied-p (list documentation))
|
---|
297 | (coerce-to-maxima :polynomial (,fun-name +maxima-ring+ p q) vars)))
|
---|
298 |
|
---|
299 |
|
---|
300 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
301 | ;;
|
---|
302 | ;; Facilities for evaluating Grobner package expressions
|
---|
303 | ;; within a prepared environment
|
---|
304 | ;;
|
---|
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 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
336 | ;;
|
---|
337 | ;; Maxima-level interface functions
|
---|
338 | ;;
|
---|
339 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
340 |
|
---|
341 | ;; Auxillary function for removing zero polynomial
|
---|
342 | (defun remzero (plist) (remove #'poly-zerop plist))
|
---|
343 |
|
---|
344 | ;;Simple operators
|
---|
345 |
|
---|
346 | #|
|
---|
347 | (define-binop $poly_add poly-add
|
---|
348 | "Adds two polynomials P and Q")
|
---|
349 |
|
---|
350 | (define-binop $poly_subtract poly-sub
|
---|
351 | "Subtracts a polynomial Q from P.")
|
---|
352 |
|
---|
353 | (define-binop $poly_multiply poly-mul
|
---|
354 | "Returns the product of polynomials P and Q.")
|
---|
355 |
|
---|
356 | (define-binop $poly_s_polynomial spoly
|
---|
357 | "Returns the syzygy polynomial (S-polynomial) of two polynomials P and Q.")
|
---|
358 |
|
---|
359 | (define-unop $poly_primitive_part poly-primitive-part
|
---|
360 | "Returns the polynomial P divided by GCD of its coefficients.")
|
---|
361 |
|
---|
362 | (define-unop $poly_normalize poly-normalize
|
---|
363 | "Returns the polynomial P divided by the leading coefficient.")
|
---|
364 | |#
|
---|
365 |
|
---|
366 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
367 | ;;
|
---|
368 | ;; Macro facility for writing Maxima-level wrappers for
|
---|
369 | ;; functions operating on internal representation
|
---|
370 | ;;
|
---|
371 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
---|
372 |
|
---|
373 | (defmacro with-ring-and-order (((maxima-vars &optional (maxima-new-vars nil new-vars-supplied-p))
|
---|
374 | &key
|
---|
375 | (polynomials nil)
|
---|
376 | (poly-lists nil)
|
---|
377 | (poly-list-lists nil)
|
---|
378 | (value-type nil)
|
---|
379 | (ring-and-order-var 'ring-and-order)
|
---|
380 | (ring-var 'ring))
|
---|
381 | &body
|
---|
382 | body
|
---|
383 | &aux
|
---|
384 | (vars (gensym))
|
---|
385 | (new-vars (gensym)))
|
---|
386 | "Evaluate a polynomial expression BODY in an environment
|
---|
387 | constructred from Maxima switches. The supplied arguments
|
---|
388 | POLYNOMIALS, POLY-LISTS and POLY-LIST-LISTS should be polynomials,
|
---|
389 | polynomial lists an lists of lists of polynomials, in Maxima general
|
---|
390 | form. These are translated to NGROBNER package internal form and
|
---|
391 | evaluated using operations in the NGROBNER package. The BODY should be
|
---|
392 | defined in terms of those operations. MAXIMA-VARS is set to the list
|
---|
393 | of variable names used at the Maxima level. The evaluation is
|
---|
394 | performed by the NGROBNER package which ignores variable names, thus
|
---|
395 | MAXIMA-VARS is used only to translate the polynomial expression to
|
---|
396 | NGROBNER internal form. After evaluation, the value of BODY is
|
---|
397 | translated back to the Maxima general form. When MAXIMA-NEW-VARS is
|
---|
398 | present, it is appended to MAXIMA-VARS upon translation from the
|
---|
399 | internal form back to Maxima general form, thus allowing extra
|
---|
400 | variables which may have been created by the evaluation process. The
|
---|
401 | value type can be either :POLYNOMIAL, :POLY-LIST or :TERM, depending
|
---|
402 | on the form of the result returned by the top NGROBNER operation.
|
---|
403 | During evaluation, symbols supplied by RING-AND-ORDER-VAR (defaul
|
---|
404 | value 'RING-AND-ORDER), and RING-VAR (default value 'RING) are bound
|
---|
405 | to RING-AND-ORDER and RING instances."
|
---|
406 | `(let ((,vars (coerce-maxima-list ,maxima-vars))
|
---|
407 | ,@(when new-vars-supplied-p
|
---|
408 | (list `(,new-vars (coerce-maxima-list ,maxima-new-vars)))))
|
---|
409 | (poly->maxima
|
---|
410 | ,value-type
|
---|
411 | (let ((,ring-and-order-var ,(find-ring-and-order-by-name)))
|
---|
412 | ;; Define a shorthand to RING
|
---|
413 | (symbol-macrolet (,ring-var (ro-ring ring-and-order))
|
---|
414 | (let ,(let ((args nil))
|
---|
415 | (dolist (p polynomials args)
|
---|
416 | (setf args (cons `(,p (maxima->poly ,p ,vars ,ring-and-order-var)) args)))
|
---|
417 | (dolist (p poly-lists args)
|
---|
418 | (setf args (cons `(,p (maxima->poly-list ,p ,vars ,ring-and-order-var)) args)))
|
---|
419 | (dolist (p poly-list-lists args)
|
---|
420 | (setf args (cons `(,p (maxima->poly-list-list ,p ,vars ,ring-and-order-var)) args))))
|
---|
421 | . ,body)))
|
---|
422 | ,(if new-vars-supplied-p
|
---|
423 | `(append ,vars ,new-vars)
|
---|
424 | vars))))
|
---|
425 |
|
---|
426 |
|
---|
427 | ;;Functions
|
---|
428 |
|
---|
429 | (defmfun $poly_expand (p vars)
|
---|
430 | "This function is equivalent to EXPAND(P) if P parses correctly to a polynomial.
|
---|
431 | If the representation is not compatible with a polynomial in variables VARS,
|
---|
432 | the result is an error."
|
---|
433 | (with-ring-and-order ((vars) :polynomials (p) :value-type :polynomial) p))
|
---|
434 |
|
---|
435 |
|
---|
436 | (defmfun $poly_expt (p n vars)
|
---|
437 | (with-ring-and-order ((vars) :polynomials (p) :value-type :polynomial)
|
---|
438 | (poly-expt ring-and-order p n)))
|
---|
439 |
|
---|
440 | (defmfun $poly_content (p vars)
|
---|
441 | (with-ring-and-order ((vars) :polynomials (p))
|
---|
442 | (poly-content ring p)))
|
---|
443 |
|
---|
444 | #|
|
---|
445 | (defmfun $poly_pseudo_divide (f fl vars)
|
---|
446 | (with-ring-and-order ((vars)
|
---|
447 | :polynomials (f)
|
---|
448 | :poly-lists (fl)
|
---|
449 | :value-type :custom)
|
---|
450 | (multiple-value-bind (quot rem c division-count)
|
---|
451 | (poly-pseudo-divide ring-and-order f fl)
|
---|
452 | `((mlist)
|
---|
453 | ,(poly->maxima :poly-list quot vars)
|
---|
454 | ,(poly->maxima :polynomial rem vars)
|
---|
455 | ,c
|
---|
456 | ,division-count))))
|
---|
457 | |#
|
---|
458 |
|
---|
459 |
|
---|
460 | (defmfun $poly_exact_divide (f g vars)
|
---|
461 | (with-ring-and-order ((vars) :polynomials (f g) :value-type :polynomial)
|
---|
462 | (poly-exact-divide ring-and-order f g)))
|
---|
463 |
|
---|
464 | (defmfun $poly_normal_form (f fl vars)
|
---|
465 | (with-ring-and-order ((vars) :polynomials (f)
|
---|
466 | :poly-lists (fl)
|
---|
467 | :value-type :polynomial)
|
---|
468 | (normal-form ring-and-order f (remzero fl) nil)))
|
---|
469 |
|
---|
470 | (defmfun $poly_buchberger_criterion (g vars)
|
---|
471 | (with-ring-and-order ((vars) :poly-lists (g) :value-type :logical)
|
---|
472 | (buchberger-criterion ring-and-order g)))
|
---|
473 |
|
---|
474 | (defmfun $poly_buchberger (fl vars)
|
---|
475 | (with-ring-and-order ((vars) :poly-lists (fl) :value-type :poly-list)
|
---|
476 | (buchberger ring-and-order (remzero fl) 0 nil)))
|
---|
477 |
|
---|
478 | (defmfun $poly_reduction (plist vars)
|
---|
479 | (with-ring-and-order ((vars) :poly-lists (plist)
|
---|
480 | :value-type :poly-list)
|
---|
481 | (reduction ring-and-order plist)))
|
---|
482 |
|
---|
483 | (defmfun $poly_minimization (plist vars)
|
---|
484 | (with-ring-and-order ((vars) :poly-lists (plist)
|
---|
485 | :value-type :poly-list)
|
---|
486 | (minimization plist)))
|
---|
487 |
|
---|
488 | (defmfun $poly_normalize_list (plist vars)
|
---|
489 | (with-ring-and-order ((vars) :poly-lists (plist)
|
---|
490 | :value-type :poly-list)
|
---|
491 | (poly-normalize-list ring plist)))
|
---|
492 |
|
---|
493 | (defmfun $poly_grobner (f vars)
|
---|
494 | (with-ring-and-order ((vars) :poly-lists (f)
|
---|
495 | :value-type :poly-list)
|
---|
496 | (grobner ring-and-order (remzero f))))
|
---|
497 |
|
---|
498 | (defmfun $poly_reduced_grobner (f vars)
|
---|
499 | (with-ring-and-order ((vars) :poly-lists (f)
|
---|
500 | :value-type :poly-list)
|
---|
501 | (reduced-grobner ring-and-order (remzero f))))
|
---|
502 |
|
---|
503 | (defmfun $poly_depends_p (p var mvars
|
---|
504 | &aux
|
---|
505 | (vars (coerce-maxima-list mvars))
|
---|
506 | (pos (position var vars)))
|
---|
507 | (with-ring-and-order ((mvars) :polynomials (p) :value-type :custom)
|
---|
508 | (if (null pos)
|
---|
509 | (merror "~%Variable ~M not in the list of variables ~M." var mvars)
|
---|
510 | (poly-depends-p p pos))))
|
---|
511 |
|
---|
512 | (defmfun $poly_elimination_ideal (flist k vars)
|
---|
513 | (with-ring-and-order ((vars) :poly-lists (flist)
|
---|
514 | :value-type :poly-list)
|
---|
515 | (elimination-ideal ring-and-order flist k nil 0)))
|
---|
516 |
|
---|
517 | (defmfun $poly_colon_ideal (f g vars)
|
---|
518 | (with-ring-and-order ((vars) :poly-lists (f g) :value-type :poly-list)
|
---|
519 | (colon-ideal ring-and-order f g nil)))
|
---|
520 |
|
---|
521 | (defmfun $poly_ideal_intersection (f g vars)
|
---|
522 | (with-ring-and-order ((vars) :poly-lists (f g) :value-type :poly-list)
|
---|
523 | (ideal-intersection ring-and-order f g nil)))
|
---|
524 |
|
---|
525 | (defmfun $poly_lcm (f g vars)
|
---|
526 | (with-ring-and-order ((vars) :polynomials (f g) :value-type :polynomial)
|
---|
527 | (poly-lcm ring-and-order f g)))
|
---|
528 |
|
---|
529 | (defmfun $poly_gcd (f g vars)
|
---|
530 | ($first ($divide (m* f g) ($poly_lcm f g vars))))
|
---|
531 |
|
---|
532 | (defmfun $poly_grobner_equal (g1 g2 vars)
|
---|
533 | (with-ring-and-order ((vars) :poly-lists (g1 g2))
|
---|
534 | (grobner-equal ring-and-order g1 g2)))
|
---|
535 |
|
---|
536 | (defmfun $poly_grobner_subsetp (g1 g2 vars)
|
---|
537 | (with-ring-and-order ((vars) :poly-lists (g1 g2))
|
---|
538 | (grobner-subsetp ring-and-order g1 g2)))
|
---|
539 |
|
---|
540 | (defmfun $poly_grobner_member (p g vars)
|
---|
541 | (with-ring-and-order ((vars) :polynomials (p) :poly-lists (g))
|
---|
542 | (grobner-member ring-and-order p g)))
|
---|
543 |
|
---|
544 | (defmfun $poly_ideal_saturation1 (f p vars)
|
---|
545 | (with-ring-and-order ((vars) :poly-lists (f) :polynomials (p)
|
---|
546 | :value-type :poly-list)
|
---|
547 | (ideal-saturation-1 ring-and-order f p 0)))
|
---|
548 |
|
---|
549 | (defmfun $poly_saturation_extension (f plist vars new-vars)
|
---|
550 | (with-ring-and-order ((vars new-vars)
|
---|
551 | :poly-lists (f plist)
|
---|
552 | :value-type :poly-list)
|
---|
553 | (saturation-extension ring-and-order f plist)))
|
---|
554 |
|
---|
555 | (defmfun $poly_polysaturation_extension (f plist vars new-vars)
|
---|
556 | (with-ring-and-order ((vars new-vars)
|
---|
557 | :poly-lists (f plist)
|
---|
558 | :value-type :poly-list)
|
---|
559 | (polysaturation-extension ring-and-order f plist)))
|
---|
560 |
|
---|
561 | (defmfun $poly_ideal_polysaturation1 (f plist vars)
|
---|
562 | (with-ring-and-order ((vars) :poly-lists (f plist)
|
---|
563 | :value-type :poly-list)
|
---|
564 | (ideal-polysaturation-1 ring-and-order f plist 0 nil)))
|
---|
565 |
|
---|
566 | (defmfun $poly_ideal_saturation (f g vars)
|
---|
567 | (with-ring-and-order ((vars) :poly-lists (f g)
|
---|
568 | :value-type :poly-list)
|
---|
569 | (ideal-saturation ring-and-order f g 0 nil)))
|
---|
570 |
|
---|
571 | (defmfun $poly_ideal_polysaturation (f ideal-list vars)
|
---|
572 | (with-ring-and-order ((vars) :poly-lists (f)
|
---|
573 | :poly-list-lists (ideal-list)
|
---|
574 | :value-type :poly-list)
|
---|
575 | (ideal-polysaturation ring-and-order f ideal-list 0 nil)))
|
---|
576 |
|
---|
577 | (defmfun $poly_lt (f vars)
|
---|
578 | (with-ring-and-order ((vars) :polynomials (f) :value-type :polynomial)
|
---|
579 | (make-poly-from-termlist (list (poly-lt f)))))
|
---|
580 |
|
---|
581 | (defmfun $poly_lm (f vars)
|
---|
582 | (with-ring-and-order ((vars) :polynomials (f) :value-type :polynomial)
|
---|
583 | (make-poly-from-termlist (list (make-term (poly-lm f) (funcall (ring-unit ring)))))))
|
---|