mat2.h

Go to the documentation of this file.

/*
 * $Id: mat2.h,v 1.5 2003/09/15 17:15:31 jmk Exp $
 */
///////////////////////////////////////////////////////////////////////////
//              _____________  ______________________    __   __  _____
//             /  ________  |  |   ___   ________   /   |  \ /  \   |
//            |  |       |  |_ |  |_ |  |       /  /    \__  |      |
//            |  |  ___  |  || |  || |  |      /  /        | |      |
//            |  | |   \ |  || |  || |  |     /  /      \__/ \__/ __|__
//            |  | |_@  ||  || |  || |  |    /  /          Institute
//            |  |___/  ||  ||_|  || |  |   /  /_____________________
//             \_______/  \______/ | |__|  /___________________________
//                        |  |__|  |
//                         \______/
//                    University of Utah       
//                           2002
///////////////////////////////////////////////////////////////////////////

// mat2.h

#ifndef mat2_h
#define mat2_h

#include "mm.h"

namespace gutz {

template <class T>
class vec2;

template <class T>
class mat2 {

public:
    //defaults to identity
    inline mat2 ();
    inline mat2 (const T);
    inline mat2 (const T*);
    inline mat2 (const T, const T, const T, const T);
    inline mat2 (const vec2<T>&, const vec2<T>&);
    inline mat2 (const mat2<T>& M);
    // inline mat2 (const mat2&); use default
    inline ~mat2 () {}

    // inline mat2& operator= (const mat2&); use default
    inline mat2& operator+= (const mat2&);
    inline mat2& operator-= (const mat2&);
    inline mat2& operator*= (const T);
    inline mat2& operator/= (const T);
    inline mat2& operator*= (const mat2&);
  
    inline mat2 operator+ (const mat2&) const;
    inline mat2 operator- (const mat2&) const;
    inline mat2 operator- () const;
    inline mat2 operator* (const T) const;
    inline mat2 operator/ (const T) const;
    inline mat2 operator* (const mat2&) const;
    inline vec2<T> operator* (const vec2<T>&) const;

    inline T* v ();
        inline const T* v () const;
    inline void set (const T, const T, const T, const T);
    inline T& operator[] (const int);

    inline void zero ();
    inline void eye ();

    inline vec2<T>& x() const;
    inline vec2<T>& y() const;
  
