[Toon-members] TooN/internal reference.hh

[Edward Rosten]

CVSROOT:        /cvsroot/toon
Module name:    TooN
Changes by:     Edward Rosten <edrosten>        09/06/03 19:36:53

Modified files:
        internal       : reference.hh 

Log message:
        Wrapping of matrices.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/TooN/internal/reference.hh?cvsroot=toon&r1=1.5&r2=1.6

Patches:
Index: reference.hh
===================================================================
RCS file: /cvsroot/toon/TooN/internal/reference.hh,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -b -r1.5 -r1.6
--- reference.hh        29 Apr 2009 22:00:17 -0000      1.5
+++ reference.hh        3 Jun 2009 19:36:52 -0000       1.6
@@ -57,7 +57,7 @@
                {
 
                        MLayout(Precision* p)
-                               : Internal::GenericMBase<Rows,Cols,Precision, 
(Cols==-1?-2:Cols), 1, Internal::MatrixSlice<Rows, Cols, Precision> > (p, 0, 0, 
0, 0)
+                               : Internal::GenericMBase<Rows,Cols,Precision, 
(Cols==-1?-2:Cols), 1, Internal::MatrixSlice<Rows, Cols, Precision> > (p)
                        {}
                        MLayout(Precision* p, int r, int c)
                                : Internal::GenericMBase<Rows,Cols,Precision, 
(Cols==-1?-2:Cols), 1, Internal::MatrixSlice<Rows, Cols, Precision> > (p, r, c, 
0, 0)
@@ -70,7 +70,7 @@
                template<int Rows, int Cols, class Precision> struct MLayout: 
public Internal::GenericMBase<Rows, Cols, Precision, 1, (Rows==-1?-2:Rows), 
Internal::MatrixSlice<Rows, Cols, Precision> >
                {
                        MLayout(Precision* p)
-                               : Internal::GenericMBase<Rows, Cols, Precision, 
1, (Rows==-1?-2:Rows), Internal::MatrixSlice<Rows, Cols, Precision> >(p, 0, 0, 
0, 0)
+                               : Internal::GenericMBase<Rows, Cols, Precision, 
1, (Rows==-1?-2:Rows), Internal::MatrixSlice<Rows, Cols, Precision> >(p)
                        {}
                        MLayout(Precision* p, int r, int c)
                                : Internal::GenericMBase<Rows, Cols, Precision, 
1, (Rows==-1?-2:Rows), Internal::MatrixSlice<Rows, Cols, Precision> >(p, r, c, 
0, 0)
@@ -80,8 +80,8 @@
 };
 
 
-inline Vector<Dynamic, double,    Reference> wrapVector(double* data, int 
size)          { return Vector<Dynamic, double,    Reference>(data, size); }
-inline const Vector<Dynamic, double,    Reference> wrapVector(const double* 
data, int size)    { return Vector<Dynamic, double,    
Reference>(const_cast<double*>(data), size); }
+                                    inline       Vector<Dynamic, double,    
Reference> wrapVector(double* data, int size)          { return Vector<Dynamic, 
double,    Reference>(data, size); }
+                                    inline const Vector<Dynamic, double,    
Reference> wrapVector(const double* data, int size)    { return Vector<Dynamic, 
double,    Reference>(const_cast<double*>(data), size); }
 template<int Size> inline Vector<Size,    double,    Reference> 
wrapVector(double* data)                    { return Vector<Size,    double,    
Reference>(data); }
 template<int Size> inline const Vector<Size,    double,    Reference> 
wrapVector(const double* data)              { return Vector<Size,    double,    
Reference>(const_cast<double*>(data)); }
 template<class Precision> inline Vector<Dynamic, Precision, Reference> 
wrapVector(Precision* data, int size)       { return Vector<Dynamic, Precision, 
Reference>(data, size); }
@@ -89,4 +89,20 @@
 template<int Size, class Precision> inline Vector<Size,    Precision, 
Reference> wrapVector(Precision* data)                 { return Vector<Size,    
Precision, Reference>(data); }
 template<int Size, class Precision> inline const Vector<Size,    Precision, 
Reference> wrapVector(const Precision* data)           { return Vector<Size,    
Precision, Reference>(const_cast<Precision*>(data)); }
 
+
+//Fully static matrices, ie no size parameters
+template<int Rows, int Cols>                  inline       Matrix<Rows, Cols,  
     double,    Reference::RowMajor> wrapMatrix(const double*    data)          
           { return Matrix<Rows, Cols, double, Reference::RowMajor>(data);}
+template<int Rows, int Cols>                  inline const Matrix<Rows, Cols,  
     double,    Reference::RowMajor> wrapMatrix(const double*    data)          
           { return Matrix<Rows, Cols, double, 
Reference::RowMajor>(const_cast<double*>(data));}
+template<int Rows, int Cols, class Precision> inline       Matrix<Rows, Cols,  
     Precision, Reference::RowMajor> wrapMatrix(const Precision* data)          
           { return Matrix<Rows, Cols, Precision, Reference::RowMajor>(data);}
+template<int Rows, int Cols, class Precision> inline const Matrix<Rows, Cols,  
     Precision, Reference::RowMajor> wrapMatrix(const Precision* data)          
           { return Matrix<Rows, Cols, Precision, 
Reference::RowMajor>(const_cast<Precision*>(data));}
+//Static sizes with size parameters (useful for half-dynamic matrices)
+template<int Rows, int Cols>                  inline       Matrix<Rows, Cols,  
     double,    Reference::RowMajor> wrapMatrix(const double*    data, int 
rows, int cols) { return Matrix<Rows, Cols, double, Reference::RowMajor>(data, 
rows, cols);}
+template<int Rows, int Cols>                  inline const Matrix<Rows, Cols,  
     double,    Reference::RowMajor> wrapMatrix(const double*    data, int 
rows, int cols) { return Matrix<Rows, Cols, double, 
Reference::RowMajor>(const_cast<double*>(data), rows, cols);}
+template<int Rows, int Cols, class Precision> inline       Matrix<Rows, Cols,  
     Precision, Reference::RowMajor> wrapMatrix(const Precision* data, int 
rows, int cols) { return Matrix<Rows, Cols, Precision, 
Reference::RowMajor>(data, rows, cols);}
+template<int Rows, int Cols, class Precision> inline const Matrix<Rows, Cols,  
     Precision, Reference::RowMajor> wrapMatrix(const Precision* data, int 
rows, int cols) { return Matrix<Rows, Cols, Precision, 
Reference::RowMajor>(const_cast<Precision*>(data), rows, cols);}
+//Fully dynamic
+                                              inline       Matrix<Dynamic, 
Dynamic, double,    Reference::RowMajor> wrapMatrix(double*          data, int 
rows, int cols) { return Matrix<Dynamic, Dynamic, double, 
Reference::RowMajor>(data, rows, cols);}
+                                              inline const Matrix<Dynamic, 
Dynamic, double,    Reference::RowMajor> wrapMatrix(const double*    data, int 
rows, int cols) { return Matrix<Dynamic, Dynamic, double, 
Reference::RowMajor>(const_cast<double*>(data), rows, cols);}
+template<class Precision>                     inline       Matrix<Dynamic, 
Dynamic, Precision, Reference::RowMajor> wrapMatrix(Precision* data, int rows, 
int cols) { return Matrix<Dynamic, Dynamic, Precision, 
Reference::RowMajor>(data, rows, cols);}
+template<class Precision>                     inline const Matrix<Dynamic, 
Dynamic, Precision, Reference::RowMajor> wrapMatrix(const Precision* data, int 
rows, int cols) { return Matrix<Dynamic, Dynamic, Precision, 
Reference::RowMajor>(const_cast<Precision*>(data), rows, cols);}
 }