diff --git a/code/float-integer-2.lisp b/code/float-integer-2.lisp
index 0bf49d00..9914edcf 100644
--- a/code/float-integer-2.lisp
+++ b/code/float-integer-2.lisp
@@ -1,46 +1,51 @@
 (in-package #:quaviver)
 
-(defmacro %integer-decode-float
-    (value
-     &key significand-size
-          exponent-size
-          ((:hidden-bit hidden-bit-p) nil)
-           exponent-bias)
-  `(let* ((bits ,value)
-          (significand (ldb (byte ,significand-size 0) bits))
-          (exponent (ldb (byte ,exponent-size ,significand-size) bits))
-          (sign (if (logbitp ,(+ exponent-size significand-size) bits) -1 1)))
-     (declare (type (unsigned-byte ,(+ 1 exponent-size significand-size))
-                    bits)
-              (type (unsigned-byte ,significand-size)
-                    significand)
-              (type (unsigned-byte ,exponent-size)
-                    exponent)
-              (type (integer -1 1)
-                    sign))
-     (cond ((= exponent ,(1- (ash 1 exponent-size)))
-            (if (zerop significand) ; infinity
-                (values 0 :infinity sign)
-                (values (ldb (byte ,(1- significand-size) 0) significand)
-                        (if (logbitp ,(1- significand-size) significand)
-                            :quiet-nan
-                            :signaling-nan)
-                        sign)))
-           ((and (zerop significand)
-                 (zerop exponent))
-            (values 0 0 sign))
-           ((zerop exponent) ; subnormal
-            (let ((shift (- ,(if hidden-bit-p (1+ significand-size) significand-size)
-                            (integer-length significand))))
-              (values (ash significand shift)
-                      (- ,(- 1 exponent-bias) shift)
-                      sign)))
-           (t
-            (values ,(if hidden-bit-p
-                         `(logior significand ,(ash 1 significand-size))
-                         'significand)
-                    (- exponent ,exponent-bias)
-                    sign)))))
+(defmacro %integer-decode-float (type value)
+  (with-accessors ((storage-size storage-size)
+                   (significand-bytespec significand-bytespec)
+                   (exponent-bytespec exponent-bytespec)
+                   (sign-bytespec sign-bytespec)
+                   (nan-payload-bytespec nan-payload-bytespec)
+                   (nan-type-bytespec nan-type-bytespec)
+                   (hidden-bit-p hidden-bit-p)
+                   (exponent-bias exponent-bias))
+      type
+    `(let* ((bits ,value)
+            (exponent (ldb ',exponent-bytespec bits))
+            (sign (if (ldb-test ',sign-bytespec bits) -1 1)))
+       (declare (type (unsigned-byte ,storage-size)
+                      bits)
+                (type (unsigned-byte ,(byte-size exponent-bytespec))
+                      exponent)
+                (type (integer -1 1)
+                      sign))
+       (cond ((= exponent ,(1- (ash 1 (byte-size exponent-bytespec))))
+              (if (ldb-test ',significand-bytespec bits) ; nan
+                  (values (ldb ',nan-payload-bytespec bits)
+                          (if (ldb-test ',nan-type-bytespec bits)
+                              :quiet-nan
+                              :signaling-nan)
+                          1)
+                  (values 0 :infinity sign)))
+             (t
+              (let ((significand (ldb ',significand-bytespec bits)))
+                (declare (type (unsigned-byte ,(byte-size significand-bytespec))
+                               significand))
+                (cond ((and (zerop significand)
+                            (zerop exponent))
+                       (values 0 0 sign))
+                      ((zerop exponent) ; subnormal
+                       (let ((shift (- ,(byte-size significand-bytespec)
+                                       (integer-length significand))))
+                         (values (ash significand shift)
+                                 (- ,(- 1 exponent-bias) shift)
+                                 sign)))
+                      (t
+                       (values ,(if hidden-bit-p
+                                    `(logior significand ,(ash 1 (byte-size significand-bytespec)))
+                                    'significand)
+                               (- exponent ,exponent-bias)
+                               sign)))))))))
 
 #-(or abcl allegro clasp cmucl ecl lispworks sbcl)
 (defmethod float-integer (client (base (eql 2)) value)
@@ -53,6 +58,7 @@
 (defmethod float-integer (client (base (eql 2)) (value single-float))
   (declare (ignore client))
   (%integer-decode-float
+    single-float
    #+abcl      (system:single-float-bits value)
    #+allegro   (multiple-value-bind (us1 us0)
                    (excl:single-float-to-shorts value)
@@ -67,16 +73,13 @@
                  (setf (sys:typed-aref 'single-float v 0) value)
                  (sys:typed-aref '(unsigned-byte 32) v 0))
    #+sbcl      (ldb (byte 32 0)
-                    (sb-kernel:single-float-bits value))
-   :significand-size 23
-   :exponent-size 8
-   :hidden-bit t
-   :exponent-bias 150))
+                    (sb-kernel:single-float-bits value))))
 
 #+(or abcl allegro clasp cmucl ecl lispworks sbcl)
 (defmethod float-integer (client (base (eql 2)) (value double-float))
   (declare (ignore client))
   (%integer-decode-float
+   double-float
    #+abcl      (logior (ash (system:double-float-high-bits value) 32)
                        (system:double-float-low-bits value))
    #+allegro   (multiple-value-bind (us3 us2 us1 us0)
@@ -103,18 +106,10 @@
    #+sbcl      (logior (ash (ldb (byte 32 0)
                                  (sb-kernel:double-float-high-bits value))
                             32)
