GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-04-21 09:09:36 +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
commit df0816b71f
12 changed files with 507 additions and 321 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
test/packetmath.cpp
View File

@ -609,12 +609,12 @@ template<typename Scalar,typename Packet> void packetmath_real()
CHECK_CWISE1_IF(PacketTraits::HasSqrt, std::sqrt, internal::psqrt);
CHECK_CWISE1_IF(PacketTraits::HasSqrt, Scalar(1)/std::sqrt, internal::prsqrt);
CHECK_CWISE1_IF(PacketTraits::HasLog, std::log, internal::plog);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::i0, internal::pi0);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::i0e, internal::pi0e);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::i1, internal::pi1);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::i1e, internal::pi1e);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::j0, internal::pj0);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::j1, internal::pj1);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0, internal::pbessel_i0);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0e, internal::pbessel_i0e);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1, internal::pbessel_i1);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1e, internal::pbessel_i1e);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_j0, internal::pbessel_j0);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_j1, internal::pbessel_j1);
// Use a smaller data range for the positive bessel operations as these
// can have much more error at very small and very large values.
@ -624,12 +624,12 @@ template<typename Scalar,typename Packet> void packetmath_real()
data2[i] = internal::random<Scalar>(0.01,1) * std::pow(
Scalar(10), internal::random<Scalar>(-1,2));
}
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::y0, internal::py0);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::y1, internal::py1);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::k0, internal::pk0);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::k0e, internal::pk0e);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::k1, internal::pk1);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::k1e, internal::pk1e);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_y0, internal::pbessel_y0);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_y1, internal::pbessel_y1);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k0, internal::pbessel_k0);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k0e, internal::pbessel_k0e);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k1, internal::pbessel_k1);
CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k1e, internal::pbessel_k1e);
#if EIGEN_HAS_C99_MATH && (__cplusplus > 199711L)
CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLGamma, std::lgamma, internal::plgamma);

24
unsupported/Eigen/CXX11/src/Tensor/TensorBase.h
View File

