123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175 |
- // Copyright David Abrahams 2002.
- // Distributed under the Boost Software License, Version 1.0. (See
- // accompanying file LICENSE_1_0.txt or copy at
- // http://www.boost.org/LICENSE_1_0.txt)
- #include <boost/python/operators.hpp>
- #include <boost/python/class.hpp>
- #include <boost/python/module.hpp>
- #include <boost/python/def.hpp>
- #include "test_class.hpp"
- #include <boost/python/module.hpp>
- #include <boost/python/class.hpp>
- #include <boost/python/operators.hpp>
- #include <boost/operators.hpp>
- //#include <boost/python/str.hpp>
- // Just use math.h here; trying to use std::pow() causes too much
- // trouble for non-conforming compilers and libraries.
- #include <math.h>
- #if __GNUC__ != 2
- # include <ostream>
- #else
- # include <ostream.h>
- #endif
- using namespace boost::python;
- using namespace boost::python;
- struct X : test_class<>
- {
- typedef test_class<> base_t;
-
- X(int x) : base_t(x) {}
- X const operator+(X const& r) const { return X(value() + r.value()); }
-
- // typedef int (X::*safe_bool)() const;
- // operator safe_bool() const { return value() != 0 ? &X::value : 0; }
- };
- X operator-(X const& l, X const& r) { return X(l.value() - r.value()); }
- X operator-(int l, X const& r) { return X(l - r.value()); }
- X operator-(X const& l, int r) { return X(l.value() - r); }
- X operator-(X const& x) { return X(-x.value()); }
- X& operator-=(X& l, X const& r) { l.set(l.value() - r.value()); return l; }
- bool operator<(X const& x, X const& y) { return x.value() < y.value(); }
- bool operator<(X const& x, int y) { return x.value() < y; }
- bool operator<(int x, X const& y) { return x < y.value(); }
- X abs(X x) { return X(x.value() < 0 ? -x.value() : x.value()); }
- X pow(X x, int y)
- {
- return X(int(pow(double(x.value()), double(y))));
- }
- X pow(X x, X y)
- {
- return X(int(pow(double(x.value()), double(y.value()))));
- }
- int pow(int x, X y)
- {
- return int(pow(double(x), double(y.value())));
- }
- std::ostream& operator<<(std::ostream& s, X const& x)
- {
- return s << x.value();
- }
- struct number
- : boost::integer_arithmetic<number>
- {
- explicit number(long x_) : x(x_) {}
- operator long() const { return x; }
- template <class T>
- number& operator+=(T const& rhs)
- { x += rhs; return *this; }
- template <class T>
- number& operator-=(T const& rhs)
- { x -= rhs; return *this; }
-
- template <class T>
- number& operator*=(T const& rhs)
- { x *= rhs; return *this; }
-
- template <class T>
- number& operator/=(T const& rhs)
- { x /= rhs; return *this; }
-
- template <class T>
- number& operator%=(T const& rhs)
- { x %= rhs; return *this; }
- long x;
- };
- BOOST_PYTHON_MODULE(operators_ext)
- {
- class_<X>("X", init<int>())
- .def("value", &X::value)
- .def(self + self)
- .def(self - self)
- .def(self - int())
- .def(other<int>() - self)
- .def(-self)
- .def(self < other<int>())
- .def(self < self)
- .def(1 < self)
- .def(self -= self)
- .def(abs(self))
- .def(str(self))
-
- .def(pow(self,self))
- .def(pow(self,int()))
- .def(pow(int(),self))
- .def(
- !self
- // "not self" is legal here but causes friction on a few
- // nonconforming compilers; it's cute because it looks
- // like python, but doing it here doesn't prove much and
- // just causes tests to fail or complicated workarounds to
- // be enacted.
- )
- ;
- class_<number>("number", init<long>())
- // interoperate with self
- .def(self += self)
- .def(self + self)
- .def(self -= self)
- .def(self - self)
- .def(self *= self)
- .def(self * self)
- .def(self /= self)
- .def(self / self)
- .def(self %= self)
- .def(self % self)
- // Convert to Python int
- .def(int_(self))
- // interoperate with long
- .def(self += long())
- .def(self + long())
- .def(long() + self)
- .def(self -= long())
- .def(self - long())
- .def(long() - self)
- .def(self *= long())
- .def(self * long())
- .def(long() * self)
- .def(self /= long())
- .def(self / long())
- .def(long() / self)
- .def(self %= long())
- .def(self % long())
- .def(long() % self)
- ;
-
- class_<test_class<1> >("Z", init<int>())
- .def(int_(self))
- .def(float_(self))
- .def(complex_(self))
- ;
- }
- #include "module_tail.cpp"
|