#include <ICLUtils/CompatMacros.h>
#include <ICLUtils/Exception.h>
#include <ICLUtils/ClippedCast.h>
#include <ICLUtils/FixedArray.h>
#include <ICLMath/DynMatrix.h>
#include <ICLMath/MatrixSubRectIterator.h>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <functional>
#include <iostream>
#include <vector>
#include <cmath>
#include <ippm.h>

Classes
struct	icl::math::FixedMatrixBase
	FixedMatrix base struct defining datamode enum. More...
class	icl::math::FixedMatrixPart< T, N, Iterator >
	Utility struct for FixedMatrix sub-parts. More...
class	icl::math::FixedMatrix< T, COLS, ROWS >
	Powerful and highly flexible matrix class implementation. More...
struct	icl::math::FixedMatrix< T, COLS, ROWS >::col_iterator
	internal struct for row-wise iteration with stride=COLS More...
Namespaces
namespace	icl
	The ICL-namespace.
namespace	icl::math
Defines
#define	C1(N) if(DIM>N) utils::FixedArray<T,COLS*ROWS>::m_data[N]=v##N
#define	C4(A, B, C, D) C1(A);C1(B);C1(C);C1(D)
#define	OPTIMIZED_MATRIX_MULTIPLICATION(LEFT_COLS, LEFT_ROWS, RIGHT_COLS, TYPE, IPPSUFFIX)
#define	USE_OPTIMIZED_INV_AND_DET_FOR_2X2_3X3_AND_4X4_MATRICES
Enumerations
enum	icl::math::AXES { icl::math::sxyz, icl::math::sxyx, icl::math::sxzy, icl::math::sxzx, icl::math::syzx, icl::math::syzy, icl::math::syxz, icl::math::syxy, icl::math::szxy, icl::math::szxz, icl::math::szyx, icl::math::szyz, icl::math::rzyx, icl::math::rxyx, icl::math::ryzx, icl::math::rxzx, icl::math::rxzy, icl::math::ryzy, icl::math::rzxy, icl::math::ryxy, icl::math::ryxz, icl::math::rzxz, icl::math::rxyz, icl::math::rzyz }
	axes order specifications for euler angles More...
Functions
template<class T , unsigned int WIDTH, unsigned int HEIGHT, unsigned int HEIGHT2>
FixedMatrix< T, WIDTH, HEIGHT+HEIGHT2 >	icl::math::operator% (const FixedMatrix< T, WIDTH, HEIGHT > &a, const FixedMatrix< T, WIDTH, HEIGHT2 > &b)
	Vertical Matrix concatenation.
template<class T , unsigned int WIDTH, unsigned int HEIGHT, unsigned int WIDTH2>
FixedMatrix< T, WIDTH+WIDTH2, HEIGHT >	icl::math::operator, (const FixedMatrix< T, WIDTH, HEIGHT > &a, const FixedMatrix< T, WIDTH2, HEIGHT > &b)
	Horizontal Matrix concatenation.
template<class T , unsigned int M_ROWS_AND_COLS, unsigned int V_COLS>
FixedMatrix< T, V_COLS, M_ROWS_AND_COLS > &	icl::math::operator*= (FixedMatrix< T, V_COLS, M_ROWS_AND_COLS > &v, const FixedMatrix< T, M_ROWS_AND_COLS, M_ROWS_AND_COLS > &m)
	Matrix multiplication (inplace)
template<class T , unsigned int COLS, unsigned int ROWS>
std::ostream &	icl::math::operator<< (std::ostream &s, const FixedMatrix< T, COLS, ROWS > &m)
	put the matrix into a std::ostream (human readable)
template<class T , unsigned int COLS, unsigned int ROWS>
std::istream &	icl::math::operator>> (std::istream &s, FixedMatrix< T, COLS, ROWS > &m)
	read matrix from std::istream (human readable)
template<class T >
ICLMath_IMP FixedMatrix< T, 2, 2 >	icl::math::create_rot_2D (T angle)
	creates a 2D rotation matrix (defined for float and double)
template<class T >
ICLMath_IMP FixedMatrix< T, 3, 3 >	icl::math::create_hom_3x3 (T angle, T dx=0, T dy=0, T v0=0, T v1=0)
	creates a 2D homogen matrix (defined for float and double)
