forked from arrayfire/arrayfire
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathbinary_ops.hpp
More file actions
89 lines (71 loc) · 2.87 KB
/
binary_ops.hpp
File metadata and controls
89 lines (71 loc) · 2.87 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <af/defines.h>
#include <algorithm>
#include <complex>
#include <numeric>
template<typename T>
static inline T min(T lhs, T rhs) {
return std::min(lhs, rhs);
}
std::complex<float> min(std::complex<float> lhs, std::complex<float> rhs);
std::complex<double> min(std::complex<double> lhs, std::complex<double> rhs);
template<typename T>
static inline T max(T lhs, T rhs) {
return std::max(lhs, rhs);
}
std::complex<float> max(std::complex<float> lhs, std::complex<float> rhs);
std::complex<double> max(std::complex<double> lhs, std::complex<double> rhs);
template<typename T, af_binary_op op>
struct Binary {
T init() { return (T)(0); }
T operator()(T lhs, T rhs) { return lhs + rhs; }
};
template<typename T>
struct Binary<T, AF_BINARY_ADD> {
T init() { return (T)(0); }
T operator()(T lhs, T rhs) { return lhs + rhs; }
};
template<typename T>
struct Binary<T, AF_BINARY_MUL> {
T init() { return (T)(1); }
T operator()(T lhs, T rhs) { return lhs * rhs; }
};
template<typename T>
struct Binary<T, AF_BINARY_MIN> {
T init() { return std::numeric_limits<T>::max(); }
T operator()(T lhs, T rhs) { return min(lhs, rhs); }
};
template<typename T>
struct Binary<T, AF_BINARY_MAX> {
T init() { return std::numeric_limits<T>::min(); }
T operator()(T lhs, T rhs) { return max(lhs, rhs); }
};
#define SPECIALIZE_COMPLEX_MIN(T, Tr) \
template<> \
struct Binary<T, AF_BINARY_MIN> { \
T init() { return (T)(std::numeric_limits<Tr>::max()); } \
\
T operator()(T lhs, T rhs) { return min(lhs, rhs); } \
};
SPECIALIZE_COMPLEX_MIN(std::complex<float>, float)
SPECIALIZE_COMPLEX_MIN(std::complex<double>, double)
#undef SPECIALIZE_COMPLEX_MIN
#define SPECIALIZE_COMPLEX_MAX(T, Tr) \
template<> \
struct Binary<T, AF_BINARY_MAX> { \
T init() { return (T)((Tr)(0)); } \
\
T operator()(T lhs, T rhs) { return max(lhs, rhs); } \
};
SPECIALIZE_COMPLEX_MAX(std::complex<float>, float)
SPECIALIZE_COMPLEX_MAX(std::complex<double>, double)
#undef SPECIALIZE_COMPLEX_MAX
#define SPECIALIZE_FLOATING_MAX(T, Tr) \
template<> \
struct Binary<T, AF_BINARY_MAX> { \
T init() { return (T)(-std::numeric_limits<Tr>::max()); } \
\
T operator()(T lhs, T rhs) { return max(lhs, rhs); } \
};
SPECIALIZE_FLOATING_MAX(float, float)
SPECIALIZE_FLOATING_MAX(double, double)
#undef SPECIALIZE_FLOATING_MAX