anchor.diff:  (defmethod invert-transformation ((transformation transformation))
     (if (not (invertible-transformation-p transformation))
         (error 'singular-transformation))
  -  (error "Invert-Transformation is not implemented"))
  +  (make-instance 'transformation :matrix (invert-matrix (transformation-matrix transformation))))
   
   (defmethod compose-translation-with-transformation ((transformation transformation) dx dy)
     (compose-transformations (make-translation-transformation dx dy) transformation))
  
positive.code: (defun transformationp (x)
    (typep x 'transformation))
  
  (defconstant +identity-transformation+ (make-instance 'transformation))
  
  ;;; TRANSFORMATION error conditions
  
  (define-condition transformation-error (error)
    (
     ))
  
  (define-condition transformation-underspecified (transformation-error)
    (
     ))
  
  (define-condition reflection-underspecified (transformation-error)
    (
     ))
  
  (define-condition singular-transformation (transformation-error)
    (
     ))
  
  ;;; TRANSFORMATION constructors
  
  (defun make-translation-transformation (translation-x translation-y)
    (make-instance 'transformation :tx (coerce translation-x 'short-float) :ty (coerce translation-y 'short-float)))
  
  (defun make-rotation-transformation (angle &optional (origin (make-point 0.0 0.0)))
    (check-type origin point)
    (let ((s (sin angle))
  	(c (cos angle)))
      (make-instance 'transformation :mxx c :mxy (- s) :myx s :myy c)))
  
  (defun make-rotation-transformation* (angle &optional (origin-x 0.0) (origin-y 0.0))
    (check-type origin-x real)
    (check-type origin-y real)
    (let ((s (sin angle))
  	(c (cos angle)))
      (make-instance 'transformation :mxx c :mxy (- s) :myx s :myy c)))
  
  (defun make-scaling-transformation (scale-x scale-y &optional (origin (make-point 0.0 0.0)))
    (check-type origin point)
    (make-instance 'transformation :mxx (coerce scale-x 'short-float) :myy (coerce scale-y 'short-float)))
  
  (defun make-scaling-transformation* (scale-x scale-y &optional (origin-x 0.0) (origin-y 0.0))
    (check-type origin-x real)
    (check-type origin-y real)
    (make-instance 'transformation :mxx (coerce scale-x 'short-float) :myy (coerce scale-y 'short-float)))
  
  (defun make-reflection-transformation (point1 point2)
    (declare (ignore point1 point2))
    (error "Make-Reflection-Transformation is not implemented"))
  
  (defun make-reflection-transformation* (x1 y1 x2 y2)
    (declare (ignore x1 y1 x2 y2))
    (error "Make-Reflection-Transformation* is not implemented"))
  
  (defun make-transformation (mxx mxy myx myy tx ty)
    (make-instance 'transformation :mxx (coerce mxx 'short-float) :mxy (coerce mxy 'short-float) :tx (coerce tx 'short-float) :myx (coerce myx 'short-float) :myy (coerce myy 'short-float) :ty (coerce ty 'short-float)))
  
  (defun make-3-point-transformation (point-1 point-2 point-3
  				    point-1-image point-2-image point-3-image)
    (declare (ignore point-1 point-2 point-3 point-1-image point-2-image point-3-image))
    (error "Make-3-Point-Transformation is not implemented"))
  
  (defun make-3-point-transformation* (x1 y1 x2 y2 x3 y3
  				     x1-image y1-image x2-image y2-image x3-image y3-image)
    (declare (ignore x1 y1 x2 y2 x3 y3 x1-image y1-image x2-image y2-image x3-image y3-image))
    (error "Make-3-Point-Transformation* is not implemented"))
  
  ;;; TRANSFORMATION operations
  
  (defmethod transformation-equal ((transformation-1 transformation) (transformation-2 transformation))
    (let ((matrix-1 (transformation-matrix transformation-1))
  	(matrix-2 (transformation-matrix transformation-2)))
      (block check-equality
        (loop for i below 2
  	  do (loop for j below 3
  		 if (not (= (aref matrix-1 i j)
  			    (aref matrix-2 i j)))
  		 do (return-from check-equality nil))
  	  finally (return-from check-equality t)))))
  
  (defmethod identity-transformation-p ((transformation transformation))
    (or (eq transformation +identity-transformation+)
        (transformation-equal transformation +identity-transformation+)))
  
  (defmethod invertible-transformation-p ((transformation transformation))
    (error "Invertible-Transformation-P is not implemented"))
  
  (defmethod translation-transformation-p ((transformation transformation))
    (let ((matrix (transformation-matrix transformation)))
      (and (= (aref matrix 0 0) 1.0)
  	 (= (aref matrix 0 1) 0.0)
  	 (= (aref matrix 1 0) 0.0)
  	 (= (aref matrix 1 1) 1.0))))
  
  (defmethod y-inverting-transformation-p ((transformation transformation))
    (let ((matrix (transformation-matrix transformation)))
  
negative.code: 	 (= (aref matrix 1 1) -1.0))))
  
  (defmethod reflection-transformation-p ((transformation transformation))
    (let ((matrix (transformation-matrix transformation)))
      (< (- (* (aref matrix 0 0) (aref matrix 1 1))
            (* (aref matrix 0 1) (aref matrix 1 0))) 0.0)))
  
  (defmethod rigid-transformation-p ((transformation transformation))
    (let ((matrix (transformation-matrix transformation)))
      (fuzzy-equal (abs (- (* (aref matrix 0 0) (aref matrix 1 1))
                           (* (aref matrix 0 1) (aref matrix 1 0)))) 1.0)))
  
  (defmethod even-scaling-transformation-p ((transformation transformation))
    (let ((matrix (transformation-matrix transformation)))
      (fuzzy-equal (aref matrix 0 1) 0.0
                   (aref matrix 1 0) 0.0
                   (- (aref matrix 0 0) (aref matrix 1 1)) 0.0)))
  
  (defmethod scaling-transformation-p ((transformation transformation))
    (let ((matrix (transformation-matrix transformation)))
      (fuzzy-equal (aref matrix 0 1) 0.0
                   (aref matrix 1 0) 0.0)))
  
  (defmethod rectilinear-transformation-p ((transformation transformation))
    (let ((matrix (transformation-matrix transformation)))
      (or (scaling-transformation-p transformation)
          (fuzzy-equal (aref matrix 0 0) 0.0
                       (aref matrix 1 1) 0.0))))
  
  (defmethod compose-transformations ((transformation1 transformation) (transformation2 transformation))
    (flet ((matrix-multiply (m1 m2)
  