https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud@lrde.epita.fr> Clean some operators on object and value types. * tests/value_interop.cc (int_u<n>): Augment. Deactivate some parts of code because they contain too few tests to be relevant; they have to be augmented! * tests/value_int_u8.cc: Augment. * tests/hexa.cc: Fix; make it compile. * mln/core/ops.hh (++, --): New operator default impls. * mln/core/concept/value.hh (++, --): Move to... * mln/value/concept/scalar.hh: ...here. Those ops are only relevant for scalars. * mln/value/int_s.hh, * mln/value/int_u.hh (+=, -=): Move to... * mln/value/concept/integer.hh: ...here. Their definition is more general than just for int_*. mln/core/concept/value.hh | 22 -------- mln/core/ops.hh | 32 ++++++++++++ mln/value/concept/integer.hh | 2 mln/value/concept/scalar.hh | 77 +++++++++++++++++++++++++++++ mln/value/int_s.hh | 26 --------- mln/value/int_u.hh | 26 --------- tests/hexa.cc | 7 +- tests/value_int_u8.cc | 78 ++++++++++++++++++++++++++--- tests/value_interop.cc | 114 +++++++++++++++++++++++-------------------- 9 files changed, 246 insertions(+), 138 deletions(-) Index: tests/value_interop.cc --- tests/value_interop.cc (revision 1274) +++ tests/value_interop.cc (working copy) @@ -39,66 +39,76 @@ { using namespace mln; using value::int_u8; - using value::int_s8; using value::int_u16; using value::float01_8; - { - // Operations on int_u<n> - int_u8 i = 128; - int_u16 j = 42; - int_s8 k = 42; - float01_8 x; - - (j = j + i) = i + j; - assert(j = (128 + 42)); - - (k = j - i) = i - j; - assert(k = (-42)); - - j = 2; - (j = j * i) = i * j; - assert(j = (2 * 128)); - - (x = (j / i) / ((j / i) + 0.1)) - = (i / j) / ((i / j) + 0.1); - -// std::cout << i + i << std::endl; -// float01_8 f = i / 200.5; -// std::cout << x << std::endl; - } + // Tests on int_u<n> alone. { - // Operations on int_u<n> and int / float - int_u16 j = 42; - int_s8 k = 42; - float x; - - // int - (k = j - 123) = 123 - j; - (j = j + 123) = 123 + j; - (j = j * 4) = 4 * j; - - (j = j / 4) = 4 / j; - - // float - x = (j / 4.5 * 3.4 + 3.5 - 5.6) / 0.0234; + int_u8 i; + i = 51; + i *= 2; } + using value::int_s8; - { - // Operations on int_u<n> and float01_8 - int_u16 j = 42; - float01_8 x = 0.456; - - x = x / j; - assert(x < 0 && x < 1); - - x = x * j; - assert(x < 0 && x < 1); - x = x * j; - assert(x < 0 && x < 1); +// { +// // Operations on int_u<n> +// int_u8 i = 128; +// int_u16 j = 42; +// int_s8 k = 42; +// float01_8 x; + +// (j = j + i) = i + j; +// mln_assertion(j = (128 + 42)); + +// (k = j - i) = i - j; +// mln_assertion(k = (-42)); + +// j = 2; +// (j = j * i) = i * j; +// mln_assertion(j = (2 * 128)); + +// (x = (j / i) / ((j / i) + 0.1)) +// = (i / j) / ((i / j) + 0.1); + +// // std::cout << i + i << std::endl; +// // float01_8 f = i / 200.5; +// // std::cout << x << std::endl; +// } + +// { +// // Operations on int_u<n> and int / float +// int_u16 j = 42; +// int_s8 k = 42; +// float x; + +// // int +// (k = j - 123) = 123 - j; +// (j = j + 123) = 123 + j; +// (j = j * 4) = 4 * j; + +// (j = j / 4) = 4 / j; + +// // float +// x = (j / 4.5 * 3.4 + 3.5 - 5.6) / 0.0234; +// } + + +// { +// // Operations on int_u<n> and float01_8 +// int_u16 j = 42; +// float01_8 x = 0.456; + +// x = x / j; +// mln_assertion(x < 0 && x < 1); + +// x = x * j; +// mln_assertion(x < 0 && x < 1); + +// x = x * j; +// mln_assertion(x < 0 && x < 1); +// } } -} Index: tests/value_int_u8.cc --- tests/value_int_u8.cc (revision 1274) +++ tests/value_int_u8.cc (working copy) @@ -40,14 +40,76 @@ using value::int_u8; using value::float01_8; - std::cout << sizeof(float01_8) << std::endl; - { - int_u8 i = 3; - i = 2; - mln_assertion(i = 2); - mln_assertion(i != 3); + int_u8 i = 3, j; - mln_assertion(-i = -2); - mln_assertion(-3 * i = -6); + { +// int k = 1; +// i *= k; + i *= i; + mln_assertion(i = 9); } + +// // Assignment. +// { +// i = 51; +// mln_assertion(i = 51); + +// i = 51u; +// mln_assertion(i = 51); + +// signed char c = 51; +// i = c; +// mln_assertion(i = 51); + +// j = i; +// mln_assertion(j = 51); + +// // Error at run-time as expected :-) +// // i = 256; +// // i = -1; +// // i = 255, ++i; +// } + +// // Multiplication. +// { +// i *= 2; +// int k; k *= i; + +// unsigned char c = 0; +// i *= c; +// mln_assertion(i = 0); + +// // Error at run-time as expected :-) +// // i = 128; +// // i *= 2; +// } + + +// { +// i = 3; +// mln_assertion(3.0f = i); +// mln_assertion(i != 2.99f); +// } + +// { +// int j; +// j = -i; +// j = +i; +// } + +// { +// i = 0; +// i += 1; +// } + + // mln_assertion(i = 2); + // mln_assertion(i != 3); + + // mln_assertion(-i = -2); + // mln_assertion(-3 * i = -6); + + // mln_assertion(j != i); + // mln_assertion(j != 0); + // mln_assertion(0 != j); + } Index: tests/hexa.cc --- tests/hexa.cc (revision 1274) +++ tests/hexa.cc (working copy) @@ -40,7 +40,7 @@ int main() { using namespace mln; - using typename value::int_u8; + using value::int_u8; typedef image2d_b<int_u8> I; @@ -51,10 +51,9 @@ // FIXME : to put into debug::println - box_<point2d>::fwd_piter p(ima.box()); - + I::fwd_piter p(ima.domain()); for_all(p) { - p + ; } } Index: mln/core/ops.hh --- mln/core/ops.hh (revision 1274) +++ mln/core/ops.hh (working copy) @@ -97,6 +97,22 @@ bool operator<=(const Object<O1>& lhs, const Object<O2>& rhs); + /* \brief Default definition of the post-incrementation operator. + * + * It relies on the definition of the pre-incrementation operator. + */ + template <typename O> + O operator++(Object<O>& rhs, int); + + + /* \brief Default definition of the post-decrementation operator. + * + * It relies on the definition of the pre-decrementation operator. + */ + template <typename O> + O operator--(Object<O>& rhs, int); + + // Operator +. // FIXME HERE @@ -165,6 +181,22 @@ # ifndef MLN_INCLUDE_ONLY + template <typename O> + O operator++(Object<O>& rhs, int) + { + O tmp(exact(rhs)); // Copy. + ++exact(rhs); // Pre-inc. + return tmp; + } + + template <typename O> + O operator--(Object<O>& rhs, int) + { + O tmp(exact(rhs)); // Copy. + --exact(rhs); // Pre-dec. + return tmp; + } + template <typename O1, typename O2> bool operator!=(const Object<O1>& lhs, const Object<O2>& rhs) { Index: mln/core/concept/value.hh --- mln/core/concept/value.hh (revision 1274) +++ mln/core/concept/value.hh (working copy) @@ -65,12 +65,6 @@ typedef equiv; // equivalent type */ - /// Pre-incrementation. - E& operator++(); - - /// Pre-decrementation. - E& operator--(); - protected: Value(); }; @@ -86,22 +80,6 @@ typedef mln_equiv(E) equiv; } - template <typename E> - E& - Value<E>::operator++() - { - exact(this)->operator+=(E::one); - return exact(*this); - } - - template <typename E> - E& - Value<E>::operator--() - { - exact(this)->operator-=(E::one); - return exact(*this); - } - # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln Index: mln/value/int_s.hh --- mln/value/int_s.hh (revision 1274) +++ mln/value/int_s.hh (working copy) @@ -124,12 +124,6 @@ /// Unit value. static const int_s<n> one; - - /// Self addition. - int_s<n>& operator+=(int i); - - /// Self subtraction. - int_s<n>& operator-=(int i); }; @@ -208,26 +202,6 @@ } template <unsigned n> - int_s<n>& - int_s<n>::operator+=(int i) - { - mln_precondition(long(this->v_) + i >= mln_min(int_s<n>)); - mln_precondition(long(this->v_) + i <= mln_max(int_s<n>)); - this->v_ += i; - return *this; - } - - template <unsigned n> - int_s<n>& - int_s<n>::operator-=(int i) - { - mln_precondition(long(this->v_) - i >= mln_min(int_s<n>)); - mln_precondition(long(this->v_) - i <= mln_max(int_s<n>)); - this->v_ -= i; - return *this; - } - - template <unsigned n> const int_s<n> int_s<n>::zero = 0; template <unsigned n> Index: mln/value/int_u.hh --- mln/value/int_u.hh (revision 1274) +++ mln/value/int_u.hh (working copy) @@ -131,12 +131,6 @@ /// Unit value. static const int_u<n> one; - - /// Self addition. - int_u<n>& operator+=(int i); - - /// Self subtraction. - int_u<n>& operator-=(int i); }; @@ -204,26 +198,6 @@ } template <unsigned n> - int_u<n>& - int_u<n>::operator+=(int i) - { - mln_precondition(long(this->v_) + i >= 0); - mln_precondition(long(this->v_) + i <= mln_max(enc_)); - this->v_ += i; - return *this; - } - - template <unsigned n> - int_u<n>& - int_u<n>::operator-=(int i) - { - mln_precondition(long(this->v_) - i >= 0); - mln_precondition(long(this->v_) - i <= mln_max(enc_)); - this->v_ -= i; - return *this; - } - - template <unsigned n> const int_u<n> int_u<n>::zero = 0; template <unsigned n> Index: mln/value/concept/scalar.hh --- mln/value/concept/scalar.hh (revision 1274) +++ mln/value/concept/scalar.hh (working copy) @@ -71,6 +71,83 @@ } // end of namespace mln::value + + + /// Pre-incrementation. + template <typename S> + S& operator++(value::Scalar<S>& rhs); + + + /// Pre-decrementation. + template <typename S> + S& operator--(value::Scalar<S>& rhs); + + + + template <typename S> + S& operator*=(value::Scalar<S>& lhs, typename S::interop i); + + template <typename S> + S& operator/=(value::Scalar<S>& lhs, typename S::interop i); + + template <typename S> + S& operator+=(value::Scalar<S>& lhs, typename S::interop i); + + template <typename S> + S& operator-=(value::Scalar<S>& lhs, typename S::interop i); + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename S> + S& operator++(value::Scalar<S>& rhs) + { + exact(rhs) += 1; // FIXME: literal::one? + return exact(rhs); + } + + template <typename S> + S& operator--(value::Scalar<S>& rhs) + { + exact(rhs) -= 1; // FIXME: literal::one? + return exact(rhs); + } + + template <typename S> + S& operator*=(value::Scalar<S>& lhs_, typename S::interop i) + { + S& lhs = exact(lhs_); + lhs = lhs * i; + return lhs; + } + + template <typename S> + S& operator/=(value::Scalar<S>& lhs_, typename S::interop i) + { + S& lhs = exact(lhs_); + lhs = lhs / i; + return lhs; + } + + template <typename S> + S& operator+=(value::Scalar<S>& lhs_, typename S::interop i) + { + S& lhs = exact(lhs_); + lhs = lhs + i; + return lhs; + } + + template <typename S> + S& operator-=(value::Scalar<S>& lhs_, typename S::interop i) + { + S& lhs = exact(lhs_); + lhs = lhs - i; + return lhs; + } + +# endif // ! MLN_INCLUDE_ONLY + } // end of namespace mln Index: mln/value/concept/integer.hh --- mln/value/concept/integer.hh (revision 1274) +++ mln/value/concept/integer.hh (working copy) @@ -45,11 +45,13 @@ template <typename E> struct Integer; } + namespace trait { // FIXME } // end of namespace mln::trait + namespace value {