working on tests

Author: programmerjake

Cargo.toml

@@ -27,4 +27,12 @@ num-rational = "0.2"
 rand = "0.5"
 rand_pcg = "0.1.1"
 lazy_static = "1.4"
-pyo3 = { version = "0.8.0", optional = true }
+
+[dependencies.pyo3]
+# switch back to PyO3/pyo3 when
+# https://github.com/PyO3/pyo3/pull/630 lands;
+# switch to crates.io version once new version is published
+git = "https://github.com/programmerjake/pyo3.git"
+rev = "f55037c3779521520971cd528b05680b283e440c"
+optional = true
+features = ["num-bigint"]

src/python.rs

@@ -6,80 +6,19 @@
 use crate::algebraic_numbers::RealAlgebraicNumber;
 use crate::traits::ExactDivAssign;
 use num_bigint::BigInt;
-use num_bigint::Sign;
 use num_traits::Signed;
-use num_traits::ToPrimitive;
 use num_traits::Zero;
 use pyo3::basic::CompareOp;
 use pyo3::exceptions::TypeError;
 use pyo3::exceptions::ValueError;
 use pyo3::exceptions::ZeroDivisionError;
 use pyo3::prelude::*;
-use pyo3::types::IntoPyDict;
 use pyo3::types::PyAny;
-use pyo3::types::PyBytes;
-use pyo3::types::PyInt;
-use pyo3::types::PyType;
-use pyo3::FromPy;
 use pyo3::PyNativeType;
 use pyo3::PyNumberProtocol;
 use pyo3::PyObjectProtocol;
 use std::sync::Arc;
 
-// TODO: Switch to using BigInt's python conversions once they are implemented
-// see https://github.com/PyO3/pyo3/issues/543
-#[derive(Clone, Debug)]
-pub struct PyBigInt(pub BigInt);
-
-impl ToPyObject for PyBigInt {
-    fn to_object(&self, py: Python) -> PyObject {
-        if let Some(value) = self.0.to_i64() {
-            value.to_object(py)
-        } else {
-            let (sign, bytes) = self.0.to_bytes_le();
-            let int_type: &PyType = py.get_type::<PyInt>();
-            let retval = int_type
-                .call_method1("from_bytes", (bytes, "little"))
-                .unwrap()
-                .downcast_ref::<PyInt>()
-                .unwrap();
-            if sign == Sign::Minus {
-                retval.call_method0("__neg__").unwrap().to_object(py)
-            } else {
-                retval.to_object(py)
-            }
-        }
-    }
-}
-
-impl FromPy<PyBigInt> for PyObject {
-    fn from_py(value: PyBigInt, py: Python) -> Self {
-        value.to_object(py)
-    }
-}
-
-impl FromPyObject<'_> for PyBigInt {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
-        let value = ob.downcast_ref::<PyInt>()?;
-        if let Ok(value) = value.extract::<i64>() {
-            Ok(PyBigInt(value.into()))
-        } else {
-            let mut len = 32;
-            let bytes = loop {
-                match value.call_method(
-                    "to_bytes",
-                    (len, "little"),
-                    Some([("signed", true)].into_py_dict(ob.py())),
-                ) {
-                    Ok(bytes) => break bytes.downcast_ref::<PyBytes>()?,
-                    Err(_) => len *= 2,
-                }
-            };
-            Ok(PyBigInt(BigInt::from_signed_bytes_le(bytes.as_bytes())))
-        }
-    }
-}
-
 #[pyclass(name=RealAlgebraicNumber, module="algebraics")]
 #[derive(Clone)]
 struct RealAlgebraicNumberPy {
@@ -91,10 +30,10 @@ impl FromPyObject<'_> for RealAlgebraicNumberPy {
         if let Ok(value) = value.downcast_ref::<RealAlgebraicNumberPy>() {
             return Ok(value.clone());
         }
-        let value = value.extract::<Option<&PyInt>>()?;
+        let value = value.extract::<Option<BigInt>>()?;
         let value = match value {
             None => RealAlgebraicNumber::zero(),
-            Some(value) => RealAlgebraicNumber::from(value.extract::<PyBigInt>()?.0),
+            Some(value) => RealAlgebraicNumber::from(value),
         }
         .into();
         Ok(RealAlgebraicNumberPy { value })
@@ -109,37 +48,30 @@ impl RealAlgebraicNumberPy {
             value: RealAlgebraicNumber::zero().into(),
         }));
     }
