         (if all-0s-fraction
           :infinity
           :nan)))))
+
+
+(defn bias-exponent [exp cat]
+  (let [bias (- (Math/pow 2 (-  (float-configuration :e) 1)) 1)]
+    (if (= cat :denormalized-values)
+      (- 1 bias)
+      (- exp bias))))
+
+(defn compute-significand [frac cat]
+  (if (= cat :denormalized-values)
+    frac
+    (+ 1 frac)))
+
+(defn compute-v [twoExM cat s]
+  (if (contains? #{:normalized-values :denormalized-values} cat)
+    (* s twoExM)
+    cat))
+  
+
+
+(defn compute-float-table-row [bit-string]
+  (let
+      [cat    (get-float-category bit-string)
+       s      (grab-sign bit-string)
+       e      (bits-to-unsigned (grab-exponent bit-string))
+       E      (bias-exponent e cat)
+       twoE   (Math/pow 2 E)
+       f      (to-decimal {:type :binary :val  (str "0." (apply str (grab-fraction bit-string)))})
+       M      (compute-significand f cat)
+       twoExM (* twoE M)
+       V      (compute-v twoExM cat s)]
+   (assoc
+    {}
+    :vec   bit-string
+    :cat   cat
+    :s     s
+    :e     e
+    :E     E
+    :2E    twoE
+    :f     f
+    :M     M
+    :2ExM  twoExM
+    :V     V)))
+
+
+(defn complete-whole-float-table
+  [config]
+  (def float-configuration config)
+  (map
+   #(compute-float-table-row %1)
+   (enumerate-bits (+ (:s config) (:e config) (:f config)))))
+
+;(complete-whole-float-table {:s 1 :e 2 :f 2}) ;solves the problem!
+
+

     (enumerate-bits (- n 1)))))

;Defaults bit counts for floats in this problem
(def float-configuration {:s 1 :e 2 :f 2})

(defn grab-sign
  "Will grab the sign portion of a float bitstring"
  [bit-string]
  ())

(defn grab-exponent
  "Will grab the exponent portion of a float bitstring"

  (loop [power 0
         rv    0]
    (if (= power (count bit-vector))
     (int rv) 
     (recur
      ;power
      (+ power 1)
