Matrix3 Class Reference

Specialisation of MatrixN to aid 3 dimensional rotations. More...

#include <Matrix3.hh>

Inheritance diagram for Matrix3:

[legend]

Collaboration diagram for Matrix3:

[legend]

List of all members.

Public Member Functions
	Matrix3 ()
	Matrix3 (const Matrix< 3 > &m3)
	Matrix3 (const Vector3 &axis, const double angle)
	Matrix3 (const Vector3 &from, const Vector3 &to)
Matrix3 &	setAsRotation (const Vector3 &from, const Vector3 &to)
Matrix &	set (const size_t i, const size_t j, const double value)
double	get (const size_t i, const size_t j) const
Vector< N >	getRow (const size_t row) const
Matrix< N > &	setRow (const size_t row, const Vector< N > &r)
Vector< N >	getColumn (const size_t col) const
Matrix< N > &	setColumn (const size_t col, const Vector< N > &c)
Matrix< N >	transpose () const
Matrix< N >	inverse () const
	Calculate inverse.
double	det () const
	Calculate determinant.
double	trace () const
	Calculate trace.
Matrix< N >	operator- () const
	Negate.
size_t	size () const
	Get dimensionality.
bool	isZero (double tolerance=1E-5) const
	Index-wise check for nullness, allowing for numerical precision.
bool	isEqual (Matrix< N > other) const
	Check for index-wise equality, allowing for numerical precision.
bool	isSymm () const
	Check for symmetry under transposition.
bool	isDiag () const
	Check that all off-diagonal elements are zero, allowing for numerical precision.
bool	operator== (const Matrix< N > &a) const
bool	operator!= (const Matrix< N > &a) const
bool	operator< (const Matrix< N > &a) const
bool	operator<= (const Matrix< N > &a) const
bool	operator> (const Matrix< N > &a) const
bool	operator>= (const Matrix< N > &a) const
Matrix< N > &	operator*= (const Matrix< N > &m)
Matrix< N > &	operator*= (const double a)
Matrix< N > &	operator/= (const double a)
Matrix< N > &	operator+= (const Matrix< N > &m)
Matrix< N > &	operator-= (const Matrix< N > &m)
Static Public Member Functions
static Matrix3	mkXRotation (const double angle)
static Matrix3	mkYRotation (const double angle)
static Matrix3	mkZRotation (const double angle)
static Matrix< N >	mkZero ()
static Matrix< N >	mkDiag (Vector< N > diag)
static Matrix< N >	mkIdentity ()
Protected Types
typedef Eigen::Matrix< double, N >	EMatrix
Protected Attributes
EMatrix	_matrix

Detailed Description

Specialisation of MatrixN to aid 3 dimensional rotations.

Definition at line 13 of file Matrix3.hh.

Member Typedef Documentation

typedef Eigen::Matrix<double,N> EMatrix [protected, inherited]

Definition at line 253 of file MatrixN.hh.

Constructor & Destructor Documentation

Matrix3 ( ) [inline]

Definition at line 15 of file Matrix3.hh.

Referenced by Matrix3::mkXRotation(), Matrix3::mkYRotation(), and Matrix3::mkZRotation().

00015 { }

Matrix3 ( const Matrix< 3 > & m3 ) [inline]

Definition at line 17 of file Matrix3.hh.

00017 :  Matrix<3>::Matrix(m3) { }

Matrix3	(	const Vector3 &	axis,
		const double	angle
	)			`[inline]`

Definition at line 19 of file Matrix3.hh.

References Matrix< 3 >::_matrix, Vector< N >::_vec, and Vector3::unit().

00019                                                      {
00020       const Vector3 normaxis = axis.unit();
00021       _matrix.loadRotation3(angle, normaxis._vec);
00022     }

Matrix3	(	const Vector3 &	from,
		const Vector3 &	to
	)			`[inline]`

Definition at line 24 of file Matrix3.hh.

References Matrix3::setAsRotation().

00024                                                     {
00025       setAsRotation(from, to);
00026     }

Member Function Documentation

double det ( ) const [inline, inherited]

Calculate determinant.

Definition at line 141 of file MatrixN.hh.

00141                         {
00142       return _matrix.determinant();
00143     }

double get	(	const size_t	i,
		const size_t	j
	)			const `[inline, inherited]`

Definition at line 84 of file MatrixN.hh.

00084                                                      {
00085       if (i < N && j < N) {
00086         return _matrix(i, j);
00087       } else {
00088         throw std::runtime_error("Attempted get access outside matrix bounds.");
00089       }
00090     }

Vector<N> getColumn ( const size_t col ) const [inline, inherited]

Definition at line 107 of file MatrixN.hh.

