(Issue #10) num_rational::Ratio: Add the ability to format as a decimal

src/lib.rs

@@ -978,6 +978,14 @@ impl<T: Clone + Integer + Signed> Signed for Ratio<T> {
     }
 }
 
+#[cfg(feature = "std")]
+use std::string::String;
+
+#[cfg(feature = "std")]
+trait AsDecimal {
+    fn as_decimal(&self, usize) -> String;
+}
+
 // String conversions
 impl<T> fmt::Display for Ratio<T>
 where
@@ -993,6 +1001,48 @@ where
     }
 }
 
+#[cfg(feature = "std")]
+impl<T> AsDecimal for Ratio<T> where
+    T: fmt::Display
+        + Clone
+        + Eq
+        + FromPrimitive
+        + Integer
+        + Pow<usize, Output = T>
+        + Signed
+        + std::string::ToString,
+{
+    /// Generates decimal approximation to a specified precision as a String.
+    fn as_decimal(&self, precision: usize) -> String {
+        if self.denom.is_one() {
+            self.numer.to_string()
+        } else {
+            let _10_pow_prec = T::from_usize(10).unwrap().pow(precision);
+            let rounded = (self.clone() * &_10_pow_prec).round();
+            let minus = rounded < Zero::zero();
+            let trunc = &((&rounded / &_10_pow_prec).trunc().to_integer());
+            let tail = &(rounded % _10_pow_prec).abs().to_integer();
+            if tail.is_zero() {
+                trunc.to_string()
+            } else {
+                let mut ret_val = String::from(if minus { "-" } else { "" });
+                ret_val.push_str(&trunc.to_string());
+                ret_val.push_str(".");
+                let tail_strarr = &tail.to_string();
+                let tail_length = &tail_strarr.chars().count();
+                let tail_zeroes = if tail_length < &precision {
+                    // If rust >= 1.16.0 - we can simply use repeat.
+                    // "0".repeat(precision - tail_length)
+                    (0..(precision - tail_length)).map(|_| "0").collect::<String>()
+                } else { String::from("") };
+                ret_val.push_str(&tail_zeroes);
+                ret_val.push_str(&tail.to_string());
+                ret_val
+            }
+        }
+    }
+}
+
 impl<T: FromStr + Clone + Integer> FromStr for Ratio<T> {
     type Err = ParseRatioError;
 
@@ -1352,6 +1402,19 @@ mod test {
         numer: -2,
         denom: 3,
     };
+    pub const _1_8: Rational = Ratio { numer: 1, denom: 8 };
+    pub const _NEG1_8: Rational = Ratio {
+        numer: -1,
+        denom: 8,
+    };
+    pub const _99999_1000: Rational = Ratio {
+        numer: 99999,
+        denom: 1000,
+    };
+    pub const _NEG99999_1000: Rational = Ratio {
+        numer: -99999,
+        denom: 1000,
+    };
 
     #[cfg(feature = "bigint")]
     pub fn to_big(n: Rational) -> BigRational {
@@ -1536,6 +1599,22 @@ mod test {
         assert_eq!(format!("{}", Ratio::from_integer(-2)), "-2".to_string());
     }
 
+    #[test]
+    #[cfg(feature = "std")]
+    fn test_as_decimal() {
+        use AsDecimal;
+        use std::string::ToString;
+        assert_eq!(_2.as_decimal(2), "2".to_string());
+        assert_eq!(_1_2.as_decimal(2), "0.50".to_string());
+        assert_eq!(_3_2.as_decimal(1), "1.5".to_string());
+        assert_eq!(_NEG1_2.as_decimal(2), "-0.50".to_string());
+        assert_eq!(_NEG2_3.as_decimal(3), "-0.667".to_string());
+        assert_eq!(_1_8.as_decimal(2), "0.13".to_string());
+        assert_eq!(_NEG1_8.as_decimal(4), "-0.1250".to_string());
+        assert_eq!(_99999_1000.as_decimal(3), "99.999".to_string());
+        assert_eq!(_NEG99999_1000.as_decimal(1), "-100".to_string());
+    }
+
     mod arith {
         use super::super::{Ratio, Rational};
         use super::{_0, _1, _1_2, _2, _3_2, _NEG1_2, to_big};