-    fn __trunc__(&self) -> PyBigInt {
+    fn __trunc__(&self) -> BigInt {
         let gil = Python::acquire_gil();
         let py = gil.python();
-        py.allow_threads(|| PyBigInt(self.value.to_integer_trunc()))
+        py.allow_threads(|| self.value.to_integer_trunc())
     }
-    fn __floor__(&self) -> PyBigInt {
+    fn __floor__(&self) -> BigInt {
         let gil = Python::acquire_gil();
         let py = gil.python();
-        py.allow_threads(|| PyBigInt(self.value.to_integer_floor()))
+        py.allow_threads(|| self.value.to_integer_floor())
     }
-    fn __ceil__(&self) -> PyBigInt {
+    fn __ceil__(&self) -> BigInt {
         let gil = Python::acquire_gil();
         let py = gil.python();
-        py.allow_threads(|| PyBigInt(self.value.to_integer_ceil()))
+        py.allow_threads(|| self.value.to_integer_ceil())
     }
-    fn to_integer(&self) -> Option<PyBigInt> {
-        self.value.to_integer().map(PyBigInt)
+    fn to_integer(&self) -> Option<BigInt> {
+        self.value.to_integer()
     }
-    fn to_rational(&self) -> Option<(PyBigInt, PyBigInt)> {
-        self.value.to_rational().map(|value| {
-            let (numer, denom) = value.into();
-            (PyBigInt(numer), PyBigInt(denom))
-        })
+    fn to_rational(&self) -> Option<(BigInt, BigInt)> {
+        self.value.to_rational().map(Into::into)
     }
     #[getter]
-    fn minimal_polynomial(&self) -> Vec<PyBigInt> {
-        self.value
-            .minimal_polynomial()
-            .iter()
-            .map(PyBigInt)
-            .collect()
+    fn minimal_polynomial(&self) -> Vec<BigInt> {
+        self.value.minimal_polynomial().iter().collect()
     }
     #[getter]
     fn degree(&self) -> usize {
@@ -270,5 +202,3 @@ fn algebraics(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<RealAlgebraicNumberPy>()?;
     Ok(())
 }
-
-// FIXME: add tests

tests/test_real_algebraic_number.py

@@ -3,6 +3,7 @@
 
 from algebraics import RealAlgebraicNumber
 import unittest
+import math
 
 
 class TestRealAlgebraicNumber(unittest.TestCase):
@@ -31,6 +32,17 @@ def test_construct(self):
                          "lower_bound_numer: -5, upper_bound_numer: -5, "
                          "log2_denom: 0 } }>")
 
+    def test_trunc(self):
+        self.assertEqual(math.trunc(RealAlgebraicNumber(123)), 123)
+        self.assertEqual(math.trunc(RealAlgebraicNumber(123) / 10), 12)
+        self.assertEqual(math.trunc(RealAlgebraicNumber(128) / 10), 12)
+        self.assertEqual(math.trunc(RealAlgebraicNumber(123)
+                                    ** (RealAlgebraicNumber(1) / 2)), 11)
+        self.assertEqual(math.trunc(RealAlgebraicNumber(-123)), -123)
+        self.assertEqual(math.trunc(RealAlgebraicNumber(-123) / 10), -12)
+        self.assertEqual(math.trunc(RealAlgebraicNumber(-128) / 10), -12)
+        self.assertEqual(math.trunc(-(RealAlgebraicNumber(123)
+                                      ** (RealAlgebraicNumber(1) / 2))), -11)
     # FIXME: add more tests