00107                                                 {
00108       Vector<N> rtn;
00109       for (size_t i = 0; i < N; ++i) {
00110         rtn.set(i, _matrix(i,col));
00111       }
00112       return rtn;
00113     }

Vector<N> getRow ( const size_t row ) const [inline, inherited]

Definition at line 92 of file MatrixN.hh.

00092                                              {
00093       Vector<N> rtn;
00094       for (size_t i = 0; i < N; ++i) {
00095         rtn.set(i, _matrix(row,i));
00096       }
00097       return rtn;
00098     }

Matrix<N> inverse ( ) const [inline, inherited]

Calculate inverse.

Definition at line 134 of file MatrixN.hh.

00134                               {
00135       Matrix<N> tmp;
00136       tmp._matrix = _matrix.inverse();
00137       return tmp;
00138     }

bool isDiag ( ) const [inline, inherited]

Check that all off-diagonal elements are zero, allowing for numerical precision.

Definition at line 193 of file MatrixN.hh.

00193                         {
00194       for (size_t i=0; i < N; ++i) {
00195         for (size_t j=0; j < N; ++j) {
00196           if (i == j) continue;
00197           if (! Rivet::isZero(_matrix(i,j)) ) return false;
00198         }
00199       }
00200       return true;
00201     }

bool isEqual ( Matrix< N > other ) const [inline, inherited]

Check for index-wise equality, allowing for numerical precision.

Definition at line 178 of file MatrixN.hh.

00178                                         {
00179       for (size_t i=0; i < N; ++i) {
00180         for (size_t j=i; j < N; ++j) {
00181           if (! Rivet::isZero(_matrix(i,j) - other._matrix(i,j)) ) return false;
00182         }
00183       }
00184       return true;
00185     }

bool isSymm ( ) const [inline, inherited]

Check for symmetry under transposition.

Definition at line 188 of file MatrixN.hh.

00188                         {
00189       return isEqual(this->transpose());
00190     }

bool isZero ( double tolerance = 1E-5 ) const [inline, inherited]

Index-wise check for nullness, allowing for numerical precision.

Definition at line 168 of file MatrixN.hh.

00168                                              {
00169       for (size_t i=0; i < N; ++i) {
00170         for (size_t j=0; j < N; ++j) {
00171           if (! Rivet::isZero(_matrix(i,j), tolerance) ) return false;
00172         }
00173       }
00174       return true;
00175     }

static Matrix<N> mkDiag ( Vector< N > diag ) [inline, static, inherited]

Definition at line 48 of file MatrixN.hh.

00048                                             {
00049       Matrix<N> rtn;
00050       for (size_t i = 0; i < N; ++i) {
00051         rtn.set(i, i, diag[i]);
00052       }
00053       return rtn;
00054     }

static Matrix<N> mkIdentity ( ) [inline, static, inherited]

Definition at line 56 of file MatrixN.hh.

00056                                   {
00057       Matrix<N> rtn;
00058       for (size_t i = 0; i < N; ++i) {
00059         rtn.set(i, i, 1);
00060       }
00061       return rtn;
00062     }

static Matrix3 mkXRotation ( const double angle ) [inline, static]

Definition at line 29 of file Matrix3.hh.

References Matrix3::Matrix3().

00029                                                    {
00030       return Matrix3(Vector3(1,0,0), angle);
00031     }

static Matrix3 mkYRotation ( const double angle ) [inline, static]

Definition at line 33 of file Matrix3.hh.

References Matrix3::Matrix3().

00033                                                    {
00034       return Matrix3(Vector3(0,1,0), angle);
00035     }

static Matrix<N> mkZero ( ) [inline, static, inherited]

Definition at line 43 of file MatrixN.hh.

00043                               {
00044       Matrix<N> rtn;
00045       return rtn;
00046     }

static Matrix3 mkZRotation ( const double angle ) [inline, static]

Definition at line 37 of file Matrix3.hh.

References Matrix3::Matrix3().

00037                                                    {
00038       return Matrix3(Vector3(0,0,1), angle);
00039     }

bool operator!= ( const Matrix< N > & a ) const [inline, inherited]

Definition at line 207 of file MatrixN.hh.

00207                                               {
00208       return _matrix != a._matrix;
00209     }

Matrix<N>& operator*= ( const double a ) [inline, inherited]

Definition at line 232 of file MatrixN.hh.

00232                                           {
00233       _matrix *= a;
00234       return *this;
00235     }

Matrix<N>& operator*= ( const Matrix< N > & m ) [inline, inherited]

Definition at line 227 of file MatrixN.hh.

00227                                               {
00228       _matrix = _matrix * m._matrix;
00229       return *this;
00230     }

Matrix<N>& operator+= ( const Matrix< N > & m ) [inline, inherited]

Definition at line 242 of file MatrixN.hh.

