WebSVN – gelsvn – Diff – /trunk/src/CGLA/ArithSqMat2x2Float.h


#ifndef __CGLA_ARITHSQMAT2X2FLOAT_H__
#define __CGLA_ARITHSQMAT2X2FLOAT_H__
 
#include "ExceptionStandard.h"
#include "ArithSqMatFloat.h"
 
 
namespace CGLA 
{
 
  CGLA_DERIVEEXCEPTION(Mat2x2fException);
 
  /** \brief Two by two float matrix template. 
 
 
	This class template is useful for various vector transformations 
	in the plane. */
  template<class V, class M>
  class ArithSqMat2x2Float: public ArithSqMatFloat<V,M, 2>
  {
  public:
 
    /// Vector type
    typedef V VectorType;
 
    /// The type of a matrix element
    typedef typename V::ScalarType ScalarType;
 
  public:
 
    /// Construct a Mat2x2f from two Vec2f vectors.
    ArithSqMat2x2Float(V a, V b): 
      ArithSqMatFloat<V, M, 2> (a,b) {}
 
    /// Construct a Mat2x2f from four scalars.
    ArithSqMat2x2Float(ScalarType a, ScalarType b, 
		       ScalarType c, ScalarType d): 
      ArithSqMatFloat<V, M, 2>(V(a,b),V(c,d)) {}
  
    /// Construct the NAN matrix
    ArithSqMat2x2Float() {}
 
    /// Construct a matrix from a single scalar value.
    explicit ArithSqMat2x2Float(ScalarType a): 
      ArithSqMatFloat<V, M, 2>(a) {}
  };
 
  /** Compute the determinant of a Mat2x2f. This function is faster than
      the generic determinant function for ArithSqMat */
  template<class V, class M>
  inline typename ArithSqMat2x2Float<V,M>::ScalarType 
  determinant(const ArithSqMat2x2Float<V,M> & m)
  {
    return m[0][0]*m[1][1]-m[0][1]*m[1][0];
  }
 
  template<class V, class M>
  const M invert(const ArithSqMat2x2Float<V,M>& m)
  {
    typename M::ScalarType det = determinant(m);
    if( !is_tiny(fabs(det)))
      {
	return M(m[1][1]/det, -m[0][1]/det,-m[1][0]/det, m[0][0]/det);
      }
    throw Mat2x2fException("Cannot invert matrix");
  }
 
 
}
#endif
 

Subversion Repositories gelsvn

(root)/trunk/src/CGLA/ArithSqMat2x2Float.h – Rev 12 → 89

