icl::math Namespace Reference

Namespaces
namespace	fft
Classes
struct	InvalidMatrixDimensionException
	Special linear algebra exception type \. More...
struct	IncompatibleMatrixDimensionException
	Special linear algebra exception type \. More...
struct	InvalidIndexException
	Special linear algebra exception type \. More...
struct	SingularMatrixException
	Special linear algebra exception type \. More...
struct	DynMatrix
	Highly flexible and optimized matrix class implementation. More...
struct	DynColVector
	Extension class for the DynMatrix<T> template, that restricts the the matrix column count to 'one'. More...
struct	DynRowVector
class	FFTException
	Special exception implementation for the FFT package. More...
struct	FixedMatrixBase
	FixedMatrix base struct defining datamode enum. More...
class	FixedMatrixPart
	Utility struct for FixedMatrix sub-parts. More...
class	FixedMatrix
	Powerful and highly flexible matrix class implementation. More...
struct	FixedColVector
struct	FixedRowVector
struct	GenericHomography2D
	Utility structure that represents a 2D homography (implemented for float and double) More...
class	KDTree
	Simple KD-Tree implementation. More...
class	KMeans
	Generic Implementation of the K-Means algorithm. More...
class	LeastSquareModelFitting
	Direct Least Square Fitting Algorithm. More...
class	LeastSquareModelFitting2D
	Direct Least Square Fitting specialization for 2D input data. More...
class	LevenbergMarquardtFitter
	Utility class implementing the multidimensional Levenberg Marquardt Algorithm for non-linear Optimization. More...
struct	LinearTransform1D
	A standard linear mapping class for the 1D case f(x) = m * x + b. More...
class	LLM
	Local Linear Map implementation (LLM) More...
class	MatrixSubRectIterator
	Iterator class used to iterate through a sub rect of 2D data. More...
class	Octree
	Generic Octree Implementation. More...
class	PolynomialRegression
	Generic Implementation of the Polynomial Regression algorithm. More...
class	QuadTree
	Generic QuadTree Implementation. More...
class	RansacFitter
	Generic RANSAC (RAndom SAmpling Consensus) Implementation. More...
struct	SimplexOptimizationResult
	Utility structure, that is used as accumulator for results of the SimplexOptimizer class. More...
class	SimplexOptimizer
	Template based implementation for the Downhill Simplex Optimiztation method. More...
class	SOM
	Generic implementation of D to K dim Self Organizing Map (SOM) More...
class	SOM2D
	Simple Wrapper class of the generic SOM Implementation for 2D SOMs. More...
struct	StochasticOptimizerResult
	Utility structure for the stochastic optimizer class. More...
class	StochasticOptimizer
	The StochasticOptimizer is a tiny frame-work for simple stochastic optimization processes. More...
struct	StraightLine2D
	A straight line is parameterized in offset/direction form. More...
Typedefs
typedef FixedColVector< icl32f, 3 >	Vec3
	another shortcut for 3D vectors
typedef FixedColVector< icl32f, 4 >	Vec4
	another shortcut for 3D vectors
typedef FixedMatrix< icl32f, 3, 3 >	Mat3
	typedef for 3x3 fixed matrices
typedef FixedMatrix< icl32f, 4, 4 >	Mat4
	typedef for 4x4 fixed matrices
typedef GenericHomography2D < float >	Homography2D
	default homography 2D type definition (usually float depth is enough)
typedef _Complex double	xcomplex
typedef double	xreal
Enumerations
enum	AXES {   sxyz, sxyx, sxzy, sxzx,   syzx, syzy, syxz, syxy,   szxy, szxz, szyx, szyz,   rzyx, rxyx, ryzx, rxzx,   rxzy, ryzy, rzxy, ryxy,   ryxz, rzxz, rxyz, rzyz }
	axes order specifications for euler angles More...
Functions
template<class T >
ICLMath_IMP std::ostream &	operator<< (std::ostream &s, const DynMatrix< T > &m)
	ostream operator implemented for uchar, short, int, float and double matrices
template<class T >
ICLMath_IMP std::istream &	operator>> (std::istream &s, DynMatrix< T > &m)
	istream operator implemented for uchar, short, int, float and double matrices
