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.
| API | Description | Default scalar implementation | SIMD |
|---|---|---|---|
| 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) |
|
a.arg(); arg(a); m.cwiseArg(); |
phase angle of complex number | using std::arg; arg(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 | |||
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.atan(); 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]); |
|
|
a.asinh(); asinh(a); |
computes inverse hyperbolic sine | using std::asinh; asinh(a[i]); |
|
|
a.cohs(); acosh(a); |
computes hyperbolic cosine | using std::acosh; acosh(a[i]); |
|
|
a.atanh(); atanh(a); |
computes hyperbolic tangent | using std::atanh; atanh(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) |
|
a.rint(); rint(a); |
nearest integer, rounding to nearest even in halfway cases |
built-in generic implementation using std::rint ; [c++11] or rintf ; |
SSE4,AVX (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 onlgamma , digamma and zeta . |
|
| betainc(a,b,x); | Incomplete beta function | built-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 | |
|
a.ndtri(); ndtri(a); |
Inverse of the CDF of the Normal distribution function | built-in for float and double | |
© Eigen.
Licensed under the MPL2 License.
https://eigen.tuxfamily.org/dox/group__CoeffwiseMathFunctions.html