matrix.hpp

Go to the documentation of this file.

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

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

   author:

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

   license:

      see LICENSE.txt

   about:

      generic matrix class

\* --------------------------------------------------------------- */
#ifndef _MATRIX_HPP_
#define _MATRIX_HPP_

namespace math
{

template<typename T, int W, int H> class Mat;


/* --------------------------------------------------------------- *\
 *  traits for the matrix
\* --------------------------------------------------------------- */

template<typename T, int W, int H>
struct Traits< Mat<T, W, H> >
{
  Mat<T, W, H> static zero() { return Mat<T, W, H>(Mat<T, W, H>::ValTrait::zero()); }
}; // struct Traits

template<typename T, int W>
struct Traits< Mat<T, W, W> >
{
  Mat<T, W, W> static zero() { return Mat<T, W, W>(Mat<T, W, W>::ValTrait::zero()); }
  Mat<T, W, W> static one()  {
    Mat<T, W, W> o(Mat<T, W, W>::ValTrait::zero());
    for(int i= 0; i < W;i++)
      o(i,i)= Mat<T, W, W>::ValTrait::one();
    return o;
  }
}; // struct Traits

template<typename T>
struct Traits< Mat<T, 3, 3> >
{
  Mat<T, 3, 3> static zero() {
    static T z[]= { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    return Mat<T, 3, 3>(z);
  }

  Mat<T, 3, 3> static one() {
    static T o[]= { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
    return Mat<T, 3, 3>(o);
  }
}; // Traits<T, 3, 3>



/* --------------------------------------------------------------- *\
    functions for Mat
\* --------------------------------------------------------------- */
namespace matrix
{
  template<typename T, int W, int H>
  inline Mat<T, W, H>& assign(Mat<T, W, H>& m, const T& scalar);

  template<typename T, int W, int H>
  inline Mat<T, W, H>& assign(Mat<T, W, H>& m, const T* valptr);

  template<typename T, int W, int H>
  inline Mat<T, W, H>& assign(Mat<T, W, H>& m, const Mat<T, W, H>& mat);

  template<typename T, int W, int H>
  inline Mat<T, W, H>& add(Mat<T, W, H>& m, const Mat<T, W, H>& mat );

  template<typename T, int W, int H>
  inline Mat<T, W, H>  add(const Mat<T, W, H>& m, const Mat<T, W, H>& mat );

  template<typename T, int W, int H>
  inline Mat<T, W, H>& multLeft(Mat<T, W, H>& m, const Mat<T, W, H>& mat );

  template<typename T, int W, int H>
  inline Mat<T, W, H>  multLeft(const Mat<T, W, H>& m, const Mat<T, W, H>& mat );

}; // namespace matrix


/* --------------------------------------------------------------- *\
    the matrix class
\* --------------------------------------------------------------- */

template<typename T, int W, int H>
class Mat
{
  public:

    typedef T                         ValType;
    typedef const T                   ConstValType;
    typedef T*                        ValTypePtr;
    typedef const T*                  ConstValTypePtr;

    typedef Mat<ValType, W, H>        MatType;
    typedef const Mat<ValType, W, H>  ConstMatType;

    typedef Traits<Mat<T, W, H> >     Trait;
    typedef Traits<T>                 ValTrait;

  public:
/* --------------------------------------------------------------- *\
     constructor
\* --------------------------------------------------------------- */
    Mat() { };
    Mat(const ValType&   scalar)    { operator=(scalar); }
    Mat(const ValTypePtr valptr)    { operator=(valptr); }
    Mat(const MatType&   mat)       { operator=(mat); }

    static unsigned int width()    { return W; };
    static unsigned int height()   { return H; };
    static unsigned int size()     { return W * H; };
    static unsigned int bytesize() { return sizeof(Mat<T, W, H>); }
/* --------------------------------------------------------------- *\
     accessors
\* --------------------------------------------------------------- */
    ValTypePtr        begin()       { return val[0].begin(); }
    ConstValTypePtr   begin() const { return val[0].begin(); }
    ValTypePtr        end()         { return val[W-1].end(); }
    ConstValTypePtr   end()   const { return val[W-1].end(); }

    ValType&       operator()(const int i, const int j)       { return val[i][j]; }
    const ValType& operator()(const int i, const int j) const { return val[i][j]; }

    ValType&       operator[](const int i)       { return (&val)[i]; }
    const ValType& operator[](const int i) const { return (&val)[i]; }


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

    inline MatType& operator=(ConstValType&    scalar);
    inline MatType& operator=(ConstValTypePtr  valptr);
    inline MatType& operator=(ConstMatType&    mat);

    inline MatType  operator+(ConstMatType&    mat)          const;
    inline MatType  operator-(ConstMatType&    mat)          const;
    inline MatType& operator+=(ConstMatType&   mat);
    inline MatType& operator-=(ConstMatType&   mat);

    template<int WW>
    inline Mat<T, WW, H> operator*(const Mat<T, WW, W>& mat) const;
    inline Vec<T, W> operator*(const Vec<T, W>& vec)         const;

    inline MatType& operator*=(const Mat<T, H, W>& mat);

    inline MatType  operator*(ConstValType& scalar)          const;
    inline MatType  operator/(ConstValType& scalar)          const;
    inline MatType& operator*=(ConstValType& scalar);
    inline MatType& operator/=(ConstValType& scalar);

 public:
    Vec<T, H> val[W];

}; // class Mat

#include <ak/matrix.inl>

}; // namespace math

#endif // _MATRIX_HPP_
/* --------------------------------------------------------------- *\
\* --------------------------------------------------------------- */

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

---