template<class T >
FixedMatrix< T, 3, 3 >	icl::math::create_hom_3x3_trans (T dx, T dy)
	creates a 2D homogen matrix with translation part only (defined for float and double)
template<class T >
ICLMath_IMP FixedMatrix< T, 3, 3 >	icl::math::create_rot_3D (T axisX, T axisY, T axisZ, T angle)
	create 3D rotation matrix from rotation axis and angle (defined for float and double only)
template<class T >
ICLMath_IMP FixedMatrix< T, 3, 3 >	icl::math::create_rot_3D (T ai, T aj, T ak, AXES axes=AXES_DEFAULT)
	create 3D rotation matrix from euler angles in specified axes order (defined for float and double only)
template<class T >
ICLMath_IMP FixedMatrix< T, 4, 4 >	icl::math::create_hom_4x4 (T rx, T ry, T rz, T dx=0, T dy=0, T dz=0, T v0=0, T v1=0, T v2=0, AXES axes=AXES_DEFAULT)
	creates a 3D homogeneous matrix (defined for float and double)
template<class T >
ICLMath_IMP FixedMatrix< T, 4, 4 >	icl::math::create_rot_4x4 (T axisX, T axisY, T axisZ, T angle)
	create 4D homogeneous matrix that rotates about given axis by given angle (defined for float and double only)
template<class T >
FixedMatrix< T, 4, 4 >	icl::math::create_hom_4x4_trans (T dx, T dy, T dz)
	creates 4D homogeneous matrix with translation part only (defined for float and double)
template<class T >
ICLMath_IMP FixedMatrix< T, 1, 3 >	icl::math::extract_euler_angles (const FixedMatrix< T, 3, 3 > &m, AXES axes=AXES_DEFAULT)
	compute euler angles for rotation matrix assuming specified axes order
template<class T >
ICLMath_IMP FixedMatrix< T, 1, 3 >	icl::math::extract_euler_angles (const FixedMatrix< T, 4, 4 > &m, AXES axes=AXES_DEFAULT)
	icl::math::OPTIMIZED_MATRIX_MULTIPLICATION (2, 2, 2, float, 32f)
	icl::math::OPTIMIZED_MATRIX_MULTIPLICATION (3, 3, 3, float, 32f)
	icl::math::OPTIMIZED_MATRIX_MULTIPLICATION (4, 4, 4, float, 32f)
	icl::math::OPTIMIZED_MATRIX_MULTIPLICATION (2, 2, 2, double, 64f)
	icl::math::OPTIMIZED_MATRIX_MULTIPLICATION (3, 3, 3, double, 64f)
	icl::math::OPTIMIZED_MATRIX_MULTIPLICATION (4, 4, 4, double, 64f)
Variables
ICLMath_API const AXES	icl::math::AXES_DEFAULT

Define Documentation

#define C1 ( N ) if(DIM>N) utils::FixedArray<T,COLS*ROWS>::m_data[N]=v##N

#define C4	(	A,
		B,
		C,
		D
	)	C1(A);C1(B);C1(C);C1(D)

#define OPTIMIZED_MATRIX_MULTIPLICATION	(	LEFT_COLS,
		LEFT_ROWS,
		RIGHT_COLS,
		TYPE,
		IPPSUFFIX
	)

Value:

template<> template<>                                                                \
    inline void                                                                          \
    FixedMatrix<TYPE,RIGHT_COLS,LEFT_ROWS>::mult                                         \
       (                                                                                 \
          const FixedMatrix<TYPE,RIGHT_COLS,LEFT_COLS> &m,                               \
          FixedMatrix<TYPE,RIGHT_COLS,LEFT_ROWS> &dst                                    \
       ) const {                                                                         \
      static const unsigned int ST=sizeof(TYPE);                                         \
      ippmMul_mm_##IPPSUFFIX(data(),LEFT_COLS*ST,ST,LEFT_COLS,LEFT_ROWS,                 \
                             m.data(),RIGHT_COLS*ST,ST,RIGHT_COLS,LEFT_COLS,             \
                             dst.data(),RIGHT_COLS*ST,ST);                               \
    }

#define USE_OPTIMIZED_INV_AND_DET_FOR_2X2_3X3_AND_4X4_MATRICES

Classes

Namespaces

Defines

Enumerations

Functions

Variables

Define Documentation