gmm/data/
float4.rs

1use crate::macros::impl_element4;
2use crate::macros::impl_element4_op;
3use super::bool4::Boolean4;
4use super::float2::Float2;
5use super::float3::Float3;
6
7
8
9/// A structure that stores four-dimensional vector data.
10#[repr(C)]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(Clone, Copy, PartialEq)]
13pub struct Float4 {
14    pub x: f32,
15    pub y: f32,
16    pub z: f32,
17    pub w: f32,
18}
19
20impl Float4 {
21    /// All elements are zero.
22    pub const ZERO: Self = Self::fill(0.0);
23
24    /// All elements are one.
25    pub const ONE: Self = Self::fill(1.0);
26
27    /// All elements are negative one.
28    pub const NEG_ONE: Self = Self::fill(-1.0);
29
30    /// positive unit vector on x-axis.
31    pub const X: Self = Self::new(1.0, 0.0, 0.0, 0.0);
32
33    /// positive unit vector on y-axis.
34    pub const Y: Self = Self::new(0.0, 1.0, 0.0, 0.0);
35
36    /// positive unit vector on z-axis.
37    pub const Z: Self = Self::new(0.0, 0.0, 1.0, 0.0);
38
39    /// positive unit vector on w-axis.
40    pub const W: Self = Self::new(0.0, 0.0, 0.0, 1.0);
41
42    /// negative unit vector on x-axis.
43    pub const NEG_X: Self = Self::new(-1.0, 0.0, 0.0, 0.0);
44
45    /// negative unit vector on y-axis.
46    pub const NEG_Y: Self = Self::new(0.0, -1.0, 0.0, 0.0);
47
48    /// negative unit vector on z-axis.
49    pub const NEG_Z: Self = Self::new(0.0, 0.0, -1.0, 0.0);
50
51    /// negative unit vector on w-axis.
52    pub const NEG_W: Self = Self::new(0.0, 0.0, 0.0, -1.0);
53
54    /// All elements are [`f32::MIN`].
55    pub const MIN: Self = Self::fill(f32::MIN);
56
57    /// All elements are [`f32::MAX`].
58    pub const MAX: Self = Self::fill(f32::MAX);
59
60    /// All elements are [`f32::NAN`].
61    pub const NAN: Self = Self::fill(f32::NAN);
62
63    /// All elements are [`f32::INFINITY`].
64    pub const INFINITY: Self = Self::fill(f32::INFINITY);
65
66    /// All elements are [`f32::NEG_INFINITY`].
67    pub const NEG_INFINITY: Self = Self::fill(f32::NEG_INFINITY);
68
69    /// Returns `true` if at least one element of the vector is [`f32::NAN`].
70    #[inline]
71    pub fn is_nan(&self) -> bool {
72        Boolean4 {
73            x: self.x.is_nan(),
74            y: self.y.is_nan(),
75            z: self.z.is_nan(),
76            w: self.w.is_nan(),
77        }.any()
78    }
79
80    /// Returns `true` if at least one element of the vector is [`f32::INFINITY`].
81    #[inline]
82    pub fn is_infinite(&self) -> bool {
83        Boolean4 {
84            x: self.x.is_infinite(),
85            y: self.y.is_infinite(),
86            z: self.z.is_infinite(),
87            w: self.w.is_infinite(),
88        }.any()
89    }
90}
91
92// Vector swizzle code implementation.
93impl Float4 {
94    #[inline]
95    pub const fn xx(self) -> Float2 {
96        Float2 { x: self.x, y: self.x }
97    }
98
99    #[inline]
100    pub const fn xy(self) -> Float2 {
101        Float2 { x: self.x, y: self.y }
102    }
103
104    #[inline]
105    pub const fn xz(self) -> Float2 {
106        Float2 { x: self.x, y: self.z }
107    }
108
109    #[inline]
110    pub const fn xw(self) -> Float2 {
111        Float2 { x: self.x, y: self.w }
112    }
113
114    #[inline]
115    pub const fn yx(self) -> Float2 {
116        Float2 { x: self.y, y: self.x }
117    }
118
119    #[inline]
120    pub const fn yy(self) -> Float2 {
121        Float2 { x: self.y, y: self.y }
122    }
123
124    #[inline]
125    pub const fn yz(self) -> Float2 {
126        Float2 { x: self.y, y: self.z }
127    }
128
129    #[inline]
130    pub const fn yw(self) -> Float2 {
131        Float2 { x: self.y, y: self.w }
132    }
133
134    #[inline]
135    pub const fn zx(self) -> Float2 {
136        Float2 { x: self.z, y: self.x }
137    }
138
139    #[inline]
140    pub const fn zy(self) -> Float2 {
141        Float2 { x: self.z, y: self.x }
142    }
143
144    #[inline]
145    pub const fn zz(self) -> Float2 {
146        Float2 { x: self.z, y: self.z }
147    }
148
149    #[inline]
150    pub const fn zw(self) -> Float2 {
151        Float2 { x: self.z, y: self.w }
152    }
153
154    #[inline]
155    pub const fn wx(self) -> Float2 {
156        Float2 { x: self.w, y: self.x }
157    }
158
159    #[inline]
160    pub const fn wy(self) -> Float2 {
161        Float2 { x: self.w, y: self.y }
162    }
163
164    #[inline]
165    pub const fn wz(self) -> Float2 {
166        Float2 { x: self.w, y: self.z }
167    }
168
169    #[inline]
170    pub const fn ww(self) -> Float2 {
171        Float2 { x: self.w, y: self.w }
172    }
173
174    #[inline]
175    pub const fn xxx(self) -> Float3 {
176        Float3 { x: self.x, y: self.x, z: self.x }
177    }
178
179    #[inline]
180    pub const fn xxy(self) -> Float3 {
181        Float3 { x: self.x, y: self.x, z: self.y }
182    }
183
184    #[inline]
185    pub const fn xxz(self) -> Float3 {
186        Float3 { x: self.x, y: self.x, z: self.z }
187    }
188
189    #[inline]
190    pub const fn xxw(self) -> Float3 {
191        Float3 { x: self.x, y: self.x, z: self.w }
192    }
193
194    #[inline]
195    pub const fn xyx(self) -> Float3 {
196        Float3 { x: self.x, y: self.y, z: self.x }
197    }
198
199    #[inline]
200    pub const fn xyy(self) -> Float3 {
201        Float3 { x: self.x, y: self.y, z: self.y }
202    }
203
204    #[inline]
205    pub const fn xyz(self) -> Float3 {
206        Float3 { x: self.x, y: self.y, z: self.z }
207    }
208
209    #[inline]
210    pub const fn xyw(self) -> Float3 {
211        Float3 { x: self.x, y: self.y, z: self.w }
212    }
213
214    #[inline]
215    pub const fn xzx(self) -> Float3 {
216        Float3 { x: self.x, y: self.z, z: self.x }
217    }
218
219    #[inline]
220    pub const fn xzy(self) -> Float3 {
221        Float3 { x: self.x, y: self.z, z: self.y }
222    }
223
224    #[inline]
225    pub const fn xzz(self) -> Float3 {
226        Float3 { x: self.x, y: self.z, z: self.z }
227    }
228
229    #[inline]
230    pub const fn xzw(self) -> Float3 {
231        Float3 { x: self.x, y: self.z, z: self.w }
232    }
233
234    #[inline]
235    pub const fn xwx(self) -> Float3 {
236        Float3 { x: self.x, y: self.w, z: self.x }
237    }
238
239    #[inline]
240    pub const fn xwy(self) -> Float3 {
241        Float3 { x: self.x, y: self.w, z: self.y }
242    }
243
244    #[inline]
245    pub const fn xwz(self) -> Float3 {
246        Float3 { x: self.x, y: self.w, z: self.z }
247    }
248
249    #[inline]
250    pub const fn xww(self) -> Float3 {
251        Float3 { x: self.x, y: self.w, z: self.w }
252    }
253
254    #[inline]
255    pub const fn yxx(self) -> Float3 {
256        Float3 { x: self.y, y: self.x, z: self.x }
257    }
258
259    #[inline]
260    pub const fn yxy(self) -> Float3 {
261        Float3 { x: self.y, y: self.x, z: self.y }
262    }
263
264    #[inline]
265    pub const fn yxz(self) -> Float3 {
266        Float3 { x: self.y, y: self.x, z: self.z }
267    }
268
269    #[inline]
270    pub const fn yxw(self) -> Float3 {
271        Float3 { x: self.y, y: self.x, z: self.w }
272    }
273
274    #[inline]
275    pub const fn yyx(self) -> Float3 {
276        Float3 { x: self.y, y: self.y, z: self.x }
277    }
278
279    #[inline]
280    pub const fn yyy(self) -> Float3 {
281        Float3 { x: self.y, y: self.y, z: self.y }
282    }
283
284    #[inline]
285    pub const fn yyz(self) -> Float3 {
286        Float3 { x: self.y, y: self.y, z: self.z }
287    }
288
289    #[inline]
290    pub const fn yyw(self) -> Float3 {
291        Float3 { x: self.y, y: self.y, z: self.w }
292    }
293
294    #[inline]
295    pub const fn yzx(self) -> Float3 {
296        Float3 { x: self.y, y: self.z, z: self.x }
297    }
298
299    #[inline]
300    pub const fn yzy(self) -> Float3 {
301        Float3 { x: self.y, y: self.z, z: self.y }
302    }
303
304    #[inline]
305    pub const fn yzz(self) -> Float3 {
306        Float3 { x: self.y, y: self.z, z: self.z }
307    }
308
309    #[inline]
310    pub const fn yzw(self) -> Float3 {
311        Float3 { x: self.y, y: self.z, z: self.w }
312    }
313
314    #[inline]
315    pub const fn ywx(self) -> Float3 {
316        Float3 { x: self.y, y: self.w, z: self.x }
317    }
318
319    #[inline]
320    pub const fn ywy(self) -> Float3 {
321        Float3 { x: self.y, y: self.w, z: self.y }
322    }
323
324    #[inline]
325    pub const fn ywz(self) -> Float3 {
326        Float3 { x: self.y, y: self.w, z: self.z }
327    }
328
329    #[inline]
330    pub const fn yww(self) -> Float3 {
331        Float3 { x: self.y, y: self.w, z: self.w }
332    }
333
334    #[inline]
335    pub const fn zxx(self) -> Float3 {
336        Float3 { x: self.z, y: self.x, z: self.x }
337    }
338
339    #[inline]
340    pub const fn zxy(self) -> Float3 {
341        Float3 { x: self.z, y: self.x, z: self.y }
342    }
343
344    #[inline]
345    pub const fn zxz(self) -> Float3 {
346        Float3 { x: self.z, y: self.x, z: self.z }
347    }
348
349    #[inline]
350    pub const fn zxw(self) -> Float3 {
351        Float3 { x: self.z, y: self.x, z: self.w }
352    }
353
354    #[inline]
355    pub const fn zyx(self) -> Float3 {
356        Float3 { x: self.z, y: self.y, z: self.x }
357    }
358
359    #[inline]
360    pub const fn zyy(self) -> Float3 {
361        Float3 { x: self.z, y: self.y, z: self.y }
362    }
363
364    #[inline]
365    pub const fn zyz(self) -> Float3 {
366        Float3 { x: self.z, y: self.y, z: self.z }
367    }
368
369    #[inline]
370    pub const fn zyw(self) -> Float3 {
371        Float3 { x: self.z, y: self.y, z: self.w }
372    }
373
374    #[inline]
375    pub const fn zzx(self) -> Float3 {
376        Float3 { x: self.z, y: self.z, z: self.x }
377    }
378
379    #[inline]
380    pub const fn zzy(self) -> Float3 {
381        Float3 { x: self.z, y: self.z, z: self.y }
382    }
383
384    #[inline]
385    pub const fn zzz(self) -> Float3 {
386        Float3 { x: self.z, y: self.z, z: self.z }
387    }
388
389    #[inline]
390    pub const fn zzw(self) -> Float3 {
391        Float3 { x: self.z, y: self.z, z: self.w }
392    }
393
394    #[inline]
395    pub const fn zwx(self) -> Float3 {
396        Float3 { x: self.z, y: self.w, z: self.x }
397    }
398
399    #[inline]
400    pub const fn zwy(self) -> Float3 {
401        Float3 { x: self.z, y: self.w, z: self.y }
402    }
403
404    #[inline]
405    pub const fn zwz(self) -> Float3 {
406        Float3 { x: self.z, y: self.w, z: self.z }
407    }
408
409    #[inline]
410    pub const fn zww(self) -> Float3 {
411        Float3 { x: self.z, y: self.w, z: self.w }
412    }
413
414    #[inline]
415    pub const fn wxx(self) -> Float3 {
416        Float3 { x: self.w, y: self.x, z: self.x }
417    }
418
419    #[inline]
420    pub const fn wxy(self) -> Float3 {
421        Float3 { x: self.w, y: self.x, z: self.y }
422    }
423
424    #[inline]
425    pub const fn wxz(self) -> Float3 {
426        Float3 { x: self.w, y: self.x, z: self.z }
427    }
428
429    #[inline]
430    pub const fn wxw(self) -> Float3 {
431        Float3 { x: self.w, y: self.x, z: self.w }
432    }
433
434    #[inline]
435    pub const fn wyx(self) -> Float3 {
436        Float3 { x: self.w, y: self.y, z: self.x }
437    }
438
439    #[inline]
440    pub const fn wyy(self) -> Float3 {
441        Float3 { x: self.w, y: self.y, z: self.y }
442    }
443
444    #[inline]
445    pub const fn wyz(self) -> Float3 {
446        Float3 { x: self.w, y: self.y, z: self.z }
447    }
448
449    #[inline]
450    pub const fn wyw(self) -> Float3 {
451        Float3 { x: self.w, y: self.y, z: self.w }
452    }
453
454    #[inline]
455    pub const fn wzx(self) -> Float3 {
456        Float3 { x: self.w, y: self.z, z: self.x }
457    }
458
459    #[inline]
460    pub const fn wzy(self) -> Float3 {
461        Float3 { x: self.w, y: self.z, z: self.y }
462    }
463
464    #[inline]
465    pub const fn wzz(self) -> Float3 {
466        Float3 { x: self.w, y: self.z, z: self.z }
467    }
468
469    #[inline]
470    pub const fn wzw(self) -> Float3 {
471        Float3 { x: self.w, y: self.z, z: self.w }
472    }
473
474    #[inline]
475    pub const fn wwx(self) -> Float3 {
476        Float3 { x: self.w, y: self.w, z: self.x }
477    }
478
479    #[inline]
480    pub const fn wwy(self) -> Float3 {
481        Float3 { x: self.w, y: self.w, z: self.y }
482    }
483
484    #[inline]
485    pub const fn wwz(self) -> Float3 {
486        Float3 { x: self.w, y: self.w, z: self.z }
487    }
488
489    #[inline]
490    pub const fn www(self) -> Float3 {
491        Float3 { x: self.w, y: self.w, z: self.w }
492    }
493
494    #[inline]
495    pub const fn xxxx(self) -> Float4 {
496        Float4 { x: self.x, y: self.x, z: self.x, w: self.x }
497    }
498
499    #[inline]
500    pub const fn xxxy(self) -> Float4 {
501        Float4 { x: self.x, y: self.x, z: self.x, w: self.y }
502    }
503
504    #[inline]
505    pub const fn xxxz(self) -> Float4 {
506        Float4 { x: self.x, y: self.x, z: self.x, w: self.z }
507    }
508
509    #[inline]
510    pub const fn xxxw(self) -> Float4 {
511        Float4 { x: self.x, y: self.x, z: self.x, w: self.w }
512    }
513
514    #[inline]
515    pub const fn xxyx(self) -> Float4 {
516        Float4 { x: self.x, y: self.x, z: self.y, w: self.x }
517    }
518
519    #[inline]
520    pub const fn xxyy(self) -> Float4 {
521        Float4 { x: self.x, y: self.x, z: self.y, w: self.y }
522    }
523
524    #[inline]
525    pub const fn xxyz(self) -> Float4 {
526        Float4 { x: self.x, y: self.x, z: self.y, w: self.z }
527    }
528
529    #[inline]
530    pub const fn xxyw(self) -> Float4 {
531        Float4 { x: self.x, y: self.x, z: self.y, w: self.w }
532    }
533
534    #[inline]
535    pub const fn xxzx(self) -> Float4 {
536        Float4 { x: self.x, y: self.x, z: self.z, w: self.x }
537    }
538
539    #[inline]
540    pub const fn xxzy(self) -> Float4 {
541        Float4 { x: self.x, y: self.x, z: self.z, w: self.y }
542    }
543
544    #[inline]
545    pub const fn xxzz(self) -> Float4 {
546        Float4 { x: self.x, y: self.x, z: self.z, w: self.z }
547    }
548
549    #[inline]
550    pub const fn xxzw(self) -> Float4 {
551        Float4 { x: self.x, y: self.x, z: self.z, w: self.w }
552    }
553
554    #[inline]
555    pub const fn xxwx(self) -> Float4 {
556        Float4 { x: self.x, y: self.x, z: self.w, w: self.x }
557    }
558
559    #[inline]
560    pub const fn xxwy(self) -> Float4 {
561        Float4 { x: self.x, y: self.x, z: self.w, w: self.y }
562    }
563
564    #[inline]
565    pub const fn xxwz(self) -> Float4 {
566        Float4 { x: self.x, y: self.x, z: self.w, w: self.z }
567    }
568
569    #[inline]
570    pub const fn xxww(self) -> Float4 {
571        Float4 { x: self.x, y: self.x, z: self.w, w: self.w }
572    }
573
574    #[inline]
575    pub const fn xyxx(self) -> Float4 {
576        Float4 { x: self.x, y: self.y, z: self.x, w: self.x }
577    }
578
579    #[inline]
580    pub const fn xyxy(self) -> Float4 {
581        Float4 { x: self.x, y: self.y, z: self.x, w: self.y }
582    }
583
584    #[inline]
585    pub const fn xyxz(self) -> Float4 {
586        Float4 { x: self.x, y: self.y, z: self.x, w: self.z }
587    }
588
589    #[inline]
590    pub const fn xyxw(self) -> Float4 {
591        Float4 { x: self.x, y: self.y, z: self.x, w: self.w }
592    }
593
594    #[inline]
595    pub const fn xyyx(self) -> Float4 {
596        Float4 { x: self.x, y: self.y, z: self.y, w: self.x }
597    }
598
599    #[inline]
600    pub const fn xyyy(self) -> Float4 {
601        Float4 { x: self.x, y: self.y, z: self.y, w: self.y }
602    }
603
604    #[inline]
605    pub const fn xyyz(self) -> Float4 {
606        Float4 { x: self.x, y: self.y, z: self.y, w: self.z }
607    }
608
609    #[inline]
610    pub const fn xyyw(self) -> Float4 {
611        Float4 { x: self.x, y: self.y, z: self.y, w: self.w }
612    }
613
614    #[inline]
615    pub const fn xyzx(self) -> Float4 {
616        Float4 { x: self.x, y: self.y, z: self.z, w: self.x }
617    }
618
619    #[inline]
620    pub const fn xyzy(self) -> Float4 {
621        Float4 { x: self.x, y: self.y, z: self.z, w: self.y }
622    }
623
624    #[inline]
625    pub const fn xyzz(self) -> Float4 {
626        Float4 { x: self.x, y: self.y, z: self.z, w: self.z }
627    }
628
629    #[inline]
630    pub const fn xyzw(self) -> Float4 {
631        Float4 { x: self.x, y: self.y, z: self.z, w: self.w }
632    }
633
634    #[inline]
635    pub const fn xywx(self) -> Float4 {
636        Float4 { x: self.x, y: self.y, z: self.w, w: self.x }
637    }
638
639    #[inline]
640    pub const fn xywy(self) -> Float4 {
641        Float4 { x: self.x, y: self.y, z: self.w, w: self.y }
642    }
643
644    #[inline]
645    pub const fn xywz(self) -> Float4 {
646        Float4 { x: self.x, y: self.y, z: self.w, w: self.z }
647    }
648
649    #[inline]
650    pub const fn xyww(self) -> Float4 {
651        Float4 { x: self.x, y: self.y, z: self.w, w: self.w }
652    }
653
654    #[inline]
655    pub const fn xzxx(self) -> Float4 {
656        Float4 { x: self.x, y: self.z, z: self.x, w: self.x }
657    }
658
659    #[inline]
660    pub const fn xzxy(self) -> Float4 {
661        Float4 { x: self.x, y: self.z, z: self.x, w: self.y }
662    }
663
664    #[inline]
665    pub const fn xzxz(self) -> Float4 {
666        Float4 { x: self.x, y: self.z, z: self.x, w: self.z }
667    }
668
669    #[inline]
670    pub const fn xzxw(self) -> Float4 {
671        Float4 { x: self.x, y: self.z, z: self.x, w: self.w }
672    }
673
674    #[inline]
675    pub const fn xzyx(self) -> Float4 {
676        Float4 { x: self.x, y: self.z, z: self.y, w: self.x }
677    }
678
679    #[inline]
680    pub const fn xzyy(self) -> Float4 {
681        Float4 { x: self.x, y: self.z, z: self.y, w: self.y }
682    }
683
684    #[inline]
685    pub const fn xzyz(self) -> Float4 {
686        Float4 { x: self.x, y: self.z, z: self.y, w: self.z }
687    }
688
689    #[inline]
690    pub const fn xzyw(self) -> Float4 {
691        Float4 { x: self.x, y: self.z, z: self.y, w: self.w }
692    }
693
694    #[inline]
695    pub const fn xzzx(self) -> Float4 {
696        Float4 { x: self.x, y: self.z, z: self.z, w: self.x }
697    }
698
699    #[inline]
700    pub const fn xzzy(self) -> Float4 {
701        Float4 { x: self.x, y: self.z, z: self.z, w: self.y }
702    }
703
704    #[inline]
705    pub const fn xzzz(self) -> Float4 {
706        Float4 { x: self.x, y: self.z, z: self.z, w: self.z }
707    }
708
709    #[inline]
710    pub const fn xzzw(self) -> Float4 {
711        Float4 { x: self.x, y: self.z, z: self.z, w: self.w }
712    }
713
714    #[inline]
715    pub const fn xzwx(self) -> Float4 {
716        Float4 { x: self.x, y: self.z, z: self.w, w: self.x }
717    }
718
719    #[inline]
720    pub const fn xzwy(self) -> Float4 {
721        Float4 { x: self.x, y: self.z, z: self.w, w: self.y }
722    }
723
724    #[inline]
725    pub const fn xzwz(self) -> Float4 {
726        Float4 { x: self.x, y: self.z, z: self.w, w: self.z }
727    }
728
729    #[inline]
730    pub const fn xzww(self) -> Float4 {
731        Float4 { x: self.x, y: self.z, z: self.w, w: self.w }
732    }
733    
734    #[inline]
735    pub const fn xwxx(self) -> Float4 {
736        Float4 { x: self.x, y: self.w, z: self.x, w: self.x }
737    }
738
739    #[inline]
740    pub const fn xwxy(self) -> Float4 {
741        Float4 { x: self.x, y: self.w, z: self.x, w: self.y }
742    }
743
744    #[inline]
745    pub const fn xwxz(self) -> Float4 {
746        Float4 { x: self.x, y: self.w, z: self.x, w: self.z }
747    }
748
749    #[inline]
750    pub const fn xwxw(self) -> Float4 {
751        Float4 { x: self.x, y: self.w, z: self.x, w: self.w }
752    }
753
754    #[inline]
755    pub const fn xwyx(self) -> Float4 {
756        Float4 { x: self.x, y: self.w, z: self.y, w: self.x }
757    }
758
759    #[inline]
760    pub const fn xwyy(self) -> Float4 {
761        Float4 { x: self.x, y: self.w, z: self.y, w: self.y }
762    }
763
764    #[inline]
765    pub const fn xwyz(self) -> Float4 {
766        Float4 { x: self.x, y: self.w, z: self.y, w: self.z }
767    }
768
769    #[inline]
770    pub const fn xwyw(self) -> Float4 {
771        Float4 { x: self.x, y: self.w, z: self.y, w: self.w }
772    }
773
774    #[inline]
775    pub const fn xwzx(self) -> Float4 {
776        Float4 { x: self.x, y: self.w, z: self.z, w: self.x }
777    }
778
779    #[inline]
780    pub const fn xwzy(self) -> Float4 {
781        Float4 { x: self.x, y: self.w, z: self.z, w: self.y }
782    }
783
784    #[inline]
785    pub const fn xwzz(self) -> Float4 {
786        Float4 { x: self.x, y: self.w, z: self.z, w: self.z }
787    }
788
789    #[inline]
790    pub const fn xwzw(self) -> Float4 {
791        Float4 { x: self.x, y: self.w, z: self.z, w: self.w }
792    }
793
794    #[inline]
795    pub const fn xwwx(self) -> Float4 {
796        Float4 { x: self.x, y: self.w, z: self.w, w: self.x }
797    }
798
799    #[inline]
800    pub const fn xwwy(self) -> Float4 {
801        Float4 { x: self.x, y: self.w, z: self.w, w: self.y }
802    }
803
804    #[inline]
805    pub const fn xwwz(self) -> Float4 {
806        Float4 { x: self.x, y: self.w, z: self.w, w: self.z }
807    }
808
809    #[inline]
810    pub const fn xwww(self) -> Float4 {
811        Float4 { x: self.x, y: self.w, z: self.w, w: self.w }
812    }
813
814    #[inline]
815    pub const fn yxxx(self) -> Float4 {
816        Float4 { x: self.y, y: self.x, z: self.x, w: self.x }
817    }
818
819    #[inline]
820    pub const fn yxxy(self) -> Float4 {
821        Float4 { x: self.y, y: self.x, z: self.x, w: self.y }
822    }
823
824    #[inline]
825    pub const fn yxxz(self) -> Float4 {
826        Float4 { x: self.y, y: self.x, z: self.x, w: self.z }
827    }
828
829    #[inline]
830    pub const fn yxxw(self) -> Float4 {
831        Float4 { x: self.y, y: self.x, z: self.x, w: self.w }
832    }
833
834    #[inline]
835    pub const fn yxyx(self) -> Float4 {
836        Float4 { x: self.y, y: self.x, z: self.y, w: self.x }
837    }
838
839    #[inline]
840    pub const fn yxyy(self) -> Float4 {
841        Float4 { x: self.y, y: self.x, z: self.y, w: self.y }
842    }
843
844    #[inline]
845    pub const fn yxyz(self) -> Float4 {
846        Float4 { x: self.y, y: self.x, z: self.y, w: self.z }
847    }
848
849    #[inline]
850    pub const fn yxyw(self) -> Float4 {
851        Float4 { x: self.y, y: self.x, z: self.y, w: self.w }
852    }
853
854    #[inline]
855    pub const fn yxzx(self) -> Float4 {
856        Float4 { x: self.y, y: self.x, z: self.z, w: self.x }
857    }
858
859    #[inline]
860    pub const fn yxzy(self) -> Float4 {
861        Float4 { x: self.y, y: self.x, z: self.z, w: self.y }
862    }
863
864    #[inline]
865    pub const fn yxzz(self) -> Float4 {
866        Float4 { x: self.y, y: self.x, z: self.z, w: self.z }
867    }
868
869    #[inline]
870    pub const fn yxzw(self) -> Float4 {
871        Float4 { x: self.y, y: self.x, z: self.z, w: self.w }
872    }
873
874    #[inline]
875    pub const fn yxwx(self) -> Float4 {
876        Float4 { x: self.y, y: self.x, z: self.w, w: self.x }
877    }
878
879    #[inline]
880    pub const fn yxwy(self) -> Float4 {
881        Float4 { x: self.y, y: self.x, z: self.w, w: self.y }
882    }
883
884    #[inline]
885    pub const fn yxwz(self) -> Float4 {
886        Float4 { x: self.y, y: self.x, z: self.w, w: self.z }
887    }
888
889    #[inline]
890    pub const fn yxww(self) -> Float4 {
891        Float4 { x: self.y, y: self.x, z: self.w, w: self.w }
892    }
893
894    #[inline]
895    pub const fn yyxx(self) -> Float4 {
896        Float4 { x: self.y, y: self.y, z: self.x, w: self.x }
897    }
898
899    #[inline]
900    pub const fn yyxy(self) -> Float4 {
901        Float4 { x: self.y, y: self.y, z: self.x, w: self.y }
902    }
903
904    #[inline]
905    pub const fn yyxz(self) -> Float4 {
906        Float4 { x: self.y, y: self.y, z: self.x, w: self.z }
907    }
908
909    #[inline]
910    pub const fn yyxw(self) -> Float4 {
911        Float4 { x: self.y, y: self.y, z: self.x, w: self.w }
912    }
913
914    #[inline]
915    pub const fn yyyx(self) -> Float4 {
916        Float4 { x: self.y, y: self.y, z: self.y, w: self.x }
917    }
918
919    #[inline]
920    pub const fn yyyy(self) -> Float4 {
921        Float4 { x: self.y, y: self.y, z: self.y, w: self.y }
922    }
923
924    #[inline]
925    pub const fn yyyz(self) -> Float4 {
926        Float4 { x: self.y, y: self.y, z: self.y, w: self.z }
927    }
928
929    #[inline]
930    pub const fn yyyw(self) -> Float4 {
931        Float4 { x: self.y, y: self.y, z: self.y, w: self.w }
932    }
933
934    #[inline]
935    pub const fn yyzx(self) -> Float4 {
936        Float4 { x: self.y, y: self.y, z: self.z, w: self.x }
937    }
938
939    #[inline]
940    pub const fn yyzy(self) -> Float4 {
941        Float4 { x: self.y, y: self.y, z: self.z, w: self.y }
942    }
943
944    #[inline]
945    pub const fn yyzz(self) -> Float4 {
946        Float4 { x: self.y, y: self.y, z: self.z, w: self.z }
947    }
948
949    #[inline]
950    pub const fn yyzw(self) -> Float4 {
951        Float4 { x: self.y, y: self.y, z: self.z, w: self.w }
952    }
953
954    #[inline]
955    pub const fn yywx(self) -> Float4 {
956        Float4 { x: self.y, y: self.y, z: self.w, w: self.x }
957    }
958
959    #[inline]
960    pub const fn yywy(self) -> Float4 {
961        Float4 { x: self.y, y: self.y, z: self.w, w: self.y }
962    }
963
964    #[inline]
965    pub const fn yywz(self) -> Float4 {
966        Float4 { x: self.y, y: self.y, z: self.w, w: self.z }
967    }
968
969    #[inline]
970    pub const fn yyww(self) -> Float4 {
971        Float4 { x: self.y, y: self.y, z: self.w, w: self.w }
972    }
973
974    #[inline]
975    pub const fn yzxx(self) -> Float4 {
976        Float4 { x: self.y, y: self.z, z: self.x, w: self.x }
977    }
978
979    #[inline]
980    pub const fn yzxy(self) -> Float4 {
981        Float4 { x: self.y, y: self.z, z: self.x, w: self.y }
982    }
983
984    #[inline]
985    pub const fn yzxz(self) -> Float4 {
986        Float4 { x: self.y, y: self.z, z: self.x, w: self.z }
987    }
988
989    #[inline]
990    pub const fn yzxw(self) -> Float4 {
991        Float4 { x: self.y, y: self.z, z: self.x, w: self.w }
992    }
993
994    #[inline]
995    pub const fn yzyx(self) -> Float4 {
996        Float4 { x: self.y, y: self.z, z: self.y, w: self.x }
997    }
998
999    #[inline]
1000    pub const fn yzyy(self) -> Float4 {
1001        Float4 { x: self.y, y: self.z, z: self.y, w: self.y }
1002    }
1003
1004    #[inline]
1005    pub const fn yzyz(self) -> Float4 {
1006        Float4 { x: self.y, y: self.z, z: self.y, w: self.z }
1007    }
1008
1009    #[inline]
1010    pub const fn yzyw(self) -> Float4 {
1011        Float4 { x: self.y, y: self.z, z: self.y, w: self.w }
1012    }
1013
1014    #[inline]
1015    pub const fn yzzx(self) -> Float4 {
1016        Float4 { x: self.y, y: self.z, z: self.z, w: self.x }
1017    }
1018
1019    #[inline]
1020    pub const fn yzzy(self) -> Float4 {
1021        Float4 { x: self.y, y: self.z, z: self.z, w: self.y }
1022    }
1023
1024    #[inline]
1025    pub const fn yzzz(self) -> Float4 {
1026        Float4 { x: self.y, y: self.z, z: self.z, w: self.z }
1027    }
1028
1029    #[inline]
1030    pub const fn yzzw(self) -> Float4 {
1031        Float4 { x: self.y, y: self.z, z: self.z, w: self.w }
1032    }
1033
1034    #[inline]
1035    pub const fn yzwx(self) -> Float4 {
1036        Float4 { x: self.y, y: self.z, z: self.w, w: self.x }
1037    }
1038
1039    #[inline]
1040    pub const fn yzwy(self) -> Float4 {
1041        Float4 { x: self.y, y: self.z, z: self.w, w: self.y }
1042    }
1043
1044    #[inline]
1045    pub const fn yzwz(self) -> Float4 {
1046        Float4 { x: self.y, y: self.z, z: self.w, w: self.z }
1047    }
1048
1049    #[inline]
1050    pub const fn yzww(self) -> Float4 {
1051        Float4 { x: self.y, y: self.z, z: self.w, w: self.w }
1052    }
1053    
1054    #[inline]
1055    pub const fn ywxx(self) -> Float4 {
1056        Float4 { x: self.y, y: self.w, z: self.x, w: self.x }
1057    }
1058
1059    #[inline]
1060    pub const fn ywxy(self) -> Float4 {
1061        Float4 { x: self.y, y: self.w, z: self.x, w: self.y }
1062    }
1063
1064    #[inline]
1065    pub const fn ywxz(self) -> Float4 {
1066        Float4 { x: self.y, y: self.w, z: self.x, w: self.z }
1067    }
1068
1069    #[inline]
1070    pub const fn ywxw(self) -> Float4 {
1071        Float4 { x: self.y, y: self.w, z: self.x, w: self.w }
1072    }
1073
1074    #[inline]
1075    pub const fn ywyx(self) -> Float4 {
1076        Float4 { x: self.y, y: self.w, z: self.y, w: self.x }
1077    }
1078
1079    #[inline]
1080    pub const fn ywyy(self) -> Float4 {
1081        Float4 { x: self.y, y: self.w, z: self.y, w: self.y }
1082    }
1083
1084    #[inline]
1085    pub const fn ywyz(self) -> Float4 {
1086        Float4 { x: self.y, y: self.w, z: self.y, w: self.z }
1087    }
1088
1089    #[inline]
1090    pub const fn ywyw(self) -> Float4 {
1091        Float4 { x: self.y, y: self.w, z: self.y, w: self.w }
1092    }
1093
1094    #[inline]
1095    pub const fn ywzx(self) -> Float4 {
1096        Float4 { x: self.y, y: self.w, z: self.z, w: self.x }
1097    }
1098
1099    #[inline]
1100    pub const fn ywzy(self) -> Float4 {
1101        Float4 { x: self.y, y: self.w, z: self.z, w: self.y }
1102    }
1103
1104    #[inline]
1105    pub const fn ywzz(self) -> Float4 {
1106        Float4 { x: self.y, y: self.w, z: self.z, w: self.z }
1107    }
1108
1109    #[inline]
1110    pub const fn ywzw(self) -> Float4 {
1111        Float4 { x: self.y, y: self.w, z: self.z, w: self.w }
1112    }
1113
1114    #[inline]
1115    pub const fn ywwx(self) -> Float4 {
1116        Float4 { x: self.y, y: self.w, z: self.w, w: self.x }
1117    }
1118
1119    #[inline]
1120    pub const fn ywwy(self) -> Float4 {
1121        Float4 { x: self.y, y: self.w, z: self.w, w: self.y }
1122    }
1123
1124    #[inline]
1125    pub const fn ywwz(self) -> Float4 {
1126        Float4 { x: self.y, y: self.w, z: self.w, w: self.z }
1127    }
1128
1129    #[inline]
1130    pub const fn ywww(self) -> Float4 {
1131        Float4 { x: self.y, y: self.w, z: self.w, w: self.w }
1132    }
1133    
1134
1135    #[inline]
1136    pub const fn zxxx(self) -> Float4 {
1137        Float4 { x: self.z, y: self.x, z: self.x, w: self.x }
1138    }
1139
1140    #[inline]
1141    pub const fn zxxy(self) -> Float4 {
1142        Float4 { x: self.z, y: self.x, z: self.x, w: self.y }
1143    }
1144
1145    #[inline]
1146    pub const fn zxxz(self) -> Float4 {
1147        Float4 { x: self.z, y: self.x, z: self.x, w: self.z }
1148    }
1149
1150    #[inline]
1151    pub const fn zxxw(self) -> Float4 {
1152        Float4 { x: self.z, y: self.x, z: self.x, w: self.w }
1153    }
1154
1155    #[inline]
1156    pub const fn zxyx(self) -> Float4 {
1157        Float4 { x: self.z, y: self.x, z: self.y, w: self.x }
1158    }
1159
1160    #[inline]
1161    pub const fn zxyy(self) -> Float4 {
1162        Float4 { x: self.z, y: self.x, z: self.y, w: self.y }
1163    }
1164
1165    #[inline]
1166    pub const fn zxyz(self) -> Float4 {
1167        Float4 { x: self.z, y: self.x, z: self.y, w: self.z }
1168    }
1169
1170    #[inline]
1171    pub const fn zxyw(self) -> Float4 {
1172        Float4 { x: self.z, y: self.x, z: self.y, w: self.w }
1173    }
1174
1175    #[inline]
1176    pub const fn zxzx(self) -> Float4 {
1177        Float4 { x: self.z, y: self.x, z: self.z, w: self.x }
1178    }
1179
1180    #[inline]
1181    pub const fn zxzy(self) -> Float4 {
1182        Float4 { x: self.z, y: self.x, z: self.z, w: self.y }
1183    }
1184
1185    #[inline]
1186    pub const fn zxzz(self) -> Float4 {
1187        Float4 { x: self.z, y: self.x, z: self.z, w: self.z }
1188    }
1189
1190    #[inline]
1191    pub const fn zxzw(self) -> Float4 {
1192        Float4 { x: self.z, y: self.x, z: self.z, w: self.w }
1193    }
1194
1195    #[inline]
1196    pub const fn zxwx(self) -> Float4 {
1197        Float4 { x: self.z, y: self.x, z: self.w, w: self.x }
1198    }
1199
1200    #[inline]
1201    pub const fn zxwy(self) -> Float4 {
1202        Float4 { x: self.z, y: self.x, z: self.w, w: self.y }
1203    }
1204
1205    #[inline]
1206    pub const fn zxwz(self) -> Float4 {
1207        Float4 { x: self.z, y: self.x, z: self.w, w: self.z }
1208    }
1209
1210    #[inline]
1211    pub const fn zxww(self) -> Float4 {
1212        Float4 { x: self.z, y: self.x, z: self.w, w: self.w }
1213    }
1214
1215    #[inline]
1216    pub const fn zyxx(self) -> Float4 {
1217        Float4 { x: self.z, y: self.y, z: self.x, w: self.x }
1218    }
1219
1220    #[inline]
1221    pub const fn zyxy(self) -> Float4 {
1222        Float4 { x: self.z, y: self.y, z: self.x, w: self.y }
1223    }
1224
1225    #[inline]
1226    pub const fn zyxz(self) -> Float4 {
1227        Float4 { x: self.z, y: self.y, z: self.x, w: self.z }
1228    }
1229
1230    #[inline]
1231    pub const fn zyxw(self) -> Float4 {
1232        Float4 { x: self.z, y: self.y, z: self.x, w: self.w }
1233    }
1234
1235    #[inline]
1236    pub const fn zyyx(self) -> Float4 {
1237        Float4 { x: self.z, y: self.y, z: self.y, w: self.x }
1238    }
1239
1240    #[inline]
1241    pub const fn zyyy(self) -> Float4 {
1242        Float4 { x: self.z, y: self.y, z: self.y, w: self.y }
1243    }
1244
1245    #[inline]
1246    pub const fn zyyz(self) -> Float4 {
1247        Float4 { x: self.z, y: self.y, z: self.y, w: self.z }
1248    }
1249
1250    #[inline]
1251    pub const fn zyyw(self) -> Float4 {
1252        Float4 { x: self.z, y: self.y, z: self.y, w: self.w }
1253    }
1254
1255    #[inline]
1256    pub const fn zyzx(self) -> Float4 {
1257        Float4 { x: self.z, y: self.y, z: self.z, w: self.x }
1258    }
1259
1260    #[inline]
1261    pub const fn zyzy(self) -> Float4 {
1262        Float4 { x: self.z, y: self.y, z: self.z, w: self.y }
1263    }
1264
1265    #[inline]
1266    pub const fn zyzz(self) -> Float4 {
1267        Float4 { x: self.z, y: self.y, z: self.z, w: self.z }
1268    }
1269
1270    #[inline]
1271    pub const fn zyzw(self) -> Float4 {
1272        Float4 { x: self.z, y: self.y, z: self.z, w: self.w }
1273    }
1274
1275    #[inline]
1276    pub const fn zywx(self) -> Float4 {
1277        Float4 { x: self.z, y: self.y, z: self.w, w: self.x }
1278    }
1279
1280    #[inline]
1281    pub const fn zywy(self) -> Float4 {
1282        Float4 { x: self.z, y: self.y, z: self.w, w: self.y }
1283    }
1284
1285    #[inline]
1286    pub const fn zywz(self) -> Float4 {
1287        Float4 { x: self.z, y: self.y, z: self.w, w: self.z }
1288    }
1289
1290    #[inline]
1291    pub const fn zyww(self) -> Float4 {
1292        Float4 { x: self.z, y: self.y, z: self.w, w: self.w }
1293    }
1294
1295    #[inline]
1296    pub const fn zzxx(self) -> Float4 {
1297        Float4 { x: self.z, y: self.z, z: self.x, w: self.x }
1298    }
1299
1300    #[inline]
1301    pub const fn zzxy(self) -> Float4 {
1302        Float4 { x: self.z, y: self.z, z: self.x, w: self.y }
1303    }
1304
1305    #[inline]
1306    pub const fn zzxz(self) -> Float4 {
1307        Float4 { x: self.z, y: self.z, z: self.x, w: self.z }
1308    }
1309
1310    #[inline]
1311    pub const fn zzxw(self) -> Float4 {
1312        Float4 { x: self.z, y: self.z, z: self.x, w: self.w }
1313    }
1314
1315    #[inline]
1316    pub const fn zzyx(self) -> Float4 {
1317        Float4 { x: self.z, y: self.z, z: self.y, w: self.x }
1318    }
1319
1320    #[inline]
1321    pub const fn zzyy(self) -> Float4 {
1322        Float4 { x: self.z, y: self.z, z: self.y, w: self.y }
1323    }
1324
1325    #[inline]
1326    pub const fn zzyz(self) -> Float4 {
1327        Float4 { x: self.z, y: self.z, z: self.y, w: self.z }
1328    }
1329
1330    #[inline]
1331    pub const fn zzyw(self) -> Float4 {
1332        Float4 { x: self.z, y: self.z, z: self.y, w: self.w }
1333    }
1334
1335    #[inline]
1336    pub const fn zzzx(self) -> Float4 {
1337        Float4 { x: self.z, y: self.z, z: self.z, w: self.x }
1338    }
1339
1340    #[inline]
1341    pub const fn zzzy(self) -> Float4 {
1342        Float4 { x: self.z, y: self.z, z: self.z, w: self.y }
1343    }
1344
1345    #[inline]
1346    pub const fn zzzz(self) -> Float4 {
1347        Float4 { x: self.z, y: self.z, z: self.z, w: self.z }
1348    }
1349
1350    #[inline]
1351    pub const fn zzzw(self) -> Float4 {
1352        Float4 { x: self.z, y: self.z, z: self.z, w: self.w }
1353    }
1354
1355    #[inline]
1356    pub const fn zzwx(self) -> Float4 {
1357        Float4 { x: self.z, y: self.z, z: self.w, w: self.x }
1358    }
1359
1360    #[inline]
1361    pub const fn zzwy(self) -> Float4 {
1362        Float4 { x: self.z, y: self.z, z: self.w, w: self.y }
1363    }
1364
1365    #[inline]
1366    pub const fn zzwz(self) -> Float4 {
1367        Float4 { x: self.z, y: self.z, z: self.w, w: self.z }
1368    }
1369
1370    #[inline]
1371    pub const fn zzww(self) -> Float4 {
1372        Float4 { x: self.z, y: self.z, z: self.w, w: self.w }
1373    }
1374    
1375    #[inline]
1376    pub const fn zwxx(self) -> Float4 {
1377        Float4 { x: self.z, y: self.w, z: self.x, w: self.x }
1378    }
1379
1380    #[inline]
1381    pub const fn zwxy(self) -> Float4 {
1382        Float4 { x: self.z, y: self.w, z: self.x, w: self.y }
1383    }
1384
1385    #[inline]
1386    pub const fn zwxz(self) -> Float4 {
1387        Float4 { x: self.z, y: self.w, z: self.x, w: self.z }
1388    }
1389
1390    #[inline]
1391    pub const fn zwxw(self) -> Float4 {
1392        Float4 { x: self.z, y: self.w, z: self.x, w: self.w }
1393    }
1394
1395    #[inline]
1396    pub const fn zwyx(self) -> Float4 {
1397        Float4 { x: self.z, y: self.w, z: self.y, w: self.x }
1398    }
1399
1400    #[inline]
1401    pub const fn zwyy(self) -> Float4 {
1402        Float4 { x: self.z, y: self.w, z: self.y, w: self.y }
1403    }
1404
1405    #[inline]
1406    pub const fn zwyz(self) -> Float4 {
1407        Float4 { x: self.z, y: self.w, z: self.y, w: self.z }
1408    }
1409
1410    #[inline]
1411    pub const fn zwyw(self) -> Float4 {
1412        Float4 { x: self.z, y: self.w, z: self.y, w: self.w }
1413    }
1414
1415    #[inline]
1416    pub const fn zwzx(self) -> Float4 {
1417        Float4 { x: self.z, y: self.w, z: self.z, w: self.x }
1418    }
1419
1420    #[inline]
1421    pub const fn zwzy(self) -> Float4 {
1422        Float4 { x: self.z, y: self.w, z: self.z, w: self.y }
1423    }
1424
1425    #[inline]
1426    pub const fn zwzz(self) -> Float4 {
1427        Float4 { x: self.z, y: self.w, z: self.z, w: self.z }
1428    }
1429
1430    #[inline]
1431    pub const fn zwzw(self) -> Float4 {
1432        Float4 { x: self.z, y: self.w, z: self.z, w: self.w }
1433    }
1434
1435    #[inline]
1436    pub const fn zwwx(self) -> Float4 {
1437        Float4 { x: self.z, y: self.w, z: self.w, w: self.x }
1438    }
1439
1440    #[inline]
1441    pub const fn zwwy(self) -> Float4 {
1442        Float4 { x: self.z, y: self.w, z: self.w, w: self.y }
1443    }
1444
1445    #[inline]
1446    pub const fn zwwz(self) -> Float4 {
1447        Float4 { x: self.z, y: self.w, z: self.w, w: self.z }
1448    }
1449
1450    #[inline]
1451    pub const fn zwww(self) -> Float4 {
1452        Float4 { x: self.z, y: self.w, z: self.w, w: self.w }
1453    }
1454
1455    #[inline]
1456    pub const fn wxxx(self) -> Float4 {
1457        Float4 { x: self.w, y: self.x, z: self.x, w: self.x }
1458    }
1459
1460    #[inline]
1461    pub const fn wxxy(self) -> Float4 {
1462        Float4 { x: self.w, y: self.x, z: self.x, w: self.y }
1463    }
1464
1465    #[inline]
1466    pub const fn wxxz(self) -> Float4 {
1467        Float4 { x: self.w, y: self.x, z: self.x, w: self.z }
1468    }
1469
1470    #[inline]
1471    pub const fn wxxw(self) -> Float4 {
1472        Float4 { x: self.w, y: self.x, z: self.x, w: self.w }
1473    }
1474
1475    #[inline]
1476    pub const fn wxyx(self) -> Float4 {
1477        Float4 { x: self.w, y: self.x, z: self.y, w: self.x }
1478    }
1479
1480    #[inline]
1481    pub const fn wxyy(self) -> Float4 {
1482        Float4 { x: self.w, y: self.x, z: self.y, w: self.y }
1483    }
1484
1485    #[inline]
1486    pub const fn wxyz(self) -> Float4 {
1487        Float4 { x: self.w, y: self.x, z: self.y, w: self.z }
1488    }
1489
1490    #[inline]
1491    pub const fn wxyw(self) -> Float4 {
1492        Float4 { x: self.w, y: self.x, z: self.y, w: self.w }
1493    }
1494
1495    #[inline]
1496    pub const fn wxzx(self) -> Float4 {
1497        Float4 { x: self.w, y: self.x, z: self.z, w: self.x }
1498    }
1499
1500    #[inline]
1501    pub const fn wxzy(self) -> Float4 {
1502        Float4 { x: self.w, y: self.x, z: self.z, w: self.y }
1503    }
1504
1505    #[inline]
1506    pub const fn wxzz(self) -> Float4 {
1507        Float4 { x: self.w, y: self.x, z: self.z, w: self.z }
1508    }
1509
1510    #[inline]
1511    pub const fn wxzw(self) -> Float4 {
1512        Float4 { x: self.w, y: self.x, z: self.z, w: self.w }
1513    }
1514
1515    #[inline]
1516    pub const fn wxwx(self) -> Float4 {
1517        Float4 { x: self.w, y: self.x, z: self.w, w: self.x }
1518    }
1519
1520    #[inline]
1521    pub const fn wxwy(self) -> Float4 {
1522        Float4 { x: self.w, y: self.x, z: self.w, w: self.y }
1523    }
1524
1525    #[inline]
1526    pub const fn wxwz(self) -> Float4 {
1527        Float4 { x: self.w, y: self.x, z: self.w, w: self.z }
1528    }
1529
1530    #[inline]
1531    pub const fn wxww(self) -> Float4 {
1532        Float4 { x: self.w, y: self.x, z: self.w, w: self.w }
1533    }
1534
1535    #[inline]
1536    pub const fn wyxx(self) -> Float4 {
1537        Float4 { x: self.w, y: self.y, z: self.x, w: self.x }
1538    }
1539
1540    #[inline]
1541    pub const fn wyxy(self) -> Float4 {
1542        Float4 { x: self.w, y: self.y, z: self.x, w: self.y }
1543    }
1544
1545    #[inline]
1546    pub const fn wyxz(self) -> Float4 {
1547        Float4 { x: self.w, y: self.y, z: self.x, w: self.z }
1548    }
1549
1550    #[inline]
1551    pub const fn wyxw(self) -> Float4 {
1552        Float4 { x: self.w, y: self.y, z: self.x, w: self.w }
1553    }
1554
1555    #[inline]
1556    pub const fn wyyx(self) -> Float4 {
1557        Float4 { x: self.w, y: self.y, z: self.y, w: self.x }
1558    }
1559
1560    #[inline]
1561    pub const fn wyyy(self) -> Float4 {
1562        Float4 { x: self.w, y: self.y, z: self.y, w: self.y }
1563    }
1564
1565    #[inline]
1566    pub const fn wyyz(self) -> Float4 {
1567        Float4 { x: self.w, y: self.y, z: self.y, w: self.z }
1568    }
1569
1570    #[inline]
1571    pub const fn wyyw(self) -> Float4 {
1572        Float4 { x: self.w, y: self.y, z: self.y, w: self.w }
1573    }
1574
1575    #[inline]
1576    pub const fn wyzx(self) -> Float4 {
1577        Float4 { x: self.w, y: self.y, z: self.z, w: self.x }
1578    }
1579
1580    #[inline]
1581    pub const fn wyzy(self) -> Float4 {
1582        Float4 { x: self.w, y: self.y, z: self.z, w: self.y }
1583    }
1584
1585    #[inline]
1586    pub const fn wyzz(self) -> Float4 {
1587        Float4 { x: self.w, y: self.y, z: self.z, w: self.z }
1588    }
1589
1590    #[inline]
1591    pub const fn wyzw(self) -> Float4 {
1592        Float4 { x: self.w, y: self.y, z: self.z, w: self.w }
1593    }
1594
1595    #[inline]
1596    pub const fn wywx(self) -> Float4 {
1597        Float4 { x: self.w, y: self.y, z: self.w, w: self.x }
1598    }
1599
1600    #[inline]
1601    pub const fn wywy(self) -> Float4 {
1602        Float4 { x: self.w, y: self.y, z: self.w, w: self.y }
1603    }
1604
1605    #[inline]
1606    pub const fn wywz(self) -> Float4 {
1607        Float4 { x: self.w, y: self.y, z: self.w, w: self.z }
1608    }
1609
1610    #[inline]
1611    pub const fn wyww(self) -> Float4 {
1612        Float4 { x: self.w, y: self.y, z: self.w, w: self.w }
1613    }
1614
1615    #[inline]
1616    pub const fn wzxx(self) -> Float4 {
1617        Float4 { x: self.w, y: self.z, z: self.x, w: self.x }
1618    }
1619
1620    #[inline]
1621    pub const fn wzxy(self) -> Float4 {
1622        Float4 { x: self.w, y: self.z, z: self.x, w: self.y }
1623    }
1624
1625    #[inline]
1626    pub const fn wzxz(self) -> Float4 {
1627        Float4 { x: self.w, y: self.z, z: self.x, w: self.z }
1628    }
1629
1630    #[inline]
1631    pub const fn wzxw(self) -> Float4 {
1632        Float4 { x: self.w, y: self.z, z: self.x, w: self.w }
1633    }
1634
1635    #[inline]
1636    pub const fn wzyx(self) -> Float4 {
1637        Float4 { x: self.w, y: self.z, z: self.y, w: self.x }
1638    }
1639
1640    #[inline]
1641    pub const fn wzyy(self) -> Float4 {
1642        Float4 { x: self.w, y: self.z, z: self.y, w: self.y }
1643    }
1644
1645    #[inline]
1646    pub const fn wzyz(self) -> Float4 {
1647        Float4 { x: self.w, y: self.z, z: self.y, w: self.z }
1648    }
1649
1650    #[inline]
1651    pub const fn wzyw(self) -> Float4 {
1652        Float4 { x: self.w, y: self.z, z: self.y, w: self.w }
1653    }
1654
1655    #[inline]
1656    pub const fn wzzx(self) -> Float4 {
1657        Float4 { x: self.w, y: self.z, z: self.z, w: self.x }
1658    }
1659
1660    #[inline]
1661    pub const fn wzzy(self) -> Float4 {
1662        Float4 { x: self.w, y: self.z, z: self.z, w: self.y }
1663    }
1664
1665    #[inline]
1666    pub const fn wzzz(self) -> Float4 {
1667        Float4 { x: self.w, y: self.z, z: self.z, w: self.z }
1668    }
1669
1670    #[inline]
1671    pub const fn wzzw(self) -> Float4 {
1672        Float4 { x: self.w, y: self.z, z: self.z, w: self.w }
1673    }
1674
1675    #[inline]
1676    pub const fn wzwx(self) -> Float4 {
1677        Float4 { x: self.w, y: self.z, z: self.w, w: self.x }
1678    }
1679
1680    #[inline]
1681    pub const fn wzwy(self) -> Float4 {
1682        Float4 { x: self.w, y: self.z, z: self.w, w: self.y }
1683    }
1684
1685    #[inline]
1686    pub const fn wzwz(self) -> Float4 {
1687        Float4 { x: self.w, y: self.z, z: self.w, w: self.z }
1688    }
1689
1690    #[inline]
1691    pub const fn wzww(self) -> Float4 {
1692        Float4 { x: self.w, y: self.z, z: self.w, w: self.w }
1693    }
1694    
1695    #[inline]
1696    pub const fn wwxx(self) -> Float4 {
1697        Float4 { x: self.w, y: self.w, z: self.x, w: self.x }
1698    }
1699
1700    #[inline]
1701    pub const fn wwxy(self) -> Float4 {
1702        Float4 { x: self.w, y: self.w, z: self.x, w: self.y }
1703    }
1704
1705    #[inline]
1706    pub const fn wwxz(self) -> Float4 {
1707        Float4 { x: self.w, y: self.w, z: self.x, w: self.z }
1708    }
1709
1710    #[inline]
1711    pub const fn wwxw(self) -> Float4 {
1712        Float4 { x: self.w, y: self.w, z: self.x, w: self.w }
1713    }
1714
1715    #[inline]
1716    pub const fn wwyx(self) -> Float4 {
1717        Float4 { x: self.w, y: self.w, z: self.y, w: self.x }
1718    }
1719
1720    #[inline]
1721    pub const fn wwyy(self) -> Float4 {
1722        Float4 { x: self.w, y: self.w, z: self.y, w: self.y }
1723    }
1724
1725    #[inline]
1726    pub const fn wwyz(self) -> Float4 {
1727        Float4 { x: self.w, y: self.w, z: self.y, w: self.z }
1728    }
1729
1730    #[inline]
1731    pub const fn wwyw(self) -> Float4 {
1732        Float4 { x: self.w, y: self.w, z: self.y, w: self.w }
1733    }
1734
1735    #[inline]
1736    pub const fn wwzx(self) -> Float4 {
1737        Float4 { x: self.w, y: self.w, z: self.z, w: self.x }
1738    }
1739
1740    #[inline]
1741    pub const fn wwzy(self) -> Float4 {
1742        Float4 { x: self.w, y: self.w, z: self.z, w: self.y }
1743    }
1744
1745    #[inline]
1746    pub const fn wwzz(self) -> Float4 {
1747        Float4 { x: self.w, y: self.w, z: self.z, w: self.z }
1748    }
1749
1750    #[inline]
1751    pub const fn wwzw(self) -> Float4 {
1752        Float4 { x: self.w, y: self.w, z: self.z, w: self.w }
1753    }
1754
1755    #[inline]
1756    pub const fn wwwx(self) -> Float4 {
1757        Float4 { x: self.w, y: self.w, z: self.w, w: self.x }
1758    }
1759
1760    #[inline]
1761    pub const fn wwwy(self) -> Float4 {
1762        Float4 { x: self.w, y: self.w, z: self.w, w: self.y }
1763    }
1764
1765    #[inline]
1766    pub const fn wwwz(self) -> Float4 {
1767        Float4 { x: self.w, y: self.w, z: self.w, w: self.z }
1768    }
1769
1770    #[inline]
1771    pub const fn wwww(self) -> Float4 {
1772        Float4 { x: self.w, y: self.w, z: self.w, w: self.w }
1773    }
1774}
1775
1776impl_element4!(f32, Float4);
1777
1778impl_element4_op!(f32, Float4);
1779
1780impl Default for Float4 {
1781    #[inline(always)]
1782    fn default() -> Self {
1783        Self::ZERO
1784    }
1785}
1786
1787impl From<Float2> for Float4 {
1788    #[inline]
1789    fn from(value: Float2) -> Self {
1790        Float4 { x: value.x, y: value.y, z: 0.0, w: 0.0 }
1791    }
1792}
1793
1794impl From<Float3> for Float4 {
1795    #[inline]
1796    fn from(value: Float3) -> Self {
1797        Float4 { x: value.x, y: value.y, z: value.z, w: 0.0 }
1798    }
1799}
1800
1801impl core::ops::Neg for Float4{
1802    type Output = Self;
1803    #[inline]
1804    fn neg(self) -> Self::Output {
1805        Self::Output {
1806            x: -self.x, 
1807            y: -self.y, 
1808            z: -self.z, 
1809            w: -self.w, 
1810        }
1811    }
1812}
gmm/data/float4.rs

gmm/data/
float4.rs
