Subversion Repositories gelsvn

Rev

Rev 22 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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