WebSVN – gelsvn – Diff – /branches/MPC/src/CGLA/ArithSqMat2x2Float.h


#ifndef __CGLA_ARITHSQMAT2X2FLOAT_H__
#define __CGLA_ARITHSQMAT2X2FLOAT_H__
 
#include "ExceptionStandard.h"
#include "ArithSqMatFloat.h"
 
 
namespace CGLA 
{
 
  CGLA_DERIVEEXCEPTION(Mat2x2fException);
 
  /** Two by two float matrix. This class 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)/branches/MPC/src/CGLA/ArithSqMat2x2Float.h – Rev 12 → 67

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