anchor.diff:  
   (in-package #:math)
   
  -
  -(defconstant* +si-base-measurements+
  +#+NIL
  +(defconstant* +si-base-measurement-metaclasses+ ;; (?)
  +    ;; This constant value is defined here, in order to ensure that
  +    ;; all of the base measurement unit classes are defined at the
  +    ;; time when this form is evaluated
       (make-array 7
                   :initial-contents
                   (mapcar #'find-class
  -                        '(length mass time electrical-current
  -                          temperature amount-substance
  -                          luminous-intensity))))
  -
  -
  -(defgeneric measurement-class-unit-sequence (class))
  -
  -(defgeneric measurement-class-degree-sequence (class))
  -
  -(defgeneric measurement-class-normalized-expression (class))
  +                        '(base-length 
  +                          base-mass 
  +                          base-time 
  +                          base-electrical-current
  +                          base-temperature 
  +                          base-amount-substance
  +                          base-luminous-intensity))))
  +
  +(defgeneric measurement-unit-sequence (class))
  +
  +(defgeneric measurement-degree-sequence (class))
  +
  +(defgeneric measurement-normalized-expression (class))
  +
  +
  +;; % Compound Measurements - Registry and Retrieval
  +
  +#| Notes
  +
  +* This system will define a registry specifically for compound
  +  measurement unit classes, effectively augmenting the registry of
  +  base and derived measurement unit classes  comprised of
  +  `%MEASUREMENT-CLASSES%' and its corresponding
  +  `%MEASUREMENT-CLASSES-LOCK%'
  +
  +* At time of registering a componound measurement class, the class may
  +  be indexed within the compound measurement unit classes registry,
  +  according to three primary values:
  +
  +    0. The identity of the class, itself. Assuming that the Common
  +       Lisp implementation ensures that any class Cn named N (n > 1)
  +       will always be EQ to class C1 named N, the identity of the
  +       class Cn may be applied as an index key, such that the
  +       functions storing and accessing the index may use EQ
  +       as a :test function.
  +
  +    1. The MEASUREMENT-NORMALIZED-EXPRESSION defined to the
  +       measurement unit class. Although this may seem to denote a 
  +       cosmetically appealing method for functional query onto the
  +       compound measurement unit classes registry, however it may not
  +       present the most optimal approach possible.
  +
  +    2. The set of the unit sequence and degree sequence for the
  +       normalized measurement unit expression defined to
  +       the measurement unit class. It may serve to permit for an
  +       optimized implementation in the functions for measurement query
  +       and unit conversion, when these values would be accessed
  +       seperately.
  +
  +* When searching for a measurement unit class, provided an arbitrary
  +  "normalized" base measurement unit expression, it may be assumed:
  +
  +    * that the elements of the expresion may occur in any arbitrary 
  +      order. 
  +    * that a subset of the elements of the expression may effectively
  +      "match" the complete set of elements of a registered, compound
  +      measurement unit class
  +    * that the expression may contain elements in addition to any
  +      subset of elements effectively "matching" the normalized unit
  +      expression of any registered, compound measurement unit class
  +
  +|#
  +
  +;; % Compound Measurements - Measurement Class Definition and Initialization
  +
   
   (defclass compound-measurement-class (measurement-class)
     ((unit-sequence
       :initarg :unit-sequence
       :type (simple-array measurement-class (*))
  -    :reader measurement-class-unit-sequence)
  +    :reader measurement-unit-sequence)
      (degree-sequence
       :initarg :degree-sequence
       :type (simple-array fixnum (*))
  -    :reader measurement-class-degree-sequence)
  +    :reader measurement-degree-sequence)
      (normalized-expression
       :type (simple-array t (* 2))
       :initarg :normalized-expression
  -    :reader measurement-class-normalized-expression
  +    :reader measurement-normalized-expression
       )))
     
   
  
positive.code:   (:metaclass measurement-domain)
    (:base-measure . newton))
  
  
  #+PROTOTYPE
  (defclass newton (measurement)
  
negative.code:                         (reslt (make-array (list n 2)
                                             :element-type t)))
                     (dotimes (index n reslt)
                       (let* ((elt (aref %expr index))
                              (s (etypecase elt
                                   (symbol elt)
                                   (cons (car elt))))
  