diff options
author | Srinivas Vasudevan <srvasude@google.com> | 2019-09-16 19:33:29 -0400 |
---|---|---|
committer | Srinivas Vasudevan <srvasude@google.com> | 2019-09-16 19:33:29 -0400 |
commit | df0816b71ff9f4844fe5027f87e0a94afd665f7d (patch) | |
tree | 39397faa9a403e62d8b91d84daddddf378b16f2f | |
parent | 6e215cf109073da9ffb5b491171613b8db24fd9d (diff) | |
parent | 7c732968491f739b6ad26eeda8ae60ef37971dda (diff) |
Merging eigen/eigen.
-rw-r--r-- | test/packetmath.cpp | 24 | ||||
-rw-r--r-- | unsupported/Eigen/CXX11/src/Tensor/TensorBase.h | 24 | ||||
-rw-r--r-- | unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h | 246 | ||||
-rw-r--r-- | unsupported/Eigen/SpecialFunctions | 24 | ||||
-rw-r--r-- | unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h | 48 | ||||
-rw-r--r-- | unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h | 96 | ||||
-rw-r--r-- | unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h | 48 | ||||
-rw-r--r-- | unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h | 120 | ||||
-rw-r--r-- | unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h | 24 | ||||
-rw-r--r-- | unsupported/Eigen/src/SpecialFunctions/arch/GPU/GpuSpecialFunctions.h | 144 | ||||
-rw-r--r-- | unsupported/test/bessel_functions.cpp | 26 | ||||
-rw-r--r-- | unsupported/test/cxx11_tensor_gpu.cu | 4 |
12 files changed, 507 insertions, 321 deletions
diff --git a/test/packetmath.cpp b/test/packetmath.cpp index 0f9ce6d06..2c7fb5aeb 100644 --- a/test/packetmath.cpp +++ b/test/packetmath.cpp @@ -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); diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h b/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h index 48e0217e5..a951bea6d 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h @@ -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>()); } diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h index 4adfeb560..ba3a80f97 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h @@ -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( // - device_, // - /*num_lhs=*/0, // - /*num_rhs=*/num_blocks, // - /*num_slices=*/1, // - /*lhs_blocks=*/nullptr, &thread_local_packed_rhs_); + thread_local_pre_alocated_mem_ = kernel_.allocateSlices( // + device_, // + /*num_lhs=*/0, // + /*num_rhs=*/num_blocks, // + /*num_slices=*/1, // + /*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( // - device_, // - /*num_lhs=*/num_blocks, // - /*num_rhs=*/0, // - /*num_slices=*/1, &thread_local_packed_lhs_, // + thread_local_pre_alocated_mem_ = kernel_.allocateSlices( // + device_, // + /*num_lhs=*/num_blocks, // + /*num_rhs=*/0, // + /*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( diff --git a/unsupported/Eigen/SpecialFunctions b/unsupported/Eigen/SpecialFunctions index ffa348eb4..6e8132fb2 100644 --- a/unsupported/Eigen/SpecialFunctions +++ b/unsupported/Eigen/SpecialFunctions @@ -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> diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h index 8f96c2ae7..41d2bf61c 100644 --- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h +++ b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h @@ -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()); diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h index e57d5042b..8606a9f8e 100644 --- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h +++ b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h @@ -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> diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h index 9aad7ac96..8930d1a3c 100644 --- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h +++ b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h @@ -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 diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h index b279687c2..c7c4f2649 100644 --- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h +++ b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h @@ -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 diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h index 70eaad5cd..efc6d9c8f 100644 --- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h +++ b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h @@ -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); } diff --git a/unsupported/Eigen/src/SpecialFunctions/arch/GPU/GpuSpecialFunctions.h b/unsupported/Eigen/src/SpecialFunctions/arch/GPU/GpuSpecialFunctions.h index b886e278c..dd3bf4dd1 100644 --- a/unsupported/Eigen/src/SpecialFunctions/arch/GPU/GpuSpecialFunctions.h +++ b/unsupported/Eigen/src/SpecialFunctions/arch/GPU/GpuSpecialFunctions.h @@ -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 diff --git a/unsupported/test/bessel_functions.cpp b/unsupported/test/bessel_functions.cpp index 2b6bb6b2c..06765bfab 100644 --- a/unsupported/test/bessel_functions.cpp +++ b/unsupported/test/bessel_functions.cpp @@ -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);); } } diff --git a/unsupported/test/cxx11_tensor_gpu.cu b/unsupported/test/cxx11_tensor_gpu.cu index aa8470123..137d0d596 100644 --- a/unsupported/test/cxx11_tensor_gpu.cu +++ b/unsupported/test/cxx11_tensor_gpu.cu @@ -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); |