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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
#ifndef CAFFE2_UTILS_MATH_ELEMENTWISE_H_
#define CAFFE2_UTILS_MATH_ELEMENTWISE_H_
#include "caffe2/core/common.h"
#include "caffe2/core/types.h"
namespace caffe2 {
namespace math {
template <typename T, class Context>
TORCH_API void Exp(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Log(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Log1p(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Sin(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Asin(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Cos(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Acos(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Tan(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Atan(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Sinh(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Cosh(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void SinCos(int N, const T* X, T* S, T* C, Context* context);
template <typename T, class Context>
TORCH_API void Tanh(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Abs(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Sqr(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Sqrt(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Rsqrt(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Cube(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Cbrt(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Neg(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Sign(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Not(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Powx(int N, const T* A, const T b, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Inv(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Erf(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void CdfNorm(int N, const T* X, T* Y, Context* context);
template <typename T, class Context>
TORCH_API void Set(std::int64_t N, T alpha, T* X, Context* context);
template <typename TAlpha, typename TData, class Context>
TORCH_API void
Scale(std::int64_t N, TAlpha alpha, const TData* X, TData* Y, Context* context);
// Different from the Scale function above, if alpha is passed in as a pointer,
// we will assume that it lives on the Context device, for example on GPU.
template <typename TAlpha, typename TData, class Context>
TORCH_API void Scale(
std::int64_t N,
const TAlpha* alpha,
const TData* X,
TData* Y,
Context* context);
template <typename T, class Context>
TORCH_API void Add(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void Sub(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void Mul(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void Div(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void Min(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void Max(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void And(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void Or(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void Xor(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void
BitwiseAnd(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void
BitwiseOr(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void
BitwiseXor(int N, const T* A, const T* B, T* C, Context* context);
template <typename T, class Context>
TORCH_API void EQ(int N, const T* A, const T* B, bool* C, Context* context);
template <typename T, class Context>
TORCH_API void NE(int N, const T* A, const T* B, bool* C, Context* context);
template <typename T, class Context>
TORCH_API void LT(int N, const T* A, const T* B, bool* C, Context* context);
template <typename T, class Context>
TORCH_API void LE(int N, const T* A, const T* B, bool* C, Context* context);
template <typename T, class Context>
TORCH_API void GT(int N, const T* A, const T* B, bool* C, Context* context);
template <typename T, class Context>
TORCH_API void GE(int N, const T* A, const T* B, bool* C, Context* context);
template <typename TAlpha, typename TData, class Context>
TORCH_API void
Axpy(std::int64_t N, TAlpha alpha, const TData* X, TData* Y, Context* context);
// Different from the Axpy function above, if alpha is passed in
// as a pointer, we will assume that it lives on the Context device,
// for example on GPU.
template <typename TAlpha, typename TData, class Context>
TORCH_API void Axpy(
std::int64_t N,
const TAlpha* alpha,
const TData* X,
TData* Y,
Context* context);
template <typename TAlpha, typename TData, class Context>
TORCH_API void Axpby(
std::int64_t N,
TAlpha alpha,
const TData* X,
TAlpha beta,
TData* Y,
Context* context);
template <typename TAlpha, typename TData, class Context>
TORCH_API void Axpby(
std::int64_t N,
const TAlpha* alpha,
const TData* X,
const TAlpha* beta,
TData* Y,
Context* context);
} // namespace math
} // namespace caffe2
#endif // CAFFE2_UTILS_MATH_ELEMENTWISE_H_
|
