Boost logo

Glas :

Re: [glas] Skalar-Like concepts from GLAS and MTL

From: Peter Gottschling (pgottsch_at_[hidden])
Date: 2005-05-26 18:12:59

On May 26, 2005, at 2:30 AM, Toon Knapen wrote:

> Here I am again. I have a bit further experimented in the direction of
> Peter's proposal and it seems to work out nice. I've been
> concentrating on the pure algebraic concepts (up until Group) for the
> moment. I've uploaded the updated concepts here:
> Let me comment on the main points of the changes:
> 1) Magma is not a refinement of Assignable (anymore). Instead probably
> we need to add the requirement that the set is a refinment of
> Assigneable.
> 2) In the Magma I added the definition of the type of the 'operator'
> saying that it is a BinaryFunctor.
Agreed, multi-type concepts require more specific refinements than I
proposed. I corrected this in the attached file.

> 3) inverse and identity are functors as well that depend on the type
> of the Set as well as on the operation. Since the inverse and identity
> are also dependent on the 'value_type', the inverse function is able
> to return identity-matrices, scalars or whatever.
This is a very good idea because it provides more flexibility. Functors
can be used for different types. If the identity is not part of a
functor, operator alone could be templated instead of the whole class
(because the compiler can use the parameters for the instantiation).
Toon's example would look like this

   struct ScalarAdd
    template < class T >
    T operator()(const T& a, const T& b) const
     { return a + b ; }
   } ;

On the other hand, it might complicate programming with these concepts
a little by introducing two types more (which should be mentioned in
the 'associated types' subsection of the concepts). We shall write some
more examples and/or adapt the examples in my paper to this. I don't
know yet, which version I prefer and we should discuss this further.

> 4) Note that identity is also a meta-function
> 5) I have made changes up to Group and also added two examples (which
> can easily be compiled with boost-build) which show the use of
> 'identity' and 'inverse'.
> I would like to change all higher-level concepts accordingly but first
> I'm going to wait for some feedback to know if we're synced and going
> in the right direction.
> BTW, I mention Assigneable above but I'm also thinking about what we
> should do with EqualityComparable. Would'nt it be good to introduce an
> equality operation that takes a tolerance into account?

This might be convenient in many situations working with floating
points but we should be very careful with this. Adding a tolerance
windows breaks the transitivity
  a==b and b==c does not imply a==c

and algebraic structures wouldn't even be isomorphic to themselves
a==b and c==d does not imply op(a,c) == op(b,d)

I think this behavior would be too strange. It might be okay in special
cases but to introduce this in general looks way to dangerous to me.


Peter Gottschling
Research Associate
Open Systems Laboratory
Indiana University
301i Lindley Hall
Bloomington, IN 47405
Tel.: +1 812 855-8898 Fax: +1 812 856 0853