Matrix.hpp

Go to the documentation of this file.

#pragma ident "$Id: Matrix.hpp 3320 2012-09-20 00:41:47Z yanweignss $"



#ifndef GPSTK_MATRIX_HPP
#define GPSTK_MATRIX_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

#include "Vector.hpp"
#include "MatrixBase.hpp"

namespace gpstk
{

 
// forward declarations
   template <class T> class MatrixRowSlice;
   template <class T> class ConstMatrixRowSlice;
   template <class T> class MatrixColSlice;
   template <class T> class ConstMatrixColSlice;


   template <class T>
   class Matrix : public RefMatrixBase<T, Matrix<T> >
   {
   public:
      typedef typename Vector<T>::value_type value_type;
      typedef typename Vector<T>::reference reference;
      typedef typename Vector<T>::const_reference const_reference;
      typedef typename Vector<T>::iterator iterator;
      typedef typename Vector<T>::const_iterator const_iterator;  

      Matrix();
      Matrix(size_t rows, size_t cols);
      Matrix(size_t rows, size_t cols, T initialValue);
      Matrix(size_t rows, size_t cols, const T* vec);
      template <class BaseClass>
      Matrix(size_t rows, size_t cols, const ConstVectorBase<T, BaseClass>& vec)
         : v(rows*cols), r(rows), c(cols), s(rows * cols)
      { assignFrom(vec); }

      template <class BaseClass>
      Matrix(const ConstMatrixBase<T, BaseClass>& mat) 
            : v(mat.size()), r(mat.rows()), c(mat.cols()), s(mat.size())
         {
            size_t i,j;
            for(i = 0; i < r; i++)
               for(j = 0; j < c; j++)
                  (*this)(i,j) = mat(i, j);
         }

      template <class BaseClass>
      Matrix(const ConstMatrixBase<T, BaseClass>& mat, size_t topRow, 
          size_t topCol, size_t numRows, size_t numCols) 
            : v((size_t)0), r(0), c(0), s(0)
         {
               // sanity checks...
            if ( (topCol > mat.cols()) || 
                 (topRow > mat.rows()) ||
                 ((topRow + numRows) > mat.rows()) ||
                 ((topCol + numCols) > mat.cols()) )
            {
               MatrixException e("Invalid dimensions or size for Matrix(MatrixBase)");
               GPSTK_THROW(e);
            }
         
               // seems ok - make the valarray and copy column by column
            r = numRows;
            c = numCols;
            s = r * c;
            v.resize(r * c);
            size_t i, j;
            for(i = 0; i < r; i++)
               for(j = 0; j < c; j++)
                  (*this)(i,j) = mat(topRow + i, topCol + j);
         }

      iterator begin() { return v.begin(); }
      const_iterator begin() const { return v.begin(); }
      iterator end() { return v.end(); }
      const_iterator end() const { return v.end(); }
      value_type front() { return v.front(); }
      const_reference front() const { return v.front();}
      bool empty() const { return s == 0; }
      size_t size() const {return s; }
      size_t max_size() const { return s; }

      inline size_t rows() const { return r; }
      inline size_t cols() const { return c; }
      inline MatrixRowSlice<T> rowRef(size_t rowNum, const std::slice& s);
      inline MatrixRowSlice<T> rowRef(size_t rowNum, size_t colNum = 0);
      inline ConstMatrixRowSlice<T> row(size_t rowNum, const std::slice& s) const;
      inline ConstMatrixRowSlice<T> row(size_t rowNum, size_t colNum = 0) const;

      inline MatrixColSlice<T> colRef(size_t colNum, const std::slice& s);
      inline MatrixColSlice<T> colRef(size_t colNum, size_t rowNum = 0);
      inline ConstMatrixColSlice<T> col(size_t colNum, const std::slice& s) const;
      inline ConstMatrixColSlice<T> col(size_t colNum, size_t rowNum = 0) const;

      inline T& operator() (size_t rowNum, size_t colNum)
         { return v(rowNum + colNum * r); }
      inline T operator() (size_t rowNum, size_t colNum) const
         { return v(rowNum + colNum * r); }
      inline MatrixRowSlice<T> operator[] (size_t row)
         { return rowRef(row); }
      inline ConstMatrixRowSlice<T> operator[] (size_t rowNum) const 
         { return row(rowNum);}

      inline Matrix& resize(size_t rows, size_t cols);

      inline Matrix& resize(size_t rows, size_t cols, 
                         const T initialValue);

