Dense matrix and array manipulation » Catalog of coefficient-wise math functions module

This table presents a catalog of the coefficient-wise math functions supported by Eigen. In this table, a, b, refer to Array objects or expressions, and m refers to a linear algebra Matrix/Vector object. Standard scalar types are abbreviated as follows:

  • int: i32
  • float: f
  • double: d
  • std::complex<float>: cf
  • std::complex<double>: cd

For each row, the first column list the equivalent calls for arrays, and matrices when supported. Of course, all functions are available for matrices by first casting it as an array: m.array().

The third column gives some hints in the underlying scalar implementation. In most cases, Eigen does not implement itself the math function but relies on the STL for standard scalar types, or user-provided functions for custom scalar types. For instance, some simply calls the respective function of the STL while preserving argument-dependent lookup for custom types. The following:

using std::foo;
foo(a[i]);

means that the STL's function std::foo will be potentially called if it is compatible with the underlying scalar type. If not, then the user must ensure that an overload of the function foo is available for the given scalar type (usually defined in the same namespace as the given scalar type). This also means that, unless specified, if the function std::foo is available only in some recent c++ versions (e.g., c++11), then the respective Eigen's function/method will be usable on standard types only if the compiler support the required c++ version.

APIDescriptionDefault scalar implementationSIMD
Basic operations
a.abs();
abs(a);
m.cwiseAbs();		absolute value ( $ |a_i| $ )using std::abs;
abs(a[i]);		SSE2, AVX (i32,f,d)
a.inverse();
inverse(a);
m.cwiseInverse();		inverse value ( $ 1/a_i $ )1/a[i];All engines (f,d,fc,fd)
a.conjugate();
conj(a);
m.conjugate();		complex conjugate ( $ \bar{a_i} $ ),
no-op for real		using std::conj;
conj(a[i]);		All engines (fc,fd)
Exponential functions
a.exp();
exp(a);		 $ e $ raised to the given power ( $ e^{a_i} $ )using std::exp;
exp(a[i]);		SSE2, AVX (f,d)
a.log();
log(a);		natural (base $ e $ ) logarithm ( $ \ln({a_i}) $ )using std::log;
log(a[i]);		SSE2, AVX (f)
a.log1p();
log1p(a);		natural (base $ e $ ) logarithm of 1 plus
the given number ( $ \ln({1+a_i}) $ )		built-in generic implementation based on log,
plus using std::log1p; [c++11]
a.log10();
log10(a);		base 10 logarithm ( $ \log_{10}({a_i}) $ )using std::log10;
log10(a[i]);
Power functions

a.pow(b);
pow(a,b);

raises a number to the given power ( $ a_i ^ {b_i} $ )
a and b can be either an array or scalar.		using std::pow;
pow(a[i],b[i]);
(plus builtin for integer types)
a.sqrt();
sqrt(a);
m.cwiseSqrt();		computes square root ( $ \sqrt a_i $ )using std::sqrt;
sqrt(a[i]);		SSE2, AVX (f,d)
a.rsqrt();
rsqrt(a);		reciprocal square root ( $ 1/{\sqrt a_i} $ )using std::sqrt;
1/sqrt(a[i]);
SSE2, AVX, AltiVec, ZVector (f,d)
(approx + 1 Newton iteration)
a.square();
square(a);		computes square power ( $ a_i^2 $ )a[i]*a[i]All (i32,f,d,cf,cd)
a.cube();
cube(a);		computes cubic power ( $ a_i^3 $ )a[i]*a[i]*a[i]All (i32,f,d,cf,cd)
a.abs2();
abs2(a);
m.cwiseAbs2();		computes the squared absolute value ( $ |a_i|^2 $ )real: a[i]*a[i]
complex: real(a[i])*real(a[i])
       + imag(a[i])*imag(a[i])		All (i32,f,d)
