sqrt implementation

Cargo.toml

@@ -52,6 +52,7 @@ with-serde-support = ["serde", "serde_derive", "num/serde"]
 [dev-dependencies]
 criterion = "0.4"
 rand = "0.8.5"
+lazy_static = "1"
 
 [[bench]]
 name = "bench_fraction"

benches/bench_fraction.rs

@@ -5,9 +5,10 @@ use fraction::generic;
 use fraction::{GenericDecimal, GenericFraction};
 use std::str::FromStr;
 
+#[allow(clippy::missing_panics_doc)]
 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)))
+        b.iter(|| GenericDecimal::<u128, u16>::from(black_box(15978.649)));
     });
 
     c.bench_function("Decimal i64/u16 init", |b| {
@@ -16,7 +17,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
             let b = GenericDecimal::<i64, u16>::from(black_box(-15978.649));
 
             (a, b)
-        })
+        });
     });
 
     c.bench_function("Convert int like from str", |b| {
@@ -25,7 +26,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
             let b = GenericFraction::<u8>::from_str(black_box("100"));
 
             (a, b)
-        })
+        });
     });
 
     c.bench_function("Convert float like from str", |b| {
@@ -34,28 +35,54 @@ pub fn criterion_benchmark(c: &mut Criterion) {
             let b = GenericFraction::<u8>::from_str(black_box("100.001"));
 
             (a, b)
-        })
+        });
     });
 
     c.bench_function("Convert fraction like from str", |b| {
         b.iter(|| {
             let a = GenericFraction::<u8>::from_str(black_box("1/1"));
             let b = GenericFraction::<u8>::from_str(black_box("255/255"));
             (a, b)
-        })
+        });
     });
 
     c.bench_function("generic::read_generic_integer / i8 to u8", |b| {
-        b.iter(|| generic::read_generic_integer::<u8, i8>(black_box(14i8)).unwrap())
+        b.iter(|| generic::read_generic_integer::<u8, i8>(black_box(14i8)).unwrap());
     });
 
     c.bench_function("generic::read_generic_integer / u8 to u8", |b| {
-        b.iter(|| generic::read_generic_integer::<u8, u8>(black_box(14u8)).unwrap())
+        b.iter(|| generic::read_generic_integer::<u8, u8>(black_box(14u8)).unwrap());
     });
 
     c.bench_function("From couple", |b| {
-        b.iter(|| GenericFraction::<u8>::from(black_box((3u8, 4u8))))
+        b.iter(|| GenericFraction::<u8>::from(black_box((3u8, 4u8))));
     });
+
+    let num2 = GenericFraction::<u8>::from(2);
+    let small_num = fraction::BigFraction::new(1_u8, u128::MAX) / u128::MAX;
+    let big_num = fraction::BigFraction::new(u128::MAX, 1_u8) * u128::MAX;
+
+    let mut bench_dp = |n: u32| {
+        let mut group = c.benchmark_group(format!("Sqrt {n}dp raw"));
+
+        group.bench_function("2", |b| {
+            b.iter(|| num2.sqrt_raw(n));
+        });
+
+        group.bench_function("Small", |b| {
+            b.iter(|| small_num.sqrt_raw(n));
+        });
+
+        group.bench_function("Big", |b| {
+            b.iter(|| big_num.sqrt_raw(n));
+        });
+
+        group.finish();
+    };
+
+    bench_dp(10_000);
+    bench_dp(1_000);
+    bench_dp(100);
 }
 
 criterion_group!(benches, criterion_benchmark);

src/dynaint.rs

@@ -27,6 +27,7 @@
 use std::mem;
 
 use num::{
+    bigint::{ToBigInt, ToBigUint},
     Bounded, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, Integer, Num, One, ToPrimitive, Zero,
 };
 use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
@@ -886,6 +887,34 @@ where
     dyna_impl!(impl_fn_refmath_tuple2self; div_rem);
 }
 
+#[cfg(feature = "with-bigint")]
+impl<T, G> ToBigInt for DynaInt<T, G>
+where
+    T: Copy + GenericInteger + Into<G> + TryToConvertFrom<G> + From<u8> + ToBigInt,
+    G: Clone + GenericInteger + ToBigInt,
+{
+    fn to_bigint(&self) -> Option<num::BigInt> {
+        match self {
+            DynaInt::S(s) => s.to_bigint(),
+            DynaInt::__H(h) => h.to_bigint(),
+        }
+    }
+}
+
+#[cfg(feature = "with-bigint")]
+impl<T, G> ToBigUint for DynaInt<T, G>
+where
+    T: Copy + GenericInteger + Into<G> + TryToConvertFrom<G> + From<u8> + ToBigUint,
+    G: Clone + GenericInteger + ToBigUint,
+{
+    fn to_biguint(&self) -> Option<num::BigUint> {
+        match self {
+            DynaInt::S(s) => s.to_biguint(),
+            DynaInt::__H(h) => h.to_biguint(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::{