-                       (sb-kernel:double-float-low-bits value))
-   :significand-size 52
-   :exponent-size 11
-   :hidden-bit t
-   :exponent-bias 1075))
+                       (sb-kernel:double-float-low-bits value))))
 
 #+quaviver/long-float
 (defmethod float-integer (client (base (eql 2)) (value long-float))
   (declare (ignore client))
-  (%integer-decode-float
-   (system:long-float-bits value)
-   :significand-size 64
-   :exponent-size 15
-   :hidden-bit nil
-   :exponent-bias 16446))
+  (%integer-decode-float long-float
+                         (system:long-float-bits value)))
diff --git a/code/integer-float-2.lisp b/code/integer-float-2.lisp
index e46e6272..76293341 100644
--- a/code/integer-float-2.lisp
+++ b/code/integer-float-2.lisp
@@ -1,67 +1,73 @@
 (in-package #:quaviver)
 
 (defmacro %integer-encode-float
-  ((bits-var significand exponent sign
-    &key significand-size
-      exponent-size
-      ((:hidden-bit hidden-bit-p) nil)
-      exponent-bias)
-   &body body)
-  (let ((decoded-significand-size (if hidden-bit-p
-                                      (1+ significand-size)
-                                      significand-size)))
+    ((type bits-var significand exponent sign) &body body)
+  (with-accessors ((storage-size storage-size)
+                   (significand-bytespec significand-bytespec)
+                   (exponent-bytespec exponent-bytespec)
+                   (sign-bytespec sign-bytespec)
+                   (nan-payload-bytespec nan-payload-bytespec)
+                   (nan-type-bytespec nan-type-bytespec)
+                   (hidden-bit-p hidden-bit-p)
+                   (exponent-bias exponent-bias))
+      type
     (multiple-value-bind (forms declarations)
         (alexandria:parse-body body)
-      `(let ((,bits-var (if (minusp ,sign)
-                            ,(ash 1 (+ significand-size exponent-size))
-                            0)))
+      `(let ((,bits-var 0))
          ,@declarations
+         (declare (type (unsigned-byte ,storage-size) ,bits-var))
+         (when (minusp ,sign)
+           (setf (ldb ',sign-bytespec ,bits-var) 1))
          (cond ((keywordp exponent)
-                (setf (ldb (byte ,exponent-size ,significand-size) ,bits-var)
-                      ,(1- (ash 1 exponent-size)))
+                (setf (ldb ',exponent-bytespec ,bits-var)
+                      ,(1- (ash 1 (byte-size exponent-bytespec))))
                 (ecase exponent
                   (:infinity)
                   (:quiet-nan
-                   (setf (ldb (byte 1 ,(1- significand-size)) ,bits-var)
-                         1
-                         (ldb (byte ,(1- significand-size) 0) ,bits-var)
-                         ,significand))
+                   (setf (ldb ',nan-type-bytespec ,bits-var) 1
+                         (ldb ',nan-payload-bytespec ,bits-var) ,significand))
                   (:signaling-nan
-                   (setf (ldb (byte ,(1- significand-size) 0) ,bits-var)
+                   (setf (ldb ',nan-payload-bytespec ,bits-var)
                          (if (zerop ,significand) 1 ,significand)))))
                (t
                 (unless (zerop ,significand)
-                  (let ((shift (- ,decoded-significand-size
+                  (let ((shift (- ,(if hidden-bit-p
+                                       (1+ (byte-size significand-bytespec))
+                                       (byte-size significand-bytespec))
                                   (integer-length ,significand))))
                     (setf ,significand (ash ,significand shift))
                     (decf ,exponent shift)))
                 (cond ((zerop ,significand)
-                       (setf (ldb (byte ,exponent-size ,significand-size) ,bits-var)
-                             ,exponent-bias))
+                       (setf (ldb ',exponent-bytespec ,bits-var) ,exponent-bias))
                       (t
                        (unless (and (< ,exponent
-                                       ,(- (1- (ash 1 exponent-size)) exponent-bias))
+                                       ,(- (1- (ash 1 (byte-size exponent-bytespec)))
+                                           exponent-bias))
                                     (or (>= ,exponent ,(- exponent-bias))
-                                        (plusp (+ ,significand-size
+                                        (plusp (+ ,(byte-size significand-bytespec)
                                                   ,exponent
                                                   ,exponent-bias))))
                          (error "Unable to encode float with significand of ~a and ~
                                  exponent of ~a when~%the significand size is ~a and ~
                                  the exponent size is ~a."
                                 ,significand ,exponent
-                                ,significand-size ,exponent-size))
+                                ,(byte-size significand-bytespec)
+                                ,(byte-size exponent-bytespec)))
                        (incf ,exponent ,exponent-bias)
                        (cond ((plusp ,exponent)
-                              (setf (ldb (byte ,significand-size 0) ,bits-var)
+                              (setf (ldb ',significand-bytespec ,bits-var)
                                     ,significand
-                                    (ldb (byte ,exponent-size ,significand-size) ,bits-var)
+                                    (ldb ',exponent-bytespec ,bits-var)
                                     ,exponent))
                              (t ; Unadjusted subnormal
-                              (setf (ldb (byte (+ ,significand-size ,exponent)
-                                               0)
+                              (setf (ldb (byte (+ ,(byte-size significand-bytespec)
+                                                  ,exponent)
+                                               ,(byte-position significand-bytespec))
                                          ,bits-var)
-                                    (ldb (byte (+ ,significand-size ,exponent)
-                                               (- 1 ,exponent))
+                                    (ldb (byte (+ ,(byte-size significand-bytespec)
+                                                  ,exponent)
+                                               (- ,(1+ (byte-position significand-bytespec))
+                                                  ,exponent))
                                          ,significand))))))))
          ,@forms))))
 
@@ -76,11 +82,7 @@
     (client (result-type (eql 'single-float)) (base (eql 2)) significand exponent sign)
   (declare (ignore client))
   (%integer-encode-float
-      (bits significand exponent sign
-       :significand-size 23
-       :exponent-size 8
-       :hidden-bit t
-       :exponent-bias 150)
+      (single-float bits significand exponent sign)
     #+abcl
     (system:make-single-float bits)
     #+allegro
@@ -110,11 +112,7 @@
     (client (result-type (eql 'double-float)) (base (eql 2)) significand exponent sign)
   (declare (ignore client))
   (%integer-encode-float
-      (bits significand exponent sign
-       :significand-size 52
-       :exponent-size 11
-       :hidden-bit t
-       :exponent-bias 1075)
+      (double-float bits significand exponent sign)
     #+abcl
     (system:make-double-float bits)
     #+allegro
diff --git a/code/interface.lisp b/code/interface.lisp
index bb8878e2..5b852cae 100644
--- a/code/interface.lisp
+++ b/code/interface.lisp
@@ -11,3 +11,31 @@
 (defgeneric digits-integer (client base digits))
 
 (defgeneric integer-digits (client result-type base value))
+
+(defgeneric storage-size (type))
+
+(defgeneric significand-bytespec (type))
+
+(defgeneric exponent-bytespec (type))
+
+(defgeneric sign-bytespec (type))
+
+(defgeneric nan-payload-bytespec (type))
+
+(defgeneric nan-type-bytespec (type))
+
+(defgeneric hidden-bit-p (type))
+
+(defgeneric exponent-bias (type))
+
+(defgeneric max-exponent (type))
+
+(defgeneric min-exponent (type))
+
+(defgeneric significand-size (type)
+  (:method (type)
+    (if (hidden-bit-p type)
+        (1+ (byte-size (significand-bytespec type)))
+        (byte-size (significand-bytespec type)))))
+
+(defgeneric arithmetic-size (type))
diff --git a/code/liebler/implementation.lisp b/code/liebler/implementation.lisp
index e67c4558..6c804d3f 100644
--- a/code/liebler/implementation.lisp
+++ b/code/liebler/implementation.lisp
@@ -3,43 +3,43 @@
 (defclass client ()
   ())
 
-(defmacro %liebler (client result-type significand exponent sign bits significand-size expt10 round-to-odd)
-  `(if (or (not (numberp ,exponent))
-           (zerop ,significand))
-       (quaviver:integer-float ,client ,result-type 2
-                               ,significand ,exponent ,sign)
-       (let ((k (quaviver/math:floor-log2-expt10 ,exponent))
-             (shift (- ,bits (integer-length ,significand))))
-         (setf ,significand (,round-to-odd (,expt10 (- ,exponent))
-                                           (ash ,significand shift))
-               k (- k -1 shift)
-               shift (- ,significand-size (integer-length ,significand)))
-         (quaviver:integer-float ,client ,result-type 2
-                                 (round ,significand (ash 1 (- shift)))
-                                 (- k shift)
-                                 ,sign))))
+(defmacro %liebler (client result-type significand exponent sign expt10 round-to-odd)
+  (with-accessors ((arithmetic-size quaviver:arithmetic-size)
+                   (significand-size quaviver:significand-size))
+      result-type
+    `(if (or (not (numberp ,exponent))
+             (zerop ,significand))
+         (quaviver:integer-float ,client ',result-type 2
+                                 ,significand ,exponent ,sign)
+         (let ((k (quaviver/math:floor-log2-expt10 ,exponent))
+               (shift (- ,arithmetic-size (integer-length ,significand))))
+           (setf ,significand (,round-to-odd (,expt10 (- ,exponent))
+                                             (ash ,significand shift))
+                 k (- k -1 shift)
+                 shift (- ,significand-size (integer-length ,significand)))
+           (quaviver:integer-float ,client ',result-type 2
+                                   (round ,significand (ash 1 (- shift)))
+                                   (- k shift)
+                                   ,sign)))))
 
 (defmethod quaviver:integer-float
     ((client client) (result-type (eql 'single-float)) (base (eql 10)) significand exponent sign)
-  (%liebler client result-type
+  (%liebler client single-float
             significand exponent sign
-            32 24
             quaviver/math:expt10/32
             quaviver/math:round-to-odd/32))
 
 (defmethod quaviver:integer-float
     ((client client) (result-type (eql 'double-float)) (base (eql 10)) significand exponent sign)
-  (%liebler client result-type
+  (%liebler client double-float
             significand exponent sign
-            64 53
             quaviver/math:expt10/64
             quaviver/math:round-to-odd/64))
 
 #+quaviver/long-float
 (defmethod quaviver:integer-float
     ((client client) (result-type (eql 'long-float)) (base (eql 10)) significand exponent sign)
-  (%liebler client result-type
+  (%liebler client long-float
             significand exponent sign
-            128 64
             quaviver/math:expt10/128
             quaviver/math:round-to-odd/128))
diff --git a/code/packages.lisp b/code/packages.lisp
index 6bd6b3a9..9185854e 100644
--- a/code/packages.lisp
+++ b/code/packages.lisp
@@ -5,7 +5,19 @@
            #:integer-float
            #:float-integer
            #:digits-integer
-           #:integer-digits))
+           #:integer-digits
+           #:storage-size
+           #:significand-bytespec
+           #:exponent-bytespec
+           #:sign-bytespec
+           #:nan-payload-bytespec
+           #:nan-type-bytespec
+           #:hidden-bit-p
+           #:exponent-bias
+           #:max-exponent
+           #:min-exponent
+           #:significand-size
+           #:arithmetic-size))
 
 #+(and ecl long-float)
 (eval-when (:compile-toplevel :load-toplevel :execute)
diff --git a/code/schubfach/implementation.lisp b/code/schubfach/implementation.lisp
index a824db2a..4d499e81 100644
--- a/code/schubfach/implementation.lisp
+++ b/code/schubfach/implementation.lisp
@@ -3,92 +3,102 @@
 (defclass client (quaviver/trailing-zeros:client)
   ())
 
-(defmacro %schubfach (client value bits significand-size expt10 round-to-odd)
-  (let ((word-size (+ significand-size 6)))
-    `(block %schubfach
-       (multiple-value-bind (significand exponent sign)
-           (quaviver:float-integer ,client 2 ,value)
-         (declare (type (unsigned-byte ,word-size) significand)
-                  (type (or fixnum keyword) exponent)
-                  (type (integer -1 1) sign))
-         (if (or (not (numberp exponent))
-                 (zerop significand))
-             (values significand exponent sign)
-             (let* ((lower-boundary-is-closer (= significand ,(ash 1 (1- significand-size))))
-                    (is-even (evenp significand))
-                    (k (quaviver/math:floor-log10-expt2 exponent lower-boundary-is-closer))
-                    (h (+ exponent 1 (quaviver/math:floor-log2-expt10 (- k))))
-                    (expt10 (,expt10 k)))
-               (declare (type (unsigned-byte ,(ash bits 1))
-                              expt10)
-                        (type boolean
-                              lower-boundary-is-closer is-even)
-                        (type (integer 1 4)
-                              h))
-               (setf significand (ash significand 2))
-               (let ((lower (,round-to-odd expt10
-                                           (ash (if lower-boundary-is-closer
-                                                    (1- significand)
-                                                    (- significand 2))
-                                                h)))
-                     (upper (,round-to-odd expt10
-                                           (ash (+ significand 2)
-                                                h))))
-                 (declare (type (unsigned-byte ,word-size)
-                                lower upper))
-                 (setf significand (,round-to-odd expt10 (ash significand h)))
-                 (let ((s (ash significand -2)))
+(defmacro %schubfach (client value type expt10 round-to-odd)
+  (with-accessors ((arithmetic-size quaviver:arithmetic-size)
+                   (significand-size quaviver:significand-size))
+      type
+    (let ((word-size (+ significand-size 6)))
+      `(block %schubfach
+         (multiple-value-bind (significand exponent sign)
+             (quaviver:float-integer ,client 2 ,value)
+           (declare (type (unsigned-byte ,word-size) significand)
+                    (type (or fixnum keyword) exponent)
+                    (type (integer -1 1) sign))
+           (if (or (not (numberp exponent))
+                   (zerop significand))
+               (values significand exponent sign)
+               (let* ((lower-boundary-is-closer (= significand ,(ash 1 (1- significand-size))))
+                      (is-even (evenp significand))
+                      (k (quaviver/math:floor-log10-expt2 exponent lower-boundary-is-closer))
+                      (h (+ exponent 1 (quaviver/math:floor-log2-expt10 (- k))))
+                      (expt10 (,expt10 k)))
+                 (declare (type (unsigned-byte ,(ash arithmetic-size 1))
+                                expt10)
+                          (type boolean
+                                lower-boundary-is-closer is-even)
+                          (type (integer 1 4)
+                                h))
+                 (setf significand (ash significand 2))
+                 (let ((lower (,round-to-odd expt10
+                                             (ash (if lower-boundary-is-closer
+                                                      (1- significand)
+                                                      (- significand 2))
+                                                  h)))
+                       (upper (,round-to-odd expt10
+                                             (ash (+ significand 2)
+                                                  h))))
                    (declare (type (unsigned-byte ,word-size)
-                                  s))
-                   (unless is-even
-                     (incf lower)
-                     (decf upper))
-                   (when (>= s 10)
-                     (let* ((sp (floor s 10))
-                            (up-inside (<= lower (* 40 sp)))
-                            (wp-inside (<= (* 40 (1+ sp)) upper)))
-                       (declare (type (unsigned-byte ,word-size)
-                                      sp))
-                       (unless (eq (not up-inside) (not wp-inside))
-                         (return-from %schubfach
-                           (values (if wp-inside (1+ sp) sp)
-                                   (1+ k)
-                                   sign)))))
-                   (let ((u-inside (<= lower (ash s 2)))
-                         (w-inside (<= (ash (1+ s) 2) upper)))
-                     (unless (eq (not u-inside) (not w-inside))
-                       (return-from %schubfach
-                         (values (if w-inside (1+ s) s)
-                                 k
-                                 sign))))
-                   (let* ((mid (+ (ash s 2) 2))
-                          (round-up (>= significand mid)
-                                    ;; yitzchak: changed this to match
-                                    ;; Burger-Dybvig rounding
-                                    #+(or)(or (> significand mid)
-                                        (and (= significand mid)
-                                             (logbitp s 0)))))
+                                  lower upper))
+                   (setf significand (,round-to-odd expt10 (ash significand h)))
+                   (let ((s (ash significand -2)))
                      (declare (type (unsigned-byte ,word-size)
-                                    mid))
-                     (values (if round-up (1+ s) s)
-                             k
-                             sign))))))))))
+                                    s))
+                     (unless is-even
+                       (incf lower)
+                       (decf upper))
+                     (when (>= s 10)
+                       (let* ((sp (floor s 10))
+                              (up-inside (<= lower (* 40 sp)))
+                              (wp-inside (<= (* 40 (1+ sp)) upper)))
+                         (declare (type (unsigned-byte ,word-size)
+                                        sp))
+                         (unless (eq (not up-inside) (not wp-inside))
+                           (return-from %schubfach
+                             (values (if wp-inside (1+ sp) sp)
+                                     (1+ k)
+                                     sign)))))
+                     (let ((u-inside (<= lower (ash s 2)))
+                           (w-inside (<= (ash (1+ s) 2) upper)))
+                       (unless (eq (not u-inside) (not w-inside))
+                         (return-from %schubfach
+                           (values (if w-inside (1+ s) s)
+                                   k
+                                   sign))))
+                     (let* ((mid (+ (ash s 2) 2))
+                            (round-up (>= significand mid)
+                                      ;; yitzchak: changed this to match
+                                      ;; Burger-Dybvig rounding
+                                      #+(or)(or (> significand mid)
+                                                (and (= significand mid)
+                                                     (logbitp s 0)))))
+                       (declare (type (unsigned-byte ,word-size)
+                                      mid))
+                       (values (if round-up (1+ s) s)
+                               k
+                               sign)))))))))))
+
+#+clisp
+(defmethod quaviver:float-integer ((client client) (base (eql 10)) (value short-float))
+  (%schubfach client value
+              short-float
+              quaviver/math:expt10/32
+              quaviver/math:round-to-odd/32))
 
 (defmethod quaviver:float-integer ((client client) (base (eql 10)) (value single-float))
   (%schubfach client value
-              32 24
+              single-float
               quaviver/math:expt10/32
               quaviver/math:round-to-odd/32))
 
 (defmethod quaviver:float-integer ((client client) (base (eql 10)) (value double-float))
   (%schubfach client value
-              64 53
+              double-float
               quaviver/math:expt10/64
               quaviver/math:round-to-odd/64))
 
 #+quaviver/long-float
 (defmethod quaviver:float-integer ((client client) (base (eql 10)) (value long-float))
   (%schubfach client value
-              128 64
+              long-float
               quaviver/math:expt10/128
               quaviver/math:round-to-odd/128))
diff --git a/code/traits.lisp b/code/traits.lisp
new file mode 100644
index 00000000..0d34c4c0
--- /dev/null
+++ b/code/traits.lisp
@@ -0,0 +1,153 @@
+(in-package #:quaviver)
+
+(defmethod storage-size ((type (eql 'short-float)))
+  #+clisp 25
+  #-clisp 32)
+
+(defmethod significand-bytespec ((type (eql 'short-float)))
+  #+clisp (byte 16 0)
+  #-clisp (byte 23 0))
+
+(defmethod exponent-bytespec ((type (eql 'short-float)))
+  #+clisp (byte 8 16)
+  #-clisp (byte 8 23))
+
+(defmethod sign-bytespec ((type (eql 'short-float)))
+  #+clisp (byte 1 24)
+  #-clisp (byte 1 31))
+
+(defmethod nan-payload-bytespec ((type (eql 'short-float)))
+  #+clisp (byte 15 0)
+  #-clisp (byte 22 0))
+
+(defmethod nan-type-bytespec ((type (eql 'short-float)))
+  #+clisp (byte 1 15)
+  #-clisp (byte 1 22))
+
+(defmethod hidden-bit-p ((type (eql 'short-float)))
+  t)
+
+(defmethod exponent-bias ((type (eql 'short-float)))
+  #+clisp 143
+  #-clisp 150)
+
+(defmethod max-exponent ((type (eql 'short-float)))
+  #+clisp 110
+  #-clisp 104)
+
+(defmethod min-exponent ((type (eql 'short-float)))
+  #+clisp -158
+  #-clisp -172)
+
+(defmethod arithmetic-size ((type (eql 'short-float)))
+  32)
+
+(defmethod storage-size ((type (eql 'single-float)))
+  32)
+
+(defmethod significand-bytespec ((type (eql 'single-float)))
+  (byte 23 0))
+
+(defmethod exponent-bytespec ((type (eql 'single-float)))
+  (byte 8 23))
+
+(defmethod sign-bytespec ((type (eql 'single-float)))
+  (byte 1 31))
+
+(defmethod nan-payload-bytespec ((type (eql 'single-float)))
+  (byte 22 0))
+
+(defmethod nan-type-bytespec ((type (eql 'single-float)))
+  (byte 1 22))
+
+(defmethod hidden-bit-p ((type (eql 'single-float)))
+  t)
+
+(defmethod exponent-bias ((type (eql 'single-float)))
+  150)
+
+(defmethod max-exponent ((type (eql 'single-float)))
+  104)
+
+(defmethod min-exponent ((type (eql 'single-float)))
+  -172)
+
+(defmethod arithmetic-size ((type (eql 'single-float)))
+  32)
+
+(defmethod storage-size ((type (eql 'double-float)))
+  64)
+
+(defmethod significand-bytespec ((type (eql 'double-float)))
+  (byte 52 0))
+
+(defmethod exponent-bytespec ((type (eql 'double-float)))
+  (byte 11 52))
+
+(defmethod sign-bytespec ((type (eql 'double-float)))
+  (byte 1 63))
+
+(defmethod nan-payload-bytespec ((type (eql 'double-float)))
+  (byte 51 0))
+
+(defmethod nan-type-bytespec ((type (eql 'double-float)))
+  (byte 1 51))
+
+(defmethod hidden-bit-p ((type (eql 'double-float)))
+  t)
+
+(defmethod exponent-bias ((type (eql 'double-float)))
+  1075)
+
+(defmethod max-exponent ((type (eql 'double-float)))
+  971)
+
+(defmethod min-exponent ((type (eql 'double-float)))
+  -1126)
+
+(defmethod arithmetic-size ((type (eql 'double-float)))
+  64)
+
+(defmethod storage-size ((type (eql 'long-float)))
+  #+quaviver/long-float 80
+  #-quaviver/long-float 64)
+
+(defmethod significand-bytespec ((type (eql 'long-float)))
+  #+quaviver/long-float (byte 64 0)
+  #-quaviver/long-float (byte 52 0))
+
+(defmethod exponent-bytespec ((type (eql 'long-float)))
+  #+quaviver/long-float (byte 15 64)
+  #-quaviver/long-float (byte 11 52))
+
+(defmethod sign-bytespec ((type (eql 'long-float)))
+  #+quaviver/long-float (byte 1 79)
+  #-quaviver/long-float (byte 1 63))
+
+(defmethod nan-payload-bytespec ((type (eql 'long-float)))
+  #+quaviver/long-float (byte 63 0)
+  #-quaviver/long-float (byte 51 0))
+
+(defmethod nan-type-bytespec ((type (eql 'long-float)))
+  #+quaviver/long-float (byte 1 63)
+  #-quaviver/long-float (byte 1 51))
+
+(defmethod hidden-bit-p ((type (eql 'long-float)))
+  #+quaviver/long-float nil
+  #-quaviver/long-float t)
+
+(defmethod exponent-bias ((type (eql 'long-float)))
+  #+quaviver/long-float 16446
+  #-quaviver/long-float 1075)
+
+(defmethod max-exponent ((type (eql 'long-float)))
+  #+quaviver/long-float 16320
+  #-quaviver/long-float 971)
+
+(defmethod min-exponent ((type (eql 'long-float)))
+  #+quaviver/long-float -16509
+  #-quaviver/long-float -1126)
+
+(defmethod arithmetic-size ((type (eql 'long-float)))
+  #+quaviver/long-float 128
+  #-quaviver/long-float 64)
diff --git a/quaviver.asd b/quaviver.asd
index 7846a2df..d42df4ad 100644
--- a/quaviver.asd
+++ b/quaviver.asd
@@ -15,6 +15,7 @@
                 :serial t
                 :components ((:file "packages")
                              (:file "interface")
+                             (:file "traits")
                              (:file "integer-float-2")
                              (:file "float-integer-2")
                              (:file "digits-integer")