Glas List: 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: 
> http://glas.sourceforge.net/doc/index.html.
>
> 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



------------
Peter Gottschling
Research Associate
Open Systems Laboratory
Indiana University
301i Lindley Hall
Bloomington, IN 47405
Tel.: [phone]   Fax: [phone]
http://www.osl.iu.edu/~pgottsch