Subversion Repositories gelsvn

Rev

Rev 12 | Rev 45 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 bj 1 
#ifndef __CGLA_ARITHSQMATFLOAT_H__
2 
#define __CGLA_ARITHSQMATFLOAT_H__
3 
 
4 
#include "ArithMatFloat.h"
5 
 
12 jab 6 
namespace CGLA
7 
{
2 bj 8 
 
12 jab 9 
  /** Template for square matrices.
10 
      Some functions like trace and determinant work only on
11 
      square matrices. To express this in the class hierarchy,
12 
      ArithSqMatFloat was created. ArithSqMatFloat is derived from ArithMat
13 
      and contains a few extra facilities applicable only to
14 
      square matrices.
15 
  */
16 
  template <class VT, class MT, int ROWS>
17 
    class ArithSqMatFloat: public ArithMatFloat<VT,VT,MT,ROWS>
18 
    {
19 
    public:
2 bj 20 
 
12 jab 21 
      /// Vector type
22 
      typedef VT VectorType;
2 bj 23 
 
12 jab 24 
      /// The type of a matrix element
25 
      typedef typename VT::ScalarType ScalarType;
2 bj 26 
 
12 jab 27 
    protected:
2 bj 28 
 
12 jab 29 
      /// Construct 0 matrix
30 
      ArithSqMatFloat() {}
2 bj 31 
 
12 jab 32 
      /// Construct matrix where all values are equal to constructor argument.
33 
      explicit ArithSqMatFloat(ScalarType _a):
34 
	ArithMatFloat<VT,VT,MT,ROWS>(_a) {}
2 bj 35 
 
12 jab 36 
      /// Construct 2x2 Matrix from two vectors
37 
      ArithSqMatFloat(VT _a, VT _b):
38 
	ArithMatFloat<VT,VT,MT,ROWS>(_a,_b) {}
2 bj 39 
 
12 jab 40 
      /// Construct 3x3 Matrix from three vectors
41 
      ArithSqMatFloat(VT _a, VT _b, VT _c):
42 
	ArithMatFloat<VT,VT,MT,ROWS>(_a,_b,_c) {}
2 bj 43 
 
12 jab 44 
      /// Construct 4x4 Matrix from four vectors
45 
      ArithSqMatFloat(VT _a, VT _b, VT _c, VT _d):
46 
	ArithMatFloat<VT,VT,MT,ROWS>(_a,_b,_c,_d) {}
2 bj 47 
 
12 jab 48 
    public:
2 bj 49 
 
12 jab 50 
      /** Assignment multiplication of matrices.
51 
	  This function is not very efficient. This because we need a temporary
52 
	  matrix anyway, so it can't really be made efficient. */
53 
      const MT& operator*=(const MT& m2)
54 
	{
55 
	  (*this) = (*this) * m2;
56 
	  return static_cast<const MT&>(*this);
57 
	}
2 bj 58 
 
44 jrf 59 
      const MT& operator *=(ScalarType k)
60 
	{
61 
	  return ArithMatFloat<VT,VT,MT,ROWS>::operator*=(k);
62 
	}
63 
 
12 jab 64 
      void identity()
65 
	{
66 
	  for(int i=0;i<ROWS;++i)
67 
	    {
68 
	      for(int j=0;j<ROWS;++j)
69 
		(*this)[i][j] = ScalarType(0);
70 
	      (*this)[i][i] = ScalarType(1);
71 
	    }
72 
	}
2 bj 73 
 
74 
 
12 jab 75 
    };
2 bj 76 
 
12 jab 77 
  /** Multiply two matrices derived from same type,
78 
      producing a new of same type */
79 
  template <class VT, class MT, int ROWS>
80 
    inline MT operator*(const ArithSqMatFloat<VT,MT,ROWS>& m1,
81 
			const ArithSqMatFloat<VT,MT,ROWS>& m2)
82 
    {
83 
      MT n;
84 
      for(int i=0;i<ROWS;i++)
85 
	for(int j=0;j<ROWS;j++)
86 
	  {
87 
	    n[i][j] = 0;
88 
	    for(int k=0;k<ROWS;k++)
89 
	      n[i][j] += m1[i][k] * m2[k][j];
90 
	  }
91 
      return n;
92 
    }
2 bj 93 
 
12 jab 94 
  /** Compute the transpose of a square matrix. This function returns
95 
      the transpose of its argument. */
96 
  template <class VT, class MT, int ROWS>
97 
    inline MT transpose(const ArithSqMatFloat<VT,MT,ROWS>& m)
98 
    {
99 
      MT m_new;
100 
      for(int i=0;i<MT::get_v_dim();i++)
101 
	for(int j=0;j<MT::get_h_dim();j++)
102 
	  m_new[i][j] = m[j][i];
103 
      return m_new;
104 
    }
2 bj 105 
 
12 jab 106 
  /// Compute trace. Works only for sq. matrices.
107 
  template <class VT, class MT, int ROWS>
108 
    inline typename MT::ScalarType trace(const ArithSqMatFloat<VT,MT,ROWS>& M)
109 
    {
110 
      typename ArithSqMatFloat<VT,MT,ROWS>::ScalarType s=0;
111 
      for(int i=0;i<ROWS;i++)
112 
	s += M[i][i];
113 
      return s;
114 
    }
2 bj 115 
 
116 
}
117 
#endif