finish implementing python bindings and start adding tests

Author: programmerjake

src/python.rs

@@ -20,6 +20,7 @@ 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;
@@ -51,6 +52,12 @@ impl ToPyObject for PyBigInt {
     }
 }
 
+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>()?;
@@ -97,17 +104,69 @@ impl FromPyObject<'_> for RealAlgebraicNumberPy {
 #[pymethods(PyObjectProtocol, PyNumberProtocol)]
 impl RealAlgebraicNumberPy {
     #[new]
-    fn pynew(obj: &PyRawObject, value: RealAlgebraicNumberPy) -> PyResult<()> {
-        obj.init(value);
-        Ok(())
+    fn pynew(obj: &PyRawObject, value: Option<RealAlgebraicNumberPy>) {
+        obj.init(value.unwrap_or_else(|| RealAlgebraicNumberPy {
+            value: RealAlgebraicNumber::zero().into(),
+        }));
+    }
+    fn __trunc__(&self) -> PyBigInt {
+        let gil = Python::acquire_gil();
+        let py = gil.python();
+        py.allow_threads(|| PyBigInt(self.value.to_integer_trunc()))
+    }
+    fn __floor__(&self) -> PyBigInt {
+        let gil = Python::acquire_gil();
+        let py = gil.python();
+        py.allow_threads(|| PyBigInt(self.value.to_integer_floor()))
+    }
+    fn __ceil__(&self) -> PyBigInt {
+        let gil = Python::acquire_gil();
+        let py = gil.python();
+        py.allow_threads(|| PyBigInt(self.value.to_integer_ceil()))
+    }
+    fn to_integer(&self) -> Option<PyBigInt> {
+        self.value.to_integer().map(PyBigInt)
+    }
+    fn to_rational(&self) -> Option<(PyBigInt, PyBigInt)> {
+        self.value.to_rational().map(|value| {
+            let (numer, denom) = value.into();
+            (PyBigInt(numer), PyBigInt(denom))
+        })
+    }
+    #[getter]
+    fn minimal_polynomial(&self) -> Vec<PyBigInt> {
+        self.value
+            .minimal_polynomial()
+            .iter()
+            .map(PyBigInt)
+            .collect()
+    }
+    #[getter]
+    fn degree(&self) -> usize {
+        self.value.degree()
+    }
+    fn is_rational(&self) -> bool {
+        self.value.is_rational()
+    }
+    fn is_integer(&self) -> bool {
+        self.value.is_integer()
+    }
+    fn recip(&self) -> PyResult<RealAlgebraicNumberPy> {
+        Python::acquire_gil()
+            .python()
+            .allow_threads(|| {
+                Some(RealAlgebraicNumberPy {
+                    value: self.value.checked_recip()?.into(),
+                })
+            })
+            .ok_or_else(get_div_by_zero_error)
     }
-    // FIXME: implement rest of methods
 }
 
 #[pyproto]
 impl PyObjectProtocol for RealAlgebraicNumberPy {
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("{:?}", self.value))
+        Ok(format!("<{:?}>", self.value))
     }
     fn __richcmp__(&self, other: &PyAny, op: CompareOp) -> PyResult<bool> {
         let py = other.py();
@@ -123,6 +182,10 @@ impl PyObjectProtocol for RealAlgebraicNumberPy {
     }
 }
 
+fn get_div_by_zero_error() -> PyErr {
+    ZeroDivisionError::py_err("can't divide RealAlgebraicNumber by zero")
+}
+
 #[pyproto]
 impl PyNumberProtocol for RealAlgebraicNumberPy {
     fn __add__(lhs: &PyAny, rhs: RealAlgebraicNumberPy) -> PyResult<RealAlgebraicNumberPy> {
@@ -156,7 +219,7 @@ impl PyNumberProtocol for RealAlgebraicNumberPy {
             Arc::make_mut(&mut lhs.value).checked_exact_div_assign(&*rhs.value)?;
             Ok(lhs)
         })
-        .map_err(|()| ZeroDivisionError::py_err("can't divide RealAlgebraicNumber by zero"))
+        .map_err(|()| get_div_by_zero_error())
     }
     fn __pow__(
         lhs: RealAlgebraicNumberPy,
@@ -204,7 +267,6 @@ impl PyNumberProtocol for RealAlgebraicNumberPy {
 
 #[pymodule]
 fn algebraics(_py: Python, m: &PyModule) -> PyResult<()> {
-    // FIXME: add module members
     m.add_class::<RealAlgebraicNumberPy>()?;
     Ok(())
 }

tests/test_real_algebraic_number.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# See Notices.txt for copyright information
+
+from algebraics import RealAlgebraicNumber
+import unittest
+
+
+class TestRealAlgebraicNumber(unittest.TestCase):
+    def test_construct(self):
+        self.assertEqual(repr(RealAlgebraicNumber()),
+                         "<RealAlgebraicNumber { minimal_polynomial: 0 + 1*X, "
+                         "interval: DyadicFractionInterval { "
+                         "lower_bound_numer: 0, upper_bound_numer: 0, "
+                         "log2_denom: 0 } }>")
+        self.assertEqual(repr(RealAlgebraicNumber(42)),
+                         "<RealAlgebraicNumber { "
+                         "minimal_polynomial: -42 + 1*X, "
+                         "interval: DyadicFractionInterval { "
+                         "lower_bound_numer: 42, upper_bound_numer: 42, "
+                         "log2_denom: 0 } }>")
+        self.assertEqual(repr(RealAlgebraicNumber(-5)),
+                         "<RealAlgebraicNumber { "
+                         "minimal_polynomial: 5 + 1*X, "
+                         "interval: DyadicFractionInterval { "
+                         "lower_bound_numer: -5, upper_bound_numer: -5, "
+                         "log2_denom: 0 } }>")
+        self.assertEqual(repr(RealAlgebraicNumber(RealAlgebraicNumber(-5))),
+                         "<RealAlgebraicNumber { "
+                         "minimal_polynomial: 5 + 1*X, "
+                         "interval: DyadicFractionInterval { "
+                         "lower_bound_numer: -5, upper_bound_numer: -5, "
+                         "log2_denom: 0 } }>")
+
+    # FIXME: add more tests
+
+
+if __name__ == '__main__':
+    unittest.main()