anchor.diff:    (:symbol . :|N|)
     (:metaclass compound-measurement-class)
     (:expression :|m| :|kg| (:|s| -2))
  -  (:documentation "Measurement class for quanities \
  +  (:documentation "Measurement class for quantities \
   of force in base unit newton (N)
   
   Symbolic representation: :N"))
   
  -;; (measurement-class-unit-sequence (find-class 'newton))
  -;; => #(#<LENGTH METER> #<MASS KILOGRAM> #<TIME SECOND>) [2 times]
  -
  -;; (measurement-class-degree-sequence (find-class 'newton))
  -;; => #(1 1 2)
  -
  -;; (measurement-class-normalized-expression (find-class 'newton))
  +#+NIL ;; instance test
  +(measurement-domain-base-measure (find-class 'force))
  +;; => #<COMPOUND-MEASUREMENT-CLASS NEWTON>
  +
  +#+PROTOTYPE
  +(register-measurement-class 'newton)
  +
  +#+PROTOTYPE
  +(resister-compound-measurement-class 'newton)
  +
  +;; (measurement-unit-sequence (find-class 'newton))
  +;; => #(#<LENGTH METER> #<MASS KILOGRAM> #<TIME SECOND>)
  +
  +;; (measurement-degree-sequence (find-class 'newton))
  +;; => #(1 1 -2)
  +
  +;; (measurement-normalized-expression (find-class 'newton))
   ;; => #2A((#<LENGTH METER> 1) (#<MASS KILOGRAM> 1) (#<TIME SECOND> -2))
   
   (defclass compound-unit-expr (unit-expr)
     ((elements
       :initarg :elements
       :accessor unit-expr-elements
  -    :type simple-vector)))
  -
  -
  +    :type (simple-array t (* 2)))))
  +
  +
  +;; NORMALIZE-UNIT - Prototype
  +
  +(defun normalize-unit-expression (&rest exprs)
  +  (declare (values (simple-array t (* 2))))
  +  (let* ((%exprs (coerce exprs 'simple-vector))
  +         (n (length %exprs))
  +         (buffer (make-array n :fill-pointer 0)))
  +    (declare (type simple-vector %exprs))
  +    (dotimes (index n (make-array (list (length buffer) 2)
  +                                  :initial-contents buffer))
  +      (let* ((elt (aref %exprs index))
  +             (s (etypecase elt
  +                  (symbol elt)
  +                  (cons (car elt))))
  +             (c (find-measurement-class s))
  +             (d (etypecase elt
  +                  (symbol 1)
  +                  (cons (cadr elt)))))
  +        (declare (type measurement-class c)
  +                 (type fixnum d))
  +        (flet ((add-elt (c d buffer)
  +                 ;; FIXME: CONSY buffer implementation
  +                 (vector-push-extend (list (measurement-symbol c) d) 
  +                                     buffer)))
  +        (etypecase c
  +          ((or base-measurement-class 
  +               linear-measurement-class
  +               geometric-measurement-class)
  +           (add-elt c d buffer))
  +          (compound-measurement-class
  +           (let ((nex (measurement-normalized-expression c)))
  +             (dotimes (%index (array-dimension nex 0))
  +               (let ((%c (aref nex %index 0))
  +                     (%d (* d (aref nex %index 1))))
  +                 (add-elt %c %d buffer)))))))))))
  +
  +;; NORMALIZE-UNIT / SIMPLIFY-UNIT - Usage cases
  +
  +;; Prototype: Newtonian force / Weight / Acceleration due to gravity (Units)
  +;;
  +;; (normalize-unit-expression :|N|)
  +;; => #2A((:|m| 1) (:|kg| 1) (:|s| -2))
  +;;
  +;; (normalize-unit-expression :|m| :|kg| '(:|s| -2))
  +;; => #2A((:|m| 1) (:|kg| 1) (:|s| -2))
  +
  +;; (simplify-unit-expression :|m| :|kg| '(:|s| -2))
  +
  +;; Prototype: Momentum (Units)
  +;;
  +;; (normalize-unit-expression :|N| :|s|)
  +;; (simplify-unit :|m| :|kg| (:|s| -2) :|s|)
  +;; (simplify-unit :|kg| :|m| (:|s| -1))
  
positive.code:                 (getf initargs :degree-sequence) (map-degrees nex))))
        (cond 
          (args-changed-p (apply #'call-next-method instance slots initargs))
          (t (call-next-method))))))
  
  ;; To Do: Develop prototypes for SIMPLIFY-UNIT / NORMALIZE-UNIT
  
negative.code:   (:metaclass measurement-domain)
    (:base-measure . newton))
  
  #+PROTOTYPE
  (register-measurement-domain 'force)
  
  
  #+PROTOTYPE
  (defclass newton (measurement)
  