source: branches/f4grobner/.junk/term.lisp@ 4025

;;; -*-  Mode: Lisp -*- 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;                                                                              

;;;  Copyright (C) 1999, 2002, 2009, 2015 Marek Rychlik <rychlik@u.arizona.edu>          

;;;                                                                              

;;;  This program is free software; you can redistribute it and/or modify        

;;;  it under the terms of the GNU General Public License as published by        

;;;  the Free Software Foundation; either version 2 of the License, or           

;;;  (at your option) any later version.                                         

;;;                                                                              

;;;  This program is distributed in the hope that it will be useful,             

;;;  but WITHOUT ANY WARRANTY; without even the implied warranty of              

;;;  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               

;;;  GNU General Public License for more details.                                

;;;                                                                              

;;;  You should have received a copy of the GNU General Public License           

;;;  along with this program; if not, write to the Free Software                 

;;;  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

;;;                                                                              

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



(defpackage "TERM"

  (:use :cl :monom :ring)

  (:export "TERM")

  (:documentation "This package implements class TERM. A term is a

product of a scalar and powers of some variables, such as

5*X^2*Y^3. The part of the term without the coefficient is a monomial

X^2*Y^3, which is represented by class MONOM, provided by the :MONOM

package. In this implementation, a TERM specializes MONOL. Also, a

monomial can be considered a TERM whose coefficient is the unit

element (1) of the underlying ring. The generic method CHANGE-CLASS

can be used to convert between a MONOM and a TERM, observing this

convention."))



(in-package :term)



(proclaim '(optimize (speed 3) (space 0) (safety 0) (debug 0)))



;; NOTE: Since term does not have slots of its own,

;; INITIALIZE-INSTANCE is not called by MAKE-INSTANCE.

(defclass term (monom scalar)

  ()

  (:documentation "Implements a term, i.e. a product of a scalar

and powers of some variables, such as 5*X^2*Y^3."))



(defmethod print-object ((self term) stream)

  (print-unreadable-object (self stream :type t :identity t)

    (with-accessors ((exponents monom-exponents)

                     (coeff scalar-coeff))

        self

      (format stream "EXPONENTS=~A COEFF=~A"

              exponents coeff))))





(defmethod r-equalp ((term1 term) (term2 term))

  (when (r-equalp (scalar-coeff term1) (scalar-coeff term2))

    (call-next-method)))



(defmethod update-instance-for-different-class :after ((old monom) (new  scalar) &key)

  (setf (scalar-coeff new) 1))



(defmethod multiply-by :before ((self term) (other term))

  "Destructively multiply terms SELF and OTHER and store the result into SELF.

It returns SELF."

  (setf (scalar-coeff self) (multiply-by (scalar-coeff self) (scalar-coeff other))))



(defmethod left-tensor-product-by ((self term) (other term))

  (setf (scalar-coeff self) (multiply-by (scalar-coeff self) (scalar-coeff other)))

  (call-next-method))



(defmethod right-tensor-product-by ((self term) (other term))

  (setf (scalar-coeff self) (multiply-by (scalar-coeff self) (scalar-coeff other)))

  (call-next-method))



(defmethod left-tensor-product-by ((self term) (other monom))

  (call-next-method))



(defmethod right-tensor-product-by ((self term) (other monom))

  (call-next-method))



(defmethod divide-by ((self term) (other term))

  "Destructively divide term SELF by OTHER and store the result into SELF.

It returns SELF."

  (setf (scalar-coeff self) (divide-by (scalar-coeff self) (scalar-coeff other)))

  (call-next-method))



(defmethod unary-minus ((self term))

  (setf (scalar-coeff self) (unary-minus (scalar-coeff self)))

  self)



(defmethod r* ((term1 term) (term2 term))

  "Non-destructively multiply TERM1 by TERM2."

  (multiply-by (copy-instance term1) (copy-instance term2)))



(defmethod r* ((term1 number) (term2 monom))

  "Non-destructively multiply TERM1 by TERM2."

  (r* term1 (change-class (copy-instance term2) 'term)))



(defmethod r* ((term1 number) (term2 term))

  "Non-destructively multiply TERM1 by TERM2."

  (setf (scalar-coeff term2) 

        (r* term1 (scalar-coeff term2)))

  term2)



(defmethod r-zerop ((self term))

  (r-zerop (scalar-coeff self)))



#|



(defun term->cons (term) 

  "A human-readable representation of a term as a cons (MONOM . COEFF)."

  (declare (type term term))

  (cons (monom->list (term-monom term)) (scalar-coeff term)))



|#