@ -137,73 +137,73 @@ class TensorBase<Derived, ReadOnlyAccessors>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i0_op<Scalar>, const Derived>
i0() const {
bessel_i0() const {
return unaryExpr(internal::scalar_bessel_i0_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i0e_op<Scalar>, const Derived>
i0e() const {
bessel_i0e() const {
return unaryExpr(internal::scalar_bessel_i0e_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i1_op<Scalar>, const Derived>
i1() const {
bessel_i1() const {
return unaryExpr(internal::scalar_bessel_i1_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i1e_op<Scalar>, const Derived>
i1e() const {
bessel_i1e() const {
return unaryExpr(internal::scalar_bessel_i1e_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_j0_op<Scalar>, const Derived>
j0() const {
bessel_j0() const {
return unaryExpr(internal::scalar_bessel_j0_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_y0_op<Scalar>, const Derived>
y0() const {
bessel_y0() const {
return unaryExpr(internal::scalar_bessel_y0_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_j1_op<Scalar>, const Derived>
j1() const {
bessel_j1() const {
return unaryExpr(internal::scalar_bessel_j1_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_y1_op<Scalar>, const Derived>
y1() const {
bessel_y1() const {
return unaryExpr(internal::scalar_bessel_y1_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k0_op<Scalar>, const Derived>
k0() const {
bessel_k0() const {
return unaryExpr(internal::scalar_bessel_k0_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k0e_op<Scalar>, const Derived>
k0e() const {
bessel_k0e() const {
return unaryExpr(internal::scalar_bessel_k0e_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k1_op<Scalar>, const Derived>
k1() const {
bessel_k1() const {
return unaryExpr(internal::scalar_bessel_k1_op<Scalar>());
}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k1e_op<Scalar>, const Derived>
k1e() const {
bessel_k1e() const {
return unaryExpr(internal::scalar_bessel_k1e_op<Scalar>());
}

232
unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h
View File

@ -379,7 +379,8 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
bool parallel_pack,
bool parallelize_by_sharding_dim_only,
DoneCallback done)
: done_(this, std::move(done)),
: created_by_thread_id_(std::this_thread::get_id()),
done_(this, std::move(done)),
device_(self->m_device),
lhs_(self->m_leftImpl, self->m_left_nocontract_strides,
self->m_i_strides, self->m_left_contracting_strides,
@ -408,7 +409,20 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
gn_(gn),
nm0_(nm0),
nn0_(nn0),
kernel_(m_, k_, n_, bm_, bk_, bn_) {
kernel_(m_, k_, n_, bm_, bk_, bn_),
num_thread_local_allocations_(0),
// We reserve 2X more capacity for a thread local values, than the
// number of threads in the pool to efficiently handle task stealing
// by threads that are not managed by the pool.
thread_local_capacity(2 * (parallelize_by_sharding_dim_only_
? device_.numThreadsInPool()
: 0)),
// We will use only one of the Lhs/Rhs thread local storage depending
// on the shard_by_col value and we parallelize by sharding dim ONLY.
lhs_thread_local_blocks_(shard_by_col_ ? 0 : thread_local_capacity,
{*this}, {*this}),
rhs_thread_local_blocks_(shard_by_col_ ? thread_local_capacity : 0,
{*this}, {*this}) {
// These two options are mutually exclusive.
eigen_assert(!(parallel_pack && parallelize_by_sharding_dim_only));
@ -455,12 +469,12 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
std::memory_order_relaxed);
Index num_blocks = num_worker_threads * gn_;
thread_local_packed_mem_ = kernel_.allocateSlices( //
thread_local_pre_alocated_mem_ = kernel_.allocateSlices( //
device_, //
/*num_lhs=*/0, //
/*num_rhs=*/num_blocks, //
/*num_slices=*/1, //
/*lhs_blocks=*/nullptr, &thread_local_packed_rhs_);
/*lhs_blocks=*/nullptr, &rhs_thread_local_pre_allocated_);
} else {
can_use_thread_local_packed_ = new std::atomic<bool>[nm_];
@ -469,11 +483,11 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
std::memory_order_relaxed);
Index num_blocks = num_worker_threads * gm_;
thread_local_packed_mem_ = kernel_.allocateSlices( //
thread_local_pre_alocated_mem_ = kernel_.allocateSlices( //
device_, //
/*num_lhs=*/num_blocks, //
/*num_rhs=*/0, //
/*num_slices=*/1, &thread_local_packed_lhs_, //
/*num_slices=*/1, &lhs_thread_local_pre_allocated_, //
/*rhs_blocks=*/nullptr);
}
}
@ -486,7 +500,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
}
kernel_.deallocate(device_, packed_mem_);
if (parallelize_by_sharding_dim_only_) {
kernel_.deallocate(device_, thread_local_packed_mem_);
kernel_.deallocate(device_, thread_local_pre_alocated_mem_);
delete[] can_use_thread_local_packed_;
}
}
@ -512,6 +526,8 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
}
private:
std::thread::id created_by_thread_id_;
// This notification is specialized on the type of DoneCallback and can be
// blocking or non-blocking.
EvalParallelNotification<DoneCallback, EvalParallelContext> done_;
@ -606,11 +622,185 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
// completion of the K-1 kernel, so we have to allocate "global" packed_lhs_
// and packed_rhs_ to allow kernels to be executed later on a thread
// different from the thread that was used for packing.
BlockMemHandle thread_local_packed_mem_;
// Only one of these will be initialized depending on shard_by_col value.
std::vector<LhsBlock> thread_local_packed_lhs_;
std::vector<RhsBlock> thread_local_packed_rhs_;
// Handle for pre-allocated thread local memory buffers.
BlockMemHandle thread_local_pre_alocated_mem_;
// Only one of these will be initialized depending on shard_by_col value
// (the size will be `num_worker_threads * num_grains_in_the_sharding_dim`).
std::vector<LhsBlock> lhs_thread_local_pre_allocated_;
std::vector<RhsBlock> rhs_thread_local_pre_allocated_;
// How many thread local blocks were already allocated.
std::atomic<int> num_thread_local_allocations_;
const int thread_local_capacity;
// We will use pre-allocated Lhs/Rhs blocks defined above, if the number of
// unique threads in a system is below or equal to the number of threads in
// a thread pool. We will fallback on dynamic memory allocation after that.
// ThreadLocalBlocks is a container for Lhs or Rhs thread local buffers. Its
// size is equal to the grain size in Lhs/Rhs sharding dimension.
template <typename BlockType>
class ThreadLocalBlocks {
public:
ThreadLocalBlocks() = default;
ThreadLocalBlocks(BlockType* base, size_t grain_size)
: is_pre_allocated_(true),
thread_local_pre_allocated_base_(base),
grain_size_(grain_size) {}
ThreadLocalBlocks(BlockMemHandle mem_handle,
std::vector<BlockType> blocks)
: is_pre_allocated_(false),
mem_handle_(std::move(mem_handle)),
blocks_(std::move(blocks)) {}
BlockType& block(int grain_index) {
eigen_assert(grain_index >= 0);
eigen_assert(static_cast<size_t>(grain_index) < size());
return is_pre_allocated_ ? thread_local_pre_allocated_base_[grain_index]
: blocks_[grain_index];
}
void Release(EvalParallelContext& ctx) const {
if (!is_pre_allocated_) {
ctx.kernel_.deallocate(ctx.device_, mem_handle_);
}
}
size_t size() const {
return is_pre_allocated_ ? grain_size_ : blocks_.size();
}
private:
bool is_pre_allocated_;
// Reuse pre-allocated thread local buffers.
BlockType* thread_local_pre_allocated_base_ = nullptr;
size_t grain_size_ = 0;
// These will be initialized only if `is_pre_allocated == false`.
BlockMemHandle mem_handle_{};
std::vector<BlockType> blocks_;
};
// ThreadLocalBlocksInitialize callable does custom thread local blocks
// initialization, and will reuse pre-allocated buffers if possible, or will
// dynamically allocate new memory.
//
// Lhs/Rhs blocks might be of the same type, so we have to pass explicitly
// for what side do we plan to do block allocation.
template <typename BlockType, bool is_rhs>
class ThreadLocalBlocksInitialize {
static constexpr bool kIsLhs =
!is_rhs && std::is_same<BlockType, LhsBlock>::value;
static const bool kIsRhs =
is_rhs && std::is_same<BlockType, RhsBlock>::value;
static_assert(kIsLhs || kIsRhs, "Unkown block type");
using Blocks = ThreadLocalBlocks<BlockType>;
public:
ThreadLocalBlocksInitialize(EvalParallelContext& ctx)
: ctx_(ctx),
num_worker_threads_(ctx_.device_.numThreadsInPool()) {}
void operator()(Blocks& blocks) {
const int n = ctx_.num_thread_local_allocations_.fetch_add(
1, std::memory_order_relaxed);
if (n >= num_worker_threads_) {
ThreadLocalBlocksAllocator<is_rhs>::allocate(ctx_, blocks);
} else {
ThreadLocalBlocksAllocator<is_rhs>::reuse(ctx_, n, blocks);
}
}
private:
// NOTE(ezhulenev): Without 'if constexpr' we have to put calls to
// TensorContractionKernel::allocateSlices into template specializations.
// Also explicit specializations are not allowed at class scope in C++03,
// EvalCtx type parameter is just a workaround for that limitation.
template <bool pack_rhs, typename EvalCtx = EvalParallelContext>
struct ThreadLocalBlocksAllocator;
template <typename EvalCtx>
struct ThreadLocalBlocksAllocator</*pack_rhs=*/true, EvalCtx> {
static void allocate(EvalCtx& ctx, Blocks& blocks) {
std::vector<RhsBlock> rhs_blocks;
BlockMemHandle mem_handle = ctx.kernel_.allocateSlices(
ctx.device_,
/*num_lhs=*/0,
/*num_rhs=*/ctx.gn_,
/*num_slices=*/1,
/*lhs_blocks=*/nullptr, /*rhs_blocks=*/&rhs_blocks);
blocks = ThreadLocalBlocks<RhsBlock>(std::move(mem_handle),
std::move(rhs_blocks));
}
static void reuse(EvalCtx& ctx, int index, Blocks& blocks) {
RhsBlock* ptr = &ctx.rhs_thread_local_pre_allocated_[ctx.gn_ * index];
blocks = ThreadLocalBlocks<RhsBlock>(ptr, ctx.gn_);
}
};
template <typename EvalCtx>
struct ThreadLocalBlocksAllocator</*pack_rhs=*/false, EvalCtx> {
static void allocate(EvalCtx& ctx, Blocks& blocks) {
std::vector<RhsBlock> lhs_blocks;
BlockMemHandle mem_handle = ctx.kernel_.allocateSlices(
ctx.device_,
/*num_lhs=*/ctx.gm_,
/*num_rhs=*/0,
/*num_slices=*/1,
/*lhs_blocks=*/&lhs_blocks, /*rhs_blocks=*/nullptr);
blocks = ThreadLocalBlocks<RhsBlock>(std::move(mem_handle),
std::move(lhs_blocks));
}
static void reuse(EvalCtx& ctx, int index, Blocks& blocks) {
LhsBlock* ptr = &ctx.lhs_thread_local_pre_allocated_[ctx.gm_ * index];
blocks = ThreadLocalBlocks<LhsBlock>(ptr, ctx.gm_);
}
};
EvalParallelContext& ctx_;
const int num_worker_threads_;
};
template <typename BlockType>
class ThreadLocalBlocksRelease {
public:
using Blocks = ThreadLocalBlocks<BlockType>;
ThreadLocalBlocksRelease(EvalParallelContext& ctx) : ctx_(ctx) {}
void operator()(Blocks& blocks) { blocks.Release(ctx_); }
private:
EvalParallelContext& ctx_;
};
// ThreadLocalBlocks initialization callables.
using ThreadLocalLhsInit =
ThreadLocalBlocksInitialize<LhsBlock, /*is_rhs=*/false>;
using ThreadLocalRhsInit =
ThreadLocalBlocksInitialize<RhsBlock, /*is_rhs=*/true>;
// ThreadLocalBlocks release callables.
using ThreadLocalLhsRelease = ThreadLocalBlocksRelease<LhsBlock>;
using ThreadLocalRhsRelease = ThreadLocalBlocksRelease<RhsBlock>;
// Thread local containers for Lhs/Rhs block packs. In practice only one of
// them will be used, depending on the shard_by_col value.
Eigen::ThreadLocal<ThreadLocalBlocks<LhsBlock>, ThreadLocalLhsInit,
ThreadLocalLhsRelease>
lhs_thread_local_blocks_;
Eigen::ThreadLocal<ThreadLocalBlocks<RhsBlock>, ThreadLocalRhsInit,
ThreadLocalRhsRelease>
rhs_thread_local_blocks_;
// After a particular shard for Kth slice missed thread local execution
// opportunity (K-1 slice didn't complete kernels execution), we can no
@ -630,12 +820,10 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
LhsBlock& packed_lhs(Index m, Index k, Index m1, bool use_thread_local) {
if (use_thread_local) {
eigen_assert(!shard_by_col_);
ThreadLocalBlocks<LhsBlock>& blocks = lhs_thread_local_blocks_.local();
Index base_idx = gm_ * device_.currentThreadId();
Index grain_idx = m1 - m * gm_;
Index block_idx = base_idx + grain_idx;
return thread_local_packed_lhs_[block_idx];
Index grain_index = m1 - m * gm_;
return blocks.block(grain_index);
} else {
return packed_lhs_[k % (P - 1)][m1];
}
@ -644,12 +832,10 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
RhsBlock& packed_rhs(Index n, Index k, Index n1, bool use_thread_local) {
if (use_thread_local) {
eigen_assert(shard_by_col_);
ThreadLocalBlocks<RhsBlock>& blocks = rhs_thread_local_blocks_.local();
Index base_idx = gn_ * device_.currentThreadId();
Index grain_idx = n1 - n * gn_;
Index block_idx = base_idx + grain_idx;
return thread_local_packed_rhs_[block_idx];
Index grain_index = n1 - n * gn_;
return blocks.block(grain_index);
} else {
return packed_rhs_[k % (P - 1)][n1];
}
@ -877,11 +1063,11 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
// to the execution of the first kernel of the k+1 slice, before
// completing a call to the last kernel of the k slice.
// (2) all pack tasks for sharded dim must be executed in a thread
// pool.
// pool to get pre-allocated thead local buffers.
bool pack_async =
(start == 0) &&
(parallelize_by_sharding_dim_only_&& shard_by_col_ == rhs) &&
(k > 0 || device_.currentThreadId() < 0);
(k > 0 || std::this_thread::get_id() == created_by_thread_id_);
if (pack_async) {
device_.enqueueNoNotification(

24
unsupported/Eigen/SpecialFunctions
View File

@ -39,18 +39,18 @@ namespace Eigen {
* - betainc
*
* Bessel Functions
* - i0
* - i0e
* - i1
* - i1e
* - j0
* - j1
* - y0
* - y1
* - k0
* - k0e
* - k1
* - k1e
* - bessel_i0
* - bessel_i0e
* - bessel_i1
* - bessel_i1e
* - bessel_j0
* - bessel_j1
* - bessel_k0
* - bessel_k0e
* - bessel_k1
* - bessel_k1e
* - bessel_y0
* - bessel_y1
*
* \code
* #include <unsupported/Eigen/SpecialFunctions>

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

26
unsupported/test/bessel_functions.cpp
View File

@ -43,7 +43,7 @@ template<typename ArrayType> void array_bessel_functions()
1.89489253e+04, 1.29418563e+05, 8.93446228e+05, 6.21841242e+06,
4.35582826e+07;
CALL_SUBTEST(res = i0(x);
CALL_SUBTEST(res = bessel_i0(x);
verify_component_wise(res, expected););
}
@ -63,7 +63,7 @@ template<typename ArrayType> void array_bessel_functions()
0.116426221213, 0.107615251671, 0.100544127361, 0.0947062952128,
0.0897803118848;
CALL_SUBTEST(res = i0e(x);
CALL_SUBTEST(res = bessel_i0e(x);
verify_component_wise(res, expected););
}
@ -83,7 +83,7 @@ template<typename ArrayType> void array_bessel_functions()
1.81413488e+04, 1.24707259e+05, 8.65059436e+05, 6.04313324e+06,
4.24549734e+07;
CALL_SUBTEST(res = i1(x);
CALL_SUBTEST(res = bessel_i1(x);
verify_component_wise(res, expected););
}
@ -103,7 +103,7 @@ template<typename ArrayType> void array_bessel_functions()
0.11146429929, 0.103697667463, 0.0973496147565, 0.092036796872,
0.0875062221833;
CALL_SUBTEST(res = i1e(x);
CALL_SUBTEST(res = bessel_i1e(x);
verify_component_wise(res, expected););
}
@ -139,7 +139,7 @@ template<typename ArrayType> void array_bessel_functions()
-0.08636798, 0.05120815, 0.13807901, 0.09727067, -0.03042119,
-0.12684568, -0.10556738, 0.01086237, 0.11433274;
CALL_SUBTEST(res = j0(x);
CALL_SUBTEST(res = bessel_j0(x);
verify_component_wise(res, expected););
}
@ -176,7 +176,7 @@ template<typename ArrayType> void array_bessel_functions()
0.04399094, -0.08232981, -0.13058004, -0.05916189, 0.0640561 ,
0.12603832;
CALL_SUBTEST(res = j1(x);
CALL_SUBTEST(res = bessel_j1(x);
verify_component_wise(res, expected););
}
// Test Bessel function k0e. Reference results obtained with SciPy.
@ -200,7 +200,7 @@ template<typename ArrayType> void array_bessel_functions()
0.21736123, 0.21416406, 0.21110397, 0.20817141, 0.20535778,
0.20265524, 0.20005668, 0.19755558;
CALL_SUBTEST(res = k0e(x);
CALL_SUBTEST(res = bessel_k0e(x);
verify_component_wise(res, expected););
}
@ -227,7 +227,7 @@ template<typename ArrayType> void array_bessel_functions()
1.33103515e-16, 4.82858338e-17, 1.75232770e-17, 6.36161716e-18,
2.31029936e-18, 8.39286110e-19;
CALL_SUBTEST(res = k0(x);
CALL_SUBTEST(res = bessel_k0(x);
verify_component_wise(res, expected););
}
@ -254,7 +254,7 @@ template<typename ArrayType> void array_bessel_functions()
0.21110397, 0.20817141, 0.20535778, 0.20265524,
0.20005668, 0.19755558;
CALL_SUBTEST(res = k0e(x);
CALL_SUBTEST(res = bessel_k0e(x);
verify_component_wise(res, expected););
}
@ -281,7 +281,7 @@ template<typename ArrayType> void array_bessel_functions()
1.34991783e-16, 4.89519373e-17, 1.77585196e-17, 6.44478588e-18,
2.33973340e-18, 8.49713195e-19;
CALL_SUBTEST(res = k1(x);
CALL_SUBTEST(res = bessel_k1(x);
verify_component_wise(res, expected););
}
@ -308,7 +308,7 @@ template<typename ArrayType> void array_bessel_functions()
0.21409878, 0.21104314, 0.20811462, 0.20530466,
0.20260547, 0.20000997;
CALL_SUBTEST(res = k1e(x);
CALL_SUBTEST(res = bessel_k1e(x);
verify_component_wise(res, expected););
}
@ -333,7 +333,7 @@ template<typename ArrayType> void array_bessel_functions()
0.13340405, 0.04579799, -0.08085609, -0.13071488, -0.06066076,
0.06262353, 0.12593642;
CALL_SUBTEST(res = y0(x);
CALL_SUBTEST(res = bessel_y0(x);
verify_component_wise(res, expected););
}
@ -358,7 +358,7 @@ template<typename ArrayType> void array_bessel_functions()
-0.09578012, 0.03238588, 0.12751273, 0.10445477, -0.01262946,
-0.11514066, -0.11056411, -0.00579351;
CALL_SUBTEST(res = y1(x);
CALL_SUBTEST(res = bessel_y1(x);
verify_component_wise(res, expected););
}
}

4
unsupported/test/cxx11_tensor_gpu.cu
View File

@ -1317,7 +1317,7 @@ void test_gpu_i0e()
Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in(d_in, 21);
Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 21);
gpu_out.device(gpu_device) = gpu_in.i0e();
gpu_out.device(gpu_device) = gpu_in.bessel_i0e();
assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost,
gpu_device.stream()) == gpuSuccess);
@ -1372,7 +1372,7 @@ void test_gpu_i1e()
Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in(d_in, 21);
Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 21);
gpu_out.device(gpu_device) = gpu_in.i1e();
gpu_out.device(gpu_device) = gpu_in.bessel_i1e();
assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost,
gpu_device.stream()) == gpuSuccess);