Runtime: Implemented builtin round and [float,int].__round__

Author: gf712

src/runtime/PyFloat.cpp

@@ -1,9 +1,14 @@
 #include "PyFloat.hpp"
 #include "MemoryError.hpp"
+#include "runtime/PyNumber.hpp"
+#include "runtime/Value.hpp"
+#include "runtime/forward.hpp"
 #include "types/api.hpp"
 #include "types/builtin.hpp"
 #include "vm/VM.hpp"
 
+#include <cmath>
+
 namespace py {
 
 template<> PyFloat *as(PyObject *obj)
@@ -56,6 +61,25 @@ PyResult<PyFloat *> PyFloat::create(double value)
 	return Ok(obj);
 }
 
+PyResult<PyObject *> PyFloat::__round__(PyObject *ndigits_obj) const
+{
+	if (!ndigits_obj || ndigits_obj == py_none()) {
+		return PyInteger::create(BigIntType{ as_f64() });
+	}
+
+	if (!ndigits_obj->type()->issubclass(types::integer())) {
+		return Err(type_error(
+			"'{}' object cannot be interpreted as an integer", ndigits_obj->type()->name()));
+	}
+
+	auto ndigits = static_cast<const PyInteger &>(*ndigits_obj).as_big_int();
+
+	const auto multiplier = std::pow(10., ndigits.get_d());
+	const auto value = std::floor(as_f64() * multiplier) / multiplier;
+	return PyFloat::create(value);
+}
+
+
 PyType *PyFloat::static_type() const { return types::float_(); }
 
 double PyFloat::as_f64() const
@@ -70,7 +94,7 @@ namespace {
 
 	std::unique_ptr<TypePrototype> register_float()
 	{
-		return std::move(klass<PyFloat>("float").type);
+		return std::move(klass<PyFloat>("float").def("__round__", &PyFloat::__round__).type);
 	}
 }// namespace
 

src/runtime/PyFloat.hpp

@@ -18,6 +18,8 @@ class PyFloat final : public PyNumber
 
 	double as_f64() const;
 
+	PyResult<PyObject *> __round__(PyObject *ndigits) const;
+
 	static std::function<std::unique_ptr<TypePrototype>()> type_factory();
 };
 

src/runtime/PyInteger.cpp

@@ -4,14 +4,15 @@
 #include "PyFloat.hpp"
 #include "TypeError.hpp"
 #include "ValueError.hpp"
-#include "interpreter/Interpreter.hpp"
+#include "runtime/PyByteArray.hpp"
 #include "runtime/PyObject.hpp"
 #include "runtime/Value.hpp"
 #include "types/api.hpp"
 #include "types/builtin.hpp"
-#include "utilities.hpp"
 #include "vm/VM.hpp"
 
+#include <gmpxx.h>
+
 namespace py {
 
 template<> PyInteger *as(PyObject *obj)
@@ -266,6 +267,24 @@ PyResult<PyObject *> PyInteger::from_bytes(PyType *type, PyTuple *args, PyDict *
 	return result;
 }
 
+PyResult<PyObject *> PyInteger::__round__(PyObject *ndigits_obj) const
+{
+	if (!ndigits_obj || ndigits_obj == py_none()) { return PyInteger::create(as_big_int()); }
+
+	if (!ndigits_obj->type()->issubclass(types::integer())) {
+		return Err(type_error(
+			"'{}' object cannot be interpreted as an integer", ndigits_obj->type()->name()));
+	}
+
+	auto ndigits = static_cast<const PyInteger &>(*ndigits_obj).as_big_int();
+
+	if (ndigits >= 0) { return PyInteger::create(as_big_int()); }
+
+	auto result = m_value - (m_value % Number{ BigIntType{ 10 } }.exp(Number{ -ndigits }));
+
+	return PyInteger::create(std::visit([](auto el) { return BigIntType{ el }; }, result.value));
+}
+
 int64_t PyInteger::as_i64() const
 {
 	ASSERT(std::holds_alternative<BigIntType>(m_value.value));
@@ -298,6 +317,7 @@ namespace {
 							 .def("bit_length", &PyInteger::bit_length)
 							 .def("bit_count", &PyInteger::bit_count)
 							 .def("to_bytes", &PyInteger::to_bytes)
+							 .def("__round__", &PyInteger::__round__)
 							 .classmethod("from_bytes", &PyInteger::from_bytes)
 							 .type);
 	}

src/runtime/PyInteger.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
 #include "PyNumber.hpp"
+#include "forward.hpp"
+#include "runtime/PyType.hpp"
 
 namespace py {
 
@@ -30,6 +32,8 @@ class PyInteger : public Interface<PyNumber, PyInteger>
 	PyResult<PyObject *> __lshift__(const PyObject *other) const;
 	PyResult<PyObject *> __rshift__(const PyObject *other) const;
 
+	PyResult<PyObject *> __round__(PyObject *ndigits) const;
+
 	PyResult<PyObject *> bit_length() const;
 	PyResult<PyObject *> bit_count() const;
 

src/runtime/modules/BuiltinsModule.cpp

@@ -1313,6 +1313,29 @@ PyResult<PyObject *> divmod(PyTuple *args, PyDict *kwargs, Interpreter &)
 	return lhs->divmod(rhs);
 }
 
+PyResult<PyObject *> round(PyTuple *args, PyDict *kwargs, Interpreter &)
+{
+	auto result = PyArgsParser<PyObject *, PyObject *>::unpack_tuple(args,
+		kwargs,
+		"round",
+		std::integral_constant<size_t, 1>{},
+		std::integral_constant<size_t, 2>{},
+		nullptr);
+
+	if (result.is_err()) { return Err(result.unwrap_err()); }
+	auto [value, ndigits] = result.unwrap();
+
+	auto round = value->lookup_attribute(PyString::create("__round__").unwrap());
+
+	if (std::get<1>(round) == LookupAttrResult::NOT_FOUND) {
+		return Err(type_error("type {} doesn't define __round__ method", value->type()->name()));
+	}
+	if (std::get<0>(round).is_err()) { return std::get<0>(round); }
+
+	if (!ndigits) { ndigits = py_none(); }
+	return std::get<0>(round).unwrap()->call(PyTuple::create(ndigits).unwrap(), nullptr);
+}
+
 auto builtin_types()
 {
 	return std::array{
@@ -1580,6 +1603,11 @@ PyModule *builtins_module(Interpreter &interpreter)
 			return divmod(args, kwargs, interpreter);
 		}));
 
+	s_builtin_module->add_symbol(PyString::create("round").unwrap(),
+		heap.allocate<PyNativeFunction>("round", [&interpreter](PyTuple *args, PyDict *kwargs) {
+			return round(args, kwargs, interpreter);
+		}));
+
 	return s_builtin_module;
 }