Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
 
Loading...
Searching...
No Matches
BesselFunctionsFunctors.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
5// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
6//
7// This Source Code Form is subject to the terms of the Mozilla
8// Public License v. 2.0. If a copy of the MPL was not distributed
9// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10
11#ifndef EIGEN_BESSELFUNCTIONS_FUNCTORS_H
12#define EIGEN_BESSELFUNCTIONS_FUNCTORS_H
13
14namespace Eigen {
15
16namespace internal {
17
23template <typename Scalar>
24struct scalar_bessel_i0_op {
25 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_i0_op)
26 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
27 using numext::bessel_i0;
28 return bessel_i0(x);
29 }
30 typedef typename packet_traits<Scalar>::type Packet;
31 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
32 return internal::pbessel_i0(x);
33 }
34};
35template <typename Scalar>
36struct functor_traits<scalar_bessel_i0_op<Scalar> > {
37 enum {
38 // On average, a Chebyshev polynomial of order N=20 is computed.
39 // The cost is N multiplications and 2N additions. We also add
40 // the cost of an additional exp over i0e.
41 Cost = 28 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
42 PacketAccess = packet_traits<Scalar>::HasBessel
43 };
44};
45
51template <typename Scalar>
52struct scalar_bessel_i0e_op {
53 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_i0e_op)
54 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
55 using numext::bessel_i0e;
56 return bessel_i0e(x);
57 }
58 typedef typename packet_traits<Scalar>::type Packet;
59 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
60 return internal::pbessel_i0e(x);
61 }
62};
63template <typename Scalar>
64struct functor_traits<scalar_bessel_i0e_op<Scalar> > {
65 enum {
66 // On average, a Chebyshev polynomial of order N=20 is computed.
67 // The cost is N multiplications and 2N additions.
68 Cost = 20 * NumTraits<Scalar>::MulCost + 40 * NumTraits<Scalar>::AddCost,
69 PacketAccess = packet_traits<Scalar>::HasBessel
70 };
71};
72
78template <typename Scalar>
79struct scalar_bessel_i1_op {
80 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_i1_op)
81 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
82 using numext::bessel_i1;
83 return bessel_i1(x);
84 }
85 typedef typename packet_traits<Scalar>::type Packet;
86 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
87 return internal::pbessel_i1(x);
88 }
89};
90template <typename Scalar>
91struct functor_traits<scalar_bessel_i1_op<Scalar> > {
92 enum {
93 // On average, a Chebyshev polynomial of order N=20 is computed.
94 // The cost is N multiplications and 2N additions. We also add
95 // the cost of an additional exp over i1e.
96 Cost = 28 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
97 PacketAccess = packet_traits<Scalar>::HasBessel
98 };
99};
100
106template <typename Scalar>
107struct scalar_bessel_i1e_op {
108 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_i1e_op)
109 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
110 using numext::bessel_i1e;
111 return bessel_i1e(x);
112 }
113 typedef typename packet_traits<Scalar>::type Packet;
114 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
115 return internal::pbessel_i1e(x);
116 }
117};
118template <typename Scalar>
119struct functor_traits<scalar_bessel_i1e_op<Scalar> > {
120 enum {
121 // On average, a Chebyshev polynomial of order N=20 is computed.
122 // The cost is N multiplications and 2N additions.
123 Cost = 20 * NumTraits<Scalar>::MulCost + 40 * NumTraits<Scalar>::AddCost,
124 PacketAccess = packet_traits<Scalar>::HasBessel
125 };
126};
127
133template <typename Scalar>
134struct scalar_bessel_j0_op {
135 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_j0_op)
136 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
137 using numext::bessel_j0;
138 return bessel_j0(x);
139 }
140 typedef typename packet_traits<Scalar>::type Packet;
141 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
142 return internal::pbessel_j0(x);
143 }
144};
145template <typename Scalar>
146struct functor_traits<scalar_bessel_j0_op<Scalar> > {
147 enum {
148 // 6 polynomial of order ~N=8 is computed.
149 // The cost is N multiplications and N additions each, along with a
150 // sine, cosine and rsqrt cost.
151 Cost = 63 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
152 PacketAccess = packet_traits<Scalar>::HasBessel
153 };
154};
155
161template <typename Scalar>
162struct scalar_bessel_y0_op {
163 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_y0_op)
164 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
165 using numext::bessel_y0;
166 return bessel_y0(x);
167 }
168 typedef typename packet_traits<Scalar>::type Packet;
169 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
170 return internal::pbessel_y0(x);
171 }
172};
173template <typename Scalar>
174struct functor_traits<scalar_bessel_y0_op<Scalar> > {
175 enum {
176 // 6 polynomial of order ~N=8 is computed.
177 // The cost is N multiplications and N additions each, along with a
178 // sine, cosine, rsqrt and j0 cost.
179 Cost = 126 * NumTraits<Scalar>::MulCost + 96 * NumTraits<Scalar>::AddCost,
180 PacketAccess = packet_traits<Scalar>::HasBessel
181 };
182};
183
189template <typename Scalar>
190struct scalar_bessel_j1_op {
191 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_j1_op)
192 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
193 using numext::bessel_j1;
194 return bessel_j1(x);
195 }
196 typedef typename packet_traits<Scalar>::type Packet;
197 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
198 return internal::pbessel_j1(x);
199 }
200};
201template <typename Scalar>
202struct functor_traits<scalar_bessel_j1_op<Scalar> > {
203 enum {
204 // 6 polynomial of order ~N=8 is computed.
205 // The cost is N multiplications and N additions each, along with a
206 // sine, cosine and rsqrt cost.
207 Cost = 63 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
208 PacketAccess = packet_traits<Scalar>::HasBessel
209 };
210};
211
217template <typename Scalar>
218struct scalar_bessel_y1_op {
219 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_y1_op)
220 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
221 using numext::bessel_y1;
222 return bessel_y1(x);
223 }
224 typedef typename packet_traits<Scalar>::type Packet;
225 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
226 return internal::pbessel_y1(x);
227 }
228};
229template <typename Scalar>
230struct functor_traits<scalar_bessel_y1_op<Scalar> > {
231 enum {
232 // 6 polynomial of order ~N=8 is computed.
233 // The cost is N multiplications and N additions each, along with a
234 // sine, cosine, rsqrt and j1 cost.
235 Cost = 126 * NumTraits<Scalar>::MulCost + 96 * NumTraits<Scalar>::AddCost,
236 PacketAccess = packet_traits<Scalar>::HasBessel
237 };
238};
239
245template <typename Scalar>
246struct scalar_bessel_k0_op {
247 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_k0_op)
248 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
249 using numext::bessel_k0;
250 return bessel_k0(x);
251 }
252 typedef typename packet_traits<Scalar>::type Packet;
253 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
254 return internal::pbessel_k0(x);
255 }
256};
257template <typename Scalar>
258struct functor_traits<scalar_bessel_k0_op<Scalar> > {
259 enum {
260 // On average, a Chebyshev polynomial of order N=10 is computed.
261 // The cost is N multiplications and 2N additions. In addition we compute
262 // i0, a log, exp and prsqrt and sin and cos.
263 Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
264 PacketAccess = packet_traits<Scalar>::HasBessel
265 };
266};
267
273template <typename Scalar>
274struct scalar_bessel_k0e_op {
275 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_k0e_op)
276 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
277 using numext::bessel_k0e;
278 return bessel_k0e(x);
279 }
280 typedef typename packet_traits<Scalar>::type Packet;
281 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
282 return internal::pbessel_k0e(x);
283 }
284};
285template <typename Scalar>
286struct functor_traits<scalar_bessel_k0e_op<Scalar> > {
287 enum {
288 // On average, a Chebyshev polynomial of order N=10 is computed.
289 // The cost is N multiplications and 2N additions. In addition we compute
290 // i0, a log, exp and prsqrt and sin and cos.
291 Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
292 PacketAccess = packet_traits<Scalar>::HasBessel
293 };
294};
295
301template <typename Scalar>
302struct scalar_bessel_k1_op {
303 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_k1_op)
304 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
305 using numext::bessel_k1;
306 return bessel_k1(x);
307 }
308 typedef typename packet_traits<Scalar>::type Packet;
309 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
310 return internal::pbessel_k1(x);
311 }
312};
313template <typename Scalar>
314struct functor_traits<scalar_bessel_k1_op<Scalar> > {
315 enum {
316 // On average, a Chebyshev polynomial of order N=10 is computed.
317 // The cost is N multiplications and 2N additions. In addition we compute
318 // i1, a log, exp and prsqrt and sin and cos.
319 Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
320 PacketAccess = packet_traits<Scalar>::HasBessel
321 };
322};
323
329template <typename Scalar>
330struct scalar_bessel_k1e_op {
331 EIGEN_EMPTY_STRUCT_CTOR(scalar_bessel_k1e_op)
332 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
333 using numext::bessel_k1e;
334 return bessel_k1e(x);
335 }
336 typedef typename packet_traits<Scalar>::type Packet;
337 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
338 return internal::pbessel_k1e(x);
339 }
340};
341template <typename Scalar>
342struct functor_traits<scalar_bessel_k1e_op<Scalar> > {
343 enum {
344 // On average, a Chebyshev polynomial of order N=10 is computed.
345 // The cost is N multiplications and 2N additions. In addition we compute
346 // i1, a log, exp and prsqrt and sin and cos.
347 Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
348 PacketAccess = packet_traits<Scalar>::HasBessel
349 };
350};
351
352
353} // end namespace internal
354
355} // end namespace Eigen
356
357#endif // EIGEN_BESSELFUNCTIONS_FUNCTORS_H
Namespace containing all symbols from the Eigen library.
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y1_op< typename Derived::Scalar >, const Derived > bessel_y1(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:278
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0e_op< typename Derived::Scalar >, const Derived > bessel_k0e(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:145
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k0_op< typename Derived::Scalar >, const Derived > bessel_k0(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:122
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1_op< typename Derived::Scalar >, const Derived > bessel_k1(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:167
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1_op< typename Derived::Scalar >, const Derived > bessel_i1(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:77
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0e_op< typename Derived::Scalar >, const Derived > bessel_i0e(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:55
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i1e_op< typename Derived::Scalar >, const Derived > bessel_i1e(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:100
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j1_op< typename Derived::Scalar >, const Derived > bessel_j1(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:256
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_y0_op< typename Derived::Scalar >, const Derived > bessel_y0(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:234
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_i0_op< typename Derived::Scalar >, const Derived > bessel_i0(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:32
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_k1e_op< typename Derived::Scalar >, const Derived > bessel_k1e(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:190
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_bessel_j0_op< typename Derived::Scalar >, const Derived > bessel_j0(const Eigen::ArrayBase< Derived > &x)
Definition: BesselFunctionsArrayAPI.h:212