[Toon-members] TooN/internal allocator.hh matrix.hh mbase.hh v...

[Edward Rosten]

CVSROOT:        /cvsroot/toon
Module name:    TooN
Changes by:     Edward Rosten <edrosten>        09/03/06 15:15:17

Modified files:
        internal       : allocator.hh matrix.hh mbase.hh vbase.hh 

Log message:
        Fix the new mbase. Everything seems to compile and run correctly.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/TooN/internal/allocator.hh?cvsroot=toon&r1=1.15&r2=1.16
http://cvs.savannah.gnu.org/viewcvs/TooN/internal/matrix.hh?cvsroot=toon&r1=1.11&r2=1.12
http://cvs.savannah.gnu.org/viewcvs/TooN/internal/mbase.hh?cvsroot=toon&r1=1.16&r2=1.17
http://cvs.savannah.gnu.org/viewcvs/TooN/internal/vbase.hh?cvsroot=toon&r1=1.16&r2=1.17

Patches:
Index: allocator.hh
===================================================================
RCS file: /cvsroot/toon/TooN/internal/allocator.hh,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -b -r1.15 -r1.16
--- allocator.hh        6 Mar 2009 14:51:41 -0000       1.15
+++ allocator.hh        6 Mar 2009 15:15:13 -0000       1.16
@@ -334,6 +334,9 @@
 {
        RowStrideHolder(int i)
                :StrideHolder<S>(i){}
+
+       RowStrideHolder()
+       {}
 };
 
 
@@ -341,6 +344,9 @@
 {
        ColStrideHolder(int i)
                :StrideHolder<S>(i){}
+
+       ColStrideHolder()
+       {}
 };
 
 

Index: matrix.hh
===================================================================
RCS file: /cvsroot/toon/TooN/internal/matrix.hh,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -b -r1.11 -r1.12
--- matrix.hh   6 Mar 2009 14:51:41 -0000       1.11
+++ matrix.hh   6 Mar 2009 15:15:16 -0000       1.12
@@ -14,16 +14,13 @@
                
        Matrix(){}
 
-       Matrix(Precision* data, Slicing)
-       :Layout::template Layout<Rows, Cols, Precision>(data){}
-       
        //The stride is always passed during a slice. If it is not
        //needed, it will be ignored later and not stored.
-       Matrix(Precision* data, int stride, Slicing)
-       :Layout::template Layout<Rows, Cols, Precision>(data, stride){}
+       Matrix(Precision* data, int rowstride, int colstride, Slicing)
+       :Layout::template Layout<Rows, Cols, Precision>(data, rowstride, 
colstride){}
 
-       Matrix(Precision* data, int rows, int cols, int stride, Slicing)
-       :Layout::template Layout<Rows, Cols, Precision>(data, rows, cols, 
stride){}
+       Matrix(Precision* data, int rows, int cols, int rowstride, int 
colstride, Slicing)
+       :Layout::template Layout<Rows, Cols, Precision>(data, rows, cols, 
rowstride, colstride){}
 
        Matrix(int rows, int cols)
        :Layout::template Layout<Rows,Cols,Precision>(rows, cols)

Index: mbase.hh
===================================================================
RCS file: /cvsroot/toon/TooN/internal/mbase.hh,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -b -r1.16 -r1.17
--- mbase.hh    6 Mar 2009 14:51:41 -0000       1.16
+++ mbase.hh    6 Mar 2009 15:15:16 -0000       1.17
@@ -3,6 +3,7 @@
 // the same as num_cols/num_rows, which must be dynamically sized.
 
 template<int,int,class,class> class Matrix;
+template<int, int, class, int, int, class> class GenericMBase;
 
 
////////////////////////////////////////////////////////////////////////////////
 //Closure used to acquire strides
@@ -10,28 +11,16 @@
 //-2 means dynamic stride is tied to size for a normal matrix
 template<int RowStride, int ColStride> struct Slice
 {
-       struct Layout{
+       //This can't be called Layout since apparently Layout::Layout is not
+       //allowed. Can anyone think of a better name than Base?
+       struct Base{
                template<int Rows, int Cols, class Precision> struct Layout: 
public GenericMBase<Rows, Cols, Precision, RowStride, ColStride, 
MatrixSlice<Rows, Cols, Precision> >
                {
                        //Optional constructors.
-                       
-                       Layout(Precision* p)
-                               
:GenericMBase<Rows,Cols,Precision,RowStride,ColStride,MatrixSlice<Rows, Cols, 
Precision> >(p)
-                       {
-                       }
-                       
-#if 0
-                       Layout(Precision* p, int stride)
-                               
:GenericRowMajor<Rows,Cols,Precision,Stride,MatrixSlice<Rows, Cols, Precision> 
>(p, stride)
-                       {
-                       }
-                       
-                       Layout(Precision* p, int rows, int cols)
-                               
:GenericRowMajor<Rows,Cols,Precision,Stride,MatrixSlice<Rows, Cols, Precision> 
>(p, rows, cols)
+                       Layout(Precision* p, int rowstride, int colstride)
+                               
:GenericMBase<Rows,Cols,Precision,RowStride,ColStride,MatrixSlice<Rows, Cols, 
Precision> >(p, rowstride, colstride)
                        {
                        }
-#endif         
-                       
                        
                        Layout(Precision* p, int rows, int cols, int rowstride, 
int colstride)
                                
:GenericMBase<Rows,Cols,Precision,RowStride,ColStride,MatrixSlice<Rows, Cols, 
Precision> >(p, rows, cols, rowstride, colstride)
@@ -49,28 +38,28 @@
 //
 struct RowMajor
 {
-       template<int Rows, int Cols, class Precision> struct Layout: public 
GenericRowMajor<Rows, Cols, Precision, (Cols==-1?-2:Cols), MatrixAlloc<Rows, 
Cols, Precision> >
+       template<int Rows, int Cols, class Precision> struct Layout: public 
GenericMBase<Rows, Cols, Precision, (Cols==-1?-2:Cols), 1, MatrixAlloc<Rows, 
Cols, Precision> >
        {
                //Optional constructors.
                
                Layout(){}
 
                Layout(int rows, int cols)
-               :GenericRowMajor<Rows, Cols, Precision, (Cols == -1 ? -2 : 
Cols), MatrixAlloc<Rows, Cols, Precision> >(rows, cols)
+               :GenericMBase<Rows, Cols, Precision, (Cols == -1 ? -2 : Cols), 
1, MatrixAlloc<Rows, Cols, Precision> >(rows, cols)
                {}
        };
 };
 
 struct ColMajor
 {
-       template<int Rows, int Cols, class Precision> struct Layout: public 
GenericColMajor<Rows, Cols, Precision, (Rows==-1?-2:Rows), MatrixAlloc<Rows, 
Cols, Precision> >
+       template<int Rows, int Cols, class Precision> struct Layout: public 
GenericMBase<Rows, Cols, Precision, 1, (Rows==-1?-2:Rows), MatrixAlloc<Rows, 
Cols, Precision> >
        {
                //Optional constructors.
                
                Layout(){}
 
                Layout(int rows, int cols)
-               :GenericColMajor<Rows, Cols, Precision, (Rows == -1 ? -2 : 
Rows), MatrixAlloc<Rows, Cols, Precision> >(rows, cols)
+               :GenericMBase<Rows, Cols, Precision, 1, (Rows == -1 ? -2 : 
Rows), MatrixAlloc<Rows, Cols, Precision> >(rows, cols)
                {}
        };
 };
@@ -102,31 +91,21 @@
 
        int colstride() const {
                if(ColStride == -2) { //Normal tied stride
-                       return num_row();
+                       return num_rows();
                } else {
                        return ColStrideHolder<ColStride>::stride();
                }
        }
 
        //Optional constructors
-       GenericMBaser(){}
-
-       GenericMBase(Precision* p)
-       :Mem(p) {}
-
-       // We think we don't need these any more
-#if 0
-       GenericRowMajor(Precision* p, int s)
-       :Mem(p),StrideHolder<Stride>(s) {}
-
-       GenericRowMajor(Precision* p, int r, int c)
-       :Mem(p, r, c) {}
-#endif
+       GenericMBase(){}
 
+       GenericMBase(Precision* p, int rs, int cs)
+       :Mem(p),RowStrideHolder<RowStride>(rs),ColStrideHolder<ColStride>(cs) {}
 
        GenericMBase(Precision* p, int r, int c, int rowstride, int colstride)
        :Mem(p, r, c),
-        RowStrideHolder<RowStride>(rowstride) 
+        RowStrideHolder<RowStride>(rowstride),
         ColStrideHolder<ColStride>(colstride) 
        {}
 
@@ -161,42 +140,42 @@
 
 
        template<int Rstart, int Cstart, int Rlength, int Clength>
-       Matrix<Rlength, Clength, Precision, typename 
Slice<SliceRowStride,SliceColStride> > slice()
+       Matrix<Rlength, Clength, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Base > slice()
        {
                //Always pass the stride as a run-time parameter. It will be 
ignored
                //by SliceHolder (above) if it is statically determined.
                Internal::CheckStaticSlice<Rows, Rstart, 
Rlength>::check(num_rows());
                Internal::CheckStaticSlice<Cols, Cstart, 
Clength>::check(num_cols());
-               return Matrix<Rlength, Clength, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Layout>(my_data+rowstride()*Rstart + 
colstride()*Cstart, rowstride(), colstride(), Slicing());
+               return Matrix<Rlength, Clength, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Base>(my_data+rowstride()*Rstart + 
colstride()*Cstart, rowstride(), colstride(), Slicing());
        }
 
        template<int Rstart, int Cstart, int Rlength, int Clength>
-       const Matrix<Rlength, Clength, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Layout> slice() const
+       const Matrix<Rlength, Clength, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Base> slice() const
        {
                Internal::CheckStaticSlice<Rows, Rstart, 
Rlength>::check(num_rows());
                Internal::CheckStaticSlice<Cols, Cstart, 
Clength>::check(num_cols());
-               return Matrix<Rlength, Clength, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Layout>(const_cast<Precision*>(my_data+rowstride()*Rstart
 + colstride()*Cstart), rowstride(), colstride(), Slicing());
+               return Matrix<Rlength, Clength, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Base>(const_cast<Precision*>(my_data+rowstride()*Rstart
 + colstride()*Cstart), rowstride(), colstride(), Slicing());
        }
 
-       Matrix<-1, -1, Precision, typename 
Slice<SliceRowStride,SliceColStride>::RowMajor > slice(int rs, int cs, int rl, 
int cl){
+       Matrix<-1, -1, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Base > slice(int rs, int cs, int rl, int 
cl){
                Internal::CheckDynamicSlice::check(num_rows(), rs, rl);
                Internal::CheckDynamicSlice::check(num_cols(), cs, cl);
-               return Matrix<-1, -1, Precision, typename 
Slice<SliceRowStride,SliceColStride>::RowMajor >(my_data+rowstride()*rs 
+colstride()*cs, rl, cl, rowstride(), colstride(), Slicing());
+               return Matrix<-1, -1, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Base >(my_data+rowstride()*rs 
+colstride()*cs, rl, cl, rowstride(), colstride(), Slicing());
        }
 
-       const Matrix<-1, -1, Precision, typename 
Slice<SliceRowStride,SliceColStride>::RowMajor > slice(int rs, int cs, int rl, 
int cl) const {
+       const Matrix<-1, -1, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Base > slice(int rs, int cs, int rl, int 
cl) const {
                Internal::CheckDynamicSlice::check(num_rows(), rs, rl);
                Internal::CheckDynamicSlice::check(num_cols(), cs, cl);
-               return Matrix<-1, -1, Precision, typename 
Slice<SliceRowStride,SliceColStride>::RowMajor 
>(const_cast<Precision*>(my_data+stride()*rs +colstride()*cs), rl, cl, 
rowstride(), colstride(), Slicing());
+               return Matrix<-1, -1, Precision, typename 
Slice<SliceRowStride,SliceColStride>::Base 
>(const_cast<Precision*>(my_data+rowstride()*rs +colstride()*cs), rl, cl, 
rowstride(), colstride(), Slicing());
        }
 
 
-       Matrix<Cols, Rows, Precision, typename 
Slice<SliceColStride,SliceRowStride>::Layout> T(){
-               return Matrix<Cols, Rows, Precision, typename 
Slice<SliceColStride,SliceRowStride>::Layout>(my_data, num_cols(), num_rows(), 
colstride(), rowstride(), Slicing());
+       Matrix<Cols, Rows, Precision, typename 
Slice<SliceColStride,SliceRowStride>::Base> T(){
+               return Matrix<Cols, Rows, Precision, typename 
Slice<SliceColStride,SliceRowStride>::Base>(my_data, num_cols(), num_rows(), 
colstride(), rowstride(), Slicing());
        }
 
-       const Matrix<Cols, Rows, Precision, typename 
Slice<SliceColStride,SliceRowStride>::Layout> T() const{
-               return Matrix<Cols, Rows, Precision, typename 
Slice<SliceColStride,SliceRowStride>::Layout>(const_cast<Precision*>(my_data), 
num_cols(), num_rows(), colstride(), rowstride(), Slicing());
+       const Matrix<Cols, Rows, Precision, typename 
Slice<SliceColStride,SliceRowStride>::Base> T() const{
+               return Matrix<Cols, Rows, Precision, typename 
Slice<SliceColStride,SliceRowStride>::Base>(const_cast<Precision*>(my_data), 
num_cols(), num_rows(), colstride(), rowstride(), Slicing());
        }
 };
 

Index: vbase.hh
===================================================================
RCS file: /cvsroot/toon/TooN/internal/vbase.hh,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -b -r1.16 -r1.17
--- vbase.hh    6 Mar 2009 14:51:41 -0000       1.16
+++ vbase.hh    6 Mar 2009 15:15:16 -0000       1.17
@@ -110,19 +110,19 @@
                return Vector<-1, Precision, SliceVBase<Stride> 
>(const_cast<Precision*>(my_data + stride()*start), length, stride(), 
Slicing());
        }
 
-       const Matrix<1, Size, Precision, typename Slice<1,Stride>::Layout> 
as_row() const{
-               return Matrix<1, Size, Precision, typename 
Slice<1,Stride>::Layout>(const_cast<Precision*>(my_data), 1, Size, 1, stride(), 
Slicing());
+       const Matrix<1, Size, Precision, typename Slice<1,Stride>::Base> 
as_row() const{
+               return Matrix<1, Size, Precision, typename 
Slice<1,Stride>::Base>(const_cast<Precision*>(my_data), 1, Size, 1, stride(), 
Slicing());
        }
 
-       Matrix<1, Size, Precision, typename Slice<1,Stride>::Layout> as_row(){
-               return Matrix<1, Size, Precision, typename 
Slice<1,Stride>::Layout>(my_data, 1, Size, 1, stride(), Slicing());
+       Matrix<1, Size, Precision, typename Slice<1,Stride>::Base> as_row(){
+               return Matrix<1, Size, Precision, typename 
Slice<1,Stride>::Base>(my_data, 1, Size, 1, stride(), Slicing());
        }
 
-       const Matrix<Size, 1, Precision, typename Slice<Stride,1>::Layout> 
as_col() const{
-               return Matrix<Size, 1, Precision, typename 
Slice<Stride,1>::Layout>(const_cast<Precision*>(my_data), Size, 1, stride(), 1, 
Slicing());
+       const Matrix<Size, 1, Precision, typename Slice<Stride,1>::Base> 
as_col() const{
+               return Matrix<Size, 1, Precision, typename 
Slice<Stride,1>::Base>(const_cast<Precision*>(my_data), Size, 1, stride(), 1, 
Slicing());
        }
 
-       Matrix<Size, 1, Precision, typename Slice<Stride,1>::Layout> as_col(){
-               return Matrix<Size, 1, Precision, typename 
Slice<Stride,1>::Layout>(my_data, Size, 1, stride(), 1, Slicing());
+       Matrix<Size, 1, Precision, typename Slice<Stride,1>::Base> as_col(){
+               return Matrix<Size, 1, Precision, typename 
Slice<Stride,1>::Base>(my_data, Size, 1, stride(), 1, Slicing());
        }
 };