feat: add to_f64 impl

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to `const-decimal`.
 
 ## Unreleased
 
+## 0.2.1
+
+- Added `Decimal::to_f64(&self)`.
+
+## 0.2.0
+
 - Added `BorshSerialize` and `BorshDeserialize` behind `borsh` feature flag.
 - Added `AddAssign`, `SubAssign`, `MulAssign`, and `DivAssign`.
 - Implemented `Decimal::from_scaled(integer: I, decimals: u8)`.

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "const-decimal"
 description = "Integer-backed decimals with constant precision"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 authors = ["Oliver Chalk"]

benches/main.rs

@@ -11,6 +11,7 @@ mod add;
 mod div;
 mod mul;
 mod sub;
+mod to_f64;
 
 fn to_sign<I>(positive: bool) -> I
 where
@@ -73,4 +74,5 @@ fn bench_integers<const D: u8, I>(
     sub::bench_all::<D, I>(group);
     mul::bench_all::<D, I>(group, lo_range.clone(), hi_mul_range);
     div::bench_all::<D, I>(group, lo_range, hi_div_range);
+    to_f64::bench_all::<D, I>(group);
 }

benches/to_f64.rs

@@ -0,0 +1,49 @@
+use const_decimal::{Decimal, ScaledInteger};
+use criterion::measurement::WallTime;
+use criterion::{black_box, BatchSize, BenchmarkGroup};
+use num_traits::PrimInt;
+use prop::strategy::ValueTree;
+use prop::test_runner::TestRunner;
+use proptest::prelude::*;
+
+pub fn bench_all<const D: u8, I>(group: &mut BenchmarkGroup<'_, WallTime>)
+where
+    I: ScaledInteger<D> + Arbitrary,
+{
+    bench_primitive_to_f64::<I>(group);
+    bench_decimal_to_f64::<D, I>(group);
+}
+
+fn bench_primitive_to_f64<I>(group: &mut BenchmarkGroup<'_, WallTime>)
+where
+    I: PrimInt + Arbitrary,
+{
+    // Use proptest to generate arbitrary input values.
+    let mut runner = TestRunner::deterministic();
+    let input = (I::arbitrary(), I::arbitrary());
+
+    group.bench_function("primitive/to_f64", |bencher| {
+        bencher.iter_batched(
+            || input.new_tree(&mut runner).unwrap().current(),
+            |(a, b)| black_box(black_box(a) + black_box(b)),
+            BatchSize::SmallInput,
+        )
+    });
+}
+
+fn bench_decimal_to_f64<const D: u8, I>(group: &mut BenchmarkGroup<'_, WallTime>)
+where
+    I: ScaledInteger<D> + Arbitrary,
+{
+    // Use proptest to generate arbitrary input values.
+    let mut runner = TestRunner::deterministic();
+    let input = I::arbitrary().prop_map(|a| Decimal::<_, D>(a));
+
+    group.bench_function("decimal/to_f64", |bencher| {
+        bencher.iter_batched(
+            || input.new_tree(&mut runner).unwrap().current(),
+            |a| black_box(a.to_f64()),
+            BatchSize::SmallInput,
+        )
+    });
+}

src/conversion.rs

@@ -1,4 +1,4 @@
-use crate::{Decimal, Int128_18, Int64_9, Uint128_18, Uint64_9};
+use crate::{Decimal, Int128_18, Int64_9, ScaledInteger, Uint128_18, Uint64_9};
 
 // TODO: Implement From generically where the result cannot overflow.
 // TODO: Implement TryFrom generically where the result can overflow.
@@ -19,14 +19,27 @@ impl From<Int64_9> for Int128_18 {
     }
 }
 
+impl<I, const D: u8> Decimal<I, D>
+where
+    I: ScaledInteger<D>,
+{
+    // SAFETY: `num_traits::to_f64` does not panic on primitive types.
+    #[allow(clippy::missing_panics_doc)]
+    pub fn to_f64(&self) -> f64 {
+        self.0.to_f64().unwrap() / I::SCALING_FACTOR.to_f64().unwrap()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::str::FromStr;
 
     use proptest::prelude::Arbitrary;
+    use proptest::proptest;
     use proptest::test_runner::TestRunner;
 
     use super::*;
+    use crate::macros::generate_tests_for_common_variants;
 
     #[test]
     fn uint128_18_from_uint64_9() {
@@ -63,4 +76,15 @@ mod tests {
             })
             .unwrap();
     }
+
+    generate_tests_for_common_variants!(to_f64_does_not_panic);
+
+    fn to_f64_does_not_panic<I, const D: u8>()
+    where
+        I: ScaledInteger<D> + Arbitrary,
+    {
+        proptest!(|(a: Decimal<I, D>)| {
+            a.to_f64();
+        });
+    }
 }

src/macros.rs

@@ -13,7 +13,6 @@ macro_rules! apply_to_common_variants {
     };
 }
 
-#[cfg(feature = "borsh")]
 macro_rules! generate_tests_for_common_variants {
     ($f:ident) => {
         crate::macros::generate_test!($f, u8, 1);
@@ -29,7 +28,6 @@ macro_rules! generate_tests_for_common_variants {
     };
 }
 
-#[cfg(feature = "borsh")]
 macro_rules! generate_test {
     ($f:ident, $underlying:ty, $decimals:literal) => {
         ::paste::paste! {
@@ -41,6 +39,4 @@ macro_rules! generate_test {
     };
 }
 
-pub(crate) use apply_to_common_variants;
-#[cfg(feature = "borsh")]
-pub(crate) use {generate_test, generate_tests_for_common_variants};
+pub(crate) use {apply_to_common_variants, generate_test, generate_tests_for_common_variants};