template<class T >
DynMatrix< T >	operator, (const DynMatrix< T > &left, const DynMatrix< T > &right)
	vertical concatenation of matrices
template<class T >
DynMatrix< T >	operator% (const DynMatrix< T > &top, const DynMatrix< T > &bottom)
	horizontal concatenation of matrices
template<class T , class Init >
DynMatrix< T > &	matrix_init (DynMatrix< T > &m, Init init)
	Matrix initialization template.
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_abs (DynMatrix< T > &m)
	element-wise absolute value (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_abs (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise absolute value [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_log (DynMatrix< T > &m)
	element-wise logarith (basis E) (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_log (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise logarith (basis E) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_exp (DynMatrix< T > &m)
	element-wise exp-function (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_exp (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise exp-function [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_sqrt (DynMatrix< T > &m)
	element-wise square-root-function (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_sqrt (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise square-root-function [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_sqr (DynMatrix< T > &m)
	element-wise square-function (x*x) (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_sqr (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise square-function (x*x) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_sin (DynMatrix< T > &m)
	element-wise sinus-function (x*x) (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_sin (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise sinus-function (x*x)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_cos (DynMatrix< T > &m)
	element-wise cosinus-function (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_cos (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise cosinus-function
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_tan (DynMatrix< T > &m)
	element-wise tangent-function (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_tan (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise tangent-function
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_arcsin (DynMatrix< T > &m)
	element-wise arcus sinus-function (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_arcsin (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise arcus sinus-function
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_arccos (DynMatrix< T > &m)
	element-wise arcus cosinus-function (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_arccos (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise arcus cosinus-function
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_arctan (DynMatrix< T > &m)
	element-wise arcus tangent-function (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_arctan (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise arcus tangent-function
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_reciprocal (DynMatrix< T > &m)
	element-wise reciprocal-function (1/x) (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_reciprocal (const DynMatrix< T > &m, DynMatrix< T > &dst)
	element-wise reciprocal-function (1/x)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_powc (DynMatrix< T > &m, T exponent)
	element-wise power-function (x^exponent) (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_powc (const DynMatrix< T > &m, T exponent, DynMatrix< T > &dst)
	element-wise power-function (x^exponent)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_addc (DynMatrix< T > &m, T val)
	element-wise addition of constant value (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_addc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst)
	element-wise addition of constant value [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_subc (DynMatrix< T > &m, T val)
	element-wise substraction of constant value (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_subc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst)
	element-wise substraction of constant value [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_divc (DynMatrix< T > &m, T val)
	element-wise division by constant value (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_divc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst)
	element-wise division by constant value [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_mulc (DynMatrix< T > &m, T val)
	element-wise multiplication with constant value (inplace) [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_mulc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst)
	element-wise multiplication with constant value [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_arctan2 (const DynMatrix< T > &my, const DynMatrix< T > &mx, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
	element-wise atan2 function atan2(y,x)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_add (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
	element-wise addition [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_sub (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
	element-wise substraction [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_mul (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
	element-wise multiplication [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_div (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
	element-wise division [IPP-optimized]
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_pow (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
	element-wise power
template<class T >
ICLMath_IMP void	svd_dyn (const DynMatrix< T > &A, DynMatrix< T > &U, DynMatrix< T > &S, DynMatrix< T > &V) throw (utils::ICLException)
	SVD function - decomposes A into USV' (only icl32f and icl64f)
template<class T , unsigned int WIDTH, unsigned int HEIGHT, unsigned int HEIGHT2>
FixedMatrix< T, WIDTH, HEIGHT+HEIGHT2 >	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 >	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 > &	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 &	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 &	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 >	create_rot_2D (T angle)
	creates a 2D rotation matrix (defined for float and double)
template<class T >
ICLMath_IMP FixedMatrix< T, 3, 3 >	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 >	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 >	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 >	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 >	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 >	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 >	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 >	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 >	extract_euler_angles (const FixedMatrix< T, 4, 4 > &m, AXES axes=AXES_DEFAULT)
	OPTIMIZED_MATRIX_MULTIPLICATION (2, 2, 2, float, 32f)
	OPTIMIZED_MATRIX_MULTIPLICATION (3, 3, 3, float, 32f)
	OPTIMIZED_MATRIX_MULTIPLICATION (4, 4, 4, float, 32f)
	OPTIMIZED_MATRIX_MULTIPLICATION (2, 2, 2, double, 64f)
	OPTIMIZED_MATRIX_MULTIPLICATION (3, 3, 3, double, 64f)
	OPTIMIZED_MATRIX_MULTIPLICATION (4, 4, 4, double, 64f)
template<class T >
T	linear_interpolate (const T &a, const T &b, float x)
	linearly interpolates between a, b (x must be in range [0,1])
ICLMath_API float	dist_point_linesegment (const Vec4 &p, const Vec4 &lineStart, const Vec4 &lineEnd, Vec4 *nearestPoint=0)
	distance from point p to line segment (lineStart -> lineEnd)
ICLMath_API float	dist_point_triangle (const Vec4 &p, const Vec4 &a, const Vec4 &b, const Vec4 &c, Vec4 *nearestPoint=0)
	distance from point p to triangle (a - b - c)
Vec4	bilinear_interpolate (const Vec4 corners[4], float x, float y)
	bilinear vector interpolation
template<class T >
math::FixedColVector< T, 4 >	normalize (const math::FixedMatrix< T, 1, 4 > &v)
	normalize a vector to length 1
template<class T >
math::FixedColVector< T, 4 >	normalize3 (const math::FixedMatrix< T, 1, 4 > &v, const double &h=1)
	normalize a vector to length 1
float	sprod3 (const Vec4 &a, const Vec4 &b)
	3D scalar (aka dot-) product for 4D homogeneous vectors (ignoring the homegeneous component)
float	sqrnorm3 (const Vec4 &a)
	sqared norm for 4D homogeneous vectors (ignoring the homegeneous component)
float	norm3 (const Vec4 &a)
	3D- euclidian norm for 4D homogeneous vectors (ignoring the homegeneous component)
float	dist3 (const Vec4 &a, const Vec4 &b)
	3d euclidian distance
template<class T >
math::FixedColVector< T, 4 >	homogenize (const math::FixedMatrix< T, 1, 4 > &v)
	homogenize a vector be normalizing 4th component to 1
template<class T >
math::FixedColVector< T, 4 >	project (math::FixedMatrix< T, 1, 4 > v, T z)
	perform perspective projection
template<class T >
math::FixedColVector< T, 4 >	cross (const math::FixedMatrix< T, 1, 4 > &v1, const math::FixedMatrix< T, 1, 4 > &v2)
	homogeneous 3D cross-product
Vec4	rotate_vector (const Vec4 &axis, float angle, const Vec4 &vec)
	rotates a vector around a given axis
template<class ForwardIterator >
float	euclidian (ForwardIterator v1Begin, ForwardIterator v1End, ForwardIterator v2Begin)
	Calculate the euclidian distance of two vectors v1 and v2.
template<class T >
float	euclidian (const std::vector< T > &a, const std::vector< T > &b)
	Calculate the euclidian distance of points a and b.
template<class ForwardIterator >
double	mean (ForwardIterator begin, ForwardIterator end)
	computes the mean value of a data range
template<class ForwardIterator >
double	variance (ForwardIterator begin, ForwardIterator end, double mean, bool empiricMean=true)
	Compute the variance of a given data range with given mean value.
template<class ForwardIterator >
double	variance (ForwardIterator begin, ForwardIterator end)
	Compute the variance of a given data range.
template<class ForwardIterator >
double	stdDeviation (ForwardIterator begin, ForwardIterator end, double mean, bool empiricMean=true)
	Compute std-deviation of a data set with given mean (calls sqrt(variance(..))
template<class ForwardIterator >
double	stdDeviation (ForwardIterator begin, ForwardIterator end)
	Compute std-deviation of a data set.
template<class ForwardIterator >
std::pair< double, double >	meanAndStdDev (ForwardIterator begin, ForwardIterator end)
	Calculates mean and standard deviation of given data range simultanously.
static xreal	xnorm (xcomplex z)
static xreal	xabs (xcomplex z)
static xreal	xroot (xreal x, int n)
static int	xlogb (xcomplex z)
static void	xscalbln (xcomplex *z, int e)
static xcomplex	cauchy (const int deg, xcomplex *P)
static void	scale (const int deg, xcomplex *P)
static void	noshft (const int l1, int deg, xcomplex *P, xcomplex *H)
static xcomplex	polyev (const int deg, const xcomplex s, const xcomplex *Q, xcomplex *q)
static xcomplex	calct (bool *bol, int deg, xcomplex Ps, xcomplex *H, xcomplex *h, xcomplex s)
static void	nexth (const bool bol, int deg, xcomplex t, xcomplex *H, xcomplex *h, xcomplex *p)
static xreal	errev (const int deg, const xcomplex *p, const xreal ms, const xreal mp)
static bool	vrshft (const int l3, int deg, xcomplex *P, xcomplex *p, xcomplex *H, xcomplex *h, xcomplex *zero, xcomplex *s)
static bool	fxshft (const int l2, int deg, xcomplex *P, xcomplex *p, xcomplex *H, xcomplex *h, xcomplex *zero, xcomplex *s)
int	cpoly (int degree, const xcomplex poly[], xcomplex Roots[])
int	solve_poly (int degree, const double *in_real, const double *in_imag, double *out_real, double *out_imag)
Variables
ICLMath_API const AXES	AXES_DEFAULT
struct {
double   icl::math::ZERO
double   icl::math::INFIN
int   icl::math::MIN_EXP
int   icl::math::MAX_EXP
}	xdata
matrix distance measurement
template<class T >
ICLMath_IMP T	matrix_distance (const DynMatrix< T > &m1, const DynMatrix< T > &m2, T norm=2) throw (IncompatibleMatrixDimensionException)
	computes norm between matrix vectors
template<class T >
ICLMath_IMP T	matrix_divergence (const DynMatrix< T > &m1, const DynMatrix< T > &m2) throw (IncompatibleMatrixDimensionException)
	computes generalized Kullback-Leibler-divergence between matrix vectors
statistical functions
template<class T >
ICLMath_IMP T	matrix_min (const DynMatrix< T > &m, int *x=0, int *y=0)
	find minimum element of matrix (optionally find location too) [IPP-optimized]
template<class T >
ICLMath_IMP T	matrix_max (const DynMatrix< T > &m, int *x=0, int *y=0)
	find maximum element of matrix (optionally find location too) [IPP-optimized]
template<class T >
ICLMath_IMP void	matrix_minmax (const DynMatrix< T > &m, T dst[2], int *minx=0, int *miny=0, int *maxx=0, int *maxy=0)
	find min- and maxinim element at once (optionally with locations) [IPP-optimized]
template<class T >
ICLMath_IMP T	matrix_mean (const DynMatrix< T > &m)
	calculate matrix mean value [IPP-optimized]
template<class T >
ICLMath_IMP T	matrix_var (const DynMatrix< T > &m)
	calculate matrix variance [IPP-optimized]
template<class T >
ICLMath_IMP T	matrix_var (const DynMatrix< T > &m, T mean, bool empiricalMean=true)
	calculate matrix variance with given mean
template<class T >
ICLMath_IMP void	matrix_meanvar (const DynMatrix< T > &m, T *mean, T *var)
	computes matrix mean and variance at once [IPP-optimized]
template<class T >
ICLMath_IMP T	matrix_stddev (const DynMatrix< T > &m)
	computes matrix standard deviation (sqrt(var)) [IPP-optimized]
template<class T >
ICLMath_IMP T	matrix_stddev (const DynMatrix< T > &m, T mean, bool empiricalMean=true)
	calculate matrix standard deviation with given mean
other functions ...
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_muladd (const DynMatrix< T > &a, T alpha, const DynMatrix< T > &b, T beta, T gamma, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
	computes alpha*a + beta*b + gamma
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_muladd (const DynMatrix< T > &a, T alpha, T gamma, DynMatrix< T > &dst)
	computes alpha*a + gamma
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_mask (const DynMatrix< unsigned char > &mask, DynMatrix< T > &m) throw (IncompatibleMatrixDimensionException)
	applies masking operation (m(i,j) is set to 0 if mask(i,j) is 0) (inplace)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_mask (const DynMatrix< unsigned char > &mask, const DynMatrix< T > &m, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
	applies masking operation (m(i,j) is set to 0 if mask(i,j) is 0)
special functions for transposed matrices ...
enum	transposedDef { NONE_T = 0, SRC1_T = 1<<0, SRC2_T = 1<<1, BOTH_T = SRC1_T | SRC2_T }
	special utility type for definition of transposed states for matrices More...
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_mult_t (const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef) throw (IncompatibleMatrixDimensionException)
	applies matrix mutliplication on optionally transposed matrices
template<class T >
ICLMath_IMP DynMatrix< T > &	big_matrix_mult_t (const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef) throw (IncompatibleMatrixDimensionException)
	applies matrix mutliplication on optionally transposed matrices (specialized for big matrices)
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_add_t (const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef) throw (IncompatibleMatrixDimensionException)
	applies matrix addition on optionally transposed matrices
template<class T >
ICLMath_IMP DynMatrix< T > &	matrix_sub_t (const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef) throw (IncompatibleMatrixDimensionException)
	applies matrix substraction on optionally transposed matrices

---

Typedef Documentation

typedef GenericHomography2D<float> icl::math::Homography2D

default homography 2D type definition (usually float depth is enough)

typedef FixedMatrix<icl32f, 3,3> icl::math::Mat3

typedef for 3x3 fixed matrices

typedef FixedMatrix<icl32f, 4,4> icl::math::Mat4

typedef for 4x4 fixed matrices

typedef FixedColVector<icl32f,3> icl::math::Vec3

another shortcut for 3D vectors

typedef FixedColVector<icl32f,4> icl::math::Vec4

another shortcut for 3D vectors

typedef _Complex double icl::math::xcomplex

typedef double icl::math::xreal

---

Enumeration Type Documentation

enum icl::math::AXES

axes order specifications for euler angles

Enumerator:

sxyz
sxyx
sxzy
sxzx
syzx
syzy
syxz
syxy
szxy
szxz
szyx
szyz
rzyx
rxyx
ryzx
rxzx
rxzy
ryzy
rzxy
ryxy
ryxz
rzxz
rxyz
rzyz

---

Function Documentation

Vec4 icl::math::bilinear_interpolate	(	const Vec4	corners[4],
		float	x,
		float	y
	)		[inline]

bilinear vector interpolation

corner order ul, ur, ll, lr 0 ----- 1 | | | --> x | 2 ------3 \/ y

static xcomplex icl::math::calct	(	bool *	bol,
		int	deg,
		xcomplex	Ps,
		xcomplex *	H,
		xcomplex *	h,
		xcomplex	s
	)		[static]

static xcomplex icl::math::cauchy	(	const int	deg,
		xcomplex *	P
	)		[static]

int icl::math::cpoly	(	int	degree,
		const xcomplex	poly[],
		xcomplex	Roots[]
	)

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
	)		[inline]

creates a 2D homogen matrix with translation part only (defined for float and double)

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 >

FixedMatrix<T, 4, 4> icl::math::create_hom_4x4_trans	(	T	dx,
		T	dy,
		T	dz
	)		[inline]

creates 4D homogeneous matrix with translation part only (defined for float and double)

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_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_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 >

math::FixedColVector<T,4> icl::math::cross	(	const math::FixedMatrix< T, 1, 4 > &	v1,
		const math::FixedMatrix< T, 1, 4 > &	v2
	)		[inline]

homogeneous 3D cross-product

float icl::math::dist3	(	const Vec4 &	a,
		const Vec4 &	b
	)		[inline]

3d euclidian distance

ICLMath_API float icl::math::dist_point_linesegment	(	const Vec4 &	p,
		const Vec4 &	lineStart,
		const Vec4 &	lineEnd,
		Vec4 *	nearestPoint = 0
	)

distance from point p to line segment (lineStart -> lineEnd)

The implementation is based on the code of http://www.geometrictools.com which is povided under the terms of the "Boost Software License 1.0" (http://www.boost.org/LICENSE_1_0.txt)

ICLMath_API float icl::math::dist_point_triangle	(	const Vec4 &	p,
		const Vec4 &	a,
		const Vec4 &	b,
		const Vec4 &	c,
		Vec4 *	nearestPoint = 0
	)

distance from point p to triangle (a - b - c)

The implementation is based on the code of http://www.geometrictools.com which is povided under the terms of the "Boost Software License 1.0" (http://www.boost.org/LICENSE_1_0.txt)

static xreal icl::math::errev	(	const int	deg,
		const xcomplex *	p,
		const xreal	ms,
		const xreal	mp
	)		[static]

template<class ForwardIterator >

float icl::math::euclidian	(	ForwardIterator	v1Begin,
		ForwardIterator	v1End,
		ForwardIterator	v2Begin
	)		[inline]

Calculate the euclidian distance of two vectors v1 and v2.

Parameters:

v1Begin	first element of v1
v1End	end of v1 (points the first element behind v1)
v2Begin	first element of v2

Returns:

The euclidian distance |v1-v2|

template<class T >

float icl::math::euclidian	(	const std::vector< T > &	a,
		const std::vector< T > &	b
	)		[inline]

Calculate the euclidian distance of points a and b.

Parameters:

a	The first point
b	The second point

Returns:

The distance of point a and b

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
	)

static bool icl::math::fxshft	(	const int	l2,
		int	deg,
		xcomplex *	P,
		xcomplex *	p,
		xcomplex *	H,
		xcomplex *	h,
		xcomplex *	zero,
		xcomplex *	s
	)		[static]

template<class T >

math::FixedColVector<T,4> icl::math::homogenize

(

const math::FixedMatrix< T, 1, 4 > &

v

)

[inline]

homogenize a vector be normalizing 4th component to 1

template<class T >

T icl::math::linear_interpolate	(	const T &	a,
		const T &	b,
		float	x
	)

linearly interpolates between a, b (x must be in range [0,1])

if x is 0, a is returned and if x is 1, b is returned

template<class T >

ICLMath_IMP DynMatrix<T>& icl::math::matrix_powc	(	const DynMatrix< T > &	m,
		T	exponent,
		DynMatrix< T > &	dst
	)

element-wise power-function (x^exponent)

For float and double only

template<class ForwardIterator >

double icl::math::mean	(	ForwardIterator	begin,
		ForwardIterator	end
	)		[inline]

computes the mean value of a data range

Parameters:

begin	start iterator
end	end iterator IPP-optimized for float and double

template<class ForwardIterator >

std::pair<double,double> icl::math::meanAndStdDev	(	ForwardIterator	begin,
		ForwardIterator	end
	)		[inline]

Calculates mean and standard deviation of given data range simultanously.

Parameters:

begin	start iterator
end	end iterator

Returns:

pair p with p.first = mean and p.second = stdDev

static void icl::math::nexth	(	const bool	bol,
		int	deg,
		xcomplex	t,
		xcomplex *	H,
		xcomplex *	h,
		xcomplex *	p
	)		[static]

float icl::math::norm3

(

const Vec4 &

a

)

[inline]

3D- euclidian norm for 4D homogeneous vectors (ignoring the homegeneous component)

template<class T >

math::FixedColVector<T,4> icl::math::normalize

(

const math::FixedMatrix< T, 1, 4 > &

v

)

[inline]

normalize a vector to length 1

template<class T >

math::FixedColVector<T,4> icl::math::normalize3	(	const math::FixedMatrix< T, 1, 4 > &	v,
		const double &	h = 1
	)		[inline]

normalize a vector to length 1

static void icl::math::noshft	(	const int	l1,
		int	deg,
		xcomplex *	P,
		xcomplex *	H
	)		[static]

template<class T >

DynMatrix<T> icl::math::operator%	(	const DynMatrix< T > &	top,
		const DynMatrix< T > &	bottom
	)		[inline]

horizontal concatenation of matrices

missing elementes are padded with 0

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
	)		[inline]

Matrix multiplication (inplace)

inplace matrix multiplication does only work for squared source and destination matrices of identical size

template<class T >

DynMatrix<T> icl::math::operator,	(	const DynMatrix< T > &	left,
		const DynMatrix< T > &	right
	)		[inline]

vertical concatenation of matrices

missing elementes are padded with 0

template<class T , unsigned int COLS, unsigned int ROWS>

std::ostream& icl::math::operator<<	(	std::ostream &	s,
		const FixedMatrix< T, COLS, ROWS > &	m
	)		[inline]

put the matrix into a std::ostream (human readable)

Internally, this function wraps a DynMatrix<T> shallowly around m

template<class T , unsigned int COLS, unsigned int ROWS>

std::istream& icl::math::operator>>	(	std::istream &	s,
		FixedMatrix< T, COLS, ROWS > &	m
	)		[inline]

read matrix from std::istream (human readable)

Internally, this function wraps a DynMatrix<T> shallowly around m

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
	)

static xcomplex icl::math::polyev	(	const int	deg,
		const xcomplex	s,
		const xcomplex *	Q,
		xcomplex *	q
	)		[static]

template<class T >

math::FixedColVector<T,4> icl::math::project	(	math::FixedMatrix< T, 1, 4 >	v,
		T	z
	)		[inline]

perform perspective projection

Vec4 icl::math::rotate_vector	(	const Vec4 &	axis,
		float	angle,
		const Vec4 &	vec
	)		[inline]

rotates a vector around a given axis

static void icl::math::scale	(	const int	deg,
		xcomplex *	P
	)		[static]

int icl::math::solve_poly	(	int	degree,
		const double *	in_real,
		const double *	in_imag,
		double *	out_real,
		double *	out_imag
	)

float icl::math::sprod3	(	const Vec4 &	a,
		const Vec4 &	b
	)		[inline]

3D scalar (aka dot-) product for 4D homogeneous vectors (ignoring the homegeneous component)

float icl::math::sqrnorm3

(

const Vec4 &

a

)

[inline]

sqared norm for 4D homogeneous vectors (ignoring the homegeneous component)

template<class ForwardIterator >

double icl::math::stdDeviation	(	ForwardIterator	begin,
		ForwardIterator	end,
		double	mean,
		bool	empiricMean = true
	)		[inline]

Compute std-deviation of a data set with given mean (calls sqrt(variance(..))

Parameters:

begin	start iterator
end	end iterator
mean	given mean value
empiricMean	if true, sum of square distances is devidec by n-1 else by n

template<class ForwardIterator >

double icl::math::stdDeviation	(	ForwardIterator	begin,
		ForwardIterator	end
	)		[inline]

Compute std-deviation of a data set.

Parameters:

begin	start iterator
end	end iterator

template<class T >

ICLMath_IMP void icl::math::svd_dyn	(	const DynMatrix< T > &	A,
		DynMatrix< T > &	U,
		DynMatrix< T > &	S,
		DynMatrix< T > &	V
	)		throw (utils::ICLException)

SVD function - decomposes A into USV' (only icl32f and icl64f)

Internaly, this function will always use double values. Other types are converted internally.

Parameters:

A	to decomposed matrix
U	is filled column-wise with the eigenvectors of AA'
S	is filled with the singular values of A (s is ColumnVector and not diagonal matrix)
V	is filled column-wise with the eigenvectors of A'A (in V, V is stored not V')

template<class ForwardIterator >

double icl::math::variance	(	ForwardIterator	begin,
		ForwardIterator	end,
		double	mean,
		bool	empiricMean = true
	)		[inline]

Compute the variance of a given data range with given mean value.

Parameters:

begin	start iterator
end	end iterator
mean	mean value of the range
empiricMean	if true, sum of square distances is devidec by n-1 else by n

template<class ForwardIterator >

double icl::math::variance	(	ForwardIterator	begin,
		ForwardIterator	end
	)		[inline]

Compute the variance of a given data range.

Parameters:

begin	start ForwardIterator
end	end ForwardIterator

static bool icl::math::vrshft	(	const int	l3,
		int	deg,
		xcomplex *	P,
		xcomplex *	p,
		xcomplex *	H,
		xcomplex *	h,
		xcomplex *	zero,
		xcomplex *	s
	)		[static]

static xreal icl::math::xabs

(

xcomplex

z

)

[static]

static int icl::math::xlogb

(

xcomplex

z

)

[static]

static xreal icl::math::xnorm

(

xcomplex

z

)

[static]

static xreal icl::math::xroot	(	xreal	x,
		int	n
	)		[static]

static void icl::math::xscalbln	(	xcomplex *	z,
		int	e
	)		[static]

---

Variable Documentation

ICLMath_API const AXES icl::math::AXES_DEFAULT

double icl::math::INFIN

int icl::math::MAX_EXP

int icl::math::MIN_EXP

struct { ... } icl::math::xdata [static]

double icl::math::ZERO