      inline Matrix& operator=(const T* array)
         { return this->assignFrom(array); }
      inline Matrix& operator=(const std::valarray<T> array)
         { return this->assignFrom(array); }
      inline Matrix& operator=(const T t)
         { return this->assignFrom(t); }
      inline Matrix& operator=(const Matrix& mat)
         { v = mat.v; r = mat.r; c = mat.c; s = mat.s; return *this; }
      template <class BaseClass>
      inline Matrix& operator=(const ConstMatrixBase<T, BaseClass>& mat)
         { 
            v.resize(mat.size()); 
            r=mat.rows(); 
            c=mat.cols(); 
            s=mat.size();
            return this->assignFrom(mat);
         }
      template <class BaseClass>
      inline Matrix& operator=(const ConstVectorBase<T, BaseClass>& mat)
         { return this->assignFrom(mat); }

   private:
      Vector<T> v;
      size_t r,  
         c,  
         s;  
   };

   template <class T>
   class MatrixSlice : public RefMatrixSliceBase<T, MatrixSlice<T> >
   {
   public:
      MatrixSlice() : m(NULL), rSlice(std::slice(0,0,0)), 
         cSlice(std::slice(0,0,0)), s(0)
         {}

      MatrixSlice(Matrix<T>& mat)
            : m(&mat), rSlice(std::slice(0, mat.rows(), 1)),
              cSlice(std::slice(0,mat.cols(), 1)), s(mat.size())
         {
            this->matSliceCheck(mat.rows(), mat.cols());
         }

      MatrixSlice(Matrix<T>& mat, const std::slice& rowSlice,
               const std::slice& colSlice)
            : m(&mat), rSlice(rowSlice), cSlice(colSlice),
              s(rSlice.size() * cSlice.size())
         {
            this->matSliceCheck(mat.rows(), mat.cols());
         }

      MatrixSlice(Matrix<T>& mat, size_t topRow, size_t topCol, 
               size_t numRows, size_t numCols)
            : m(&mat), rSlice(std::slice(topRow, numRows, 1)),
              cSlice(std::slice(topCol, numCols, 1)),
              s(rSlice.size() * cSlice.size())
         {
            this->matSliceCheck(mat.rows(), mat.cols());
         }
      
      template <class V>
      MatrixSlice& operator=(const ConstMatrixBase<T, V>& x)
         { return this->assignFrom(x); }

      template <class V>
      MatrixSlice& operator=(const ConstVectorBase<T, V>& x)
         { return this->assignFrom(x); }

      MatrixSlice& operator=(const std::valarray<T>& x)
         { return this->assignFrom(x); }
      MatrixSlice& operator=(const T x)
         { return this->assignFrom(x); }
      MatrixSlice& operator=(const T* x)
         { return this->assignFrom(x); }

      size_t size() const { return s; }
      size_t cols() const { return colSize(); }
      size_t rows() const { return rowSize(); }
      T& operator() (size_t i, size_t j)
         { return (*m)(i * rowStride() + rowStart(), 
                       j * colStride() + colStart()); }
      T operator() (size_t i, size_t j) const
         { return (*m)(i * rowStride() + rowStart(), 
                       j * colStride() + colStart()); }


      size_t rowSize() const { return rSlice.size(); }
      size_t rowStart() const{ return rSlice.start(); }
      size_t rowStride() const { return rSlice.stride(); }
      size_t colSize() const { return cSlice.size(); }
      size_t colStart() const { return cSlice.start(); }
      size_t colStride() const { return cSlice.stride(); }

   private:
      Matrix<T>* m;
      std::slice rSlice, 
         cSlice; 
      size_t s; 
   };

   template <class T>
   class ConstMatrixSlice : public ConstMatrixSliceBase<T, ConstMatrixSlice<T> >
   {
   public:
      ConstMatrixSlice(void) : m(NULL), rSlice(std::slice(0,0,0)), 
         cSlice(std::slice(0,0,0)), s(0)
         {}

      ConstMatrixSlice(const Matrix<T>& mat)
            : m(&mat), rSlice(std::slice(0, mat.rows(), 1)),
              cSlice(std::slice(0,mat.cols(), 1)), s(mat.size())
         {
            this->matSliceCheck(mat.rows(), mat.cols());
         }

      ConstMatrixSlice(const Matrix<T>& mat, const std::slice& rowSlice,
               const std::slice& colSlice)
            : m(&mat), rSlice(rowSlice), cSlice(colSlice),
              s(rSlice.size() * cSlice.size())
         {
            this->matSliceCheck(mat.rows(), mat.cols());
         }

