hpt_types/scalars/
_bf16.rs1use num_traits::real::Real;
2
3use crate::{
4 convertion::Convertor,
5 type_promote::{
6 BitWiseOut2, Eval2, FloatOutBinary2, FloatOutUnary2, NormalOut2, NormalOutUnary2,
7 },
8};
9
10impl FloatOutBinary2 for half::bf16 {
11 #[inline(always)]
12 fn __div(self, rhs: Self) -> Self {
13 self / rhs
14 }
15 #[inline(always)]
16 fn __log(self, base: Self) -> Self {
17 self.log(base)
18 }
19 #[inline(always)]
20 fn __hypot(self, rhs: Self) -> Self {
21 self.hypot(rhs)
22 }
23 #[inline(always)]
24 fn __pow(self, rhs: Self) -> Self {
25 self.powf(rhs)
26 }
27}
28
29impl NormalOut2 for half::bf16 {
30 #[inline(always)]
31 fn __add(self, rhs: Self) -> Self {
32 self + rhs
33 }
34
35 #[inline(always)]
36 fn __sub(self, rhs: Self) -> Self {
37 self - rhs
38 }
39
40 #[inline(always)]
41 fn __mul_add(self, a: Self, b: Self) -> Self {
42 (self * a) + b
43 }
44
45 #[inline(always)]
46 fn __mul(self, rhs: Self) -> Self {
47 self * rhs
48 }
49
50 #[inline(always)]
51 fn __rem(self, rhs: Self) -> Self {
52 self % rhs
53 }
54
55 #[inline(always)]
56 fn __max(self, rhs: Self) -> Self {
57 self.max(rhs)
58 }
59
60 #[inline(always)]
61 fn __min(self, rhs: Self) -> Self {
62 self.min(rhs)
63 }
64
65 #[inline(always)]
66 fn __clamp(self, min: Self, max: Self) -> Self {
67 self.clamp(min, max)
68 }
69}
70
71impl NormalOutUnary2 for half::bf16 {
72 #[inline(always)]
73 fn __square(self) -> Self {
74 self * self
75 }
76
77 #[inline(always)]
78 fn __abs(self) -> Self {
79 self.abs()
80 }
81
82 #[inline(always)]
83 fn __ceil(self) -> Self {
84 self.ceil()
85 }
86
87 #[inline(always)]
88 fn __floor(self) -> Self {
89 self.floor()
90 }
91
92 #[inline(always)]
93 fn __neg(self) -> Self {
94 -self
95 }
96
97 #[inline(always)]
98 fn __round(self) -> Self {
99 self.round()
100 }
101
102 #[inline(always)]
103 fn __signum(self) -> Self {
104 self.signum()
105 }
106
107 #[inline(always)]
108 fn __trunc(self) -> Self {
109 self.trunc()
110 }
111
112 #[inline(always)]
113 fn __leaky_relu(self, alpha: Self) -> Self {
114 self.max(half::bf16::from_f32_const(0.0))
115 + alpha * self.min(half::bf16::from_f32_const(0.0))
116 }
117
118 #[inline(always)]
119 fn __relu(self) -> Self {
120 self.max(half::bf16::from_f32_const(0.0))
121 }
122
123 #[inline(always)]
124 fn __relu6(self) -> Self {
125 self.min(half::bf16::from_f32_const(6.0))
126 .max(half::bf16::from_f32_const(0.0))
127 }
128
129 #[inline(always)]
130 fn __copysign(self, rhs: Self) -> Self {
131 self.copysign(rhs)
132 }
133}
134
135impl BitWiseOut2 for half::bf16 {
136 #[inline(always)]
137 fn __bitand(self, rhs: Self) -> Self {
138 half::bf16::from_bits(self.to_bits() & rhs.to_bits())
139 }
140
141 #[inline(always)]
142 fn __bitor(self, rhs: Self) -> Self {
143 half::bf16::from_bits(self.to_bits() | rhs.to_bits())
144 }
145
146 #[inline(always)]
147 fn __bitxor(self, rhs: Self) -> Self {
148 half::bf16::from_bits(self.to_bits() ^ rhs.to_bits())
149 }
150
151 #[inline(always)]
152 fn __not(self) -> Self {
153 half::bf16::from_bits(!self.to_bits())
154 }
155
156 #[inline(always)]
157 fn __shl(self, _: Self) -> Self {
158 panic!("Shift operations are not supported for half::bf16")
159 }
160
161 #[inline(always)]
162 fn __shr(self, _: Self) -> Self {
163 panic!("Shift operations are not supported for half::bf16")
164 }
165}
166
167impl Eval2 for half::bf16 {
168 type Output = bool;
169 #[inline(always)]
170 fn __is_nan(&self) -> Self::Output {
171 self.is_nan()
172 }
173
174 #[inline(always)]
175 fn __is_true(&self) -> Self::Output {
176 *self != half::bf16::from_f32_const(0.0) && !self.is_nan()
177 }
178
179 #[inline(always)]
180 fn __is_inf(&self) -> Self::Output {
181 self.is_infinite()
182 }
183}
184
185impl FloatOutUnary2 for half::bf16 {
186 #[inline(always)]
187 fn __exp(self) -> Self {
188 self.exp()
189 }
190 #[inline(always)]
191 fn __expm1(self) -> Self {
192 self.to_f32().__expm1().to_bf16()
193 }
194 #[inline(always)]
195 fn __exp2(self) -> Self {
196 self.exp2()
197 }
198 #[inline(always)]
199 fn __ln(self) -> Self {
200 self.ln()
201 }
202 #[inline(always)]
203 fn __log1p(self) -> Self {
204 self.to_f32().__log1p().to_bf16()
205 }
206 #[inline(always)]
207 fn __celu(self, alpha: Self) -> Self {
208 self.to_f32().__celu(alpha.to_f32()).to_bf16()
209 }
210 #[inline(always)]
211 fn __log2(self) -> Self {
212 self.log2()
213 }
214 #[inline(always)]
215 fn __log10(self) -> Self {
216 self.log10()
217 }
218 #[inline(always)]
219 fn __sqrt(self) -> Self {
220 self.sqrt()
221 }
222 #[inline(always)]
223 fn __sin(self) -> Self {
224 self.sin()
225 }
226 #[inline(always)]
227 fn __cos(self) -> Self {
228 self.cos()
229 }
230 #[inline(always)]
231 fn __tan(self) -> Self {
232 self.tan()
233 }
234 #[inline(always)]
235 fn __asin(self) -> Self {
236 self.asin()
237 }
238 #[inline(always)]
239 fn __acos(self) -> Self {
240 self.acos()
241 }
242 #[inline(always)]
243 fn __atan(self) -> Self {
244 self.atan()
245 }
246 #[inline(always)]
247 fn __sinh(self) -> Self {
248 self.sinh()
249 }
250 #[inline(always)]
251 fn __cosh(self) -> Self {
252 self.cosh()
253 }
254 #[inline(always)]
255 fn __tanh(self) -> Self {
256 self.tanh()
257 }
258 #[inline(always)]
259 fn __asinh(self) -> Self {
260 self.asinh()
261 }
262 #[inline(always)]
263 fn __acosh(self) -> Self {
264 self.acosh()
265 }
266 #[inline(always)]
267 fn __atanh(self) -> Self {
268 self.atanh()
269 }
270 #[inline(always)]
271 fn __recip(self) -> Self {
272 self.recip()
273 }
274 #[inline(always)]
275 fn __erf(self) -> Self {
276 self.to_f32().__erf().to_bf16()
277 }
278 #[inline(always)]
279 fn __sigmoid(self) -> Self {
280 self.to_f32().__sigmoid().to_bf16()
281 }
282 #[inline(always)]
283 fn __elu(self, alpha: Self) -> Self {
284 self.to_f32().__elu(alpha.to_f32()).to_bf16()
285 }
286 #[inline(always)]
287 fn __gelu(self) -> Self {
288 self.to_f32().__gelu().to_bf16()
289 }
290 #[inline(always)]
291 fn __selu(self, alpha: Self, scale: Self) -> Self {
292 self.to_f32()
293 .__selu(alpha.to_f32(), scale.to_f32())
294 .to_bf16()
295 }
296 #[inline(always)]
297 fn __hard_sigmoid(self) -> Self {
298 self.to_f32().__hard_sigmoid().to_bf16()
299 }
300 #[inline(always)]
301 fn __hard_swish(self) -> Self {
302 self.to_f32().__hard_swish().to_bf16()
303 }
304 #[inline(always)]
305 fn __softplus(self) -> Self {
306 self.to_f32().__softplus().to_bf16()
307 }
308 #[inline(always)]
309 fn __softsign(self) -> Self {
310 self.to_f32().__softsign().to_bf16()
311 }
312 #[inline(always)]
313 fn __mish(self) -> Self {
314 self.to_f32().__mish().to_bf16()
315 }
316 #[inline(always)]
317 fn __cbrt(self) -> Self {
318 self.to_f32().__cbrt().to_bf16()
319 }
320
321 #[inline(always)]
322 fn __sincos(self) -> (Self, Self) {
323 let res = self.to_f32().sin_cos();
324 (res.0.to_bf16(), res.1.to_bf16())
325 }
326
327 #[inline(always)]
328 fn __atan2(self, rhs: Self) -> Self {
329 self.atan2(rhs)
330 }
331
332 #[inline(always)]
333 fn __exp10(self) -> Self {
334 self.to_f32().__exp10().to_bf16()
335 }
336}