Use a GCD initialization for f32 and f64

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fraction"
-version = "0.7.0"
+version = "0.8.0"
 authors = ["dnsl48 <[email protected]>"]
 
 description = "Lossless fractions and decimals; drop-in float replacement"
@@ -47,3 +47,10 @@ with-dynaint = []
 with-juniper-support = ["juniper"]
 with-postgres-support = ["postgres", "byteorder"]
 with-serde-support = ["serde", "serde_derive", "num/serde"]
+
+[dev-dependencies]
+criterion = "0.3"
+
+[[bench]]
+name = "bench_fraction"
+harness = false

benches/bench_fraction.rs

@@ -0,0 +1,22 @@
+extern crate criterion;
+extern crate fraction;
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use fraction::GenericDecimal;
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    c.bench_function("Decimal u128/u16 init", |b| {
+        b.iter(|| {
+            GenericDecimal::<u128, u16>::from(black_box(15978.649));
+        })
+    });
+
+    c.bench_function("Decimal i64/u16 init", |b| {
+        b.iter(|| {
+            GenericDecimal::<i64, u16>::from(black_box(15978.649));
+            GenericDecimal::<i64, u16>::from(black_box(-15978.649));
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

src/decimal/mod.rs

@@ -3,7 +3,7 @@ use error;
 
 use num::integer::Integer;
 use num::traits::{
-    /*Float, */ Bounded, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, Num, One, Signed,
+    Bounded, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, FromPrimitive, Num, One, Signed,
     ToPrimitive, Zero,
 };
 
@@ -97,7 +97,7 @@ where
         match *self {
             GenericDecimal(ref fraction, precision) => {
                 let prec = precision.into();
-                let debug_prec = f.precision().unwrap_or_else(|| 32);
+                let debug_prec = f.precision().unwrap_or(32);
                 write!(
                     f,
                     "GenericDecimal({} | prec={}; {:?}; {})",
@@ -285,17 +285,14 @@ macro_rules! dec_impl {
     (impl_trait_from_float; $($t:ty),*) => {$(
         impl<T, P> From<$t> for GenericDecimal<T, P>
         where
-            T: Clone + GenericInteger,
-            P: Copy + GenericInteger + Into<usize> + From<u8>
+            T: Clone + GenericInteger + FromPrimitive,
+            P: Copy + GenericInteger + Into<usize> + From<u8> + Bounded
         {
             fn from(value: $t) -> Self {
                 if value.is_nan () { return GenericDecimal::nan() };
                 if value.is_infinite () { return if value.is_sign_negative () { GenericDecimal::neg_infinity() } else { GenericDecimal::infinity() } };
 
-                /* TODO: without the String conversion (probably through .to_bits) */
-                let src = format! ("{:+}", value);
-
-                GenericDecimal::from_decimal_str(&src).unwrap_or_else(|_| GenericDecimal::nan())
+                GenericDecimal(GenericFraction::from(value), P::zero()).calc_precision(None)
             }
         }
     )*}
@@ -848,7 +845,7 @@ where
                     GenericFraction::Infinity(_) => P::zero(),
                     GenericFraction::Rational(_, ref ratio) => {
                         let mut precision: P = P::zero();
-                        let max_precision: P = max_precision.unwrap_or_else(|| P::max_value());
+                        let max_precision: P = max_precision.unwrap_or(P::max_value());
 
                         let num = ratio.numer();
                         let den = ratio.denom();

src/division.rs

@@ -20,10 +20,7 @@ pub struct DivisionState<I> {
 
 impl<I> DivisionState<I> {
     pub fn new(remainder: I, divisor: I) -> Self {
-        DivisionState {
-            remainder: remainder,
-            divisor: divisor,
-        }
+        DivisionState { remainder, divisor }
     }
 }
 

src/dynaint.rs

@@ -861,8 +861,8 @@ where
 
     fn from_str_radix(s: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
         T::from_str_radix(s, radix)
-            .map(|v| DynaInt::S(v))
-            .or_else(|_| G::from_str_radix(s, radix).map(|v| DynaInt::h(v)))
+            .map(DynaInt::S)
+            .or_else(|_| G::from_str_radix(s, radix).map(DynaInt::h))
     }
 }
 

src/fraction/display.rs

@@ -76,7 +76,7 @@ impl Format {
             align: formatter.align(),
             width: formatter.width(),
             precision: formatter.precision(),
-            flags: flags,
+            flags,
         }
     }