[Toon-members] TooN/internal objects.h

[Edward Rosten]

CVSROOT:        /cvsroot/toon
Module name:    TooN
Changes by:     Edward Rosten <edrosten>        09/04/30 12:24:28

Modified files:
        internal       : objects.h 

Log message:
        Added the concept of scalable operators. Identity and Scalars are now 
        scalable operators.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/TooN/internal/objects.h?cvsroot=toon&r1=1.4&r2=1.5

Patches:
Index: objects.h
===================================================================
RCS file: /cvsroot/toon/TooN/internal/objects.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -b -r1.4 -r1.5
--- objects.h   29 Apr 2009 22:04:04 -0000      1.4
+++ objects.h   30 Apr 2009 12:24:28 -0000      1.5
@@ -116,15 +116,20 @@
 template<class Precision> struct Operator<Internal::SizedIdentity<Precision> > 
        : public  Operator<Internal::Identity<Precision> > {
 
-       const Precision val;
+       using Operator<Internal::Identity<Precision> >::val;
        const int my_size;
 
        Operator(int s, const Precision& v=1)
-               :my_size(s),val(v)
+               :Operator<Internal::Identity<Precision> > (v), my_size(s)
        {}
 
        int num_rows() const {return my_size;}
        int num_cols() const {return my_size;}
+
+       template<class Pout, class Pmult> 
Operator<Internal::SizedIdentity<Pout> > scale_me(const Pmult& m) const
+       {
+               return Operator<Internal::SizedIdentity<Pout> >(my_size, val*m);
+       }
 };
 
 template<class Precision> struct Operator<Internal::Identity<Precision> > {
@@ -152,27 +157,12 @@
        Operator<Internal::SizedIdentity<Precision> > operator()(int s){
                return Operator<Internal::SizedIdentity<Precision> >(s);
        }
-};
-       
-template<class P1, class P2> Operator<Internal::Identity<typename 
Internal::MultiplyType<P1, P2>::type> > operator*(const P1& p, const 
Operator<Internal::Identity<P2> >& i)
-{
-       return Operator<Internal::Identity<typename Internal::MultiplyType<P1, 
P2>::type> >(p * i.val);
-}
-
-template<class P1, class P2> Operator<Internal::Identity<typename 
Internal::MultiplyType<P1, P2>::type> > operator*(const 
Operator<Internal::Identity<P2> >& i, const P1&p)
-{
-       return Operator<Internal::Identity<typename Internal::MultiplyType<P1, 
P2>::type> >(p * i.val);
-}
 
-template<class P1, class P2> Operator<Internal::SizedIdentity<typename 
Internal::MultiplyType<P1, P2>::type> > operator*(const P1& p, const 
Operator<Internal::SizedIdentity<P2> >& i)
-{
-       return Operator<Internal::SizedIdentity<typename 
Internal::MultiplyType<P1, P2>::type> >(i.my_size, p * i.val);
-}
-
-template<class P1, class P2> Operator<Internal::SizedIdentity<typename 
Internal::MultiplyType<P1, P2>::type> > operator*(const 
Operator<Internal::SizedIdentity<P2> >& i, const P1&p)
-{
-       return Operator<Internal::SizedIdentity<typename 
Internal::MultiplyType<P1, P2>::type> >(i.my_size, p * i.val);
-}
+       template<class Pout, class Pmult> Operator<Internal::Identity<Pout> > 
scale_me(const Pmult& m) const
+       {
+               return Operator<Internal::Identity<Pout> >(val*m);
+       }
+};
        
 
////////////////////////////////////////////////////////////////////////////////
 //
@@ -299,10 +289,16 @@
        {
                return Operator<Internal::RCScalars<Precision> > (s,r,c);
        }
+
+       template<class Pout, class Pmult> Operator<Internal::Scalars<Pout> > 
scale_me(const Pmult& m) const
+       {
+               return Operator<Internal::Scalars<Pout> >(s*m);
+       }
 };
 
 template<class P> struct Operator<Internal::SizedScalars<P> >: public 
