[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

Classes | Namespaces | Functions
Mathematical Functions

Classes

class  BSpline< ORDER, T >
class  BSplineBase< ORDER, T >
class  CatmullRomSpline< T >
class  CoscotFunction< T >
class  Gaussian< T >

Namespaces

namespace  vigra::detail

Functions

template<class Iterator >
Iterator argMax (Iterator first, Iterator last)
template<class Iterator , class UnaryFunctor >
Iterator argMaxIf (Iterator first, Iterator last, UnaryFunctor condition)
template<class Iterator >
Iterator argMin (Iterator first, Iterator last)
template<class Iterator , class UnaryFunctor >
Iterator argMinIf (Iterator first, Iterator last, UnaryFunctor condition)
UInt32 ceilPower2 (UInt32 x)
double chi2 (unsigned int degreesOfFreedom, double arg, double accuracy=1e-7)
double chi2CDF (unsigned int degreesOfFreedom, double arg, double accuracy=1e-7)
template<class T1 , class T2 >
bool closeAtTolerance (T1 l, T2 r, typename PromoteTraits< T1, T2 >::Promote epsilon)
double ellipticIntegralE (double x, double k)
double ellipticIntegralF (double x, double k)
UInt32 floorPower2 (UInt32 x)
template<typename IntType >
IntType gcd (IntType n, IntType m)
template<typename IntType >
IntType lcm (IntType n, IntType m)
Int32 log2i (UInt32 x)
double noncentralChi2 (unsigned int degreesOfFreedom, double noncentrality, double arg, double accuracy=1e-7)
double noncentralChi2CDF (unsigned int degreesOfFreedom, double noncentrality, double arg, double accuracy=1e-7)
double noncentralChi2CDFApprox (unsigned int degreesOfFreedom, double noncentrality, double arg)
template<class T >
NormTraits< T >::NormType norm (T const &t)
result_type operator() (argument_type x) const
float round (float t)
int roundi (double t)
template<class T1 , class T2 >
T1 sign (T1 t1, T2 t2)
template<class T >
sign (T t)
template<class T >
int signi (T t)
template<class T >
NumericTraits< T >::Promote sq (T t)
Int32 sqrti (Int32 v)
NormTraits< T >::SquaredNormType squaredNorm (T const &t)
template<class T >
void symmetric2x2Eigenvalues (T a00, T a01, T a11, T *r0, T *r1)
template<class T >
void symmetric3x3Eigenvalues (T a00, T a01, T a02, T a11, T a12, T a22, T *r0, T *r1, T *r2)

Detailed Description

Useful mathematical functions and functors.


Function Documentation

float vigra::round ( float  t)

The rounding function.

Defined for all floating point types. Rounds towards the nearest integer such that abs(round(t)) == round(abs(t)) for all t.

#include <vigra/mathutil.hxx>
Namespace: vigra

int vigra::roundi ( double  t)

Round and cast to integer.

Rounds to the nearest integer like round(), but casts the result to int (this will be faster and is usually needed anyway).

#include <vigra/mathutil.hxx>
Namespace: vigra

UInt32 vigra::ceilPower2 ( UInt32  x)

Round up to the nearest power of 2.

Efficient algorithm for finding the smallest power of 2 which is not smaller than x (function clp2() from Henry Warren: "Hacker's Delight", Addison-Wesley, 2003, see http://www.hackersdelight.org/). If x > 2^31, the function will return 0 because integer arithmetic is defined modulo 2^32.

#include <vigra/mathutil.hxx>
Namespace: vigra

UInt32 vigra::floorPower2 ( UInt32  x)

Round down to the nearest power of 2.

Efficient algorithm for finding the largest power of 2 which is not greater than x (function flp2() from Henry Warren: "Hacker's Delight", Addison-Wesley, 2003, see http://www.hackersdelight.org/).

#include <vigra/mathutil.hxx>
Namespace: vigra

Int32 vigra::log2i ( UInt32  x)

Compute the base-2 logarithm of an integer.

Returns the position of the left-most 1-bit in the given number x, or -1 if x == 0. That is,

        assert(k >= 0 && k < 32 && log2i(1 << k) == k);

The function uses Robert Harley's algorithm to determine the number of leading zeros in x (algorithm nlz10() at http://www.hackersdelight.org/). But note that the functions floorPower2() or ceilPower2() are more efficient and should be preferred when possible.

#include <vigra/mathutil.hxx>
Namespace: vigra

NumericTraits<T>::Promote vigra::sq ( t)

The square function.

sq(x) = x*x is needed so often that it makes sense to define it as a function.

#include <vigra/mathutil.hxx>
Namespace: vigra

UInt32 sqrti ( Int32  v)

Signed integer square root.

Useful for fast fixed-point computations.

#include <vigra/mathutil.hxx>
Namespace: vigra

Unsigned integer square root.

Useful for fast fixed-point computations.

#include <vigra/mathutil.hxx>
Namespace: vigra

T vigra::sign ( t)

The sign function.

Returns 1, 0, or -1 depending on the sign of t, but with the same type as t.

#include <vigra/mathutil.hxx>
Namespace: vigra

int vigra::signi ( t)

The integer sign function.

Returns 1, 0, or -1 depending on the sign of t, converted to int.

#include <vigra/mathutil.hxx>
Namespace: vigra

T1 vigra::sign ( T1  t1,
T2  t2 
)

The binary sign function.

Transfers the sign of t2 to t1.

#include <vigra/mathutil.hxx>
Namespace: vigra

NormTraits<T>::SquaredNormType vigra::squaredNorm ( T const &  t)

The squared norm of a numerical object.

For scalar types: equals vigra::sq(t)
. For vectorial types: equals vigra::dot(t, t)
. For complex types: equals vigra::sq(t.real()) + vigra::sq(t.imag())
. For matrix types: results in the squared Frobenius norm (sum of squares of the matrix elements).

NormTraits<T>::NormType vigra::norm ( T const &  t)

The norm of a numerical object.

For scalar types: implemented as abs(t)
otherwise: implemented as sqrt(squaredNorm(t)).

#include <vigra/mathutil.hxx>
Namespace: vigra

Iterator vigra::argMin ( Iterator  first,
Iterator  last 
)

Find the minimum element in a sequence.

The function returns the iterator refering to the minimum element.

Required Interface:

        Iterator is a standard forward iterator.
        
        bool f = *first < NumericTraits<typename std::iterator_traits<Iterator>::value_type>::max();

#include <vigra/mathutil.hxx>
Namespace: vigra

Iterator vigra::argMax ( Iterator  first,
Iterator  last 
)

Find the maximum element in a sequence.

The function returns the iterator refering to the maximum element.

Required Interface:

        Iterator is a standard forward iterator.
        
        bool f = NumericTraits<typename std::iterator_traits<Iterator>::value_type>::min() < *first;

#include <vigra/mathutil.hxx>
Namespace: vigra

Iterator vigra::argMinIf ( Iterator  first,
Iterator  last,
UnaryFunctor  condition 
)

Find the minimum element in a sequence conforming to a condition.

The function returns the iterator refering to the minimum element, where only elements conforming to the condition (i.e. where condition(*iterator) evaluates to true) are considered. If no element conforms to the condition, or the sequence is empty, the end iterator last is returned.

Required Interface:

        Iterator is a standard forward iterator.
        
        bool c = condition(*first);
        
        bool f = *first < NumericTraits<typename std::iterator_traits<Iterator>::value_type>::max();

#include <vigra/mathutil.hxx>
Namespace: vigra

Iterator vigra::argMaxIf ( Iterator  first,
Iterator  last,
UnaryFunctor  condition 
)

Find the maximum element in a sequence conforming to a condition.

The function returns the iterator refering to the maximum element, where only elements conforming to the condition (i.e. where condition(*iterator) evaluates to true) are considered. If no element conforms to the condition, or the sequence is empty, the end iterator last is returned.

Required Interface:

        Iterator is a standard forward iterator.
        
        bool c = condition(*first);
        
        bool f = NumericTraits<typename std::iterator_traits<Iterator>::value_type>::min() < *first;

#include <vigra/mathutil.hxx>
Namespace: vigra

void vigra::symmetric2x2Eigenvalues ( a00,
a01,
a11,
T *  r0,
T *  r1 
)

Compute the eigenvalues of a 2x2 real symmetric matrix.

This uses the analytical eigenvalue formula

\[ \lambda_{1,2} = \frac{1}{2}\left(a_{00} + a_{11} \pm \sqrt{(a_{00} - a_{11})^2 + 4 a_{01}^2}\right) \]

#include <vigra/mathutil.hxx>
Namespace: vigra

void vigra::symmetric3x3Eigenvalues ( a00,
a01,
a02,
a11,
a12,
a22,
T *  r0,
T *  r1,
T *  r2 
)

Compute the eigenvalues of a 3x3 real symmetric matrix.

This uses a numerically stable version of the analytical eigenvalue formula according to

David Eberly: "Eigensystems for 3 × 3 Symmetric Matrices (Revisited)", Geometric Tools Documentation, 2006

#include <vigra/mathutil.hxx>
Namespace: vigra

double vigra::ellipticIntegralF ( double  x,
double  k 
)

The incomplete elliptic integral of the first kind.

Computes

\[ \mbox{F}(x, k) = \int_0^x \frac{1}{\sqrt{1 - k^2 \sin(t)^2}} dt \]

according to the algorithm given in Press et al. "Numerical Recipes".

Note: In some libraries (e.g. Mathematica), the second parameter of the elliptic integral functions must be k^2 rather than k. Check the documentation when results disagree!

#include <vigra/mathutil.hxx>
Namespace: vigra

double vigra::ellipticIntegralE ( double  x,
double  k 
)

The incomplete elliptic integral of the second kind.

Computes

\[ \mbox{E}(x, k) = \int_0^x \sqrt{1 - k^2 \sin(t)^2} dt \]

according to the algorithm given in Press et al. "Numerical Recipes". The complete elliptic integral of the second kind is simply ellipticIntegralE(M_PI/2, k).

Note: In some libraries (e.g. Mathematica), the second parameter of the elliptic integral functions must be k^2 rather than k. Check the documentation when results disagree!

#include <vigra/mathutil.hxx>
Namespace: vigra

double vigra::chi2 ( unsigned int  degreesOfFreedom,
double  arg,
double  accuracy = 1e-7 
)

Chi square distribution.

Computes the density of a chi square distribution with degreesOfFreedom and tolerance accuracy at the given argument arg by calling noncentralChi2(degreesOfFreedom, 0.0, arg, accuracy).

#include <vigra/mathutil.hxx>
Namespace: vigra

double vigra::chi2CDF ( unsigned int  degreesOfFreedom,
double  arg,
double  accuracy = 1e-7 
)

Cumulative chi square distribution.

Computes the cumulative density of a chi square distribution with degreesOfFreedom and tolerance accuracy at the given argument arg, i.e. the probability that a random number drawn from the distribution is below arg by calling noncentralChi2CDF(degreesOfFreedom, 0.0, arg, accuracy).

#include <vigra/mathutil.hxx>
Namespace: vigra

double vigra::noncentralChi2 ( unsigned int  degreesOfFreedom,
double  noncentrality,
double  arg,
double  accuracy = 1e-7 
)

Non-central chi square distribution.

Computes the density of a non-central chi square distribution with degreesOfFreedom, noncentrality parameter noncentrality and tolerance accuracy at the given argument arg. It uses Algorithm AS 231 from Appl. Statist. (1987) Vol.36, No.3 (code ported from http://lib.stat.cmu.edu/apstat/231). The algorithm has linear complexity in the number of degrees of freedom.

#include <vigra/mathutil.hxx>
Namespace: vigra

double vigra::noncentralChi2CDF ( unsigned int  degreesOfFreedom,
double  noncentrality,
double  arg,
double  accuracy = 1e-7 
)

Cumulative non-central chi square distribution.

Computes the cumulative density of a chi square distribution with degreesOfFreedom, noncentrality parameter noncentrality and tolerance accuracy at the given argument arg, i.e. the probability that a random number drawn from the distribution is below arg It uses Algorithm AS 231 from Appl. Statist. (1987) Vol.36, No.3 (code ported from http://lib.stat.cmu.edu/apstat/231). The algorithm has linear complexity in the number of degrees of freedom (see noncentralChi2CDFApprox() for a constant-time algorithm).

#include <vigra/mathutil.hxx>
Namespace: vigra

double vigra::noncentralChi2CDFApprox ( unsigned int  degreesOfFreedom,
double  noncentrality,
double  arg 
)

Cumulative non-central chi square distribution (approximate).

Computes approximate values of the cumulative density of a chi square distribution with degreesOfFreedom, and noncentrality parameter noncentrality at the given argument arg, i.e. the probability that a random number drawn from the distribution is below arg It uses the approximate transform into a normal distribution due to Wilson and Hilferty (see Abramovitz, Stegun: "Handbook of Mathematical Functions", formula 26.3.32). The algorithm's running time is independent of the inputs, i.e. is should be used when noncentralChi2CDF() is too slow, and approximate values are sufficient. The accuracy is only about 0.1 for few degrees of freedom, but reaches about 0.001 above dof = 5.

#include <vigra/mathutil.hxx>
Namespace: vigra

bool vigra::closeAtTolerance ( T1  l,
T2  r,
typename PromoteTraits< T1, T2 >::Promote  epsilon 
)

Tolerance based floating-point comparison.

Check whether two floating point numbers are equal within the given tolerance. This is useful because floating point numbers that should be equal in theory are rarely exactly equal in practice. If the tolerance epsilon is not given, twice the machine epsilon is used.

#include <vigra/mathutil.hxx>
Namespace: vigra

IntType vigra::gcd ( IntType  n,
IntType  m 
)

Calculate the greatest common divisor.

This function works for arbitrary integer types, including user-defined (e.g. infinite precision) ones.

#include <vigra/rational.hxx>
Namespace: vigra

IntType vigra::lcm ( IntType  n,
IntType  m 
)

Calculate the lowest common multiple.

This function works for arbitrary integer types, including user-defined (e.g. infinite precision) ones.

#include <vigra/rational.hxx>
Namespace: vigra

CatmullRomSpline< T >::result_type operator() ( argument_type  x) const

function (functor) call

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.7.0 (Thu Aug 25 2011)