vSMC
vSMC: Scalable Monte Carlo
vmath.hpp
Go to the documentation of this file.
1 //============================================================================
2 // vSMC/include/vsmc/math/vmath.hpp
3 //----------------------------------------------------------------------------
4 // vSMC: Scalable Monte Carlo
5 //----------------------------------------------------------------------------
6 // Copyright (c) 2013,2014, Yan Zhou
7 // All rights reserved.
8 //
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are met:
11 //
12 // Redistributions of source code must retain the above copyright notice,
13 // this list of conditions and the following disclaimer.
14 //
15 // Redistributions in binary form must reproduce the above copyright notice,
16 // this list of conditions and the following disclaimer in the documentation
17 // and/or other materials provided with the distribution.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
20 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 // POSSIBILITY OF SUCH DAMAGE.
30 //============================================================================
31 
32 #ifndef VSMC_MATH_VMATH_HPP
33 #define VSMC_MATH_VMATH_HPP
34 
35 #include <vsmc/internal/config.hpp>
36 #include <vsmc/cxx11/cmath.hpp>
37 #include <vsmc/math/constants.hpp>
38 
39 #if VSMC_USE_MKL_VML
40 #include <mkl.h>
41 #elif VSMC_USE_VECLIB_VFORCE
42 #include <Accelerate/Accelerate.h>
43 #endif
44 
56 #ifndef VSMC_VMATH_THRESHOLD
57 #define VSMC_VMATH_THRESHOLD 1000
58 #endif
59 
60 #ifndef VSMC_VMATH_THRESHOLD_Add
61 #define VSMC_VMATH_THRESHOLD_Add VSMC_VMATH_THRESHOLD
62 #endif
63 
64 #ifndef VSMC_VMATH_THRESHOLD_Sub
65 #define VSMC_VMATH_THRESHOLD_Sub VSMC_VMATH_THRESHOLD
66 #endif
67 
68 #ifndef VSMC_VMATH_THRESHOLD_Sqr
69 #define VSMC_VMATH_THRESHOLD_Sqr VSMC_VMATH_THRESHOLD
70 #endif
71 
72 #ifndef VSMC_VMATH_THRESHOLD_Mul
73 #define VSMC_VMATH_THRESHOLD_Mul VSMC_VMATH_THRESHOLD
74 #endif
75 
76 #ifndef VSMC_VMATH_THRESHOLD_Abs
77 #define VSMC_VMATH_THRESHOLD_Abs VSMC_VMATH_THRESHOLD
78 #endif
79 
80 #ifndef VSMC_VMATH_THRESHOLD_LinearFrac
81 #define VSMC_VMATH_THRESHOLD_LinearFrac VSMC_VMATH_THRESHOLD
82 #endif
83 
84 #ifndef VSMC_VMATH_THRESHOLD_Inv
85 #define VSMC_VMATH_THRESHOLD_Inv VSMC_VMATH_THRESHOLD
86 #endif
87 
88 #ifndef VSMC_VMATH_THRESHOLD_Div
89 #define VSMC_VMATH_THRESHOLD_Div VSMC_VMATH_THRESHOLD
90 #endif
91 
92 #ifndef VSMC_VMATH_THRESHOLD_Sqrt
93 #define VSMC_VMATH_THRESHOLD_Sqrt VSMC_VMATH_THRESHOLD
94 #endif
95 
96 #ifndef VSMC_VMATH_THRESHOLD_InvSqrt
97 #define VSMC_VMATH_THRESHOLD_InvSqrt VSMC_VMATH_THRESHOLD
98 #endif
99 
100 #ifndef VSMC_VMATH_THRESHOLD_Cbrt
101 #define VSMC_VMATH_THRESHOLD_Cbrt VSMC_VMATH_THRESHOLD
102 #endif
103 
104 #ifndef VSMC_VMATH_THRESHOLD_InvCbrt
105 #define VSMC_VMATH_THRESHOLD_InvCbrt VSMC_VMATH_THRESHOLD
106 #endif
107 
108 #ifndef VSMC_VMATH_THRESHOLD_Pow2o3
109 #define VSMC_VMATH_THRESHOLD_Pow2o3 VSMC_VMATH_THRESHOLD
110 #endif
111 
112 #ifndef VSMC_VMATH_THRESHOLD_Pow3o2
113 #define VSMC_VMATH_THRESHOLD_Pow3o2 VSMC_VMATH_THRESHOLD
114 #endif
115 
116 #ifndef VSMC_VMATH_THRESHOLD_Pow
117 #define VSMC_VMATH_THRESHOLD_Pow VSMC_VMATH_THRESHOLD
118 #endif
119 
120 #ifndef VSMC_VMATH_THRESHOLD_Powx
121 #define VSMC_VMATH_THRESHOLD_Powx VSMC_VMATH_THRESHOLD
122 #endif
123 
124 #ifndef VSMC_VMATH_THRESHOLD_Hypot
125 #define VSMC_VMATH_THRESHOLD_Hypot VSMC_VMATH_THRESHOLD
126 #endif
127 
128 #ifndef VSMC_VMATH_THRESHOLD_Exp
129 #define VSMC_VMATH_THRESHOLD_Exp VSMC_VMATH_THRESHOLD
130 #endif
131 
132 #ifndef VSMC_VMATH_THRESHOLD_Expm1
133 #define VSMC_VMATH_THRESHOLD_Expm1 VSMC_VMATH_THRESHOLD
134 #endif
135 
136 #ifndef VSMC_VMATH_THRESHOLD_Ln
137 #define VSMC_VMATH_THRESHOLD_Ln VSMC_VMATH_THRESHOLD
138 #endif
139 
140 #ifndef VSMC_VMATH_THRESHOLD_Log10
141 #define VSMC_VMATH_THRESHOLD_Log10 VSMC_VMATH_THRESHOLD
142 #endif
143 
144 #ifndef VSMC_VMATH_THRESHOLD_Log1p
145 #define VSMC_VMATH_THRESHOLD_Log1p VSMC_VMATH_THRESHOLD
146 #endif
147 
148 #ifndef VSMC_VMATH_THRESHOLD_Cos
149 #define VSMC_VMATH_THRESHOLD_Cos VSMC_VMATH_THRESHOLD
150 #endif
151 
152 #ifndef VSMC_VMATH_THRESHOLD_Sin
153 #define VSMC_VMATH_THRESHOLD_Sin VSMC_VMATH_THRESHOLD
154 #endif
155 
156 #ifndef VSMC_VMATH_THRESHOLD_SinCos
157 #define VSMC_VMATH_THRESHOLD_SinCos VSMC_VMATH_THRESHOLD
158 #endif
159 
160 #ifndef VSMC_VMATH_THRESHOLD_Tan
161 #define VSMC_VMATH_THRESHOLD_Tan VSMC_VMATH_THRESHOLD
162 #endif
163 
164 #ifndef VSMC_VMATH_THRESHOLD_Acos
165 #define VSMC_VMATH_THRESHOLD_Acos VSMC_VMATH_THRESHOLD
166 #endif
167 
168 #ifndef VSMC_VMATH_THRESHOLD_Asin
169 #define VSMC_VMATH_THRESHOLD_Asin VSMC_VMATH_THRESHOLD
170 #endif
171 
172 #ifndef VSMC_VMATH_THRESHOLD_Atan
173 #define VSMC_VMATH_THRESHOLD_Atan VSMC_VMATH_THRESHOLD
174 #endif
175 
176 #ifndef VSMC_VMATH_THRESHOLD_Atan2
177 #define VSMC_VMATH_THRESHOLD_Atan2 VSMC_VMATH_THRESHOLD
178 #endif
179 
180 #ifndef VSMC_VMATH_THRESHOLD_Cosh
181 #define VSMC_VMATH_THRESHOLD_Cosh VSMC_VMATH_THRESHOLD
182 #endif
183 
184 #ifndef VSMC_VMATH_THRESHOLD_Sinh
185 #define VSMC_VMATH_THRESHOLD_Sinh VSMC_VMATH_THRESHOLD
186 #endif
187 
188 #ifndef VSMC_VMATH_THRESHOLD_Tanh
189 #define VSMC_VMATH_THRESHOLD_Tanh VSMC_VMATH_THRESHOLD
190 #endif
191 
192 #ifndef VSMC_VMATH_THRESHOLD_Acosh
193 #define VSMC_VMATH_THRESHOLD_Acosh VSMC_VMATH_THRESHOLD
194 #endif
195 
196 #ifndef VSMC_VMATH_THRESHOLD_Asinh
197 #define VSMC_VMATH_THRESHOLD_Asinh VSMC_VMATH_THRESHOLD
198 #endif
199 
200 #ifndef VSMC_VMATH_THRESHOLD_Atanh
201 #define VSMC_VMATH_THRESHOLD_Atanh VSMC_VMATH_THRESHOLD
202 #endif
203 
204 #ifndef VSMC_VMATH_THRESHOLD_Erf
205 #define VSMC_VMATH_THRESHOLD_Erf VSMC_VMATH_THRESHOLD
206 #endif
207 
208 #ifndef VSMC_VMATH_THRESHOLD_Erfc
209 #define VSMC_VMATH_THRESHOLD_Erfc VSMC_VMATH_THRESHOLD
210 #endif
211 
212 #ifndef VSMC_VMATH_THRESHOLD_CdfNorm
213 #define VSMC_VMATH_THRESHOLD_CdfNorm VSMC_VMATH_THRESHOLD
214 #endif
215 
216 #ifndef VSMC_VMATH_THRESHOLD_ErfInv
217 #define VSMC_VMATH_THRESHOLD_ErfInv VSMC_VMATH_THRESHOLD
218 #endif
219 
220 #ifndef VSMC_VMATH_THRESHOLD_ErfcInv
221 #define VSMC_VMATH_THRESHOLD_ErfcInv VSMC_VMATH_THRESHOLD
222 #endif
223 
224 #ifndef VSMC_VMATH_THRESHOLD_CdfNormInv
225 #define VSMC_VMATH_THRESHOLD_CdfNormInv VSMC_VMATH_THRESHOLD
226 #endif
227 
228 #ifndef VSMC_VMATH_THRESHOLD_LGamma
229 #define VSMC_VMATH_THRESHOLD_LGamma VSMC_VMATH_THRESHOLD
230 #endif
231 
232 #ifndef VSMC_VMATH_THRESHOLD_TGamma
233 #define VSMC_VMATH_THRESHOLD_TGamma VSMC_VMATH_THRESHOLD
234 #endif
235 
236 #define VSMC_DEFINE_MATH_VMATH_1(ns, func, name) \
237 template <typename T> \
238 inline void v##name (std::size_t n, const T *a, T *y) \
239 { \
240  using ns::func; \
241  for (std::size_t i = 0; i != n; ++i) \
242  y[i] = func(a[i]); \
243 }
244 
245 #define VSMC_DEFINE_MATH_VMATH_2(ns, func, name) \
246 template <typename T> \
247 inline void v##name (std::size_t n, const T *a, const T *b, T *y) \
248 { \
249  using ns::func; \
250  for (std::size_t i = 0; i != n; ++i) \
251  y[i] = func(a[i], b[i]); \
252 }
253 
254 #define VSMC_DEFINE_MATH_VMATH_B(op, vname) \
255 template <typename T> \
256 inline void v##vname (std::size_t n, const T *a, const T *b, T *y) \
257 { \
258  for (std::size_t i = 0; i != n; ++i) \
259  y[i] = a[i] op b[i]; \
260 }
261 
262 namespace vsmc {
263 
264 namespace math {
265 
266 namespace internal {
267 
268 template <typename T>
269 inline T vmath_sqr (T a)
270 {return a * a;}
271 
272 template <typename T>
273 inline T vmath_inv (T a)
274 {return static_cast<T>(1) / a;}
275 
276 template <typename T>
277 inline T vmath_invsqrt (T a)
278 {using std::sqrt; return static_cast<T>(1) / sqrt(a);}
279 
280 template <typename T>
281 inline T vmath_invcbrt (T a)
282 {using cxx11::cbrt; return static_cast<T>(1) / cbrt(a);}
283 
284 template <typename T>
285 inline T vmath_pow2o3 (T a)
286 {using cxx11::cbrt; a = cbrt(a); return a * a;}
287 
288 template <typename T>
289 inline T vmath_pow3o2 (T a)
290 {using std::sqrt; a = sqrt(a); return a * a * a;}
291 
292 template <typename T>
293 inline T vmath_cdfnorm (T a)
294 {
295  using cxx11::erf;
296  return static_cast<T>(0.5) + static_cast<T>(0.5) * erf(
297  a * sqrt_1by2<T>());
298 }
299 
300 template <typename T>
301 inline T vmath_erfinv (T a)
302 {using cxx11::erf; return static_cast<T>(1) / erf(a);}
303 
304 template <typename T>
305 inline T vmath_erfcinv (T a)
306 {return vmath_erfinv(static_cast<T>(1) - a);}
307 
308 template <typename T>
309 inline T vmath_cdfnorminv (T a)
310 {return static_cast<T>(1) / vmath_cdfnorm(a);}
311 
312 } // namespace vsmc::math::internal
313 
317 
319 VSMC_DEFINE_MATH_VMATH_B(+, Add)
320 
321 VSMC_DEFINE_MATH_VMATH_B(-, Sub)
323 
325 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_sqr, Sqr)
326 
328 VSMC_DEFINE_MATH_VMATH_B(*, Mul)
329 
331 VSMC_DEFINE_MATH_VMATH_1(std, fabs, Abs)
332 
335 template <typename T>
336 inline void vLinearFrac (std::size_t n, const T *a, const T *b,
337  T beta_a, T beta_b, T mu_a, T mu_b, T *y)
338 {
339  for (std::size_t i = 0; i != n; ++i)
340  y[i] = beta_a * a[i] + mu_a;
341  for (std::size_t i = 0; i != n; ++i)
342  y[i] /= beta_b * b[i] + mu_b;
343 }
344 
346 
350 
352 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_inv, Inv)
353 
354 VSMC_DEFINE_MATH_VMATH_B(/, Div)
356 
358 VSMC_DEFINE_MATH_VMATH_1(std, sqrt, Sqrt)
359 
361 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_invsqrt, InvSqrt)
362 
364 VSMC_DEFINE_MATH_VMATH_1(cxx11, cbrt, Cbrt)
365 
367 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_invcbrt, InvCbrt)
368 
370 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_pow2o3, Pow2o3)
371 
373 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_pow3o2, Pow3o2)
374 
376 VSMC_DEFINE_MATH_VMATH_2(std, pow, Pow)
377 
379 template <typename T>
380 inline void vPowx (std::size_t n, const T *a, T b, T *y)
381 {
382  using std::pow;
383  for (std::size_t i = 0; i != n; ++i)
384  y[i] = pow(a[i], b);
385 }
386 
388 VSMC_DEFINE_MATH_VMATH_2(cxx11, hypot, Hypot)
389 
390 
395 
397 VSMC_DEFINE_MATH_VMATH_1(std, exp, Exp)
398 
400 VSMC_DEFINE_MATH_VMATH_1(cxx11, expm1, Expm1)
401 
403 VSMC_DEFINE_MATH_VMATH_1(std, log, Ln)
404 
406 VSMC_DEFINE_MATH_VMATH_1(std, log10, Log10)
407 
409 VSMC_DEFINE_MATH_VMATH_1(cxx11, log1p, Log1p)
411 
415 
417 VSMC_DEFINE_MATH_VMATH_1(std, cos, Cos)
418 
420 VSMC_DEFINE_MATH_VMATH_1(std, sin, Sin)
421 
424 template <typename T>
425 inline void vSinCos (std::size_t n, const T *a, T *y, T *z)
426 {
427  using std::sin;
428  using std::cos;
429  for (std::size_t i = 0; i != n; ++i)
430  y[i] = sin(a[i]);
431  for (std::size_t i = 0; i != n; ++i)
432  z[i] = cos(a[i]);
433 }
434 
436 VSMC_DEFINE_MATH_VMATH_1(std, tan, Tan)
437 
438 VSMC_DEFINE_MATH_VMATH_1(std, acos, Acos)
440 
442 VSMC_DEFINE_MATH_VMATH_1(std, asin, Asin)
443 
445 VSMC_DEFINE_MATH_VMATH_1(std, atan, Atan)
446 
449 VSMC_DEFINE_MATH_VMATH_2(std, atan2, Atan2)
450 
452 
456 
458 VSMC_DEFINE_MATH_VMATH_1(std, cosh, Cosh)
459 
461 VSMC_DEFINE_MATH_VMATH_1(std, sinh, Sinh)
462 
464 VSMC_DEFINE_MATH_VMATH_1(std, tanh, Tanh)
465 
467 VSMC_DEFINE_MATH_VMATH_1(cxx11, acosh, Acosh)
468 
470 VSMC_DEFINE_MATH_VMATH_1(cxx11, asinh, Asinh)
471 
473 VSMC_DEFINE_MATH_VMATH_1(cxx11, atanh, Atanh)
474 
476 
480 
482 VSMC_DEFINE_MATH_VMATH_1(cxx11, erf, Erf)
483 
486 VSMC_DEFINE_MATH_VMATH_1(cxx11, erfc, Erfc)
487 
490 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_cdfnorm, CdfNorm)
491 
493 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_erfinv, ErfInv)
494 
497 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_erfcinv, ErfcInv)
498 
502 VSMC_DEFINE_MATH_VMATH_1(internal, vmath_cdfnorminv, CdfNormInv)
503 
506 VSMC_DEFINE_MATH_VMATH_1(cxx11, lgamma, LGamma)
507 
510 VSMC_DEFINE_MATH_VMATH_1(cxx11, tgamma, TGamma)
512 
513 } // namespace vsmc::math
514 
515 } // namespace vsmc
516 
517 #if VSMC_USE_MKL_VML
518 
519 #define VSMC_DEFINE_MATH_VMATH_VML_1(name) \
520 inline void v##name \
521 (std::size_t n, const float *a, float *y) \
522 { \
523  n < VSMC_VMATH_THRESHOLD_##name ? \
524  v##name<float>(n, a, y): \
525  ::vs##name(static_cast<MKL_INT>(n), a, y); \
526 } \
527 inline void v##name \
528 (std::size_t n, const double *a, double *y) \
529 { \
530  n < VSMC_VMATH_THRESHOLD_##name ? \
531  v##name<double>(n, a, y): \
532  ::vd##name(static_cast<MKL_INT>(n), a, y); \
533 }
534 
535 #define VSMC_DEFINE_MATH_VMATH_VML_2(name) \
536 inline void v##name \
537 (std::size_t n, const float *a, const float *b, float *y) \
538 { \
539  n < VSMC_VMATH_THRESHOLD_##name ? \
540  v##name<float>(n, a, b, y): \
541  ::vs##name(static_cast<MKL_INT>(n), a, b, y); \
542 } \
543 inline void v##name \
544 (std::size_t n, const double *a, const double *b, double *y) \
545 { \
546  n < VSMC_VMATH_THRESHOLD_##name ? \
547  v##name<double>(n, a, b, y): \
548  ::vd##name(static_cast<MKL_INT>(n), a, b, y); \
549 }
550 
551 namespace vsmc {
552 
553 namespace math {
554 
555 VSMC_DEFINE_MATH_VMATH_VML_2(Add)
556 VSMC_DEFINE_MATH_VMATH_VML_2(Sub)
557 VSMC_DEFINE_MATH_VMATH_VML_1(Sqr)
558 VSMC_DEFINE_MATH_VMATH_VML_2(Mul)
559 VSMC_DEFINE_MATH_VMATH_VML_1(Abs)
560 inline void vLinearFrac (std::size_t n, const float *a, const float *b,
561  float beta_a, float beta_b, float mu_a, float mu_b, float *y)
562 {
563  n < VSMC_VMATH_THRESHOLD_LinearFrac ?
564  vLinearFrac<float>(n, a, b, beta_a, beta_b, mu_a, mu_b, y):
565  ::vsLinearFrac(static_cast<MKL_INT>(n), a, b,
566  beta_a, beta_b, mu_a, mu_b, y);
567 }
568 inline void vLinearFrac (std::size_t n, const double *a, const double *b,
569  double beta_a, double beta_b, double mu_a, double mu_b, double *y)
570 {
571  n < VSMC_VMATH_THRESHOLD_LinearFrac ?
572  vLinearFrac<double>(n, a, b, beta_a, beta_b, mu_a, mu_b, y):
573  ::vdLinearFrac(static_cast<MKL_INT>(n), a, b,
574  beta_a, beta_b, mu_a, mu_b, y);
575 }
576 
577 VSMC_DEFINE_MATH_VMATH_VML_1(Inv)
578 VSMC_DEFINE_MATH_VMATH_VML_2(Div)
579 VSMC_DEFINE_MATH_VMATH_VML_1(Sqrt)
580 VSMC_DEFINE_MATH_VMATH_VML_1(InvSqrt)
581 VSMC_DEFINE_MATH_VMATH_VML_1(Cbrt)
582 VSMC_DEFINE_MATH_VMATH_VML_1(InvCbrt)
583 VSMC_DEFINE_MATH_VMATH_VML_1(Pow2o3)
584 VSMC_DEFINE_MATH_VMATH_VML_1(Pow3o2)
585 VSMC_DEFINE_MATH_VMATH_VML_2(Pow)
586 inline void vPowx (std::size_t n, const float *a, float b, float *y)
587 {
588  n < VSMC_VMATH_THRESHOLD_Powx ?
589  vPowx<float>(n, a, b, y):
590  ::vsPowx(static_cast<MKL_INT>(n), a, b, y);
591 }
592 inline void vPowx (std::size_t n, const double *a, double b, double *y)
593 {
594  n < VSMC_VMATH_THRESHOLD_Powx ?
595  vPowx<double>(n, a, b, y):
596  ::vdPowx(static_cast<MKL_INT>(n), a, b, y);
597 }
598 VSMC_DEFINE_MATH_VMATH_VML_2(Hypot)
599 
600 VSMC_DEFINE_MATH_VMATH_VML_1(Exp)
601 VSMC_DEFINE_MATH_VMATH_VML_1(Expm1)
602 VSMC_DEFINE_MATH_VMATH_VML_1(Ln)
603 VSMC_DEFINE_MATH_VMATH_VML_1(Log10)
604 VSMC_DEFINE_MATH_VMATH_VML_1(Log1p)
605 
606 VSMC_DEFINE_MATH_VMATH_VML_1(Cos)
607 VSMC_DEFINE_MATH_VMATH_VML_1(Sin)
608 inline void vSinCos (std::size_t n, const float *a, float *y, float *z)
609 {
610  n < VSMC_VMATH_THRESHOLD_SinCos ?
611  vSinCos<float>(n, a, y, z):
612  ::vsSinCos(static_cast<MKL_INT>(n), a, y, z);
613 }
614 inline void vSinCos (std::size_t n, const double *a, double *y, double *z)
615 {
616  n < VSMC_VMATH_THRESHOLD_SinCos ?
617  vSinCos<double>(n, a, y, z):
618  ::vdSinCos(static_cast<MKL_INT>(n), a, y, z);
619 }
620 VSMC_DEFINE_MATH_VMATH_VML_1(Tan)
621 VSMC_DEFINE_MATH_VMATH_VML_1(Acos)
622 VSMC_DEFINE_MATH_VMATH_VML_1(Asin)
623 VSMC_DEFINE_MATH_VMATH_VML_1(Atan)
624 VSMC_DEFINE_MATH_VMATH_VML_2(Atan2)
625 
626 VSMC_DEFINE_MATH_VMATH_VML_1(Cosh)
627 VSMC_DEFINE_MATH_VMATH_VML_1(Sinh)
628 VSMC_DEFINE_MATH_VMATH_VML_1(Tanh)
629 VSMC_DEFINE_MATH_VMATH_VML_1(Acosh)
630 VSMC_DEFINE_MATH_VMATH_VML_1(Asinh)
631 VSMC_DEFINE_MATH_VMATH_VML_1(Atanh)
632 
633 VSMC_DEFINE_MATH_VMATH_VML_1(Erf)
634 VSMC_DEFINE_MATH_VMATH_VML_1(Erfc)
635 VSMC_DEFINE_MATH_VMATH_VML_1(CdfNorm)
636 VSMC_DEFINE_MATH_VMATH_VML_1(ErfInv)
637 VSMC_DEFINE_MATH_VMATH_VML_1(ErfcInv)
638 VSMC_DEFINE_MATH_VMATH_VML_1(CdfNormInv)
639 VSMC_DEFINE_MATH_VMATH_VML_1(LGamma)
640 VSMC_DEFINE_MATH_VMATH_VML_1(TGamma)
641 
642 } // namespace vsmc::math
643 
644 } // namespace vsmc
645 
646 #elif VSMC_USE_VECLIB_VFORCE
647 
648 #define VSMC_DEFINE_MATH_VMATH_VFORCE_1(func, name) \
649 inline void v##name \
650 (std::size_t n, const float *a, float *y) \
651 { \
652  const int in = static_cast<int>(n); \
653  n < VSMC_VMATH_THRESHOLD_##name ? \
654  v##name<float>(n, a, y): \
655  ::vv##func##f(y, a, &in); \
656 } \
657 inline void v##name \
658 (std::size_t n, const double *a, double *y) \
659 { \
660  const int in = static_cast<int>(n); \
661  n < VSMC_VMATH_THRESHOLD_##name ? \
662  v##name<double>(n, a, y): \
663  ::vv##func(y, a, &in); \
664 }
665 
666 #define VSMC_DEFINE_MATH_VMATH_VFORCE_2(func, name) \
667 inline void v##name \
668 (std::size_t n, const float *a, const float *b, float *y) \
669 { \
670  const int in = static_cast<int>(n); \
671  n < VSMC_VMATH_THRESHOLD_##name ? \
672  v##name<float>(n, a, b, y): \
673  ::vv##func##f(y, a, b, &in); \
674 } \
675 inline void v##name \
676 (std::size_t n, const double *a, const double *b, double *y) \
677 { \
678  const int in = static_cast<int>(n); \
679  n < VSMC_VMATH_THRESHOLD_##name ? \
680  v##name<double>(n, a, b, y): \
681  ::vv##func(y, a, b, &in); \
682 }
683 
684 namespace vsmc {
685 
686 namespace math {
687 
688 VSMC_DEFINE_MATH_VMATH_VFORCE_1(rec, Inv)
689 VSMC_DEFINE_MATH_VMATH_VFORCE_2(div, Div)
690 VSMC_DEFINE_MATH_VMATH_VFORCE_1(sqrt, Sqrt)
691 VSMC_DEFINE_MATH_VMATH_VFORCE_1(rsqrt, InvSqrt)
692 VSMC_DEFINE_MATH_VMATH_VFORCE_2(pow, Pow)
693 
694 VSMC_DEFINE_MATH_VMATH_VFORCE_1(exp, Exp)
695 VSMC_DEFINE_MATH_VMATH_VFORCE_1(log, Ln)
696 VSMC_DEFINE_MATH_VMATH_VFORCE_1(log10, Log10)
697 VSMC_DEFINE_MATH_VMATH_VFORCE_1(log1p, Log1p)
698 
699 VSMC_DEFINE_MATH_VMATH_VFORCE_1(cos, Cos)
700 VSMC_DEFINE_MATH_VMATH_VFORCE_1(sin, Sin)
701 inline void vSinCos (std::size_t n, const float *a, float *y, float *z)
702 {
703  int in = static_cast<int>(n);
704  n < VSMC_VMATH_THRESHOLD_SinCos ?
705  vSinCos<float>(n, a, y, z):
706  ::vvsincosf(z, y, a, &in);
707 }
708 inline void vSinCos (std::size_t n, const double *a, double *y, double *z)
709 {
710  int in = static_cast<int>(n);
711  n < VSMC_VMATH_THRESHOLD_SinCos ?
712  vSinCos<double>(n, a, y, z):
713  ::vvsincos(z, y, a, &in);
714 }
715 VSMC_DEFINE_MATH_VMATH_VFORCE_1(tan, Tan)
716 VSMC_DEFINE_MATH_VMATH_VFORCE_1(acos, Acos)
717 VSMC_DEFINE_MATH_VMATH_VFORCE_1(asin, Asin)
718 VSMC_DEFINE_MATH_VMATH_VFORCE_1(atan, Atan)
719 VSMC_DEFINE_MATH_VMATH_VFORCE_2(atan2, Atan2)
720 
721 VSMC_DEFINE_MATH_VMATH_VFORCE_1(cosh, Cosh)
722 VSMC_DEFINE_MATH_VMATH_VFORCE_1(sinh, Sinh)
723 VSMC_DEFINE_MATH_VMATH_VFORCE_1(tanh, Tanh)
724 VSMC_DEFINE_MATH_VMATH_VFORCE_1(acosh, Acosh)
725 VSMC_DEFINE_MATH_VMATH_VFORCE_1(asinh, Asinh)
726 VSMC_DEFINE_MATH_VMATH_VFORCE_1(atanh, Atanh)
727 
728 } // namespace vsmc::math
729 
730 } // namespace vsmc
731 
732 #endif // VSMC_USE_MKL_VML
733 
734 #endif // VSMC_MATH_VMATH_HPP
vsmc
Definition: adapter.hpp:37
vsmc::math::vSinCos
void vSinCos(std::size_t n, const T *a, T *y, T *z)
For , compute .
Definition: vmath.hpp:425
VSMC_VMATH_THRESHOLD_Powx
#define VSMC_VMATH_THRESHOLD_Powx
Definition: vmath.hpp:121
std
STL namespace.
vsmc::math::internal::vmath_invcbrt
T vmath_invcbrt(T a)
Definition: vmath.hpp:281
VSMC_DEFINE_MATH_VMATH_VML_2
#define VSMC_DEFINE_MATH_VMATH_VML_2(name)
Definition: vmath.hpp:535
VSMC_DEFINE_MATH_VMATH_2
#define VSMC_DEFINE_MATH_VMATH_2(ns, func, name)
Definition: vmath.hpp:245
VSMC_DEFINE_MATH_VMATH_1
#define VSMC_DEFINE_MATH_VMATH_1(ns, func, name)
Definition: vmath.hpp:236
vsmc::math::internal::vmath_cdfnorm
T vmath_cdfnorm(T a)
Definition: vmath.hpp:293
vsmc::math::vPowx
void vPowx(std::size_t n, const T *a, T b, T *y)
For , compute .
Definition: vmath.hpp:380
vsmc::math::internal::vmath_invsqrt
T vmath_invsqrt(T a)
Definition: vmath.hpp:277
vsmc::math::internal::vmath_erfcinv
T vmath_erfcinv(T a)
Definition: vmath.hpp:305
VSMC_VMATH_THRESHOLD_SinCos
#define VSMC_VMATH_THRESHOLD_SinCos
Definition: vmath.hpp:157
vsmc::math::internal::vmath_cdfnorminv
T vmath_cdfnorminv(T a)
Definition: vmath.hpp:309
VSMC_VMATH_THRESHOLD_LinearFrac
#define VSMC_VMATH_THRESHOLD_LinearFrac
Definition: vmath.hpp:81
vsmc::math::vLinearFrac
void vLinearFrac(std::size_t n, const T *a, const T *b, T beta_a, T beta_b, T mu_a, T mu_b, T *y)
For , compute .
Definition: vmath.hpp:336
VSMC_DEFINE_MATH_VMATH_VML_1
#define VSMC_DEFINE_MATH_VMATH_VML_1(name)
Definition: vmath.hpp:519
VSMC_DEFINE_MATH_VMATH_B
#define VSMC_DEFINE_MATH_VMATH_B(op, vname)
Definition: vmath.hpp:254
Generated by   doxygen 1.8.9.1