      ConstMatrixSlice(const Matrix<T>& mat, size_t topRow, size_t topCol, 
               size_t numRows, size_t numCols)
            : m(&mat), rSlice(std::slice(topRow, numRows, 1)),
              cSlice(std::slice(topCol, numCols, 1)),
              s(rSlice.size() * cSlice.size())
         {
            this->matSliceCheck(mat.rows(), mat.cols());
         }

      size_t size() const { return s; }
      size_t cols() const { return colSize(); }
      size_t rows() const { return rowSize(); }
      T operator() (size_t i, size_t j) const 
         { return (*m)(i * rowStride() + rowStart(), 
                       j * colStride() + colStart()); }

      size_t rowSize() const { return rSlice.size(); }
      size_t rowStart() const{ return rSlice.start(); }
      size_t rowStride() const { return rSlice.stride(); }
      size_t colSize() const { return cSlice.size(); }
      size_t colStart() const { return cSlice.start(); }
      size_t colStride() const { return cSlice.stride(); }
   private:
      const Matrix<T>* m;
      std::slice rSlice, 
         cSlice; 
      size_t s; 
   };

   template <class T>
   class MatrixColSlice : public RefMatrixSliceBase<T, MatrixColSlice<T> >
   {
   public:
      MatrixColSlice() : m(NULL), c(0), rSlice(std::slice(0,0,0)) {}
      MatrixColSlice(Matrix<T>& mat, size_t col)
            : m(&mat), c(col), rSlice(std::slice(0,mat.rows(),1))
         { 
            this->matSliceCheck(mat.rows(), mat.cols()); 
         }
      MatrixColSlice(Matrix<T>& mat, size_t col, const std::slice& s)
            : m(&mat), c(col), rSlice(s)
         { 
               // decide if the input is reasonable
            this->matSliceCheck(mat.rows(), mat.cols());
         }

      template <class V>
      MatrixColSlice& operator=(const ConstMatrixBase<T, V>& x)
         { return this->assignFrom(x); }

      template <class V>
      MatrixColSlice& operator=(const ConstVectorBase<T, V>& x)
         { return this->assignFrom(x); }
      MatrixColSlice& operator=(const std::valarray<T>& x)
         { return this->assignFrom(x); }
      MatrixColSlice& operator=(const T x)
         { return this->assignFrom(x); }
      MatrixColSlice& operator=(const T* x)
         { return this->assignFrom(x); }

      T& operator[] (size_t i) 
         { return (*m)(rowStart() + i * rowStride(), c); }
      T& operator() (size_t i) 
         { return (*m)(rowStart() + i * rowStride(), c); }
      T operator[] (size_t i) const
         { return (*m)(rowStart() + i * rowStride(), c); }
      T operator() (size_t i) const
         { return (*m)(rowStart() + i * rowStride(), c); }

      T& operator() (size_t i, size_t j) 
         { return (*m)(rowStart() + i * rowStride(), j + c); }
      T operator() (size_t i, size_t j) const
         { return (*m)(rowStart() + i * rowStride(), j + c); }

      size_t rows() const {return size();}
      size_t cols() const {return 1;}
      size_t size() const {return rowSize();}

      size_t rowSize() const { return rSlice.size(); }
      size_t rowStart() const{ return rSlice.start(); }
      size_t rowStride() const { return rSlice.stride(); }
      size_t colSize() const { return 1; }
      size_t colStart() const { return c; }
      size_t colStride() const { return 1; }

   private:
      Matrix<T>* m;
      size_t c;
      std::slice rSlice;

   };

   template <class T>
   class ConstMatrixColSlice : public ConstMatrixSliceBase<T, ConstMatrixColSlice<T> >
   {
   public:
      ConstMatrixColSlice() 
            : m(NULL), c(0), rSlice(std::slice(0,0,0)) 
         {}

      ConstMatrixColSlice(const Matrix<T>& mat, size_t col)
            : m(&mat), c(col), rSlice(std::slice(0,mat.rows(),1))
         { this->matSliceCheck(mat.rows(), mat.cols()); }

      ConstMatrixColSlice(const Matrix<T>& mat, size_t col, 
                       const std::slice& s)
            : m(&mat), c(col), rSlice(s)
         { 
               // decide if the input is reasonable
            this->matSliceCheck(mat.rows(), mat.cols());
         }

      T operator[] (size_t i) const
         { return (*m)(rowStart() + i * rowStride(), c); }
      T operator() (size_t i) const
         { return (*m)(rowStart() + i * rowStride(), c); }

      T operator() (size_t i, size_t j) const
         { return (*m)(rowStart() + i * rowStride(), j + c); }

      size_t rows() const {return rowSize();}
      size_t cols() const {return 1;}
      size_t size() const {return rowSize();}

