devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merging eigen/eigen.

Browse Source
This commit is contained in:
Srinivas Vasudevan
2019-09-16 19:33:29 -04:00
parent 6e215cf109 7c73296849
commit df0816b71f
12 changed files with 507 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h
View File

@@ -24,12 +24,12 @@ namespace Eigen {
* other scalar types, the user has to provide implementations of i0(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::i0()
* \sa ArrayBase::bessel_i0()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived>
i0(const Eigen::ArrayBase<Derived>& x) {
bessel_i0(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -47,12 +47,12 @@ i0(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of i0e(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::i0e()
* \sa ArrayBase::bessel_i0e()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived>
i0e(const Eigen::ArrayBase<Derived>& x) {
bessel_i0e(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -69,12 +69,12 @@ i0e(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of i1(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::i1()
* \sa ArrayBase::bessel_i1()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived>
i1(const Eigen::ArrayBase<Derived>& x) {
bessel_i1(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -92,12 +92,12 @@ i1(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of i1e(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::i1e()
* \sa ArrayBase::bessel_i1e()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived>
i1e(const Eigen::ArrayBase<Derived>& x) {
bessel_i1e(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -114,12 +114,12 @@ i1e(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of k0(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::k0()
* \sa ArrayBase::bessel_k0()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived>
k0(const Eigen::ArrayBase<Derived>& x) {
bessel_k0(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -137,12 +137,12 @@ k0(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of k0e(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::k0e()
* \sa ArrayBase::bessel_k0e()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived>
k0e(const Eigen::ArrayBase<Derived>& x) {
bessel_k0e(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -159,12 +159,12 @@ k0e(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of k1(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::k1()
* \sa ArrayBase::bessel_k1()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived>
k1(const Eigen::ArrayBase<Derived>& x) {
bessel_k1(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -182,12 +182,12 @@ k1(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of k1e(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::k1e()
* \sa ArrayBase::bessel_k1e()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived>
k1e(const Eigen::ArrayBase<Derived>& x) {
bessel_k1e(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -204,12 +204,12 @@ k1e(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of j0(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::j0()
* \sa ArrayBase::bessel_j0()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived>
j0(const Eigen::ArrayBase<Derived>& x) {
bessel_j0(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -226,12 +226,12 @@ j0(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of y0(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::y0()
* \sa ArrayBase::bessel_y0()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived>
y0(const Eigen::ArrayBase<Derived>& x) {
bessel_y0(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -248,12 +248,12 @@ y0(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of j1(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::j1()
* \sa ArrayBase::bessel_j1()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived>
j1(const Eigen::ArrayBase<Derived>& x) {
bessel_j1(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>,
const Derived>(x.derived());
@@ -270,12 +270,12 @@ j1(const Eigen::ArrayBase<Derived>& x) {
* other scalar types, the user has to provide implementations of y1(T) for
* any scalar type T to be supported.
*
* \sa ArrayBase::y1()
* \sa ArrayBase::bessel_y1()
*/
template <typename Derived>
EIGEN_STRONG_INLINE const Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived>
y1(const Eigen::ArrayBase<Derived>& x) {
bessel_y1(const Eigen::ArrayBase<Derived>& x) {
return Eigen::CwiseUnaryOp<
Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>,
const Derived>(x.derived());

96
unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h
View File

@@ -18,18 +18,18 @@ namespace internal {
/** \internal
* \brief Template functor to compute the modified Bessel function of the first
* kind of order zero.
* \sa class CwiseUnaryOp, Cwise::i0()
* \sa class CwiseUnaryOp, Cwise::bessel_i0()
*/
template <typename Scalar>
struct scalar_bessel_i0_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_i0_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::i0;
return i0(x);
using numext::bessel_i0;
return bessel_i0(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pi0(x);
return internal::pbessel_i0(x);
}
};
template <typename Scalar>
@@ -46,18 +46,18 @@ struct functor_traits<scalar_bessel_i0_op<Scalar> > {
/** \internal
* \brief Template functor to compute the exponentially scaled modified Bessel
* function of the first kind of order zero
* \sa class CwiseUnaryOp, Cwise::i0e()
* \sa class CwiseUnaryOp, Cwise::bessel_i0e()
*/
template <typename Scalar>
struct scalar_bessel_i0e_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_i0e_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::i0e;
return i0e(x);
using numext::bessel_i0e;
return bessel_i0e(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pi0e(x);
return internal::pbessel_i0e(x);
}
};
template <typename Scalar>
@@ -73,18 +73,18 @@ struct functor_traits<scalar_bessel_i0e_op<Scalar> > {
/** \internal
* \brief Template functor to compute the modified Bessel function of the first
* kind of order one
* \sa class CwiseUnaryOp, Cwise::i1()
* \sa class CwiseUnaryOp, Cwise::bessel_i1()
*/
template <typename Scalar>
struct scalar_bessel_i1_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_i1_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::i1;
return i1(x);
using numext::bessel_i1;
return bessel_i1(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pi1(x);
return internal::pbessel_i1(x);
}
};
template <typename Scalar>
@@ -101,18 +101,18 @@ struct functor_traits<scalar_bessel_i1_op<Scalar> > {
/** \internal
* \brief Template functor to compute the exponentially scaled modified Bessel
* function of the first kind of order zero
* \sa class CwiseUnaryOp, Cwise::i1e()
* \sa class CwiseUnaryOp, Cwise::bessel_i1e()
*/
template <typename Scalar>
struct scalar_bessel_i1e_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_i1e_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::i1e;
return i1e(x);
using numext::bessel_i1e;
return bessel_i1e(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pi1e(x);
return internal::pbessel_i1e(x);
}
};
template <typename Scalar>
@@ -128,18 +128,18 @@ struct functor_traits<scalar_bessel_i1e_op<Scalar> > {
/** \internal
* \brief Template functor to compute the Bessel function of the second kind of
* order zero
* \sa class CwiseUnaryOp, Cwise::j0()
* \sa class CwiseUnaryOp, Cwise::bessel_j0()
*/
template <typename Scalar>
struct scalar_bessel_j0_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_j0_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::j0;
return j0(x);
using numext::bessel_j0;
return bessel_j0(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pj0(x);
return internal::pbessel_j0(x);
}
};
template <typename Scalar>
@@ -156,18 +156,18 @@ struct functor_traits<scalar_bessel_j0_op<Scalar> > {
/** \internal
* \brief Template functor to compute the Bessel function of the second kind of
* order zero
* \sa class CwiseUnaryOp, Cwise::y0()
* \sa class CwiseUnaryOp, Cwise::bessel_y0()
*/
template <typename Scalar>
struct scalar_bessel_y0_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_y0_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::y0;
return y0(x);
using numext::bessel_y0;
return bessel_y0(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::py0(x);
return internal::pbessel_y0(x);
}
};
template <typename Scalar>
@@ -184,18 +184,18 @@ struct functor_traits<scalar_bessel_y0_op<Scalar> > {
/** \internal
* \brief Template functor to compute the Bessel function of the first kind of
* order one
* \sa class CwiseUnaryOp, Cwise::j1()
* \sa class CwiseUnaryOp, Cwise::bessel_j1()
*/
template <typename Scalar>
struct scalar_bessel_j1_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_j1_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::j1;
return j1(x);
using numext::bessel_j1;
return bessel_j1(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pj1(x);
return internal::pbessel_j1(x);
}
};
template <typename Scalar>
@@ -212,18 +212,18 @@ struct functor_traits<scalar_bessel_j1_op<Scalar> > {
/** \internal
* \brief Template functor to compute the Bessel function of the second kind of
* order one
* \sa class CwiseUnaryOp, Cwise::j1e()
* \sa class CwiseUnaryOp, Cwise::bessel_j1e()
*/
template <typename Scalar>
struct scalar_bessel_y1_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_y1_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::y1;
return y1(x);
using numext::bessel_y1;
return bessel_y1(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::py1(x);
return internal::pbessel_y1(x);
}
};
template <typename Scalar>
@@ -240,18 +240,18 @@ struct functor_traits<scalar_bessel_y1_op<Scalar> > {
/** \internal
* \brief Template functor to compute the modified Bessel function of the second
* kind of order zero
* \sa class CwiseUnaryOp, Cwise::k0()
* \sa class CwiseUnaryOp, Cwise::bessel_k0()
*/
template <typename Scalar>
struct scalar_bessel_k0_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_k0_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::k0;
return k0(x);
using numext::bessel_k0;
return bessel_k0(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pk0(x);
return internal::pbessel_k0(x);
}
};
template <typename Scalar>
@@ -268,18 +268,18 @@ struct functor_traits<scalar_bessel_k0_op<Scalar> > {
/** \internal
* \brief Template functor to compute the exponentially scaled modified Bessel
* function of the second kind of order zero
* \sa class CwiseUnaryOp, Cwise::k0e()
* \sa class CwiseUnaryOp, Cwise::bessel_k0e()
*/
template <typename Scalar>
struct scalar_bessel_k0e_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_k0e_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::k0e;
return k0e(x);
using numext::bessel_k0e;
return bessel_k0e(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pk0e(x);
return internal::pbessel_k0e(x);
}
};
template <typename Scalar>
@@ -296,18 +296,18 @@ struct functor_traits<scalar_bessel_k0e_op<Scalar> > {
/** \internal
* \brief Template functor to compute the modified Bessel function of the
* second kind of order one
* \sa class CwiseUnaryOp, Cwise::k1()
* \sa class CwiseUnaryOp, Cwise::bessel_k1()
*/
template <typename Scalar>
struct scalar_bessel_k1_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_k1_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::k1;
return k1(x);
using numext::bessel_k1;
return bessel_k1(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pk1(x);
return internal::pbessel_k1(x);
}
};
template <typename Scalar>
@@ -324,18 +324,18 @@ struct functor_traits<scalar_bessel_k1_op<Scalar> > {
/** \internal
* \brief Template functor to compute the exponentially scaled modified Bessel
* function of the second kind of order one
* \sa class CwiseUnaryOp, Cwise::k1e()
* \sa class CwiseUnaryOp, Cwise::bessel_k1e()
*/
template <typename Scalar>
struct scalar_bessel_k1e_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_k1e_op)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
using numext::k1e;
return k1e(x);
using numext::bessel_k1e;
return bessel_k1e(x);
}
typedef typename packet_traits<Scalar>::type Packet;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
return internal::pk1e(x);
return internal::pbessel_k1e(x);
}
};
template <typename Scalar>

48
unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h
View File

@@ -13,50 +13,50 @@ namespace numext {
#if EIGEN_HAS_C99_MATH
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half i0(const Eigen::half& x) {
return Eigen::half(Eigen::numext::i0(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i0(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_i0(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half i0e(const Eigen::half& x) {
return Eigen::half(Eigen::numext::i0e(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i0e(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_i0e(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half i1(const Eigen::half& x) {
return Eigen::half(Eigen::numext::i1(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i1(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_i1(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half i1e(const Eigen::half& x) {
return Eigen::half(Eigen::numext::i1e(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i1e(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_i1e(static_cast<float>(x)));
}
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half j0(const Eigen::half& x) {
return Eigen::half(Eigen::numext::j0(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_j0(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_j0(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half j1(const Eigen::half& x) {
return Eigen::half(Eigen::numext::j1(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_j1(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_j1(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half y0(const Eigen::half& x) {
return Eigen::half(Eigen::numext::y0(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_y0(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_y0(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half y1(const Eigen::half& x) {
return Eigen::half(Eigen::numext::y1(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_y1(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_y1(static_cast<float>(x)));
}
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half k0(const Eigen::half& x) {
return Eigen::half(Eigen::numext::k0(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k0(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_k0(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half k0e(const Eigen::half& x) {
return Eigen::half(Eigen::numext::k0e(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k0e(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_k0e(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half k1(const Eigen::half& x) {
return Eigen::half(Eigen::numext::k1(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k1(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_k1(static_cast<float>(x)));
}
template <>
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half k1e(const Eigen::half& x) {
return Eigen::half(Eigen::numext::k1e(static_cast<float>(x)));
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k1e(const Eigen::half& x) {
return Eigen::half(Eigen::numext::bessel_k1e(static_cast<float>(x)));
}
#endif

120
unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h
View File

@@ -42,7 +42,7 @@ namespace internal {
****************************************************************************/
template <typename Scalar>
struct i0e_retval {
struct bessel_i0e_retval {
typedef Scalar type;
};
@@ -202,7 +202,7 @@ struct generic_i0e<T, double> {
};
template <typename Scalar>
struct i0e_impl {
struct bessel_i0e_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_i0e<Scalar, Scalar>::run(x);
@@ -210,7 +210,7 @@ struct i0e_impl {
};
template <typename Scalar>
struct i0_retval {
struct bessel_i0_retval {
typedef Scalar type;
};
@@ -225,7 +225,7 @@ struct generic_i0 {
};
template <typename Scalar>
struct i0_impl {
struct bessel_i0_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_i0<Scalar, Scalar>::run(x);
@@ -233,7 +233,7 @@ struct i0_impl {
};
template <typename Scalar>
struct i1e_retval {
struct bessel_i1e_retval {
typedef Scalar type;
};
@@ -397,7 +397,7 @@ struct generic_i1e<T, double> {
};
template <typename Scalar>
struct i1e_impl {
struct bessel_i1e_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_i1e<Scalar, Scalar>::run(x);
@@ -405,7 +405,7 @@ struct i1e_impl {
};
template <typename Scalar>
struct i1_retval {
struct bessel_i1_retval {
typedef Scalar type;
};
@@ -420,7 +420,7 @@ struct generic_i1 {
};
template <typename Scalar>
struct i1_impl {
struct bessel_i1_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_i1<Scalar, Scalar>::run(x);
@@ -428,7 +428,7 @@ struct i1_impl {
};
template <typename Scalar>
struct k0e_retval {
struct bessel_k0e_retval {
typedef Scalar type;
};
@@ -583,7 +583,7 @@ struct generic_k0e<T, double> {
};
template <typename Scalar>
struct k0e_impl {
struct bessel_k0e_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_k0e<Scalar, Scalar>::run(x);
@@ -591,7 +591,7 @@ struct k0e_impl {
};
template <typename Scalar>
struct k0_retval {
struct bessel_k0_retval {
typedef Scalar type;
};
@@ -755,7 +755,7 @@ struct generic_k0<T, double> {
};
template <typename Scalar>
struct k0_impl {
struct bessel_k0_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_k0<Scalar, Scalar>::run(x);
@@ -763,7 +763,7 @@ struct k0_impl {
};
template <typename Scalar>
struct k1e_retval {
struct bessel_k1e_retval {
typedef Scalar type;
};
@@ -911,7 +911,7 @@ struct generic_k1e<T, double> {
};
template <typename Scalar>
struct k1e_impl {
struct bessel_k1e_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_k1e<Scalar, Scalar>::run(x);
@@ -919,7 +919,7 @@ struct k1e_impl {
};
template <typename Scalar>
struct k1_retval {
struct bessel_k1_retval {
typedef Scalar type;
};
@@ -1077,7 +1077,7 @@ struct generic_k1<T, double> {
};
template <typename Scalar>
struct k1_impl {
struct bessel_k1_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_k1<Scalar, Scalar>::run(x);
@@ -1085,7 +1085,7 @@ struct k1_impl {
};
template <typename Scalar>
struct j0_retval {
struct bessel_j0_retval {
typedef Scalar type;
};
@@ -1277,7 +1277,7 @@ struct generic_j0<T, double> {
};
template <typename Scalar>
struct j0_impl {
struct bessel_j0_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_j0<Scalar, Scalar>::run(x);
@@ -1285,7 +1285,7 @@ struct j0_impl {
};
template <typename Scalar>
struct y0_retval {
struct bessel_y0_retval {
typedef Scalar type;
};
@@ -1475,7 +1475,7 @@ struct generic_y0<T, double> {
};
template <typename Scalar>
struct y0_impl {
struct bessel_y0_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_y0<Scalar, Scalar>::run(x);
@@ -1483,7 +1483,7 @@ struct y0_impl {
};
template <typename Scalar>
struct j1_retval {
struct bessel_j1_retval {
typedef Scalar type;
};
@@ -1666,7 +1666,7 @@ struct generic_j1<T, double> {
};
template <typename Scalar>
struct j1_impl {
struct bessel_j1_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_j1<Scalar, Scalar>::run(x);
@@ -1674,7 +1674,7 @@ struct j1_impl {
};
template <typename Scalar>
struct y1_retval {
struct bessel_y1_retval {
typedef Scalar type;
};
@@ -1869,7 +1869,7 @@ struct generic_y1<T, double> {
};
template <typename Scalar>
struct y1_impl {
struct bessel_y1_impl {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Scalar x) {
return generic_y1<Scalar, Scalar>::run(x);
@@ -1881,75 +1881,75 @@ struct y1_impl {
namespace numext {
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(i0, Scalar)
i0(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(i0, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_i0, Scalar)
bessel_i0(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_i0, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(i0e, Scalar)
i0e(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(i0e, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_i0e, Scalar)
bessel_i0e(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_i0e, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(i1, Scalar)
i1(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(i1, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_i1, Scalar)
bessel_i1(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_i1, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(i1e, Scalar)
i1e(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(i1e, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_i1e, Scalar)
bessel_i1e(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_i1e, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(k0, Scalar)
k0(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(k0, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_k0, Scalar)
bessel_k0(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_k0, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(k0e, Scalar)
k0e(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(k0e, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_k0e, Scalar)
bessel_k0e(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_k0e, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(k1, Scalar)
k1(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(k1, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_k1, Scalar)
bessel_k1(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_k1, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(k1e, Scalar)
k1e(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(k1e, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_k1e, Scalar)
bessel_k1e(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_k1e, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(j0, Scalar)
j0(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(j0, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_j0, Scalar)
bessel_j0(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_j0, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(y0, Scalar)
y0(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(y0, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_y0, Scalar)
bessel_y0(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_y0, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(j1, Scalar)
j1(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(j1, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_j1, Scalar)
bessel_j1(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_j1, Scalar)::run(x);
}
template <typename Scalar>
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(y1, Scalar)
y1(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(y1, Scalar)::run(x);
EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_y1, Scalar)
bessel_y1(const Scalar& x) {
return EIGEN_MATHFUNC_IMPL(bessel_y1, Scalar)::run(x);
}
} // end namespace numext

24
unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h
View File

@@ -18,7 +18,7 @@ namespace internal {
* order zero i0(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pi0(const Packet& x) {
Packet pbessel_i0(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_i0; return generic_i0<Packet, ScalarType>::run(x);
}
@@ -27,7 +27,7 @@ Packet pi0(const Packet& x) {
* order zero i0e(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pi0e(const Packet& x) {
Packet pbessel_i0e(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_i0e; return generic_i0e<Packet, ScalarType>::run(x);
}
@@ -36,7 +36,7 @@ Packet pi0e(const Packet& x) {
* order one i1(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pi1(const Packet& x) {
Packet pbessel_i1(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_i1; return generic_i1<Packet, ScalarType>::run(x);
}
@@ -45,7 +45,7 @@ Packet pi1(const Packet& x) {
* order one i1e(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pi1e(const Packet& x) {
Packet pbessel_i1e(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_i1e; return generic_i1e<Packet, ScalarType>::run(x);
}
@@ -54,7 +54,7 @@ Packet pi1e(const Packet& x) {
* order zero j0(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pj0(const Packet& x) {
Packet pbessel_j0(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_j0; return generic_j0<Packet, ScalarType>::run(x);
}
@@ -63,7 +63,7 @@ Packet pj0(const Packet& x) {
* order zero j1(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pj1(const Packet& x) {
Packet pbessel_j1(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_j1; return generic_j1<Packet, ScalarType>::run(x);
}
@@ -72,7 +72,7 @@ Packet pj1(const Packet& x) {
* order one y0(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet py0(const Packet& x) {
Packet pbessel_y0(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_y0; return generic_y0<Packet, ScalarType>::run(x);
}
@@ -81,7 +81,7 @@ Packet py0(const Packet& x) {
* order one y1(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet py1(const Packet& x) {
Packet pbessel_y1(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_y1; return generic_y1<Packet, ScalarType>::run(x);
}
@@ -90,7 +90,7 @@ Packet py1(const Packet& x) {
* order zero k0(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pk0(const Packet& x) {
Packet pbessel_k0(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_k0; return generic_k0<Packet, ScalarType>::run(x);
}
@@ -99,7 +99,7 @@ Packet pk0(const Packet& x) {
* order zero k0e(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pk0e(const Packet& x) {
Packet pbessel_k0e(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_k0e; return generic_k0e<Packet, ScalarType>::run(x);
}
@@ -108,7 +108,7 @@ Packet pk0e(const Packet& x) {
* order one k1e(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pk1(const Packet& x) {
Packet pbessel_k1(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_k1; return generic_k1<Packet, ScalarType>::run(x);
}
@@ -117,7 +117,7 @@ Packet pk1(const Packet& x) {
* order one k1e(\a a) (coeff-wise) */
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet pk1e(const Packet& x) {
Packet pbessel_k1e(const Packet& x) {
typedef typename unpacket_traits<Packet>::type ScalarType;
using internal::generic_k1e; return generic_k1e<Packet, ScalarType>::run(x);
}

144
unsupported/Eigen/src/SpecialFunctions/arch/GPU/GpuSpecialFunctions.h
View File

@@ -205,159 +205,159 @@ double2 pbetainc<double2>(const double2& a, const double2& b, const double2& x)
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pi0e<float4>(const float4& x) {
using numext::i0e;
return make_float4(i0e(x.x), i0e(x.y), i0e(x.z), i0e(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i0e<float4>(const float4& x) {
using numext::bessel_i0e;
return make_float4(bessel_i0e(x.x), bessel_i0e(x.y), bessel_i0e(x.z), bessel_i0e(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pi0e<double2>(const double2& x) {
using numext::i0e;
return make_double2(i0e(x.x), i0e(x.y));
pbessel_i0e<double2>(const double2& x) {
using numext::bessel_i0e;
return make_double2(bessel_i0e(x.x), bessel_i0e(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pi0<float4>(const float4& x) {
using numext::i0;
return make_float4(i0(x.x), i0(x.y), i0(x.z), i0(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i0<float4>(const float4& x) {
using numext::bessel_i0;
return make_float4(bessel_i0(x.x), bessel_i0(x.y), bessel_i0(x.z), bessel_i0(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pi0<double2>(const double2& x) {
using numext::i0;
return make_double2(i0(x.x), i0(x.y));
pbessel_i0<double2>(const double2& x) {
using numext::bessel_i0;
return make_double2(bessel_i0(x.x), bessel_i0(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pi1e<float4>(const float4& x) {
using numext::i1e;
return make_float4(i1e(x.x), i1e(x.y), i1e(x.z), i1e(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i1e<float4>(const float4& x) {
using numext::bessel_i1e;
return make_float4(bessel_i1e(x.x), bessel_i1e(x.y), bessel_i1e(x.z), bessel_i1e(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pi1e<double2>(const double2& x) {
using numext::i1e;
return make_double2(i1e(x.x), i1e(x.y));
pbessel_i1e<double2>(const double2& x) {
using numext::bessel_i1e;
return make_double2(bessel_i1e(x.x), bessel_i1e(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pi1<float4>(const float4& x) {
using numext::i1;
return make_float4(i1(x.x), i1(x.y), i1(x.z), i1(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i1<float4>(const float4& x) {
using numext::bessel_i1;
return make_float4(bessel_i1(x.x), bessel_i1(x.y), bessel_i1(x.z), bessel_i1(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pi1<double2>(const double2& x) {
using numext::i1;
return make_double2(i1(x.x), i1(x.y));
pbessel_i1<double2>(const double2& x) {
using numext::bessel_i1;
return make_double2(bessel_i1(x.x), bessel_i1(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pk0e<float4>(const float4& x) {
using numext::k0e;
return make_float4(k0e(x.x), k0e(x.y), k0e(x.z), k0e(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k0e<float4>(const float4& x) {
using numext::bessel_k0e;
return make_float4(bessel_k0e(x.x), bessel_k0e(x.y), bessel_k0e(x.z), bessel_k0e(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pk0e<double2>(const double2& x) {
using numext::k0e;
return make_double2(k0e(x.x), k0e(x.y));
pbessel_k0e<double2>(const double2& x) {
using numext::bessel_k0e;
return make_double2(bessel_k0e(x.x), bessel_k0e(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pk0<float4>(const float4& x) {
using numext::k0;
return make_float4(k0(x.x), k0(x.y), k0(x.z), k0(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k0<float4>(const float4& x) {
using numext::bessel_k0;
return make_float4(bessel_k0(x.x), bessel_k0(x.y), bessel_k0(x.z), bessel_k0(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pk0<double2>(const double2& x) {
using numext::k0;
return make_double2(k0(x.x), k0(x.y));
pbessel_k0<double2>(const double2& x) {
using numext::bessel_k0;
return make_double2(bessel_k0(x.x), bessel_k0(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pk1e<float4>(const float4& x) {
using numext::k1e;
return make_float4(k1e(x.x), k1e(x.y), k1e(x.z), k1e(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k1e<float4>(const float4& x) {
using numext::bessel_k1e;
return make_float4(bessel_k1e(x.x), bessel_k1e(x.y), bessel_k1e(x.z), bessel_k1e(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pk1e<double2>(const double2& x) {
using numext::k1e;
return make_double2(k1e(x.x), k1e(x.y));
pbessel_k1e<double2>(const double2& x) {
using numext::bessel_k1e;
return make_double2(bessel_k1e(x.x), bessel_k1e(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pk1<float4>(const float4& x) {
using numext::k1;
return make_float4(k1(x.x), k1(x.y), k1(x.z), k1(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k1<float4>(const float4& x) {
using numext::bessel_k1;
return make_float4(bessel_k1(x.x), bessel_k1(x.y), bessel_k1(x.z), bessel_k1(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pk1<double2>(const double2& x) {
using numext::k1;
return make_double2(k1(x.x), k1(x.y));
pbessel_k1<double2>(const double2& x) {
using numext::bessel_k1;
return make_double2(bessel_k1(x.x), bessel_k1(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pj0<float4>(const float4& x) {
using numext::j0;
return make_float4(j0(x.x), j0(x.y), j0(x.z), j0(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_j0<float4>(const float4& x) {
using numext::bessel_j0;
return make_float4(bessel_j0(x.x), bessel_j0(x.y), bessel_j0(x.z), bessel_j0(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pj0<double2>(const double2& x) {
using numext::j0;
return make_double2(j0(x.x), j0(x.y));
pbessel_j0<double2>(const double2& x) {
using numext::bessel_j0;
return make_double2(bessel_j0(x.x), bessel_j0(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pj1<float4>(const float4& x) {
using numext::j1;
return make_float4(j1(x.x), j1(x.y), j1(x.z), j1(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_j1<float4>(const float4& x) {
using numext::bessel_j1;
return make_float4(bessel_j1(x.x), bessel_j1(x.y), bessel_j1(x.z), bessel_j1(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
pj1<double2>(const double2& x) {
using numext::j1;
return make_double2(j1(x.x), j1(x.y));
pbessel_j1<double2>(const double2& x) {
using numext::bessel_j1;
return make_double2(bessel_j1(x.x), bessel_j1(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 py0<float4>(const float4& x) {
using numext::y0;
return make_float4(y0(x.x), y0(x.y), y0(x.z), y0(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_y0<float4>(const float4& x) {
using numext::bessel_y0;
return make_float4(bessel_y0(x.x), bessel_y0(x.y), bessel_y0(x.z), bessel_y0(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
py0<double2>(const double2& x) {
using numext::y0;
return make_double2(y0(x.x), y0(x.y));
pbessel_y0<double2>(const double2& x) {
using numext::bessel_y0;
return make_double2(bessel_y0(x.x), bessel_y0(x.y));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 py1<float4>(const float4& x) {
using numext::y1;
return make_float4(y1(x.x), y1(x.y), y1(x.z), y1(x.w));
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_y1<float4>(const float4& x) {
using numext::bessel_y1;
return make_float4(bessel_y1(x.x), bessel_y1(x.y), bessel_y1(x.z), bessel_y1(x.w));
}
template <>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
py1<double2>(const double2& x) {
using numext::y1;
return make_double2(y1(x.x), y1(x.y));
pbessel_y1<double2>(const double2& x) {
using numext::bessel_y1;
return make_double2(bessel_y1(x.x), bessel_y1(x.y));
}
#endif