[Toon-members] TooN maccessor.hh mbase.hh vaccessor.hh vbase.h...

[Ethan Eade]

CVSROOT:        /cvsroot/toon
Module name:    TooN
Changes by:     Ethan Eade <ethaneade>  07/01/15 18:19:34

Modified files:
        .              : maccessor.hh mbase.hh vaccessor.hh vbase.hh 
                         vclasses.hh 

Log message:
        A few random fixes, but mostly adding empty dummy calls so that gcc-4 
won't
        complain about reinterpret casts at compile time.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/TooN/maccessor.hh?cvsroot=toon&r1=1.9&r2=1.10
http://cvs.savannah.gnu.org/viewcvs/TooN/mbase.hh?cvsroot=toon&r1=1.8&r2=1.9
http://cvs.savannah.gnu.org/viewcvs/TooN/vaccessor.hh?cvsroot=toon&r1=1.12&r2=1.13
http://cvs.savannah.gnu.org/viewcvs/TooN/vbase.hh?cvsroot=toon&r1=1.13&r2=1.14
http://cvs.savannah.gnu.org/viewcvs/TooN/vclasses.hh?cvsroot=toon&r1=1.23&r2=1.24

Patches:
Index: maccessor.hh
===================================================================
RCS file: /cvsroot/toon/TooN/maccessor.hh,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -b -r1.9 -r1.10
--- maccessor.hh        23 Jul 2006 10:17:11 -0000      1.9
+++ maccessor.hh        15 Jan 2007 18:19:34 -0000      1.10
@@ -339,275 +339,289 @@
 #define TOON_CHECK_COL TOON_ASSERT(c < Cols && c >= 0, TooNError::BadColIndex)
 
 