00242                                               {
00243       _matrix += m._matrix;
00244       return *this;
00245     }

Matrix<N> operator- ( ) const [inline, inherited]

Negate.

Definition at line 156 of file MatrixN.hh.

00156                                 {
00157       Matrix<N> rtn;
00158       rtn._matrix = -_matrix;
00159       return rtn;
00160     }

Matrix<N>& operator-= ( const Matrix< N > & m ) [inline, inherited]

Definition at line 247 of file MatrixN.hh.

00247                                               {
00248       _matrix -= m._matrix;
00249       return *this;
00250     }

Matrix<N>& operator/= ( const double a ) [inline, inherited]

Definition at line 237 of file MatrixN.hh.

00237                                           {
00238       _matrix /= a;
00239       return *this;
00240     }

bool operator< ( const Matrix< N > & a ) const [inline, inherited]

Definition at line 211 of file MatrixN.hh.

00211                                              {
00212       return _matrix < a._matrix;
00213     }

bool operator<= ( const Matrix< N > & a ) const [inline, inherited]

Definition at line 215 of file MatrixN.hh.

00215                                               {
00216       return _matrix <= a._matrix;
00217     }

bool operator== ( const Matrix< N > & a ) const [inline, inherited]

Definition at line 203 of file MatrixN.hh.

00203                                               {
00204       return _matrix == a._matrix;
00205     }

bool operator> ( const Matrix< N > & a ) const [inline, inherited]

Definition at line 219 of file MatrixN.hh.

00219                                              {
00220       return _matrix > a._matrix;
00221     }

bool operator>= ( const Matrix< N > & a ) const [inline, inherited]

Definition at line 223 of file MatrixN.hh.

00223                                               {
00224       return _matrix >= a._matrix;
00225     }

Matrix& set	(	const size_t	i,
		const size_t	j,
		const double	value
	)			`[inline, inherited]`

Definition at line 75 of file MatrixN.hh.

00075                                                                     {
00076       if (i < N && j < N) {
00077         _matrix(i, j) = value;
00078       } else {
00079         throw std::runtime_error("Attempted set access outside matrix bounds.");
00080       }
00081       return *this;
00082     }

Matrix3& setAsRotation	(	const Vector3 &	from,
		const Vector3 &	to
	)			`[inline]`

Definition at line 42 of file Matrix3.hh.

References Matrix< 3 >::_matrix, Vector< N >::_vec, Rivet::angle(), Rivet::cross(), Rivet::isZero(), Rivet::theta(), and Vector3::unit().

Referenced by Matrix3::Matrix3().

00042                                                                    {
00043       const double theta = angle(from, to);
00044       if (Rivet::isZero(theta)) {
00045         _matrix.loadIdentity();
00046       } else {
00047         const Vector3 normaxis = cross(from, to).unit();
00048         _matrix.loadRotation3(theta, normaxis._vec);
00049       }
00050       return *this;
00051     }

Matrix<N>& setColumn	(	const size_t	col,
		const Vector< N > &	c
	)			`[inline, inherited]`

Definition at line 115 of file MatrixN.hh.

00115                                                                {
00116       for (size_t i = 0; i < N; ++i) {
00117         _matrix(i,col) = c.get(i);
00118       }
00119       return *this;
00120     }

Matrix<N>& setRow	(	const size_t	row,
		const Vector< N > &	r
	)			`[inline, inherited]`

Definition at line 100 of file MatrixN.hh.

00100                                                             {
00101       for (size_t i = 0; i < N; ++i) {
00102         _matrix(row,i) = r.get(i);
00103       }
00104       return *this;
00105     }

size_t size ( ) const [inline, inherited]

Get dimensionality.

Definition at line 163 of file MatrixN.hh.

00163                         {
00164       return N;
00165     }

double trace ( ) const [inline, inherited]

Calculate trace.

Definition at line 146 of file MatrixN.hh.

00146                          {
00147       double tr = 0.0;
00148       for (size_t i = 0; i < N; ++i) {
00149         tr += _matrix(i,i);
00150       }
00151       return tr;
00152       // return _matrix.trace();
00153     }

Matrix<N> transpose ( ) const [inline, inherited]

Definition at line 122 of file MatrixN.hh.

00122                                 {
00123       Matrix<N> tmp = *this;
00124       tmp._matrix.replaceWithAdjoint();
00125       return tmp;
00126     }

Member Data Documentation

EMatrix _matrix [protected, inherited]

Definition at line 254 of file MatrixN.hh.

Referenced by Matrix3::Matrix3(), and Matrix3::setAsRotation().

The documentation for this class was generated from the following file:

Matrix3.hh

Matrix3 Class Reference

Public Member Functions

Static Public Member Functions

Protected Types

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation