RustPython
diff --git a/‎Cargo.lock‎
Lines changed: 1 addition & 2 deletions b/‎Cargo.lock‎
Lines changed: 1 addition & 2 deletions
diff --git a/‎Cargo.toml‎
Lines changed: 1 addition & 1 deletion b/‎Cargo.toml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/stdlib/src/math.rs‎
Lines changed: 36 additions & 31 deletions b/‎crates/stdlib/src/math.rs‎
Lines changed: 36 additions & 31 deletions
@@ -184,7 +184,7 @@ once_cell = "1.20.3"
 parking_lot = "0.12.3"
 paste = "1.0.15"
 proc-macro2 = "1.0.105"
-pymath = { version = "0.1.3", features = ["mul_add", "malachite-bigint", "complex"] }
+pymath = { git = "https://github.com/RustPython/pymath.git", rev = "564ebb2780a05a9460ad12a2752a67244dc5f89e", features = ["mul_add", "malachite-bigint", "complex"] }
 quote = "1.0.43"
 radium = "1.1.1"
 rand = "0.9"
 
@@ -534,10 +534,11 @@ mod math {
 
                     if let Some(int_item) = item.downcast_ref::<PyInt>()
                         && let Ok(b) = int_item.as_bigint().try_into() as Result<i64, _>
-                            && let Some(product) = int_result.checked_mul(b) {
-                                int_result = product;
-                                continue;
-                            }
+                        && let Some(product) = int_result.checked_mul(b)
+                    {
+                        int_result = product;
+                        continue;
+                    }
 
                     // Overflow or non-int: restore to PyObject and continue
                     obj_result = Some(vm.ctx.new_int(int_result).into());
@@ -590,10 +591,11 @@ mod math {
                         continue;
                     }
                     if let Some(i) = item.downcast_ref::<PyInt>()
-                        && let Ok(v) = i.as_bigint().try_into() as Result<i64, _> {
-                            flt_result *= v as f64;
-                            continue;
-                        }
+                        && let Ok(v) = i.as_bigint().try_into() as Result<i64, _>
+                    {
+                        flt_result *= v as f64;
+                        continue;
+                    }
 
                     // Non-float/int: restore and continue with generic path
                     obj_result = Some(vm.ctx.new_float(flt_result).into());
@@ -854,11 +856,13 @@ mod math {
 
         // Fast path: n fits in i64
         if let Some(ni) = n_big.to_i64()
-            && ni >= 0 && ki > 1 {
-                let result = pymath::math::integer::perm(ni, Some(ki as i64))
-                    .map_err(|_| vm.new_value_error("perm() error"))?;
-                return Ok(result.into());
-            }
+            && ni >= 0
+            && ki > 1
+        {
+            let result = pymath::math::integer::perm(ni, Some(ki as i64))
+                .map_err(|_| vm.new_value_error("perm() error"))?;
+            return Ok(result.into());
+        }
 
         // BigInt path: use perm_bigint
         let result = pymath::math::perm_bigint(n_big, ki);
@@ -881,25 +885,26 @@ mod math {
 
         // Fast path: n fits in i64
         if let Some(ni) = n_big.to_i64()
-            && ni >= 0 {
-                // k overflow or k > n means result is 0
-                let ki = match k_big.to_i64() {
-                    Some(k) if k >= 0 && k <= ni => k,
-                    _ => return Ok(BigInt::from(0u8)),
-                };
-                // Apply symmetry: use min(k, n-k)
-                let ki = ki.min(ni - ki);
-                if ki > 1 {
-                    let result = pymath::math::integer::comb(ni, ki)
-                        .map_err(|_| vm.new_value_error("comb() error"))?;
-                    return Ok(result.into());
-                }
-                // ki <= 1 cases
-                if ki == 0 {
-                    return Ok(BigInt::from(1u8));
-                }
-                return Ok(n_big.clone()); // ki == 1
+            && ni >= 0
+        {
+            // k overflow or k > n means result is 0
+            let ki = match k_big.to_i64() {
+                Some(k) if k >= 0 && k <= ni => k,
+                _ => return Ok(BigInt::from(0u8)),
+            };
+            // Apply symmetry: use min(k, n-k)
+            let ki = ki.min(ni - ki);
+            if ki > 1 {
+                let result = pymath::math::integer::comb(ni, ki)
+                    .map_err(|_| vm.new_value_error("comb() error"))?;
+                return Ok(result.into());
             }
+            // ki <= 1 cases
+            if ki == 0 {
+                return Ok(BigInt::from(1u8));
+            }
+            return Ok(n_big.clone()); // ki == 1
+        }
 
         // BigInt path: n doesn't fit in i64
         // Apply symmetry: k = min(k, n - k)