Removed unnecessary #ifdef for Python<=2

src/common.h

@@ -10,14 +10,6 @@
 namespace py = pybind11;
 using namespace pybind11::literals;
 
-#if PY_MAJOR_VERSION >= 3
-#define PY_DIV "__truediv__"
-#define PY_RDIV "__rtruediv__"
-#else
-#define PY_DIV "__div__"
-#define PY_RDIV "__rdiv__"
-#endif
-
 PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
 PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T const>)
 

src/pycarl/common.h

@@ -8,15 +8,7 @@
 
 #include <boost/variant.hpp>
 
-namespace py = pybind11;
-
-#if PY_MAJOR_VERSION >= 3
-#define PY_DIV "__truediv__"
-#define PY_RDIV "__rtruediv__"
-#else
-#define PY_DIV "__div__"
-#define PY_RDIV "__rdiv__"
-#endif
+#include "src/common.h"
 
 struct NoPickling : public std::exception {
     virtual const char* what() const throw() {

src/pycarl/core/bound_type.cpp

@@ -1,6 +1,6 @@
 #include "bound_type.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 void define_boundtype(py::module& m) {

src/pycarl/core/monomial.cpp

@@ -1,6 +1,6 @@
 #include "monomial.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 void define_monomial(py::module& m) {

src/pycarl/core/variable.cpp

@@ -2,7 +2,7 @@
 #include <carl/core/VariablePool.h>
 #include <string>
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 #include "variable.h"
 

src/pycarl/formula/relation.cpp

@@ -1,5 +1,5 @@
 #include "relation.h"
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 
 #include <carl/core/Relation.h>
 

src/pycarl/mod_formula.cpp

@@ -1,5 +1,5 @@
 #include "common.h"
-#include "helpers.h"
+#include "src/helpers.h"
 
 #include "formula/formula_type.h"
 #include "formula/relation.h"

src/pycarl/mod_typed_formula.cpp

@@ -1,5 +1,5 @@
 #include "common.h"
-#include "helpers.h"
+#include "src/helpers.h"
 
 #include "typed_formula/constraint.h"
 #include "typed_formula/formula.h"

src/pycarl/typed_core/factorization.cpp

@@ -1,6 +1,6 @@
 #include "factorization.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 void define_factorizationcache(py::module& m) {

src/pycarl/typed_core/factorizedpolynomial.cpp

@@ -1,6 +1,6 @@
 #include "factorizedpolynomial.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 void define_factorizedpolynomial(py::module& m) {

src/pycarl/typed_core/factorizedrationalfunction.cpp

@@ -1,6 +1,6 @@
 #include "factorizedrationalfunction.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 void define_factorizedrationalfunction(py::module& m) {

src/pycarl/typed_core/integer.cpp

@@ -1,6 +1,6 @@
 #include "rational.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 #include "carl/numbers/conversion/cln_gmp.h"
@@ -42,7 +42,7 @@ void define_cln_integer(py::module& m) {
         .def("__rmul__", [](const cln::cl_I& rhs, carl::Variable::Arg lhs) -> Term { return cln::cl_RA(rhs) * lhs; })
         .def("__rmul__", [](const cln::cl_I& rhs, const Monomial::Arg& lhs) -> Term { return cln::cl_RA(rhs) * lhs; })
 
-        .def(PY_DIV,
+        .def("__truediv__",
              [](const cln::cl_I& lhs, const cln::cl_I& rhs) -> cln::cl_RA {
                  if (carl::isZero(rhs))
                      throw std::runtime_error("Div by zero");
@@ -121,7 +121,7 @@ void define_gmp_integer(py::module& m) {
         .def("__rmul__", [](const mpz_class& rhs, carl::Variable::Arg lhs) -> Term { return mpq_class(rhs) * lhs; })
         .def("__rmul__", [](const mpz_class& rhs, const Monomial::Arg& lhs) -> Term { return mpq_class(rhs) * lhs; })
 
-        .def(PY_DIV,
+        .def("__truediv__",
              [](const mpz_class& lhs, const mpz_class& rhs) -> mpq_class {
                  if (carl::isZero(rhs))
                      throw std::runtime_error("Div by zero");

src/pycarl/typed_core/interval.h

@@ -1,7 +1,7 @@
 #pragma once
 
+#include "src/helpers.h"
 #include "src/pycarl/common.h"
-#include "src/pycarl/helpers.h"
 #include "src/pycarl/types.h"
 
 template<typename Number>

src/pycarl/typed_core/polynomial.cpp

@@ -1,6 +1,6 @@
 #include "polynomial.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 void define_polynomial(py::module& m) {
@@ -40,13 +40,13 @@ void define_polynomial(py::module& m) {
         .def(py::self * Term())
         .def(py::self * py::self)
 
-        .def(PY_DIV, [](const Polynomial& lhs, const RationalFunction& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Polynomial& lhs, const Polynomial& rhs) { return RationalFunction(lhs, rhs); })
-        .def(PY_DIV, [](const Polynomial& lhs, const Term& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Polynomial& lhs, const Monomial::Arg& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Polynomial& lhs, carl::Variable::Arg rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Polynomial& lhs, const RationalFunction& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Polynomial& lhs, const Polynomial& rhs) { return RationalFunction(lhs, rhs); })
+        .def("__truediv__", [](const Polynomial& lhs, const Term& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Polynomial& lhs, const Monomial::Arg& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Polynomial& lhs, carl::Variable::Arg rhs) { return RationalFunction(lhs) / rhs; })
         .def(py::self / Rational())
-        .def(PY_DIV, [](const Polynomial& lhs, const Integer& rhs) -> Polynomial { return lhs / Rational(rhs); })
+        .def("__truediv__", [](const Polynomial& lhs, const Integer& rhs) -> Polynomial { return lhs / Rational(rhs); })
 
         .def("__pow__", [](const Polynomial& var, carl::uint exp) { return var.pow(exp); })
 

src/pycarl/typed_core/rational.cpp

@@ -2,7 +2,7 @@
 
 #include <stdexcept>
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 #include "carl/numbers/conversion/cln_gmp.h"
@@ -43,31 +43,31 @@ void define_cln_rational(py::module& m) {
         .def("__rmul__", [](const cln::cl_RA& rhs, carl::sint lhs) -> cln::cl_RA { return carl::rationalize<cln::cl_RA>(lhs) * rhs; })
         .def("__rmul__", [](const cln::cl_RA& rhs, carl::Variable::Arg lhs) -> Term { return rhs * lhs; })
 
-        .def(PY_DIV,
+        .def("__truediv__",
              [](const cln::cl_RA& lhs, const cln::cl_RA& rhs) -> cln::cl_RA {
                  if (carl::isZero(rhs))
                      throw std::runtime_error("Div by zero");
                  return lhs / rhs;
              })
-        .def(PY_DIV,
+        .def("__truediv__",
              [](const cln::cl_RA& lhs, carl::sint rhs) -> cln::cl_RA {
                  if (rhs == 0.0)
                      throw std::runtime_error("Div by zero");
                  return lhs / carl::rationalize<cln::cl_RA>(rhs);
              })
-        .def(PY_RDIV,
+        .def("__rtruediv__",
              [](const cln::cl_RA& rhs, carl::sint lhs) -> cln::cl_RA {
                  if (carl::isZero(rhs))
                      throw std::runtime_error("Div by zero");
                  return carl::rationalize<cln::cl_RA>(lhs) / rhs;
              })
 
-        .def(PY_DIV, [](const Rational& lhs, const RationalFunction& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Rational& lhs, const Polynomial& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Rational& lhs, const Term& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Rational& lhs, const Monomial::Arg& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Rational& lhs, carl::Variable::Arg rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_RDIV, [](const Rational& rhs, carl::Variable::Arg lhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, const RationalFunction& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, const Polynomial& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, const Term& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, const Monomial::Arg& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, carl::Variable::Arg rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__rtruediv__", [](const Rational& rhs, carl::Variable::Arg lhs) { return RationalFunction(lhs) / rhs; })
 
         .def("__pow__", static_cast<cln::cl_RA (*)(const cln::cl_RA&, std::size_t)>(&carl::pow))
         .def("__pos__", [](const cln::cl_RA& var) { return cln::cl_RA(var); })
@@ -155,31 +155,31 @@ void define_gmp_rational(py::module& m) {
         .def("__rmul__", [](const mpq_class& rhs, carl::sint lhs) -> mpq_class { return carl::rationalize<mpq_class>(lhs) * rhs; })
         .def("__rmul__", [](const mpq_class& rhs, carl::Variable::Arg lhs) -> Term { return rhs * lhs; })
 
-        .def(PY_DIV,
+        .def("__truediv__",
              [](const mpq_class& lhs, const mpq_class& rhs) -> mpq_class {
                  if (carl::isZero(rhs))
                      throw std::runtime_error("Div by zero");
                  return lhs / rhs;
              })
-        .def(PY_DIV,
+        .def("__truediv__",
              [](const mpq_class& lhs, carl::sint rhs) -> mpq_class {
                  if (rhs == 0.0)
                      throw std::runtime_error("Div by zero");
                  return lhs / carl::rationalize<mpq_class>(rhs);
              })
-        .def(PY_RDIV,
+        .def("__rtruediv__",
              [](const mpq_class& rhs, carl::sint lhs) -> mpq_class {
                  if (carl::isZero(rhs))
                      throw std::runtime_error("Div by zero");
                  return carl::rationalize<mpq_class>(lhs) / rhs;
              })
 
-        .def(PY_DIV, [](const Rational& lhs, const RationalFunction& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Rational& lhs, const Polynomial& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Rational& lhs, const Term& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Rational& lhs, const Monomial::Arg& rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_DIV, [](const Rational& lhs, carl::Variable::Arg rhs) { return RationalFunction(lhs) / rhs; })
-        .def(PY_RDIV, [](const Rational& rhs, carl::Variable::Arg lhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, const RationalFunction& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, const Polynomial& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, const Term& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, const Monomial::Arg& rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__truediv__", [](const Rational& lhs, carl::Variable::Arg rhs) { return RationalFunction(lhs) / rhs; })
+        .def("__rtruediv__", [](const Rational& rhs, carl::Variable::Arg lhs) { return RationalFunction(lhs) / rhs; })
 
         .def("__pow__", static_cast<mpq_class (*)(const mpq_class&, std::size_t)>(&carl::pow))
         .def("__pos__", [](const mpq_class& var) { return mpq_class(var); })

src/pycarl/typed_core/rationalfunction.cpp

@@ -1,6 +1,6 @@
 #include "rationalfunction.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 void define_rationalfunction(py::module& m) {
@@ -36,11 +36,11 @@ void define_rationalfunction(py::module& m) {
         .def("__mul__", static_cast<RationalFunction (*)(const RationalFunction&, const Rational&)>(&carl::operator*))
         .def(py::self * py::self)
 
-        .def(PY_DIV, static_cast<RationalFunction (*)(const RationalFunction&, const Rational&)>(&carl::operator/))
-        .def(PY_DIV, static_cast<RationalFunction (*)(const RationalFunction&, const Polynomial&)>(&carl::operator/))
-        .def(PY_DIV, static_cast<RationalFunction (*)(const RationalFunction&, const Term&)>(&carl::operator/))
-        .def(PY_DIV, static_cast<RationalFunction (*)(const RationalFunction&, carl::Variable)>(&carl::operator/))
-        .def(PY_DIV, static_cast<RationalFunction (*)(const RationalFunction&, const Rational&)>(&carl::operator/))
+        .def("__truediv__", static_cast<RationalFunction (*)(const RationalFunction&, const Rational&)>(&carl::operator/))
+        .def("__truediv__", static_cast<RationalFunction (*)(const RationalFunction&, const Polynomial&)>(&carl::operator/))
+        .def("__truediv__", static_cast<RationalFunction (*)(const RationalFunction&, const Term&)>(&carl::operator/))
+        .def("__truediv__", static_cast<RationalFunction (*)(const RationalFunction&, carl::Variable)>(&carl::operator/))
+        .def("__truediv__", static_cast<RationalFunction (*)(const RationalFunction&, const Rational&)>(&carl::operator/))
         .def(py::self / py::self)
 
         .def("__pow__", [](const RationalFunction& var, carl::uint exp) { return carl::pow(var, exp); })

src/pycarl/typed_core/term.cpp

@@ -1,6 +1,6 @@
 #include "term.h"
 
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"
 #include "src/pycarl/types.h"
 
 void define_term(py::module& m) {
@@ -27,11 +27,11 @@ void define_term(py::module& m) {
         .def("__mul__", static_cast<Term (*)(Term, carl::Variable)>(&carl::operator*))
         .def("__mul__", static_cast<Term (*)(Term, const Rational&)>(&carl::operator*))
 
-        .def(PY_DIV, [](const Term& lhs, const RationalFunction& rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
-        .def(PY_DIV, [](const Term& lhs, const Polynomial& rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
-        .def(PY_DIV, [](const Term& lhs, const Term& rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
-        .def(PY_DIV, [](const Term& lhs, const Monomial::Arg& rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
-        .def(PY_DIV, [](const Term& lhs, carl::Variable::Arg rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
+        .def("__truediv__", [](const Term& lhs, const RationalFunction& rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
+        .def("__truediv__", [](const Term& lhs, const Polynomial& rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
+        .def("__truediv__", [](const Term& lhs, const Term& rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
+        .def("__truediv__", [](const Term& lhs, const Monomial::Arg& rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
+        .def("__truediv__", [](const Term& lhs, carl::Variable::Arg rhs) { return RationalFunction(Polynomial(lhs)) / rhs; })
         .def(py::self / Rational())
 
         .def("__pow__", [](const Term& var, carl::uint exp) { return var.pow(exp); })

src/pycarl/typed_formula/common.h

@@ -3,4 +3,4 @@
 #include "types.h"
 
 // toString
-#include "src/pycarl/helpers.h"
+#include "src/helpers.h"