Rev 12		Rev 89
1	`#ifndef __CGLA_ARITHSQMAT2X2FLOAT_H__`	1	`#ifndef __CGLA_ARITHSQMAT2X2FLOAT_H__`
2	`#define __CGLA_ARITHSQMAT2X2FLOAT_H__`	2	`#define __CGLA_ARITHSQMAT2X2FLOAT_H__`
3		3
4	`#include "ExceptionStandard.h"`	4	`#include "ExceptionStandard.h"`
5	`#include "ArithSqMatFloat.h"`	5	`#include "ArithSqMatFloat.h"`
6		6
7		7
8	`namespace CGLA`	8	`namespace CGLA`
9	`{`	9	`{`
10		10
11	`CGLA_DERIVEEXCEPTION(Mat2x2fException);`	11	`CGLA_DERIVEEXCEPTION(Mat2x2fException);`
12		12
13	`/** Two by two float matrix. This class is useful for various`	13	`/** \brief Two by two float matrix template.`
14	`vector transformations in the plane. */`	-
15		14
-		15	`This class template is useful for various vector transformations`
-		16	`in the plane. */`
16	`template<class V, class M>`	17	`template<class V, class M>`
17	`class ArithSqMat2x2Float: public ArithSqMatFloat<V,M, 2>`	18	`class ArithSqMat2x2Float: public ArithSqMatFloat<V,M, 2>`
18	`{`	19	`{`
19	`public:`	20	`public:`
20		21
21	`/// Vector type`	22	`/// Vector type`
22	`typedef V VectorType;`	23	`typedef V VectorType;`
23		24
24	`/// The type of a matrix element`	25	`/// The type of a matrix element`
25	`typedef typename V::ScalarType ScalarType;`	26	`typedef typename V::ScalarType ScalarType;`
26		27
27	`public:`	28	`public:`
28		29
29	`/// Construct a Mat2x2f from two Vec2f vectors.`	30	`/// Construct a Mat2x2f from two Vec2f vectors.`
30	`ArithSqMat2x2Float(V a, V b):`	31	`ArithSqMat2x2Float(V a, V b):`
31	`ArithSqMatFloat<V, M, 2> (a,b) {}`	32	`ArithSqMatFloat<V, M, 2> (a,b) {}`
32		33
33	`/// Construct a Mat2x2f from four scalars.`	34	`/// Construct a Mat2x2f from four scalars.`
34	`ArithSqMat2x2Float(ScalarType a, ScalarType b,`	35	`ArithSqMat2x2Float(ScalarType a, ScalarType b,`
35	`ScalarType c, ScalarType d):`	36	`ScalarType c, ScalarType d):`
36	`ArithSqMatFloat<V, M, 2>(V(a,b),V(c,d)) {}`	37	`ArithSqMatFloat<V, M, 2>(V(a,b),V(c,d)) {}`
37		38
38	`/// Construct the NAN matrix`	39	`/// Construct the NAN matrix`
39	`ArithSqMat2x2Float() {}`	40	`ArithSqMat2x2Float() {}`
40		41
41	`/// Construct a matrix from a single scalar value.`	42	`/// Construct a matrix from a single scalar value.`
42	`explicit ArithSqMat2x2Float(ScalarType a):`	43	`explicit ArithSqMat2x2Float(ScalarType a):`
43	`ArithSqMatFloat<V, M, 2>(a) {}`	44	`ArithSqMatFloat<V, M, 2>(a) {}`
44	`};`	45	`};`
45		46
46	`/** Compute the determinant of a Mat2x2f. This function is faster than`	47	`/** Compute the determinant of a Mat2x2f. This function is faster than`
47	`the generic determinant function for ArithSqMat */`	48	`the generic determinant function for ArithSqMat */`
48	`template<class V, class M>`	49	`template<class V, class M>`
49	`inline typename ArithSqMat2x2Float<V,M>::ScalarType`	50	`inline typename ArithSqMat2x2Float<V,M>::ScalarType`
50	`determinant(const ArithSqMat2x2Float<V,M> & m)`	51	`determinant(const ArithSqMat2x2Float<V,M> & m)`
51	`{`	52	`{`
52	`return m[0][0]m[1][1]-m[0][1]m[1][0];`	53	`return m[0][0]m[1][1]-m[0][1]m[1][0];`
53	`}`	54	`}`
54		55
55	`template<class V, class M>`	56	`template<class V, class M>`
56	`const M invert(const ArithSqMat2x2Float<V,M>& m)`	57	`const M invert(const ArithSqMat2x2Float<V,M>& m)`
57	`{`	58	`{`
58	`typename M::ScalarType det = determinant(m);`	59	`typename M::ScalarType det = determinant(m);`
59	`if( !is_tiny(fabs(det)))`	60	`if( !is_tiny(fabs(det)))`
60	`{`	61	`{`
61	`return M(m[1][1]/det, -m[0][1]/det,-m[1][0]/det, m[0][0]/det);`	62	`return M(m[1][1]/det, -m[0][1]/det,-m[1][0]/det, m[0][0]/det);`
62	`}`	63	`}`
63	`throw Mat2x2fException("Cannot invert matrix");`	64	`throw Mat2x2fException("Cannot invert matrix");`
64	`}`	65	`}`
65		66
66		67
67	`}`	68	`}`
68	`#endif`	69	`#endif`
69		70