-template <int Rows,int Cols, class AllocZone>
-class FixedMAccessor<Rows,Cols,RowMajor,AllocZone> : public AllocZone {
- public:
-  inline FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >& operator[](int 
r) TOON_THROW {
+
+
+template<int Rows, int Cols, int Skip>
+class SkipMAccessor<Rows,Cols,Skip,RowMajor> {
+public:
+  inline FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >& operator[](int 
r) TOON_THROW{
        TOON_CHECK_ROW;
-    return reinterpret_cast<FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > 
>&>(this->my_values[r*Cols]);
+    return reinterpret_cast<FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > 
>&>(this->my_values[r*Skip]);
   }
-  inline const FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >& 
operator[](int r) const TOON_THROW {
+  inline const FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >& 
operator[](int r) const TOON_THROW{
        TOON_CHECK_ROW;
-    return reinterpret_cast<const 
FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >&>(this->my_values[r*Cols]);
+    return reinterpret_cast<const 
FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >&>(this->my_values[r*Skip]);
   }
 
-  inline double& operator()(int r, int c) TOON_THROW {
+  inline double& operator()(int r, int c) TOON_THROW
+  {
        TOON_CHECK_ROW;
        TOON_CHECK_COL;
-       return this->my_values[r*Cols+c];
+       return this->my_values[r*Skip+c];
   }
 
   inline const double& operator()(int r, int c) const TOON_THROW
   {
        TOON_CHECK_ROW;
        TOON_CHECK_COL;
-       return this->my_values[r*Cols+c];
+       return this->my_values[r*Skip+c];
   }
 
   static inline int num_rows() throw() {return Rows;}
   static inline int num_cols() throw() {return Cols;}
-  static inline int num_skip() throw() {return Cols;}
+  static inline int num_skip() throw() {return Skip;}
   typedef RowMajor layout;
 
   // Transpose operations
-  inline 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols> > >& 
T() {
-    return 
reinterpret_cast<FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols>
 > >&>(*this->my_values);
+  inline FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,ColMajor> >& T() {
+    return 
reinterpret_cast<FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,ColMajor> 
>&>(*this); 
   }
-  inline const 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols> > >& 
T() const {
-    return reinterpret_cast<const 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols> > 
>&>(*this->my_values);
+
+  inline const FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,ColMajor> >& 
T() const {
+     return reinterpret_cast<const 
FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,ColMajor> >&>(*this);
   }
 
   // slice
   template<int Rstart, int Cstart, int Rsize, int Csize>
-  inline FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Cols,RowMajor> >& 
slice(){
+  inline FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor> >& 
slice() {
+      FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor> 
>::dummy();
       util::Assert<(Rstart+Rsize <= Rows)>();
       util::Assert<(Cstart+Csize <= Cols)>();
-    return 
reinterpret_cast<FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Cols,RowMajor>
 >&>
-      (this->my_values[Rstart*Cols+Cstart]);
+    return 
reinterpret_cast<FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor>
 >&>
+      (this->my_values[Rstart*Skip+Cstart]);
   }
 
   template<int Rstart, int Cstart, int Rsize, int Csize>
-  inline const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Cols,RowMajor> >& slice() 
const {
+  inline const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor> >& slice() 
const {
+     FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor> 
>::dummy();
       util::Assert<(Rstart+Rsize <= Rows)>();
       util::Assert<(Cstart+Csize <= Cols)>();
-    return reinterpret_cast<const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Cols,RowMajor> >&>
-      (this->my_values[Rstart*Cols+Cstart]);
+    return reinterpret_cast<const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor> >&>
+      (this->my_values[Rstart*Skip+Cstart]);
   }
 
   inline RefSkipMatrixRM slice(int Rstart, int Cstart, int Rsize, int Csize) {
-    return makeRefSkipMatrixRM(Rsize, Csize, Cols, this->my_values + 
Rstart*Cols + Cstart);
+    return makeRefSkipMatrixRM(Rsize, Csize, Skip, this->my_values + 
Rstart*Skip + Cstart);
   }
 
   inline const RefSkipMatrixRM slice(int Rstart, int Cstart, int Rsize, int 
Csize) const {
-    return makeRefSkipMatrixRM(Rsize, Csize, Cols, this->my_values + 
Rstart*Cols + Cstart);
+    return makeRefSkipMatrixRM(Rsize, Csize, Skip, this->my_values + 
Rstart*Skip + Cstart);
   }
 
-};
 
+ protected:
+  double my_values[Rows*Skip];
+};
 
+template<int Rows, int Cols, int Skip> 
+class SkipMAccessor<Rows, Cols, Skip, ColMajor> {
+public:
 
-template <int Rows,int Cols, class AllocZone>
-class FixedMAccessor<Rows,Cols,ColMajor,AllocZone> : public AllocZone {
- public:
-  FixedVector<Cols, SkipAccessor<Cols, Rows> >& operator[](int r) TOON_THROW{
+  inline FixedVector<Cols, SkipAccessor<Cols, Skip> >& operator[](int r)  
TOON_THROW
+  {
        TOON_CHECK_ROW;
-    return reinterpret_cast<FixedVector<Cols, SkipAccessor<Cols, Rows> 
>&>(this->my_values[r]);
+    return reinterpret_cast<FixedVector<Cols, SkipAccessor<Cols, Skip> 
>&>(this->my_values[r]);
   }
 
-  const FixedVector<Cols, SkipAccessor<Cols, Rows> >& operator[](int r) const 
TOON_THROW{
+  inline const FixedVector<Cols, SkipAccessor<Cols, Skip> >& operator[](int r) 
const TOON_THROW{
        TOON_CHECK_ROW;
-    return reinterpret_cast<const FixedVector<Cols, SkipAccessor<Cols, Rows> 
>&>(this->my_values[r]);
+    return reinterpret_cast<const FixedVector<Cols, SkipAccessor<Cols, Skip> 
>&>(this->my_values[r]);
   }
 
   inline double& operator()(int r, int c) TOON_THROW
   {
        TOON_CHECK_ROW;
        TOON_CHECK_COL;
-       return this->my_values[c*Rows+r];
+       return my_values[c*Skip+r];
   }
 
   inline const double& operator()(int r, int c)const TOON_THROW
   {
        TOON_CHECK_ROW;
        TOON_CHECK_COL;
-       return this->my_values[c*Rows+r];
+       return this->my_values[c*Skip+r];
   }
 
   static inline int num_rows() throw() {return Rows;}
   static inline int num_cols() throw() {return Cols;}
-  static inline int num_skip() throw() {return Rows;}
+  static inline int num_skip() throw() {return Skip;}
   typedef ColMajor layout;
 
   // Transpose operations
-  inline 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols> > >& 
T() {
-    return 
reinterpret_cast<FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols>
 > >&>(*this->my_values);
+  inline FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,RowMajor> >& T() {
+    return 
reinterpret_cast<FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,RowMajor> 
>&>(*this); 
   }
-  inline const 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols> > >& 
T() const {
-    return reinterpret_cast<const 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols> > 
>&>(*this->my_values);
+
+  inline const FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,RowMajor> >& 
T() const {
+    return reinterpret_cast<const 
FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,RowMajor> >&>(*this);
   }
 
   // slice()
   template<int Rstart, int Cstart, int Rsize, int Csize>
-  inline FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor> >& 
slice(){
-    return 
reinterpret_cast<FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor>
 >&>
-      (this->my_values[Cstart*Rows+Rstart]);
+  inline FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,ColMajor> >& 
slice(){
+    return 
reinterpret_cast<FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,ColMajor>
 >&>
+      (this->my_values[Cstart*Skip+Rstart]);
   }
 
   template<int Rstart, int Cstart, int Rsize, int Csize>
-  inline const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor> >& 
slice()const{
-    return reinterpret_cast<const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor> >&>
-      (this->my_values[Cstart*Rows+Rstart]);
+  inline const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,ColMajor> >& 
slice()const{
+    return reinterpret_cast<const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,ColMajor> >&>
+      (this->my_values[Cstart*Skip+Rstart]);
   }
 
   inline RefSkipMatrixCM slice(int Rstart, int Cstart, int Rsize, int Csize) {
-    return makeRefSkipMatrixCM(Rsize, Csize, Rows, this->my_values + Rstart + 
Cstart*Rows);
+    return makeRefSkipMatrixCM(Rsize, Csize, Skip, this->my_values + Rstart + 
Cstart*Skip);
   }
 
   inline const RefSkipMatrixCM slice(int Rstart, int Cstart, int Rsize, int 
Csize) const {
-    return makeRefSkipMatrixCM(Rsize, Csize, Rows, this->my_values + Rstart + 
Cstart*Rows);
+    return makeRefSkipMatrixCM(Rsize, Csize, Skip, this->my_values + Rstart + 
Cstart*Skip);
   }
 
+ protected:
+  double my_values[Cols*Skip];
 };
 
 
-
-
-
-template<int Rows, int Cols, int Skip>
-class SkipMAccessor<Rows,Cols,Skip,RowMajor> {
-public:
-  inline FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >& operator[](int 
r) TOON_THROW{
+template <int Rows,int Cols, class AllocZone>
+class FixedMAccessor<Rows,Cols,RowMajor,AllocZone> : public AllocZone {
+ public:
+  inline FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >& operator[](int 
r) TOON_THROW {
        TOON_CHECK_ROW;
-    return reinterpret_cast<FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > 
>&>(this->my_values[r*Skip]);
+    return reinterpret_cast<FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > 
>&>(this->my_values[r*Cols]);
   }
-  inline const FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >& 
operator[](int r) const TOON_THROW{
+  inline const FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >& 
operator[](int r) const TOON_THROW {
        TOON_CHECK_ROW;
-    return reinterpret_cast<const 
FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >&>(this->my_values[r*Skip]);
+    return reinterpret_cast<const 
FixedVector<Cols,FixedVAccessor<Cols,Stack<Cols> > >&>(this->my_values[r*Cols]);
   }
 
-  inline double& operator()(int r, int c) TOON_THROW
-  {
+  inline double& operator()(int r, int c) TOON_THROW {
        TOON_CHECK_ROW;
        TOON_CHECK_COL;
-       return this->my_values[r*Skip+c];
+       return this->my_values[r*Cols+c];
   }
 
   inline const double& operator()(int r, int c) const TOON_THROW
   {
        TOON_CHECK_ROW;
        TOON_CHECK_COL;
-       return this->my_values[r*Skip+c];
+       return this->my_values[r*Cols+c];
   }
 
   static inline int num_rows() throw() {return Rows;}
   static inline int num_cols() throw() {return Cols;}
-  static inline int num_skip() throw() {return Skip;}
+  static inline int num_skip() throw() {return Cols;}
   typedef RowMajor layout;
 
   // Transpose operations
-  inline FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,ColMajor> >& T() {
-    return 
reinterpret_cast<FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,ColMajor> 
>&>(*this); 
+  inline 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols> > >& 
T() {
+      FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols> 
> >::dummy();
+    return 
reinterpret_cast<FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols>
 > >&>(*this->my_values);
   }
-
-  inline const FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,ColMajor> >& 
T() const {
-    return reinterpret_cast<const 
FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,ColMajor> >&>(*this);
+  inline const 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols> > >& 
T() const {
+      FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols> 
> >::dummy();
+      return reinterpret_cast<const 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,ColMajor,Stack<Rows*Cols> > 
>&>(*this->my_values);
   }
 
   // slice
   template<int Rstart, int Cstart, int Rsize, int Csize>
-  inline FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor> >& 
slice(){
-    return 
reinterpret_cast<FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor>
 >&>
-      (this->my_values[Rstart*Skip+Cstart]);
+  inline FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Cols,RowMajor> >& 
slice(){
+      typedef FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Cols,RowMajor> 
> ST;
+      util::Assert<(Rstart+Rsize <= Rows)>();
+      util::Assert<(Cstart+Csize <= Cols)>();
+      ST::dummy();
+      return reinterpret_cast<ST&>(this->my_values[Rstart*Cols+Cstart]);
   }
 
   template<int Rstart, int Cstart, int Rsize, int Csize>
-  inline const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor> >& slice() 
const {
-    return reinterpret_cast<const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,RowMajor> >&>
-      (this->my_values[Rstart*Skip+Cstart]);
+  inline const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Cols,RowMajor> >& slice() 
const {
+      util::Assert<(Rstart+Rsize <= Rows)>();
+      util::Assert<(Cstart+Csize <= Cols)>();
+    return reinterpret_cast<const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Cols,RowMajor> >&>
+      (this->my_values[Rstart*Cols+Cstart]);
   }
 
   inline RefSkipMatrixRM slice(int Rstart, int Cstart, int Rsize, int Csize) {
-    return makeRefSkipMatrixRM(Rsize, Csize, Skip, this->my_values + 
Rstart*Skip + Cstart);
+    return makeRefSkipMatrixRM(Rsize, Csize, Cols, this->my_values + 
Rstart*Cols + Cstart);
   }
 
   inline const RefSkipMatrixRM slice(int Rstart, int Cstart, int Rsize, int 
Csize) const {
-    return makeRefSkipMatrixRM(Rsize, Csize, Skip, this->my_values + 
Rstart*Skip + Cstart);
+    return makeRefSkipMatrixRM(Rsize, Csize, Cols, this->my_values + 
Rstart*Cols + Cstart);
   }
 
-
- protected:
-  double my_values[Rows*Skip];
 };
 
-template<int Rows, int Cols, int Skip> 
-class SkipMAccessor<Rows, Cols, Skip, ColMajor> {
-public:
 
-  inline FixedVector<Cols, SkipAccessor<Cols, Skip> >& operator[](int r)  
TOON_THROW
-  {
+
+template <int Rows,int Cols, class AllocZone>
+class FixedMAccessor<Rows,Cols,ColMajor,AllocZone> : public AllocZone {
+ public:
+  FixedVector<Cols, SkipAccessor<Cols, Rows> >& operator[](int r) TOON_THROW{
        TOON_CHECK_ROW;
-    return reinterpret_cast<FixedVector<Cols, SkipAccessor<Cols, Skip> 
>&>(this->my_values[r]);
+       FixedVector<Cols, SkipAccessor<Cols, Rows> >::dummy();
+       return reinterpret_cast<FixedVector<Cols, SkipAccessor<Cols, Rows> 
>&>(this->my_values[r]);
   }
 
-  inline const FixedVector<Cols, SkipAccessor<Cols, Skip> >& operator[](int r) 
const TOON_THROW{
+  const FixedVector<Cols, SkipAccessor<Cols, Rows> >& operator[](int r) const 
TOON_THROW{
        TOON_CHECK_ROW;
-    return reinterpret_cast<const FixedVector<Cols, SkipAccessor<Cols, Skip> 
>&>(this->my_values[r]);
+    return reinterpret_cast<const FixedVector<Cols, SkipAccessor<Cols, Rows> 
>&>(this->my_values[r]);
   }
 
   inline double& operator()(int r, int c) TOON_THROW
   {
        TOON_CHECK_ROW;
        TOON_CHECK_COL;
-       return my_values[c*Skip+r];
+       return this->my_values[c*Rows+r];
   }
 
   inline const double& operator()(int r, int c)const TOON_THROW
   {
        TOON_CHECK_ROW;
        TOON_CHECK_COL;
-       return this->my_values[c*Skip+r];
+       return this->my_values[c*Rows+r];
   }
 
   static inline int num_rows() throw() {return Rows;}
   static inline int num_cols() throw() {return Cols;}
-  static inline int num_skip() throw() {return Skip;}
+  static inline int num_skip() throw() {return Rows;}
   typedef ColMajor layout;
 
   // Transpose operations
-  inline FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,RowMajor> >& T() {
-    return 
reinterpret_cast<FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,RowMajor> 
>&>(*this); 
+  inline 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols> > >& 
T() {
+      FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols> 
> >::dummy();
+      return 
reinterpret_cast<FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols>
 > >&>(*this->my_values);
   }
-
-  inline const FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,RowMajor> >& 
T() const {
-    return reinterpret_cast<const 
FixedMatrix<Cols,Rows,SkipMAccessor<Cols,Rows,Skip,RowMajor> >&>(*this);
+  inline const 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols> > >& 
T() const {
+      FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols> 
> >::dummy();
+      return reinterpret_cast<const 
FixedMatrix<Cols,Rows,FixedMAccessor<Cols,Rows,RowMajor,Stack<Rows*Cols> > 
>&>(*this->my_values);
   }
 
   // slice()
   template<int Rstart, int Cstart, int Rsize, int Csize>
-  inline FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,ColMajor> >& 
slice(){
-    return 
reinterpret_cast<FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,ColMajor>
 >&>
-      (this->my_values[Cstart*Skip+Rstart]);
+  inline FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor> >& 
slice(){
+      FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor> 
>::dummy();
+    return 
reinterpret_cast<FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor>
 >&>
+      (this->my_values[Cstart*Rows+Rstart]);
   }
 
   template<int Rstart, int Cstart, int Rsize, int Csize>
-  inline const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,ColMajor> >& 
slice()const{
-    return reinterpret_cast<const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Skip,ColMajor> >&>
-      (this->my_values[Cstart*Skip+Rstart]);
+  inline const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor> >& 
slice()const{
+      FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor> 
>::dummy();
+    return reinterpret_cast<const 
FixedMatrix<Rsize,Csize,SkipMAccessor<Rsize,Csize,Rows,ColMajor> >&>
+      (this->my_values[Cstart*Rows+Rstart]);
   }
 
   inline RefSkipMatrixCM slice(int Rstart, int Cstart, int Rsize, int Csize) {
-    return makeRefSkipMatrixCM(Rsize, Csize, Skip, this->my_values + Rstart + 
Cstart*Skip);
+    return makeRefSkipMatrixCM(Rsize, Csize, Rows, this->my_values + Rstart + 
Cstart*Rows);
   }
 
   inline const RefSkipMatrixCM slice(int Rstart, int Cstart, int Rsize, int 
Csize) const {
-    return makeRefSkipMatrixCM(Rsize, Csize, Skip, this->my_values + Rstart + 
Cstart*Skip);
+    return makeRefSkipMatrixCM(Rsize, Csize, Rows, this->my_values + Rstart + 
Cstart*Rows);
   }
 
- protected:
-  double my_values[Cols*Skip];
 };
 
 
+
 #undef TOON_CHECK_ROW
 #undef TOON_CHECK_COL
 

Index: mbase.hh
===================================================================
RCS file: /cvsroot/toon/TooN/mbase.hh,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -b -r1.8 -r1.9
--- mbase.hh    25 Apr 2006 23:14:02 -0000      1.8
+++ mbase.hh    15 Jan 2007 18:19:34 -0000      1.9
@@ -110,6 +110,7 @@
     MatrixCopy<Accessor,Accessor2>::eval(*this,from);
     return *this;
   }
+    static void dummy() {}
 };
 
 template<class Accessor>
@@ -130,6 +131,9 @@
     return *this;
   }
 
+    operator DynamicMatrix& () { return *this; }
+    operator const DynamicMatrix& () const { return *this; }
+
 };
 
 

Index: vaccessor.hh
===================================================================
RCS file: /cvsroot/toon/TooN/vaccessor.hh,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -b -r1.12 -r1.13
--- vaccessor.hh        5 Dec 2006 00:35:36 -0000       1.12
+++ vaccessor.hh        15 Jan 2007 18:19:34 -0000      1.13
@@ -263,6 +263,7 @@
   inline FixedVector<Length,FixedVAccessor<Length,Stack<Length> > >& slice()
   {
       util::Assert<(Start+Length <= Size)>();
+      FixedVector<Length,FixedVAccessor<Length,Stack<Length> > >::dummy();
       return 
reinterpret_cast<FixedVector<Length,FixedVAccessor<Length,Stack<Length> > >&> 
(parent::my_values[Start]);
   }
 
@@ -276,7 +277,7 @@
   inline const RefVector slice(int start, int size) const
   {
     assert(0 <= start && start < Size && size >=0 && start+size <= Size);
-    return makeRefVector(size, parent::my_values + start);
+    return makeRefVector(size, const_cast<double*>( parent::my_values + 
start));
   }
   
   template<int Start, int Length>
@@ -289,21 +290,25 @@
   // convert to Matrices
   inline FixedMatrix<Size,1,FixedMAccessor<Size,1,ColMajor,Stack<Size> > >& 
as_col() 
   {
+      FixedMatrix<Size,1,FixedMAccessor<Size,1,ColMajor,Stack<Size> > 
>::dummy();
     return 
reinterpret_cast<FixedMatrix<Size,1,FixedMAccessor<Size,1,ColMajor,Stack<Size> 
> >&>(*parent::my_values);
   }
 
   inline const FixedMatrix<Size,1,FixedMAccessor<Size,1,ColMajor,Stack<Size> > 
>& as_col() const 
   {
+      FixedMatrix<Size,1,FixedMAccessor<Size,1,ColMajor,Stack<Size> > 
>::dummy();
     return reinterpret_cast<const 
FixedMatrix<Size,1,FixedMAccessor<Size,1,ColMajor,Stack<Size> > >&> 
(*parent::my_values);
   }
 
   inline FixedMatrix<1,Size,FixedMAccessor<1,Size,RowMajor,Stack<Size> > >& 
as_row() 
   {
+      FixedMatrix<1,Size,FixedMAccessor<1,Size,RowMajor,Stack<Size> > 
>::dummy();
     return 
reinterpret_cast<FixedMatrix<1,Size,FixedMAccessor<1,Size,RowMajor,Stack<Size> 
> >&> (*parent::my_values);
   }
   
   inline const FixedMatrix<1,Size,FixedMAccessor<1,Size,RowMajor,Stack<Size> > 
>& as_row() const 
   {
+      FixedMatrix<1,Size,FixedMAccessor<1,Size,RowMajor,Stack<Size> > 
>::dummy();
     return reinterpret_cast<const 
FixedMatrix<1,Size,FixedMAccessor<1,Size,RowMajor,Stack<Size> > >&> 
(*parent::my_values);
   }
   

Index: vbase.hh
===================================================================
RCS file: /cvsroot/toon/TooN/vbase.hh,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -b -r1.13 -r1.14
--- vbase.hh    8 Sep 2006 09:23:46 -0000       1.13
+++ vbase.hh    15 Jan 2007 18:19:34 -0000      1.14
@@ -102,6 +102,8 @@
     return VectorMagic::VectorFiller<N,Size, FixedVector<Size,Accessor>, 
VectorMagic::InsertionStyle>(*this);
   }
 
+    static void dummy() {}
+
   template<class A, int I> FixedVector<Size, Accessor>& operator=(const 
VectorMagic::VectorCreator<A,I>& v)
   {
     v.assign(*this);
@@ -127,6 +129,8 @@
     VectorCopy<Accessor,Accessor>::eval(*this,from);
     return *this;
   }
+    operator DynamicVector& () { return *this; }
+    operator const DynamicVector& () const { return *this; }
 
   template<class A, int I> DynamicVector<Accessor> & operator=(const 
VectorMagic::VectorCreator<A,I>& v)
   {

Index: vclasses.hh
===================================================================
RCS file: /cvsroot/toon/TooN/vclasses.hh,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -b -r1.23 -r1.24
--- vclasses.hh 8 Sep 2006 09:23:46 -0000       1.23
+++ vclasses.hh 15 Jan 2007 18:19:34 -0000      1.24
@@ -69,12 +69,6 @@
     return *this;
   }
 
-  inline Vector<Size>& operator=(const Vector<-1>& v) {
-    *this = Vector<Size>(v);
-    return *this;
-  }
-
-
   // vector magic assignment operators (uses comma style) - insertion style 
defined in vbase.hh
   VectorMagic::VectorFiller<1,Size, Vector<Size>, VectorMagic::CommaStyle> 
operator=(double t) {
     (*this)[0] = t;