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