matrix.inl

Go to the documentation of this file.

/* --------------------------------------------------------------- *\

   file: matrix.inl
   date: 030825 22:16:28

   author:

      mathias gumz <gumz at cs.uni-magdeburg.de>

   license:

      see LICENSE.txt

   about:

      generic matrix class

\* --------------------------------------------------------------- */


/* --------------------------------------------------------------- *\
    definition of Mat
\* --------------------------------------------------------------- */

template<typename T, int W, int H>
Mat<T, W, H>& Mat<T, W, H>::operator=(typename Mat<T, W, H>::ConstValType& scalar)
{
  return matrix::assign(*this, scalar);
}

template<typename T, int W, int H> inline
Mat<T, W, H>& Mat<T, W, H>::operator=(typename Mat<T, W, H>::ConstValTypePtr valptr)
{
  return matrix::assign(*this, valptr);
}

template<typename T, int W, int H> inline
Mat<T, W, H>& Mat<T, W, H>::operator=(typename Mat<T, W, H>::ConstMatType& mat)
{
  return matrix::assign(*this, mat);
}

/* --------------------------------------------------------------- *\
\* --------------------------------------------------------------- */

template<typename T, int W, int H> inline
Mat<T, W, H> Mat<T, W, H>::operator+(typename Mat<T, W, H>::ConstMatType& mat) const
{
  Mat<T, W, H> m;
  for (int i= 0; i < W; i++ )
    m.val[i]= val[i] + mat.val[i];

  return m;
};

template<typename T, int W, int H> inline
Mat<T, W, H>& Mat<T, W, H>::operator+=(typename Mat<T, W, H>::ConstMatType& mat)
{
  for (int i= 0; i < W; i++ )
    val[i]+= mat.val[i];
  return *this;
};

template<typename T, int W, int H> inline
Mat<T, W, H> Mat<T, W, H>::operator-(typename Mat<T, W, H>::ConstMatType& mat) const
{
  Mat<T, W, H> m;
  for (int i= 0; i < W; i++ )
    m.val[i]= val[i] - mat.val[i];
  return m;
};

template<typename T, int W, int H> inline
Mat<T, W, H>& Mat<T, W, H>::operator-=(typename Mat<T, W, H>::ConstMatType& mat)
{
  for (int i= 0; i < W; i++ )
    val[i]-= mat.val[i];
  return *this;
};

template<typename T, int W, int H> inline
Mat<T, W, H> Mat<T, W, H>::operator*(typename Mat<T, W, H>::ConstValType& scalar) const
{
  Mat<T, W, H> m;
  for (int i= 0; i < W; i++ )
    m.val[i]= val[i] * scalar;
  return m;
};

template<typename T, int W, int H> inline
Mat<T, W, H>& Mat<T, W, H>::operator*=(typename Mat<T, W, H>::ConstValType& scalar)
{
  for (int i= 0; i < W; i++)
    val[i]*= scalar;
  return *this;
};

template<typename T, int W, int H> inline
Mat<T, W, H> Mat<T, W, H>::operator/(typename Mat<T, W, H>::ConstValType& scalar) const
{
  Mat<T, W, H> m;
  for (int i= 0; i < W; i++ )
    m.val[i]/= scalar;
  return m;
};

template<typename T, int W, int H> inline
Mat<T, W, H>& Mat<T, W, H>::operator/=(typename Mat<T, W, H>::ConstValType& scalar)
{
  for (int i= 0; i < W; i++)
    val[i]*= scalar;
  return *this;
};



template<typename T, int W, int H>
template<int WW> inline
Mat<T, WW, H> Mat<T, W, H>::operator*(const Mat<T, WW, W>& mat) const
{
  Mat<T, WW, H> m;
  int col;
  int row;
  int i;

  for(col= 0; col < WW; col++ )
  {
    for(row= 0; row < W; row++ )
    {
      m(col, row)= Mat<T, WW, H>::ValTrait::zero();
      for(i= 0; i < W; i++ )
      {
        m(col, row)+= (*this)(i, row) * mat(col, i);
      }
    }
  }

  return m;
};

template<typename T, int W, int H> inline
Vec<T, W> Mat<T, W, H>::operator*(const Vec<T, W>& vec) const
{
  Vec<T, W> v;
  int row;
  int i;

  for(row= 0; row < W; row++ )
  {
    v[row]= Vec<T, W>::ValTrait::zero();
    for(i= 0; i < W; i++ )
    {
      v[row]+= (*this)(i, row) * vec[i];
    }
  }

  return v;
};


template<typename T, int W, int H> inline
Mat<T, W, H>& Mat<T, W, H>::operator*=(const Mat<T, H, W>& mat)
{
  Mat<T, W, H> m;

  m= (*this) * mat;
  (*this)= m;

  return (*this);
};



/* --------------------------------------------------------------- *\
    functions for the matrix _AND_ the specialisations !!
\* --------------------------------------------------------------- */

template<typename T, int W, int H> inline
Mat<T, W, H>& matrix::assign(Mat<T, W, H>& m, const T& scalar)
{
  for (T* i= m.begin(); i != m.end(); )
    *i++= scalar;
  return m;
}

template<typename T> inline
Mat<T, 3, 3>& matrix::assign(Mat<T, 3, 3>& m, const T& scalar)
{
  m.val[0]= m.val[1]= m.val[2]= scalar;
  return m;
}

template<typename T, int W, int H> inline
Mat<T, W, H>& matrix::assign(Mat<T, W, H>& m, const T* valptr)
{
  for (T* i= m.begin(); i != m.end(); )
    *i++= *valptr++;
  return m;
}

template<typename T, int W, int H> inline
Mat<T, W, H>& matrix::assign(Mat<T, W, H>& m, const Mat<T, W, H>& mat)
{
  const T* j= mat.begin();
  for (T* i= m.begin(); i != m.end(); )
    *i++= *j++;
  return m;
}

/* --------------------------------------------------------------- *\
\* --------------------------------------------------------------- */
template<typename T, int W, int H>
std::ostream& operator<<(std::ostream& os, const Mat<T, W, H>& m)
{
  os << "\n";
  int col;
  int row;

  for (row= 0; row < H; row++ )
  {
    os << "|";
    for ( col= 0; col < W; col++ )
    {
      os << m(col, row) << " ";
    }
    os << "|\n";
  }

  return os << "|";
}
/* --------------------------------------------------------------- *\
\* --------------------------------------------------------------- */

/* -- emacs - settings ------------------------------------------- *\
   ;;; Local Variables: ***
   ;;; mode:C++ ***
   ;;; c-basic-offset:2 ***
   ;;; End: ***
\* --------------------------------------------------------------- */
/* -- vim - settings --------------------------------------------- *\
  vim:set ft=cpp ts=2 ss=2:
\* --------------------------------------------------------------- */

---