    inline mat2 inv () const;
    inline mat2 tp () const;

public:
    T m[4];
};

//-----------------------------------------------------------------------------
// Typedefs
//-----------------------------------------------------------------------------
typedef mat2<uchar>     mat2ub;
typedef mat2<int>       mat2i;
typedef mat2<uint>      mat2ui;
typedef mat2<float>     mat2f;
typedef mat2<double>    mat2d;

//-----------------------------------------------------------------------------
// External functions
//-----------------------------------------------------------------------------

template <class T>
inline
mat2<T>
operator* (const T, const mat2<T>&);

// rotation matrix
template <class T>
mat2<T>
rot (const T);

// diagonal matrix
template <class T>
mat2<T>
diag (const vec2<T>&);

template <class T>
std::ostream&
operator<< (std::ostream& os, const mat2<T>& M)
{
    os << M.m[0] << " " << M.m[2] << "\n"
       << M.m[1] << " " << M.m[3];
    return os;
}

template <class T>
std::istream&
operator>> (std::istream& os, mat2<T>& M)
{
   is >> M.m[0] >> M.m[2];
   is >> M.m[1] >> M.m[3];
   return is;
}

template <class T>
bool
str2mat2 (const std::string& s, mat2<T>& v)
{
   std::istringstream z(s);
   mat2<T> w;
   bool status = z.eof();
   for (int i=0; i<3; i++)
   {
      z >> w.m[i];
      status = status || z.fail() || z.eof();
   }
   z >> w.m[3];
   status = status || z.fail();
   if (!status) v = w.tp();
   return status;
}

template <class T>
bool
str2mat2 (const std::string*, mat2<T>&);

//-----------------------------------------------------------------------------
// Implementation
//-----------------------------------------------------------------------------

template <class T>
mat2<T>::mat2 ()
{
    m[0] = 1; m[1] = 0;
    m[2] = 0; m[3] = 1;
}

template <class T>
mat2<T>::mat2 (const T c)
{
    m[0] = c; m[1] = c;
    m[2] = c; m[3] = c;
}

template <class T>
mat2<T>::mat2 (const T* v)
{
    m[0] = v[0]; m[1] = v[1];
    m[2] = v[2]; m[3] = v[3];
}

template <class T>
mat2<T>::mat2 (const T m0, const T m1,
               const T m2, const T m3)
{
    m[0] = m0; m[1] = m1;
    m[2] = m2; m[3] = m3;
}

template <class T>
mat2<T>::mat2 (const vec2<T>& c0, const vec2<T>& c1)
{
    m[0] = c0.x; m[1] = c0.y;
    m[2] = c1.x; m[3] = c1.y;
}

template <class T>
mat2<T>::mat2 (const mat2<T>& M)
{
  m[0] = M.m[0];
  m[1] = M.m[1];
  m[2] = M.m[2];
  m[3] = M.m[3];
}


template <class T>
mat2<T>&
mat2<T>::operator+= (const mat2<T>& M)
{  
    m[0] += M.m[0]; m[1] += M.m[1];
    m[2] += M.m[2]; m[3] += M.m[3];
    return *this;
}

template <class T>
mat2<T>&
mat2<T>::operator-= (const mat2<T>& M)
{
    m[0] -= M.m[0]; m[1] -= M.m[1];
    m[2] -= M.m[2]; m[3] -= M.m[3];
    return *this;
}

template <class T>
mat2<T>&
mat2<T>::operator*= (T c)
{
    m[0] *= c; m[1] *= c;
    m[2] *= c; m[3] *= c;
    return *this;
}

template <class T>
mat2<T>&
mat2<T>::operator/= (T c)
{
    T d = 1/c;
    m[0] *= d; m[1] *= d;
    m[2] *= d; m[3] *= d;
    return *this;
}

template <class T>
mat2<T>&
mat2<T>::operator*= (const mat2& M)
{
    mat2<T> temp(*this);
    m[0] = temp.m[0]*M.m[0] + temp.m[2]*M.m[1];
    m[1] = temp.m[1]*M.m[0] + temp.m[3]*M.m[1];
    m[2] = temp.m[0]*M.m[2] + temp.m[2]*M.m[3];
    m[3] = temp.m[1]*M.m[2] + temp.m[3]*M.m[3];
    return *this;
}

template <class T>
mat2<T>
mat2<T>::operator+ (const mat2& M) const
{
    return mat2(m[0] + M.m[0], m[1] + M.m[1],
                m[2] + M.m[2], m[3] + M.m[3]);
}

template <class T>
mat2<T>
mat2<T>::operator- (const mat2& M) const
{
    return mat2(m[0] - M.m[0], m[1] - M.m[1],
                m[2] - M.m[2], m[3] - M.m[3]);
}

template <class T>
mat2<T>
mat2<T>::operator- () const
{
    return mat2(-m[0], -m[2],
                -m[1], -m[3]);
}

template <class T>
mat2<T>
mat2<T>::operator* (T c) const
{
    return mat2(m[0]*c, m[2]*c,
                m[1]*c, m[3]*c);
}

template <class T>
mat2<T>
mat2<T>::operator/ (T c) const
{
    T d = 1/c;
    return mat2(m[0]*d, m[1]*d,
                m[2]*d, m[3]*d);
}

template <class T>
mat2<T>
mat2<T>::operator* (const mat2& M) const
{
    return mat2(m[0]*M.m[0] + m[2]*M.m[1], m[1]*M.m[0] + m[3]*M.m[1],
                m[0]*M.m[2] + m[2]*M.m[3], m[1]*M.m[2] + m[3]*M.m[3]);
}

template <class T>
vec2<T>
mat2<T>::operator* (const vec2<T>& v) const
{
    return vec2<T>(m[0]*v.x + m[2]*v.y, m[1]*v.x + m[3]*v.y);
}

template <class T>
T*
mat2<T>::v ()
{
    return m;
}

template <class T>
const T*
mat2<T>::v () const
{
    return m;
}


template <class T>
void
mat2<T>::set (const T m0, const T m1,
              const T m2, const T m3)
{
    m[0] = m0; m[1] = m1;
    m[2] = m2; m[3] = m3;
}

template <class T>
T&
mat2<T>::operator[] (const int i)
{
    return v()[i];
}

template <class T>
void
mat2<T>::zero ()
{
    m[0] = 0; m[1] = 0;
    m[2] = 0; m[3] = 0;
}

template <class T>
void
mat2<T>::eye ()
{
    m[0] = 1; m[1] = 0;
    m[2] = 0; m[3] = 1;
}

template <class T>
vec2<T>&
mat2<T>::x () const
{
    return (vec2<T>&)m[0];
}

template <class T>
vec2<T>&
mat2<T>::y () const
{
    return (vec2<T>&)m[2];
}

template <class T>
mat2<T>
mat2<T>::inv () const
{
    T d = 1 / (m[0]*m[3] - m[2]*m[1]);
    return mat2(m[3]*d, -m[2]*d,
                -m[1]*d, m[0]*d);
}

template <class T>
mat2<T>
mat2<T>::tp () const
{
    return mat2(m[0], m[2],
                m[1], m[3]);
}

template <class T>
mat2<T>
operator* (const T c, const mat2<T>& M)
{
    return mat2<T> (M.m[0]*c, M.m[1]*c,
                    M.m[2]*c, M.m[3]*c);
}

template <class T>
mat2<T>
rot (const T angle)
{
    T ca = cos(angle);
    T sa = sin(angle);
    return mat2<T>(ca, sa,
                   -sa, ca);
}

template <class T>
mat2<T>
diag (const vec2<T>& v)
{
    return mat2<T>(v.x, 0,
                   0, v.y);
}

template <class T>
bool
str2mat2 (const std::string* s, mat2<T>& M)
{
    if (!s) return true;
    return str2mat2(*s, M);
}

//-----------------------------------------------------------------------------

typedef mat2<float> mat2f;
typedef mat2<double> mat2d;

#if __win32
inline
mat2d
mm_castf2d (mat2f M)
{
    return mat2d(M.m[0], M.m[1],
                 M.m[2], M.m[3]);
}

inline
mat2f
mm_castd2f (mat2d M)
{
    return mat2f((float)M.m[0], (float)M.m[1],
                 (float)M.m[2], (float)M.m[3]);
}
#else //__real_os
template <class T1, class T2>
mat2<T2>
mm_cast (mat2<T1> v)
{
    return mat2<T2>(M.m[0], M.m[1],
                    M.m[2], M.m[3]);
}
#endif

} // End of namespace gutz

#endif // mat2_h

---

Send questions, comments, and bug reports to: