Image Component Library (ICL)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Namespaces | Classes | Typedefs | Functions
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 GenericHomography2D
< float > 
Homography2D
 default homography 2D type definition (usually fload depth is enough)

Functions

template<class T >
std::ostream & operator<< (std::ostream &s, const DynMatrix< T > &m)
 ostream operator implemented for uchar, short, int, float and double matrices
template<class T >
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 >
DynMatrix< T > & matrix_abs (DynMatrix< T > &m)
 element-wise absolute value (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_abs (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise absolute value [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_log (DynMatrix< T > &m)
 element-wise logarith (basis E) (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_log (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise logarith (basis E) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_exp (DynMatrix< T > &m)
 element-wise exp-function (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_exp (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise exp-function [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_sqrt (DynMatrix< T > &m)
 element-wise square-root-function (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_sqrt (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise square-root-function [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_sqr (DynMatrix< T > &m)
 element-wise square-function (x*x) (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_sqr (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise square-function (x*x) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_sin (DynMatrix< T > &m)
 element-wise sinus-function (x*x) (inplace)
template<class T >
DynMatrix< T > & matrix_sin (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise sinus-function (x*x)
template<class T >
DynMatrix< T > & matrix_cos (DynMatrix< T > &m)
 element-wise cosinus-function (inplace)
template<class T >
DynMatrix< T > & matrix_cos (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise cosinus-function
template<class T >
DynMatrix< T > & matrix_tan (DynMatrix< T > &m)
 element-wise tangent-function (inplace)
template<class T >
DynMatrix< T > & matrix_tan (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise tangent-function
template<class T >
DynMatrix< T > & matrix_arcsin (DynMatrix< T > &m)
 element-wise arcus sinus-function (inplace)
template<class T >
DynMatrix< T > & matrix_arcsin (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise arcus sinus-function
template<class T >
DynMatrix< T > & matrix_arccos (DynMatrix< T > &m)
 element-wise arcus cosinus-function (inplace)
template<class T >
DynMatrix< T > & matrix_arccos (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise arcus cosinus-function
template<class T >
DynMatrix< T > & matrix_arctan (DynMatrix< T > &m)
 element-wise arcus tangent-function (inplace)
template<class T >
DynMatrix< T > & matrix_arctan (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise arcus tangent-function
template<class T >
DynMatrix< T > & matrix_reciprocal (DynMatrix< T > &m)
 element-wise reciprocal-function (1/x) (inplace)
template<class T >
DynMatrix< T > & matrix_reciprocal (const DynMatrix< T > &m, DynMatrix< T > &dst)
 element-wise reciprocal-function (1/x)
template<class T >
DynMatrix< T > & matrix_powc (DynMatrix< T > &m, T exponent)
 element-wise power-function (x^exponent) (inplace)
template<class T >
DynMatrix< T > & matrix_powc (const DynMatrix< T > &m, T exponent, DynMatrix< T > &dst)
 element-wise power-function (x^exponent)
template<class T >
DynMatrix< T > & matrix_addc (DynMatrix< T > &m, T val)
 element-wise addition of constant value (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_addc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst)
 element-wise addition of constant value [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_subc (DynMatrix< T > &m, T val)
 element-wise substraction of constant value (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_subc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst)
 element-wise substraction of constant value [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_divc (DynMatrix< T > &m, T val)
 element-wise division by constant value (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_divc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst)
 element-wise division by constant value [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_mulc (DynMatrix< T > &m, T val)
 element-wise multiplication with constant value (inplace) [IPP-optimized]
template<class T >
DynMatrix< T > & matrix_mulc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst)
 element-wise multiplication with constant value [IPP-optimized]
template<class T >
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 >
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 >
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 >
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 >
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 >
DynMatrix< T > & matrix_pow (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException)
 element-wise power
template<class T >
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 >
FixedMatrix< T, 2, 2 > create_rot_2D (T angle)
 creates a 2D rotation matrix (defined for float and double)
template<class T >
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 >
FixedMatrix< T, 3, 3 > create_rot_3D (T axisX, T axisY, T axisZ, T angle)
 create 3D rotation matrix that rotates about given axis by given angle (float and double only)
template<class T >
FixedMatrix< T, 3, 3 > create_rot_3D (T rx, T ry, T rz)
 creates a 3D rotation matrix (defined for float and double)
template<class T >
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)
 creates a 3D homogeneous matrix (defined for float and double)
template<class T >
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 float and double only)
template<class T >
FixedMatrix< T, 4, 4 > create_hom_4x4_trans (T dx, T dy, T dz)
 creates a 3D homogen matrix with translation part only (defined for float and double)
template<class T , unsigned int COLS, unsigned int ROWS>
FixedMatrix< T, 1, 3 > extract_euler_angles (const FixedMatrix< T, COLS, ROWS > &m) throw (InvalidMatrixDimensionException)
 extracts the euler angles from the given rotation matrix
 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 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.

matrix distance measurement

template<class T >
matrix_distance (const DynMatrix< T > &m1, const DynMatrix< T > &m2, T norm=2) throw (IncompatibleMatrixDimensionException)
 computes norm between matrix vectors
template<class 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 >
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 >
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 >
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 >
matrix_mean (const DynMatrix< T > &m)
 calculate matrix mean value [IPP-optimized]
template<class T >
matrix_var (const DynMatrix< T > &m)
 calculate matrix variance [IPP-optimized]
template<class T >
matrix_var (const DynMatrix< T > &m, T mean, bool empiricalMean=true)
 calculate matrix variance with given mean
template<class T >
void matrix_meanvar (const DynMatrix< T > &m, T *mean, T *var)
 computes matrix mean and variance at once [IPP-optimized]
template<class T >
matrix_stddev (const DynMatrix< T > &m)
 computes matrix standard deviation (sqrt(var)) [IPP-optimized]
template<class T >
matrix_stddev (const DynMatrix< T > &m, T mean, bool empiricalMean=true)
 calculate matrix standard deviation with given mean

other functions ...

template<class T >
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 >
DynMatrix< T > & matrix_muladd (const DynMatrix< T > &a, T alpha, T gamma, DynMatrix< T > &dst)
 computes alpha*a + gamma
template<class T >
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 >
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 >
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 >
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 >
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 >
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

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


Function Documentation

template<class T >
FixedMatrix<T,3,3> icl::math::create_hom_3x3 ( angle,
dx = 0,
dy = 0,
v0 = 0,
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 ( dx,
dy 
) [inline]

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

template<class T >
FixedMatrix<T,4,4> icl::math::create_hom_4x4 ( rx,
ry,
rz,
dx = 0,
dy = 0,
dz = 0,
v0 = 0,
v1 = 0,
v2 = 0 
)

creates a 3D homogeneous matrix (defined for float and double)

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

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

template<class T >
FixedMatrix<T,2,2> icl::math::create_rot_2D ( angle)

creates a 2D rotation matrix (defined for float and double)

template<class T >
FixedMatrix<T,3,3> icl::math::create_rot_3D ( axisX,
axisY,
axisZ,
angle 
)

create 3D rotation matrix that rotates about given axis by given angle (float and double only)

template<class T >
FixedMatrix<T,3,3> icl::math::create_rot_3D ( rx,
ry,
rz 
)

creates a 3D rotation matrix (defined for float and double)

template<class T >
FixedMatrix<T,4,4> icl::math::create_rot_4x4 ( axisX,
axisY,
axisZ,
angle 
)

create 4D homogeneous matrix that rotates about given axis by given angle float and double only)

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:
v1Beginfirst element of v1
v1Endend of v1 (points the first element behind v1)
v2Beginfirst 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:
aThe first point
bThe second point
Returns:
The distance of point a and b
template<class T , unsigned int COLS, unsigned int ROWS>
FixedMatrix<T,1,3> icl::math::extract_euler_angles ( const FixedMatrix< T, COLS, ROWS > &  m) throw (InvalidMatrixDimensionException)

extracts the euler angles from the given rotation matrix

Even though the function interface suggests, that m can have arbitrary dimensions, it must hae at least 3 rows and 3 colums. We chose this very generic interface in order to avoid having several functions for 3x3, 4x4, ... matrices. To avoid seg-faults, an exception is thrown in case of too small matrices m.

template<class T >
DynMatrix<T>& icl::math::matrix_powc ( const DynMatrix< T > &  m,
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:
beginstart iterator
endend 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:
beginstart iterator
endend iterator
Returns:
pair p with p.first = mean and p.second = stdDev
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 ( ,
,
,
float  ,
32f   
)
icl::math::OPTIMIZED_MATRIX_MULTIPLICATION ( ,
,
,
float  ,
32f   
)
icl::math::OPTIMIZED_MATRIX_MULTIPLICATION ( ,
,
,
float  ,
32f   
)
icl::math::OPTIMIZED_MATRIX_MULTIPLICATION ( ,
,
,
double  ,
64f   
)
icl::math::OPTIMIZED_MATRIX_MULTIPLICATION ( ,
,
,
double  ,
64f   
)
icl::math::OPTIMIZED_MATRIX_MULTIPLICATION ( ,
,
,
double  ,
64f   
)
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:
beginstart iterator
endend iterator
meangiven mean value
empiricMeanif 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:
beginstart iterator
endend iterator
template<class T >
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:
Ato decomposed matrix
Uis filled column-wise with the eigenvectors of AA'
Sis filled with the singular values of A (s is ColumnVector and not diagonal matrix)
Vis 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:
beginstart iterator
endend iterator
meanmean value of the range
empiricMeanif 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:
beginstart ForwardIterator
endend ForwardIterator
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines