CLJ-937: cl-format coerces ratio args for E,F,G directives to double or BigDecimal

Signed-off-by: Stuart Halloway <stu@thinkrelevance.com>

Author: jafingerhut

src/clj/clojure/pprint/cl_format.clj

@@ -543,13 +543,15 @@ Note this should only be used for the last one in the sequence"
   "Produce string parts for the mantissa (normalized 1-9) and exponent"
   [^Object f]
   (let [^String s (.toLowerCase (.toString f))
-        exploc (.indexOf s (int \e))]
+        exploc (.indexOf s (int \e))
+        dotloc (.indexOf s (int \.))]
     (if (neg? exploc)
-      (let [dotloc (.indexOf s (int \.))]
-        (if (neg? dotloc)
-          [s (str (dec (count s)))]
-          [(str (subs s 0 dotloc) (subs s (inc dotloc))) (str (dec dotloc))]))
-      [(str (subs s 0 1) (subs s 2 exploc)) (subs s (inc exploc))])))
+      (if (neg? dotloc)
+        [s (str (dec (count s)))]
+        [(str (subs s 0 dotloc) (subs s (inc dotloc))) (str (dec dotloc))])
+      (if (neg? dotloc)
+        [(subs s 0 exploc) (subs s (inc exploc))]
+        [(str (subs s 0 1) (subs s 2 exploc)) (subs s (inc exploc))]))))
 
 
 (defn- float-parts
@@ -650,13 +652,29 @@ string, or one character longer."
     (str "." m)
     (str (subs m 0 k) "." (subs m k))))
 
+(defn- convert-ratio [x]
+  (if (ratio? x)
+    ;; Usually convert to a double, only resorting to the slower
+    ;; bigdec conversion if the result does not fit within the range
+    ;; of a double.
+    (let [d (double x)]
+      (if (== d 0.0)
+        (if (not= x 0)
+          (bigdec x)
+          d)
+        (if (or (== d Double/POSITIVE_INFINITY) (== d Double/NEGATIVE_INFINITY))
+          (bigdec x)
+          d)))
+    x))
+
 ;; the function to render ~F directives
 ;; TODO: support rationals. Back off to ~D/~A is the appropriate cases
 (defn- fixed-float [params navigator offsets]
   (let [w (:w params)
         d (:d params)
         [arg navigator] (next-arg navigator)
         [sign abs] (if (neg? arg) ["-" (- arg)] ["+" arg])
+        abs (convert-ratio abs)
         [mantissa exp] (float-parts abs)
         scaled-exp (+ exp (:k params))
         add-sign (or (:at params) (neg? arg))
@@ -700,7 +718,8 @@ string, or one character longer."
 ;; TODO: support rationals. Back off to ~D/~A is the appropriate cases
 ;; TODO: define ~E representation for Infinity
 (defn- exponential-float [params navigator offsets]
-  (let [[arg navigator] (next-arg navigator)]
+  (let [[arg navigator] (next-arg navigator)
+        arg (convert-ratio arg)]
     (loop [[mantissa exp] (float-parts (if (neg? arg) (- arg) arg))]
       (let [w (:w params)
             d (:d params)
@@ -774,6 +793,7 @@ string, or one character longer."
 ;; TODO: refactor so that float-parts isn't called twice
 (defn- general-float [params navigator offsets]
   (let [[arg _] (next-arg navigator)
+        arg (convert-ratio arg)
         [mantissa exp] (float-parts (if (neg? arg) (- arg) arg))
         w (:w params)
         d (:d params)

test/clojure/test_clojure/pprint/test_cl_format.clj

@@ -589,8 +589,28 @@
   (format nil "~6,2F|~6,2,1,'*F|~6,2,,'?F|~6F|~,2F|~F" 
           x x x x x x))
 
+;; big-pos-ratio is a ratio value that is larger than
+;; Double/MAX_VALUE, and has a non-terminating decimal representation
+;; if you attempt to represent it exactly.
+(def big-pos-ratio (/ (* 4 (bigint (. BigDecimal valueOf Double/MAX_VALUE))) 3))
+(def big-neg-ratio (- big-pos-ratio))
+;; tiny-pos-ratio is a ratio between 0 and Double/MIN_VALUE.
+(def tiny-pos-ratio (/ 1 (bigint (apply str (cons "1" (repeat 340 "0"))))))
+(def tiny-neg-ratio (- tiny-pos-ratio))
+
 (simple-tests cltl-F-tests
+  (cl-format false "~10,3f" 4/5) "     0.800"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3f" big-pos-ratio)) "239692417981642093333333333333333300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3f" big-neg-ratio)) "-239692417981642093333333333333333300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3f" tiny-pos-ratio)) "     0.000"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3f" tiny-neg-ratio)) "    -0.000"
   (foo 3.14159)  "  3.14| 31.42|  3.14|3.1416|3.14|3.14159" 
+  (foo 314159/100000)
+                 "  3.14| 31.42|  3.14|3.1416|3.14|3.14159"
   (foo -3.14159) " -3.14|-31.42| -3.14|-3.142|-3.14|-3.14159" 
   (foo 100.0)    "100.00|******|100.00| 100.0|100.00|100.0" 
   (foo 1234.0)   "1234.00|******|??????|1234.0|1234.00|1234.0" 
@@ -603,7 +623,18 @@
 
 ;; Clojure doesn't support float/double differences in representation
 (simple-tests cltl-E-tests
+  (cl-format false "~10,3e" 4/5) "  8.000E-1"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3e" big-pos-ratio)) "2.397E+308"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3e" big-neg-ratio)) "-2.397E+308"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3e" tiny-pos-ratio)) "1.000E-340"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3e" tiny-neg-ratio)) "-1.000E-340"
   (foo-e 0.0314159) "  3.14E-2| 31.42$-03|+.003E+01|  3.14E-2"  ; Added this one 
+  (foo-e 314159/10000000)
+                    "  3.14E-2| 31.42$-03|+.003E+01|  3.14E-2"
   (foo-e 3.14159)  "  3.14E+0| 31.42$-01|+.003E+03|  3.14E+0" 
   (foo-e -3.14159) " -3.14E+0|-31.42$-01|-.003E+03| -3.14E+0"
   (foo-e 1100.0)   "  1.10E+3| 11.00$+02|+.001E+06|  1.10E+3" 
@@ -641,7 +672,18 @@
 
 ;; Clojure doesn't support float/double differences in representation
 (simple-tests cltl-G-tests
+  (cl-format false "~10,3g" 4/5)  " 0.800    "
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3g" big-pos-ratio)) "2.397E+308"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3g" big-neg-ratio)) "-2.397E+308"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3g" tiny-pos-ratio)) "1.000E-340"
+  (binding [*math-context* java.math.MathContext/DECIMAL128]
+    (cl-format false "~10,3g" tiny-neg-ratio)) "-1.000E-340"
   (foo-g 0.0314159) "  3.14E-2|314.2$-04|0.314E-01|  3.14E-2" 
+  (foo-g 314159/10000000)
+                    "  3.14E-2|314.2$-04|0.314E-01|  3.14E-2"
   (foo-g 0.314159)  "  0.31   |0.314    |0.314    | 0.31    " 
   (foo-g 3.14159)   "   3.1   | 3.14    | 3.14    |  3.1    " 
   (foo-g 31.4159)   "   31.   | 31.4    | 31.4    |  31.    "