Eigen  3.3.90 (mercurial changeset af41d217c085)
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
Catalog of coefficient-wise math functions

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:

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 sine using std::sin;
sin(a[i]);
SSE2, AVX (f)
a.cos();
cos(a);
computes cosine using std::cos;
cos(a[i]);
SSE2, AVX (f)
a.tan();
tan(a);
computes tangent using 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.tan();
atan(a);
computes arc tangent ( $ \tan^{-1} a_i $) using std::atan;
atan(a[i]);
Hyperbolic functions
a.sinh();
sinh(a);
computes hyperbolic sine using std::sinh;
sinh(a[i]);
a.cohs();
cosh(a);
computes hyperbolic cosine using std::cosh;
cosh(a[i]);
a.tanh();
tanh(a);
computes hyperbolic tangent using std::tanh;
tanh(a[i]);
Nearest integer floating point operations
a.ceil();
ceil(a);
nearest integer not less than the given value using std::ceil;
ceil(a[i]);
SSE4,AVX,ZVector (f,d)
a.floor();
floor(a);
nearest integer not greater than the given value using 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 value built-in generic implementation,
plus using std::isfinite ; [c++11]
a.isInf();
isinf(a);
checks if the given number is infinite built-in generic implementation,
plus using std::isinf ; [c++11]
a.isNaN();
isnan(a);
checks if the given number is not a number built-in generic implementation,
plus using std::isnan ; [c++11]
Error and gamma functions
Require #include <unsupported/Eigen/SpecialFunctions>
a.erf();
erf(a);
error function using std::erf; [c++11]
erf(a[i]);
a.erfc();
erfc(a);
complementary error function using std::erfc; [c++11]
erfc(a[i]);
a.lgamma();
lgamma(a);
natural logarithm of the gamma function using std::lgamma; [c++11]
lgamma(a[i]);
a.digamma();
digamma(a);
logarithmic derivative of the gamma function built-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 x built-in generic based on
lgamma , digamma and zeta .
betainc(a,b,x); Incomplete beta function built-in for float and double,
but requires [c++11]
zeta(a,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