Operator<Internal::Scalars<P> >
 {
+       using Operator<Internal::Scalars<P> >::s;
        const int my_size;
        int size() const {
                return my_size;
@@ -311,6 +307,11 @@
        Operator(P s, int sz)
                :Operator<Internal::Scalars<P> >(s),my_size(sz){}
                
+       template<class Pout, class Pmult> Operator<Internal::SizedScalars<Pout> 
> scale_me(const Pmult& m) const
+       {
+               return Operator<Internal::SizedScalars<Pout> >(s*m, my_size);
+       }
+
 private:
        void operator()(int);
        void operator()(int,int);
@@ -320,6 +321,7 @@
 
 template<class P> struct Operator<Internal::RCScalars<P> >: public 
Operator<Internal::Scalars<P> >
 {
+       using Operator<Internal::Scalars<P> >::s;
        const int my_rows, my_cols;
        int num_rows() const {
                return my_rows;
@@ -332,57 +334,42 @@
                :Operator<Internal::Scalars<P> >(s),my_rows(r),my_cols(c)
        {}
                
+       template<class Pout, class Pmult> Operator<Internal::RCScalars<Pout> > 
scale_me(const Pmult& m) const
+       {
+               return Operator<Internal::RCScalars<Pout> >(s*m, my_rows, 
my_cols);
+       }
+
 private:
        void operator()(int);
        void operator()(int,int);
 };
        
-template<class Pl, class Pr> 
-Operator<Internal::Scalars<typename Internal::MultiplyType<Pl, Pr>::type > >
-operator*(const Pl& l, const Operator<Internal::Scalars<Pr> >& r)
-{
-       return Operator<Internal::Scalars<typename Internal::MultiplyType<Pl, 
Pr>::type > >(l * r.s);
-}
-
        
-template<class Pl, class Pr> 
-Operator<Internal::Scalars<typename Internal::MultiplyType<Pl, Pr>::type > >
-operator*(const Operator<Internal::Scalars<Pl> >& l, const Pr& r)
-{
-       return Operator<Internal::Scalars<typename Internal::MultiplyType<Pl, 
Pr>::type > >(l.s * r);
-}
-
-       
-template<class Pl, class Pr> 
-Operator<Internal::SizedScalars<typename Internal::MultiplyType<Pl, Pr>::type 
> >
-operator*(const Pl& l, const Operator<Internal::SizedScalars<Pr> >& r)
-{
-       return Operator<Internal::SizedScalars<typename 
Internal::MultiplyType<Pl, Pr>::type > >(l * r.s, r.my_size);
-}
+////////////////////////////////////////////////////////////////////////////////
+//
+// How to scale scalable operators
+//
        
-template<class Pl, class Pr> 
-Operator<Internal::SizedScalars<typename Internal::MultiplyType<Pl, Pr>::type 
> >
-operator*(const Operator<Internal::SizedScalars<Pl> >& l, const Pr& r)
+template<template<class> class Op, class Pl, class Pr> 
+Operator<Op<typename Internal::MultiplyType<Pl, Pr>::type > >
+operator*(const Pl& l, const Operator<Op<Pr> >& r)
 {
-       return Operator<Internal::SizedScalars<typename 
Internal::MultiplyType<Pl, Pr>::type > >(l.s * r, l.my_size);
+       return r.template scale_me<typename Internal::MultiplyType<Pl, 
Pr>::type, Pl>(l); 
 }
 
-       
-template<class Pl, class Pr> 
-Operator<Internal::RCScalars<typename Internal::MultiplyType<Pl, Pr>::type > >
-operator*(const Pl& l, const Operator<Internal::RCScalars<Pr> >& r)
+template<template<class> class Op, class Pl, class Pr> 
+Operator<Op<typename Internal::MultiplyType<Pl, Pr>::type > >
+operator*(const Operator<Op<Pl> >& l, const Pr&  r)
 {
-       return Operator<Internal::RCScalars<typename Internal::MultiplyType<Pl, 
Pr>::type > >(l * r.s, r.my_rows, r.my_cols);
+       return l.template scale_me<typename Internal::MultiplyType<Pl, 
Pr>::type, Pl>(r); 
 }
        
-template<class Pl, class Pr> 
-Operator<Internal::RCScalars<typename Internal::MultiplyType<Pl, Pr>::type > >
-operator*(const Operator<Internal::RCScalars<Pl> >& l, const Pr& r)
+template<template<class> class Op, class Pl, class Pr> 
+Operator<Op<typename Internal::MultiplyType<Pl, Pr>::type > >
+operator/(const Operator<Op<Pl> >& l, const Pr&  r)
 {
-       return Operator<Internal::RCScalars<typename Internal::MultiplyType<Pl, 
Pr>::type > >(l.s * r, l.my_rows, l.my_cols);
+       return l.template scale_me<typename Internal::MultiplyType<Pl, 
Pr>::type, Pl>(1/r); 
 }
-
-
 /**This function us used to add a scalar to every element of a vector or
    matrix. For example:
    @code