      size_t rowSize() const { return rSlice.size(); }
      size_t rowStart() const{ return rSlice.start(); }
      size_t rowStride() const { return rSlice.stride(); }
      size_t colSize() const { return 1; }
      size_t colStart() const { return c; }
      size_t colStride() const { return 1; }
   private:
      const Matrix<T>* m;
      size_t c;
      std::slice rSlice;
   };

   template <class T>
   class MatrixRowSlice : public RefMatrixSliceBase<T, MatrixRowSlice<T> >
   {
   public:
      MatrixRowSlice() 
            : m(NULL), r(0), cSlice(std::slice(0,0,0)) 
         {}
      MatrixRowSlice(Matrix<T>& mat, size_t row)
            : m(&mat), r(row), cSlice(std::slice(0,mat.cols(),1))
         { this->matSliceCheck(mat.rows(), mat.cols()); }

      MatrixRowSlice(Matrix<T>& mat, size_t row, 
                  const std::slice& s)
            : m(&mat), r(row), cSlice(s)
         { 
               // decide if the input is reasonable
            this->matSliceCheck(mat.rows(), mat.cols());
         }   

      template <class V>
      MatrixRowSlice& operator=(const ConstMatrixBase<T, V>& x)
         { return this->assignFrom(x); }
      template <class V>
      MatrixRowSlice& operator=(const ConstVectorBase<T, V>& x)
         { return this->assignFrom(x); }
      MatrixRowSlice& operator=(const std::valarray<T>& x)
         { return this->assignFrom(x); }
      MatrixRowSlice& operator=(const T x)
         { return this->assignFrom(x); }
      MatrixRowSlice& operator=(const T* x)
         { return this->assignFrom(x); }

      T& operator[] (size_t j)
         { return (*m)(r, colStart() + j * colStride()); }
      T& operator() (size_t j)
         { return (*m)(r, colStart() + j * colStride()); }
      T operator[] (size_t j) const
         { return (*m)(r, colStart() + j * colStride()); }
      T operator() (size_t j) const
         { return (*m)(r, colStart() + j * colStride()); }
      T& operator() (size_t i, size_t j) 
         { return (*m)(i + r, colStart() + j * colStride()); }
      T operator() (size_t i, size_t j) const
         { return (*m)(i + r, colStart() + j * colStride()); }

      size_t rows() const {return 1;}
      size_t cols() const {return colSize();}
      size_t size() const {return colSize();}

      size_t rowSize() const { return 1; }
      size_t rowStart() const{ return r; }
      size_t rowStride() const { return 1; }
      size_t colSize() const { return cSlice.size(); }
      size_t colStart() const { return cSlice.start(); }
      size_t colStride() const { return cSlice.stride(); }

   private:
      Matrix<T>* m;
      size_t r;
      std::slice cSlice;
   };

   template <class T>
   class ConstMatrixRowSlice : public ConstMatrixSliceBase<T, ConstMatrixRowSlice<T> >
   {
   public:
      ConstMatrixRowSlice() 
            : m(NULL), r(0), cSlice(std::slice(0,0,0)) 
         {}
      ConstMatrixRowSlice(const Matrix<T>& mat, size_t row)
            : m(&mat), r(row), cSlice(std::slice(0,mat.cols(),1))
         { this->matSliceCheck(mat.rows(), mat.cols()); }

      ConstMatrixRowSlice(const Matrix<T>& mat, size_t row, 
                       const std::slice& s)
            : m(&mat), r(row), cSlice(s)
         { 
               // decide if the input is reasonable
            this->matSliceCheck(mat.rows(), mat.cols());
         }   

      T operator[] (size_t i) const
         { return (*m)(r, colStart() + i * colStride()); }
      T operator() (size_t i) const
         { return (*m)(r, colStart() + i * colStride()); }

      T operator() (size_t i, size_t j) const
         { return (*m)(i + r, colStart() + j * colStride()); }

      size_t rows() const {return 1;}
      size_t cols() const {return colSize();}
      size_t size() const {return colSize();}

      size_t rowSize() const { return 1; }
      size_t rowStart() const{ return r; }
      size_t rowStride() const { return 1; }
      size_t colSize() const { return cSlice.size(); }
      size_t colStart() const { return cSlice.start(); }
      size_t colStride() const { return cSlice.stride(); }
   private:
      const Matrix<T>* m;
      size_t r;
      std::slice cSlice;
   };


}  // namespace

#include "MatrixImplementation.hpp"
#include "MatrixOperators.hpp"
#include "MatrixFunctors.hpp"

#endif

---