Trigonometric functions
a.sin();
sin(a);		computes sineusing std::sin;
sin(a[i]);		SSE2, AVX (f)
a.cos();
cos(a);		computes cosineusing std::cos;
cos(a[i]);		SSE2, AVX (f)
a.tan();
tan(a);		computes tangentusing std::tan;
tan(a[i]);
a.asin();
asin(a);		computes arc sine ( $ \sin^{-1} a_i $ )using std::asin;
asin(a[i]);
a.acos();
acos(a);		computes arc cosine ( $ \cos^{-1} a_i $ )using std::acos;
acos(a[i]);
a.atan();
atan(a);		computes arc tangent ( $ \tan^{-1} a_i $ )using std::atan;
atan(a[i]);
Hyperbolic functions
a.sinh();
sinh(a);		computes hyperbolic sineusing std::sinh;
sinh(a[i]);
a.cohs();
cosh(a);		computes hyperbolic cosineusing std::cosh;
cosh(a[i]);
a.tanh();
tanh(a);		computes hyperbolic tangentusing std::tanh;
tanh(a[i]);
a.asinh();
asinh(a);		computes inverse hyperbolic sineusing std::asinh;
asinh(a[i]);
a.cohs();
acosh(a);		computes hyperbolic cosineusing std::acosh;
acosh(a[i]);
a.atanh();
atanh(a);		computes hyperbolic tangentusing std::atanh;
atanh(a[i]);
Nearest integer floating point operations
a.ceil();
ceil(a);		nearest integer not less than the given valueusing std::ceil;
ceil(a[i]);		SSE4,AVX,ZVector (f,d)
a.floor();
floor(a);		nearest integer not greater than the given valueusing std::floor;
floor(a[i]);		SSE4,AVX,ZVector (f,d)
a.round();
round(a);		nearest integer,
rounding away from zero in halfway cases		built-in generic implementation
based on floor and ceil,
plus using std::round; [c++11]		SSE4,AVX,ZVector (f,d)
Floating point manipulation functions
Classification and comparison
a.isFinite();
isfinite(a);		checks if the given number has finite valuebuilt-in generic implementation,
plus using std::isfinite; [c++11]
a.isInf();
isinf(a);		checks if the given number is infinitebuilt-in generic implementation,
plus using std::isinf; [c++11]
a.isNaN();
isnan(a);		checks if the given number is not a numberbuilt-in generic implementation,
plus using std::isnan; [c++11]
Error and gamma functions
Require #include <unsupported/Eigen/SpecialFunctions>
a.erf();
erf(a);		error functionusing std::erf; [c++11]
erf(a[i]);
a.erfc();
erfc(a);		complementary error functionusing std::erfc; [c++11]
erfc(a[i]);
a.lgamma();
lgamma(a);		natural logarithm of the gamma functionusing std::lgamma; [c++11]
lgamma(a[i]);
a.digamma();
digamma(a);		logarithmic derivative of the gamma functionbuilt-in for float and double
igamma(a,x);lower incomplete gamma integral
$ \gamma(a_i,x_i)= \frac{1}{|a_i|} \int_{0}^{x_i}e^{\text{-}t} t^{a_i-1} \mathrm{d} t $ 		built-in for float and double,
but requires [c++11]
igammac(a,x);upper incomplete gamma integral
$ \Gamma(a_i,x_i) = \frac{1}{|a_i|} \int_{x_i}^{\infty}e^{\text{-}t} t^{a_i-1} \mathrm{d} t $ 		built-in for float and double,
but requires [c++11]
Special functions
Require #include <unsupported/Eigen/SpecialFunctions>
polygamma(n,x);n-th derivative of digamma at xbuilt-in generic based on
lgamma, digamma and zeta.
betainc(a,b,x);Incomplete beta functionbuilt-in for float and double,
but requires [c++11]
zeta(a,b);
a.zeta(b);		Hurwitz zeta function
$ \zeta(a_i,b_i)=\sum_{k=0}^{\infty}(b_i+k)^{\text{-}a_i} $ 		built-in for float and double