Spec-Zone.ru › Eigen3

Каталог функций математических операций по коэффициентам

В этой таблице представлен каталог функций математических операций по коэффициентам, поддерживаемых Eigen. В этой таблице, a, b, относятся к объектам массива или выражениям, а m относится к объекту линейной алгебры Matrix/Vector. Стандартные скалярные типы сокращены следующим образом:

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

В каждой строке первый столбец перечисляет эквивалентные вызовы для массивов и матриц, если они поддерживаются. Конечно, все функции доступны для матриц, предварительно преобразовав их в массив: m.array().

Третий столбец содержит подсказки по реализации функций на уровне скаляров. В большинстве случаев Eigen не реализует математическую функцию самостоятельно, но полагается на STL для стандартных скалярных типов или на предоставленные пользователем функции для пользовательских типов скаляров. Например, некоторые просто вызывают соответствующую функцию STL, сохраняя поиск по аргументу для пользовательских типов. Следующее:

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

означает, что функция STL std::foo потенциально будет вызвана, если она совместима с типом базового скаляра. Если нет, то пользователь должен убедиться, что перегрузка функции foo доступна для данного скалярного типа (обычно определена в том же пространстве имен, что и данный скалярный тип). Это также означает, что, если не указано иное, если функция std::foo доступна только в некоторых последних версиях C++ (например, C++11), то соответствующая функция/метод Eigen будет доступна для стандартных типов только если компилятор поддерживает требуемую версию C++.

API Описание Реализация скаляра по умолчанию SIMD
Основные операции
a.abs();
abs(a);
m.cwiseAbs();
модуль ( \( |a_i| \)) используя std::abs;
abs(a[i]);
SSE2, AVX (i32,f,d)
a.inverse();
inverse(a);
m.cwiseInverse();
обратное значение ( \( 1/a_i \)) 1/a[i]; Все ядра (f,d,fc,fd)
a.conjugate();
conj(a);
m.conjugate();
комплексное сопряжение ( \( \bar{a_i} \)),
нет действия для вещественных чисел
используя std::conj;
conj(a[i]);
Все ядра (fc,fd)
a.arg();
arg(a);
m.cwiseArg();
угол фазы комплексного числа используя std::arg;
arg(a[i]);
Все ядра (fc,fd)
Экспоненциальные функции
a.exp();
exp(a);
\( e \) в заданной степени ( \( e^{a_i} \)) используя std::exp;
exp(a[i]);
SSE2, AVX (f,d)
a.log();
log(a);
натуральный (основание \( e \)) логарифм ( \( \ln({a_i}) \)) используя std::log;
log(a[i]);
SSE2, AVX (f)
a.log1p();
log1p(a);
натуральный (основание \( e \)) логарифм от 1 плюс
заданное число ( \( \ln({1+a_i}) \))
встроенная общая реализация, основанная на log,
плюс using std::log1p ; [c++11]
a.log10();
log10(a);
логарифм по основанию 10 ( \( \log_{10}({a_i}) \)) используя std::log10;
log10(a[i]);
Функции степеней

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

