Merge pull request #35 from stencillogic/33-subtraction-gives-wrong-result

33 subtraction gives wrong result

Author: stencillogic

.github/workflows/2-tests.yml

@@ -20,21 +20,3 @@ jobs:
       run: cargo test --workspace --release --verbose
     - name: Run no_std tests
       run: cargo test --workspace --release --verbose --no-default-features --features random,serde
-
-  build-and-test-x32:
-
-    runs-on: ubuntu-latest
-
-    env:
-      DEP_GMP_LIMB_BITS: 32
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Install dependencies
-      run: sudo dpkg --add-architecture i386 && sudo apt-get update && sudo apt-get install -y gcc-multilib g++-multilib
-    - name: Add 32 bit toolchain
-      run: rustup toolchain install stable-i686-unknown-linux-gnu && rustup default stable-i686-unknown-linux-gnu
-    - name: Run tests
-      run: cargo test --workspace --release --verbose
-    - name: Run no_std tests
-      run: cargo test --workspace --release --verbose --no-default-features --features random,serde

astro-float-macro/src/lib.rs

@@ -450,8 +450,8 @@ fn traverse_expr(expr: &Expr, err: &mut Vec<usize>, cc: &mut Consts) -> Result<T
 
 // Docs for the macro are in the astro-float crate.
 
-///
 #[proc_macro]
+#[allow(missing_docs)]
 pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let pmi = syn::parse_macro_input!(input as MacroInput);
 

astro-float-num/src/conv.rs

@@ -767,6 +767,12 @@ mod tests {
     fn test_conv_num() {
         let mut cc = Consts::new().unwrap();
 
+        /* let z = BigFloatNumber::from_f64(1024, -2.0).unwrap();
+        let d = BigFloatNumber::from_f64(1024, 1.0e-64).unwrap();
+        let r = z.sub(&d, 1024, RoundingMode::None).unwrap();
+        print!("{:?}", r.conv_to_dec(RoundingMode::Down, &mut cc).unwrap());
+        return; */
+
         // basic tests
         let n = BigFloatNumber::from_f64(64, 0.031256789f64).unwrap();
 

astro-float-num/src/mantissa/conv.rs

@@ -19,7 +19,7 @@ impl Mantissa {
     /// Convert `self` to an array of decimal digits with divide and conquer algorithm.
     /// `l` is the number of decimal digits in the input ceiled to a power of 10.
     /// `p` is the current depth of `tenpowers` for the given `input`.
-    /// `most_significant` true if `self` contains the most significant part.
+    /// `most_significant` true if `self` contains the most significant part (ignores leading zeroes if ture).
     pub(crate) fn conv_to_dec(
         &mut self,
         l: usize,
@@ -71,16 +71,20 @@ impl Mantissa {
             let mut q = Mantissa::from_word_buf(q);
             let mut r = Mantissa::from_word_buf(r);
 
+            let l2 = l / 2;
+
             if q.is_zero() {
-                let part1 = Self::conv_to_dec(&mut r, l / 2, tenpowers, p - 1, most_significant)?;
+                let part1 = Self::conv_to_dec(&mut r, l2, tenpowers, p - 1, most_significant)?;
 
                 Ok(part1)
             } else {
-                let mut part1 = Self::conv_to_dec(&mut r, l / 2, tenpowers, p - 1, false)?;
-                let mut part2 =
-                    Self::conv_to_dec(&mut q, l / 2, tenpowers, p - 1, most_significant)?;
+                let mut part1 = Self::conv_to_dec(&mut r, l2, tenpowers, p - 1, false)?;
+                let mut part2 = Self::conv_to_dec(&mut q, l2, tenpowers, p - 1, most_significant)?;
 
-                part2.try_reserve_exact(part1.len())?;
+                part2.try_reserve_exact(l2)?;
+                if part1.len() < l2 {
+                    part2.resize(part2.len() + l2 - part1.len(), 0);
+                }
                 part2.append(&mut part1);
 
                 Ok(part2)
@@ -134,7 +138,7 @@ impl Mantissa {
         debug_assert!(input[0] != 0);
 
         let mut chunks = Vec::new();
-        chunks.try_reserve_exact((input.len() + WORD_TENPOWER_LEN - 1) / WORD_TENPOWER_LEN)?;
+        chunks.try_reserve_exact(input.len().div_ceil(WORD_TENPOWER_LEN))?;
 
         let mut word: Word = 0;
         let mut i = 0;
@@ -321,7 +325,7 @@ mod tests {
             assert_eq!(ret, expected);
         };
 
-        /* let tst = [0x9999999999999999, 0x9999999999999999, 0x9999999999999999];
+        /* let tst = [0, 15336237721486753792, 13000820969757097588, 12856862479722330362, 1520271299530698982, 744111004532756610, 13398299208874459061, 17516404478540231373, 3742450158296248731, 2601219928155938017, 8664737567992370843, 17634481686646146565, 12526671041338573227, 4683828805702906964, 8213244418837960360, 17723613685701911250, 13242562882371522762, 6031074778335529103];
         let mut input = WordBuf::new(tst.len()).unwrap();
         input.copy_from_slice(&tst);
         test_input(input);

astro-float-num/src/ops/series.rs

@@ -425,7 +425,6 @@ fn compute_cube<T: PolycoeffGen>(
 ) -> Result<BigFloatNumber, Error> {
     if n > 1 {
         let mut acc = BigFloatNumber::new(p)?;
-        let cache_dim_sz = cache_dim_sz;
         // no need to multityply the returned coefficient of the first cube by 1.
         let poly_val = compute_cube(p, n - 1, cache, cache_dim_sz, polycoeff_gen)?;
         acc = acc.add(&poly_val, p, RoundingMode::None)?;