Matrix.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
#ifndef GNSSTK_MATRIX_HPP
#define GNSSTK_MATRIX_HPP
 
#include "Vector.hpp"
#include "MatrixBase.hpp"
 
namespace gnsstk
{
 
 
 
      // 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;
#ifndef SWIG
      typedef typename Vector<T>::const_reference const_reference;
#endif
      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)
      { this->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)");
            GNSSTK_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);
      }
 
      virtual ~Matrix()
      {}
 
      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(); }
#ifndef SWIG
      const_reference front() const { return v.front();}
#endif
      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