возводит число в заданную степень ( \( a_i ^ {b_i} \))
a и b могут быть массивом или скаляром.
используя std::pow;
pow(a[i],b[i]);
(плюс встроенная реализация для целых типов)
a.sqrt();
sqrt(a);
m.cwiseSqrt();
вычисляет квадратный корень ( \( \sqrt a_i \)) используя std::sqrt;
sqrt(a[i]);
SSE2, AVX (f,d)
a.rsqrt();
rsqrt(a);
обратный квадратный корень ( \( 1/{\sqrt a_i} \)) используя std::sqrt;
1/sqrt(a[i]);
SSE2, AVX, AltiVec, ZVector (f,d)
(приближение + 1 итерация Ньютона)
a.square();
square(a);
вычисляет квадратную степень ( \( a_i^2 \)) a[i]*a[i] Все (i32,f,d,cf,cd)
a.cube();
cube(a);
вычисляет кубическую степень ( \( a_i^3 \)) a[i]*a[i]*a[i] Все (i32,f,d,cf,cd)
a.abs2();
abs2(a);
m.cwiseAbs2();
вычисляет квадрат модуля ( \( |a_i|^2 \)) вещественные: a[i]*a[i]
комплексные: real(a[i])*real(a[i])
+ imag(a[i])*imag(a[i])
Все (i32,f,d)
Тригонометрические функции
a.sin();
sin(a);
вычисляет синус используя std::sin;
sin(a[i]);
SSE2, AVX (f)
a.cos();
cos(a);
вычисляет косинус используя std::cos;
cos(a[i]);
SSE2, AVX (f)
a.tan();
tan(a);
вычисляет тангенс используя std::tan;
tan(a[i]);
a.asin();
asin(a);
вычисляет арксинус ( \( \sin^{-1} a_i \)) используя std::asin;
asin(a[i]);
a.acos();
acos(a);
вычисляет арккосинус ( \( \cos^{-1} a_i \)) используя std::acos;
acos(a[i]);
a.atan();
atan(a);
вычисляет арктангенс ( \( \tan^{-1} a_i \)) используя std::atan;
atan(a[i]);
Гиперболические функции
a.sinh();
sinh(a);
вычисляет гиперболический синус используя std::sinh;
sinh(a[i]);
a.cohs();
cosh(a);
вычисляет гиперболический косинус используя std::cosh;
cosh(a[i]);
a.tanh();
tanh(a);
вычисляет гиперболический тангенс используя std::tanh;
tanh(a[i]);
a.asinh();
asinh(a);
вычисляет обратный гиперболический синус используя std::asinh;
asinh(a[i]);
a.cohs();
acosh(a);
вычисляет гиперболический косинус используя std::acosh;
acosh(a[i]);
a.atanh();
atanh(a);
вычисляет гиперболический тангенс используя std::atanh;
atanh(a[i]);
Операции с плавающей точкой ближайшего целого числа
a.ceil();
ceil(a);
ближайшее целое число, не меньшее заданного значения используя std::ceil;
ceil(a[i]);
SSE4,AVX,ZVector (f,d)
a.floor();
floor(a);
ближайшее целое число, не большее заданного значения используя std::floor;
floor(a[i]);
SSE4,AVX,ZVector (f,d)
a.round();
round(a);
ближайшее целое число,
округляя в сторону от нуля в случаях с половиной
встроенная общая реализация,
основанная на floor и ceil,
плюс using std::round ; [c++11]
SSE4,AVX,ZVector (f,d)
a.rint();
rint(a);
целое ближайшее,
при равенстве — чётное
встроенная универсальная реализация, использующая std::rint ; [c++11] или rintf ; SSE4,AVX (f,d)
Функции манипулирования с плавающей точкой
Классификация и сравнение
a.isFinite();
isfinite(a);
проверяет, является ли данное число конечным встроенная универсальная реализация,
плюс using std::isfinite ; [c++11]
a.isInf();
isinf(a);
проверяет, является ли данное число бесконечным встроенная универсальная реализация,
плюс using std::isinf ; [c++11]
a.isNaN();
isnan(a);
проверяет, является ли данное число неопределённым встроенная универсальная реализация,
плюс using std::isnan ; [c++11]
Функции ошибок и гамма-функции
Требуется #include <unsupported/Eigen/SpecialFunctions>
a.erf();
erf(a);
функция ошибок используется std::erf; [c++11]
erf(a[i]);
a.erfc();
erfc(a);
дополнительная функция ошибок используется std::erfc; [c++11]
erfc(a[i]);
a.lgamma();
lgamma(a);
натуральный логарифм гамма-функции используется std::lgamma; [c++11]
lgamma(a[i]);
a.digamma();
digamma(a);
логарифмическая производная гамма-функции встроено для float и double
igamma(a,x); нижняя неполная гамма-интеграл
\( \gamma(a_i,x_i)= \frac{1}{|a_i|} \int_{0}^{x_i}e^{\text{-}t} t^{a_i-1} \mathrm{d} t \)
встроено для float и double,
но требует [c++11]
igammac(a,x); верхняя неполная гамма-интеграл
\( \Gamma(a_i,x_i) = \frac{1}{|a_i|} \int_{x_i}^{\infty}e^{\text{-}t} t^{a_i-1} \mathrm{d} t \)
встроено для float и double,
но требует [c++11]
Специальные функции
Требуется #include <unsupported/Eigen/SpecialFunctions>
polygamma(n,x); n-ая производная дигаммы в x встроенная универсальная, основанная на
lgamma , digamma и zeta .
betainc(a,b,x); неполная бета-функция встроено для float и double,
но требует [c++11]
zeta(a,b);
a.zeta(b);
дзета-функция Гурвица
\( \zeta(a_i,b_i)=\sum_{k=0}^{\infty}(b_i+k)^{\text{-}a_i} \)
встроено для float и double
a.ndtri();
ndtri(a);
Обратное значение функции кумулятивного распределения нормального распределения встроено для float и double


© Eigen.
Licensed under the MPL2 License.
https://eigen.tuxfamily.org/dox/group__CoeffwiseMathFunctions.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API