Subversion Repositories gelsvn

Rev

Rev 10 | Rev 44 | 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 
 
12 jab 59 
      void identity()
60 
	{
61 
	  for(int i=0;i<ROWS;++i)
62 
	    {
63 
	      for(int j=0;j<ROWS;++j)
64 
		(*this)[i][j] = ScalarType(0);
65 
	      (*this)[i][i] = ScalarType(1);
66 
	    }
67 
	}
2 bj 68 
 
69 
 
12 jab 70 
    };
2 bj 71 
 
12 jab 72 
  /** Multiply two matrices derived from same type,
73 
      producing a new of same type */
74 
  template <class VT, class MT, int ROWS>
75 
    inline MT operator*(const ArithSqMatFloat<VT,MT,ROWS>& m1,
76 
			const ArithSqMatFloat<VT,MT,ROWS>& m2)
77 
    {
78 
      MT n;
79 
      for(int i=0;i<ROWS;i++)
80 
	for(int j=0;j<ROWS;j++)
81 
	  {
82 
	    n[i][j] = 0;
83 
	    for(int k=0;k<ROWS;k++)
84 
	      n[i][j] += m1[i][k] * m2[k][j];
85 
	  }
86 
      return n;
87 
    }
2 bj 88 
 
12 jab 89 
  /** Compute the transpose of a square matrix. This function returns
90 
      the transpose of its argument. */
91 
  template <class VT, class MT, int ROWS>
92 
    inline MT transpose(const ArithSqMatFloat<VT,MT,ROWS>& m)
93 
    {
94 
      MT m_new;
95 
      for(int i=0;i<MT::get_v_dim();i++)
96 
	for(int j=0;j<MT::get_h_dim();j++)
97 
	  m_new[i][j] = m[j][i];
98 
      return m_new;
99 
    }
2 bj 100 
 
12 jab 101 
  /// Compute trace. Works only for sq. matrices.
102 
  template <class VT, class MT, int ROWS>
103 
    inline typename MT::ScalarType trace(const ArithSqMatFloat<VT,MT,ROWS>& M)
104 
    {
105 
      typename ArithSqMatFloat<VT,MT,ROWS>::ScalarType s=0;
106 
      for(int i=0;i<ROWS;i++)
107 
	s += M[i][i];
108 
      return s;
109 
    }
2 bj 110 
 
111 
}
112 
#endif