anchor.diff:  
   ;;; %% Miscellaneous Monadic Functions
   
  +(labels ((defop-monadic (op &optional (classes %numeric-instance-classes%))
  +	   (defop op :diadic-p nil :variadic-p nil
  +		  :default nil)))
  +
   ;;; %%% EXP
   
  +  (defop-monadic 'exp)
  +
   ;;; %%% SIGNUM
   
  +  (defop-monadic 'signum)
  +
   ;;; %%% SQRT, ISQRT
   
  +  (defop-monadic 'sqrt)
  +  (defop-monadic 'isqrt %integer-instance-classes%)
  +  
   ;;; %%% CIS
   
  +  (defop-monadic 'cis)
  +
   ;;; %%% CONJUGATE
   
  +  ;: FIXME: Note for possible relevance within AC circuit analysis 
  +  ;; (RC / RL)
  +  
  +  (defop-monadic 'conjugate)
  +
   ;;; %%% PHASE
   
  +  (defop-monadic 'phase)
  +
   ;;; %%% Structural Accessor Functions
   
   ;;; %%%% REALPART, IMAGPART
  +  
  +  ;; NB: This is in leaving all of the optimization to the
  +  ;; implementation -- including any behaviors in numeric type
  +  ;; handling. In evaluation of DEFOP, notably the numeric OP is
  +  ;; declared as INLINE within each respective method lambda.
  +  ;;
  +  ;; Of course (%REALPART REAL) => REAL
  +  ;;           (%IMAGPART REAL) => ZERO
  +
  +  (defop-monadic 'realpart) 
  +  (defop-monadic 'imagpart)
   
   ;;; %%%% NUMERATOR, DENOMINATOR
  -
  +  
  +  (defop-monadic 'numerator %rational-instance-classes%)
  +  (defop-monadic 'denominator %rational-instance-classes%)
   
   ;;; %% Overloading for Monadic Predicate Functions
   
   ;;; %%% "Number-Line" Predicates
   
  -(defgeneric %minusp (a)
  -  (:method ((a number))
  -    (minusp a)))
  -
  -(defgeneric %plusp (a)
  -  (:method ((a number))
  -    (plusp a)))
  -
  -(defgeneric %zerop (a)
  -  (:method ((a number))
  -    (zerop a)))
  +  (defop-monadic 'minusp)
  +  (defop-monadic 'plusp)
  +  (defop-monadic 'zerop)
   
   ;; %%% EVENP, ODDP
   
  +  (defop-monadic 'evenp)
  +  (defop-monadic 'oddp)
  +
  +
   ;;; %% Overloading for Monadic Increment Functions
   
   ;;; 1+, 1-
  +
  +  (defop-monadic '1+)
  +  (defop-monadic '1-)
  +
   ;;; INCF, DECF (?)
   
  +  ;; FIXME: Define overloaded macro forms for INCF, DECF
  +  ;; using GET-SETF-EXPANSION in each - possibly, applying %1+ and %1-
  +  ;; within the respective macroexpansions
  +
  +
   ;;; %% Overloading for Strictly Monadic Transcendental Functions
   
   ;; %%% SIN, COS, TAN
  +
  +  (defop-monadic 'sin)
  +  (defop-monadic 'cos)
  +  (defop-monadic 'tan)
  +
   ;; %%% ASIN, ACOS
   
  -
  +  (defop-monadic 'asin)
  +  (defop-monadic 'acos)
  +
  +  )
  +
  +;;; % New Functions
  +
  +(defgeneric geometric-sum (a b)
  +  (:generic-function-class monotonic-generic-function)
  +  (:method ((a number) (b number))
  +    ;; FIXME: This completely looses optimizations,
  +    ;; though it does allow for overloaded math operations
  +    (%sqrt (@+ (@expt a 2) (@expt b 2)))))
  +
  +;; (geometric-sum 3 4)
  +;; => 5.0
  +
  +;; (geometric-sum 3d0 4d0)
  +;; => 5.0d0
  
positive.code: (defun defop (op &key 
                     (classes %numeric-instance-classes%)
                     (default (find-class 'number))
                     (variadic-p t))
    (declare (type symbol op)
             (type (or class-designator null) default)
             (type cons classes)
             (values generic-function
                     generic-function
                     (or generic-function null)))
    "For a funtion <OP> acccepting zero or more arguments, define and
  return generic functions: 
  
negative.code: 
  ;; %% ATAN
  
  (defop 'atan :variadic-p nil)
  
  ;; (= (/ pi 4) (%atan 1d0))
  ;; => T
  
  ;; (= (/ pi 4) (@atan 2d0 2d0))
  ;; => T
  
  ;; also
  ;; (= (rationalize (/ pi 4d0)) (rationalize (@atan 2d0 2d0)))
  ;;
  ;; although
  ;; (= (/ (rationalize pi) 4) (rationalize (@atan 2d0 2d0)))
  ;; => NIL
  ;;
  ;; however
  ;; (= (/ (rational pi) 4) (rational (@atan 2d0 2d0)))
  ;; => T
  ;;
  ;; furthermore
  ;; (= (rationalize (/ pi 4d0)) (rationalize (@atan 2d0 2d0)))
  ;; => T
  ;;
  ;; thus illustrating some of the contrasting qualities of CL:RATIONAL 
  ;; and CL:RATIONALIZE - onto that simple wrapper for diadic ATAN
  
  ;; Considering the examples in the previous, it may seem to be
  ;; advisable to apply a methodology of using DOUBLE-FLOAT values,
  ;; internally, with RATIONALIZE applied when a rational return value
  ;; is sought?
  
  ;; furthermore:
  ;;
  ;; (defun rad-to-deg (r) (* r #.(/ 180 (rationalize pi))))
  ;; 
  ;; double-float=>rational=>..=>ratio onto pi/4 via effective (atan 1d0)
  ;; (rad-to-deg (rational (atan 2d0 2d0)))
  ;; => <large ratio>
  ;;
  ;; double-float=>rational=>...=>ratio=>single-float onto pi/4 via effective (atan 1d0)
  ;; (float (rad-to-deg (rational (atan 2d0 2d0))))
  ;; => 45.0
  ;;
  ;; furthermore, redefining RAD-TO-DEG
  ;;
  ;; (defun rad-to-deg (r) (rational (* r #.(/ 180d0 pi))))
  ;;; ^ double-float => rational (consistently)
  ;;
  ;; (rad-to-deg (/ pi 4))
  ;; => 45
  ;;
  ;; lastly:
  ;;
  ;; (defun rad-to-deg (r) (rationalize (* r #.(/ 180d0 pi))))
  ;; (rad-to-deg (/ pi 4))
  ;; => 45
  ;;
  ;; The function RAD-TO-DEG is applied as an example, in this instance,
  ;; considering the common practice of denoting degree type phase 
  ;; angles within methodologies of electrical circuit analysis onto
  ;; inductive, capacitive, and resistive circuits with AC electrical
  ;; components -- although Common Lisp uses radians, canonically.
  ;; 
  
  
  ;; %% LOG
  
  (defop 'log :variadic-p nil)
  
  ;;; % Overloading for Other Monadic Functions
  
  