1use crate::{Simd, SimdInto};
7use crate::{
8 f32x4, f32x8, f32x16, f64x2, f64x4, f64x8, i8x16, i8x32, i8x64, i16x8, i16x16, i16x32, i32x4,
9 i32x8, i32x16, mask8x16, mask8x32, mask8x64, mask16x8, mask16x16, mask16x32, mask32x4,
10 mask32x8, mask32x16, mask64x2, mask64x4, mask64x8, u8x16, u8x32, u8x64, u16x8, u16x16, u16x32,
11 u32x4, u32x8, u32x16,
12};
13impl<S: Simd> core::ops::Neg for f32x4<S> {
14 type Output = Self;
15 #[inline(always)]
16 fn neg(self) -> Self::Output {
17 self.simd.neg_f32x4(self)
18 }
19}
20impl<S: Simd> core::ops::Add for f32x4<S> {
21 type Output = Self;
22 #[inline(always)]
23 fn add(self, rhs: Self) -> Self::Output {
24 self.simd.add_f32x4(self, rhs)
25 }
26}
27impl<S: Simd> core::ops::Add<f32> for f32x4<S> {
28 type Output = Self;
29 #[inline(always)]
30 fn add(self, rhs: f32) -> Self::Output {
31 self.simd.add_f32x4(self, rhs.simd_into(self.simd))
32 }
33}
34impl<S: Simd> core::ops::Add<f32x4<S>> for f32 {
35 type Output = f32x4<S>;
36 #[inline(always)]
37 fn add(self, rhs: f32x4<S>) -> Self::Output {
38 rhs.simd.add_f32x4(self.simd_into(rhs.simd), rhs)
39 }
40}
41impl<S: Simd> core::ops::Sub for f32x4<S> {
42 type Output = Self;
43 #[inline(always)]
44 fn sub(self, rhs: Self) -> Self::Output {
45 self.simd.sub_f32x4(self, rhs)
46 }
47}
48impl<S: Simd> core::ops::Sub<f32> for f32x4<S> {
49 type Output = Self;
50 #[inline(always)]
51 fn sub(self, rhs: f32) -> Self::Output {
52 self.simd.sub_f32x4(self, rhs.simd_into(self.simd))
53 }
54}
55impl<S: Simd> core::ops::Sub<f32x4<S>> for f32 {
56 type Output = f32x4<S>;
57 #[inline(always)]
58 fn sub(self, rhs: f32x4<S>) -> Self::Output {
59 rhs.simd.sub_f32x4(self.simd_into(rhs.simd), rhs)
60 }
61}
62impl<S: Simd> core::ops::Mul for f32x4<S> {
63 type Output = Self;
64 #[inline(always)]
65 fn mul(self, rhs: Self) -> Self::Output {
66 self.simd.mul_f32x4(self, rhs)
67 }
68}
69impl<S: Simd> core::ops::Mul<f32> for f32x4<S> {
70 type Output = Self;
71 #[inline(always)]
72 fn mul(self, rhs: f32) -> Self::Output {
73 self.simd.mul_f32x4(self, rhs.simd_into(self.simd))
74 }
75}
76impl<S: Simd> core::ops::Mul<f32x4<S>> for f32 {
77 type Output = f32x4<S>;
78 #[inline(always)]
79 fn mul(self, rhs: f32x4<S>) -> Self::Output {
80 rhs.simd.mul_f32x4(self.simd_into(rhs.simd), rhs)
81 }
82}
83impl<S: Simd> core::ops::Div for f32x4<S> {
84 type Output = Self;
85 #[inline(always)]
86 fn div(self, rhs: Self) -> Self::Output {
87 self.simd.div_f32x4(self, rhs)
88 }
89}
90impl<S: Simd> core::ops::Div<f32> for f32x4<S> {
91 type Output = Self;
92 #[inline(always)]
93 fn div(self, rhs: f32) -> Self::Output {
94 self.simd.div_f32x4(self, rhs.simd_into(self.simd))
95 }
96}
97impl<S: Simd> core::ops::Div<f32x4<S>> for f32 {
98 type Output = f32x4<S>;
99 #[inline(always)]
100 fn div(self, rhs: f32x4<S>) -> Self::Output {
101 rhs.simd.div_f32x4(self.simd_into(rhs.simd), rhs)
102 }
103}
104impl<S: Simd> core::ops::Add for i8x16<S> {
105 type Output = Self;
106 #[inline(always)]
107 fn add(self, rhs: Self) -> Self::Output {
108 self.simd.add_i8x16(self, rhs)
109 }
110}
111impl<S: Simd> core::ops::Add<i8> for i8x16<S> {
112 type Output = Self;
113 #[inline(always)]
114 fn add(self, rhs: i8) -> Self::Output {
115 self.simd.add_i8x16(self, rhs.simd_into(self.simd))
116 }
117}
118impl<S: Simd> core::ops::Add<i8x16<S>> for i8 {
119 type Output = i8x16<S>;
120 #[inline(always)]
121 fn add(self, rhs: i8x16<S>) -> Self::Output {
122 rhs.simd.add_i8x16(self.simd_into(rhs.simd), rhs)
123 }
124}
125impl<S: Simd> core::ops::Sub for i8x16<S> {
126 type Output = Self;
127 #[inline(always)]
128 fn sub(self, rhs: Self) -> Self::Output {
129 self.simd.sub_i8x16(self, rhs)
130 }
131}
132impl<S: Simd> core::ops::Sub<i8> for i8x16<S> {
133 type Output = Self;
134 #[inline(always)]
135 fn sub(self, rhs: i8) -> Self::Output {
136 self.simd.sub_i8x16(self, rhs.simd_into(self.simd))
137 }
138}
139impl<S: Simd> core::ops::Sub<i8x16<S>> for i8 {
140 type Output = i8x16<S>;
141 #[inline(always)]
142 fn sub(self, rhs: i8x16<S>) -> Self::Output {
143 rhs.simd.sub_i8x16(self.simd_into(rhs.simd), rhs)
144 }
145}
146impl<S: Simd> core::ops::Mul for i8x16<S> {
147 type Output = Self;
148 #[inline(always)]
149 fn mul(self, rhs: Self) -> Self::Output {
150 self.simd.mul_i8x16(self, rhs)
151 }
152}
153impl<S: Simd> core::ops::Mul<i8> for i8x16<S> {
154 type Output = Self;
155 #[inline(always)]
156 fn mul(self, rhs: i8) -> Self::Output {
157 self.simd.mul_i8x16(self, rhs.simd_into(self.simd))
158 }
159}
160impl<S: Simd> core::ops::Mul<i8x16<S>> for i8 {
161 type Output = i8x16<S>;
162 #[inline(always)]
163 fn mul(self, rhs: i8x16<S>) -> Self::Output {
164 rhs.simd.mul_i8x16(self.simd_into(rhs.simd), rhs)
165 }
166}
167impl<S: Simd> core::ops::BitAnd for i8x16<S> {
168 type Output = Self;
169 #[inline(always)]
170 fn bitand(self, rhs: Self) -> Self::Output {
171 self.simd.and_i8x16(self, rhs)
172 }
173}
174impl<S: Simd> core::ops::BitAnd<i8> for i8x16<S> {
175 type Output = Self;
176 #[inline(always)]
177 fn bitand(self, rhs: i8) -> Self::Output {
178 self.simd.and_i8x16(self, rhs.simd_into(self.simd))
179 }
180}
181impl<S: Simd> core::ops::BitAnd<i8x16<S>> for i8 {
182 type Output = i8x16<S>;
183 #[inline(always)]
184 fn bitand(self, rhs: i8x16<S>) -> Self::Output {
185 rhs.simd.and_i8x16(self.simd_into(rhs.simd), rhs)
186 }
187}
188impl<S: Simd> core::ops::BitOr for i8x16<S> {
189 type Output = Self;
190 #[inline(always)]
191 fn bitor(self, rhs: Self) -> Self::Output {
192 self.simd.or_i8x16(self, rhs)
193 }
194}
195impl<S: Simd> core::ops::BitOr<i8> for i8x16<S> {
196 type Output = Self;
197 #[inline(always)]
198 fn bitor(self, rhs: i8) -> Self::Output {
199 self.simd.or_i8x16(self, rhs.simd_into(self.simd))
200 }
201}
202impl<S: Simd> core::ops::BitOr<i8x16<S>> for i8 {
203 type Output = i8x16<S>;
204 #[inline(always)]
205 fn bitor(self, rhs: i8x16<S>) -> Self::Output {
206 rhs.simd.or_i8x16(self.simd_into(rhs.simd), rhs)
207 }
208}
209impl<S: Simd> core::ops::BitXor for i8x16<S> {
210 type Output = Self;
211 #[inline(always)]
212 fn bitxor(self, rhs: Self) -> Self::Output {
213 self.simd.xor_i8x16(self, rhs)
214 }
215}
216impl<S: Simd> core::ops::BitXor<i8> for i8x16<S> {
217 type Output = Self;
218 #[inline(always)]
219 fn bitxor(self, rhs: i8) -> Self::Output {
220 self.simd.xor_i8x16(self, rhs.simd_into(self.simd))
221 }
222}
223impl<S: Simd> core::ops::BitXor<i8x16<S>> for i8 {
224 type Output = i8x16<S>;
225 #[inline(always)]
226 fn bitxor(self, rhs: i8x16<S>) -> Self::Output {
227 rhs.simd.xor_i8x16(self.simd_into(rhs.simd), rhs)
228 }
229}
230impl<S: Simd> core::ops::Add for u8x16<S> {
231 type Output = Self;
232 #[inline(always)]
233 fn add(self, rhs: Self) -> Self::Output {
234 self.simd.add_u8x16(self, rhs)
235 }
236}
237impl<S: Simd> core::ops::Add<u8> for u8x16<S> {
238 type Output = Self;
239 #[inline(always)]
240 fn add(self, rhs: u8) -> Self::Output {
241 self.simd.add_u8x16(self, rhs.simd_into(self.simd))
242 }
243}
244impl<S: Simd> core::ops::Add<u8x16<S>> for u8 {
245 type Output = u8x16<S>;
246 #[inline(always)]
247 fn add(self, rhs: u8x16<S>) -> Self::Output {
248 rhs.simd.add_u8x16(self.simd_into(rhs.simd), rhs)
249 }
250}
251impl<S: Simd> core::ops::Sub for u8x16<S> {
252 type Output = Self;
253 #[inline(always)]
254 fn sub(self, rhs: Self) -> Self::Output {
255 self.simd.sub_u8x16(self, rhs)
256 }
257}
258impl<S: Simd> core::ops::Sub<u8> for u8x16<S> {
259 type Output = Self;
260 #[inline(always)]
261 fn sub(self, rhs: u8) -> Self::Output {
262 self.simd.sub_u8x16(self, rhs.simd_into(self.simd))
263 }
264}
265impl<S: Simd> core::ops::Sub<u8x16<S>> for u8 {
266 type Output = u8x16<S>;
267 #[inline(always)]
268 fn sub(self, rhs: u8x16<S>) -> Self::Output {
269 rhs.simd.sub_u8x16(self.simd_into(rhs.simd), rhs)
270 }
271}
272impl<S: Simd> core::ops::Mul for u8x16<S> {
273 type Output = Self;
274 #[inline(always)]
275 fn mul(self, rhs: Self) -> Self::Output {
276 self.simd.mul_u8x16(self, rhs)
277 }
278}
279impl<S: Simd> core::ops::Mul<u8> for u8x16<S> {
280 type Output = Self;
281 #[inline(always)]
282 fn mul(self, rhs: u8) -> Self::Output {
283 self.simd.mul_u8x16(self, rhs.simd_into(self.simd))
284 }
285}
286impl<S: Simd> core::ops::Mul<u8x16<S>> for u8 {
287 type Output = u8x16<S>;
288 #[inline(always)]
289 fn mul(self, rhs: u8x16<S>) -> Self::Output {
290 rhs.simd.mul_u8x16(self.simd_into(rhs.simd), rhs)
291 }
292}
293impl<S: Simd> core::ops::BitAnd for u8x16<S> {
294 type Output = Self;
295 #[inline(always)]
296 fn bitand(self, rhs: Self) -> Self::Output {
297 self.simd.and_u8x16(self, rhs)
298 }
299}
300impl<S: Simd> core::ops::BitAnd<u8> for u8x16<S> {
301 type Output = Self;
302 #[inline(always)]
303 fn bitand(self, rhs: u8) -> Self::Output {
304 self.simd.and_u8x16(self, rhs.simd_into(self.simd))
305 }
306}
307impl<S: Simd> core::ops::BitAnd<u8x16<S>> for u8 {
308 type Output = u8x16<S>;
309 #[inline(always)]
310 fn bitand(self, rhs: u8x16<S>) -> Self::Output {
311 rhs.simd.and_u8x16(self.simd_into(rhs.simd), rhs)
312 }
313}
314impl<S: Simd> core::ops::BitOr for u8x16<S> {
315 type Output = Self;
316 #[inline(always)]
317 fn bitor(self, rhs: Self) -> Self::Output {
318 self.simd.or_u8x16(self, rhs)
319 }
320}
321impl<S: Simd> core::ops::BitOr<u8> for u8x16<S> {
322 type Output = Self;
323 #[inline(always)]
324 fn bitor(self, rhs: u8) -> Self::Output {
325 self.simd.or_u8x16(self, rhs.simd_into(self.simd))
326 }
327}
328impl<S: Simd> core::ops::BitOr<u8x16<S>> for u8 {
329 type Output = u8x16<S>;
330 #[inline(always)]
331 fn bitor(self, rhs: u8x16<S>) -> Self::Output {
332 rhs.simd.or_u8x16(self.simd_into(rhs.simd), rhs)
333 }
334}
335impl<S: Simd> core::ops::BitXor for u8x16<S> {
336 type Output = Self;
337 #[inline(always)]
338 fn bitxor(self, rhs: Self) -> Self::Output {
339 self.simd.xor_u8x16(self, rhs)
340 }
341}
342impl<S: Simd> core::ops::BitXor<u8> for u8x16<S> {
343 type Output = Self;
344 #[inline(always)]
345 fn bitxor(self, rhs: u8) -> Self::Output {
346 self.simd.xor_u8x16(self, rhs.simd_into(self.simd))
347 }
348}
349impl<S: Simd> core::ops::BitXor<u8x16<S>> for u8 {
350 type Output = u8x16<S>;
351 #[inline(always)]
352 fn bitxor(self, rhs: u8x16<S>) -> Self::Output {
353 rhs.simd.xor_u8x16(self.simd_into(rhs.simd), rhs)
354 }
355}
356impl<S: Simd> core::ops::BitAnd for mask8x16<S> {
357 type Output = Self;
358 #[inline(always)]
359 fn bitand(self, rhs: Self) -> Self::Output {
360 self.simd.and_mask8x16(self, rhs)
361 }
362}
363impl<S: Simd> core::ops::BitAnd<i8> for mask8x16<S> {
364 type Output = Self;
365 #[inline(always)]
366 fn bitand(self, rhs: i8) -> Self::Output {
367 self.simd.and_mask8x16(self, rhs.simd_into(self.simd))
368 }
369}
370impl<S: Simd> core::ops::BitAnd<mask8x16<S>> for i8 {
371 type Output = mask8x16<S>;
372 #[inline(always)]
373 fn bitand(self, rhs: mask8x16<S>) -> Self::Output {
374 rhs.simd.and_mask8x16(self.simd_into(rhs.simd), rhs)
375 }
376}
377impl<S: Simd> core::ops::BitOr for mask8x16<S> {
378 type Output = Self;
379 #[inline(always)]
380 fn bitor(self, rhs: Self) -> Self::Output {
381 self.simd.or_mask8x16(self, rhs)
382 }
383}
384impl<S: Simd> core::ops::BitOr<i8> for mask8x16<S> {
385 type Output = Self;
386 #[inline(always)]
387 fn bitor(self, rhs: i8) -> Self::Output {
388 self.simd.or_mask8x16(self, rhs.simd_into(self.simd))
389 }
390}
391impl<S: Simd> core::ops::BitOr<mask8x16<S>> for i8 {
392 type Output = mask8x16<S>;
393 #[inline(always)]
394 fn bitor(self, rhs: mask8x16<S>) -> Self::Output {
395 rhs.simd.or_mask8x16(self.simd_into(rhs.simd), rhs)
396 }
397}
398impl<S: Simd> core::ops::BitXor for mask8x16<S> {
399 type Output = Self;
400 #[inline(always)]
401 fn bitxor(self, rhs: Self) -> Self::Output {
402 self.simd.xor_mask8x16(self, rhs)
403 }
404}
405impl<S: Simd> core::ops::BitXor<i8> for mask8x16<S> {
406 type Output = Self;
407 #[inline(always)]
408 fn bitxor(self, rhs: i8) -> Self::Output {
409 self.simd.xor_mask8x16(self, rhs.simd_into(self.simd))
410 }
411}
412impl<S: Simd> core::ops::BitXor<mask8x16<S>> for i8 {
413 type Output = mask8x16<S>;
414 #[inline(always)]
415 fn bitxor(self, rhs: mask8x16<S>) -> Self::Output {
416 rhs.simd.xor_mask8x16(self.simd_into(rhs.simd), rhs)
417 }
418}
419impl<S: Simd> core::ops::Not for mask8x16<S> {
420 type Output = Self;
421 #[inline(always)]
422 fn not(self) -> Self::Output {
423 self.simd.not_mask8x16(self)
424 }
425}
426impl<S: Simd> core::ops::Add for i16x8<S> {
427 type Output = Self;
428 #[inline(always)]
429 fn add(self, rhs: Self) -> Self::Output {
430 self.simd.add_i16x8(self, rhs)
431 }
432}
433impl<S: Simd> core::ops::Add<i16> for i16x8<S> {
434 type Output = Self;
435 #[inline(always)]
436 fn add(self, rhs: i16) -> Self::Output {
437 self.simd.add_i16x8(self, rhs.simd_into(self.simd))
438 }
439}
440impl<S: Simd> core::ops::Add<i16x8<S>> for i16 {
441 type Output = i16x8<S>;
442 #[inline(always)]
443 fn add(self, rhs: i16x8<S>) -> Self::Output {
444 rhs.simd.add_i16x8(self.simd_into(rhs.simd), rhs)
445 }
446}
447impl<S: Simd> core::ops::Sub for i16x8<S> {
448 type Output = Self;
449 #[inline(always)]
450 fn sub(self, rhs: Self) -> Self::Output {
451 self.simd.sub_i16x8(self, rhs)
452 }
453}
454impl<S: Simd> core::ops::Sub<i16> for i16x8<S> {
455 type Output = Self;
456 #[inline(always)]
457 fn sub(self, rhs: i16) -> Self::Output {
458 self.simd.sub_i16x8(self, rhs.simd_into(self.simd))
459 }
460}
461impl<S: Simd> core::ops::Sub<i16x8<S>> for i16 {
462 type Output = i16x8<S>;
463 #[inline(always)]
464 fn sub(self, rhs: i16x8<S>) -> Self::Output {
465 rhs.simd.sub_i16x8(self.simd_into(rhs.simd), rhs)
466 }
467}
468impl<S: Simd> core::ops::Mul for i16x8<S> {
469 type Output = Self;
470 #[inline(always)]
471 fn mul(self, rhs: Self) -> Self::Output {
472 self.simd.mul_i16x8(self, rhs)
473 }
474}
475impl<S: Simd> core::ops::Mul<i16> for i16x8<S> {
476 type Output = Self;
477 #[inline(always)]
478 fn mul(self, rhs: i16) -> Self::Output {
479 self.simd.mul_i16x8(self, rhs.simd_into(self.simd))
480 }
481}
482impl<S: Simd> core::ops::Mul<i16x8<S>> for i16 {
483 type Output = i16x8<S>;
484 #[inline(always)]
485 fn mul(self, rhs: i16x8<S>) -> Self::Output {
486 rhs.simd.mul_i16x8(self.simd_into(rhs.simd), rhs)
487 }
488}
489impl<S: Simd> core::ops::BitAnd for i16x8<S> {
490 type Output = Self;
491 #[inline(always)]
492 fn bitand(self, rhs: Self) -> Self::Output {
493 self.simd.and_i16x8(self, rhs)
494 }
495}
496impl<S: Simd> core::ops::BitAnd<i16> for i16x8<S> {
497 type Output = Self;
498 #[inline(always)]
499 fn bitand(self, rhs: i16) -> Self::Output {
500 self.simd.and_i16x8(self, rhs.simd_into(self.simd))
501 }
502}
503impl<S: Simd> core::ops::BitAnd<i16x8<S>> for i16 {
504 type Output = i16x8<S>;
505 #[inline(always)]
506 fn bitand(self, rhs: i16x8<S>) -> Self::Output {
507 rhs.simd.and_i16x8(self.simd_into(rhs.simd), rhs)
508 }
509}
510impl<S: Simd> core::ops::BitOr for i16x8<S> {
511 type Output = Self;
512 #[inline(always)]
513 fn bitor(self, rhs: Self) -> Self::Output {
514 self.simd.or_i16x8(self, rhs)
515 }
516}
517impl<S: Simd> core::ops::BitOr<i16> for i16x8<S> {
518 type Output = Self;
519 #[inline(always)]
520 fn bitor(self, rhs: i16) -> Self::Output {
521 self.simd.or_i16x8(self, rhs.simd_into(self.simd))
522 }
523}
524impl<S: Simd> core::ops::BitOr<i16x8<S>> for i16 {
525 type Output = i16x8<S>;
526 #[inline(always)]
527 fn bitor(self, rhs: i16x8<S>) -> Self::Output {
528 rhs.simd.or_i16x8(self.simd_into(rhs.simd), rhs)
529 }
530}
531impl<S: Simd> core::ops::BitXor for i16x8<S> {
532 type Output = Self;
533 #[inline(always)]
534 fn bitxor(self, rhs: Self) -> Self::Output {
535 self.simd.xor_i16x8(self, rhs)
536 }
537}
538impl<S: Simd> core::ops::BitXor<i16> for i16x8<S> {
539 type Output = Self;
540 #[inline(always)]
541 fn bitxor(self, rhs: i16) -> Self::Output {
542 self.simd.xor_i16x8(self, rhs.simd_into(self.simd))
543 }
544}
545impl<S: Simd> core::ops::BitXor<i16x8<S>> for i16 {
546 type Output = i16x8<S>;
547 #[inline(always)]
548 fn bitxor(self, rhs: i16x8<S>) -> Self::Output {
549 rhs.simd.xor_i16x8(self.simd_into(rhs.simd), rhs)
550 }
551}
552impl<S: Simd> core::ops::Add for u16x8<S> {
553 type Output = Self;
554 #[inline(always)]
555 fn add(self, rhs: Self) -> Self::Output {
556 self.simd.add_u16x8(self, rhs)
557 }
558}
559impl<S: Simd> core::ops::Add<u16> for u16x8<S> {
560 type Output = Self;
561 #[inline(always)]
562 fn add(self, rhs: u16) -> Self::Output {
563 self.simd.add_u16x8(self, rhs.simd_into(self.simd))
564 }
565}
566impl<S: Simd> core::ops::Add<u16x8<S>> for u16 {
567 type Output = u16x8<S>;
568 #[inline(always)]
569 fn add(self, rhs: u16x8<S>) -> Self::Output {
570 rhs.simd.add_u16x8(self.simd_into(rhs.simd), rhs)
571 }
572}
573impl<S: Simd> core::ops::Sub for u16x8<S> {
574 type Output = Self;
575 #[inline(always)]
576 fn sub(self, rhs: Self) -> Self::Output {
577 self.simd.sub_u16x8(self, rhs)
578 }
579}
580impl<S: Simd> core::ops::Sub<u16> for u16x8<S> {
581 type Output = Self;
582 #[inline(always)]
583 fn sub(self, rhs: u16) -> Self::Output {
584 self.simd.sub_u16x8(self, rhs.simd_into(self.simd))
585 }
586}
587impl<S: Simd> core::ops::Sub<u16x8<S>> for u16 {
588 type Output = u16x8<S>;
589 #[inline(always)]
590 fn sub(self, rhs: u16x8<S>) -> Self::Output {
591 rhs.simd.sub_u16x8(self.simd_into(rhs.simd), rhs)
592 }
593}
594impl<S: Simd> core::ops::Mul for u16x8<S> {
595 type Output = Self;
596 #[inline(always)]
597 fn mul(self, rhs: Self) -> Self::Output {
598 self.simd.mul_u16x8(self, rhs)
599 }
600}
601impl<S: Simd> core::ops::Mul<u16> for u16x8<S> {
602 type Output = Self;
603 #[inline(always)]
604 fn mul(self, rhs: u16) -> Self::Output {
605 self.simd.mul_u16x8(self, rhs.simd_into(self.simd))
606 }
607}
608impl<S: Simd> core::ops::Mul<u16x8<S>> for u16 {
609 type Output = u16x8<S>;
610 #[inline(always)]
611 fn mul(self, rhs: u16x8<S>) -> Self::Output {
612 rhs.simd.mul_u16x8(self.simd_into(rhs.simd), rhs)
613 }
614}
615impl<S: Simd> core::ops::BitAnd for u16x8<S> {
616 type Output = Self;
617 #[inline(always)]
618 fn bitand(self, rhs: Self) -> Self::Output {
619 self.simd.and_u16x8(self, rhs)
620 }
621}
622impl<S: Simd> core::ops::BitAnd<u16> for u16x8<S> {
623 type Output = Self;
624 #[inline(always)]
625 fn bitand(self, rhs: u16) -> Self::Output {
626 self.simd.and_u16x8(self, rhs.simd_into(self.simd))
627 }
628}
629impl<S: Simd> core::ops::BitAnd<u16x8<S>> for u16 {
630 type Output = u16x8<S>;
631 #[inline(always)]
632 fn bitand(self, rhs: u16x8<S>) -> Self::Output {
633 rhs.simd.and_u16x8(self.simd_into(rhs.simd), rhs)
634 }
635}
636impl<S: Simd> core::ops::BitOr for u16x8<S> {
637 type Output = Self;
638 #[inline(always)]
639 fn bitor(self, rhs: Self) -> Self::Output {
640 self.simd.or_u16x8(self, rhs)
641 }
642}
643impl<S: Simd> core::ops::BitOr<u16> for u16x8<S> {
644 type Output = Self;
645 #[inline(always)]
646 fn bitor(self, rhs: u16) -> Self::Output {
647 self.simd.or_u16x8(self, rhs.simd_into(self.simd))
648 }
649}
650impl<S: Simd> core::ops::BitOr<u16x8<S>> for u16 {
651 type Output = u16x8<S>;
652 #[inline(always)]
653 fn bitor(self, rhs: u16x8<S>) -> Self::Output {
654 rhs.simd.or_u16x8(self.simd_into(rhs.simd), rhs)
655 }
656}
657impl<S: Simd> core::ops::BitXor for u16x8<S> {
658 type Output = Self;
659 #[inline(always)]
660 fn bitxor(self, rhs: Self) -> Self::Output {
661 self.simd.xor_u16x8(self, rhs)
662 }
663}
664impl<S: Simd> core::ops::BitXor<u16> for u16x8<S> {
665 type Output = Self;
666 #[inline(always)]
667 fn bitxor(self, rhs: u16) -> Self::Output {
668 self.simd.xor_u16x8(self, rhs.simd_into(self.simd))
669 }
670}
671impl<S: Simd> core::ops::BitXor<u16x8<S>> for u16 {
672 type Output = u16x8<S>;
673 #[inline(always)]
674 fn bitxor(self, rhs: u16x8<S>) -> Self::Output {
675 rhs.simd.xor_u16x8(self.simd_into(rhs.simd), rhs)
676 }
677}
678impl<S: Simd> core::ops::BitAnd for mask16x8<S> {
679 type Output = Self;
680 #[inline(always)]
681 fn bitand(self, rhs: Self) -> Self::Output {
682 self.simd.and_mask16x8(self, rhs)
683 }
684}
685impl<S: Simd> core::ops::BitAnd<i16> for mask16x8<S> {
686 type Output = Self;
687 #[inline(always)]
688 fn bitand(self, rhs: i16) -> Self::Output {
689 self.simd.and_mask16x8(self, rhs.simd_into(self.simd))
690 }
691}
692impl<S: Simd> core::ops::BitAnd<mask16x8<S>> for i16 {
693 type Output = mask16x8<S>;
694 #[inline(always)]
695 fn bitand(self, rhs: mask16x8<S>) -> Self::Output {
696 rhs.simd.and_mask16x8(self.simd_into(rhs.simd), rhs)
697 }
698}
699impl<S: Simd> core::ops::BitOr for mask16x8<S> {
700 type Output = Self;
701 #[inline(always)]
702 fn bitor(self, rhs: Self) -> Self::Output {
703 self.simd.or_mask16x8(self, rhs)
704 }
705}
706impl<S: Simd> core::ops::BitOr<i16> for mask16x8<S> {
707 type Output = Self;
708 #[inline(always)]
709 fn bitor(self, rhs: i16) -> Self::Output {
710 self.simd.or_mask16x8(self, rhs.simd_into(self.simd))
711 }
712}
713impl<S: Simd> core::ops::BitOr<mask16x8<S>> for i16 {
714 type Output = mask16x8<S>;
715 #[inline(always)]
716 fn bitor(self, rhs: mask16x8<S>) -> Self::Output {
717 rhs.simd.or_mask16x8(self.simd_into(rhs.simd), rhs)
718 }
719}
720impl<S: Simd> core::ops::BitXor for mask16x8<S> {
721 type Output = Self;
722 #[inline(always)]
723 fn bitxor(self, rhs: Self) -> Self::Output {
724 self.simd.xor_mask16x8(self, rhs)
725 }
726}
727impl<S: Simd> core::ops::BitXor<i16> for mask16x8<S> {
728 type Output = Self;
729 #[inline(always)]
730 fn bitxor(self, rhs: i16) -> Self::Output {
731 self.simd.xor_mask16x8(self, rhs.simd_into(self.simd))
732 }
733}
734impl<S: Simd> core::ops::BitXor<mask16x8<S>> for i16 {
735 type Output = mask16x8<S>;
736 #[inline(always)]
737 fn bitxor(self, rhs: mask16x8<S>) -> Self::Output {
738 rhs.simd.xor_mask16x8(self.simd_into(rhs.simd), rhs)
739 }
740}
741impl<S: Simd> core::ops::Not for mask16x8<S> {
742 type Output = Self;
743 #[inline(always)]
744 fn not(self) -> Self::Output {
745 self.simd.not_mask16x8(self)
746 }
747}
748impl<S: Simd> core::ops::Add for i32x4<S> {
749 type Output = Self;
750 #[inline(always)]
751 fn add(self, rhs: Self) -> Self::Output {
752 self.simd.add_i32x4(self, rhs)
753 }
754}
755impl<S: Simd> core::ops::Add<i32> for i32x4<S> {
756 type Output = Self;
757 #[inline(always)]
758 fn add(self, rhs: i32) -> Self::Output {
759 self.simd.add_i32x4(self, rhs.simd_into(self.simd))
760 }
761}
762impl<S: Simd> core::ops::Add<i32x4<S>> for i32 {
763 type Output = i32x4<S>;
764 #[inline(always)]
765 fn add(self, rhs: i32x4<S>) -> Self::Output {
766 rhs.simd.add_i32x4(self.simd_into(rhs.simd), rhs)
767 }
768}
769impl<S: Simd> core::ops::Sub for i32x4<S> {
770 type Output = Self;
771 #[inline(always)]
772 fn sub(self, rhs: Self) -> Self::Output {
773 self.simd.sub_i32x4(self, rhs)
774 }
775}
776impl<S: Simd> core::ops::Sub<i32> for i32x4<S> {
777 type Output = Self;
778 #[inline(always)]
779 fn sub(self, rhs: i32) -> Self::Output {
780 self.simd.sub_i32x4(self, rhs.simd_into(self.simd))
781 }
782}
783impl<S: Simd> core::ops::Sub<i32x4<S>> for i32 {
784 type Output = i32x4<S>;
785 #[inline(always)]
786 fn sub(self, rhs: i32x4<S>) -> Self::Output {
787 rhs.simd.sub_i32x4(self.simd_into(rhs.simd), rhs)
788 }
789}
790impl<S: Simd> core::ops::Mul for i32x4<S> {
791 type Output = Self;
792 #[inline(always)]
793 fn mul(self, rhs: Self) -> Self::Output {
794 self.simd.mul_i32x4(self, rhs)
795 }
796}
797impl<S: Simd> core::ops::Mul<i32> for i32x4<S> {
798 type Output = Self;
799 #[inline(always)]
800 fn mul(self, rhs: i32) -> Self::Output {
801 self.simd.mul_i32x4(self, rhs.simd_into(self.simd))
802 }
803}
804impl<S: Simd> core::ops::Mul<i32x4<S>> for i32 {
805 type Output = i32x4<S>;
806 #[inline(always)]
807 fn mul(self, rhs: i32x4<S>) -> Self::Output {
808 rhs.simd.mul_i32x4(self.simd_into(rhs.simd), rhs)
809 }
810}
811impl<S: Simd> core::ops::BitAnd for i32x4<S> {
812 type Output = Self;
813 #[inline(always)]
814 fn bitand(self, rhs: Self) -> Self::Output {
815 self.simd.and_i32x4(self, rhs)
816 }
817}
818impl<S: Simd> core::ops::BitAnd<i32> for i32x4<S> {
819 type Output = Self;
820 #[inline(always)]
821 fn bitand(self, rhs: i32) -> Self::Output {
822 self.simd.and_i32x4(self, rhs.simd_into(self.simd))
823 }
824}
825impl<S: Simd> core::ops::BitAnd<i32x4<S>> for i32 {
826 type Output = i32x4<S>;
827 #[inline(always)]
828 fn bitand(self, rhs: i32x4<S>) -> Self::Output {
829 rhs.simd.and_i32x4(self.simd_into(rhs.simd), rhs)
830 }
831}
832impl<S: Simd> core::ops::BitOr for i32x4<S> {
833 type Output = Self;
834 #[inline(always)]
835 fn bitor(self, rhs: Self) -> Self::Output {
836 self.simd.or_i32x4(self, rhs)
837 }
838}
839impl<S: Simd> core::ops::BitOr<i32> for i32x4<S> {
840 type Output = Self;
841 #[inline(always)]
842 fn bitor(self, rhs: i32) -> Self::Output {
843 self.simd.or_i32x4(self, rhs.simd_into(self.simd))
844 }
845}
846impl<S: Simd> core::ops::BitOr<i32x4<S>> for i32 {
847 type Output = i32x4<S>;
848 #[inline(always)]
849 fn bitor(self, rhs: i32x4<S>) -> Self::Output {
850 rhs.simd.or_i32x4(self.simd_into(rhs.simd), rhs)
851 }
852}
853impl<S: Simd> core::ops::BitXor for i32x4<S> {
854 type Output = Self;
855 #[inline(always)]
856 fn bitxor(self, rhs: Self) -> Self::Output {
857 self.simd.xor_i32x4(self, rhs)
858 }
859}
860impl<S: Simd> core::ops::BitXor<i32> for i32x4<S> {
861 type Output = Self;
862 #[inline(always)]
863 fn bitxor(self, rhs: i32) -> Self::Output {
864 self.simd.xor_i32x4(self, rhs.simd_into(self.simd))
865 }
866}
867impl<S: Simd> core::ops::BitXor<i32x4<S>> for i32 {
868 type Output = i32x4<S>;
869 #[inline(always)]
870 fn bitxor(self, rhs: i32x4<S>) -> Self::Output {
871 rhs.simd.xor_i32x4(self.simd_into(rhs.simd), rhs)
872 }
873}
874impl<S: Simd> core::ops::Add for u32x4<S> {
875 type Output = Self;
876 #[inline(always)]
877 fn add(self, rhs: Self) -> Self::Output {
878 self.simd.add_u32x4(self, rhs)
879 }
880}
881impl<S: Simd> core::ops::Add<u32> for u32x4<S> {
882 type Output = Self;
883 #[inline(always)]
884 fn add(self, rhs: u32) -> Self::Output {
885 self.simd.add_u32x4(self, rhs.simd_into(self.simd))
886 }
887}
888impl<S: Simd> core::ops::Add<u32x4<S>> for u32 {
889 type Output = u32x4<S>;
890 #[inline(always)]
891 fn add(self, rhs: u32x4<S>) -> Self::Output {
892 rhs.simd.add_u32x4(self.simd_into(rhs.simd), rhs)
893 }
894}
895impl<S: Simd> core::ops::Sub for u32x4<S> {
896 type Output = Self;
897 #[inline(always)]
898 fn sub(self, rhs: Self) -> Self::Output {
899 self.simd.sub_u32x4(self, rhs)
900 }
901}
902impl<S: Simd> core::ops::Sub<u32> for u32x4<S> {
903 type Output = Self;
904 #[inline(always)]
905 fn sub(self, rhs: u32) -> Self::Output {
906 self.simd.sub_u32x4(self, rhs.simd_into(self.simd))
907 }
908}
909impl<S: Simd> core::ops::Sub<u32x4<S>> for u32 {
910 type Output = u32x4<S>;
911 #[inline(always)]
912 fn sub(self, rhs: u32x4<S>) -> Self::Output {
913 rhs.simd.sub_u32x4(self.simd_into(rhs.simd), rhs)
914 }
915}
916impl<S: Simd> core::ops::Mul for u32x4<S> {
917 type Output = Self;
918 #[inline(always)]
919 fn mul(self, rhs: Self) -> Self::Output {
920 self.simd.mul_u32x4(self, rhs)
921 }
922}
923impl<S: Simd> core::ops::Mul<u32> for u32x4<S> {
924 type Output = Self;
925 #[inline(always)]
926 fn mul(self, rhs: u32) -> Self::Output {
927 self.simd.mul_u32x4(self, rhs.simd_into(self.simd))
928 }
929}
930impl<S: Simd> core::ops::Mul<u32x4<S>> for u32 {
931 type Output = u32x4<S>;
932 #[inline(always)]
933 fn mul(self, rhs: u32x4<S>) -> Self::Output {
934 rhs.simd.mul_u32x4(self.simd_into(rhs.simd), rhs)
935 }
936}
937impl<S: Simd> core::ops::BitAnd for u32x4<S> {
938 type Output = Self;
939 #[inline(always)]
940 fn bitand(self, rhs: Self) -> Self::Output {
941 self.simd.and_u32x4(self, rhs)
942 }
943}
944impl<S: Simd> core::ops::BitAnd<u32> for u32x4<S> {
945 type Output = Self;
946 #[inline(always)]
947 fn bitand(self, rhs: u32) -> Self::Output {
948 self.simd.and_u32x4(self, rhs.simd_into(self.simd))
949 }
950}
951impl<S: Simd> core::ops::BitAnd<u32x4<S>> for u32 {
952 type Output = u32x4<S>;
953 #[inline(always)]
954 fn bitand(self, rhs: u32x4<S>) -> Self::Output {
955 rhs.simd.and_u32x4(self.simd_into(rhs.simd), rhs)
956 }
957}
958impl<S: Simd> core::ops::BitOr for u32x4<S> {
959 type Output = Self;
960 #[inline(always)]
961 fn bitor(self, rhs: Self) -> Self::Output {
962 self.simd.or_u32x4(self, rhs)
963 }
964}
965impl<S: Simd> core::ops::BitOr<u32> for u32x4<S> {
966 type Output = Self;
967 #[inline(always)]
968 fn bitor(self, rhs: u32) -> Self::Output {
969 self.simd.or_u32x4(self, rhs.simd_into(self.simd))
970 }
971}
972impl<S: Simd> core::ops::BitOr<u32x4<S>> for u32 {
973 type Output = u32x4<S>;
974 #[inline(always)]
975 fn bitor(self, rhs: u32x4<S>) -> Self::Output {
976 rhs.simd.or_u32x4(self.simd_into(rhs.simd), rhs)
977 }
978}
979impl<S: Simd> core::ops::BitXor for u32x4<S> {
980 type Output = Self;
981 #[inline(always)]
982 fn bitxor(self, rhs: Self) -> Self::Output {
983 self.simd.xor_u32x4(self, rhs)
984 }
985}
986impl<S: Simd> core::ops::BitXor<u32> for u32x4<S> {
987 type Output = Self;
988 #[inline(always)]
989 fn bitxor(self, rhs: u32) -> Self::Output {
990 self.simd.xor_u32x4(self, rhs.simd_into(self.simd))
991 }
992}
993impl<S: Simd> core::ops::BitXor<u32x4<S>> for u32 {
994 type Output = u32x4<S>;
995 #[inline(always)]
996 fn bitxor(self, rhs: u32x4<S>) -> Self::Output {
997 rhs.simd.xor_u32x4(self.simd_into(rhs.simd), rhs)
998 }
999}
1000impl<S: Simd> core::ops::BitAnd for mask32x4<S> {
1001 type Output = Self;
1002 #[inline(always)]
1003 fn bitand(self, rhs: Self) -> Self::Output {
1004 self.simd.and_mask32x4(self, rhs)
1005 }
1006}
1007impl<S: Simd> core::ops::BitAnd<i32> for mask32x4<S> {
1008 type Output = Self;
1009 #[inline(always)]
1010 fn bitand(self, rhs: i32) -> Self::Output {
1011 self.simd.and_mask32x4(self, rhs.simd_into(self.simd))
1012 }
1013}
1014impl<S: Simd> core::ops::BitAnd<mask32x4<S>> for i32 {
1015 type Output = mask32x4<S>;
1016 #[inline(always)]
1017 fn bitand(self, rhs: mask32x4<S>) -> Self::Output {
1018 rhs.simd.and_mask32x4(self.simd_into(rhs.simd), rhs)
1019 }
1020}
1021impl<S: Simd> core::ops::BitOr for mask32x4<S> {
1022 type Output = Self;
1023 #[inline(always)]
1024 fn bitor(self, rhs: Self) -> Self::Output {
1025 self.simd.or_mask32x4(self, rhs)
1026 }
1027}
1028impl<S: Simd> core::ops::BitOr<i32> for mask32x4<S> {
1029 type Output = Self;
1030 #[inline(always)]
1031 fn bitor(self, rhs: i32) -> Self::Output {
1032 self.simd.or_mask32x4(self, rhs.simd_into(self.simd))
1033 }
1034}
1035impl<S: Simd> core::ops::BitOr<mask32x4<S>> for i32 {
1036 type Output = mask32x4<S>;
1037 #[inline(always)]
1038 fn bitor(self, rhs: mask32x4<S>) -> Self::Output {
1039 rhs.simd.or_mask32x4(self.simd_into(rhs.simd), rhs)
1040 }
1041}
1042impl<S: Simd> core::ops::BitXor for mask32x4<S> {
1043 type Output = Self;
1044 #[inline(always)]
1045 fn bitxor(self, rhs: Self) -> Self::Output {
1046 self.simd.xor_mask32x4(self, rhs)
1047 }
1048}
1049impl<S: Simd> core::ops::BitXor<i32> for mask32x4<S> {
1050 type Output = Self;
1051 #[inline(always)]
1052 fn bitxor(self, rhs: i32) -> Self::Output {
1053 self.simd.xor_mask32x4(self, rhs.simd_into(self.simd))
1054 }
1055}
1056impl<S: Simd> core::ops::BitXor<mask32x4<S>> for i32 {
1057 type Output = mask32x4<S>;
1058 #[inline(always)]
1059 fn bitxor(self, rhs: mask32x4<S>) -> Self::Output {
1060 rhs.simd.xor_mask32x4(self.simd_into(rhs.simd), rhs)
1061 }
1062}
1063impl<S: Simd> core::ops::Not for mask32x4<S> {
1064 type Output = Self;
1065 #[inline(always)]
1066 fn not(self) -> Self::Output {
1067 self.simd.not_mask32x4(self)
1068 }
1069}
1070impl<S: Simd> core::ops::Neg for f64x2<S> {
1071 type Output = Self;
1072 #[inline(always)]
1073 fn neg(self) -> Self::Output {
1074 self.simd.neg_f64x2(self)
1075 }
1076}
1077impl<S: Simd> core::ops::Add for f64x2<S> {
1078 type Output = Self;
1079 #[inline(always)]
1080 fn add(self, rhs: Self) -> Self::Output {
1081 self.simd.add_f64x2(self, rhs)
1082 }
1083}
1084impl<S: Simd> core::ops::Add<f64> for f64x2<S> {
1085 type Output = Self;
1086 #[inline(always)]
1087 fn add(self, rhs: f64) -> Self::Output {
1088 self.simd.add_f64x2(self, rhs.simd_into(self.simd))
1089 }
1090}
1091impl<S: Simd> core::ops::Add<f64x2<S>> for f64 {
1092 type Output = f64x2<S>;
1093 #[inline(always)]
1094 fn add(self, rhs: f64x2<S>) -> Self::Output {
1095 rhs.simd.add_f64x2(self.simd_into(rhs.simd), rhs)
1096 }
1097}
1098impl<S: Simd> core::ops::Sub for f64x2<S> {
1099 type Output = Self;
1100 #[inline(always)]
1101 fn sub(self, rhs: Self) -> Self::Output {
1102 self.simd.sub_f64x2(self, rhs)
1103 }
1104}
1105impl<S: Simd> core::ops::Sub<f64> for f64x2<S> {
1106 type Output = Self;
1107 #[inline(always)]
1108 fn sub(self, rhs: f64) -> Self::Output {
1109 self.simd.sub_f64x2(self, rhs.simd_into(self.simd))
1110 }
1111}
1112impl<S: Simd> core::ops::Sub<f64x2<S>> for f64 {
1113 type Output = f64x2<S>;
1114 #[inline(always)]
1115 fn sub(self, rhs: f64x2<S>) -> Self::Output {
1116 rhs.simd.sub_f64x2(self.simd_into(rhs.simd), rhs)
1117 }
1118}
1119impl<S: Simd> core::ops::Mul for f64x2<S> {
1120 type Output = Self;
1121 #[inline(always)]
1122 fn mul(self, rhs: Self) -> Self::Output {
1123 self.simd.mul_f64x2(self, rhs)
1124 }
1125}
1126impl<S: Simd> core::ops::Mul<f64> for f64x2<S> {
1127 type Output = Self;
1128 #[inline(always)]
1129 fn mul(self, rhs: f64) -> Self::Output {
1130 self.simd.mul_f64x2(self, rhs.simd_into(self.simd))
1131 }
1132}
1133impl<S: Simd> core::ops::Mul<f64x2<S>> for f64 {
1134 type Output = f64x2<S>;
1135 #[inline(always)]
1136 fn mul(self, rhs: f64x2<S>) -> Self::Output {
1137 rhs.simd.mul_f64x2(self.simd_into(rhs.simd), rhs)
1138 }
1139}
1140impl<S: Simd> core::ops::Div for f64x2<S> {
1141 type Output = Self;
1142 #[inline(always)]
1143 fn div(self, rhs: Self) -> Self::Output {
1144 self.simd.div_f64x2(self, rhs)
1145 }
1146}
1147impl<S: Simd> core::ops::Div<f64> for f64x2<S> {
1148 type Output = Self;
1149 #[inline(always)]
1150 fn div(self, rhs: f64) -> Self::Output {
1151 self.simd.div_f64x2(self, rhs.simd_into(self.simd))
1152 }
1153}
1154impl<S: Simd> core::ops::Div<f64x2<S>> for f64 {
1155 type Output = f64x2<S>;
1156 #[inline(always)]
1157 fn div(self, rhs: f64x2<S>) -> Self::Output {
1158 rhs.simd.div_f64x2(self.simd_into(rhs.simd), rhs)
1159 }
1160}
1161impl<S: Simd> core::ops::BitAnd for mask64x2<S> {
1162 type Output = Self;
1163 #[inline(always)]
1164 fn bitand(self, rhs: Self) -> Self::Output {
1165 self.simd.and_mask64x2(self, rhs)
1166 }
1167}
1168impl<S: Simd> core::ops::BitAnd<i64> for mask64x2<S> {
1169 type Output = Self;
1170 #[inline(always)]
1171 fn bitand(self, rhs: i64) -> Self::Output {
1172 self.simd.and_mask64x2(self, rhs.simd_into(self.simd))
1173 }
1174}
1175impl<S: Simd> core::ops::BitAnd<mask64x2<S>> for i64 {
1176 type Output = mask64x2<S>;
1177 #[inline(always)]
1178 fn bitand(self, rhs: mask64x2<S>) -> Self::Output {
1179 rhs.simd.and_mask64x2(self.simd_into(rhs.simd), rhs)
1180 }
1181}
1182impl<S: Simd> core::ops::BitOr for mask64x2<S> {
1183 type Output = Self;
1184 #[inline(always)]
1185 fn bitor(self, rhs: Self) -> Self::Output {
1186 self.simd.or_mask64x2(self, rhs)
1187 }
1188}
1189impl<S: Simd> core::ops::BitOr<i64> for mask64x2<S> {
1190 type Output = Self;
1191 #[inline(always)]
1192 fn bitor(self, rhs: i64) -> Self::Output {
1193 self.simd.or_mask64x2(self, rhs.simd_into(self.simd))
1194 }
1195}
1196impl<S: Simd> core::ops::BitOr<mask64x2<S>> for i64 {
1197 type Output = mask64x2<S>;
1198 #[inline(always)]
1199 fn bitor(self, rhs: mask64x2<S>) -> Self::Output {
1200 rhs.simd.or_mask64x2(self.simd_into(rhs.simd), rhs)
1201 }
1202}
1203impl<S: Simd> core::ops::BitXor for mask64x2<S> {
1204 type Output = Self;
1205 #[inline(always)]
1206 fn bitxor(self, rhs: Self) -> Self::Output {
1207 self.simd.xor_mask64x2(self, rhs)
1208 }
1209}
1210impl<S: Simd> core::ops::BitXor<i64> for mask64x2<S> {
1211 type Output = Self;
1212 #[inline(always)]
1213 fn bitxor(self, rhs: i64) -> Self::Output {
1214 self.simd.xor_mask64x2(self, rhs.simd_into(self.simd))
1215 }
1216}
1217impl<S: Simd> core::ops::BitXor<mask64x2<S>> for i64 {
1218 type Output = mask64x2<S>;
1219 #[inline(always)]
1220 fn bitxor(self, rhs: mask64x2<S>) -> Self::Output {
1221 rhs.simd.xor_mask64x2(self.simd_into(rhs.simd), rhs)
1222 }
1223}
1224impl<S: Simd> core::ops::Not for mask64x2<S> {
1225 type Output = Self;
1226 #[inline(always)]
1227 fn not(self) -> Self::Output {
1228 self.simd.not_mask64x2(self)
1229 }
1230}
1231impl<S: Simd> core::ops::Neg for f32x8<S> {
1232 type Output = Self;
1233 #[inline(always)]
1234 fn neg(self) -> Self::Output {
1235 self.simd.neg_f32x8(self)
1236 }
1237}
1238impl<S: Simd> core::ops::Add for f32x8<S> {
1239 type Output = Self;
1240 #[inline(always)]
1241 fn add(self, rhs: Self) -> Self::Output {
1242 self.simd.add_f32x8(self, rhs)
1243 }
1244}
1245impl<S: Simd> core::ops::Add<f32> for f32x8<S> {
1246 type Output = Self;
1247 #[inline(always)]
1248 fn add(self, rhs: f32) -> Self::Output {
1249 self.simd.add_f32x8(self, rhs.simd_into(self.simd))
1250 }
1251}
1252impl<S: Simd> core::ops::Add<f32x8<S>> for f32 {
1253 type Output = f32x8<S>;
1254 #[inline(always)]
1255 fn add(self, rhs: f32x8<S>) -> Self::Output {
1256 rhs.simd.add_f32x8(self.simd_into(rhs.simd), rhs)
1257 }
1258}
1259impl<S: Simd> core::ops::Sub for f32x8<S> {
1260 type Output = Self;
1261 #[inline(always)]
1262 fn sub(self, rhs: Self) -> Self::Output {
1263 self.simd.sub_f32x8(self, rhs)
1264 }
1265}
1266impl<S: Simd> core::ops::Sub<f32> for f32x8<S> {
1267 type Output = Self;
1268 #[inline(always)]
1269 fn sub(self, rhs: f32) -> Self::Output {
1270 self.simd.sub_f32x8(self, rhs.simd_into(self.simd))
1271 }
1272}
1273impl<S: Simd> core::ops::Sub<f32x8<S>> for f32 {
1274 type Output = f32x8<S>;
1275 #[inline(always)]
1276 fn sub(self, rhs: f32x8<S>) -> Self::Output {
1277 rhs.simd.sub_f32x8(self.simd_into(rhs.simd), rhs)
1278 }
1279}
1280impl<S: Simd> core::ops::Mul for f32x8<S> {
1281 type Output = Self;
1282 #[inline(always)]
1283 fn mul(self, rhs: Self) -> Self::Output {
1284 self.simd.mul_f32x8(self, rhs)
1285 }
1286}
1287impl<S: Simd> core::ops::Mul<f32> for f32x8<S> {
1288 type Output = Self;
1289 #[inline(always)]
1290 fn mul(self, rhs: f32) -> Self::Output {
1291 self.simd.mul_f32x8(self, rhs.simd_into(self.simd))
1292 }
1293}
1294impl<S: Simd> core::ops::Mul<f32x8<S>> for f32 {
1295 type Output = f32x8<S>;
1296 #[inline(always)]
1297 fn mul(self, rhs: f32x8<S>) -> Self::Output {
1298 rhs.simd.mul_f32x8(self.simd_into(rhs.simd), rhs)
1299 }
1300}
1301impl<S: Simd> core::ops::Div for f32x8<S> {
1302 type Output = Self;
1303 #[inline(always)]
1304 fn div(self, rhs: Self) -> Self::Output {
1305 self.simd.div_f32x8(self, rhs)
1306 }
1307}
1308impl<S: Simd> core::ops::Div<f32> for f32x8<S> {
1309 type Output = Self;
1310 #[inline(always)]
1311 fn div(self, rhs: f32) -> Self::Output {
1312 self.simd.div_f32x8(self, rhs.simd_into(self.simd))
1313 }
1314}
1315impl<S: Simd> core::ops::Div<f32x8<S>> for f32 {
1316 type Output = f32x8<S>;
1317 #[inline(always)]
1318 fn div(self, rhs: f32x8<S>) -> Self::Output {
1319 rhs.simd.div_f32x8(self.simd_into(rhs.simd), rhs)
1320 }
1321}
1322impl<S: Simd> core::ops::Add for i8x32<S> {
1323 type Output = Self;
1324 #[inline(always)]
1325 fn add(self, rhs: Self) -> Self::Output {
1326 self.simd.add_i8x32(self, rhs)
1327 }
1328}
1329impl<S: Simd> core::ops::Add<i8> for i8x32<S> {
1330 type Output = Self;
1331 #[inline(always)]
1332 fn add(self, rhs: i8) -> Self::Output {
1333 self.simd.add_i8x32(self, rhs.simd_into(self.simd))
1334 }
1335}
1336impl<S: Simd> core::ops::Add<i8x32<S>> for i8 {
1337 type Output = i8x32<S>;
1338 #[inline(always)]
1339 fn add(self, rhs: i8x32<S>) -> Self::Output {
1340 rhs.simd.add_i8x32(self.simd_into(rhs.simd), rhs)
1341 }
1342}
1343impl<S: Simd> core::ops::Sub for i8x32<S> {
1344 type Output = Self;
1345 #[inline(always)]
1346 fn sub(self, rhs: Self) -> Self::Output {
1347 self.simd.sub_i8x32(self, rhs)
1348 }
1349}
1350impl<S: Simd> core::ops::Sub<i8> for i8x32<S> {
1351 type Output = Self;
1352 #[inline(always)]
1353 fn sub(self, rhs: i8) -> Self::Output {
1354 self.simd.sub_i8x32(self, rhs.simd_into(self.simd))
1355 }
1356}
1357impl<S: Simd> core::ops::Sub<i8x32<S>> for i8 {
1358 type Output = i8x32<S>;
1359 #[inline(always)]
1360 fn sub(self, rhs: i8x32<S>) -> Self::Output {
1361 rhs.simd.sub_i8x32(self.simd_into(rhs.simd), rhs)
1362 }
1363}
1364impl<S: Simd> core::ops::Mul for i8x32<S> {
1365 type Output = Self;
1366 #[inline(always)]
1367 fn mul(self, rhs: Self) -> Self::Output {
1368 self.simd.mul_i8x32(self, rhs)
1369 }
1370}
1371impl<S: Simd> core::ops::Mul<i8> for i8x32<S> {
1372 type Output = Self;
1373 #[inline(always)]
1374 fn mul(self, rhs: i8) -> Self::Output {
1375 self.simd.mul_i8x32(self, rhs.simd_into(self.simd))
1376 }
1377}
1378impl<S: Simd> core::ops::Mul<i8x32<S>> for i8 {
1379 type Output = i8x32<S>;
1380 #[inline(always)]
1381 fn mul(self, rhs: i8x32<S>) -> Self::Output {
1382 rhs.simd.mul_i8x32(self.simd_into(rhs.simd), rhs)
1383 }
1384}
1385impl<S: Simd> core::ops::BitAnd for i8x32<S> {
1386 type Output = Self;
1387 #[inline(always)]
1388 fn bitand(self, rhs: Self) -> Self::Output {
1389 self.simd.and_i8x32(self, rhs)
1390 }
1391}
1392impl<S: Simd> core::ops::BitAnd<i8> for i8x32<S> {
1393 type Output = Self;
1394 #[inline(always)]
1395 fn bitand(self, rhs: i8) -> Self::Output {
1396 self.simd.and_i8x32(self, rhs.simd_into(self.simd))
1397 }
1398}
1399impl<S: Simd> core::ops::BitAnd<i8x32<S>> for i8 {
1400 type Output = i8x32<S>;
1401 #[inline(always)]
1402 fn bitand(self, rhs: i8x32<S>) -> Self::Output {
1403 rhs.simd.and_i8x32(self.simd_into(rhs.simd), rhs)
1404 }
1405}
1406impl<S: Simd> core::ops::BitOr for i8x32<S> {
1407 type Output = Self;
1408 #[inline(always)]
1409 fn bitor(self, rhs: Self) -> Self::Output {
1410 self.simd.or_i8x32(self, rhs)
1411 }
1412}
1413impl<S: Simd> core::ops::BitOr<i8> for i8x32<S> {
1414 type Output = Self;
1415 #[inline(always)]
1416 fn bitor(self, rhs: i8) -> Self::Output {
1417 self.simd.or_i8x32(self, rhs.simd_into(self.simd))
1418 }
1419}
1420impl<S: Simd> core::ops::BitOr<i8x32<S>> for i8 {
1421 type Output = i8x32<S>;
1422 #[inline(always)]
1423 fn bitor(self, rhs: i8x32<S>) -> Self::Output {
1424 rhs.simd.or_i8x32(self.simd_into(rhs.simd), rhs)
1425 }
1426}
1427impl<S: Simd> core::ops::BitXor for i8x32<S> {
1428 type Output = Self;
1429 #[inline(always)]
1430 fn bitxor(self, rhs: Self) -> Self::Output {
1431 self.simd.xor_i8x32(self, rhs)
1432 }
1433}
1434impl<S: Simd> core::ops::BitXor<i8> for i8x32<S> {
1435 type Output = Self;
1436 #[inline(always)]
1437 fn bitxor(self, rhs: i8) -> Self::Output {
1438 self.simd.xor_i8x32(self, rhs.simd_into(self.simd))
1439 }
1440}
1441impl<S: Simd> core::ops::BitXor<i8x32<S>> for i8 {
1442 type Output = i8x32<S>;
1443 #[inline(always)]
1444 fn bitxor(self, rhs: i8x32<S>) -> Self::Output {
1445 rhs.simd.xor_i8x32(self.simd_into(rhs.simd), rhs)
1446 }
1447}
1448impl<S: Simd> core::ops::Add for u8x32<S> {
1449 type Output = Self;
1450 #[inline(always)]
1451 fn add(self, rhs: Self) -> Self::Output {
1452 self.simd.add_u8x32(self, rhs)
1453 }
1454}
1455impl<S: Simd> core::ops::Add<u8> for u8x32<S> {
1456 type Output = Self;
1457 #[inline(always)]
1458 fn add(self, rhs: u8) -> Self::Output {
1459 self.simd.add_u8x32(self, rhs.simd_into(self.simd))
1460 }
1461}
1462impl<S: Simd> core::ops::Add<u8x32<S>> for u8 {
1463 type Output = u8x32<S>;
1464 #[inline(always)]
1465 fn add(self, rhs: u8x32<S>) -> Self::Output {
1466 rhs.simd.add_u8x32(self.simd_into(rhs.simd), rhs)
1467 }
1468}
1469impl<S: Simd> core::ops::Sub for u8x32<S> {
1470 type Output = Self;
1471 #[inline(always)]
1472 fn sub(self, rhs: Self) -> Self::Output {
1473 self.simd.sub_u8x32(self, rhs)
1474 }
1475}
1476impl<S: Simd> core::ops::Sub<u8> for u8x32<S> {
1477 type Output = Self;
1478 #[inline(always)]
1479 fn sub(self, rhs: u8) -> Self::Output {
1480 self.simd.sub_u8x32(self, rhs.simd_into(self.simd))
1481 }
1482}
1483impl<S: Simd> core::ops::Sub<u8x32<S>> for u8 {
1484 type Output = u8x32<S>;
1485 #[inline(always)]
1486 fn sub(self, rhs: u8x32<S>) -> Self::Output {
1487 rhs.simd.sub_u8x32(self.simd_into(rhs.simd), rhs)
1488 }
1489}
1490impl<S: Simd> core::ops::Mul for u8x32<S> {
1491 type Output = Self;
1492 #[inline(always)]
1493 fn mul(self, rhs: Self) -> Self::Output {
1494 self.simd.mul_u8x32(self, rhs)
1495 }
1496}
1497impl<S: Simd> core::ops::Mul<u8> for u8x32<S> {
1498 type Output = Self;
1499 #[inline(always)]
1500 fn mul(self, rhs: u8) -> Self::Output {
1501 self.simd.mul_u8x32(self, rhs.simd_into(self.simd))
1502 }
1503}
1504impl<S: Simd> core::ops::Mul<u8x32<S>> for u8 {
1505 type Output = u8x32<S>;
1506 #[inline(always)]
1507 fn mul(self, rhs: u8x32<S>) -> Self::Output {
1508 rhs.simd.mul_u8x32(self.simd_into(rhs.simd), rhs)
1509 }
1510}
1511impl<S: Simd> core::ops::BitAnd for u8x32<S> {
1512 type Output = Self;
1513 #[inline(always)]
1514 fn bitand(self, rhs: Self) -> Self::Output {
1515 self.simd.and_u8x32(self, rhs)
1516 }
1517}
1518impl<S: Simd> core::ops::BitAnd<u8> for u8x32<S> {
1519 type Output = Self;
1520 #[inline(always)]
1521 fn bitand(self, rhs: u8) -> Self::Output {
1522 self.simd.and_u8x32(self, rhs.simd_into(self.simd))
1523 }
1524}
1525impl<S: Simd> core::ops::BitAnd<u8x32<S>> for u8 {
1526 type Output = u8x32<S>;
1527 #[inline(always)]
1528 fn bitand(self, rhs: u8x32<S>) -> Self::Output {
1529 rhs.simd.and_u8x32(self.simd_into(rhs.simd), rhs)
1530 }
1531}
1532impl<S: Simd> core::ops::BitOr for u8x32<S> {
1533 type Output = Self;
1534 #[inline(always)]
1535 fn bitor(self, rhs: Self) -> Self::Output {
1536 self.simd.or_u8x32(self, rhs)
1537 }
1538}
1539impl<S: Simd> core::ops::BitOr<u8> for u8x32<S> {
1540 type Output = Self;
1541 #[inline(always)]
1542 fn bitor(self, rhs: u8) -> Self::Output {
1543 self.simd.or_u8x32(self, rhs.simd_into(self.simd))
1544 }
1545}
1546impl<S: Simd> core::ops::BitOr<u8x32<S>> for u8 {
1547 type Output = u8x32<S>;
1548 #[inline(always)]
1549 fn bitor(self, rhs: u8x32<S>) -> Self::Output {
1550 rhs.simd.or_u8x32(self.simd_into(rhs.simd), rhs)
1551 }
1552}
1553impl<S: Simd> core::ops::BitXor for u8x32<S> {
1554 type Output = Self;
1555 #[inline(always)]
1556 fn bitxor(self, rhs: Self) -> Self::Output {
1557 self.simd.xor_u8x32(self, rhs)
1558 }
1559}
1560impl<S: Simd> core::ops::BitXor<u8> for u8x32<S> {
1561 type Output = Self;
1562 #[inline(always)]
1563 fn bitxor(self, rhs: u8) -> Self::Output {
1564 self.simd.xor_u8x32(self, rhs.simd_into(self.simd))
1565 }
1566}
1567impl<S: Simd> core::ops::BitXor<u8x32<S>> for u8 {
1568 type Output = u8x32<S>;
1569 #[inline(always)]
1570 fn bitxor(self, rhs: u8x32<S>) -> Self::Output {
1571 rhs.simd.xor_u8x32(self.simd_into(rhs.simd), rhs)
1572 }
1573}
1574impl<S: Simd> core::ops::BitAnd for mask8x32<S> {
1575 type Output = Self;
1576 #[inline(always)]
1577 fn bitand(self, rhs: Self) -> Self::Output {
1578 self.simd.and_mask8x32(self, rhs)
1579 }
1580}
1581impl<S: Simd> core::ops::BitAnd<i8> for mask8x32<S> {
1582 type Output = Self;
1583 #[inline(always)]
1584 fn bitand(self, rhs: i8) -> Self::Output {
1585 self.simd.and_mask8x32(self, rhs.simd_into(self.simd))
1586 }
1587}
1588impl<S: Simd> core::ops::BitAnd<mask8x32<S>> for i8 {
1589 type Output = mask8x32<S>;
1590 #[inline(always)]
1591 fn bitand(self, rhs: mask8x32<S>) -> Self::Output {
1592 rhs.simd.and_mask8x32(self.simd_into(rhs.simd), rhs)
1593 }
1594}
1595impl<S: Simd> core::ops::BitOr for mask8x32<S> {
1596 type Output = Self;
1597 #[inline(always)]
1598 fn bitor(self, rhs: Self) -> Self::Output {
1599 self.simd.or_mask8x32(self, rhs)
1600 }
1601}
1602impl<S: Simd> core::ops::BitOr<i8> for mask8x32<S> {
1603 type Output = Self;
1604 #[inline(always)]
1605 fn bitor(self, rhs: i8) -> Self::Output {
1606 self.simd.or_mask8x32(self, rhs.simd_into(self.simd))
1607 }
1608}
1609impl<S: Simd> core::ops::BitOr<mask8x32<S>> for i8 {
1610 type Output = mask8x32<S>;
1611 #[inline(always)]
1612 fn bitor(self, rhs: mask8x32<S>) -> Self::Output {
1613 rhs.simd.or_mask8x32(self.simd_into(rhs.simd), rhs)
1614 }
1615}
1616impl<S: Simd> core::ops::BitXor for mask8x32<S> {
1617 type Output = Self;
1618 #[inline(always)]
1619 fn bitxor(self, rhs: Self) -> Self::Output {
1620 self.simd.xor_mask8x32(self, rhs)
1621 }
1622}
1623impl<S: Simd> core::ops::BitXor<i8> for mask8x32<S> {
1624 type Output = Self;
1625 #[inline(always)]
1626 fn bitxor(self, rhs: i8) -> Self::Output {
1627 self.simd.xor_mask8x32(self, rhs.simd_into(self.simd))
1628 }
1629}
1630impl<S: Simd> core::ops::BitXor<mask8x32<S>> for i8 {
1631 type Output = mask8x32<S>;
1632 #[inline(always)]
1633 fn bitxor(self, rhs: mask8x32<S>) -> Self::Output {
1634 rhs.simd.xor_mask8x32(self.simd_into(rhs.simd), rhs)
1635 }
1636}
1637impl<S: Simd> core::ops::Not for mask8x32<S> {
1638 type Output = Self;
1639 #[inline(always)]
1640 fn not(self) -> Self::Output {
1641 self.simd.not_mask8x32(self)
1642 }
1643}
1644impl<S: Simd> core::ops::Add for i16x16<S> {
1645 type Output = Self;
1646 #[inline(always)]
1647 fn add(self, rhs: Self) -> Self::Output {
1648 self.simd.add_i16x16(self, rhs)
1649 }
1650}
1651impl<S: Simd> core::ops::Add<i16> for i16x16<S> {
1652 type Output = Self;
1653 #[inline(always)]
1654 fn add(self, rhs: i16) -> Self::Output {
1655 self.simd.add_i16x16(self, rhs.simd_into(self.simd))
1656 }
1657}
1658impl<S: Simd> core::ops::Add<i16x16<S>> for i16 {
1659 type Output = i16x16<S>;
1660 #[inline(always)]
1661 fn add(self, rhs: i16x16<S>) -> Self::Output {
1662 rhs.simd.add_i16x16(self.simd_into(rhs.simd), rhs)
1663 }
1664}
1665impl<S: Simd> core::ops::Sub for i16x16<S> {
1666 type Output = Self;
1667 #[inline(always)]
1668 fn sub(self, rhs: Self) -> Self::Output {
1669 self.simd.sub_i16x16(self, rhs)
1670 }
1671}
1672impl<S: Simd> core::ops::Sub<i16> for i16x16<S> {
1673 type Output = Self;
1674 #[inline(always)]
1675 fn sub(self, rhs: i16) -> Self::Output {
1676 self.simd.sub_i16x16(self, rhs.simd_into(self.simd))
1677 }
1678}
1679impl<S: Simd> core::ops::Sub<i16x16<S>> for i16 {
1680 type Output = i16x16<S>;
1681 #[inline(always)]
1682 fn sub(self, rhs: i16x16<S>) -> Self::Output {
1683 rhs.simd.sub_i16x16(self.simd_into(rhs.simd), rhs)
1684 }
1685}
1686impl<S: Simd> core::ops::Mul for i16x16<S> {
1687 type Output = Self;
1688 #[inline(always)]
1689 fn mul(self, rhs: Self) -> Self::Output {
1690 self.simd.mul_i16x16(self, rhs)
1691 }
1692}
1693impl<S: Simd> core::ops::Mul<i16> for i16x16<S> {
1694 type Output = Self;
1695 #[inline(always)]
1696 fn mul(self, rhs: i16) -> Self::Output {
1697 self.simd.mul_i16x16(self, rhs.simd_into(self.simd))
1698 }
1699}
1700impl<S: Simd> core::ops::Mul<i16x16<S>> for i16 {
1701 type Output = i16x16<S>;
1702 #[inline(always)]
1703 fn mul(self, rhs: i16x16<S>) -> Self::Output {
1704 rhs.simd.mul_i16x16(self.simd_into(rhs.simd), rhs)
1705 }
1706}
1707impl<S: Simd> core::ops::BitAnd for i16x16<S> {
1708 type Output = Self;
1709 #[inline(always)]
1710 fn bitand(self, rhs: Self) -> Self::Output {
1711 self.simd.and_i16x16(self, rhs)
1712 }
1713}
1714impl<S: Simd> core::ops::BitAnd<i16> for i16x16<S> {
1715 type Output = Self;
1716 #[inline(always)]
1717 fn bitand(self, rhs: i16) -> Self::Output {
1718 self.simd.and_i16x16(self, rhs.simd_into(self.simd))
1719 }
1720}
1721impl<S: Simd> core::ops::BitAnd<i16x16<S>> for i16 {
1722 type Output = i16x16<S>;
1723 #[inline(always)]
1724 fn bitand(self, rhs: i16x16<S>) -> Self::Output {
1725 rhs.simd.and_i16x16(self.simd_into(rhs.simd), rhs)
1726 }
1727}
1728impl<S: Simd> core::ops::BitOr for i16x16<S> {
1729 type Output = Self;
1730 #[inline(always)]
1731 fn bitor(self, rhs: Self) -> Self::Output {
1732 self.simd.or_i16x16(self, rhs)
1733 }
1734}
1735impl<S: Simd> core::ops::BitOr<i16> for i16x16<S> {
1736 type Output = Self;
1737 #[inline(always)]
1738 fn bitor(self, rhs: i16) -> Self::Output {
1739 self.simd.or_i16x16(self, rhs.simd_into(self.simd))
1740 }
1741}
1742impl<S: Simd> core::ops::BitOr<i16x16<S>> for i16 {
1743 type Output = i16x16<S>;
1744 #[inline(always)]
1745 fn bitor(self, rhs: i16x16<S>) -> Self::Output {
1746 rhs.simd.or_i16x16(self.simd_into(rhs.simd), rhs)
1747 }
1748}
1749impl<S: Simd> core::ops::BitXor for i16x16<S> {
1750 type Output = Self;
1751 #[inline(always)]
1752 fn bitxor(self, rhs: Self) -> Self::Output {
1753 self.simd.xor_i16x16(self, rhs)
1754 }
1755}
1756impl<S: Simd> core::ops::BitXor<i16> for i16x16<S> {
1757 type Output = Self;
1758 #[inline(always)]
1759 fn bitxor(self, rhs: i16) -> Self::Output {
1760 self.simd.xor_i16x16(self, rhs.simd_into(self.simd))
1761 }
1762}
1763impl<S: Simd> core::ops::BitXor<i16x16<S>> for i16 {
1764 type Output = i16x16<S>;
1765 #[inline(always)]
1766 fn bitxor(self, rhs: i16x16<S>) -> Self::Output {
1767 rhs.simd.xor_i16x16(self.simd_into(rhs.simd), rhs)
1768 }
1769}
1770impl<S: Simd> core::ops::Add for u16x16<S> {
1771 type Output = Self;
1772 #[inline(always)]
1773 fn add(self, rhs: Self) -> Self::Output {
1774 self.simd.add_u16x16(self, rhs)
1775 }
1776}
1777impl<S: Simd> core::ops::Add<u16> for u16x16<S> {
1778 type Output = Self;
1779 #[inline(always)]
1780 fn add(self, rhs: u16) -> Self::Output {
1781 self.simd.add_u16x16(self, rhs.simd_into(self.simd))
1782 }
1783}
1784impl<S: Simd> core::ops::Add<u16x16<S>> for u16 {
1785 type Output = u16x16<S>;
1786 #[inline(always)]
1787 fn add(self, rhs: u16x16<S>) -> Self::Output {
1788 rhs.simd.add_u16x16(self.simd_into(rhs.simd), rhs)
1789 }
1790}
1791impl<S: Simd> core::ops::Sub for u16x16<S> {
1792 type Output = Self;
1793 #[inline(always)]
1794 fn sub(self, rhs: Self) -> Self::Output {
1795 self.simd.sub_u16x16(self, rhs)
1796 }
1797}
1798impl<S: Simd> core::ops::Sub<u16> for u16x16<S> {
1799 type Output = Self;
1800 #[inline(always)]
1801 fn sub(self, rhs: u16) -> Self::Output {
1802 self.simd.sub_u16x16(self, rhs.simd_into(self.simd))
1803 }
1804}
1805impl<S: Simd> core::ops::Sub<u16x16<S>> for u16 {
1806 type Output = u16x16<S>;
1807 #[inline(always)]
1808 fn sub(self, rhs: u16x16<S>) -> Self::Output {
1809 rhs.simd.sub_u16x16(self.simd_into(rhs.simd), rhs)
1810 }
1811}
1812impl<S: Simd> core::ops::Mul for u16x16<S> {
1813 type Output = Self;
1814 #[inline(always)]
1815 fn mul(self, rhs: Self) -> Self::Output {
1816 self.simd.mul_u16x16(self, rhs)
1817 }
1818}
1819impl<S: Simd> core::ops::Mul<u16> for u16x16<S> {
1820 type Output = Self;
1821 #[inline(always)]
1822 fn mul(self, rhs: u16) -> Self::Output {
1823 self.simd.mul_u16x16(self, rhs.simd_into(self.simd))
1824 }
1825}
1826impl<S: Simd> core::ops::Mul<u16x16<S>> for u16 {
1827 type Output = u16x16<S>;
1828 #[inline(always)]
1829 fn mul(self, rhs: u16x16<S>) -> Self::Output {
1830 rhs.simd.mul_u16x16(self.simd_into(rhs.simd), rhs)
1831 }
1832}
1833impl<S: Simd> core::ops::BitAnd for u16x16<S> {
1834 type Output = Self;
1835 #[inline(always)]
1836 fn bitand(self, rhs: Self) -> Self::Output {
1837 self.simd.and_u16x16(self, rhs)
1838 }
1839}
1840impl<S: Simd> core::ops::BitAnd<u16> for u16x16<S> {
1841 type Output = Self;
1842 #[inline(always)]
1843 fn bitand(self, rhs: u16) -> Self::Output {
1844 self.simd.and_u16x16(self, rhs.simd_into(self.simd))
1845 }
1846}
1847impl<S: Simd> core::ops::BitAnd<u16x16<S>> for u16 {
1848 type Output = u16x16<S>;
1849 #[inline(always)]
1850 fn bitand(self, rhs: u16x16<S>) -> Self::Output {
1851 rhs.simd.and_u16x16(self.simd_into(rhs.simd), rhs)
1852 }
1853}
1854impl<S: Simd> core::ops::BitOr for u16x16<S> {
1855 type Output = Self;
1856 #[inline(always)]
1857 fn bitor(self, rhs: Self) -> Self::Output {
1858 self.simd.or_u16x16(self, rhs)
1859 }
1860}
1861impl<S: Simd> core::ops::BitOr<u16> for u16x16<S> {
1862 type Output = Self;
1863 #[inline(always)]
1864 fn bitor(self, rhs: u16) -> Self::Output {
1865 self.simd.or_u16x16(self, rhs.simd_into(self.simd))
1866 }
1867}
1868impl<S: Simd> core::ops::BitOr<u16x16<S>> for u16 {
1869 type Output = u16x16<S>;
1870 #[inline(always)]
1871 fn bitor(self, rhs: u16x16<S>) -> Self::Output {
1872 rhs.simd.or_u16x16(self.simd_into(rhs.simd), rhs)
1873 }
1874}
1875impl<S: Simd> core::ops::BitXor for u16x16<S> {
1876 type Output = Self;
1877 #[inline(always)]
1878 fn bitxor(self, rhs: Self) -> Self::Output {
1879 self.simd.xor_u16x16(self, rhs)
1880 }
1881}
1882impl<S: Simd> core::ops::BitXor<u16> for u16x16<S> {
1883 type Output = Self;
1884 #[inline(always)]
1885 fn bitxor(self, rhs: u16) -> Self::Output {
1886 self.simd.xor_u16x16(self, rhs.simd_into(self.simd))
1887 }
1888}
1889impl<S: Simd> core::ops::BitXor<u16x16<S>> for u16 {
1890 type Output = u16x16<S>;
1891 #[inline(always)]
1892 fn bitxor(self, rhs: u16x16<S>) -> Self::Output {
1893 rhs.simd.xor_u16x16(self.simd_into(rhs.simd), rhs)
1894 }
1895}
1896impl<S: Simd> core::ops::BitAnd for mask16x16<S> {
1897 type Output = Self;
1898 #[inline(always)]
1899 fn bitand(self, rhs: Self) -> Self::Output {
1900 self.simd.and_mask16x16(self, rhs)
1901 }
1902}
1903impl<S: Simd> core::ops::BitAnd<i16> for mask16x16<S> {
1904 type Output = Self;
1905 #[inline(always)]
1906 fn bitand(self, rhs: i16) -> Self::Output {
1907 self.simd.and_mask16x16(self, rhs.simd_into(self.simd))
1908 }
1909}
1910impl<S: Simd> core::ops::BitAnd<mask16x16<S>> for i16 {
1911 type Output = mask16x16<S>;
1912 #[inline(always)]
1913 fn bitand(self, rhs: mask16x16<S>) -> Self::Output {
1914 rhs.simd.and_mask16x16(self.simd_into(rhs.simd), rhs)
1915 }
1916}
1917impl<S: Simd> core::ops::BitOr for mask16x16<S> {
1918 type Output = Self;
1919 #[inline(always)]
1920 fn bitor(self, rhs: Self) -> Self::Output {
1921 self.simd.or_mask16x16(self, rhs)
1922 }
1923}
1924impl<S: Simd> core::ops::BitOr<i16> for mask16x16<S> {
1925 type Output = Self;
1926 #[inline(always)]
1927 fn bitor(self, rhs: i16) -> Self::Output {
1928 self.simd.or_mask16x16(self, rhs.simd_into(self.simd))
1929 }
1930}
1931impl<S: Simd> core::ops::BitOr<mask16x16<S>> for i16 {
1932 type Output = mask16x16<S>;
1933 #[inline(always)]
1934 fn bitor(self, rhs: mask16x16<S>) -> Self::Output {
1935 rhs.simd.or_mask16x16(self.simd_into(rhs.simd), rhs)
1936 }
1937}
1938impl<S: Simd> core::ops::BitXor for mask16x16<S> {
1939 type Output = Self;
1940 #[inline(always)]
1941 fn bitxor(self, rhs: Self) -> Self::Output {
1942 self.simd.xor_mask16x16(self, rhs)
1943 }
1944}
1945impl<S: Simd> core::ops::BitXor<i16> for mask16x16<S> {
1946 type Output = Self;
1947 #[inline(always)]
1948 fn bitxor(self, rhs: i16) -> Self::Output {
1949 self.simd.xor_mask16x16(self, rhs.simd_into(self.simd))
1950 }
1951}
1952impl<S: Simd> core::ops::BitXor<mask16x16<S>> for i16 {
1953 type Output = mask16x16<S>;
1954 #[inline(always)]
1955 fn bitxor(self, rhs: mask16x16<S>) -> Self::Output {
1956 rhs.simd.xor_mask16x16(self.simd_into(rhs.simd), rhs)
1957 }
1958}
1959impl<S: Simd> core::ops::Not for mask16x16<S> {
1960 type Output = Self;
1961 #[inline(always)]
1962 fn not(self) -> Self::Output {
1963 self.simd.not_mask16x16(self)
1964 }
1965}
1966impl<S: Simd> core::ops::Add for i32x8<S> {
1967 type Output = Self;
1968 #[inline(always)]
1969 fn add(self, rhs: Self) -> Self::Output {
1970 self.simd.add_i32x8(self, rhs)
1971 }
1972}
1973impl<S: Simd> core::ops::Add<i32> for i32x8<S> {
1974 type Output = Self;
1975 #[inline(always)]
1976 fn add(self, rhs: i32) -> Self::Output {
1977 self.simd.add_i32x8(self, rhs.simd_into(self.simd))
1978 }
1979}
1980impl<S: Simd> core::ops::Add<i32x8<S>> for i32 {
1981 type Output = i32x8<S>;
1982 #[inline(always)]
1983 fn add(self, rhs: i32x8<S>) -> Self::Output {
1984 rhs.simd.add_i32x8(self.simd_into(rhs.simd), rhs)
1985 }
1986}
1987impl<S: Simd> core::ops::Sub for i32x8<S> {
1988 type Output = Self;
1989 #[inline(always)]
1990 fn sub(self, rhs: Self) -> Self::Output {
1991 self.simd.sub_i32x8(self, rhs)
1992 }
1993}
1994impl<S: Simd> core::ops::Sub<i32> for i32x8<S> {
1995 type Output = Self;
1996 #[inline(always)]
1997 fn sub(self, rhs: i32) -> Self::Output {
1998 self.simd.sub_i32x8(self, rhs.simd_into(self.simd))
1999 }
2000}
2001impl<S: Simd> core::ops::Sub<i32x8<S>> for i32 {
2002 type Output = i32x8<S>;
2003 #[inline(always)]
2004 fn sub(self, rhs: i32x8<S>) -> Self::Output {
2005 rhs.simd.sub_i32x8(self.simd_into(rhs.simd), rhs)
2006 }
2007}
2008impl<S: Simd> core::ops::Mul for i32x8<S> {
2009 type Output = Self;
2010 #[inline(always)]
2011 fn mul(self, rhs: Self) -> Self::Output {
2012 self.simd.mul_i32x8(self, rhs)
2013 }
2014}
2015impl<S: Simd> core::ops::Mul<i32> for i32x8<S> {
2016 type Output = Self;
2017 #[inline(always)]
2018 fn mul(self, rhs: i32) -> Self::Output {
2019 self.simd.mul_i32x8(self, rhs.simd_into(self.simd))
2020 }
2021}
2022impl<S: Simd> core::ops::Mul<i32x8<S>> for i32 {
2023 type Output = i32x8<S>;
2024 #[inline(always)]
2025 fn mul(self, rhs: i32x8<S>) -> Self::Output {
2026 rhs.simd.mul_i32x8(self.simd_into(rhs.simd), rhs)
2027 }
2028}
2029impl<S: Simd> core::ops::BitAnd for i32x8<S> {
2030 type Output = Self;
2031 #[inline(always)]
2032 fn bitand(self, rhs: Self) -> Self::Output {
2033 self.simd.and_i32x8(self, rhs)
2034 }
2035}
2036impl<S: Simd> core::ops::BitAnd<i32> for i32x8<S> {
2037 type Output = Self;
2038 #[inline(always)]
2039 fn bitand(self, rhs: i32) -> Self::Output {
2040 self.simd.and_i32x8(self, rhs.simd_into(self.simd))
2041 }
2042}
2043impl<S: Simd> core::ops::BitAnd<i32x8<S>> for i32 {
2044 type Output = i32x8<S>;
2045 #[inline(always)]
2046 fn bitand(self, rhs: i32x8<S>) -> Self::Output {
2047 rhs.simd.and_i32x8(self.simd_into(rhs.simd), rhs)
2048 }
2049}
2050impl<S: Simd> core::ops::BitOr for i32x8<S> {
2051 type Output = Self;
2052 #[inline(always)]
2053 fn bitor(self, rhs: Self) -> Self::Output {
2054 self.simd.or_i32x8(self, rhs)
2055 }
2056}
2057impl<S: Simd> core::ops::BitOr<i32> for i32x8<S> {
2058 type Output = Self;
2059 #[inline(always)]
2060 fn bitor(self, rhs: i32) -> Self::Output {
2061 self.simd.or_i32x8(self, rhs.simd_into(self.simd))
2062 }
2063}
2064impl<S: Simd> core::ops::BitOr<i32x8<S>> for i32 {
2065 type Output = i32x8<S>;
2066 #[inline(always)]
2067 fn bitor(self, rhs: i32x8<S>) -> Self::Output {
2068 rhs.simd.or_i32x8(self.simd_into(rhs.simd), rhs)
2069 }
2070}
2071impl<S: Simd> core::ops::BitXor for i32x8<S> {
2072 type Output = Self;
2073 #[inline(always)]
2074 fn bitxor(self, rhs: Self) -> Self::Output {
2075 self.simd.xor_i32x8(self, rhs)
2076 }
2077}
2078impl<S: Simd> core::ops::BitXor<i32> for i32x8<S> {
2079 type Output = Self;
2080 #[inline(always)]
2081 fn bitxor(self, rhs: i32) -> Self::Output {
2082 self.simd.xor_i32x8(self, rhs.simd_into(self.simd))
2083 }
2084}
2085impl<S: Simd> core::ops::BitXor<i32x8<S>> for i32 {
2086 type Output = i32x8<S>;
2087 #[inline(always)]
2088 fn bitxor(self, rhs: i32x8<S>) -> Self::Output {
2089 rhs.simd.xor_i32x8(self.simd_into(rhs.simd), rhs)
2090 }
2091}
2092impl<S: Simd> core::ops::Add for u32x8<S> {
2093 type Output = Self;
2094 #[inline(always)]
2095 fn add(self, rhs: Self) -> Self::Output {
2096 self.simd.add_u32x8(self, rhs)
2097 }
2098}
2099impl<S: Simd> core::ops::Add<u32> for u32x8<S> {
2100 type Output = Self;
2101 #[inline(always)]
2102 fn add(self, rhs: u32) -> Self::Output {
2103 self.simd.add_u32x8(self, rhs.simd_into(self.simd))
2104 }
2105}
2106impl<S: Simd> core::ops::Add<u32x8<S>> for u32 {
2107 type Output = u32x8<S>;
2108 #[inline(always)]
2109 fn add(self, rhs: u32x8<S>) -> Self::Output {
2110 rhs.simd.add_u32x8(self.simd_into(rhs.simd), rhs)
2111 }
2112}
2113impl<S: Simd> core::ops::Sub for u32x8<S> {
2114 type Output = Self;
2115 #[inline(always)]
2116 fn sub(self, rhs: Self) -> Self::Output {
2117 self.simd.sub_u32x8(self, rhs)
2118 }
2119}
2120impl<S: Simd> core::ops::Sub<u32> for u32x8<S> {
2121 type Output = Self;
2122 #[inline(always)]
2123 fn sub(self, rhs: u32) -> Self::Output {
2124 self.simd.sub_u32x8(self, rhs.simd_into(self.simd))
2125 }
2126}
2127impl<S: Simd> core::ops::Sub<u32x8<S>> for u32 {
2128 type Output = u32x8<S>;
2129 #[inline(always)]
2130 fn sub(self, rhs: u32x8<S>) -> Self::Output {
2131 rhs.simd.sub_u32x8(self.simd_into(rhs.simd), rhs)
2132 }
2133}
2134impl<S: Simd> core::ops::Mul for u32x8<S> {
2135 type Output = Self;
2136 #[inline(always)]
2137 fn mul(self, rhs: Self) -> Self::Output {
2138 self.simd.mul_u32x8(self, rhs)
2139 }
2140}
2141impl<S: Simd> core::ops::Mul<u32> for u32x8<S> {
2142 type Output = Self;
2143 #[inline(always)]
2144 fn mul(self, rhs: u32) -> Self::Output {
2145 self.simd.mul_u32x8(self, rhs.simd_into(self.simd))
2146 }
2147}
2148impl<S: Simd> core::ops::Mul<u32x8<S>> for u32 {
2149 type Output = u32x8<S>;
2150 #[inline(always)]
2151 fn mul(self, rhs: u32x8<S>) -> Self::Output {
2152 rhs.simd.mul_u32x8(self.simd_into(rhs.simd), rhs)
2153 }
2154}
2155impl<S: Simd> core::ops::BitAnd for u32x8<S> {
2156 type Output = Self;
2157 #[inline(always)]
2158 fn bitand(self, rhs: Self) -> Self::Output {
2159 self.simd.and_u32x8(self, rhs)
2160 }
2161}
2162impl<S: Simd> core::ops::BitAnd<u32> for u32x8<S> {
2163 type Output = Self;
2164 #[inline(always)]
2165 fn bitand(self, rhs: u32) -> Self::Output {
2166 self.simd.and_u32x8(self, rhs.simd_into(self.simd))
2167 }
2168}
2169impl<S: Simd> core::ops::BitAnd<u32x8<S>> for u32 {
2170 type Output = u32x8<S>;
2171 #[inline(always)]
2172 fn bitand(self, rhs: u32x8<S>) -> Self::Output {
2173 rhs.simd.and_u32x8(self.simd_into(rhs.simd), rhs)
2174 }
2175}
2176impl<S: Simd> core::ops::BitOr for u32x8<S> {
2177 type Output = Self;
2178 #[inline(always)]
2179 fn bitor(self, rhs: Self) -> Self::Output {
2180 self.simd.or_u32x8(self, rhs)
2181 }
2182}
2183impl<S: Simd> core::ops::BitOr<u32> for u32x8<S> {
2184 type Output = Self;
2185 #[inline(always)]
2186 fn bitor(self, rhs: u32) -> Self::Output {
2187 self.simd.or_u32x8(self, rhs.simd_into(self.simd))
2188 }
2189}
2190impl<S: Simd> core::ops::BitOr<u32x8<S>> for u32 {
2191 type Output = u32x8<S>;
2192 #[inline(always)]
2193 fn bitor(self, rhs: u32x8<S>) -> Self::Output {
2194 rhs.simd.or_u32x8(self.simd_into(rhs.simd), rhs)
2195 }
2196}
2197impl<S: Simd> core::ops::BitXor for u32x8<S> {
2198 type Output = Self;
2199 #[inline(always)]
2200 fn bitxor(self, rhs: Self) -> Self::Output {
2201 self.simd.xor_u32x8(self, rhs)
2202 }
2203}
2204impl<S: Simd> core::ops::BitXor<u32> for u32x8<S> {
2205 type Output = Self;
2206 #[inline(always)]
2207 fn bitxor(self, rhs: u32) -> Self::Output {
2208 self.simd.xor_u32x8(self, rhs.simd_into(self.simd))
2209 }
2210}
2211impl<S: Simd> core::ops::BitXor<u32x8<S>> for u32 {
2212 type Output = u32x8<S>;
2213 #[inline(always)]
2214 fn bitxor(self, rhs: u32x8<S>) -> Self::Output {
2215 rhs.simd.xor_u32x8(self.simd_into(rhs.simd), rhs)
2216 }
2217}
2218impl<S: Simd> core::ops::BitAnd for mask32x8<S> {
2219 type Output = Self;
2220 #[inline(always)]
2221 fn bitand(self, rhs: Self) -> Self::Output {
2222 self.simd.and_mask32x8(self, rhs)
2223 }
2224}
2225impl<S: Simd> core::ops::BitAnd<i32> for mask32x8<S> {
2226 type Output = Self;
2227 #[inline(always)]
2228 fn bitand(self, rhs: i32) -> Self::Output {
2229 self.simd.and_mask32x8(self, rhs.simd_into(self.simd))
2230 }
2231}
2232impl<S: Simd> core::ops::BitAnd<mask32x8<S>> for i32 {
2233 type Output = mask32x8<S>;
2234 #[inline(always)]
2235 fn bitand(self, rhs: mask32x8<S>) -> Self::Output {
2236 rhs.simd.and_mask32x8(self.simd_into(rhs.simd), rhs)
2237 }
2238}
2239impl<S: Simd> core::ops::BitOr for mask32x8<S> {
2240 type Output = Self;
2241 #[inline(always)]
2242 fn bitor(self, rhs: Self) -> Self::Output {
2243 self.simd.or_mask32x8(self, rhs)
2244 }
2245}
2246impl<S: Simd> core::ops::BitOr<i32> for mask32x8<S> {
2247 type Output = Self;
2248 #[inline(always)]
2249 fn bitor(self, rhs: i32) -> Self::Output {
2250 self.simd.or_mask32x8(self, rhs.simd_into(self.simd))
2251 }
2252}
2253impl<S: Simd> core::ops::BitOr<mask32x8<S>> for i32 {
2254 type Output = mask32x8<S>;
2255 #[inline(always)]
2256 fn bitor(self, rhs: mask32x8<S>) -> Self::Output {
2257 rhs.simd.or_mask32x8(self.simd_into(rhs.simd), rhs)
2258 }
2259}
2260impl<S: Simd> core::ops::BitXor for mask32x8<S> {
2261 type Output = Self;
2262 #[inline(always)]
2263 fn bitxor(self, rhs: Self) -> Self::Output {
2264 self.simd.xor_mask32x8(self, rhs)
2265 }
2266}
2267impl<S: Simd> core::ops::BitXor<i32> for mask32x8<S> {
2268 type Output = Self;
2269 #[inline(always)]
2270 fn bitxor(self, rhs: i32) -> Self::Output {
2271 self.simd.xor_mask32x8(self, rhs.simd_into(self.simd))
2272 }
2273}
2274impl<S: Simd> core::ops::BitXor<mask32x8<S>> for i32 {
2275 type Output = mask32x8<S>;
2276 #[inline(always)]
2277 fn bitxor(self, rhs: mask32x8<S>) -> Self::Output {
2278 rhs.simd.xor_mask32x8(self.simd_into(rhs.simd), rhs)
2279 }
2280}
2281impl<S: Simd> core::ops::Not for mask32x8<S> {
2282 type Output = Self;
2283 #[inline(always)]
2284 fn not(self) -> Self::Output {
2285 self.simd.not_mask32x8(self)
2286 }
2287}
2288impl<S: Simd> core::ops::Neg for f64x4<S> {
2289 type Output = Self;
2290 #[inline(always)]
2291 fn neg(self) -> Self::Output {
2292 self.simd.neg_f64x4(self)
2293 }
2294}
2295impl<S: Simd> core::ops::Add for f64x4<S> {
2296 type Output = Self;
2297 #[inline(always)]
2298 fn add(self, rhs: Self) -> Self::Output {
2299 self.simd.add_f64x4(self, rhs)
2300 }
2301}
2302impl<S: Simd> core::ops::Add<f64> for f64x4<S> {
2303 type Output = Self;
2304 #[inline(always)]
2305 fn add(self, rhs: f64) -> Self::Output {
2306 self.simd.add_f64x4(self, rhs.simd_into(self.simd))
2307 }
2308}
2309impl<S: Simd> core::ops::Add<f64x4<S>> for f64 {
2310 type Output = f64x4<S>;
2311 #[inline(always)]
2312 fn add(self, rhs: f64x4<S>) -> Self::Output {
2313 rhs.simd.add_f64x4(self.simd_into(rhs.simd), rhs)
2314 }
2315}
2316impl<S: Simd> core::ops::Sub for f64x4<S> {
2317 type Output = Self;
2318 #[inline(always)]
2319 fn sub(self, rhs: Self) -> Self::Output {
2320 self.simd.sub_f64x4(self, rhs)
2321 }
2322}
2323impl<S: Simd> core::ops::Sub<f64> for f64x4<S> {
2324 type Output = Self;
2325 #[inline(always)]
2326 fn sub(self, rhs: f64) -> Self::Output {
2327 self.simd.sub_f64x4(self, rhs.simd_into(self.simd))
2328 }
2329}
2330impl<S: Simd> core::ops::Sub<f64x4<S>> for f64 {
2331 type Output = f64x4<S>;
2332 #[inline(always)]
2333 fn sub(self, rhs: f64x4<S>) -> Self::Output {
2334 rhs.simd.sub_f64x4(self.simd_into(rhs.simd), rhs)
2335 }
2336}
2337impl<S: Simd> core::ops::Mul for f64x4<S> {
2338 type Output = Self;
2339 #[inline(always)]
2340 fn mul(self, rhs: Self) -> Self::Output {
2341 self.simd.mul_f64x4(self, rhs)
2342 }
2343}
2344impl<S: Simd> core::ops::Mul<f64> for f64x4<S> {
2345 type Output = Self;
2346 #[inline(always)]
2347 fn mul(self, rhs: f64) -> Self::Output {
2348 self.simd.mul_f64x4(self, rhs.simd_into(self.simd))
2349 }
2350}
2351impl<S: Simd> core::ops::Mul<f64x4<S>> for f64 {
2352 type Output = f64x4<S>;
2353 #[inline(always)]
2354 fn mul(self, rhs: f64x4<S>) -> Self::Output {
2355 rhs.simd.mul_f64x4(self.simd_into(rhs.simd), rhs)
2356 }
2357}
2358impl<S: Simd> core::ops::Div for f64x4<S> {
2359 type Output = Self;
2360 #[inline(always)]
2361 fn div(self, rhs: Self) -> Self::Output {
2362 self.simd.div_f64x4(self, rhs)
2363 }
2364}
2365impl<S: Simd> core::ops::Div<f64> for f64x4<S> {
2366 type Output = Self;
2367 #[inline(always)]
2368 fn div(self, rhs: f64) -> Self::Output {
2369 self.simd.div_f64x4(self, rhs.simd_into(self.simd))
2370 }
2371}
2372impl<S: Simd> core::ops::Div<f64x4<S>> for f64 {
2373 type Output = f64x4<S>;
2374 #[inline(always)]
2375 fn div(self, rhs: f64x4<S>) -> Self::Output {
2376 rhs.simd.div_f64x4(self.simd_into(rhs.simd), rhs)
2377 }
2378}
2379impl<S: Simd> core::ops::BitAnd for mask64x4<S> {
2380 type Output = Self;
2381 #[inline(always)]
2382 fn bitand(self, rhs: Self) -> Self::Output {
2383 self.simd.and_mask64x4(self, rhs)
2384 }
2385}
2386impl<S: Simd> core::ops::BitAnd<i64> for mask64x4<S> {
2387 type Output = Self;
2388 #[inline(always)]
2389 fn bitand(self, rhs: i64) -> Self::Output {
2390 self.simd.and_mask64x4(self, rhs.simd_into(self.simd))
2391 }
2392}
2393impl<S: Simd> core::ops::BitAnd<mask64x4<S>> for i64 {
2394 type Output = mask64x4<S>;
2395 #[inline(always)]
2396 fn bitand(self, rhs: mask64x4<S>) -> Self::Output {
2397 rhs.simd.and_mask64x4(self.simd_into(rhs.simd), rhs)
2398 }
2399}
2400impl<S: Simd> core::ops::BitOr for mask64x4<S> {
2401 type Output = Self;
2402 #[inline(always)]
2403 fn bitor(self, rhs: Self) -> Self::Output {
2404 self.simd.or_mask64x4(self, rhs)
2405 }
2406}
2407impl<S: Simd> core::ops::BitOr<i64> for mask64x4<S> {
2408 type Output = Self;
2409 #[inline(always)]
2410 fn bitor(self, rhs: i64) -> Self::Output {
2411 self.simd.or_mask64x4(self, rhs.simd_into(self.simd))
2412 }
2413}
2414impl<S: Simd> core::ops::BitOr<mask64x4<S>> for i64 {
2415 type Output = mask64x4<S>;
2416 #[inline(always)]
2417 fn bitor(self, rhs: mask64x4<S>) -> Self::Output {
2418 rhs.simd.or_mask64x4(self.simd_into(rhs.simd), rhs)
2419 }
2420}
2421impl<S: Simd> core::ops::BitXor for mask64x4<S> {
2422 type Output = Self;
2423 #[inline(always)]
2424 fn bitxor(self, rhs: Self) -> Self::Output {
2425 self.simd.xor_mask64x4(self, rhs)
2426 }
2427}
2428impl<S: Simd> core::ops::BitXor<i64> for mask64x4<S> {
2429 type Output = Self;
2430 #[inline(always)]
2431 fn bitxor(self, rhs: i64) -> Self::Output {
2432 self.simd.xor_mask64x4(self, rhs.simd_into(self.simd))
2433 }
2434}
2435impl<S: Simd> core::ops::BitXor<mask64x4<S>> for i64 {
2436 type Output = mask64x4<S>;
2437 #[inline(always)]
2438 fn bitxor(self, rhs: mask64x4<S>) -> Self::Output {
2439 rhs.simd.xor_mask64x4(self.simd_into(rhs.simd), rhs)
2440 }
2441}
2442impl<S: Simd> core::ops::Not for mask64x4<S> {
2443 type Output = Self;
2444 #[inline(always)]
2445 fn not(self) -> Self::Output {
2446 self.simd.not_mask64x4(self)
2447 }
2448}
2449impl<S: Simd> core::ops::Neg for f32x16<S> {
2450 type Output = Self;
2451 #[inline(always)]
2452 fn neg(self) -> Self::Output {
2453 self.simd.neg_f32x16(self)
2454 }
2455}
2456impl<S: Simd> core::ops::Add for f32x16<S> {
2457 type Output = Self;
2458 #[inline(always)]
2459 fn add(self, rhs: Self) -> Self::Output {
2460 self.simd.add_f32x16(self, rhs)
2461 }
2462}
2463impl<S: Simd> core::ops::Add<f32> for f32x16<S> {
2464 type Output = Self;
2465 #[inline(always)]
2466 fn add(self, rhs: f32) -> Self::Output {
2467 self.simd.add_f32x16(self, rhs.simd_into(self.simd))
2468 }
2469}
2470impl<S: Simd> core::ops::Add<f32x16<S>> for f32 {
2471 type Output = f32x16<S>;
2472 #[inline(always)]
2473 fn add(self, rhs: f32x16<S>) -> Self::Output {
2474 rhs.simd.add_f32x16(self.simd_into(rhs.simd), rhs)
2475 }
2476}
2477impl<S: Simd> core::ops::Sub for f32x16<S> {
2478 type Output = Self;
2479 #[inline(always)]
2480 fn sub(self, rhs: Self) -> Self::Output {
2481 self.simd.sub_f32x16(self, rhs)
2482 }
2483}
2484impl<S: Simd> core::ops::Sub<f32> for f32x16<S> {
2485 type Output = Self;
2486 #[inline(always)]
2487 fn sub(self, rhs: f32) -> Self::Output {
2488 self.simd.sub_f32x16(self, rhs.simd_into(self.simd))
2489 }
2490}
2491impl<S: Simd> core::ops::Sub<f32x16<S>> for f32 {
2492 type Output = f32x16<S>;
2493 #[inline(always)]
2494 fn sub(self, rhs: f32x16<S>) -> Self::Output {
2495 rhs.simd.sub_f32x16(self.simd_into(rhs.simd), rhs)
2496 }
2497}
2498impl<S: Simd> core::ops::Mul for f32x16<S> {
2499 type Output = Self;
2500 #[inline(always)]
2501 fn mul(self, rhs: Self) -> Self::Output {
2502 self.simd.mul_f32x16(self, rhs)
2503 }
2504}
2505impl<S: Simd> core::ops::Mul<f32> for f32x16<S> {
2506 type Output = Self;
2507 #[inline(always)]
2508 fn mul(self, rhs: f32) -> Self::Output {
2509 self.simd.mul_f32x16(self, rhs.simd_into(self.simd))
2510 }
2511}
2512impl<S: Simd> core::ops::Mul<f32x16<S>> for f32 {
2513 type Output = f32x16<S>;
2514 #[inline(always)]
2515 fn mul(self, rhs: f32x16<S>) -> Self::Output {
2516 rhs.simd.mul_f32x16(self.simd_into(rhs.simd), rhs)
2517 }
2518}
2519impl<S: Simd> core::ops::Div for f32x16<S> {
2520 type Output = Self;
2521 #[inline(always)]
2522 fn div(self, rhs: Self) -> Self::Output {
2523 self.simd.div_f32x16(self, rhs)
2524 }
2525}
2526impl<S: Simd> core::ops::Div<f32> for f32x16<S> {
2527 type Output = Self;
2528 #[inline(always)]
2529 fn div(self, rhs: f32) -> Self::Output {
2530 self.simd.div_f32x16(self, rhs.simd_into(self.simd))
2531 }
2532}
2533impl<S: Simd> core::ops::Div<f32x16<S>> for f32 {
2534 type Output = f32x16<S>;
2535 #[inline(always)]
2536 fn div(self, rhs: f32x16<S>) -> Self::Output {
2537 rhs.simd.div_f32x16(self.simd_into(rhs.simd), rhs)
2538 }
2539}
2540impl<S: Simd> core::ops::Add for i8x64<S> {
2541 type Output = Self;
2542 #[inline(always)]
2543 fn add(self, rhs: Self) -> Self::Output {
2544 self.simd.add_i8x64(self, rhs)
2545 }
2546}
2547impl<S: Simd> core::ops::Add<i8> for i8x64<S> {
2548 type Output = Self;
2549 #[inline(always)]
2550 fn add(self, rhs: i8) -> Self::Output {
2551 self.simd.add_i8x64(self, rhs.simd_into(self.simd))
2552 }
2553}
2554impl<S: Simd> core::ops::Add<i8x64<S>> for i8 {
2555 type Output = i8x64<S>;
2556 #[inline(always)]
2557 fn add(self, rhs: i8x64<S>) -> Self::Output {
2558 rhs.simd.add_i8x64(self.simd_into(rhs.simd), rhs)
2559 }
2560}
2561impl<S: Simd> core::ops::Sub for i8x64<S> {
2562 type Output = Self;
2563 #[inline(always)]
2564 fn sub(self, rhs: Self) -> Self::Output {
2565 self.simd.sub_i8x64(self, rhs)
2566 }
2567}
2568impl<S: Simd> core::ops::Sub<i8> for i8x64<S> {
2569 type Output = Self;
2570 #[inline(always)]
2571 fn sub(self, rhs: i8) -> Self::Output {
2572 self.simd.sub_i8x64(self, rhs.simd_into(self.simd))
2573 }
2574}
2575impl<S: Simd> core::ops::Sub<i8x64<S>> for i8 {
2576 type Output = i8x64<S>;
2577 #[inline(always)]
2578 fn sub(self, rhs: i8x64<S>) -> Self::Output {
2579 rhs.simd.sub_i8x64(self.simd_into(rhs.simd), rhs)
2580 }
2581}
2582impl<S: Simd> core::ops::Mul for i8x64<S> {
2583 type Output = Self;
2584 #[inline(always)]
2585 fn mul(self, rhs: Self) -> Self::Output {
2586 self.simd.mul_i8x64(self, rhs)
2587 }
2588}
2589impl<S: Simd> core::ops::Mul<i8> for i8x64<S> {
2590 type Output = Self;
2591 #[inline(always)]
2592 fn mul(self, rhs: i8) -> Self::Output {
2593 self.simd.mul_i8x64(self, rhs.simd_into(self.simd))
2594 }
2595}
2596impl<S: Simd> core::ops::Mul<i8x64<S>> for i8 {
2597 type Output = i8x64<S>;
2598 #[inline(always)]
2599 fn mul(self, rhs: i8x64<S>) -> Self::Output {
2600 rhs.simd.mul_i8x64(self.simd_into(rhs.simd), rhs)
2601 }
2602}
2603impl<S: Simd> core::ops::BitAnd for i8x64<S> {
2604 type Output = Self;
2605 #[inline(always)]
2606 fn bitand(self, rhs: Self) -> Self::Output {
2607 self.simd.and_i8x64(self, rhs)
2608 }
2609}
2610impl<S: Simd> core::ops::BitAnd<i8> for i8x64<S> {
2611 type Output = Self;
2612 #[inline(always)]
2613 fn bitand(self, rhs: i8) -> Self::Output {
2614 self.simd.and_i8x64(self, rhs.simd_into(self.simd))
2615 }
2616}
2617impl<S: Simd> core::ops::BitAnd<i8x64<S>> for i8 {
2618 type Output = i8x64<S>;
2619 #[inline(always)]
2620 fn bitand(self, rhs: i8x64<S>) -> Self::Output {
2621 rhs.simd.and_i8x64(self.simd_into(rhs.simd), rhs)
2622 }
2623}
2624impl<S: Simd> core::ops::BitOr for i8x64<S> {
2625 type Output = Self;
2626 #[inline(always)]
2627 fn bitor(self, rhs: Self) -> Self::Output {
2628 self.simd.or_i8x64(self, rhs)
2629 }
2630}
2631impl<S: Simd> core::ops::BitOr<i8> for i8x64<S> {
2632 type Output = Self;
2633 #[inline(always)]
2634 fn bitor(self, rhs: i8) -> Self::Output {
2635 self.simd.or_i8x64(self, rhs.simd_into(self.simd))
2636 }
2637}
2638impl<S: Simd> core::ops::BitOr<i8x64<S>> for i8 {
2639 type Output = i8x64<S>;
2640 #[inline(always)]
2641 fn bitor(self, rhs: i8x64<S>) -> Self::Output {
2642 rhs.simd.or_i8x64(self.simd_into(rhs.simd), rhs)
2643 }
2644}
2645impl<S: Simd> core::ops::BitXor for i8x64<S> {
2646 type Output = Self;
2647 #[inline(always)]
2648 fn bitxor(self, rhs: Self) -> Self::Output {
2649 self.simd.xor_i8x64(self, rhs)
2650 }
2651}
2652impl<S: Simd> core::ops::BitXor<i8> for i8x64<S> {
2653 type Output = Self;
2654 #[inline(always)]
2655 fn bitxor(self, rhs: i8) -> Self::Output {
2656 self.simd.xor_i8x64(self, rhs.simd_into(self.simd))
2657 }
2658}
2659impl<S: Simd> core::ops::BitXor<i8x64<S>> for i8 {
2660 type Output = i8x64<S>;
2661 #[inline(always)]
2662 fn bitxor(self, rhs: i8x64<S>) -> Self::Output {
2663 rhs.simd.xor_i8x64(self.simd_into(rhs.simd), rhs)
2664 }
2665}
2666impl<S: Simd> core::ops::Add for u8x64<S> {
2667 type Output = Self;
2668 #[inline(always)]
2669 fn add(self, rhs: Self) -> Self::Output {
2670 self.simd.add_u8x64(self, rhs)
2671 }
2672}
2673impl<S: Simd> core::ops::Add<u8> for u8x64<S> {
2674 type Output = Self;
2675 #[inline(always)]
2676 fn add(self, rhs: u8) -> Self::Output {
2677 self.simd.add_u8x64(self, rhs.simd_into(self.simd))
2678 }
2679}
2680impl<S: Simd> core::ops::Add<u8x64<S>> for u8 {
2681 type Output = u8x64<S>;
2682 #[inline(always)]
2683 fn add(self, rhs: u8x64<S>) -> Self::Output {
2684 rhs.simd.add_u8x64(self.simd_into(rhs.simd), rhs)
2685 }
2686}
2687impl<S: Simd> core::ops::Sub for u8x64<S> {
2688 type Output = Self;
2689 #[inline(always)]
2690 fn sub(self, rhs: Self) -> Self::Output {
2691 self.simd.sub_u8x64(self, rhs)
2692 }
2693}
2694impl<S: Simd> core::ops::Sub<u8> for u8x64<S> {
2695 type Output = Self;
2696 #[inline(always)]
2697 fn sub(self, rhs: u8) -> Self::Output {
2698 self.simd.sub_u8x64(self, rhs.simd_into(self.simd))
2699 }
2700}
2701impl<S: Simd> core::ops::Sub<u8x64<S>> for u8 {
2702 type Output = u8x64<S>;
2703 #[inline(always)]
2704 fn sub(self, rhs: u8x64<S>) -> Self::Output {
2705 rhs.simd.sub_u8x64(self.simd_into(rhs.simd), rhs)
2706 }
2707}
2708impl<S: Simd> core::ops::Mul for u8x64<S> {
2709 type Output = Self;
2710 #[inline(always)]
2711 fn mul(self, rhs: Self) -> Self::Output {
2712 self.simd.mul_u8x64(self, rhs)
2713 }
2714}
2715impl<S: Simd> core::ops::Mul<u8> for u8x64<S> {
2716 type Output = Self;
2717 #[inline(always)]
2718 fn mul(self, rhs: u8) -> Self::Output {
2719 self.simd.mul_u8x64(self, rhs.simd_into(self.simd))
2720 }
2721}
2722impl<S: Simd> core::ops::Mul<u8x64<S>> for u8 {
2723 type Output = u8x64<S>;
2724 #[inline(always)]
2725 fn mul(self, rhs: u8x64<S>) -> Self::Output {
2726 rhs.simd.mul_u8x64(self.simd_into(rhs.simd), rhs)
2727 }
2728}
2729impl<S: Simd> core::ops::BitAnd for u8x64<S> {
2730 type Output = Self;
2731 #[inline(always)]
2732 fn bitand(self, rhs: Self) -> Self::Output {
2733 self.simd.and_u8x64(self, rhs)
2734 }
2735}
2736impl<S: Simd> core::ops::BitAnd<u8> for u8x64<S> {
2737 type Output = Self;
2738 #[inline(always)]
2739 fn bitand(self, rhs: u8) -> Self::Output {
2740 self.simd.and_u8x64(self, rhs.simd_into(self.simd))
2741 }
2742}
2743impl<S: Simd> core::ops::BitAnd<u8x64<S>> for u8 {
2744 type Output = u8x64<S>;
2745 #[inline(always)]
2746 fn bitand(self, rhs: u8x64<S>) -> Self::Output {
2747 rhs.simd.and_u8x64(self.simd_into(rhs.simd), rhs)
2748 }
2749}
2750impl<S: Simd> core::ops::BitOr for u8x64<S> {
2751 type Output = Self;
2752 #[inline(always)]
2753 fn bitor(self, rhs: Self) -> Self::Output {
2754 self.simd.or_u8x64(self, rhs)
2755 }
2756}
2757impl<S: Simd> core::ops::BitOr<u8> for u8x64<S> {
2758 type Output = Self;
2759 #[inline(always)]
2760 fn bitor(self, rhs: u8) -> Self::Output {
2761 self.simd.or_u8x64(self, rhs.simd_into(self.simd))
2762 }
2763}
2764impl<S: Simd> core::ops::BitOr<u8x64<S>> for u8 {
2765 type Output = u8x64<S>;
2766 #[inline(always)]
2767 fn bitor(self, rhs: u8x64<S>) -> Self::Output {
2768 rhs.simd.or_u8x64(self.simd_into(rhs.simd), rhs)
2769 }
2770}
2771impl<S: Simd> core::ops::BitXor for u8x64<S> {
2772 type Output = Self;
2773 #[inline(always)]
2774 fn bitxor(self, rhs: Self) -> Self::Output {
2775 self.simd.xor_u8x64(self, rhs)
2776 }
2777}
2778impl<S: Simd> core::ops::BitXor<u8> for u8x64<S> {
2779 type Output = Self;
2780 #[inline(always)]
2781 fn bitxor(self, rhs: u8) -> Self::Output {
2782 self.simd.xor_u8x64(self, rhs.simd_into(self.simd))
2783 }
2784}
2785impl<S: Simd> core::ops::BitXor<u8x64<S>> for u8 {
2786 type Output = u8x64<S>;
2787 #[inline(always)]
2788 fn bitxor(self, rhs: u8x64<S>) -> Self::Output {
2789 rhs.simd.xor_u8x64(self.simd_into(rhs.simd), rhs)
2790 }
2791}
2792impl<S: Simd> core::ops::BitAnd for mask8x64<S> {
2793 type Output = Self;
2794 #[inline(always)]
2795 fn bitand(self, rhs: Self) -> Self::Output {
2796 self.simd.and_mask8x64(self, rhs)
2797 }
2798}
2799impl<S: Simd> core::ops::BitAnd<i8> for mask8x64<S> {
2800 type Output = Self;
2801 #[inline(always)]
2802 fn bitand(self, rhs: i8) -> Self::Output {
2803 self.simd.and_mask8x64(self, rhs.simd_into(self.simd))
2804 }
2805}
2806impl<S: Simd> core::ops::BitAnd<mask8x64<S>> for i8 {
2807 type Output = mask8x64<S>;
2808 #[inline(always)]
2809 fn bitand(self, rhs: mask8x64<S>) -> Self::Output {
2810 rhs.simd.and_mask8x64(self.simd_into(rhs.simd), rhs)
2811 }
2812}
2813impl<S: Simd> core::ops::BitOr for mask8x64<S> {
2814 type Output = Self;
2815 #[inline(always)]
2816 fn bitor(self, rhs: Self) -> Self::Output {
2817 self.simd.or_mask8x64(self, rhs)
2818 }
2819}
2820impl<S: Simd> core::ops::BitOr<i8> for mask8x64<S> {
2821 type Output = Self;
2822 #[inline(always)]
2823 fn bitor(self, rhs: i8) -> Self::Output {
2824 self.simd.or_mask8x64(self, rhs.simd_into(self.simd))
2825 }
2826}
2827impl<S: Simd> core::ops::BitOr<mask8x64<S>> for i8 {
2828 type Output = mask8x64<S>;
2829 #[inline(always)]
2830 fn bitor(self, rhs: mask8x64<S>) -> Self::Output {
2831 rhs.simd.or_mask8x64(self.simd_into(rhs.simd), rhs)
2832 }
2833}
2834impl<S: Simd> core::ops::BitXor for mask8x64<S> {
2835 type Output = Self;
2836 #[inline(always)]
2837 fn bitxor(self, rhs: Self) -> Self::Output {
2838 self.simd.xor_mask8x64(self, rhs)
2839 }
2840}
2841impl<S: Simd> core::ops::BitXor<i8> for mask8x64<S> {
2842 type Output = Self;
2843 #[inline(always)]
2844 fn bitxor(self, rhs: i8) -> Self::Output {
2845 self.simd.xor_mask8x64(self, rhs.simd_into(self.simd))
2846 }
2847}
2848impl<S: Simd> core::ops::BitXor<mask8x64<S>> for i8 {
2849 type Output = mask8x64<S>;
2850 #[inline(always)]
2851 fn bitxor(self, rhs: mask8x64<S>) -> Self::Output {
2852 rhs.simd.xor_mask8x64(self.simd_into(rhs.simd), rhs)
2853 }
2854}
2855impl<S: Simd> core::ops::Not for mask8x64<S> {
2856 type Output = Self;
2857 #[inline(always)]
2858 fn not(self) -> Self::Output {
2859 self.simd.not_mask8x64(self)
2860 }
2861}
2862impl<S: Simd> core::ops::Add for i16x32<S> {
2863 type Output = Self;
2864 #[inline(always)]
2865 fn add(self, rhs: Self) -> Self::Output {
2866 self.simd.add_i16x32(self, rhs)
2867 }
2868}
2869impl<S: Simd> core::ops::Add<i16> for i16x32<S> {
2870 type Output = Self;
2871 #[inline(always)]
2872 fn add(self, rhs: i16) -> Self::Output {
2873 self.simd.add_i16x32(self, rhs.simd_into(self.simd))
2874 }
2875}
2876impl<S: Simd> core::ops::Add<i16x32<S>> for i16 {
2877 type Output = i16x32<S>;
2878 #[inline(always)]
2879 fn add(self, rhs: i16x32<S>) -> Self::Output {
2880 rhs.simd.add_i16x32(self.simd_into(rhs.simd), rhs)
2881 }
2882}
2883impl<S: Simd> core::ops::Sub for i16x32<S> {
2884 type Output = Self;
2885 #[inline(always)]
2886 fn sub(self, rhs: Self) -> Self::Output {
2887 self.simd.sub_i16x32(self, rhs)
2888 }
2889}
2890impl<S: Simd> core::ops::Sub<i16> for i16x32<S> {
2891 type Output = Self;
2892 #[inline(always)]
2893 fn sub(self, rhs: i16) -> Self::Output {
2894 self.simd.sub_i16x32(self, rhs.simd_into(self.simd))
2895 }
2896}
2897impl<S: Simd> core::ops::Sub<i16x32<S>> for i16 {
2898 type Output = i16x32<S>;
2899 #[inline(always)]
2900 fn sub(self, rhs: i16x32<S>) -> Self::Output {
2901 rhs.simd.sub_i16x32(self.simd_into(rhs.simd), rhs)
2902 }
2903}
2904impl<S: Simd> core::ops::Mul for i16x32<S> {
2905 type Output = Self;
2906 #[inline(always)]
2907 fn mul(self, rhs: Self) -> Self::Output {
2908 self.simd.mul_i16x32(self, rhs)
2909 }
2910}
2911impl<S: Simd> core::ops::Mul<i16> for i16x32<S> {
2912 type Output = Self;
2913 #[inline(always)]
2914 fn mul(self, rhs: i16) -> Self::Output {
2915 self.simd.mul_i16x32(self, rhs.simd_into(self.simd))
2916 }
2917}
2918impl<S: Simd> core::ops::Mul<i16x32<S>> for i16 {
2919 type Output = i16x32<S>;
2920 #[inline(always)]
2921 fn mul(self, rhs: i16x32<S>) -> Self::Output {
2922 rhs.simd.mul_i16x32(self.simd_into(rhs.simd), rhs)
2923 }
2924}
2925impl<S: Simd> core::ops::BitAnd for i16x32<S> {
2926 type Output = Self;
2927 #[inline(always)]
2928 fn bitand(self, rhs: Self) -> Self::Output {
2929 self.simd.and_i16x32(self, rhs)
2930 }
2931}
2932impl<S: Simd> core::ops::BitAnd<i16> for i16x32<S> {
2933 type Output = Self;
2934 #[inline(always)]
2935 fn bitand(self, rhs: i16) -> Self::Output {
2936 self.simd.and_i16x32(self, rhs.simd_into(self.simd))
2937 }
2938}
2939impl<S: Simd> core::ops::BitAnd<i16x32<S>> for i16 {
2940 type Output = i16x32<S>;
2941 #[inline(always)]
2942 fn bitand(self, rhs: i16x32<S>) -> Self::Output {
2943 rhs.simd.and_i16x32(self.simd_into(rhs.simd), rhs)
2944 }
2945}
2946impl<S: Simd> core::ops::BitOr for i16x32<S> {
2947 type Output = Self;
2948 #[inline(always)]
2949 fn bitor(self, rhs: Self) -> Self::Output {
2950 self.simd.or_i16x32(self, rhs)
2951 }
2952}
2953impl<S: Simd> core::ops::BitOr<i16> for i16x32<S> {
2954 type Output = Self;
2955 #[inline(always)]
2956 fn bitor(self, rhs: i16) -> Self::Output {
2957 self.simd.or_i16x32(self, rhs.simd_into(self.simd))
2958 }
2959}
2960impl<S: Simd> core::ops::BitOr<i16x32<S>> for i16 {
2961 type Output = i16x32<S>;
2962 #[inline(always)]
2963 fn bitor(self, rhs: i16x32<S>) -> Self::Output {
2964 rhs.simd.or_i16x32(self.simd_into(rhs.simd), rhs)
2965 }
2966}
2967impl<S: Simd> core::ops::BitXor for i16x32<S> {
2968 type Output = Self;
2969 #[inline(always)]
2970 fn bitxor(self, rhs: Self) -> Self::Output {
2971 self.simd.xor_i16x32(self, rhs)
2972 }
2973}
2974impl<S: Simd> core::ops::BitXor<i16> for i16x32<S> {
2975 type Output = Self;
2976 #[inline(always)]
2977 fn bitxor(self, rhs: i16) -> Self::Output {
2978 self.simd.xor_i16x32(self, rhs.simd_into(self.simd))
2979 }
2980}
2981impl<S: Simd> core::ops::BitXor<i16x32<S>> for i16 {
2982 type Output = i16x32<S>;
2983 #[inline(always)]
2984 fn bitxor(self, rhs: i16x32<S>) -> Self::Output {
2985 rhs.simd.xor_i16x32(self.simd_into(rhs.simd), rhs)
2986 }
2987}
2988impl<S: Simd> core::ops::Add for u16x32<S> {
2989 type Output = Self;
2990 #[inline(always)]
2991 fn add(self, rhs: Self) -> Self::Output {
2992 self.simd.add_u16x32(self, rhs)
2993 }
2994}
2995impl<S: Simd> core::ops::Add<u16> for u16x32<S> {
2996 type Output = Self;
2997 #[inline(always)]
2998 fn add(self, rhs: u16) -> Self::Output {
2999 self.simd.add_u16x32(self, rhs.simd_into(self.simd))
3000 }
3001}
3002impl<S: Simd> core::ops::Add<u16x32<S>> for u16 {
3003 type Output = u16x32<S>;
3004 #[inline(always)]
3005 fn add(self, rhs: u16x32<S>) -> Self::Output {
3006 rhs.simd.add_u16x32(self.simd_into(rhs.simd), rhs)
3007 }
3008}
3009impl<S: Simd> core::ops::Sub for u16x32<S> {
3010 type Output = Self;
3011 #[inline(always)]
3012 fn sub(self, rhs: Self) -> Self::Output {
3013 self.simd.sub_u16x32(self, rhs)
3014 }
3015}
3016impl<S: Simd> core::ops::Sub<u16> for u16x32<S> {
3017 type Output = Self;
3018 #[inline(always)]
3019 fn sub(self, rhs: u16) -> Self::Output {
3020 self.simd.sub_u16x32(self, rhs.simd_into(self.simd))
3021 }
3022}
3023impl<S: Simd> core::ops::Sub<u16x32<S>> for u16 {
3024 type Output = u16x32<S>;
3025 #[inline(always)]
3026 fn sub(self, rhs: u16x32<S>) -> Self::Output {
3027 rhs.simd.sub_u16x32(self.simd_into(rhs.simd), rhs)
3028 }
3029}
3030impl<S: Simd> core::ops::Mul for u16x32<S> {
3031 type Output = Self;
3032 #[inline(always)]
3033 fn mul(self, rhs: Self) -> Self::Output {
3034 self.simd.mul_u16x32(self, rhs)
3035 }
3036}
3037impl<S: Simd> core::ops::Mul<u16> for u16x32<S> {
3038 type Output = Self;
3039 #[inline(always)]
3040 fn mul(self, rhs: u16) -> Self::Output {
3041 self.simd.mul_u16x32(self, rhs.simd_into(self.simd))
3042 }
3043}
3044impl<S: Simd> core::ops::Mul<u16x32<S>> for u16 {
3045 type Output = u16x32<S>;
3046 #[inline(always)]
3047 fn mul(self, rhs: u16x32<S>) -> Self::Output {
3048 rhs.simd.mul_u16x32(self.simd_into(rhs.simd), rhs)
3049 }
3050}
3051impl<S: Simd> core::ops::BitAnd for u16x32<S> {
3052 type Output = Self;
3053 #[inline(always)]
3054 fn bitand(self, rhs: Self) -> Self::Output {
3055 self.simd.and_u16x32(self, rhs)
3056 }
3057}
3058impl<S: Simd> core::ops::BitAnd<u16> for u16x32<S> {
3059 type Output = Self;
3060 #[inline(always)]
3061 fn bitand(self, rhs: u16) -> Self::Output {
3062 self.simd.and_u16x32(self, rhs.simd_into(self.simd))
3063 }
3064}
3065impl<S: Simd> core::ops::BitAnd<u16x32<S>> for u16 {
3066 type Output = u16x32<S>;
3067 #[inline(always)]
3068 fn bitand(self, rhs: u16x32<S>) -> Self::Output {
3069 rhs.simd.and_u16x32(self.simd_into(rhs.simd), rhs)
3070 }
3071}
3072impl<S: Simd> core::ops::BitOr for u16x32<S> {
3073 type Output = Self;
3074 #[inline(always)]
3075 fn bitor(self, rhs: Self) -> Self::Output {
3076 self.simd.or_u16x32(self, rhs)
3077 }
3078}
3079impl<S: Simd> core::ops::BitOr<u16> for u16x32<S> {
3080 type Output = Self;
3081 #[inline(always)]
3082 fn bitor(self, rhs: u16) -> Self::Output {
3083 self.simd.or_u16x32(self, rhs.simd_into(self.simd))
3084 }
3085}
3086impl<S: Simd> core::ops::BitOr<u16x32<S>> for u16 {
3087 type Output = u16x32<S>;
3088 #[inline(always)]
3089 fn bitor(self, rhs: u16x32<S>) -> Self::Output {
3090 rhs.simd.or_u16x32(self.simd_into(rhs.simd), rhs)
3091 }
3092}
3093impl<S: Simd> core::ops::BitXor for u16x32<S> {
3094 type Output = Self;
3095 #[inline(always)]
3096 fn bitxor(self, rhs: Self) -> Self::Output {
3097 self.simd.xor_u16x32(self, rhs)
3098 }
3099}
3100impl<S: Simd> core::ops::BitXor<u16> for u16x32<S> {
3101 type Output = Self;
3102 #[inline(always)]
3103 fn bitxor(self, rhs: u16) -> Self::Output {
3104 self.simd.xor_u16x32(self, rhs.simd_into(self.simd))
3105 }
3106}
3107impl<S: Simd> core::ops::BitXor<u16x32<S>> for u16 {
3108 type Output = u16x32<S>;
3109 #[inline(always)]
3110 fn bitxor(self, rhs: u16x32<S>) -> Self::Output {
3111 rhs.simd.xor_u16x32(self.simd_into(rhs.simd), rhs)
3112 }
3113}
3114impl<S: Simd> core::ops::BitAnd for mask16x32<S> {
3115 type Output = Self;
3116 #[inline(always)]
3117 fn bitand(self, rhs: Self) -> Self::Output {
3118 self.simd.and_mask16x32(self, rhs)
3119 }
3120}
3121impl<S: Simd> core::ops::BitAnd<i16> for mask16x32<S> {
3122 type Output = Self;
3123 #[inline(always)]
3124 fn bitand(self, rhs: i16) -> Self::Output {
3125 self.simd.and_mask16x32(self, rhs.simd_into(self.simd))
3126 }
3127}
3128impl<S: Simd> core::ops::BitAnd<mask16x32<S>> for i16 {
3129 type Output = mask16x32<S>;
3130 #[inline(always)]
3131 fn bitand(self, rhs: mask16x32<S>) -> Self::Output {
3132 rhs.simd.and_mask16x32(self.simd_into(rhs.simd), rhs)
3133 }
3134}
3135impl<S: Simd> core::ops::BitOr for mask16x32<S> {
3136 type Output = Self;
3137 #[inline(always)]
3138 fn bitor(self, rhs: Self) -> Self::Output {
3139 self.simd.or_mask16x32(self, rhs)
3140 }
3141}
3142impl<S: Simd> core::ops::BitOr<i16> for mask16x32<S> {
3143 type Output = Self;
3144 #[inline(always)]
3145 fn bitor(self, rhs: i16) -> Self::Output {
3146 self.simd.or_mask16x32(self, rhs.simd_into(self.simd))
3147 }
3148}
3149impl<S: Simd> core::ops::BitOr<mask16x32<S>> for i16 {
3150 type Output = mask16x32<S>;
3151 #[inline(always)]
3152 fn bitor(self, rhs: mask16x32<S>) -> Self::Output {
3153 rhs.simd.or_mask16x32(self.simd_into(rhs.simd), rhs)
3154 }
3155}
3156impl<S: Simd> core::ops::BitXor for mask16x32<S> {
3157 type Output = Self;
3158 #[inline(always)]
3159 fn bitxor(self, rhs: Self) -> Self::Output {
3160 self.simd.xor_mask16x32(self, rhs)
3161 }
3162}
3163impl<S: Simd> core::ops::BitXor<i16> for mask16x32<S> {
3164 type Output = Self;
3165 #[inline(always)]
3166 fn bitxor(self, rhs: i16) -> Self::Output {
3167 self.simd.xor_mask16x32(self, rhs.simd_into(self.simd))
3168 }
3169}
3170impl<S: Simd> core::ops::BitXor<mask16x32<S>> for i16 {
3171 type Output = mask16x32<S>;
3172 #[inline(always)]
3173 fn bitxor(self, rhs: mask16x32<S>) -> Self::Output {
3174 rhs.simd.xor_mask16x32(self.simd_into(rhs.simd), rhs)
3175 }
3176}
3177impl<S: Simd> core::ops::Not for mask16x32<S> {
3178 type Output = Self;
3179 #[inline(always)]
3180 fn not(self) -> Self::Output {
3181 self.simd.not_mask16x32(self)
3182 }
3183}
3184impl<S: Simd> core::ops::Add for i32x16<S> {
3185 type Output = Self;
3186 #[inline(always)]
3187 fn add(self, rhs: Self) -> Self::Output {
3188 self.simd.add_i32x16(self, rhs)
3189 }
3190}
3191impl<S: Simd> core::ops::Add<i32> for i32x16<S> {
3192 type Output = Self;
3193 #[inline(always)]
3194 fn add(self, rhs: i32) -> Self::Output {
3195 self.simd.add_i32x16(self, rhs.simd_into(self.simd))
3196 }
3197}
3198impl<S: Simd> core::ops::Add<i32x16<S>> for i32 {
3199 type Output = i32x16<S>;
3200 #[inline(always)]
3201 fn add(self, rhs: i32x16<S>) -> Self::Output {
3202 rhs.simd.add_i32x16(self.simd_into(rhs.simd), rhs)
3203 }
3204}
3205impl<S: Simd> core::ops::Sub for i32x16<S> {
3206 type Output = Self;
3207 #[inline(always)]
3208 fn sub(self, rhs: Self) -> Self::Output {
3209 self.simd.sub_i32x16(self, rhs)
3210 }
3211}
3212impl<S: Simd> core::ops::Sub<i32> for i32x16<S> {
3213 type Output = Self;
3214 #[inline(always)]
3215 fn sub(self, rhs: i32) -> Self::Output {
3216 self.simd.sub_i32x16(self, rhs.simd_into(self.simd))
3217 }
3218}
3219impl<S: Simd> core::ops::Sub<i32x16<S>> for i32 {
3220 type Output = i32x16<S>;
3221 #[inline(always)]
3222 fn sub(self, rhs: i32x16<S>) -> Self::Output {
3223 rhs.simd.sub_i32x16(self.simd_into(rhs.simd), rhs)
3224 }
3225}
3226impl<S: Simd> core::ops::Mul for i32x16<S> {
3227 type Output = Self;
3228 #[inline(always)]
3229 fn mul(self, rhs: Self) -> Self::Output {
3230 self.simd.mul_i32x16(self, rhs)
3231 }
3232}
3233impl<S: Simd> core::ops::Mul<i32> for i32x16<S> {
3234 type Output = Self;
3235 #[inline(always)]
3236 fn mul(self, rhs: i32) -> Self::Output {
3237 self.simd.mul_i32x16(self, rhs.simd_into(self.simd))
3238 }
3239}
3240impl<S: Simd> core::ops::Mul<i32x16<S>> for i32 {
3241 type Output = i32x16<S>;
3242 #[inline(always)]
3243 fn mul(self, rhs: i32x16<S>) -> Self::Output {
3244 rhs.simd.mul_i32x16(self.simd_into(rhs.simd), rhs)
3245 }
3246}
3247impl<S: Simd> core::ops::BitAnd for i32x16<S> {
3248 type Output = Self;
3249 #[inline(always)]
3250 fn bitand(self, rhs: Self) -> Self::Output {
3251 self.simd.and_i32x16(self, rhs)
3252 }
3253}
3254impl<S: Simd> core::ops::BitAnd<i32> for i32x16<S> {
3255 type Output = Self;
3256 #[inline(always)]
3257 fn bitand(self, rhs: i32) -> Self::Output {
3258 self.simd.and_i32x16(self, rhs.simd_into(self.simd))
3259 }
3260}
3261impl<S: Simd> core::ops::BitAnd<i32x16<S>> for i32 {
3262 type Output = i32x16<S>;
3263 #[inline(always)]
3264 fn bitand(self, rhs: i32x16<S>) -> Self::Output {
3265 rhs.simd.and_i32x16(self.simd_into(rhs.simd), rhs)
3266 }
3267}
3268impl<S: Simd> core::ops::BitOr for i32x16<S> {
3269 type Output = Self;
3270 #[inline(always)]
3271 fn bitor(self, rhs: Self) -> Self::Output {
3272 self.simd.or_i32x16(self, rhs)
3273 }
3274}
3275impl<S: Simd> core::ops::BitOr<i32> for i32x16<S> {
3276 type Output = Self;
3277 #[inline(always)]
3278 fn bitor(self, rhs: i32) -> Self::Output {
3279 self.simd.or_i32x16(self, rhs.simd_into(self.simd))
3280 }
3281}
3282impl<S: Simd> core::ops::BitOr<i32x16<S>> for i32 {
3283 type Output = i32x16<S>;
3284 #[inline(always)]
3285 fn bitor(self, rhs: i32x16<S>) -> Self::Output {
3286 rhs.simd.or_i32x16(self.simd_into(rhs.simd), rhs)
3287 }
3288}
3289impl<S: Simd> core::ops::BitXor for i32x16<S> {
3290 type Output = Self;
3291 #[inline(always)]
3292 fn bitxor(self, rhs: Self) -> Self::Output {
3293 self.simd.xor_i32x16(self, rhs)
3294 }
3295}
3296impl<S: Simd> core::ops::BitXor<i32> for i32x16<S> {
3297 type Output = Self;
3298 #[inline(always)]
3299 fn bitxor(self, rhs: i32) -> Self::Output {
3300 self.simd.xor_i32x16(self, rhs.simd_into(self.simd))
3301 }
3302}
3303impl<S: Simd> core::ops::BitXor<i32x16<S>> for i32 {
3304 type Output = i32x16<S>;
3305 #[inline(always)]
3306 fn bitxor(self, rhs: i32x16<S>) -> Self::Output {
3307 rhs.simd.xor_i32x16(self.simd_into(rhs.simd), rhs)
3308 }
3309}
3310impl<S: Simd> core::ops::Add for u32x16<S> {
3311 type Output = Self;
3312 #[inline(always)]
3313 fn add(self, rhs: Self) -> Self::Output {
3314 self.simd.add_u32x16(self, rhs)
3315 }
3316}
3317impl<S: Simd> core::ops::Add<u32> for u32x16<S> {
3318 type Output = Self;
3319 #[inline(always)]
3320 fn add(self, rhs: u32) -> Self::Output {
3321 self.simd.add_u32x16(self, rhs.simd_into(self.simd))
3322 }
3323}
3324impl<S: Simd> core::ops::Add<u32x16<S>> for u32 {
3325 type Output = u32x16<S>;
3326 #[inline(always)]
3327 fn add(self, rhs: u32x16<S>) -> Self::Output {
3328 rhs.simd.add_u32x16(self.simd_into(rhs.simd), rhs)
3329 }
3330}
3331impl<S: Simd> core::ops::Sub for u32x16<S> {
3332 type Output = Self;
3333 #[inline(always)]
3334 fn sub(self, rhs: Self) -> Self::Output {
3335 self.simd.sub_u32x16(self, rhs)
3336 }
3337}
3338impl<S: Simd> core::ops::Sub<u32> for u32x16<S> {
3339 type Output = Self;
3340 #[inline(always)]
3341 fn sub(self, rhs: u32) -> Self::Output {
3342 self.simd.sub_u32x16(self, rhs.simd_into(self.simd))
3343 }
3344}
3345impl<S: Simd> core::ops::Sub<u32x16<S>> for u32 {
3346 type Output = u32x16<S>;
3347 #[inline(always)]
3348 fn sub(self, rhs: u32x16<S>) -> Self::Output {
3349 rhs.simd.sub_u32x16(self.simd_into(rhs.simd), rhs)
3350 }
3351}
3352impl<S: Simd> core::ops::Mul for u32x16<S> {
3353 type Output = Self;
3354 #[inline(always)]
3355 fn mul(self, rhs: Self) -> Self::Output {
3356 self.simd.mul_u32x16(self, rhs)
3357 }
3358}
3359impl<S: Simd> core::ops::Mul<u32> for u32x16<S> {
3360 type Output = Self;
3361 #[inline(always)]
3362 fn mul(self, rhs: u32) -> Self::Output {
3363 self.simd.mul_u32x16(self, rhs.simd_into(self.simd))
3364 }
3365}
3366impl<S: Simd> core::ops::Mul<u32x16<S>> for u32 {
3367 type Output = u32x16<S>;
3368 #[inline(always)]
3369 fn mul(self, rhs: u32x16<S>) -> Self::Output {
3370 rhs.simd.mul_u32x16(self.simd_into(rhs.simd), rhs)
3371 }
3372}
3373impl<S: Simd> core::ops::BitAnd for u32x16<S> {
3374 type Output = Self;
3375 #[inline(always)]
3376 fn bitand(self, rhs: Self) -> Self::Output {
3377 self.simd.and_u32x16(self, rhs)
3378 }
3379}
3380impl<S: Simd> core::ops::BitAnd<u32> for u32x16<S> {
3381 type Output = Self;
3382 #[inline(always)]
3383 fn bitand(self, rhs: u32) -> Self::Output {
3384 self.simd.and_u32x16(self, rhs.simd_into(self.simd))
3385 }
3386}
3387impl<S: Simd> core::ops::BitAnd<u32x16<S>> for u32 {
3388 type Output = u32x16<S>;
3389 #[inline(always)]
3390 fn bitand(self, rhs: u32x16<S>) -> Self::Output {
3391 rhs.simd.and_u32x16(self.simd_into(rhs.simd), rhs)
3392 }
3393}
3394impl<S: Simd> core::ops::BitOr for u32x16<S> {
3395 type Output = Self;
3396 #[inline(always)]
3397 fn bitor(self, rhs: Self) -> Self::Output {
3398 self.simd.or_u32x16(self, rhs)
3399 }
3400}
3401impl<S: Simd> core::ops::BitOr<u32> for u32x16<S> {
3402 type Output = Self;
3403 #[inline(always)]
3404 fn bitor(self, rhs: u32) -> Self::Output {
3405 self.simd.or_u32x16(self, rhs.simd_into(self.simd))
3406 }
3407}
3408impl<S: Simd> core::ops::BitOr<u32x16<S>> for u32 {
3409 type Output = u32x16<S>;
3410 #[inline(always)]
3411 fn bitor(self, rhs: u32x16<S>) -> Self::Output {
3412 rhs.simd.or_u32x16(self.simd_into(rhs.simd), rhs)
3413 }
3414}
3415impl<S: Simd> core::ops::BitXor for u32x16<S> {
3416 type Output = Self;
3417 #[inline(always)]
3418 fn bitxor(self, rhs: Self) -> Self::Output {
3419 self.simd.xor_u32x16(self, rhs)
3420 }
3421}
3422impl<S: Simd> core::ops::BitXor<u32> for u32x16<S> {
3423 type Output = Self;
3424 #[inline(always)]
3425 fn bitxor(self, rhs: u32) -> Self::Output {
3426 self.simd.xor_u32x16(self, rhs.simd_into(self.simd))
3427 }
3428}
3429impl<S: Simd> core::ops::BitXor<u32x16<S>> for u32 {
3430 type Output = u32x16<S>;
3431 #[inline(always)]
3432 fn bitxor(self, rhs: u32x16<S>) -> Self::Output {
3433 rhs.simd.xor_u32x16(self.simd_into(rhs.simd), rhs)
3434 }
3435}
3436impl<S: Simd> core::ops::BitAnd for mask32x16<S> {
3437 type Output = Self;
3438 #[inline(always)]
3439 fn bitand(self, rhs: Self) -> Self::Output {
3440 self.simd.and_mask32x16(self, rhs)
3441 }
3442}
3443impl<S: Simd> core::ops::BitAnd<i32> for mask32x16<S> {
3444 type Output = Self;
3445 #[inline(always)]
3446 fn bitand(self, rhs: i32) -> Self::Output {
3447 self.simd.and_mask32x16(self, rhs.simd_into(self.simd))
3448 }
3449}
3450impl<S: Simd> core::ops::BitAnd<mask32x16<S>> for i32 {
3451 type Output = mask32x16<S>;
3452 #[inline(always)]
3453 fn bitand(self, rhs: mask32x16<S>) -> Self::Output {
3454 rhs.simd.and_mask32x16(self.simd_into(rhs.simd), rhs)
3455 }
3456}
3457impl<S: Simd> core::ops::BitOr for mask32x16<S> {
3458 type Output = Self;
3459 #[inline(always)]
3460 fn bitor(self, rhs: Self) -> Self::Output {
3461 self.simd.or_mask32x16(self, rhs)
3462 }
3463}
3464impl<S: Simd> core::ops::BitOr<i32> for mask32x16<S> {
3465 type Output = Self;
3466 #[inline(always)]
3467 fn bitor(self, rhs: i32) -> Self::Output {
3468 self.simd.or_mask32x16(self, rhs.simd_into(self.simd))
3469 }
3470}
3471impl<S: Simd> core::ops::BitOr<mask32x16<S>> for i32 {
3472 type Output = mask32x16<S>;
3473 #[inline(always)]
3474 fn bitor(self, rhs: mask32x16<S>) -> Self::Output {
3475 rhs.simd.or_mask32x16(self.simd_into(rhs.simd), rhs)
3476 }
3477}
3478impl<S: Simd> core::ops::BitXor for mask32x16<S> {
3479 type Output = Self;
3480 #[inline(always)]
3481 fn bitxor(self, rhs: Self) -> Self::Output {
3482 self.simd.xor_mask32x16(self, rhs)
3483 }
3484}
3485impl<S: Simd> core::ops::BitXor<i32> for mask32x16<S> {
3486 type Output = Self;
3487 #[inline(always)]
3488 fn bitxor(self, rhs: i32) -> Self::Output {
3489 self.simd.xor_mask32x16(self, rhs.simd_into(self.simd))
3490 }
3491}
3492impl<S: Simd> core::ops::BitXor<mask32x16<S>> for i32 {
3493 type Output = mask32x16<S>;
3494 #[inline(always)]
3495 fn bitxor(self, rhs: mask32x16<S>) -> Self::Output {
3496 rhs.simd.xor_mask32x16(self.simd_into(rhs.simd), rhs)
3497 }
3498}
3499impl<S: Simd> core::ops::Not for mask32x16<S> {
3500 type Output = Self;
3501 #[inline(always)]
3502 fn not(self) -> Self::Output {
3503 self.simd.not_mask32x16(self)
3504 }
3505}
3506impl<S: Simd> core::ops::Neg for f64x8<S> {
3507 type Output = Self;
3508 #[inline(always)]
3509 fn neg(self) -> Self::Output {
3510 self.simd.neg_f64x8(self)
3511 }
3512}
3513impl<S: Simd> core::ops::Add for f64x8<S> {
3514 type Output = Self;
3515 #[inline(always)]
3516 fn add(self, rhs: Self) -> Self::Output {
3517 self.simd.add_f64x8(self, rhs)
3518 }
3519}
3520impl<S: Simd> core::ops::Add<f64> for f64x8<S> {
3521 type Output = Self;
3522 #[inline(always)]
3523 fn add(self, rhs: f64) -> Self::Output {
3524 self.simd.add_f64x8(self, rhs.simd_into(self.simd))
3525 }
3526}
3527impl<S: Simd> core::ops::Add<f64x8<S>> for f64 {
3528 type Output = f64x8<S>;
3529 #[inline(always)]
3530 fn add(self, rhs: f64x8<S>) -> Self::Output {
3531 rhs.simd.add_f64x8(self.simd_into(rhs.simd), rhs)
3532 }
3533}
3534impl<S: Simd> core::ops::Sub for f64x8<S> {
3535 type Output = Self;
3536 #[inline(always)]
3537 fn sub(self, rhs: Self) -> Self::Output {
3538 self.simd.sub_f64x8(self, rhs)
3539 }
3540}
3541impl<S: Simd> core::ops::Sub<f64> for f64x8<S> {
3542 type Output = Self;
3543 #[inline(always)]
3544 fn sub(self, rhs: f64) -> Self::Output {
3545 self.simd.sub_f64x8(self, rhs.simd_into(self.simd))
3546 }
3547}
3548impl<S: Simd> core::ops::Sub<f64x8<S>> for f64 {
3549 type Output = f64x8<S>;
3550 #[inline(always)]
3551 fn sub(self, rhs: f64x8<S>) -> Self::Output {
3552 rhs.simd.sub_f64x8(self.simd_into(rhs.simd), rhs)
3553 }
3554}
3555impl<S: Simd> core::ops::Mul for f64x8<S> {
3556 type Output = Self;
3557 #[inline(always)]
3558 fn mul(self, rhs: Self) -> Self::Output {
3559 self.simd.mul_f64x8(self, rhs)
3560 }
3561}
3562impl<S: Simd> core::ops::Mul<f64> for f64x8<S> {
3563 type Output = Self;
3564 #[inline(always)]
3565 fn mul(self, rhs: f64) -> Self::Output {
3566 self.simd.mul_f64x8(self, rhs.simd_into(self.simd))
3567 }
3568}
3569impl<S: Simd> core::ops::Mul<f64x8<S>> for f64 {
3570 type Output = f64x8<S>;
3571 #[inline(always)]
3572 fn mul(self, rhs: f64x8<S>) -> Self::Output {
3573 rhs.simd.mul_f64x8(self.simd_into(rhs.simd), rhs)
3574 }
3575}
3576impl<S: Simd> core::ops::Div for f64x8<S> {
3577 type Output = Self;
3578 #[inline(always)]
3579 fn div(self, rhs: Self) -> Self::Output {
3580 self.simd.div_f64x8(self, rhs)
3581 }
3582}
3583impl<S: Simd> core::ops::Div<f64> for f64x8<S> {
3584 type Output = Self;
3585 #[inline(always)]
3586 fn div(self, rhs: f64) -> Self::Output {
3587 self.simd.div_f64x8(self, rhs.simd_into(self.simd))
3588 }
3589}
3590impl<S: Simd> core::ops::Div<f64x8<S>> for f64 {
3591 type Output = f64x8<S>;
3592 #[inline(always)]
3593 fn div(self, rhs: f64x8<S>) -> Self::Output {
3594 rhs.simd.div_f64x8(self.simd_into(rhs.simd), rhs)
3595 }
3596}
3597impl<S: Simd> core::ops::BitAnd for mask64x8<S> {
3598 type Output = Self;
3599 #[inline(always)]
3600 fn bitand(self, rhs: Self) -> Self::Output {
3601 self.simd.and_mask64x8(self, rhs)
3602 }
3603}
3604impl<S: Simd> core::ops::BitAnd<i64> for mask64x8<S> {
3605 type Output = Self;
3606 #[inline(always)]
3607 fn bitand(self, rhs: i64) -> Self::Output {
3608 self.simd.and_mask64x8(self, rhs.simd_into(self.simd))
3609 }
3610}
3611impl<S: Simd> core::ops::BitAnd<mask64x8<S>> for i64 {
3612 type Output = mask64x8<S>;
3613 #[inline(always)]
3614 fn bitand(self, rhs: mask64x8<S>) -> Self::Output {
3615 rhs.simd.and_mask64x8(self.simd_into(rhs.simd), rhs)
3616 }
3617}
3618impl<S: Simd> core::ops::BitOr for mask64x8<S> {
3619 type Output = Self;
3620 #[inline(always)]
3621 fn bitor(self, rhs: Self) -> Self::Output {
3622 self.simd.or_mask64x8(self, rhs)
3623 }
3624}
3625impl<S: Simd> core::ops::BitOr<i64> for mask64x8<S> {
3626 type Output = Self;
3627 #[inline(always)]
3628 fn bitor(self, rhs: i64) -> Self::Output {
3629 self.simd.or_mask64x8(self, rhs.simd_into(self.simd))
3630 }
3631}
3632impl<S: Simd> core::ops::BitOr<mask64x8<S>> for i64 {
3633 type Output = mask64x8<S>;
3634 #[inline(always)]
3635 fn bitor(self, rhs: mask64x8<S>) -> Self::Output {
3636 rhs.simd.or_mask64x8(self.simd_into(rhs.simd), rhs)
3637 }
3638}
3639impl<S: Simd> core::ops::BitXor for mask64x8<S> {
3640 type Output = Self;
3641 #[inline(always)]
3642 fn bitxor(self, rhs: Self) -> Self::Output {
3643 self.simd.xor_mask64x8(self, rhs)
3644 }
3645}
3646impl<S: Simd> core::ops::BitXor<i64> for mask64x8<S> {
3647 type Output = Self;
3648 #[inline(always)]
3649 fn bitxor(self, rhs: i64) -> Self::Output {
3650 self.simd.xor_mask64x8(self, rhs.simd_into(self.simd))
3651 }
3652}
3653impl<S: Simd> core::ops::BitXor<mask64x8<S>> for i64 {
3654 type Output = mask64x8<S>;
3655 #[inline(always)]
3656 fn bitxor(self, rhs: mask64x8<S>) -> Self::Output {
3657 rhs.simd.xor_mask64x8(self.simd_into(rhs.simd), rhs)
3658 }
3659}
3660impl<S: Simd> core::ops::Not for mask64x8<S> {
3661 type Output = Self;
3662 #[inline(always)]
3663 fn not(self) -> Self::Output {
3664 self.simd.not_mask64x8(self)
3665 }
3666}