Re: [boost] Re: operators.hpp issue

From: David Abrahams (david.abrahams_at_[hidden])
Date: 2001-08-21 15:58:37

----- Original Message -----
From: <helmut.zeisel_at_[hidden]>

> Long time ago I asked whether  operator.hpp could
> support the other version of non-commutative operators like
>
> friend T operator-(const U& x, const T& y)
> {
>   T x1(x);
>   return x1 -= y;
> }

I think it's a good idea, though I don't remember if I had any objections
earlier ;-).
If the intention of your email is to ask again whether your changes can be
incorporated, then I'll ask again for a proposed patch (including
documentation). A code snippet like you have supplied below is pretty good,
but I'm sorry to say that I don't have time to figure out where it should go
in the header. A patch would be much better.

Thanks,
Dave

> --- In boost_at_y..., "David Abrahams" <david.abrahams_at_r...> wrote:
> >
> > ----- Original Message -----
> > From: <helmut.zeisel_at_a...>
> >
> > > I would appreciate an additional related
> > > family of operator templates.
> >
> > Why don't you submit a proposed patch (including one for the
> documentation)?
>
> Below are the additional operators struct
> I use in my current implementation of big_int
> (already using the additions of Daryle Walker
> from May 2001 to operators.hpp).
>
> subtractable2_left, dividable2_left and
> ordered_field_operators
> could also be used to simply interfaces such as rational.hpp.
>
> For the structs you accept for operators.hpp,
> I will add the necessary documentation.
> If you prefer different names for some structs,
> it will probably be no problem for me.
>
> Helmut
>
> template <class T,class B=::boost::detail::empty_base>
> struct ring_operators1
>     : additive1<T
>     , multipliable1<T, B
>       > > {};
>
> template <class T,class B=::boost::detail::empty_base>
> struct field_operators1
>     : additive1<T
>     , multiplicative1<T, B
>       > > {};
>
> template <class T,class B=::boost::detail::empty_base>
> struct ordered_field_operators1
>     : field_operators1<T
>     , totally_ordered1<T, B
>       > > {};
>
> template <class T,class B=::boost::detail::empty_base>
> struct euclidian_ring_operators1
>     : ring_operators1<T
>     , dividable1<T
>     , modable1<T,B
>       > > > {};
>
> template <class T,class B=::boost::detail::empty_base>
> struct integer_operators1
>     : totally_ordered1<T
>     , euclidian_ring_operators1<T
>     , unit_steppable<T,B
>       > > > {};
>
> template <class T,class B=::boost::detail::empty_base>
> struct bitwise_integer_operators1
>     : integer_operators1<T
>     , bitwise1<T,B
>       > > {};
>
> //
> // "left" means that the argument of other class U
> // is applied from left.
> //
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct subtractable2_left : B
> {
>   friend T operator-(const U& x, const T& y)
>   { T result(x); return result -= y; }
> };
>
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct dividable2_left : B
> {
>   friend T operator/(const U& x, const T& y)
>   { T result(x); return result /= y; }
> };
>
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct modable2_left : B
> {
>   friend T operator%(const U& x, const T& y)
>   { T result(x); return result %= y; }
> };
>
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct ring_operators2
>     : additive2<T,U
>     , subtractable2_left<T,U
>     , multipliable2<T,U,B
>       > > > {};
>
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct field_operators2
>     : ring_operators2<T,U
>     , dividable2<T,U
>     , dividable2_left<T,U,B
>       > > > {};
>
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct ordered_field_operators2
>     : field_operators2<T,U
>     , totally_ordered2<T,U,B
>       > > {};
>
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct euclidian_ring_operators2
>     : ring_operators2<T,U
>     , dividable2<T,U
>     , dividable2_left<T,U
>     , modable2<T,U
>     , modable2_left<T,U,B
>       > > > > > {};
>
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct integer_operators2
>     : totally_ordered2<T,U
>     , euclidian_ring_operators2<T,U,B
>       > > {};
>
> template <class T, class U, class B = ::boost::detail::empty_base>
> struct bitwise_integer_operators2
>     : integer_operators2<T,U
>     , bitwise2<T,U,B
>       > > {};
>
>
> Info: http://www.boost.org  Unsubscribe:
<mailto:boost-unsubscribe_at_[hidden]>
>
> Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/
>
>
>