Address review suggestions

Will squash with previous commit for PR merge if all changes are agreed on.

Author: CokieMiner

Cargo.toml

@@ -25,9 +25,8 @@ members = [
     "macros",
     "python",
     "rational",
-    "fuzz",
 ]
-exclude = ["benchmark"]
+exclude = ["benchmark", "fuzz"]
 default-members = ["base", "integer", "float", "rational", "macros"]
 
 [features]

float/Cargo.toml

@@ -47,6 +47,7 @@ zeroize = { optional = true, version = "1.5.7", default-features = false }
 diesel_v1 = { optional = true, version = "1.4.0", package = "diesel", default-features = false, features = ["postgres"]}
 diesel_v2 = { optional = true, version = "2.0.0", package = "diesel", default-features = false, features = ["postgres_backend"]}
 _bytes = { optional = true, version = "1.0", package = "bytes", default-features = false }
+
 # unstable dependencies
 rand_v08 = { optional = true, version = "0.8.3", package = "rand", default-features = false }
 num-traits_v02 = { optional = true, version = "0.2.15", package = "num-traits", default-features = false }

float/src/math/consts.rs

@@ -4,8 +4,9 @@ use crate::{
     repr::{Context, Word},
     round::{Round, Rounded},
 };
-use dashu_base::{BitTest, UnsignedAbs};
-use dashu_int::{IBig, UBig};
+use core::mem::size_of;
+use dashu_base::{BitTest, Sign, UnsignedAbs};
+use dashu_int::{DoubleWord, IBig, UBig};
 
 impl<R: Round> Context<R> {
     /// Calculate π using the Chudnovsky algorithm with binary splitting.
@@ -70,19 +71,21 @@ fn chudnovsky_bs(a: usize, b: usize) -> (UBig, UBig, IBig) {
     if b - a == 1 {
         // Base case: calculate single term
         if a == 0 {
-            return (UBig::ONE, UBig::ONE, IBig::from(13_591_409));
+            return (UBig::ONE, UBig::ONE, IBig::from_parts_const(Sign::Positive, 13_591_409));
         }
 
         let k = a as u64;
         let p = UBig::from(6 * k - 5) * (2 * k - 1) * (6 * k - 1);
-        let q = UBig::from(k).pow(3) * UBig::from(10_939_058_860_032_000_u64);
-        let t_val = IBig::from(13_591_409) + IBig::from(545_140_134_u64) * k;
+        let q = UBig::from(k).pow(3)
+            * if size_of::<Word>() == 2 {
+                UBig::from(10_939_058_860_032_000_u64)
+            } else {
+                UBig::from_dword(10_939_058_860_032_000 as DoubleWord)
+            };
+        let t_val = IBig::from_parts_const(Sign::Positive, 13_591_409)
+            + IBig::from_parts_const(Sign::Positive, 545_140_134) * k;
         let t_abs = &p * t_val.unsigned_abs();
-        let t = if a % 2 == 1 {
-            -IBig::from(t_abs)
-        } else {
-            IBig::from(t_abs)
-        };
+        let t = IBig::from(t_abs) * Sign::from(a % 2 == 1);
         return (p, q, t);
     }
 

float/src/math/mod.rs

@@ -84,68 +84,3 @@ impl<const B: Word> FpResult<B> {
         matches!(self, Self::Normal(_) | Self::Overflow | Self::Underflow)
     }
 }
-
-/// Operations that can be performed on floating point numbers via their context.
-pub trait ContextOps<R: Round, const B: Word> {
-    fn context(&self) -> &Context<R>;
-    fn repr(&self) -> &Repr<B>;
-
-    /// Calculate the sine of the number.
-    #[inline]
-    fn sin(&self) -> FpResult<B> {
-        self.context().sin(self.repr())
-    }
-
-    /// Calculate the cosine of the number.
-    #[inline]
-    fn cos(&self) -> FpResult<B> {
-        self.context().cos(self.repr())
-    }
-
-    /// Calculate both the sine and cosine of the number.
-    #[inline]
-    fn sin_cos(&self) -> (FpResult<B>, FpResult<B>) {
-        self.context().sin_cos(self.repr())
-    }
-
-    /// Calculate the tangent of the number.
-    #[inline]
-    fn tan(&self) -> FpResult<B> {
-        self.context().tan(self.repr())
-    }
-
-    /// Calculate the arcsine of the number.
-    #[inline]
-    fn asin(&self) -> FpResult<B> {
-        self.context().asin(self.repr())
-    }
-
-    /// Calculate the arccosine of the number.
-    #[inline]
-    fn acos(&self) -> FpResult<B> {
-        self.context().acos(self.repr())
-    }
-
-    /// Calculate the arctangent of the number.
-    #[inline]
-    fn atan(&self) -> FpResult<B> {
-        self.context().atan(self.repr())
-    }
-
-    /// Calculate the 2-argument arctangent of the number (`y`) and `x`.
-    #[inline]
-    fn atan2(&self, x: &Repr<B>) -> FpResult<B> {
-        self.context().atan2(self.repr(), x)
-    }
-}
-
-impl<R: Round, const B: Word> ContextOps<R, B> for FBig<R, B> {
-    #[inline]
-    fn context(&self) -> &Context<R> {
-        &self.context
-    }
-    #[inline]
-    fn repr(&self) -> &Repr<B> {
-        &self.repr
-    }
-}