mthTensor.h

Go to the documentation of this file.

/******************************************************************************
 
  Copyright 2015 Scientific Computation Research Center,
      Rensselaer Polytechnic Institute. All rights reserved.
 
  This work is open source software, licensed under the terms of the
  BSD license as described in the LICENSE file in the top-level directory.
 
*******************************************************************************/
 
#ifndef MTH_TENSOR_H
#define MTH_TENSOR_H
 
#include "mthMatrix.h"
#include <pcu_util.h>
 
namespace mth {
 
template <class T>
class Tensor : public Matrix<T>
{
  public:
    Tensor() : Matrix<T>() {}
    Tensor(unsigned d) : mth::Matrix<T>(d,d)
    {
      PCU_ALWAYS_ASSERT((d==2) || (d==3));
    }
    Tensor(Tensor<T> const& b) : mth::Matrix<T>() {copy(b);}
    Tensor(Matrix<T> const& b) : mth::Matrix<T>() {copy(b);}
    Tensor<T>& operator=(Tensor<T> const& b)
    {
      (*this).copy(b);
      return *this;
    }
    Tensor<T> operator=(Matrix<T> const& b)
    {
      Tensor<T> r;
      r.copy(b);
      return r;
    }
    Tensor<T> operator+(Tensor<T> const& b)
    {
      Tensor<T> r(dim());
      for (unsigned i=0; i < dim(); ++i)
      for (unsigned j=0; j < dim(); ++j)
        r(i,j) = (*this)(i,j) + b(i,j);
      return r;
    }
    Tensor<T> operator-(Tensor<T> const& b)
    {
      Tensor<T> r(dim());
      for (unsigned i=0; i < dim(); ++i)
      for (unsigned j=0; j < dim(); ++j)
        r(i,j) = (*this)(i,j) - b(i,j);
      return r;
    }
    Tensor<T> operator*(Tensor<T> const& b)
    {
      Tensor<T> r(dim());
      for (unsigned i=0; i < dim(); ++i)
      for (unsigned j=0; j < dim(); ++j)
      {
        r(i,j) = (*this)(i,0) * b(0,j);
        for (unsigned k=1; k < dim(); ++k)
          r(i,j) += (*this)(i,k) * b(k,j);
      }
      return r;
    }
    Tensor<T> operator*(T const& s)
    {
      Tensor<T> r(dim());
      for (unsigned i=0; i < dim(); ++i)
      for (unsigned j=0; j < dim(); ++j)
        r(i,j) = (*this)(i,j) * s;
      return r;
    }
    Tensor<T> operator/(T const& s)
    {
      Tensor<T> r(dim());
      for (unsigned i=0; i < dim(); ++i)
      for (unsigned j=0; j < dim(); ++j)
        r(i,j) = (*this)(i,j) / s;
      return r;
    }
    void resize(unsigned d)
    {
      PCU_ALWAYS_ASSERT((d==2) || (d==3));
      this->columns = d;
      this->elems.resize(d*d);
    }
    void resize(unsigned m, unsigned n)
    {
      PCU_ALWAYS_ASSERT(m==n);
      PCU_ALWAYS_ASSERT((m==2) || (m==3));
      this->columns = m;
      this->elems.resize(m*m);
    }
    unsigned dim() const {return this->columns;}
  private:
    void copy(Tensor<T> const& b)
    {
      unsigned d = b.dim();
      resize(d);
      for (unsigned i=0; i < d; ++i)
      for (unsigned j=0; j < d; ++j)
        (*this)(i,j) = b(i,j);
    }
    void copy(Matrix<T> const& b)
    {
      unsigned m = b.rows();
      unsigned n = b.cols();
      resize(m,n);
      for (unsigned i=0; i < m; ++i)
      for (unsigned j=0; j < m; ++j)
        (*this)(i,j) = b(i,j);
    }
};
 
}
 
#endif