PintS  0.1
Portable Intrinsics for SIMD
 All Data Structures Files Functions Groups
pints-doc.h
Go to the documentation of this file.
1 
8 //#ifdef PINTS_DOC_H
9 #error "This file should not be included"
10 
51 struct v1d {};
72 struct m1d {};
91 struct v1f {};
112 struct m1f {};
131 struct v1i {};
152 struct m1i {};
171 struct v1l {};
192 struct m1l {};
211 struct v2d {};
232 struct m2d {};
251 struct v2f {};
272 struct m2f {};
291 struct v2i {};
312 struct m2i {};
331 struct v2l {};
352 struct m2l {};
371 struct v4d {};
392 struct m4d {};
411 struct v4f {};
432 struct m4f {};
451 struct v4i {};
472 struct m4i {};
491 struct v4l {};
512 struct m4l {};
531 struct v8d {};
552 struct m8d {};
571 struct v8f {};
592 struct m8f {};
611 struct v8i {};
632 struct m8i {};
651 struct v8l {};
672 struct m8l {};
691 struct v16f {};
712 struct m16f {};
731 struct v16i {};
752 struct m16i {};
753 
754 /* LOADS */
771 v1d v1d_load(const double *p);
784 v1f v1f_load(const float *p);
797 v1i v1i_load(const int32_t *p);
810 v1l v1l_load(const int64_t *p);
823 v2d v2d_load(const double *p);
836 v2f v2f_load(const float *p);
849 v2i v2i_load(const int32_t *p);
862 v2l v2l_load(const int64_t *p);
875 v4d v4d_load(const double *p);
888 v4f v4f_load(const float *p);
901 v4i v4i_load(const int32_t *p);
914 v4l v4l_load(const int64_t *p);
927 v8d v8d_load(const double *p);
940 v8f v8f_load(const float *p);
953 v8i v8i_load(const int32_t *p);
966 v8l v8l_load(const int64_t *p);
979 v16f v16f_load(const float *p);
992 v16i v16i_load(const int32_t *p);
993 
1006 v1d v1d_loadu(const double *p);
1019 v1f v1f_loadu(const float *p);
1032 v1i v1i_loadu(const int32_t *p);
1045 v1l v1l_loadu(const int64_t *p);
1058 v2d v2d_loadu(const double *p);
1071 v2f v2f_loadu(const float *p);
1084 v2i v2i_loadu(const int32_t *p);
1097 v2l v2l_loadu(const int64_t *p);
1110 v4d v4d_loadu(const double *p);
1123 v4f v4f_loadu(const float *p);
1136 v4i v4i_loadu(const int32_t *p);
1149 v4l v4l_loadu(const int64_t *p);
1162 v8d v8d_loadu(const double *p);
1175 v8f v8f_loadu(const float *p);
1188 v8i v8i_loadu(const int32_t *p);
1201 v8l v8l_loadu(const int64_t *p);
1214 v16f v16f_loadu(const float *p);
1227 v16i v16i_loadu(const int32_t *p);
1228 
1244 v1d v1d_load1(const double *p);
1260 v1f v1f_load1(const float *p);
1276 v1i v1i_load1(const int32_t *p);
1292 v1l v1l_load1(const int64_t *p);
1308 v2d v2d_load1(const double *p);
1324 v2f v2f_load1(const float *p);
1340 v2i v2i_load1(const int32_t *p);
1356 v2l v2l_load1(const int64_t *p);
1372 v4d v4d_load1(const double *p);
1388 v4f v4f_load1(const float *p);
1404 v4i v4i_load1(const int32_t *p);
1420 v4l v4l_load1(const int64_t *p);
1436 v8d v8d_load1(const double *p);
1452 v8f v8f_load1(const float *p);
1468 v8i v8i_load1(const int32_t *p);
1484 v8l v8l_load1(const int64_t *p);
1500 v16f v16f_load1(const float *p);
1516 v16i v16i_load1(const int32_t *p);
1517 
1518 
1519 /* STORES */
1536 void v1d_store(double *p, v1d a);
1549 void v1f_store(float *p, v1f a);
1562 void v1i_store(int32_t *p, v1i a);
1575 void v1l_store(int64_t *p, v1l a);
1588 void v2d_store(double *p, v2d a);
1601 void v2f_store(float *p, v2f a);
1614 void v2i_store(int32_t *p, v2i a);
1627 void v2l_store(int64_t *p, v2l a);
1640 void v4d_store(double *p, v4d a);
1653 void v4f_store(float *p, v4f a);
1666 void v4i_store(int32_t *p, v4i a);
1679 void v4l_store(int64_t *p, v4l a);
1692 void v8d_store(double *p, v8d a);
1705 void v8f_store(float *p, v8f a);
1718 void v8i_store(int32_t *p, v8i a);
1731 void v8l_store(int64_t *p, v8l a);
1744 void v16f_store(float *p, v16f a);
1757 void v16i_store(int32_t *p, v16i a);
1758 
1771 void v1d_storeu(double *p, v1d a);
1784 void v1f_storeu(float *p, v1f a);
1797 void v1i_storeu(int32_t *p, v1i a);
1810 void v1l_storeu(int64_t *p, v1l a);
1823 void v2d_storeu(double *p, v2d a);
1836 void v2f_storeu(float *p, v2f a);
1849 void v2i_storeu(int32_t *p, v2i a);
1862 void v2l_storeu(int64_t *p, v2l a);
1875 void v4d_storeu(double *p, v4d a);
1888 void v4f_storeu(float *p, v4f a);
1901 void v4i_storeu(int32_t *p, v4i a);
1914 void v4l_storeu(int64_t *p, v4l a);
1927 void v8d_storeu(double *p, v8d a);
1940 void v8f_storeu(float *p, v8f a);
1953 void v8i_storeu(int32_t *p, v8i a);
1966 void v8l_storeu(int64_t *p, v8l a);
1979 void v16f_storeu(float *p, v16f a);
1992 void v16i_storeu(int32_t *p, v16i a);
1993 
2006 void v1d_store1(double *p, v1d a);
2019 void v1f_store1(float *p, v1f a);
2032 void v1i_store1(int32_t *p, v1i a);
2045 void v1l_store1(int64_t *p, v1l a);
2058 void v2d_store1(double *p, v2d a);
2071 void v2f_store1(float *p, v2f a);
2084 void v2i_store1(int32_t *p, v2i a);
2097 void v2l_store1(int64_t *p, v2l a);
2110 void v4d_store1(double *p, v4d a);
2123 void v4f_store1(float *p, v4f a);
2136 void v4i_store1(int32_t *p, v4i a);
2149 void v4l_store1(int64_t *p, v4l a);
2162 void v8d_store1(double *p, v8d a);
2175 void v8f_store1(float *p, v8f a);
2188 void v8i_store1(int32_t *p, v8i a);
2201 void v8l_store1(int64_t *p, v8l a);
2214 void v16f_store1(float *p, v16f a);
2227 void v16i_store1(int32_t *p, v16i a);
2228 
2229 
2230 /* SETS */
2246 v1d v1d_set(double v0);
2258 v1f v1f_set(float v0);
2270 v1i v1i_set(int32_t v0);
2282 v1l v1l_set(int64_t v0);
2296 v2d v2d_set(double v0, double v1);
2310 v2f v2f_set(float v0, float v1);
2324 v2i v2i_set(int32_t v0, int32_t v1);
2338 v2l v2l_set(int64_t v0, int64_t v1);
2356 v4d v4d_set(double v0, double v1, double v2, double v3);
2374 v4f v4f_set(float v0, float v1, float v2, float v3);
2392 v4i v4i_set(int32_t v0, int32_t v1, int32_t v2, int32_t v3);
2410 v4l v4l_set(int64_t v0, int64_t v1, int64_t v2, int64_t v3);
2436 v8d v8d_set(double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7);
2462 v8f v8f_set(float v0, float v1, float v2, float v3, float v4, float v5, float v6, float v7);
2488 v8i v8i_set(int32_t v0, int32_t v1, int32_t v2, int32_t v3, int32_t v4, int32_t v5, int32_t v6, int32_t v7);
2514 v8l v8l_set(int64_t v0, int64_t v1, int64_t v2, int64_t v3, int64_t v4, int64_t v5, int64_t v6, int64_t v7);
2556 v16f v16f_set(float v0, float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8, float v9, float v10, float v11, float v12, float v13, float v14, float v15);
2598 v16i v16i_set(int32_t v0, int32_t v1, int32_t v2, int32_t v3, int32_t v4, int32_t v5, int32_t v6, int32_t v7, int32_t v8, int32_t v9, int32_t v10, int32_t v11, int32_t v12, int32_t v13, int32_t v14, int32_t v15);
2599 
2611 v1d v1d_rset(double v0);
2623 v1f v1f_rset(float v0);
2635 v1i v1i_rset(int32_t v0);
2647 v1l v1l_rset(int64_t v0);
2661 v2d v2d_rset(double v1, double v0);
2675 v2f v2f_rset(float v1, float v0);
2689 v2i v2i_rset(int32_t v1, int32_t v0);
2703 v2l v2l_rset(int64_t v1, int64_t v0);
2721 v4d v4d_rset(double v3, double v2, double v1, double v0);
2739 v4f v4f_rset(float v3, float v2, float v1, float v0);
2757 v4i v4i_rset(int32_t v3, int32_t v2, int32_t v1, int32_t v0);
2775 v4l v4l_rset(int64_t v3, int64_t v2, int64_t v1, int64_t v0);
2801 v8d v8d_rset(double v7, double v6, double v5, double v4, double v3, double v2, double v1, double v0);
2827 v8f v8f_rset(float v7, float v6, float v5, float v4, float v3, float v2, float v1, float v0);
2853 v8i v8i_rset(int32_t v7, int32_t v6, int32_t v5, int32_t v4, int32_t v3, int32_t v2, int32_t v1, int32_t v0);
2879 v8l v8l_rset(int64_t v7, int64_t v6, int64_t v5, int64_t v4, int64_t v3, int64_t v2, int64_t v1, int64_t v0);
2921 v16f v16f_rset(float v15, float v14, float v13, float v12, float v11, float v10, float v9, float v8, float v7, float v6, float v5, float v4, float v3, float v2, float v1, float v0);
2963 v16i v16i_rset(int32_t v15, int32_t v14, int32_t v13, int32_t v12, int32_t v11, int32_t v10, int32_t v9, int32_t v8, int32_t v7, int32_t v6, int32_t v5, int32_t v4, int32_t v3, int32_t v2, int32_t v1, int32_t v0);
2964 
2978 v1d v1d_set1(double v);
2992 v1f v1f_set1(float v);
3006 v1i v1i_set1(int32_t v);
3020 v1l v1l_set1(int64_t v);
3034 v2d v2d_set1(double v);
3048 v2f v2f_set1(float v);
3062 v2i v2i_set1(int32_t v);
3076 v2l v2l_set1(int64_t v);
3090 v4d v4d_set1(double v);
3104 v4f v4f_set1(float v);
3118 v4i v4i_set1(int32_t v);
3132 v4l v4l_set1(int64_t v);
3146 v8d v8d_set1(double v);
3160 v8f v8f_set1(float v);
3174 v8i v8i_set1(int32_t v);
3188 v8l v8l_set1(int64_t v);
3202 v16f v16f_set1(float v);
3216 v16i v16i_set1(int32_t v);
3217 
3218 /* CONSTANTS */
3229 v1d v1d_zeros();
3240 v1f v1f_zeros();
3251 v1i v1i_zeros();
3262 v1l v1l_zeros();
3273 v2d v2d_zeros();
3284 v2f v2f_zeros();
3295 v2i v2i_zeros();
3306 v2l v2l_zeros();
3317 v4d v4d_zeros();
3328 v4f v4f_zeros();
3339 v4i v4i_zeros();
3350 v4l v4l_zeros();
3361 v8d v8d_zeros();
3372 v8f v8f_zeros();
3383 v8i v8i_zeros();
3394 v8l v8l_zeros();
3405 v16f v16f_zeros();
3416 v16i v16i_zeros();
3427 v1d v1d_ones();
3438 v1f v1f_ones();
3449 v1i v1i_ones();
3460 v1l v1l_ones();
3471 v2d v2d_ones();
3482 v2f v2f_ones();
3493 v2i v2i_ones();
3504 v2l v2l_ones();
3515 v4d v4d_ones();
3526 v4f v4f_ones();
3537 v4i v4i_ones();
3548 v4l v4l_ones();
3559 v8d v8d_ones();
3570 v8f v8f_ones();
3581 v8i v8i_ones();
3592 v8l v8l_ones();
3603 v16f v16f_ones();
3614 v16i v16i_ones();
3627 v1d v1d_zero();
3640 v1f v1f_zero();
3653 v1i v1i_zero();
3666 v1l v1l_zero();
3679 v2d v2d_zero();
3692 v2f v2f_zero();
3705 v2i v2i_zero();
3718 v2l v2l_zero();
3731 v4d v4d_zero();
3744 v4f v4f_zero();
3757 v4i v4i_zero();
3770 v4l v4l_zero();
3783 v8d v8d_zero();
3796 v8f v8f_zero();
3809 v8i v8i_zero();
3822 v8l v8l_zero();
3835 v16f v16f_zero();
3848 v16i v16i_zero();
3861 v1d v1d_one();
3874 v1f v1f_one();
3887 v1i v1i_one();
3900 v1l v1l_one();
3913 v2d v2d_one();
3926 v2f v2f_one();
3939 v2i v2i_one();
3952 v2l v2l_one();
3965 v4d v4d_one();
3978 v4f v4f_one();
3991 v4i v4i_one();
4004 v4l v4l_one();
4017 v8d v8d_one();
4030 v8f v8f_one();
4043 v8i v8i_one();
4056 v8l v8l_one();
4069 v16f v16f_one();
4082 v16i v16i_one();
4083 
4084 
4085 /* COMPARISONS */
4110 m1d m1d_eq(v1d a, v1d b);
4130 m1f m1f_eq(v1f a, v1f b);
4150 m1i m1i_eq(v1i a, v1i b);
4170 m1l m1l_eq(v1l a, v1l b);
4190 m2d m2d_eq(v2d a, v2d b);
4210 m2f m2f_eq(v2f a, v2f b);
4230 m2i m2i_eq(v2i a, v2i b);
4250 m2l m2l_eq(v2l a, v2l b);
4270 m4d m4d_eq(v4d a, v4d b);
4290 m4f m4f_eq(v4f a, v4f b);
4310 m4i m4i_eq(v4i a, v4i b);
4330 m4l m4l_eq(v4l a, v4l b);
4350 m8d m8d_eq(v8d a, v8d b);
4370 m8f m8f_eq(v8f a, v8f b);
4390 m8i m8i_eq(v8i a, v8i b);
4410 m8l m8l_eq(v8l a, v8l b);
4430 m16f m16f_eq(v16f a, v16f b);
4450 m16i m16i_eq(v16i a, v16i b);
4451 
4471 m1d m1d_neq(v1d a, v1d b);
4491 m1f m1f_neq(v1f a, v1f b);
4511 m1i m1i_neq(v1i a, v1i b);
4531 m1l m1l_neq(v1l a, v1l b);
4551 m2d m2d_neq(v2d a, v2d b);
4571 m2f m2f_neq(v2f a, v2f b);
4591 m2i m2i_neq(v2i a, v2i b);
4611 m2l m2l_neq(v2l a, v2l b);
4631 m4d m4d_neq(v4d a, v4d b);
4651 m4f m4f_neq(v4f a, v4f b);
4671 m4i m4i_neq(v4i a, v4i b);
4691 m4l m4l_neq(v4l a, v4l b);
4711 m8d m8d_neq(v8d a, v8d b);
4731 m8f m8f_neq(v8f a, v8f b);
4751 m8i m8i_neq(v8i a, v8i b);
4771 m8l m8l_neq(v8l a, v8l b);
4791 m16f m16f_neq(v16f a, v16f b);
4811 m16i m16i_neq(v16i a, v16i b);
4812 
4832 m1d m1d_gt(v1d a, v1d b);
4852 m1f m1f_gt(v1f a, v1f b);
4872 m1i m1i_gt(v1i a, v1i b);
4892 m1l m1l_gt(v1l a, v1l b);
4912 m2d m2d_gt(v2d a, v2d b);
4932 m2f m2f_gt(v2f a, v2f b);
4952 m2i m2i_gt(v2i a, v2i b);
4972 m2l m2l_gt(v2l a, v2l b);
4992 m4d m4d_gt(v4d a, v4d b);
5012 m4f m4f_gt(v4f a, v4f b);
5032 m4i m4i_gt(v4i a, v4i b);
5052 m4l m4l_gt(v4l a, v4l b);
5072 m8d m8d_gt(v8d a, v8d b);
5092 m8f m8f_gt(v8f a, v8f b);
5112 m8i m8i_gt(v8i a, v8i b);
5132 m8l m8l_gt(v8l a, v8l b);
5152 m16f m16f_gt(v16f a, v16f b);
5172 m16i m16i_gt(v16i a, v16i b);
5173 
5193 m1d m1d_geq(v1d a, v1d b);
5213 m1f m1f_geq(v1f a, v1f b);
5233 m1i m1i_geq(v1i a, v1i b);
5253 m1l m1l_geq(v1l a, v1l b);
5273 m2d m2d_geq(v2d a, v2d b);
5293 m2f m2f_geq(v2f a, v2f b);
5313 m2i m2i_geq(v2i a, v2i b);
5333 m2l m2l_geq(v2l a, v2l b);
5353 m4d m4d_geq(v4d a, v4d b);
5373 m4f m4f_geq(v4f a, v4f b);
5393 m4i m4i_geq(v4i a, v4i b);
5413 m4l m4l_geq(v4l a, v4l b);
5433 m8d m8d_geq(v8d a, v8d b);
5453 m8f m8f_geq(v8f a, v8f b);
5473 m8i m8i_geq(v8i a, v8i b);
5493 m8l m8l_geq(v8l a, v8l b);
5513 m16f m16f_geq(v16f a, v16f b);
5533 m16i m16i_geq(v16i a, v16i b);
5534 
5554 m1d m1d_lt(v1d a, v1d b);
5574 m1f m1f_lt(v1f a, v1f b);
5594 m1i m1i_lt(v1i a, v1i b);
5614 m1l m1l_lt(v1l a, v1l b);
5634 m2d m2d_lt(v2d a, v2d b);
5654 m2f m2f_lt(v2f a, v2f b);
5674 m2i m2i_lt(v2i a, v2i b);
5694 m2l m2l_lt(v2l a, v2l b);
5714 m4d m4d_lt(v4d a, v4d b);
5734 m4f m4f_lt(v4f a, v4f b);
5754 m4i m4i_lt(v4i a, v4i b);
5774 m4l m4l_lt(v4l a, v4l b);
5794 m8d m8d_lt(v8d a, v8d b);
5814 m8f m8f_lt(v8f a, v8f b);
5834 m8i m8i_lt(v8i a, v8i b);
5854 m8l m8l_lt(v8l a, v8l b);
5874 m16f m16f_lt(v16f a, v16f b);
5894 m16i m16i_lt(v16i a, v16i b);
5895 
5915 m1d m1d_leq(v1d a, v1d b);
5935 m1f m1f_leq(v1f a, v1f b);
5955 m1i m1i_leq(v1i a, v1i b);
5975 m1l m1l_leq(v1l a, v1l b);
5995 m2d m2d_leq(v2d a, v2d b);
6015 m2f m2f_leq(v2f a, v2f b);
6035 m2i m2i_leq(v2i a, v2i b);
6055 m2l m2l_leq(v2l a, v2l b);
6075 m4d m4d_leq(v4d a, v4d b);
6095 m4f m4f_leq(v4f a, v4f b);
6115 m4i m4i_leq(v4i a, v4i b);
6135 m4l m4l_leq(v4l a, v4l b);
6155 m8d m8d_leq(v8d a, v8d b);
6175 m8f m8f_leq(v8f a, v8f b);
6195 m8i m8i_leq(v8i a, v8i b);
6215 m8l m8l_leq(v8l a, v8l b);
6235 m16f m16f_leq(v16f a, v16f b);
6255 m16i m16i_leq(v16i a, v16i b);
6256 
6257 
6258 /* LOGIC */
6276 m1d m1d_and(m1d a, m1d b);
6289 m1f m1f_and(m1f a, m1f b);
6302 m1i m1i_and(m1i a, m1i b);
6315 m1l m1l_and(m1l a, m1l b);
6328 m2d m2d_and(m2d a, m2d b);
6341 m2f m2f_and(m2f a, m2f b);
6354 m2i m2i_and(m2i a, m2i b);
6367 m2l m2l_and(m2l a, m2l b);
6380 m4d m4d_and(m4d a, m4d b);
6393 m4f m4f_and(m4f a, m4f b);
6406 m4i m4i_and(m4i a, m4i b);
6419 m4l m4l_and(m4l a, m4l b);
6432 m8d m8d_and(m8d a, m8d b);
6445 m8f m8f_and(m8f a, m8f b);
6458 m8i m8i_and(m8i a, m8i b);
6471 m8l m8l_and(m8l a, m8l b);
6484 m16f m16f_and(m16f a, m16f b);
6497 m16i m16i_and(m16i a, m16i b);
6498 
6511 m1d m1d_or(m1d a, m1d b);
6524 m1f m1f_or(m1f a, m1f b);
6537 m1i m1i_or(m1i a, m1i b);
6550 m1l m1l_or(m1l a, m1l b);
6563 m2d m2d_or(m2d a, m2d b);
6576 m2f m2f_or(m2f a, m2f b);
6589 m2i m2i_or(m2i a, m2i b);
6602 m2l m2l_or(m2l a, m2l b);
6615 m4d m4d_or(m4d a, m4d b);
6628 m4f m4f_or(m4f a, m4f b);
6641 m4i m4i_or(m4i a, m4i b);
6654 m4l m4l_or(m4l a, m4l b);
6667 m8d m8d_or(m8d a, m8d b);
6680 m8f m8f_or(m8f a, m8f b);
6693 m8i m8i_or(m8i a, m8i b);
6706 m8l m8l_or(m8l a, m8l b);
6719 m16f m16f_or(m16f a, m16f b);
6732 m16i m16i_or(m16i a, m16i b);
6733 
6746 m1d m1d_xor(m1d a, m1d b);
6759 m1f m1f_xor(m1f a, m1f b);
6772 m1i m1i_xor(m1i a, m1i b);
6785 m1l m1l_xor(m1l a, m1l b);
6798 m2d m2d_xor(m2d a, m2d b);
6811 m2f m2f_xor(m2f a, m2f b);
6824 m2i m2i_xor(m2i a, m2i b);
6837 m2l m2l_xor(m2l a, m2l b);
6850 m4d m4d_xor(m4d a, m4d b);
6863 m4f m4f_xor(m4f a, m4f b);
6876 m4i m4i_xor(m4i a, m4i b);
6889 m4l m4l_xor(m4l a, m4l b);
6902 m8d m8d_xor(m8d a, m8d b);
6915 m8f m8f_xor(m8f a, m8f b);
6928 m8i m8i_xor(m8i a, m8i b);
6941 m8l m8l_xor(m8l a, m8l b);
6954 m16f m16f_xor(m16f a, m16f b);
6967 m16i m16i_xor(m16i a, m16i b);
6968 
6980 m1d m1d_not(m1d a);
6992 m1f m1f_not(m1f a);
7004 m1i m1i_not(m1i a);
7016 m1l m1l_not(m1l a);
7028 m2d m2d_not(m2d a);
7040 m2f m2f_not(m2f a);
7052 m2i m2i_not(m2i a);
7064 m2l m2l_not(m2l a);
7076 m4d m4d_not(m4d a);
7088 m4f m4f_not(m4f a);
7100 m4i m4i_not(m4i a);
7112 m4l m4l_not(m4l a);
7124 m8d m8d_not(m8d a);
7136 m8f m8f_not(m8f a);
7148 m8i m8i_not(m8i a);
7160 m8l m8l_not(m8l a);
7172 m16f m16f_not(m16f a);
7184 m16i m16i_not(m16i a);
7185 
7204 m1d m1d_nand(m1d a, m1d b);
7223 m1f m1f_nand(m1f a, m1f b);
7242 m1i m1i_nand(m1i a, m1i b);
7261 m1l m1l_nand(m1l a, m1l b);
7280 m2d m2d_nand(m2d a, m2d b);
7299 m2f m2f_nand(m2f a, m2f b);
7318 m2i m2i_nand(m2i a, m2i b);
7337 m2l m2l_nand(m2l a, m2l b);
7356 m4d m4d_nand(m4d a, m4d b);
7375 m4f m4f_nand(m4f a, m4f b);
7394 m4i m4i_nand(m4i a, m4i b);
7413 m4l m4l_nand(m4l a, m4l b);
7432 m8d m8d_nand(m8d a, m8d b);
7451 m8f m8f_nand(m8f a, m8f b);
7470 m8i m8i_nand(m8i a, m8i b);
7489 m8l m8l_nand(m8l a, m8l b);
7508 m16f m16f_nand(m16f a, m16f b);
7527 m16i m16i_nand(m16i a, m16i b);
7528 
7547 m1d m1d_nor(m1d a, m1d b);
7566 m1f m1f_nor(m1f a, m1f b);
7585 m1i m1i_nor(m1i a, m1i b);
7604 m1l m1l_nor(m1l a, m1l b);
7623 m2d m2d_nor(m2d a, m2d b);
7642 m2f m2f_nor(m2f a, m2f b);
7661 m2i m2i_nor(m2i a, m2i b);
7680 m2l m2l_nor(m2l a, m2l b);
7699 m4d m4d_nor(m4d a, m4d b);
7718 m4f m4f_nor(m4f a, m4f b);
7737 m4i m4i_nor(m4i a, m4i b);
7756 m4l m4l_nor(m4l a, m4l b);
7775 m8d m8d_nor(m8d a, m8d b);
7794 m8f m8f_nor(m8f a, m8f b);
7813 m8i m8i_nor(m8i a, m8i b);
7832 m8l m8l_nor(m8l a, m8l b);
7851 m16f m16f_nor(m16f a, m16f b);
7870 m16i m16i_nor(m16i a, m16i b);
7871 
7888 m1d m1d_nxor(m1d a, m1d b);
7905 m1f m1f_nxor(m1f a, m1f b);
7922 m1i m1i_nxor(m1i a, m1i b);
7939 m1l m1l_nxor(m1l a, m1l b);
7956 m2d m2d_nxor(m2d a, m2d b);
7973 m2f m2f_nxor(m2f a, m2f b);
7990 m2i m2i_nxor(m2i a, m2i b);
8007 m2l m2l_nxor(m2l a, m2l b);
8024 m4d m4d_nxor(m4d a, m4d b);
8041 m4f m4f_nxor(m4f a, m4f b);
8058 m4i m4i_nxor(m4i a, m4i b);
8075 m4l m4l_nxor(m4l a, m4l b);
8092 m8d m8d_nxor(m8d a, m8d b);
8109 m8f m8f_nxor(m8f a, m8f b);
8126 m8i m8i_nxor(m8i a, m8i b);
8143 m8l m8l_nxor(m8l a, m8l b);
8160 m16f m16f_nxor(m16f a, m16f b);
8177 m16i m16i_nxor(m16i a, m16i b);
8178 
8197 m1d m1d_andnot(m1d a, m1d b);
8216 m1f m1f_andnot(m1f a, m1f b);
8235 m1i m1i_andnot(m1i a, m1i b);
8254 m1l m1l_andnot(m1l a, m1l b);
8273 m2d m2d_andnot(m2d a, m2d b);
8292 m2f m2f_andnot(m2f a, m2f b);
8311 m2i m2i_andnot(m2i a, m2i b);
8330 m2l m2l_andnot(m2l a, m2l b);
8349 m4d m4d_andnot(m4d a, m4d b);
8368 m4f m4f_andnot(m4f a, m4f b);
8387 m4i m4i_andnot(m4i a, m4i b);
8406 m4l m4l_andnot(m4l a, m4l b);
8425 m8d m8d_andnot(m8d a, m8d b);
8444 m8f m8f_andnot(m8f a, m8f b);
8463 m8i m8i_andnot(m8i a, m8i b);
8482 m8l m8l_andnot(m8l a, m8l b);
8501 m16f m16f_andnot(m16f a, m16f b);
8520 m16i m16i_andnot(m16i a, m16i b);
8521 
8540 m1d m1d_ornot(m1d a, m1d b);
8559 m1f m1f_ornot(m1f a, m1f b);
8578 m1i m1i_ornot(m1i a, m1i b);
8597 m1l m1l_ornot(m1l a, m1l b);
8616 m2d m2d_ornot(m2d a, m2d b);
8635 m2f m2f_ornot(m2f a, m2f b);
8654 m2i m2i_ornot(m2i a, m2i b);
8673 m2l m2l_ornot(m2l a, m2l b);
8692 m4d m4d_ornot(m4d a, m4d b);
8711 m4f m4f_ornot(m4f a, m4f b);
8730 m4i m4i_ornot(m4i a, m4i b);
8749 m4l m4l_ornot(m4l a, m4l b);
8768 m8d m8d_ornot(m8d a, m8d b);
8787 m8f m8f_ornot(m8f a, m8f b);
8806 m8i m8i_ornot(m8i a, m8i b);
8825 m8l m8l_ornot(m8l a, m8l b);
8844 m16f m16f_ornot(m16f a, m16f b);
8863 m16i m16i_ornot(m16i a, m16i b);
8864 
8865 
8866 /* COMPARISONS */
8892 v1d v1d_eq(v1d a, v1d b);
8914 v1f v1f_eq(v1f a, v1f b);
8936 v1i v1i_eq(v1i a, v1i b);
8958 v1l v1l_eq(v1l a, v1l b);
8980 v2d v2d_eq(v2d a, v2d b);
9002 v2f v2f_eq(v2f a, v2f b);
9024 v2i v2i_eq(v2i a, v2i b);
9046 v2l v2l_eq(v2l a, v2l b);
9068 v4d v4d_eq(v4d a, v4d b);
9090 v4f v4f_eq(v4f a, v4f b);
9112 v4i v4i_eq(v4i a, v4i b);
9134 v4l v4l_eq(v4l a, v4l b);
9156 v8d v8d_eq(v8d a, v8d b);
9178 v8f v8f_eq(v8f a, v8f b);
9200 v8i v8i_eq(v8i a, v8i b);
9222 v8l v8l_eq(v8l a, v8l b);
9244 v16f v16f_eq(v16f a, v16f b);
9266 v16i v16i_eq(v16i a, v16i b);
9267 
9289 v1d v1d_neq(v1d a, v1d b);
9311 v1f v1f_neq(v1f a, v1f b);
9333 v1i v1i_neq(v1i a, v1i b);
9355 v1l v1l_neq(v1l a, v1l b);
9377 v2d v2d_neq(v2d a, v2d b);
9399 v2f v2f_neq(v2f a, v2f b);
9421 v2i v2i_neq(v2i a, v2i b);
9443 v2l v2l_neq(v2l a, v2l b);
9465 v4d v4d_neq(v4d a, v4d b);
9487 v4f v4f_neq(v4f a, v4f b);
9509 v4i v4i_neq(v4i a, v4i b);
9531 v4l v4l_neq(v4l a, v4l b);
9553 v8d v8d_neq(v8d a, v8d b);
9575 v8f v8f_neq(v8f a, v8f b);
9597 v8i v8i_neq(v8i a, v8i b);
9619 v8l v8l_neq(v8l a, v8l b);
9641 v16f v16f_neq(v16f a, v16f b);
9663 v16i v16i_neq(v16i a, v16i b);
9664 
9686 v1d v1d_gt(v1d a, v1d b);
9708 v1f v1f_gt(v1f a, v1f b);
9730 v1i v1i_gt(v1i a, v1i b);
9752 v1l v1l_gt(v1l a, v1l b);
9774 v2d v2d_gt(v2d a, v2d b);
9796 v2f v2f_gt(v2f a, v2f b);
9818 v2i v2i_gt(v2i a, v2i b);
9840 v2l v2l_gt(v2l a, v2l b);
9862 v4d v4d_gt(v4d a, v4d b);
9884 v4f v4f_gt(v4f a, v4f b);
9906 v4i v4i_gt(v4i a, v4i b);
9928 v4l v4l_gt(v4l a, v4l b);
9950 v8d v8d_gt(v8d a, v8d b);
9972 v8f v8f_gt(v8f a, v8f b);
9994 v8i v8i_gt(v8i a, v8i b);
10016 v8l v8l_gt(v8l a, v8l b);
10038 v16f v16f_gt(v16f a, v16f b);
10060 v16i v16i_gt(v16i a, v16i b);
10061 
10083 v1d v1d_geq(v1d a, v1d b);
10105 v1f v1f_geq(v1f a, v1f b);
10127 v1i v1i_geq(v1i a, v1i b);
10149 v1l v1l_geq(v1l a, v1l b);
10171 v2d v2d_geq(v2d a, v2d b);
10193 v2f v2f_geq(v2f a, v2f b);
10215 v2i v2i_geq(v2i a, v2i b);
10237 v2l v2l_geq(v2l a, v2l b);
10259 v4d v4d_geq(v4d a, v4d b);
10281 v4f v4f_geq(v4f a, v4f b);
10303 v4i v4i_geq(v4i a, v4i b);
10325 v4l v4l_geq(v4l a, v4l b);
10347 v8d v8d_geq(v8d a, v8d b);
10369 v8f v8f_geq(v8f a, v8f b);
10391 v8i v8i_geq(v8i a, v8i b);
10413 v8l v8l_geq(v8l a, v8l b);
10435 v16f v16f_geq(v16f a, v16f b);
10457 v16i v16i_geq(v16i a, v16i b);
10458 
10480 v1d v1d_lt(v1d a, v1d b);
10502 v1f v1f_lt(v1f a, v1f b);
10524 v1i v1i_lt(v1i a, v1i b);
10546 v1l v1l_lt(v1l a, v1l b);
10568 v2d v2d_lt(v2d a, v2d b);
10590 v2f v2f_lt(v2f a, v2f b);
10612 v2i v2i_lt(v2i a, v2i b);
10634 v2l v2l_lt(v2l a, v2l b);
10656 v4d v4d_lt(v4d a, v4d b);
10678 v4f v4f_lt(v4f a, v4f b);
10700 v4i v4i_lt(v4i a, v4i b);
10722 v4l v4l_lt(v4l a, v4l b);
10744 v8d v8d_lt(v8d a, v8d b);
10766 v8f v8f_lt(v8f a, v8f b);
10788 v8i v8i_lt(v8i a, v8i b);
10810 v8l v8l_lt(v8l a, v8l b);
10832 v16f v16f_lt(v16f a, v16f b);
10854 v16i v16i_lt(v16i a, v16i b);
10855 
10877 v1d v1d_leq(v1d a, v1d b);
10899 v1f v1f_leq(v1f a, v1f b);
10921 v1i v1i_leq(v1i a, v1i b);
10943 v1l v1l_leq(v1l a, v1l b);
10965 v2d v2d_leq(v2d a, v2d b);
10987 v2f v2f_leq(v2f a, v2f b);
11009 v2i v2i_leq(v2i a, v2i b);
11031 v2l v2l_leq(v2l a, v2l b);
11053 v4d v4d_leq(v4d a, v4d b);
11075 v4f v4f_leq(v4f a, v4f b);
11097 v4i v4i_leq(v4i a, v4i b);
11119 v4l v4l_leq(v4l a, v4l b);
11141 v8d v8d_leq(v8d a, v8d b);
11163 v8f v8f_leq(v8f a, v8f b);
11185 v8i v8i_leq(v8i a, v8i b);
11207 v8l v8l_leq(v8l a, v8l b);
11229 v16f v16f_leq(v16f a, v16f b);
11251 v16i v16i_leq(v16i a, v16i b);
11252 
11253 /* LOGIC */
11270 v1d v1d_and(v1d a, v1d b);
11283 v1f v1f_and(v1f a, v1f b);
11296 v1i v1i_and(v1i a, v1i b);
11309 v1l v1l_and(v1l a, v1l b);
11322 v2d v2d_and(v2d a, v2d b);
11335 v2f v2f_and(v2f a, v2f b);
11348 v2i v2i_and(v2i a, v2i b);
11361 v2l v2l_and(v2l a, v2l b);
11374 v4d v4d_and(v4d a, v4d b);
11387 v4f v4f_and(v4f a, v4f b);
11400 v4i v4i_and(v4i a, v4i b);
11413 v4l v4l_and(v4l a, v4l b);
11426 v8d v8d_and(v8d a, v8d b);
11439 v8f v8f_and(v8f a, v8f b);
11452 v8i v8i_and(v8i a, v8i b);
11465 v8l v8l_and(v8l a, v8l b);
11478 v16f v16f_and(v16f a, v16f b);
11491 v16i v16i_and(v16i a, v16i b);
11492 
11505 v1d v1d_or(v1d a, v1d b);
11518 v1f v1f_or(v1f a, v1f b);
11531 v1i v1i_or(v1i a, v1i b);
11544 v1l v1l_or(v1l a, v1l b);
11557 v2d v2d_or(v2d a, v2d b);
11570 v2f v2f_or(v2f a, v2f b);
11583 v2i v2i_or(v2i a, v2i b);
11596 v2l v2l_or(v2l a, v2l b);
11609 v4d v4d_or(v4d a, v4d b);
11622 v4f v4f_or(v4f a, v4f b);
11635 v4i v4i_or(v4i a, v4i b);
11648 v4l v4l_or(v4l a, v4l b);
11661 v8d v8d_or(v8d a, v8d b);
11674 v8f v8f_or(v8f a, v8f b);
11687 v8i v8i_or(v8i a, v8i b);
11700 v8l v8l_or(v8l a, v8l b);
11713 v16f v16f_or(v16f a, v16f b);
11726 v16i v16i_or(v16i a, v16i b);
11727 
11740 v1d v1d_xor(v1d a, v1d b);
11753 v1f v1f_xor(v1f a, v1f b);
11766 v1i v1i_xor(v1i a, v1i b);
11779 v1l v1l_xor(v1l a, v1l b);
11792 v2d v2d_xor(v2d a, v2d b);
11805 v2f v2f_xor(v2f a, v2f b);
11818 v2i v2i_xor(v2i a, v2i b);
11831 v2l v2l_xor(v2l a, v2l b);
11844 v4d v4d_xor(v4d a, v4d b);
11857 v4f v4f_xor(v4f a, v4f b);
11870 v4i v4i_xor(v4i a, v4i b);
11883 v4l v4l_xor(v4l a, v4l b);
11896 v8d v8d_xor(v8d a, v8d b);
11909 v8f v8f_xor(v8f a, v8f b);
11922 v8i v8i_xor(v8i a, v8i b);
11935 v8l v8l_xor(v8l a, v8l b);
11948 v16f v16f_xor(v16f a, v16f b);
11961 v16i v16i_xor(v16i a, v16i b);
11962 
11974 v1d v1d_not(v1d a);
11986 v1f v1f_not(v1f a);
11998 v1i v1i_not(v1i a);
12010 v1l v1l_not(v1l a);
12022 v2d v2d_not(v2d a);
12034 v2f v2f_not(v2f a);
12046 v2i v2i_not(v2i a);
12058 v2l v2l_not(v2l a);
12070 v4d v4d_not(v4d a);
12082 v4f v4f_not(v4f a);
12094 v4i v4i_not(v4i a);
12106 v4l v4l_not(v4l a);
12118 v8d v8d_not(v8d a);
12130 v8f v8f_not(v8f a);
12142 v8i v8i_not(v8i a);
12154 v8l v8l_not(v8l a);
12166 v16f v16f_not(v16f a);
12178 v16i v16i_not(v16i a);
12179 
12198 v1d v1d_nand(v1d a, v1d b);
12217 v1f v1f_nand(v1f a, v1f b);
12236 v1i v1i_nand(v1i a, v1i b);
12255 v1l v1l_nand(v1l a, v1l b);
12274 v2d v2d_nand(v2d a, v2d b);
12293 v2f v2f_nand(v2f a, v2f b);
12312 v2i v2i_nand(v2i a, v2i b);
12331 v2l v2l_nand(v2l a, v2l b);
12350 v4d v4d_nand(v4d a, v4d b);
12369 v4f v4f_nand(v4f a, v4f b);
12388 v4i v4i_nand(v4i a, v4i b);
12407 v4l v4l_nand(v4l a, v4l b);
12426 v8d v8d_nand(v8d a, v8d b);
12445 v8f v8f_nand(v8f a, v8f b);
12464 v8i v8i_nand(v8i a, v8i b);
12483 v8l v8l_nand(v8l a, v8l b);
12502 v16f v16f_nand(v16f a, v16f b);
12521 v16i v16i_nand(v16i a, v16i b);
12522 
12541 v1d v1d_nor(v1d a, v1d b);
12560 v1f v1f_nor(v1f a, v1f b);
12579 v1i v1i_nor(v1i a, v1i b);
12598 v1l v1l_nor(v1l a, v1l b);
12617 v2d v2d_nor(v2d a, v2d b);
12636 v2f v2f_nor(v2f a, v2f b);
12655 v2i v2i_nor(v2i a, v2i b);
12674 v2l v2l_nor(v2l a, v2l b);
12693 v4d v4d_nor(v4d a, v4d b);
12712 v4f v4f_nor(v4f a, v4f b);
12731 v4i v4i_nor(v4i a, v4i b);
12750 v4l v4l_nor(v4l a, v4l b);
12769 v8d v8d_nor(v8d a, v8d b);
12788 v8f v8f_nor(v8f a, v8f b);
12807 v8i v8i_nor(v8i a, v8i b);
12826 v8l v8l_nor(v8l a, v8l b);
12845 v16f v16f_nor(v16f a, v16f b);
12864 v16i v16i_nor(v16i a, v16i b);
12865 
12882 v1d v1d_nxor(v1d a, v1d b);
12899 v1f v1f_nxor(v1f a, v1f b);
12916 v1i v1i_nxor(v1i a, v1i b);
12933 v1l v1l_nxor(v1l a, v1l b);
12950 v2d v2d_nxor(v2d a, v2d b);
12967 v2f v2f_nxor(v2f a, v2f b);
12984 v2i v2i_nxor(v2i a, v2i b);
13001 v2l v2l_nxor(v2l a, v2l b);
13018 v4d v4d_nxor(v4d a, v4d b);
13035 v4f v4f_nxor(v4f a, v4f b);
13052 v4i v4i_nxor(v4i a, v4i b);
13069 v4l v4l_nxor(v4l a, v4l b);
13086 v8d v8d_nxor(v8d a, v8d b);
13103 v8f v8f_nxor(v8f a, v8f b);
13120 v8i v8i_nxor(v8i a, v8i b);
13137 v8l v8l_nxor(v8l a, v8l b);
13154 v16f v16f_nxor(v16f a, v16f b);
13171 v16i v16i_nxor(v16i a, v16i b);
13172 
13191 v1d v1d_andnot(v1d a, v1d b);
13210 v1f v1f_andnot(v1f a, v1f b);
13229 v1i v1i_andnot(v1i a, v1i b);
13248 v1l v1l_andnot(v1l a, v1l b);
13267 v2d v2d_andnot(v2d a, v2d b);
13286 v2f v2f_andnot(v2f a, v2f b);
13305 v2i v2i_andnot(v2i a, v2i b);
13324 v2l v2l_andnot(v2l a, v2l b);
13343 v4d v4d_andnot(v4d a, v4d b);
13362 v4f v4f_andnot(v4f a, v4f b);
13381 v4i v4i_andnot(v4i a, v4i b);
13400 v4l v4l_andnot(v4l a, v4l b);
13419 v8d v8d_andnot(v8d a, v8d b);
13438 v8f v8f_andnot(v8f a, v8f b);
13457 v8i v8i_andnot(v8i a, v8i b);
13476 v8l v8l_andnot(v8l a, v8l b);
13495 v16f v16f_andnot(v16f a, v16f b);
13514 v16i v16i_andnot(v16i a, v16i b);
13515 
13534 v1d v1d_ornot(v1d a, v1d b);
13553 v1f v1f_ornot(v1f a, v1f b);
13572 v1i v1i_ornot(v1i a, v1i b);
13591 v1l v1l_ornot(v1l a, v1l b);
13610 v2d v2d_ornot(v2d a, v2d b);
13629 v2f v2f_ornot(v2f a, v2f b);
13648 v2i v2i_ornot(v2i a, v2i b);
13667 v2l v2l_ornot(v2l a, v2l b);
13686 v4d v4d_ornot(v4d a, v4d b);
13705 v4f v4f_ornot(v4f a, v4f b);
13724 v4i v4i_ornot(v4i a, v4i b);
13743 v4l v4l_ornot(v4l a, v4l b);
13762 v8d v8d_ornot(v8d a, v8d b);
13781 v8f v8f_ornot(v8f a, v8f b);
13800 v8i v8i_ornot(v8i a, v8i b);
13819 v8l v8l_ornot(v8l a, v8l b);
13838 v16f v16f_ornot(v16f a, v16f b);
13857 v16i v16i_ornot(v16i a, v16i b);
13858 
13859 
13860 /* ARITHMETIC AND MATH */
13883 v1d v1d_add(v1d a, v1d b);
13898 v1f v1f_add(v1f a, v1f b);
13913 v1i v1i_add(v1i a, v1i b);
13928 v1l v1l_add(v1l a, v1l b);
13943 v2d v2d_add(v2d a, v2d b);
13958 v2f v2f_add(v2f a, v2f b);
13973 v2i v2i_add(v2i a, v2i b);
13988 v2l v2l_add(v2l a, v2l b);
14003 v4d v4d_add(v4d a, v4d b);
14018 v4f v4f_add(v4f a, v4f b);
14033 v4i v4i_add(v4i a, v4i b);
14048 v4l v4l_add(v4l a, v4l b);
14063 v8d v8d_add(v8d a, v8d b);
14078 v8f v8f_add(v8f a, v8f b);
14093 v8i v8i_add(v8i a, v8i b);
14108 v8l v8l_add(v8l a, v8l b);
14123 v16f v16f_add(v16f a, v16f b);
14138 v16i v16i_add(v16i a, v16i b);
14139 
14154 v1d v1d_sub(v1d a, v1d b);
14169 v1f v1f_sub(v1f a, v1f b);
14184 v1i v1i_sub(v1i a, v1i b);
14199 v1l v1l_sub(v1l a, v1l b);
14214 v2d v2d_sub(v2d a, v2d b);
14229 v2f v2f_sub(v2f a, v2f b);
14244 v2i v2i_sub(v2i a, v2i b);
14259 v2l v2l_sub(v2l a, v2l b);
14274 v4d v4d_sub(v4d a, v4d b);
14289 v4f v4f_sub(v4f a, v4f b);
14304 v4i v4i_sub(v4i a, v4i b);
14319 v4l v4l_sub(v4l a, v4l b);
14334 v8d v8d_sub(v8d a, v8d b);
14349 v8f v8f_sub(v8f a, v8f b);
14364 v8i v8i_sub(v8i a, v8i b);
14379 v8l v8l_sub(v8l a, v8l b);
14394 v16f v16f_sub(v16f a, v16f b);
14409 v16i v16i_sub(v16i a, v16i b);
14410 
14425 v1d v1d_neg(v1d a);
14440 v1f v1f_neg(v1f a);
14455 v1i v1i_neg(v1i a);
14470 v1l v1l_neg(v1l a);
14485 v2d v2d_neg(v2d a);
14500 v2f v2f_neg(v2f a);
14515 v2i v2i_neg(v2i a);
14530 v2l v2l_neg(v2l a);
14545 v4d v4d_neg(v4d a);
14560 v4f v4f_neg(v4f a);
14575 v4i v4i_neg(v4i a);
14590 v4l v4l_neg(v4l a);
14605 v8d v8d_neg(v8d a);
14620 v8f v8f_neg(v8f a);
14635 v8i v8i_neg(v8i a);
14650 v8l v8l_neg(v8l a);
14665 v16f v16f_neg(v16f a);
14680 v16i v16i_neg(v16i a);
14681 
14700 v1d v1d_min(v1d a, v1d b);
14719 v1f v1f_min(v1f a, v1f b);
14738 v1i v1i_min(v1i a, v1i b);
14757 v1l v1l_min(v1l a, v1l b);
14776 v2d v2d_min(v2d a, v2d b);
14795 v2f v2f_min(v2f a, v2f b);
14814 v2i v2i_min(v2i a, v2i b);
14833 v2l v2l_min(v2l a, v2l b);
14852 v4d v4d_min(v4d a, v4d b);
14871 v4f v4f_min(v4f a, v4f b);
14890 v4i v4i_min(v4i a, v4i b);
14909 v4l v4l_min(v4l a, v4l b);
14928 v8d v8d_min(v8d a, v8d b);
14947 v8f v8f_min(v8f a, v8f b);
14966 v8i v8i_min(v8i a, v8i b);
14985 v8l v8l_min(v8l a, v8l b);
15004 v16f v16f_min(v16f a, v16f b);
15023 v16i v16i_min(v16i a, v16i b);
15024 
15043 v1d v1d_max(v1d a, v1d b);
15062 v1f v1f_max(v1f a, v1f b);
15081 v1i v1i_max(v1i a, v1i b);
15100 v1l v1l_max(v1l a, v1l b);
15119 v2d v2d_max(v2d a, v2d b);
15138 v2f v2f_max(v2f a, v2f b);
15157 v2i v2i_max(v2i a, v2i b);
15176 v2l v2l_max(v2l a, v2l b);
15195 v4d v4d_max(v4d a, v4d b);
15214 v4f v4f_max(v4f a, v4f b);
15233 v4i v4i_max(v4i a, v4i b);
15252 v4l v4l_max(v4l a, v4l b);
15271 v8d v8d_max(v8d a, v8d b);
15290 v8f v8f_max(v8f a, v8f b);
15309 v8i v8i_max(v8i a, v8i b);
15328 v8l v8l_max(v8l a, v8l b);
15347 v16f v16f_max(v16f a, v16f b);
15366 v16i v16i_max(v16i a, v16i b);
15367 
15385 v1d v1d_abs(v1d a);
15403 v1f v1f_abs(v1f a);
15421 v1i v1i_abs(v1i a);
15439 v1l v1l_abs(v1l a);
15457 v2d v2d_abs(v2d a);
15475 v2f v2f_abs(v2f a);
15493 v2i v2i_abs(v2i a);
15511 v2l v2l_abs(v2l a);
15529 v4d v4d_abs(v4d a);
15547 v4f v4f_abs(v4f a);
15565 v4i v4i_abs(v4i a);
15583 v4l v4l_abs(v4l a);
15601 v8d v8d_abs(v8d a);
15619 v8f v8f_abs(v8f a);
15637 v8i v8i_abs(v8i a);
15655 v8l v8l_abs(v8l a);
15673 v16f v16f_abs(v16f a);
15691 v16i v16i_abs(v16i a);
15692 
15707 v1d v1d_mul(v1d a, v1d b);
15722 v1f v1f_mul(v1f a, v1f b);
15737 v1i v1i_mul(v1i a, v1i b);
15752 v1l v1l_mul(v1l a, v1l b);
15767 v2d v2d_mul(v2d a, v2d b);
15782 v2f v2f_mul(v2f a, v2f b);
15797 v2i v2i_mul(v2i a, v2i b);
15812 v2l v2l_mul(v2l a, v2l b);
15827 v4d v4d_mul(v4d a, v4d b);
15842 v4f v4f_mul(v4f a, v4f b);
15857 v4i v4i_mul(v4i a, v4i b);
15872 v4l v4l_mul(v4l a, v4l b);
15887 v8d v8d_mul(v8d a, v8d b);
15902 v8f v8f_mul(v8f a, v8f b);
15917 v8i v8i_mul(v8i a, v8i b);
15932 v8l v8l_mul(v8l a, v8l b);
15947 v16f v16f_mul(v16f a, v16f b);
15962 v16i v16i_mul(v16i a, v16i b);
15963 
15978 v1d v1d_div(v1d a, v1d b);
15993 v1f v1f_div(v1f a, v1f b);
16008 v1i v1i_div(v1i a, v1i b);
16023 v1l v1l_div(v1l a, v1l b);
16038 v2d v2d_div(v2d a, v2d b);
16053 v2f v2f_div(v2f a, v2f b);
16068 v2i v2i_div(v2i a, v2i b);
16083 v2l v2l_div(v2l a, v2l b);
16098 v4d v4d_div(v4d a, v4d b);
16113 v4f v4f_div(v4f a, v4f b);
16128 v4i v4i_div(v4i a, v4i b);
16143 v4l v4l_div(v4l a, v4l b);
16158 v8d v8d_div(v8d a, v8d b);
16173 v8f v8f_div(v8f a, v8f b);
16188 v8i v8i_div(v8i a, v8i b);
16203 v8l v8l_div(v8l a, v8l b);
16218 v16f v16f_div(v16f a, v16f b);
16233 v16i v16i_div(v16i a, v16i b);
16234 
16248 v1d v1d_rcp(v1d a);
16262 v1f v1f_rcp(v1f a);
16276 v1i v1i_rcp(v1i a);
16290 v1l v1l_rcp(v1l a);
16304 v2d v2d_rcp(v2d a);
16318 v2f v2f_rcp(v2f a);
16332 v2i v2i_rcp(v2i a);
16346 v2l v2l_rcp(v2l a);
16360 v4d v4d_rcp(v4d a);
16374 v4f v4f_rcp(v4f a);
16388 v4i v4i_rcp(v4i a);
16402 v4l v4l_rcp(v4l a);
16416 v8d v8d_rcp(v8d a);
16430 v8f v8f_rcp(v8f a);
16444 v8i v8i_rcp(v8i a);
16458 v8l v8l_rcp(v8l a);
16472 v16f v16f_rcp(v16f a);
16486 v16i v16i_rcp(v16i a);
16487 
16502 v1d v1d_frcp(v1d a);
16517 v1f v1f_frcp(v1f a);
16532 v1i v1i_frcp(v1i a);
16547 v1l v1l_frcp(v1l a);
16562 v2d v2d_frcp(v2d a);
16577 v2f v2f_frcp(v2f a);
16592 v2i v2i_frcp(v2i a);
16607 v2l v2l_frcp(v2l a);
16622 v4d v4d_frcp(v4d a);
16637 v4f v4f_frcp(v4f a);
16652 v4i v4i_frcp(v4i a);
16667 v4l v4l_frcp(v4l a);
16682 v8d v8d_frcp(v8d a);
16697 v8f v8f_frcp(v8f a);
16712 v8i v8i_frcp(v8i a);
16727 v8l v8l_frcp(v8l a);
16742 v16f v16f_frcp(v16f a);
16757 v16i v16i_frcp(v16i a);
16758 
16772 v1d v1d_sqrt(v1d a);
16786 v1f v1f_sqrt(v1f a);
16800 v1i v1i_sqrt(v1i a);
16814 v1l v1l_sqrt(v1l a);
16828 v2d v2d_sqrt(v2d a);
16842 v2f v2f_sqrt(v2f a);
16856 v2i v2i_sqrt(v2i a);
16870 v2l v2l_sqrt(v2l a);
16884 v4d v4d_sqrt(v4d a);
16898 v4f v4f_sqrt(v4f a);
16912 v4i v4i_sqrt(v4i a);
16926 v4l v4l_sqrt(v4l a);
16940 v8d v8d_sqrt(v8d a);
16954 v8f v8f_sqrt(v8f a);
16968 v8i v8i_sqrt(v8i a);
16982 v8l v8l_sqrt(v8l a);
16996 v16f v16f_sqrt(v16f a);
17010 v16i v16i_sqrt(v16i a);
17011 
17025 v1d v1d_rsqrt(v1d a);
17039 v1f v1f_rsqrt(v1f a);
17053 v1i v1i_rsqrt(v1i a);
17067 v1l v1l_rsqrt(v1l a);
17081 v2d v2d_rsqrt(v2d a);
17095 v2f v2f_rsqrt(v2f a);
17109 v2i v2i_rsqrt(v2i a);
17123 v2l v2l_rsqrt(v2l a);
17137 v4d v4d_rsqrt(v4d a);
17151 v4f v4f_rsqrt(v4f a);
17165 v4i v4i_rsqrt(v4i a);
17179 v4l v4l_rsqrt(v4l a);
17193 v8d v8d_rsqrt(v8d a);
17207 v8f v8f_rsqrt(v8f a);
17221 v8i v8i_rsqrt(v8i a);
17235 v8l v8l_rsqrt(v8l a);
17249 v16f v16f_rsqrt(v16f a);
17263 v16i v16i_rsqrt(v16i a);
17264 
17279 v1d v1d_frsqrt(v1d a);
17294 v1f v1f_frsqrt(v1f a);
17309 v1i v1i_frsqrt(v1i a);
17324 v1l v1l_frsqrt(v1l a);
17339 v2d v2d_frsqrt(v2d a);
17354 v2f v2f_frsqrt(v2f a);
17369 v2i v2i_frsqrt(v2i a);
17384 v2l v2l_frsqrt(v2l a);
17399 v4d v4d_frsqrt(v4d a);
17414 v4f v4f_frsqrt(v4f a);
17429 v4i v4i_frsqrt(v4i a);
17444 v4l v4l_frsqrt(v4l a);
17459 v8d v8d_frsqrt(v8d a);
17474 v8f v8f_frsqrt(v8f a);
17489 v8i v8i_frsqrt(v8i a);
17504 v8l v8l_frsqrt(v8l a);
17519 v16f v16f_frsqrt(v16f a);
17534 v16i v16i_frsqrt(v16i a);
17535 
17536 /* Fused Multiply-Add */
17554 v1d v1d_fmadd(v1d a, v1d b, v1d acc);
17572 v1f v1f_fmadd(v1f a, v1f b, v1f acc);
17590 v1i v1i_fmadd(v1i a, v1i b, v1i acc);
17608 v1l v1l_fmadd(v1l a, v1l b, v1l acc);
17626 v2d v2d_fmadd(v2d a, v2d b, v2d acc);
17644 v2f v2f_fmadd(v2f a, v2f b, v2f acc);
17662 v2i v2i_fmadd(v2i a, v2i b, v2i acc);
17680 v2l v2l_fmadd(v2l a, v2l b, v2l acc);
17698 v4d v4d_fmadd(v4d a, v4d b, v4d acc);
17716 v4f v4f_fmadd(v4f a, v4f b, v4f acc);
17734 v4i v4i_fmadd(v4i a, v4i b, v4i acc);
17752 v4l v4l_fmadd(v4l a, v4l b, v4l acc);
17770 v8d v8d_fmadd(v8d a, v8d b, v8d acc);
17788 v8f v8f_fmadd(v8f a, v8f b, v8f acc);
17806 v8i v8i_fmadd(v8i a, v8i b, v8i acc);
17824 v8l v8l_fmadd(v8l a, v8l b, v8l acc);
17842 v16f v16f_fmadd(v16f a, v16f b, v16f acc);
17860 v16i v16i_fmadd(v16i a, v16i b, v16i acc);
17861 
17879 v1d v1d_fmsub(v1d a, v1d b, v1d acc);
17897 v1f v1f_fmsub(v1f a, v1f b, v1f acc);
17915 v1i v1i_fmsub(v1i a, v1i b, v1i acc);
17933 v1l v1l_fmsub(v1l a, v1l b, v1l acc);
17951 v2d v2d_fmsub(v2d a, v2d b, v2d acc);
17969 v2f v2f_fmsub(v2f a, v2f b, v2f acc);
17987 v2i v2i_fmsub(v2i a, v2i b, v2i acc);
18005 v2l v2l_fmsub(v2l a, v2l b, v2l acc);
18023 v4d v4d_fmsub(v4d a, v4d b, v4d acc);
18041 v4f v4f_fmsub(v4f a, v4f b, v4f acc);
18059 v4i v4i_fmsub(v4i a, v4i b, v4i acc);
18077 v4l v4l_fmsub(v4l a, v4l b, v4l acc);
18095 v8d v8d_fmsub(v8d a, v8d b, v8d acc);
18113 v8f v8f_fmsub(v8f a, v8f b, v8f acc);
18131 v8i v8i_fmsub(v8i a, v8i b, v8i acc);
18149 v8l v8l_fmsub(v8l a, v8l b, v8l acc);
18167 v16f v16f_fmsub(v16f a, v16f b, v16f acc);
18185 v16i v16i_fmsub(v16i a, v16i b, v16i acc);
18186 
18204 v1d v1d_fnmadd(v1d a, v1d b, v1d acc);
18222 v1f v1f_fnmadd(v1f a, v1f b, v1f acc);
18240 v1i v1i_fnmadd(v1i a, v1i b, v1i acc);
18258 v1l v1l_fnmadd(v1l a, v1l b, v1l acc);
18276 v2d v2d_fnmadd(v2d a, v2d b, v2d acc);
18294 v2f v2f_fnmadd(v2f a, v2f b, v2f acc);
18312 v2i v2i_fnmadd(v2i a, v2i b, v2i acc);
18330 v2l v2l_fnmadd(v2l a, v2l b, v2l acc);
18348 v4d v4d_fnmadd(v4d a, v4d b, v4d acc);
18366 v4f v4f_fnmadd(v4f a, v4f b, v4f acc);
18384 v4i v4i_fnmadd(v4i a, v4i b, v4i acc);
18402 v4l v4l_fnmadd(v4l a, v4l b, v4l acc);
18420 v8d v8d_fnmadd(v8d a, v8d b, v8d acc);
18438 v8f v8f_fnmadd(v8f a, v8f b, v8f acc);
18456 v8i v8i_fnmadd(v8i a, v8i b, v8i acc);
18474 v8l v8l_fnmadd(v8l a, v8l b, v8l acc);
18492 v16f v16f_fnmadd(v16f a, v16f b, v16f acc);
18510 v16i v16i_fnmadd(v16i a, v16i b, v16i acc);
18511 
18529 v1d v1d_fnmsub(v1d a, v1d b, v1d acc);
18547 v1f v1f_fnmsub(v1f a, v1f b, v1f acc);
18565 v1i v1i_fnmsub(v1i a, v1i b, v1i acc);
18583 v1l v1l_fnmsub(v1l a, v1l b, v1l acc);
18601 v2d v2d_fnmsub(v2d a, v2d b, v2d acc);
18619 v2f v2f_fnmsub(v2f a, v2f b, v2f acc);
18637 v2i v2i_fnmsub(v2i a, v2i b, v2i acc);
18655 v2l v2l_fnmsub(v2l a, v2l b, v2l acc);
18673 v4d v4d_fnmsub(v4d a, v4d b, v4d acc);
18691 v4f v4f_fnmsub(v4f a, v4f b, v4f acc);
18709 v4i v4i_fnmsub(v4i a, v4i b, v4i acc);
18727 v4l v4l_fnmsub(v4l a, v4l b, v4l acc);
18745 v8d v8d_fnmsub(v8d a, v8d b, v8d acc);
18763 v8f v8f_fnmsub(v8f a, v8f b, v8f acc);
18781 v8i v8i_fnmsub(v8i a, v8i b, v8i acc);
18799 v8l v8l_fnmsub(v8l a, v8l b, v8l acc);
18817 v16f v16f_fnmsub(v16f a, v16f b, v16f acc);
18835 v16i v16i_fnmsub(v16i a, v16i b, v16i acc);
18836 
18837 /* MERGES */
18855 v2d v2d_merge2_v1d(v1d a0, v1d a1);
18869 v2f v2f_merge2_v1f(v1f a0, v1f a1);
18883 v2i v2i_merge2_v1i(v1i a0, v1i a1);
18897 v2l v2l_merge2_v1l(v1l a0, v1l a1);
18911 v4d v4d_merge2_v2d(v2d a0, v2d a1);
18925 v4f v4f_merge2_v2f(v2f a0, v2f a1);
18939 v4i v4i_merge2_v2i(v2i a0, v2i a1);
18953 v4l v4l_merge2_v2l(v2l a0, v2l a1);
18967 v8d v8d_merge2_v4d(v4d a0, v4d a1);
18981 v8f v8f_merge2_v4f(v4f a0, v4f a1);
18995 v8i v8i_merge2_v4i(v4i a0, v4i a1);
19009 v8l v8l_merge2_v4l(v4l a0, v4l a1);
19023 v16f v16f_merge2_v8f(v8f a0, v8f a1);
19037 v16i v16i_merge2_v8i(v8i a0, v8i a1);
19055 v4d v4d_merge4_v1d(v1d a0, v1d a1, v1d a2, v1d a3);
19073 v4f v4f_merge4_v1f(v1f a0, v1f a1, v1f a2, v1f a3);
19091 v4i v4i_merge4_v1i(v1i a0, v1i a1, v1i a2, v1i a3);
19109 v4l v4l_merge4_v1l(v1l a0, v1l a1, v1l a2, v1l a3);
19127 v8d v8d_merge4_v2d(v2d a0, v2d a1, v2d a2, v2d a3);
19145 v8f v8f_merge4_v2f(v2f a0, v2f a1, v2f a2, v2f a3);
19163 v8i v8i_merge4_v2i(v2i a0, v2i a1, v2i a2, v2i a3);
19181 v8l v8l_merge4_v2l(v2l a0, v2l a1, v2l a2, v2l a3);
19199 v16f v16f_merge4_v4f(v4f a0, v4f a1, v4f a2, v4f a3);
19217 v16i v16i_merge4_v4i(v4i a0, v4i a1, v4i a2, v4i a3);
19243 v8d v8d_merge8_v1d(v1d a0, v1d a1, v1d a2, v1d a3, v1d a4, v1d a5, v1d a6, v1d a7);
19269 v8f v8f_merge8_v1f(v1f a0, v1f a1, v1f a2, v1f a3, v1f a4, v1f a5, v1f a6, v1f a7);
19295 v8i v8i_merge8_v1i(v1i a0, v1i a1, v1i a2, v1i a3, v1i a4, v1i a5, v1i a6, v1i a7);
19321 v8l v8l_merge8_v1l(v1l a0, v1l a1, v1l a2, v1l a3, v1l a4, v1l a5, v1l a6, v1l a7);
19347 v16f v16f_merge8_v2f(v2f a0, v2f a1, v2f a2, v2f a3, v2f a4, v2f a5, v2f a6, v2f a7);
19373 v16i v16i_merge8_v2i(v2i a0, v2i a1, v2i a2, v2i a3, v2i a4, v2i a5, v2i a6, v2i a7);
19415 v16f v16f_merge16_v1f(v1f a0, v1f a1, v1f a2, v1f a3, v1f a4, v1f a5, v1f a6, v1f a7, v1f a8, v1f a9, v1f a10, v1f a11, v1f a12, v1f a13, v1f a14, v1f a15);
19457 v16i v16i_merge16_v1i(v1i a0, v1i a1, v1i a2, v1i a3, v1i a4, v1i a5, v1i a6, v1i a7, v1i a8, v1i a9, v1i a10, v1i a11, v1i a12, v1i a13, v1i a14, v1i a15);
19458 
19473 v2d v2d_rmerge2_v1d(v1d a1, v1d a0);
19488 v2f v2f_rmerge2_v1f(v1f a1, v1f a0);
19503 v2i v2i_rmerge2_v1i(v1i a1, v1i a0);
19518 v2l v2l_rmerge2_v1l(v1l a1, v1l a0);
19533 v4d v4d_rmerge2_v2d(v2d a1, v2d a0);
19548 v4f v4f_rmerge2_v2f(v2f a1, v2f a0);
19563 v4i v4i_rmerge2_v2i(v2i a1, v2i a0);
19578 v4l v4l_rmerge2_v2l(v2l a1, v2l a0);
19593 v8d v8d_rmerge2_v4d(v4d a1, v4d a0);
19608 v8f v8f_rmerge2_v4f(v4f a1, v4f a0);
19623 v8i v8i_rmerge2_v4i(v4i a1, v4i a0);
19638 v8l v8l_rmerge2_v4l(v4l a1, v4l a0);
19653 v16f v16f_rmerge2_v8f(v8f a1, v8f a0);
19668 v16i v16i_rmerge2_v8i(v8i a1, v8i a0);
19687 v4d v4d_rmerge4_v1d(v1d a3, v1d a2, v1d a1, v1d a0);
19706 v4f v4f_rmerge4_v1f(v1f a3, v1f a2, v1f a1, v1f a0);
19725 v4i v4i_rmerge4_v1i(v1i a3, v1i a2, v1i a1, v1i a0);
19744 v4l v4l_rmerge4_v1l(v1l a3, v1l a2, v1l a1, v1l a0);
19763 v8d v8d_rmerge4_v2d(v2d a3, v2d a2, v2d a1, v2d a0);
19782 v8f v8f_rmerge4_v2f(v2f a3, v2f a2, v2f a1, v2f a0);
19801 v8i v8i_rmerge4_v2i(v2i a3, v2i a2, v2i a1, v2i a0);
19820 v8l v8l_rmerge4_v2l(v2l a3, v2l a2, v2l a1, v2l a0);
19839 v16f v16f_rmerge4_v4f(v4f a3, v4f a2, v4f a1, v4f a0);
19858 v16i v16i_rmerge4_v4i(v4i a3, v4i a2, v4i a1, v4i a0);
19885 v8d v8d_rmerge8_v1d(v1d a7, v1d a6, v1d a5, v1d a4, v1d a3, v1d a2, v1d a1, v1d a0);
19912 v8f v8f_rmerge8_v1f(v1f a7, v1f a6, v1f a5, v1f a4, v1f a3, v1f a2, v1f a1, v1f a0);
19939 v8i v8i_rmerge8_v1i(v1i a7, v1i a6, v1i a5, v1i a4, v1i a3, v1i a2, v1i a1, v1i a0);
19966 v8l v8l_rmerge8_v1l(v1l a7, v1l a6, v1l a5, v1l a4, v1l a3, v1l a2, v1l a1, v1l a0);
19993 v16f v16f_rmerge8_v2f(v2f a7, v2f a6, v2f a5, v2f a4, v2f a3, v2f a2, v2f a1, v2f a0);
20020 v16i v16i_rmerge8_v2i(v2i a7, v2i a6, v2i a5, v2i a4, v2i a3, v2i a2, v2i a1, v2i a0);
20063 v16f v16f_rmerge16_v1f(v1f a15, v1f a14, v1f a13, v1f a12, v1f a11, v1f a10, v1f a9, v1f a8, v1f a7, v1f a6, v1f a5, v1f a4, v1f a3, v1f a2, v1f a1, v1f a0);
20106 v16i v16i_rmerge16_v1i(v1i a15, v1i a14, v1i a13, v1i a12, v1i a11, v1i a10, v1i a9, v1i a8, v1i a7, v1i a6, v1i a5, v1i a4, v1i a3, v1i a2, v1i a1, v1i a0);
20107 
20122 v2d v2d_merge_v1d(v1d low, v1d high);
20137 v2f v2f_merge_v1f(v1f low, v1f high);
20152 v2i v2i_merge_v1i(v1i low, v1i high);
20167 v2l v2l_merge_v1l(v1l low, v1l high);
20182 v4d v4d_merge_v2d(v2d low, v2d high);
20197 v4f v4f_merge_v2f(v2f low, v2f high);
20212 v4i v4i_merge_v2i(v2i low, v2i high);
20227 v4l v4l_merge_v2l(v2l low, v2l high);
20242 v8d v8d_merge_v4d(v4d low, v4d high);
20257 v8f v8f_merge_v4f(v4f low, v4f high);
20272 v8i v8i_merge_v4i(v4i low, v4i high);
20287 v8l v8l_merge_v4l(v4l low, v4l high);
20302 v16f v16f_merge_v8f(v8f low, v8f high);
20317 v16i v16i_merge_v8i(v8i low, v8i high);
20318 
20334 v2d v2d_rmerge_v1d(v1d high, v1d low);
20350 v2f v2f_rmerge_v1f(v1f high, v1f low);
20366 v2i v2i_rmerge_v1i(v1i high, v1i low);
20382 v2l v2l_rmerge_v1l(v1l high, v1l low);
20398 v4d v4d_rmerge_v2d(v2d high, v2d low);
20414 v4f v4f_rmerge_v2f(v2f high, v2f low);
20430 v4i v4i_rmerge_v2i(v2i high, v2i low);
20446 v4l v4l_rmerge_v2l(v2l high, v2l low);
20462 v8d v8d_rmerge_v4d(v4d high, v4d low);
20478 v8f v8f_rmerge_v4f(v4f high, v4f low);
20494 v8i v8i_rmerge_v4i(v4i high, v4i low);
20510 v8l v8l_rmerge_v4l(v4l high, v4l low);
20526 v16f v16f_rmerge_v8f(v8f high, v8f low);
20542 v16i v16i_rmerge_v8i(v8i high, v8i low);
20543 
20544 
20545 /* HIGH and LOW manipulation */
20563 v1d v1d_get_low_v2d(v2d a);
20577 v1f v1f_get_low_v2f(v2f a);
20591 v1i v1i_get_low_v2i(v2i a);
20605 v1l v1l_get_low_v2l(v2l a);
20619 v2d v2d_get_low_v4d(v4d a);
20633 v2f v2f_get_low_v4f(v4f a);
20647 v2i v2i_get_low_v4i(v4i a);
20661 v2l v2l_get_low_v4l(v4l a);
20675 v4d v4d_get_low_v8d(v8d a);
20689 v4f v4f_get_low_v8f(v8f a);
20703 v4i v4i_get_low_v8i(v8i a);
20717 v4l v4l_get_low_v8l(v8l a);
20731 v8f v8f_get_low_v16f(v16f a);
20745 v8i v8i_get_low_v16i(v16i a);
20758 v1d v1d_get_high_v2d(v2d a);
20771 v1f v1f_get_high_v2f(v2f a);
20784 v1i v1i_get_high_v2i(v2i a);
20797 v1l v1l_get_high_v2l(v2l a);
20810 v2d v2d_get_high_v4d(v4d a);
20823 v2f v2f_get_high_v4f(v4f a);
20836 v2i v2i_get_high_v4i(v4i a);
20849 v2l v2l_get_high_v4l(v4l a);
20862 v4d v4d_get_high_v8d(v8d a);
20875 v4f v4f_get_high_v8f(v8f a);
20888 v4i v4i_get_high_v8i(v8i a);
20901 v4l v4l_get_high_v8l(v8l a);
20914 v8f v8f_get_high_v16f(v16f a);
20927 v8i v8i_get_high_v16i(v16i a);
20947 v1d v1d_get_hilo_v2d(v2d a, int high);
20967 v1f v1f_get_hilo_v2f(v2f a, int high);
20987 v1i v1i_get_hilo_v2i(v2i a, int high);
21007 v1l v1l_get_hilo_v2l(v2l a, int high);
21027 v2d v2d_get_hilo_v4d(v4d a, int high);
21047 v2f v2f_get_hilo_v4f(v4f a, int high);
21067 v2i v2i_get_hilo_v4i(v4i a, int high);
21087 v2l v2l_get_hilo_v4l(v4l a, int high);
21107 v4d v4d_get_hilo_v8d(v8d a, int high);
21127 v4f v4f_get_hilo_v8f(v8f a, int high);
21147 v4i v4i_get_hilo_v8i(v8i a, int high);
21167 v4l v4l_get_hilo_v8l(v8l a, int high);
21187 v8f v8f_get_hilo_v16f(v16f a, int high);
21207 v8i v8i_get_hilo_v16i(v16i a, int high);
21222 v2d v2d_set_low_v1d(v2d src, v1d low);
21237 v2f v2f_set_low_v1f(v2f src, v1f low);
21252 v2i v2i_set_low_v1i(v2i src, v1i low);
21267 v2l v2l_set_low_v1l(v2l src, v1l low);
21282 v4d v4d_set_low_v2d(v4d src, v2d low);
21297 v4f v4f_set_low_v2f(v4f src, v2f low);
21312 v4i v4i_set_low_v2i(v4i src, v2i low);
21327 v4l v4l_set_low_v2l(v4l src, v2l low);
21342 v8d v8d_set_low_v4d(v8d src, v4d low);
21357 v8f v8f_set_low_v4f(v8f src, v4f low);
21372 v8i v8i_set_low_v4i(v8i src, v4i low);
21387 v8l v8l_set_low_v4l(v8l src, v4l low);
21402 v16f v16f_set_low_v8f(v16f src, v8f low);
21417 v16i v16i_set_low_v8i(v16i src, v8i low);
21432 v2d v2d_set_high_v1d(v2d src, v1d high);
21447 v2f v2f_set_high_v1f(v2f src, v1f high);
21462 v2i v2i_set_high_v1i(v2i src, v1i high);
21477 v2l v2l_set_high_v1l(v2l src, v1l high);
21492 v4d v4d_set_high_v2d(v4d src, v2d high);
21507 v4f v4f_set_high_v2f(v4f src, v2f high);
21522 v4i v4i_set_high_v2i(v4i src, v2i high);
21537 v4l v4l_set_high_v2l(v4l src, v2l high);
21552 v8d v8d_set_high_v4d(v8d src, v4d high);
21567 v8f v8f_set_high_v4f(v8f src, v4f high);
21582 v8i v8i_set_high_v4i(v8i src, v4i high);
21597 v8l v8l_set_high_v4l(v8l src, v4l high);
21612 v16f v16f_set_high_v8f(v16f src, v8f high);
21627 v16i v16i_set_high_v8i(v16i src, v8i high);
21650 v2d v2d_set_hilo_v1d(v2d src, v1d a, int high);
21673 v2f v2f_set_hilo_v1f(v2f src, v1f a, int high);
21696 v2i v2i_set_hilo_v1i(v2i src, v1i a, int high);
21719 v2l v2l_set_hilo_v1l(v2l src, v1l a, int high);
21742 v4d v4d_set_hilo_v2d(v4d src, v2d a, int high);
21765 v4f v4f_set_hilo_v2f(v4f src, v2f a, int high);
21788 v4i v4i_set_hilo_v2i(v4i src, v2i a, int high);
21811 v4l v4l_set_hilo_v2l(v4l src, v2l a, int high);
21834 v8d v8d_set_hilo_v4d(v8d src, v4d a, int high);
21857 v8f v8f_set_hilo_v4f(v8f src, v4f a, int high);
21880 v8i v8i_set_hilo_v4i(v8i src, v4i a, int high);
21903 v8l v8l_set_hilo_v4l(v8l src, v4l a, int high);
21926 v16f v16f_set_hilo_v8f(v16f src, v8f a, int high);
21949 v16i v16i_set_hilo_v8i(v16i src, v8i a, int high);
21950 
21951 /* BLENDS */
21976 v1d v1d_blend1(v1d a, v1d b, uint_fast8_t mask);
21997 v1f v1f_blend1(v1f a, v1f b, uint_fast8_t mask);
22018 v1i v1i_blend1(v1i a, v1i b, uint_fast8_t mask);
22039 v1l v1l_blend1(v1l a, v1l b, uint_fast8_t mask);
22060 v2d v2d_blend1(v2d a, v2d b, uint_fast8_t mask);
22081 v2f v2f_blend1(v2f a, v2f b, uint_fast8_t mask);
22102 v2i v2i_blend1(v2i a, v2i b, uint_fast8_t mask);
22123 v2l v2l_blend1(v2l a, v2l b, uint_fast8_t mask);
22144 v4d v4d_blend1(v4d a, v4d b, uint_fast8_t mask);
22165 v4f v4f_blend1(v4f a, v4f b, uint_fast8_t mask);
22186 v4i v4i_blend1(v4i a, v4i b, uint_fast8_t mask);
22207 v4l v4l_blend1(v4l a, v4l b, uint_fast8_t mask);
22228 v8d v8d_blend1(v8d a, v8d b, uint_fast8_t mask);
22249 v8f v8f_blend1(v8f a, v8f b, uint_fast8_t mask);
22270 v8i v8i_blend1(v8i a, v8i b, uint_fast8_t mask);
22291 v8l v8l_blend1(v8l a, v8l b, uint_fast8_t mask);
22312 v16f v16f_blend1(v16f a, v16f b, uint_fast8_t mask);
22333 v16i v16i_blend1(v16i a, v16i b, uint_fast8_t mask);
22354 v2d v2d_blend2(v2d a, v2d b, uint_fast8_t mask);
22375 v2f v2f_blend2(v2f a, v2f b, uint_fast8_t mask);
22396 v2i v2i_blend2(v2i a, v2i b, uint_fast8_t mask);
22417 v2l v2l_blend2(v2l a, v2l b, uint_fast8_t mask);
22438 v4d v4d_blend2(v4d a, v4d b, uint_fast8_t mask);
22459 v4f v4f_blend2(v4f a, v4f b, uint_fast8_t mask);
22480 v4i v4i_blend2(v4i a, v4i b, uint_fast8_t mask);
22501 v4l v4l_blend2(v4l a, v4l b, uint_fast8_t mask);
22522 v8d v8d_blend2(v8d a, v8d b, uint_fast8_t mask);
22543 v8f v8f_blend2(v8f a, v8f b, uint_fast8_t mask);
22564 v8i v8i_blend2(v8i a, v8i b, uint_fast8_t mask);
22585 v8l v8l_blend2(v8l a, v8l b, uint_fast8_t mask);
22606 v16f v16f_blend2(v16f a, v16f b, uint_fast8_t mask);
22627 v16i v16i_blend2(v16i a, v16i b, uint_fast8_t mask);
22648 v4d v4d_blend4(v4d a, v4d b, uint_fast8_t mask);
22669 v4f v4f_blend4(v4f a, v4f b, uint_fast8_t mask);
22690 v4i v4i_blend4(v4i a, v4i b, uint_fast8_t mask);
22711 v4l v4l_blend4(v4l a, v4l b, uint_fast8_t mask);
22732 v8d v8d_blend4(v8d a, v8d b, uint_fast8_t mask);
22753 v8f v8f_blend4(v8f a, v8f b, uint_fast8_t mask);
22774 v8i v8i_blend4(v8i a, v8i b, uint_fast8_t mask);
22795 v8l v8l_blend4(v8l a, v8l b, uint_fast8_t mask);
22816 v16f v16f_blend4(v16f a, v16f b, uint_fast8_t mask);
22837 v16i v16i_blend4(v16i a, v16i b, uint_fast8_t mask);
22858 v8d v8d_blend8(v8d a, v8d b, uint_fast8_t mask);
22879 v8f v8f_blend8(v8f a, v8f b, uint_fast8_t mask);
22900 v8i v8i_blend8(v8i a, v8i b, uint_fast8_t mask);
22921 v8l v8l_blend8(v8l a, v8l b, uint_fast8_t mask);
22942 v16f v16f_blend8(v16f a, v16f b, uint_fast8_t mask);
22963 v16i v16i_blend8(v16i a, v16i b, uint_fast8_t mask);
22984 v16f v16f_blend16(v16f a, v16f b, uint_fast16_t mask);
23005 v16i v16i_blend16(v16i a, v16i b, uint_fast16_t mask);
23006 
23034 v1d v1d_blend1x1(v1d a, v1d b, uint_fast8_t mask);
23062 v1f v1f_blend1x1(v1f a, v1f b, uint_fast8_t mask);
23090 v1i v1i_blend1x1(v1i a, v1i b, uint_fast8_t mask);
23118 v1l v1l_blend1x1(v1l a, v1l b, uint_fast8_t mask);
23146 v2d v2d_blend1x2(v2d a, v2d b, uint_fast8_t mask);
23174 v2f v2f_blend1x2(v2f a, v2f b, uint_fast8_t mask);
23202 v2i v2i_blend1x2(v2i a, v2i b, uint_fast8_t mask);
23230 v2l v2l_blend1x2(v2l a, v2l b, uint_fast8_t mask);
23258 v4d v4d_blend1x4(v4d a, v4d b, uint_fast8_t mask);
23286 v4f v4f_blend1x4(v4f a, v4f b, uint_fast8_t mask);
23314 v4i v4i_blend1x4(v4i a, v4i b, uint_fast8_t mask);
23342 v4l v4l_blend1x4(v4l a, v4l b, uint_fast8_t mask);
23370 v8d v8d_blend1x8(v8d a, v8d b, uint_fast8_t mask);
23398 v8f v8f_blend1x8(v8f a, v8f b, uint_fast8_t mask);
23426 v8i v8i_blend1x8(v8i a, v8i b, uint_fast8_t mask);
23454 v8l v8l_blend1x8(v8l a, v8l b, uint_fast8_t mask);
23482 v16f v16f_blend1x16(v16f a, v16f b, uint_fast8_t mask);
23510 v16i v16i_blend1x16(v16i a, v16i b, uint_fast8_t mask);
23538 v2d v2d_blend2x1(v2d a, v2d b, uint_fast8_t mask);
23566 v2f v2f_blend2x1(v2f a, v2f b, uint_fast8_t mask);
23594 v2i v2i_blend2x1(v2i a, v2i b, uint_fast8_t mask);
23622 v2l v2l_blend2x1(v2l a, v2l b, uint_fast8_t mask);
23650 v4d v4d_blend2x2(v4d a, v4d b, uint_fast8_t mask);
23678 v4f v4f_blend2x2(v4f a, v4f b, uint_fast8_t mask);
23706 v4i v4i_blend2x2(v4i a, v4i b, uint_fast8_t mask);
23734 v4l v4l_blend2x2(v4l a, v4l b, uint_fast8_t mask);
23762 v8d v8d_blend2x4(v8d a, v8d b, uint_fast8_t mask);
23790 v8f v8f_blend2x4(v8f a, v8f b, uint_fast8_t mask);
23818 v8i v8i_blend2x4(v8i a, v8i b, uint_fast8_t mask);
23846 v8l v8l_blend2x4(v8l a, v8l b, uint_fast8_t mask);
23874 v16f v16f_blend2x8(v16f a, v16f b, uint_fast8_t mask);
23902 v16i v16i_blend2x8(v16i a, v16i b, uint_fast8_t mask);
23930 v4d v4d_blend4x1(v4d a, v4d b, uint_fast8_t mask);
23958 v4f v4f_blend4x1(v4f a, v4f b, uint_fast8_t mask);
23986 v4i v4i_blend4x1(v4i a, v4i b, uint_fast8_t mask);
24014 v4l v4l_blend4x1(v4l a, v4l b, uint_fast8_t mask);
24042 v8d v8d_blend4x2(v8d a, v8d b, uint_fast8_t mask);
24070 v8f v8f_blend4x2(v8f a, v8f b, uint_fast8_t mask);
24098 v8i v8i_blend4x2(v8i a, v8i b, uint_fast8_t mask);
24126 v8l v8l_blend4x2(v8l a, v8l b, uint_fast8_t mask);
24154 v16f v16f_blend4x4(v16f a, v16f b, uint_fast8_t mask);
24182 v16i v16i_blend4x4(v16i a, v16i b, uint_fast8_t mask);
24210 v8d v8d_blend8x1(v8d a, v8d b, uint_fast8_t mask);
24238 v8f v8f_blend8x1(v8f a, v8f b, uint_fast8_t mask);
24266 v8i v8i_blend8x1(v8i a, v8i b, uint_fast8_t mask);
24294 v8l v8l_blend8x1(v8l a, v8l b, uint_fast8_t mask);
24322 v16f v16f_blend8x2(v16f a, v16f b, uint_fast8_t mask);
24350 v16i v16i_blend8x2(v16i a, v16i b, uint_fast8_t mask);
24378 v16f v16f_blend16x1(v16f a, v16f b, uint_fast16_t mask);
24406 v16i v16i_blend16x1(v16i a, v16i b, uint_fast16_t mask);
24407 
24428 v1d v1d_blend(v1d a, v1d b, uint_fast8_t mask);
24449 v1f v1f_blend(v1f a, v1f b, uint_fast8_t mask);
24470 v1i v1i_blend(v1i a, v1i b, uint_fast8_t mask);
24491 v1l v1l_blend(v1l a, v1l b, uint_fast8_t mask);
24512 v2d v2d_blend(v2d a, v2d b, uint_fast8_t mask);
24533 v2f v2f_blend(v2f a, v2f b, uint_fast8_t mask);
24554 v2i v2i_blend(v2i a, v2i b, uint_fast8_t mask);
24575 v2l v2l_blend(v2l a, v2l b, uint_fast8_t mask);
24596 v4d v4d_blend(v4d a, v4d b, uint_fast8_t mask);
24617 v4f v4f_blend(v4f a, v4f b, uint_fast8_t mask);
24638 v4i v4i_blend(v4i a, v4i b, uint_fast8_t mask);
24659 v4l v4l_blend(v4l a, v4l b, uint_fast8_t mask);
24680 v8d v8d_blend(v8d a, v8d b, uint_fast8_t mask);
24701 v8f v8f_blend(v8f a, v8f b, uint_fast8_t mask);
24722 v8i v8i_blend(v8i a, v8i b, uint_fast8_t mask);
24743 v8l v8l_blend(v8l a, v8l b, uint_fast8_t mask);
24764 v16f v16f_blend(v16f a, v16f b, uint_fast16_t mask);
24785 v16i v16i_blend(v16i a, v16i b, uint_fast16_t mask);
24786 
24787 /* SHUFFLES */
24815 v2d v2d_hshuffle2(v2d a, v2d b, uint_fast8_t rule);
24839 v2f v2f_hshuffle2(v2f a, v2f b, uint_fast8_t rule);
24863 v2i v2i_hshuffle2(v2i a, v2i b, uint_fast8_t rule);
24887 v2l v2l_hshuffle2(v2l a, v2l b, uint_fast8_t rule);
24911 v4d v4d_hshuffle2(v4d a, v4d b, uint_fast8_t rule);
24935 v4f v4f_hshuffle2(v4f a, v4f b, uint_fast8_t rule);
24959 v4i v4i_hshuffle2(v4i a, v4i b, uint_fast8_t rule);
24983 v4l v4l_hshuffle2(v4l a, v4l b, uint_fast8_t rule);
25007 v8d v8d_hshuffle2(v8d a, v8d b, uint_fast8_t rule);
25031 v8f v8f_hshuffle2(v8f a, v8f b, uint_fast8_t rule);
25055 v8i v8i_hshuffle2(v8i a, v8i b, uint_fast8_t rule);
25079 v8l v8l_hshuffle2(v8l a, v8l b, uint_fast8_t rule);
25103 v16f v16f_hshuffle2(v16f a, v16f b, uint_fast8_t rule);
25127 v16i v16i_hshuffle2(v16i a, v16i b, uint_fast8_t rule);
25155 v4d v4d_hshuffle4(v4d a, v4d b, uint_fast8_t rule);
25183 v4f v4f_hshuffle4(v4f a, v4f b, uint_fast8_t rule);
25211 v4i v4i_hshuffle4(v4i a, v4i b, uint_fast8_t rule);
25239 v4l v4l_hshuffle4(v4l a, v4l b, uint_fast8_t rule);
25267 v8d v8d_hshuffle4(v8d a, v8d b, uint_fast8_t rule);
25295 v8f v8f_hshuffle4(v8f a, v8f b, uint_fast8_t rule);
25323 v8i v8i_hshuffle4(v8i a, v8i b, uint_fast8_t rule);
25351 v8l v8l_hshuffle4(v8l a, v8l b, uint_fast8_t rule);
25379 v16f v16f_hshuffle4(v16f a, v16f b, uint_fast8_t rule);
25407 v16i v16i_hshuffle4(v16i a, v16i b, uint_fast8_t rule);
25443 v8d v8d_hshuffle8(v8d a, v8d b, uint_fast32_t rule);
25479 v8f v8f_hshuffle8(v8f a, v8f b, uint_fast32_t rule);
25515 v8i v8i_hshuffle8(v8i a, v8i b, uint_fast32_t rule);
25551 v8l v8l_hshuffle8(v8l a, v8l b, uint_fast32_t rule);
25587 v16f v16f_hshuffle8(v16f a, v16f b, uint_fast32_t rule);
25623 v16i v16i_hshuffle8(v16i a, v16i b, uint_fast32_t rule);
25675 v16f v16f_hshuffle16(v16f a, v16f b, uint_fast64_t rule);
25727 v16i v16i_hshuffle16(v16i a, v16i b, uint_fast64_t rule);
25728 
25755 v2d v2d_hshuffle2x1(v2d a, v2d b, uint_fast8_t rule);
25782 v2f v2f_hshuffle2x1(v2f a, v2f b, uint_fast8_t rule);
25809 v2i v2i_hshuffle2x1(v2i a, v2i b, uint_fast8_t rule);
25836 v2l v2l_hshuffle2x1(v2l a, v2l b, uint_fast8_t rule);
25863 v4d v4d_hshuffle2x2(v4d a, v4d b, uint_fast8_t rule);
25890 v4f v4f_hshuffle2x2(v4f a, v4f b, uint_fast8_t rule);
25917 v4i v4i_hshuffle2x2(v4i a, v4i b, uint_fast8_t rule);
25944 v4l v4l_hshuffle2x2(v4l a, v4l b, uint_fast8_t rule);
25971 v8d v8d_hshuffle2x4(v8d a, v8d b, uint_fast8_t rule);
25998 v8f v8f_hshuffle2x4(v8f a, v8f b, uint_fast8_t rule);
26025 v8i v8i_hshuffle2x4(v8i a, v8i b, uint_fast8_t rule);
26052 v8l v8l_hshuffle2x4(v8l a, v8l b, uint_fast8_t rule);
26079 v16f v16f_hshuffle2x8(v16f a, v16f b, uint_fast8_t rule);
26106 v16i v16i_hshuffle2x8(v16i a, v16i b, uint_fast8_t rule);
26137 v4d v4d_hshuffle4x1(v4d a, v4d b, uint_fast8_t rule);
26168 v4f v4f_hshuffle4x1(v4f a, v4f b, uint_fast8_t rule);
26199 v4i v4i_hshuffle4x1(v4i a, v4i b, uint_fast8_t rule);
26230 v4l v4l_hshuffle4x1(v4l a, v4l b, uint_fast8_t rule);
26261 v8d v8d_hshuffle4x2(v8d a, v8d b, uint_fast8_t rule);
26292 v8f v8f_hshuffle4x2(v8f a, v8f b, uint_fast8_t rule);
26323 v8i v8i_hshuffle4x2(v8i a, v8i b, uint_fast8_t rule);
26354 v8l v8l_hshuffle4x2(v8l a, v8l b, uint_fast8_t rule);
26385 v16f v16f_hshuffle4x4(v16f a, v16f b, uint_fast8_t rule);
26416 v16i v16i_hshuffle4x4(v16i a, v16i b, uint_fast8_t rule);
26455 v8d v8d_hshuffle8x1(v8d a, v8d b, uint_fast32_t rule);
26494 v8f v8f_hshuffle8x1(v8f a, v8f b, uint_fast32_t rule);
26533 v8i v8i_hshuffle8x1(v8i a, v8i b, uint_fast32_t rule);
26572 v8l v8l_hshuffle8x1(v8l a, v8l b, uint_fast32_t rule);
26611 v16f v16f_hshuffle8x2(v16f a, v16f b, uint_fast32_t rule);
26650 v16i v16i_hshuffle8x2(v16i a, v16i b, uint_fast32_t rule);
26705 v16f v16f_hshuffle16x1(v16f a, v16f b, uint_fast64_t rule);
26760 v16i v16i_hshuffle16x1(v16i a, v16i b, uint_fast64_t rule);
26761 
26787 v2d v2d_permute2(v2d a, uint_fast8_t rule);
26813 v2f v2f_permute2(v2f a, uint_fast8_t rule);
26839 v2i v2i_permute2(v2i a, uint_fast8_t rule);
26865 v2l v2l_permute2(v2l a, uint_fast8_t rule);
26891 v4d v4d_permute2(v4d a, uint_fast8_t rule);
26917 v4f v4f_permute2(v4f a, uint_fast8_t rule);
26943 v4i v4i_permute2(v4i a, uint_fast8_t rule);
26969 v4l v4l_permute2(v4l a, uint_fast8_t rule);
26995 v8d v8d_permute2(v8d a, uint_fast8_t rule);
27021 v8f v8f_permute2(v8f a, uint_fast8_t rule);
27047 v8i v8i_permute2(v8i a, uint_fast8_t rule);
27073 v8l v8l_permute2(v8l a, uint_fast8_t rule);
27099 v16f v16f_permute2(v16f a, uint_fast8_t rule);
27125 v16i v16i_permute2(v16i a, uint_fast8_t rule);
27155 v4d v4d_permute4(v4d a, uint_fast8_t rule);
27185 v4f v4f_permute4(v4f a, uint_fast8_t rule);
27215 v4i v4i_permute4(v4i a, uint_fast8_t rule);
27245 v4l v4l_permute4(v4l a, uint_fast8_t rule);
27275 v8d v8d_permute4(v8d a, uint_fast8_t rule);
27305 v8f v8f_permute4(v8f a, uint_fast8_t rule);
27335 v8i v8i_permute4(v8i a, uint_fast8_t rule);
27365 v8l v8l_permute4(v8l a, uint_fast8_t rule);
27395 v16f v16f_permute4(v16f a, uint_fast8_t rule);
27425 v16i v16i_permute4(v16i a, uint_fast8_t rule);
27463 v8d v8d_permute8(v8d a, uint_fast32_t rule);
27501 v8f v8f_permute8(v8f a, uint_fast32_t rule);
27539 v8i v8i_permute8(v8i a, uint_fast32_t rule);
27577 v8l v8l_permute8(v8l a, uint_fast32_t rule);
27615 v16f v16f_permute8(v16f a, uint_fast32_t rule);
27653 v16i v16i_permute8(v16i a, uint_fast32_t rule);
27707 v16f v16f_permute16(v16f a, uint_fast64_t rule);
27761 v16i v16i_permute16(v16i a, uint_fast64_t rule);
27762 
27791 v2d v2d_permute2x1(v2d a, uint_fast8_t rule);
27820 v2f v2f_permute2x1(v2f a, uint_fast8_t rule);
27849 v2i v2i_permute2x1(v2i a, uint_fast8_t rule);
27878 v2l v2l_permute2x1(v2l a, uint_fast8_t rule);
27907 v4d v4d_permute2x2(v4d a, uint_fast8_t rule);
27936 v4f v4f_permute2x2(v4f a, uint_fast8_t rule);
27965 v4i v4i_permute2x2(v4i a, uint_fast8_t rule);
27994 v4l v4l_permute2x2(v4l a, uint_fast8_t rule);
28023 v8d v8d_permute2x4(v8d a, uint_fast8_t rule);
28052 v8f v8f_permute2x4(v8f a, uint_fast8_t rule);
28081 v8i v8i_permute2x4(v8i a, uint_fast8_t rule);
28110 v8l v8l_permute2x4(v8l a, uint_fast8_t rule);
28139 v16f v16f_permute2x8(v16f a, uint_fast8_t rule);
28168 v16i v16i_permute2x8(v16i a, uint_fast8_t rule);
28201 v4d v4d_permute4x1(v4d a, uint_fast8_t rule);
28234 v4f v4f_permute4x1(v4f a, uint_fast8_t rule);
28267 v4i v4i_permute4x1(v4i a, uint_fast8_t rule);
28300 v4l v4l_permute4x1(v4l a, uint_fast8_t rule);
28333 v8d v8d_permute4x2(v8d a, uint_fast8_t rule);
28366 v8f v8f_permute4x2(v8f a, uint_fast8_t rule);
28399 v8i v8i_permute4x2(v8i a, uint_fast8_t rule);
28432 v8l v8l_permute4x2(v8l a, uint_fast8_t rule);
28465 v16f v16f_permute4x4(v16f a, uint_fast8_t rule);
28498 v16i v16i_permute4x4(v16i a, uint_fast8_t rule);
28539 v8d v8d_permute8x1(v8d a, uint_fast32_t rule);
28580 v8f v8f_permute8x1(v8f a, uint_fast32_t rule);
28621 v8i v8i_permute8x1(v8i a, uint_fast32_t rule);
28662 v8l v8l_permute8x1(v8l a, uint_fast32_t rule);
28703 v16f v16f_permute8x2(v16f a, uint_fast32_t rule);
28744 v16i v16i_permute8x2(v16i a, uint_fast32_t rule);
28801 v16f v16f_permute16x1(v16f a, uint_fast64_t rule);
28858 v16i v16i_permute16x1(v16i a, uint_fast64_t rule);
28859 
28884 v2d v2d_fshuffle2(v2d a, v2d b, uint_fast8_t rule, uint_fast8_t mask);
28909 v2f v2f_fshuffle2(v2f a, v2f b, uint_fast8_t rule, uint_fast8_t mask);
28934 v2i v2i_fshuffle2(v2i a, v2i b, uint_fast8_t rule, uint_fast8_t mask);
28959 v2l v2l_fshuffle2(v2l a, v2l b, uint_fast8_t rule, uint_fast8_t mask);
28984 v4d v4d_fshuffle2(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask);
29009 v4f v4f_fshuffle2(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask);
29034 v4i v4i_fshuffle2(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask);
29059 v4l v4l_fshuffle2(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask);
29084 v8d v8d_fshuffle2(v8d a, v8d b, uint_fast8_t rule, uint_fast8_t mask);
29109 v8f v8f_fshuffle2(v8f a, v8f b, uint_fast8_t rule, uint_fast8_t mask);
29134 v8i v8i_fshuffle2(v8i a, v8i b, uint_fast8_t rule, uint_fast8_t mask);
29159 v8l v8l_fshuffle2(v8l a, v8l b, uint_fast8_t rule, uint_fast8_t mask);
29184 v16f v16f_fshuffle2(v16f a, v16f b, uint_fast8_t rule, uint_fast8_t mask);
29209 v16i v16i_fshuffle2(v16i a, v16i b, uint_fast8_t rule, uint_fast8_t mask);
29238 v4d v4d_fshuffle4(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask);
29267 v4f v4f_fshuffle4(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask);
29296 v4i v4i_fshuffle4(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask);
29325 v4l v4l_fshuffle4(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask);
29354 v8d v8d_fshuffle4(v8d a, v8d b, uint_fast8_t rule, uint_fast8_t mask);
29383 v8f v8f_fshuffle4(v8f a, v8f b, uint_fast8_t rule, uint_fast8_t mask);
29412 v8i v8i_fshuffle4(v8i a, v8i b, uint_fast8_t rule, uint_fast8_t mask);
29441 v8l v8l_fshuffle4(v8l a, v8l b, uint_fast8_t rule, uint_fast8_t mask);
29470 v16f v16f_fshuffle4(v16f a, v16f b, uint_fast8_t rule, uint_fast8_t mask);
29499 v16i v16i_fshuffle4(v16i a, v16i b, uint_fast8_t rule, uint_fast8_t mask);
29536 v8d v8d_fshuffle8(v8d a, v8d b, uint_fast32_t rule, uint_fast8_t mask);
29573 v8f v8f_fshuffle8(v8f a, v8f b, uint_fast32_t rule, uint_fast8_t mask);
29610 v8i v8i_fshuffle8(v8i a, v8i b, uint_fast32_t rule, uint_fast8_t mask);
29647 v8l v8l_fshuffle8(v8l a, v8l b, uint_fast32_t rule, uint_fast8_t mask);
29684 v16f v16f_fshuffle8(v16f a, v16f b, uint_fast32_t rule, uint_fast8_t mask);
29721 v16i v16i_fshuffle8(v16i a, v16i b, uint_fast32_t rule, uint_fast8_t mask);
29774 v16f v16f_fshuffle16(v16f a, v16f b, uint_fast64_t rule, uint_fast16_t mask);
29827 v16i v16i_fshuffle16(v16i a, v16i b, uint_fast64_t rule, uint_fast16_t mask);
29828 
29856 v2d v2d_fshuffle2x1(v2d a, v2d b, uint_fast8_t rule, uint_fast8_t mask);
29884 v2f v2f_fshuffle2x1(v2f a, v2f b, uint_fast8_t rule, uint_fast8_t mask);
29912 v2i v2i_fshuffle2x1(v2i a, v2i b, uint_fast8_t rule, uint_fast8_t mask);
29940 v2l v2l_fshuffle2x1(v2l a, v2l b, uint_fast8_t rule, uint_fast8_t mask);
29968 v4d v4d_fshuffle2x2(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask);
29996 v4f v4f_fshuffle2x2(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask);
30024 v4i v4i_fshuffle2x2(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask);
30052 v4l v4l_fshuffle2x2(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask);
30080 v8d v8d_fshuffle2x4(v8d a, v8d b, uint_fast8_t rule, uint_fast8_t mask);
30108 v8f v8f_fshuffle2x4(v8f a, v8f b, uint_fast8_t rule, uint_fast8_t mask);
30136 v8i v8i_fshuffle2x4(v8i a, v8i b, uint_fast8_t rule, uint_fast8_t mask);
30164 v8l v8l_fshuffle2x4(v8l a, v8l b, uint_fast8_t rule, uint_fast8_t mask);
30192 v16f v16f_fshuffle2x8(v16f a, v16f b, uint_fast8_t rule, uint_fast8_t mask);
30220 v16i v16i_fshuffle2x8(v16i a, v16i b, uint_fast8_t rule, uint_fast8_t mask);
30252 v4d v4d_fshuffle4x1(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask);
30284 v4f v4f_fshuffle4x1(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask);
30316 v4i v4i_fshuffle4x1(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask);
30348 v4l v4l_fshuffle4x1(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask);
30380 v8d v8d_fshuffle4x2(v8d a, v8d b, uint_fast8_t rule, uint_fast8_t mask);
30412 v8f v8f_fshuffle4x2(v8f a, v8f b, uint_fast8_t rule, uint_fast8_t mask);
30444 v8i v8i_fshuffle4x2(v8i a, v8i b, uint_fast8_t rule, uint_fast8_t mask);
30476 v8l v8l_fshuffle4x2(v8l a, v8l b, uint_fast8_t rule, uint_fast8_t mask);
30508 v16f v16f_fshuffle4x4(v16f a, v16f b, uint_fast8_t rule, uint_fast8_t mask);
30540 v16i v16i_fshuffle4x4(v16i a, v16i b, uint_fast8_t rule, uint_fast8_t mask);
30580 v8d v8d_fshuffle8x1(v8d a, v8d b, uint_fast32_t rule, uint_fast8_t mask);
30620 v8f v8f_fshuffle8x1(v8f a, v8f b, uint_fast32_t rule, uint_fast8_t mask);
30660 v8i v8i_fshuffle8x1(v8i a, v8i b, uint_fast32_t rule, uint_fast8_t mask);
30700 v8l v8l_fshuffle8x1(v8l a, v8l b, uint_fast32_t rule, uint_fast8_t mask);
30740 v16f v16f_fshuffle8x2(v16f a, v16f b, uint_fast32_t rule, uint_fast8_t mask);
30780 v16i v16i_fshuffle8x2(v16i a, v16i b, uint_fast32_t rule, uint_fast8_t mask);
30836 v16f v16f_fshuffle16x1(v16f a, v16f b, uint_fast64_t rule, uint_fast16_t mask);
30892 v16i v16i_fshuffle16x1(v16i a, v16i b, uint_fast64_t rule, uint_fast16_t mask);
30893 
30915 v1d v1d_hshuffle(v1d a, v1d b, uint_fast8_t rule);
30937 v1f v1f_hshuffle(v1f a, v1f b, uint_fast8_t rule);
30959 v1i v1i_hshuffle(v1i a, v1i b, uint_fast8_t rule);
30981 v1l v1l_hshuffle(v1l a, v1l b, uint_fast8_t rule);
31005 v2d v2d_hshuffle(v2d a, v2d b, uint_fast8_t rule);
31029 v2f v2f_hshuffle(v2f a, v2f b, uint_fast8_t rule);
31053 v2i v2i_hshuffle(v2i a, v2i b, uint_fast8_t rule);
31077 v2l v2l_hshuffle(v2l a, v2l b, uint_fast8_t rule);
31105 v4d v4d_hshuffle(v4d a, v4d b, uint_fast8_t rule);
31133 v4f v4f_hshuffle(v4f a, v4f b, uint_fast8_t rule);
31161 v4i v4i_hshuffle(v4i a, v4i b, uint_fast8_t rule);
31189 v4l v4l_hshuffle(v4l a, v4l b, uint_fast8_t rule);
31225 v8d v8d_hshuffle(v8d a, v8d b, uint_fast32_t rule);
31261 v8f v8f_hshuffle(v8f a, v8f b, uint_fast32_t rule);
31297 v8i v8i_hshuffle(v8i a, v8i b, uint_fast32_t rule);
31333 v8l v8l_hshuffle(v8l a, v8l b, uint_fast32_t rule);
31385 v16f v16f_hshuffle(v16f a, v16f b, uint_fast64_t rule);
31437 v16i v16i_hshuffle(v16i a, v16i b, uint_fast64_t rule);
31438 
31463 v1d v1d_permute(v1d a, uint_fast8_t rule);
31488 v1f v1f_permute(v1f a, uint_fast8_t rule);
31513 v1i v1i_permute(v1i a, uint_fast8_t rule);
31538 v1l v1l_permute(v1l a, uint_fast8_t rule);
31565 v2d v2d_permute(v2d a, uint_fast8_t rule);
31592 v2f v2f_permute(v2f a, uint_fast8_t rule);
31619 v2i v2i_permute(v2i a, uint_fast8_t rule);
31646 v2l v2l_permute(v2l a, uint_fast8_t rule);
31677 v4d v4d_permute(v4d a, uint_fast8_t rule);
31708 v4f v4f_permute(v4f a, uint_fast8_t rule);
31739 v4i v4i_permute(v4i a, uint_fast8_t rule);
31770 v4l v4l_permute(v4l a, uint_fast8_t rule);
31809 v8d v8d_permute(v8d a, uint_fast32_t rule);
31848 v8f v8f_permute(v8f a, uint_fast32_t rule);
31887 v8i v8i_permute(v8i a, uint_fast32_t rule);
31926 v8l v8l_permute(v8l a, uint_fast32_t rule);
31981 v16f v16f_permute(v16f a, uint_fast64_t rule);
32036 v16i v16i_permute(v16i a, uint_fast64_t rule);
32037 
32060 v1d v1d_fshuffle(v1d a, v1d b, uint_fast8_t rule, uint_fast8_t mask);
32083 v1f v1f_fshuffle(v1f a, v1f b, uint_fast8_t rule, uint_fast8_t mask);
32106 v1i v1i_fshuffle(v1i a, v1i b, uint_fast8_t rule, uint_fast8_t mask);
32129 v1l v1l_fshuffle(v1l a, v1l b, uint_fast8_t rule, uint_fast8_t mask);
32154 v2d v2d_fshuffle(v2d a, v2d b, uint_fast8_t rule, uint_fast8_t mask);
32179 v2f v2f_fshuffle(v2f a, v2f b, uint_fast8_t rule, uint_fast8_t mask);
32204 v2i v2i_fshuffle(v2i a, v2i b, uint_fast8_t rule, uint_fast8_t mask);
32229 v2l v2l_fshuffle(v2l a, v2l b, uint_fast8_t rule, uint_fast8_t mask);
32258 v4d v4d_fshuffle(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask);
32287 v4f v4f_fshuffle(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask);
32316 v4i v4i_fshuffle(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask);
32345 v4l v4l_fshuffle(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask);
32382 v8d v8d_fshuffle(v8d a, v8d b, uint_fast32_t rule, uint_fast8_t mask);
32419 v8f v8f_fshuffle(v8f a, v8f b, uint_fast32_t rule, uint_fast8_t mask);
32456 v8i v8i_fshuffle(v8i a, v8i b, uint_fast32_t rule, uint_fast8_t mask);
32493 v8l v8l_fshuffle(v8l a, v8l b, uint_fast32_t rule, uint_fast8_t mask);
32546 v16f v16f_fshuffle(v16f a, v16f b, uint_fast64_t rule, uint_fast16_t mask);
32599 v16i v16i_fshuffle(v16i a, v16i b, uint_fast64_t rule, uint_fast16_t mask);
32600 
32601 /* REDUCTIONS */
32618 v1d v1d_reduce_add(v1d a);
32631 v1f v1f_reduce_add(v1f a);
32644 v1i v1i_reduce_add(v1i a);
32657 v1l v1l_reduce_add(v1l a);
32677 v2d v2d_reduce_add(v2d a);
32697 v2f v2f_reduce_add(v2f a);
32717 v2i v2i_reduce_add(v2i a);
32737 v2l v2l_reduce_add(v2l a);
32757 v4d v4d_reduce_add(v4d a);
32777 v4f v4f_reduce_add(v4f a);
32797 v4i v4i_reduce_add(v4i a);
32817 v4l v4l_reduce_add(v4l a);
32837 v8d v8d_reduce_add(v8d a);
32857 v8f v8f_reduce_add(v8f a);
32877 v8i v8i_reduce_add(v8i a);
32897 v8l v8l_reduce_add(v8l a);
32917 v16f v16f_reduce_add(v16f a);
32937 v16i v16i_reduce_add(v16i a);
32950 v1d v1d_reduce_add_v1d(v1d a);
32963 v1f v1f_reduce_add_v1f(v1f a);
32976 v1i v1i_reduce_add_v1i(v1i a);
32989 v1l v1l_reduce_add_v1l(v1l a);
33009 v2d v2d_reduce_add_v1d(v1d a);
33029 v2f v2f_reduce_add_v1f(v1f a);
33049 v2i v2i_reduce_add_v1i(v1i a);
33069 v2l v2l_reduce_add_v1l(v1l a);
33089 v4d v4d_reduce_add_v1d(v1d a);
33109 v4f v4f_reduce_add_v1f(v1f a);
33129 v4i v4i_reduce_add_v1i(v1i a);
33149 v4l v4l_reduce_add_v1l(v1l a);
33169 v8d v8d_reduce_add_v1d(v1d a);
33189 v8f v8f_reduce_add_v1f(v1f a);
33209 v8i v8i_reduce_add_v1i(v1i a);
33229 v8l v8l_reduce_add_v1l(v1l a);
33249 v16f v16f_reduce_add_v1f(v1f a);
33269 v16i v16i_reduce_add_v1i(v1i a);
33282 v1d v1d_reduce_add_v2d(v2d a);
33295 v1f v1f_reduce_add_v2f(v2f a);
33308 v1i v1i_reduce_add_v2i(v2i a);
33321 v1l v1l_reduce_add_v2l(v2l a);
33341 v2d v2d_reduce_add_v2d(v2d a);
33361 v2f v2f_reduce_add_v2f(v2f a);
33381 v2i v2i_reduce_add_v2i(v2i a);
33401 v2l v2l_reduce_add_v2l(v2l a);
33421 v4d v4d_reduce_add_v2d(v2d a);
33441 v4f v4f_reduce_add_v2f(v2f a);
33461 v4i v4i_reduce_add_v2i(v2i a);
33481 v4l v4l_reduce_add_v2l(v2l a);
33501 v8d v8d_reduce_add_v2d(v2d a);
33521 v8f v8f_reduce_add_v2f(v2f a);
33541 v8i v8i_reduce_add_v2i(v2i a);
33561 v8l v8l_reduce_add_v2l(v2l a);
33581 v16f v16f_reduce_add_v2f(v2f a);
33601 v16i v16i_reduce_add_v2i(v2i a);
33614 v1d v1d_reduce_add_v4d(v4d a);
33627 v1f v1f_reduce_add_v4f(v4f a);
33640 v1i v1i_reduce_add_v4i(v4i a);
33653 v1l v1l_reduce_add_v4l(v4l a);
33673 v2d v2d_reduce_add_v4d(v4d a);
33693 v2f v2f_reduce_add_v4f(v4f a);
33713 v2i v2i_reduce_add_v4i(v4i a);
33733 v2l v2l_reduce_add_v4l(v4l a);
33753 v4d v4d_reduce_add_v4d(v4d a);
33773 v4f v4f_reduce_add_v4f(v4f a);
33793 v4i v4i_reduce_add_v4i(v4i a);
33813 v4l v4l_reduce_add_v4l(v4l a);
33833 v8d v8d_reduce_add_v4d(v4d a);
33853 v8f v8f_reduce_add_v4f(v4f a);
33873 v8i v8i_reduce_add_v4i(v4i a);
33893 v8l v8l_reduce_add_v4l(v4l a);
33913 v16f v16f_reduce_add_v4f(v4f a);
33933 v16i v16i_reduce_add_v4i(v4i a);
33946 v1d v1d_reduce_add_v8d(v8d a);
33959 v1f v1f_reduce_add_v8f(v8f a);
33972 v1i v1i_reduce_add_v8i(v8i a);
33985 v1l v1l_reduce_add_v8l(v8l a);
34005 v2d v2d_reduce_add_v8d(v8d a);
34025 v2f v2f_reduce_add_v8f(v8f a);
34045 v2i v2i_reduce_add_v8i(v8i a);
34065 v2l v2l_reduce_add_v8l(v8l a);
34085 v4d v4d_reduce_add_v8d(v8d a);
34105 v4f v4f_reduce_add_v8f(v8f a);
34125 v4i v4i_reduce_add_v8i(v8i a);
34145 v4l v4l_reduce_add_v8l(v8l a);
34165 v8d v8d_reduce_add_v8d(v8d a);
34185 v8f v8f_reduce_add_v8f(v8f a);
34205 v8i v8i_reduce_add_v8i(v8i a);
34225 v8l v8l_reduce_add_v8l(v8l a);
34245 v16f v16f_reduce_add_v8f(v8f a);
34265 v16i v16i_reduce_add_v8i(v8i a);
34278 v1f v1f_reduce_add_v16f(v16f a);
34291 v1i v1i_reduce_add_v16i(v16i a);
34311 v2f v2f_reduce_add_v16f(v16f a);
34331 v2i v2i_reduce_add_v16i(v16i a);
34351 v4f v4f_reduce_add_v16f(v16f a);
34371 v4i v4i_reduce_add_v16i(v16i a);
34391 v8f v8f_reduce_add_v16f(v16f a);
34411 v8i v8i_reduce_add_v16i(v16i a);
34431 v16f v16f_reduce_add_v16f(v16f a);
34451 v16i v16i_reduce_add_v16i(v16i a);
34464 v1d sd_reduce_add_v1d(v1d a);
34477 v1f sf_reduce_add_v1f(v1f a);
34490 v1i si_reduce_add_v1i(v1i a);
34503 v1l sl_reduce_add_v1l(v1l a);
34519 v2d sd_reduce_add_v2d(v2d a);
34535 v2f sf_reduce_add_v2f(v2f a);
34551 v2i si_reduce_add_v2i(v2i a);
34567 v2l sl_reduce_add_v2l(v2l a);
34583 v4d sd_reduce_add_v4d(v4d a);
34599 v4f sf_reduce_add_v4f(v4f a);
34615 v4i si_reduce_add_v4i(v4i a);
34631 v4l sl_reduce_add_v4l(v4l a);
34647 v8d sd_reduce_add_v8d(v8d a);
34663 v8f sf_reduce_add_v8f(v8f a);
34679 v8i si_reduce_add_v8i(v8i a);
34695 v8l sl_reduce_add_v8l(v8l a);
34711 v16f sf_reduce_add_v16f(v16f a);
34727 v16i si_reduce_add_v16i(v16i a);
34740 v1d v1d_reduce_mul(v1d a);
34753 v1f v1f_reduce_mul(v1f a);
34766 v1i v1i_reduce_mul(v1i a);
34779 v1l v1l_reduce_mul(v1l a);
34799 v2d v2d_reduce_mul(v2d a);
34819 v2f v2f_reduce_mul(v2f a);
34839 v2i v2i_reduce_mul(v2i a);
34859 v2l v2l_reduce_mul(v2l a);
34879 v4d v4d_reduce_mul(v4d a);
34899 v4f v4f_reduce_mul(v4f a);
34919 v4i v4i_reduce_mul(v4i a);
34939 v4l v4l_reduce_mul(v4l a);
34959 v8d v8d_reduce_mul(v8d a);
34979 v8f v8f_reduce_mul(v8f a);
34999 v8i v8i_reduce_mul(v8i a);
35019 v8l v8l_reduce_mul(v8l a);
35039 v16f v16f_reduce_mul(v16f a);
35059 v16i v16i_reduce_mul(v16i a);
35072 v1d v1d_reduce_mul_v1d(v1d a);
35085 v1f v1f_reduce_mul_v1f(v1f a);
35098 v1i v1i_reduce_mul_v1i(v1i a);
35111 v1l v1l_reduce_mul_v1l(v1l a);
35131 v2d v2d_reduce_mul_v1d(v1d a);
35151 v2f v2f_reduce_mul_v1f(v1f a);
35171 v2i v2i_reduce_mul_v1i(v1i a);
35191 v2l v2l_reduce_mul_v1l(v1l a);
35211 v4d v4d_reduce_mul_v1d(v1d a);
35231 v4f v4f_reduce_mul_v1f(v1f a);
35251 v4i v4i_reduce_mul_v1i(v1i a);
35271 v4l v4l_reduce_mul_v1l(v1l a);
35291 v8d v8d_reduce_mul_v1d(v1d a);
35311 v8f v8f_reduce_mul_v1f(v1f a);
35331 v8i v8i_reduce_mul_v1i(v1i a);
35351 v8l v8l_reduce_mul_v1l(v1l a);
35371 v16f v16f_reduce_mul_v1f(v1f a);
35391 v16i v16i_reduce_mul_v1i(v1i a);
35404 v1d v1d_reduce_mul_v2d(v2d a);
35417 v1f v1f_reduce_mul_v2f(v2f a);
35430 v1i v1i_reduce_mul_v2i(v2i a);
35443 v1l v1l_reduce_mul_v2l(v2l a);
35463 v2d v2d_reduce_mul_v2d(v2d a);
35483 v2f v2f_reduce_mul_v2f(v2f a);
35503 v2i v2i_reduce_mul_v2i(v2i a);
35523 v2l v2l_reduce_mul_v2l(v2l a);
35543 v4d v4d_reduce_mul_v2d(v2d a);
35563 v4f v4f_reduce_mul_v2f(v2f a);
35583 v4i v4i_reduce_mul_v2i(v2i a);
35603 v4l v4l_reduce_mul_v2l(v2l a);
35623 v8d v8d_reduce_mul_v2d(v2d a);
35643 v8f v8f_reduce_mul_v2f(v2f a);
35663 v8i v8i_reduce_mul_v2i(v2i a);
35683 v8l v8l_reduce_mul_v2l(v2l a);
35703 v16f v16f_reduce_mul_v2f(v2f a);
35723 v16i v16i_reduce_mul_v2i(v2i a);
35736 v1d v1d_reduce_mul_v4d(v4d a);
35749 v1f v1f_reduce_mul_v4f(v4f a);
35762 v1i v1i_reduce_mul_v4i(v4i a);
35775 v1l v1l_reduce_mul_v4l(v4l a);
35795 v2d v2d_reduce_mul_v4d(v4d a);
35815 v2f v2f_reduce_mul_v4f(v4f a);
35835 v2i v2i_reduce_mul_v4i(v4i a);
35855 v2l v2l_reduce_mul_v4l(v4l a);
35875 v4d v4d_reduce_mul_v4d(v4d a);
35895 v4f v4f_reduce_mul_v4f(v4f a);
35915 v4i v4i_reduce_mul_v4i(v4i a);
35935 v4l v4l_reduce_mul_v4l(v4l a);
35955 v8d v8d_reduce_mul_v4d(v4d a);
35975 v8f v8f_reduce_mul_v4f(v4f a);
35995 v8i v8i_reduce_mul_v4i(v4i a);
36015 v8l v8l_reduce_mul_v4l(v4l a);
36035 v16f v16f_reduce_mul_v4f(v4f a);
36055 v16i v16i_reduce_mul_v4i(v4i a);
36068 v1d v1d_reduce_mul_v8d(v8d a);
36081 v1f v1f_reduce_mul_v8f(v8f a);
36094 v1i v1i_reduce_mul_v8i(v8i a);
36107 v1l v1l_reduce_mul_v8l(v8l a);
36127 v2d v2d_reduce_mul_v8d(v8d a);
36147 v2f v2f_reduce_mul_v8f(v8f a);
36167 v2i v2i_reduce_mul_v8i(v8i a);
36187 v2l v2l_reduce_mul_v8l(v8l a);
36207 v4d v4d_reduce_mul_v8d(v8d a);
36227 v4f v4f_reduce_mul_v8f(v8f a);
36247 v4i v4i_reduce_mul_v8i(v8i a);
36267 v4l v4l_reduce_mul_v8l(v8l a);
36287 v8d v8d_reduce_mul_v8d(v8d a);
36307 v8f v8f_reduce_mul_v8f(v8f a);
36327 v8i v8i_reduce_mul_v8i(v8i a);
36347 v8l v8l_reduce_mul_v8l(v8l a);
36367 v16f v16f_reduce_mul_v8f(v8f a);
36387 v16i v16i_reduce_mul_v8i(v8i a);
36400 v1f v1f_reduce_mul_v16f(v16f a);
36413 v1i v1i_reduce_mul_v16i(v16i a);
36433 v2f v2f_reduce_mul_v16f(v16f a);
36453 v2i v2i_reduce_mul_v16i(v16i a);
36473 v4f v4f_reduce_mul_v16f(v16f a);
36493 v4i v4i_reduce_mul_v16i(v16i a);
36513 v8f v8f_reduce_mul_v16f(v16f a);
36533 v8i v8i_reduce_mul_v16i(v16i a);
36553 v16f v16f_reduce_mul_v16f(v16f a);
36573 v16i v16i_reduce_mul_v16i(v16i a);
36586 v1d sd_reduce_mul_v1d(v1d a);
36599 v1f sf_reduce_mul_v1f(v1f a);
36612 v1i si_reduce_mul_v1i(v1i a);
36625 v1l sl_reduce_mul_v1l(v1l a);
36641 v2d sd_reduce_mul_v2d(v2d a);
36657 v2f sf_reduce_mul_v2f(v2f a);
36673 v2i si_reduce_mul_v2i(v2i a);
36689 v2l sl_reduce_mul_v2l(v2l a);
36705 v4d sd_reduce_mul_v4d(v4d a);
36721 v4f sf_reduce_mul_v4f(v4f a);
36737 v4i si_reduce_mul_v4i(v4i a);
36753 v4l sl_reduce_mul_v4l(v4l a);
36769 v8d sd_reduce_mul_v8d(v8d a);
36785 v8f sf_reduce_mul_v8f(v8f a);
36801 v8i si_reduce_mul_v8i(v8i a);
36817 v8l sl_reduce_mul_v8l(v8l a);
36833 v16f sf_reduce_mul_v16f(v16f a);
36849 v16i si_reduce_mul_v16i(v16i a);
36862 v1d v1d_reduce_and(v1d a);
36875 v1f v1f_reduce_and(v1f a);
36888 v1i v1i_reduce_and(v1i a);
36901 v1l v1l_reduce_and(v1l a);
36921 v2d v2d_reduce_and(v2d a);
36941 v2f v2f_reduce_and(v2f a);
36961 v2i v2i_reduce_and(v2i a);
36981 v2l v2l_reduce_and(v2l a);
37001 v4d v4d_reduce_and(v4d a);
37021 v4f v4f_reduce_and(v4f a);
37041 v4i v4i_reduce_and(v4i a);
37061 v4l v4l_reduce_and(v4l a);
37081 v8d v8d_reduce_and(v8d a);
37101 v8f v8f_reduce_and(v8f a);
37121 v8i v8i_reduce_and(v8i a);
37141 v8l v8l_reduce_and(v8l a);
37161 v16f v16f_reduce_and(v16f a);
37181 v16i v16i_reduce_and(v16i a);
37194 v1d v1d_reduce_and_v1d(v1d a);
37207 v1f v1f_reduce_and_v1f(v1f a);
37220 v1i v1i_reduce_and_v1i(v1i a);
37233 v1l v1l_reduce_and_v1l(v1l a);
37253 v2d v2d_reduce_and_v1d(v1d a);
37273 v2f v2f_reduce_and_v1f(v1f a);
37293 v2i v2i_reduce_and_v1i(v1i a);
37313 v2l v2l_reduce_and_v1l(v1l a);
37333 v4d v4d_reduce_and_v1d(v1d a);
37353 v4f v4f_reduce_and_v1f(v1f a);
37373 v4i v4i_reduce_and_v1i(v1i a);
37393 v4l v4l_reduce_and_v1l(v1l a);
37413 v8d v8d_reduce_and_v1d(v1d a);
37433 v8f v8f_reduce_and_v1f(v1f a);
37453 v8i v8i_reduce_and_v1i(v1i a);
37473 v8l v8l_reduce_and_v1l(v1l a);
37493 v16f v16f_reduce_and_v1f(v1f a);
37513 v16i v16i_reduce_and_v1i(v1i a);
37526 v1d v1d_reduce_and_v2d(v2d a);
37539 v1f v1f_reduce_and_v2f(v2f a);
37552 v1i v1i_reduce_and_v2i(v2i a);
37565 v1l v1l_reduce_and_v2l(v2l a);
37585 v2d v2d_reduce_and_v2d(v2d a);
37605 v2f v2f_reduce_and_v2f(v2f a);
37625 v2i v2i_reduce_and_v2i(v2i a);
37645 v2l v2l_reduce_and_v2l(v2l a);
37665 v4d v4d_reduce_and_v2d(v2d a);
37685 v4f v4f_reduce_and_v2f(v2f a);
37705 v4i v4i_reduce_and_v2i(v2i a);
37725 v4l v4l_reduce_and_v2l(v2l a);
37745 v8d v8d_reduce_and_v2d(v2d a);
37765 v8f v8f_reduce_and_v2f(v2f a);
37785 v8i v8i_reduce_and_v2i(v2i a);
37805 v8l v8l_reduce_and_v2l(v2l a);
37825 v16f v16f_reduce_and_v2f(v2f a);
37845 v16i v16i_reduce_and_v2i(v2i a);
37858 v1d v1d_reduce_and_v4d(v4d a);
37871 v1f v1f_reduce_and_v4f(v4f a);
37884 v1i v1i_reduce_and_v4i(v4i a);
37897 v1l v1l_reduce_and_v4l(v4l a);
37917 v2d v2d_reduce_and_v4d(v4d a);
37937 v2f v2f_reduce_and_v4f(v4f a);
37957 v2i v2i_reduce_and_v4i(v4i a);
37977 v2l v2l_reduce_and_v4l(v4l a);
37997 v4d v4d_reduce_and_v4d(v4d a);
38017 v4f v4f_reduce_and_v4f(v4f a);
38037 v4i v4i_reduce_and_v4i(v4i a);
38057 v4l v4l_reduce_and_v4l(v4l a);
38077 v8d v8d_reduce_and_v4d(v4d a);
38097 v8f v8f_reduce_and_v4f(v4f a);
38117 v8i v8i_reduce_and_v4i(v4i a);
38137 v8l v8l_reduce_and_v4l(v4l a);
38157 v16f v16f_reduce_and_v4f(v4f a);
38177 v16i v16i_reduce_and_v4i(v4i a);
38190 v1d v1d_reduce_and_v8d(v8d a);
38203 v1f v1f_reduce_and_v8f(v8f a);
38216 v1i v1i_reduce_and_v8i(v8i a);
38229 v1l v1l_reduce_and_v8l(v8l a);
38249 v2d v2d_reduce_and_v8d(v8d a);
38269 v2f v2f_reduce_and_v8f(v8f a);
38289 v2i v2i_reduce_and_v8i(v8i a);
38309 v2l v2l_reduce_and_v8l(v8l a);
38329 v4d v4d_reduce_and_v8d(v8d a);
38349 v4f v4f_reduce_and_v8f(v8f a);
38369 v4i v4i_reduce_and_v8i(v8i a);
38389 v4l v4l_reduce_and_v8l(v8l a);
38409 v8d v8d_reduce_and_v8d(v8d a);
38429 v8f v8f_reduce_and_v8f(v8f a);
38449 v8i v8i_reduce_and_v8i(v8i a);
38469 v8l v8l_reduce_and_v8l(v8l a);
38489 v16f v16f_reduce_and_v8f(v8f a);
38509 v16i v16i_reduce_and_v8i(v8i a);
38522 v1f v1f_reduce_and_v16f(v16f a);
38535 v1i v1i_reduce_and_v16i(v16i a);
38555 v2f v2f_reduce_and_v16f(v16f a);
38575 v2i v2i_reduce_and_v16i(v16i a);
38595 v4f v4f_reduce_and_v16f(v16f a);
38615 v4i v4i_reduce_and_v16i(v16i a);
38635 v8f v8f_reduce_and_v16f(v16f a);
38655 v8i v8i_reduce_and_v16i(v16i a);
38675 v16f v16f_reduce_and_v16f(v16f a);
38695 v16i v16i_reduce_and_v16i(v16i a);
38708 v1d sd_reduce_and_v1d(v1d a);
38721 v1f sf_reduce_and_v1f(v1f a);
38734 v1i si_reduce_and_v1i(v1i a);
38747 v1l sl_reduce_and_v1l(v1l a);
38763 v2d sd_reduce_and_v2d(v2d a);
38779 v2f sf_reduce_and_v2f(v2f a);
38795 v2i si_reduce_and_v2i(v2i a);
38811 v2l sl_reduce_and_v2l(v2l a);
38827 v4d sd_reduce_and_v4d(v4d a);
38843 v4f sf_reduce_and_v4f(v4f a);
38859 v4i si_reduce_and_v4i(v4i a);
38875 v4l sl_reduce_and_v4l(v4l a);
38891 v8d sd_reduce_and_v8d(v8d a);
38907 v8f sf_reduce_and_v8f(v8f a);
38923 v8i si_reduce_and_v8i(v8i a);
38939 v8l sl_reduce_and_v8l(v8l a);
38955 v16f sf_reduce_and_v16f(v16f a);
38971 v16i si_reduce_and_v16i(v16i a);
38984 v1d v1d_reduce_or(v1d a);
38997 v1f v1f_reduce_or(v1f a);
39010 v1i v1i_reduce_or(v1i a);
39023 v1l v1l_reduce_or(v1l a);
39043 v2d v2d_reduce_or(v2d a);
39063 v2f v2f_reduce_or(v2f a);
39083 v2i v2i_reduce_or(v2i a);
39103 v2l v2l_reduce_or(v2l a);
39123 v4d v4d_reduce_or(v4d a);
39143 v4f v4f_reduce_or(v4f a);
39163 v4i v4i_reduce_or(v4i a);
39183 v4l v4l_reduce_or(v4l a);
39203 v8d v8d_reduce_or(v8d a);
39223 v8f v8f_reduce_or(v8f a);
39243 v8i v8i_reduce_or(v8i a);
39263 v8l v8l_reduce_or(v8l a);
39283 v16f v16f_reduce_or(v16f a);
39303 v16i v16i_reduce_or(v16i a);
39316 v1d v1d_reduce_or_v1d(v1d a);
39329 v1f v1f_reduce_or_v1f(v1f a);
39342 v1i v1i_reduce_or_v1i(v1i a);
39355 v1l v1l_reduce_or_v1l(v1l a);
39375 v2d v2d_reduce_or_v1d(v1d a);
39395 v2f v2f_reduce_or_v1f(v1f a);
39415 v2i v2i_reduce_or_v1i(v1i a);
39435 v2l v2l_reduce_or_v1l(v1l a);
39455 v4d v4d_reduce_or_v1d(v1d a);
39475 v4f v4f_reduce_or_v1f(v1f a);
39495 v4i v4i_reduce_or_v1i(v1i a);
39515 v4l v4l_reduce_or_v1l(v1l a);
39535 v8d v8d_reduce_or_v1d(v1d a);
39555 v8f v8f_reduce_or_v1f(v1f a);
39575 v8i v8i_reduce_or_v1i(v1i a);
39595 v8l v8l_reduce_or_v1l(v1l a);
39615 v16f v16f_reduce_or_v1f(v1f a);
39635 v16i v16i_reduce_or_v1i(v1i a);
39648 v1d v1d_reduce_or_v2d(v2d a);
39661 v1f v1f_reduce_or_v2f(v2f a);
39674 v1i v1i_reduce_or_v2i(v2i a);
39687 v1l v1l_reduce_or_v2l(v2l a);
39707 v2d v2d_reduce_or_v2d(v2d a);
39727 v2f v2f_reduce_or_v2f(v2f a);
39747 v2i v2i_reduce_or_v2i(v2i a);
39767 v2l v2l_reduce_or_v2l(v2l a);
39787 v4d v4d_reduce_or_v2d(v2d a);
39807 v4f v4f_reduce_or_v2f(v2f a);
39827 v4i v4i_reduce_or_v2i(v2i a);
39847 v4l v4l_reduce_or_v2l(v2l a);
39867 v8d v8d_reduce_or_v2d(v2d a);
39887 v8f v8f_reduce_or_v2f(v2f a);
39907 v8i v8i_reduce_or_v2i(v2i a);
39927 v8l v8l_reduce_or_v2l(v2l a);
39947 v16f v16f_reduce_or_v2f(v2f a);
39967 v16i v16i_reduce_or_v2i(v2i a);
39980 v1d v1d_reduce_or_v4d(v4d a);
39993 v1f v1f_reduce_or_v4f(v4f a);
40006 v1i v1i_reduce_or_v4i(v4i a);
40019 v1l v1l_reduce_or_v4l(v4l a);
40039 v2d v2d_reduce_or_v4d(v4d a);
40059 v2f v2f_reduce_or_v4f(v4f a);
40079 v2i v2i_reduce_or_v4i(v4i a);
40099 v2l v2l_reduce_or_v4l(v4l a);
40119 v4d v4d_reduce_or_v4d(v4d a);
40139 v4f v4f_reduce_or_v4f(v4f a);
40159 v4i v4i_reduce_or_v4i(v4i a);
40179 v4l v4l_reduce_or_v4l(v4l a);
40199 v8d v8d_reduce_or_v4d(v4d a);
40219 v8f v8f_reduce_or_v4f(v4f a);
40239 v8i v8i_reduce_or_v4i(v4i a);
40259 v8l v8l_reduce_or_v4l(v4l a);
40279 v16f v16f_reduce_or_v4f(v4f a);
40299 v16i v16i_reduce_or_v4i(v4i a);
40312 v1d v1d_reduce_or_v8d(v8d a);
40325 v1f v1f_reduce_or_v8f(v8f a);
40338 v1i v1i_reduce_or_v8i(v8i a);
40351 v1l v1l_reduce_or_v8l(v8l a);
40371 v2d v2d_reduce_or_v8d(v8d a);
40391 v2f v2f_reduce_or_v8f(v8f a);
40411 v2i v2i_reduce_or_v8i(v8i a);
40431 v2l v2l_reduce_or_v8l(v8l a);
40451 v4d v4d_reduce_or_v8d(v8d a);
40471 v4f v4f_reduce_or_v8f(v8f a);
40491 v4i v4i_reduce_or_v8i(v8i a);
40511 v4l v4l_reduce_or_v8l(v8l a);
40531 v8d v8d_reduce_or_v8d(v8d a);
40551 v8f v8f_reduce_or_v8f(v8f a);
40571 v8i v8i_reduce_or_v8i(v8i a);
40591 v8l v8l_reduce_or_v8l(v8l a);
40611 v16f v16f_reduce_or_v8f(v8f a);
40631 v16i v16i_reduce_or_v8i(v8i a);
40644 v1f v1f_reduce_or_v16f(v16f a);
40657 v1i v1i_reduce_or_v16i(v16i a);
40677 v2f v2f_reduce_or_v16f(v16f a);
40697 v2i v2i_reduce_or_v16i(v16i a);
40717 v4f v4f_reduce_or_v16f(v16f a);
40737 v4i v4i_reduce_or_v16i(v16i a);
40757 v8f v8f_reduce_or_v16f(v16f a);
40777 v8i v8i_reduce_or_v16i(v16i a);
40797 v16f v16f_reduce_or_v16f(v16f a);
40817 v16i v16i_reduce_or_v16i(v16i a);
40830 v1d sd_reduce_or_v1d(v1d a);
40843 v1f sf_reduce_or_v1f(v1f a);
40856 v1i si_reduce_or_v1i(v1i a);
40869 v1l sl_reduce_or_v1l(v1l a);
40885 v2d sd_reduce_or_v2d(v2d a);
40901 v2f sf_reduce_or_v2f(v2f a);
40917 v2i si_reduce_or_v2i(v2i a);
40933 v2l sl_reduce_or_v2l(v2l a);
40949 v4d sd_reduce_or_v4d(v4d a);
40965 v4f sf_reduce_or_v4f(v4f a);
40981 v4i si_reduce_or_v4i(v4i a);
40997 v4l sl_reduce_or_v4l(v4l a);
41013 v8d sd_reduce_or_v8d(v8d a);
41029 v8f sf_reduce_or_v8f(v8f a);
41045 v8i si_reduce_or_v8i(v8i a);
41061 v8l sl_reduce_or_v8l(v8l a);
41077 v16f sf_reduce_or_v16f(v16f a);
41093 v16i si_reduce_or_v16i(v16i a);
41106 v1d v1d_reduce_min(v1d a);
41119 v1f v1f_reduce_min(v1f a);
41132 v1i v1i_reduce_min(v1i a);
41145 v1l v1l_reduce_min(v1l a);
41165 v2d v2d_reduce_min(v2d a);
41185 v2f v2f_reduce_min(v2f a);
41205 v2i v2i_reduce_min(v2i a);
41225 v2l v2l_reduce_min(v2l a);
41245 v4d v4d_reduce_min(v4d a);
41265 v4f v4f_reduce_min(v4f a);
41285 v4i v4i_reduce_min(v4i a);
41305 v4l v4l_reduce_min(v4l a);
41325 v8d v8d_reduce_min(v8d a);
41345 v8f v8f_reduce_min(v8f a);
41365 v8i v8i_reduce_min(v8i a);
41385 v8l v8l_reduce_min(v8l a);
41405 v16f v16f_reduce_min(v16f a);
41425 v16i v16i_reduce_min(v16i a);
41438 v1d v1d_reduce_min_v1d(v1d a);
41451 v1f v1f_reduce_min_v1f(v1f a);
41464 v1i v1i_reduce_min_v1i(v1i a);
41477 v1l v1l_reduce_min_v1l(v1l a);
41497 v2d v2d_reduce_min_v1d(v1d a);
41517 v2f v2f_reduce_min_v1f(v1f a);
41537 v2i v2i_reduce_min_v1i(v1i a);
41557 v2l v2l_reduce_min_v1l(v1l a);
41577 v4d v4d_reduce_min_v1d(v1d a);
41597 v4f v4f_reduce_min_v1f(v1f a);
41617 v4i v4i_reduce_min_v1i(v1i a);
41637 v4l v4l_reduce_min_v1l(v1l a);
41657 v8d v8d_reduce_min_v1d(v1d a);
41677 v8f v8f_reduce_min_v1f(v1f a);
41697 v8i v8i_reduce_min_v1i(v1i a);
41717 v8l v8l_reduce_min_v1l(v1l a);
41737 v16f v16f_reduce_min_v1f(v1f a);
41757 v16i v16i_reduce_min_v1i(v1i a);
41770 v1d v1d_reduce_min_v2d(v2d a);
41783 v1f v1f_reduce_min_v2f(v2f a);
41796 v1i v1i_reduce_min_v2i(v2i a);
41809 v1l v1l_reduce_min_v2l(v2l a);
41829 v2d v2d_reduce_min_v2d(v2d a);
41849 v2f v2f_reduce_min_v2f(v2f a);
41869 v2i v2i_reduce_min_v2i(v2i a);
41889 v2l v2l_reduce_min_v2l(v2l a);
41909 v4d v4d_reduce_min_v2d(v2d a);
41929 v4f v4f_reduce_min_v2f(v2f a);
41949 v4i v4i_reduce_min_v2i(v2i a);
41969 v4l v4l_reduce_min_v2l(v2l a);
41989 v8d v8d_reduce_min_v2d(v2d a);
42009 v8f v8f_reduce_min_v2f(v2f a);
42029 v8i v8i_reduce_min_v2i(v2i a);
42049 v8l v8l_reduce_min_v2l(v2l a);
42069 v16f v16f_reduce_min_v2f(v2f a);
42089 v16i v16i_reduce_min_v2i(v2i a);
42102 v1d v1d_reduce_min_v4d(v4d a);
42115 v1f v1f_reduce_min_v4f(v4f a);
42128 v1i v1i_reduce_min_v4i(v4i a);
42141 v1l v1l_reduce_min_v4l(v4l a);
42161 v2d v2d_reduce_min_v4d(v4d a);
42181 v2f v2f_reduce_min_v4f(v4f a);
42201 v2i v2i_reduce_min_v4i(v4i a);
42221 v2l v2l_reduce_min_v4l(v4l a);
42241 v4d v4d_reduce_min_v4d(v4d a);
42261 v4f v4f_reduce_min_v4f(v4f a);
42281 v4i v4i_reduce_min_v4i(v4i a);
42301 v4l v4l_reduce_min_v4l(v4l a);
42321 v8d v8d_reduce_min_v4d(v4d a);
42341 v8f v8f_reduce_min_v4f(v4f a);
42361 v8i v8i_reduce_min_v4i(v4i a);
42381 v8l v8l_reduce_min_v4l(v4l a);
42401 v16f v16f_reduce_min_v4f(v4f a);
42421 v16i v16i_reduce_min_v4i(v4i a);
42434 v1d v1d_reduce_min_v8d(v8d a);
42447 v1f v1f_reduce_min_v8f(v8f a);
42460 v1i v1i_reduce_min_v8i(v8i a);
42473 v1l v1l_reduce_min_v8l(v8l a);
42493 v2d v2d_reduce_min_v8d(v8d a);
42513 v2f v2f_reduce_min_v8f(v8f a);
42533 v2i v2i_reduce_min_v8i(v8i a);
42553 v2l v2l_reduce_min_v8l(v8l a);
42573 v4d v4d_reduce_min_v8d(v8d a);
42593 v4f v4f_reduce_min_v8f(v8f a);
42613 v4i v4i_reduce_min_v8i(v8i a);
42633 v4l v4l_reduce_min_v8l(v8l a);
42653 v8d v8d_reduce_min_v8d(v8d a);
42673 v8f v8f_reduce_min_v8f(v8f a);
42693 v8i v8i_reduce_min_v8i(v8i a);
42713 v8l v8l_reduce_min_v8l(v8l a);
42733 v16f v16f_reduce_min_v8f(v8f a);
42753 v16i v16i_reduce_min_v8i(v8i a);
42766 v1f v1f_reduce_min_v16f(v16f a);
42779 v1i v1i_reduce_min_v16i(v16i a);
42799 v2f v2f_reduce_min_v16f(v16f a);
42819 v2i v2i_reduce_min_v16i(v16i a);
42839 v4f v4f_reduce_min_v16f(v16f a);
42859 v4i v4i_reduce_min_v16i(v16i a);
42879 v8f v8f_reduce_min_v16f(v16f a);
42899 v8i v8i_reduce_min_v16i(v16i a);
42919 v16f v16f_reduce_min_v16f(v16f a);
42939 v16i v16i_reduce_min_v16i(v16i a);
42952 v1d sd_reduce_min_v1d(v1d a);
42965 v1f sf_reduce_min_v1f(v1f a);
42978 v1i si_reduce_min_v1i(v1i a);
42991 v1l sl_reduce_min_v1l(v1l a);
43007 v2d sd_reduce_min_v2d(v2d a);
43023 v2f sf_reduce_min_v2f(v2f a);
43039 v2i si_reduce_min_v2i(v2i a);
43055 v2l sl_reduce_min_v2l(v2l a);
43071 v4d sd_reduce_min_v4d(v4d a);
43087 v4f sf_reduce_min_v4f(v4f a);
43103 v4i si_reduce_min_v4i(v4i a);
43119 v4l sl_reduce_min_v4l(v4l a);
43135 v8d sd_reduce_min_v8d(v8d a);
43151 v8f sf_reduce_min_v8f(v8f a);
43167 v8i si_reduce_min_v8i(v8i a);
43183 v8l sl_reduce_min_v8l(v8l a);
43199 v16f sf_reduce_min_v16f(v16f a);
43215 v16i si_reduce_min_v16i(v16i a);
43228 v1d v1d_reduce_max(v1d a);
43241 v1f v1f_reduce_max(v1f a);
43254 v1i v1i_reduce_max(v1i a);
43267 v1l v1l_reduce_max(v1l a);
43287 v2d v2d_reduce_max(v2d a);
43307 v2f v2f_reduce_max(v2f a);
43327 v2i v2i_reduce_max(v2i a);
43347 v2l v2l_reduce_max(v2l a);
43367 v4d v4d_reduce_max(v4d a);
43387 v4f v4f_reduce_max(v4f a);
43407 v4i v4i_reduce_max(v4i a);
43427 v4l v4l_reduce_max(v4l a);
43447 v8d v8d_reduce_max(v8d a);
43467 v8f v8f_reduce_max(v8f a);
43487 v8i v8i_reduce_max(v8i a);
43507 v8l v8l_reduce_max(v8l a);
43527 v16f v16f_reduce_max(v16f a);
43547 v16i v16i_reduce_max(v16i a);
43560 v1d v1d_reduce_max_v1d(v1d a);
43573 v1f v1f_reduce_max_v1f(v1f a);
43586 v1i v1i_reduce_max_v1i(v1i a);
43599 v1l v1l_reduce_max_v1l(v1l a);
43619 v2d v2d_reduce_max_v1d(v1d a);
43639 v2f v2f_reduce_max_v1f(v1f a);
43659 v2i v2i_reduce_max_v1i(v1i a);
43679 v2l v2l_reduce_max_v1l(v1l a);
43699 v4d v4d_reduce_max_v1d(v1d a);
43719 v4f v4f_reduce_max_v1f(v1f a);
43739 v4i v4i_reduce_max_v1i(v1i a);
43759 v4l v4l_reduce_max_v1l(v1l a);
43779 v8d v8d_reduce_max_v1d(v1d a);
43799 v8f v8f_reduce_max_v1f(v1f a);
43819 v8i v8i_reduce_max_v1i(v1i a);
43839 v8l v8l_reduce_max_v1l(v1l a);
43859 v16f v16f_reduce_max_v1f(v1f a);
43879 v16i v16i_reduce_max_v1i(v1i a);
43892 v1d v1d_reduce_max_v2d(v2d a);
43905 v1f v1f_reduce_max_v2f(v2f a);
43918 v1i v1i_reduce_max_v2i(v2i a);
43931 v1l v1l_reduce_max_v2l(v2l a);
43951 v2d v2d_reduce_max_v2d(v2d a);
43971 v2f v2f_reduce_max_v2f(v2f a);
43991 v2i v2i_reduce_max_v2i(v2i a);
44011 v2l v2l_reduce_max_v2l(v2l a);
44031 v4d v4d_reduce_max_v2d(v2d a);
44051 v4f v4f_reduce_max_v2f(v2f a);
44071 v4i v4i_reduce_max_v2i(v2i a);
44091 v4l v4l_reduce_max_v2l(v2l a);
44111 v8d v8d_reduce_max_v2d(v2d a);
44131 v8f v8f_reduce_max_v2f(v2f a);
44151 v8i v8i_reduce_max_v2i(v2i a);
44171 v8l v8l_reduce_max_v2l(v2l a);
44191 v16f v16f_reduce_max_v2f(v2f a);
44211 v16i v16i_reduce_max_v2i(v2i a);
44224 v1d v1d_reduce_max_v4d(v4d a);
44237 v1f v1f_reduce_max_v4f(v4f a);
44250 v1i v1i_reduce_max_v4i(v4i a);
44263 v1l v1l_reduce_max_v4l(v4l a);
44283 v2d v2d_reduce_max_v4d(v4d a);
44303 v2f v2f_reduce_max_v4f(v4f a);
44323 v2i v2i_reduce_max_v4i(v4i a);
44343 v2l v2l_reduce_max_v4l(v4l a);
44363 v4d v4d_reduce_max_v4d(v4d a);
44383 v4f v4f_reduce_max_v4f(v4f a);
44403 v4i v4i_reduce_max_v4i(v4i a);
44423 v4l v4l_reduce_max_v4l(v4l a);
44443 v8d v8d_reduce_max_v4d(v4d a);
44463 v8f v8f_reduce_max_v4f(v4f a);
44483 v8i v8i_reduce_max_v4i(v4i a);
44503 v8l v8l_reduce_max_v4l(v4l a);
44523 v16f v16f_reduce_max_v4f(v4f a);
44543 v16i v16i_reduce_max_v4i(v4i a);
44556 v1d v1d_reduce_max_v8d(v8d a);
44569 v1f v1f_reduce_max_v8f(v8f a);
44582 v1i v1i_reduce_max_v8i(v8i a);
44595 v1l v1l_reduce_max_v8l(v8l a);
44615 v2d v2d_reduce_max_v8d(v8d a);
44635 v2f v2f_reduce_max_v8f(v8f a);
44655 v2i v2i_reduce_max_v8i(v8i a);
44675 v2l v2l_reduce_max_v8l(v8l a);
44695 v4d v4d_reduce_max_v8d(v8d a);
44715 v4f v4f_reduce_max_v8f(v8f a);
44735 v4i v4i_reduce_max_v8i(v8i a);
44755 v4l v4l_reduce_max_v8l(v8l a);
44775 v8d v8d_reduce_max_v8d(v8d a);
44795 v8f v8f_reduce_max_v8f(v8f a);
44815 v8i v8i_reduce_max_v8i(v8i a);
44835 v8l v8l_reduce_max_v8l(v8l a);
44855 v16f v16f_reduce_max_v8f(v8f a);
44875 v16i v16i_reduce_max_v8i(v8i a);
44888 v1f v1f_reduce_max_v16f(v16f a);
44901 v1i v1i_reduce_max_v16i(v16i a);
44921 v2f v2f_reduce_max_v16f(v16f a);
44941 v2i v2i_reduce_max_v16i(v16i a);
44961 v4f v4f_reduce_max_v16f(v16f a);
44981 v4i v4i_reduce_max_v16i(v16i a);
45001 v8f v8f_reduce_max_v16f(v16f a);
45021 v8i v8i_reduce_max_v16i(v16i a);
45041 v16f v16f_reduce_max_v16f(v16f a);
45061 v16i v16i_reduce_max_v16i(v16i a);
45074 v1d sd_reduce_max_v1d(v1d a);
45087 v1f sf_reduce_max_v1f(v1f a);
45100 v1i si_reduce_max_v1i(v1i a);
45113 v1l sl_reduce_max_v1l(v1l a);
45129 v2d sd_reduce_max_v2d(v2d a);
45145 v2f sf_reduce_max_v2f(v2f a);
45161 v2i si_reduce_max_v2i(v2i a);
45177 v2l sl_reduce_max_v2l(v2l a);
45193 v4d sd_reduce_max_v4d(v4d a);
45209 v4f sf_reduce_max_v4f(v4f a);
45225 v4i si_reduce_max_v4i(v4i a);
45241 v4l sl_reduce_max_v4l(v4l a);
45257 v8d sd_reduce_max_v8d(v8d a);
45273 v8f sf_reduce_max_v8f(v8f a);
45289 v8i si_reduce_max_v8i(v8i a);
45305 v8l sl_reduce_max_v8l(v8l a);
45321 v16f sf_reduce_max_v16f(v16f a);
45337 v16i si_reduce_max_v16i(v16i a);
45338 
45339 
45340 /* MOVES */
45353 v1d v1d_move(v1d a);
45362 v1f v1f_move(v1f a);
45371 v1i v1i_move(v1i a);
45380 v1l v1l_move(v1l a);
45389 v2d v2d_move(v2d a);
45398 v2f v2f_move(v2f a);
45407 v2i v2i_move(v2i a);
45416 v2l v2l_move(v2l a);
45425 v4d v4d_move(v4d a);
45434 v4f v4f_move(v4f a);
45443 v4i v4i_move(v4i a);
45452 v4l v4l_move(v4l a);
45461 v8d v8d_move(v8d a);
45470 v8f v8f_move(v8f a);
45479 v8i v8i_move(v8i a);
45488 v8l v8l_move(v8l a);
45497 v16f v16f_move(v16f a);
45506 v16i v16i_move(v16i a);
45507 
45517 v1d v1d_maskz_move(m1d mask, v1d a);
45527 v1f v1f_maskz_move(m1f mask, v1f a);
45537 v1i v1i_maskz_move(m1i mask, v1i a);
45547 v1l v1l_maskz_move(m1l mask, v1l a);
45557 v2d v2d_maskz_move(m2d mask, v2d a);
45567 v2f v2f_maskz_move(m2f mask, v2f a);
45577 v2i v2i_maskz_move(m2i mask, v2i a);
45587 v2l v2l_maskz_move(m2l mask, v2l a);
45597 v4d v4d_maskz_move(m4d mask, v4d a);
45607 v4f v4f_maskz_move(m4f mask, v4f a);
45617 v4i v4i_maskz_move(m4i mask, v4i a);
45627 v4l v4l_maskz_move(m4l mask, v4l a);
45637 v8d v8d_maskz_move(m8d mask, v8d a);
45647 v8f v8f_maskz_move(m8f mask, v8f a);
45657 v8i v8i_maskz_move(m8i mask, v8i a);
45667 v8l v8l_maskz_move(m8l mask, v8l a);
45677 v16f v16f_maskz_move(m16f mask, v16f a);
45687 v16i v16i_maskz_move(m16i mask, v16i a);
45688 
45699 v1d v1d_mask_move(m1d mask, v1d src, v1d a);
45710 v1f v1f_mask_move(m1f mask, v1f src, v1f a);
45721 v1i v1i_mask_move(m1i mask, v1i src, v1i a);
45732 v1l v1l_mask_move(m1l mask, v1l src, v1l a);
45743 v2d v2d_mask_move(m2d mask, v2d src, v2d a);
45754 v2f v2f_mask_move(m2f mask, v2f src, v2f a);
45765 v2i v2i_mask_move(m2i mask, v2i src, v2i a);
45776 v2l v2l_mask_move(m2l mask, v2l src, v2l a);
45787 v4d v4d_mask_move(m4d mask, v4d src, v4d a);
45798 v4f v4f_mask_move(m4f mask, v4f src, v4f a);
45809 v4i v4i_mask_move(m4i mask, v4i src, v4i a);
45820 v4l v4l_mask_move(m4l mask, v4l src, v4l a);
45831 v8d v8d_mask_move(m8d mask, v8d src, v8d a);
45842 v8f v8f_mask_move(m8f mask, v8f src, v8f a);
45853 v8i v8i_mask_move(m8i mask, v8i src, v8i a);
45864 v8l v8l_mask_move(m8l mask, v8l src, v8l a);
45875 v16f v16f_mask_move(m16f mask, v16f src, v16f a);
45886 v16i v16i_mask_move(m16i mask, v16i src, v16i a);
45887 
45888 
45889 /* PRINTS */
45904 void v1d_fprintf(FILE *file, v1d a, const char* format);
45915 void v1f_fprintf(FILE *file, v1f a, const char* format);
45926 void v1i_fprintf(FILE *file, v1i a, const char* format);
45937 void v1l_fprintf(FILE *file, v1l a, const char* format);
45948 void v2d_fprintf(FILE *file, v2d a, const char* format);
45959 void v2f_fprintf(FILE *file, v2f a, const char* format);
45970 void v2i_fprintf(FILE *file, v2i a, const char* format);
45981 void v2l_fprintf(FILE *file, v2l a, const char* format);
45992 void v4d_fprintf(FILE *file, v4d a, const char* format);
46003 void v4f_fprintf(FILE *file, v4f a, const char* format);
46014 void v4i_fprintf(FILE *file, v4i a, const char* format);
46025 void v4l_fprintf(FILE *file, v4l a, const char* format);
46036 void v8d_fprintf(FILE *file, v8d a, const char* format);
46047 void v8f_fprintf(FILE *file, v8f a, const char* format);
46058 void v8i_fprintf(FILE *file, v8i a, const char* format);
46069 void v8l_fprintf(FILE *file, v8l a, const char* format);
46080 void v16f_fprintf(FILE *file, v16f a, const char* format);
46091 void v16i_fprintf(FILE *file, v16i a, const char* format);
46092 
46103 void v1d_printf(v1d a, const char* format);
46114 void v1f_printf(v1f a, const char* format);
46125 void v1i_printf(v1i a, const char* format);
46136 void v1l_printf(v1l a, const char* format);
46147 void v2d_printf(v2d a, const char* format);
46158 void v2f_printf(v2f a, const char* format);
46169 void v2i_printf(v2i a, const char* format);
46180 void v2l_printf(v2l a, const char* format);
46191 void v4d_printf(v4d a, const char* format);
46202 void v4f_printf(v4f a, const char* format);
46213 void v4i_printf(v4i a, const char* format);
46224 void v4l_printf(v4l a, const char* format);
46235 void v8d_printf(v8d a, const char* format);
46246 void v8f_printf(v8f a, const char* format);
46257 void v8i_printf(v8i a, const char* format);
46268 void v8l_printf(v8l a, const char* format);
46279 void v16f_printf(v16f a, const char* format);
46290 void v16i_printf(v16i a, const char* format);
46291 
46301 void v1d_fprint(FILE *file, v1d a);
46311 void v1f_fprint(FILE *file, v1f a);
46321 void v1i_fprint(FILE *file, v1i a);
46331 void v1l_fprint(FILE *file, v1l a);
46341 void v2d_fprint(FILE *file, v2d a);
46351 void v2f_fprint(FILE *file, v2f a);
46361 void v2i_fprint(FILE *file, v2i a);
46371 void v2l_fprint(FILE *file, v2l a);
46381 void v4d_fprint(FILE *file, v4d a);
46391 void v4f_fprint(FILE *file, v4f a);
46401 void v4i_fprint(FILE *file, v4i a);
46411 void v4l_fprint(FILE *file, v4l a);
46421 void v8d_fprint(FILE *file, v8d a);
46431 void v8f_fprint(FILE *file, v8f a);
46441 void v8i_fprint(FILE *file, v8i a);
46451 void v8l_fprint(FILE *file, v8l a);
46461 void v16f_fprint(FILE *file, v16f a);
46471 void v16i_fprint(FILE *file, v16i a);
46472 
46481 void v1d_print(v1d a);
46490 void v1f_print(v1f a);
46499 void v1i_print(v1i a);
46508 void v1l_print(v1l a);
46517 void v2d_print(v2d a);
46526 void v2f_print(v2f a);
46535 void v2i_print(v2i a);
46544 void v2l_print(v2l a);
46553 void v4d_print(v4d a);
46562 void v4f_print(v4f a);
46571 void v4i_print(v4i a);
46580 void v4l_print(v4l a);
46589 void v8d_print(v8d a);
46598 void v8f_print(v8f a);
46607 void v8i_print(v8i a);
46616 void v8l_print(v8l a);
46625 void v16f_print(v16f a);
46634 void v16i_print(v16i a);
46635 
46646 void v1d_rfprintf(FILE *file, v1d a, const char* format);
46657 void v1f_rfprintf(FILE *file, v1f a, const char* format);
46668 void v1i_rfprintf(FILE *file, v1i a, const char* format);
46679 void v1l_rfprintf(FILE *file, v1l a, const char* format);
46690 void v2d_rfprintf(FILE *file, v2d a, const char* format);
46701 void v2f_rfprintf(FILE *file, v2f a, const char* format);
46712 void v2i_rfprintf(FILE *file, v2i a, const char* format);
46723 void v2l_rfprintf(FILE *file, v2l a, const char* format);
46734 void v4d_rfprintf(FILE *file, v4d a, const char* format);
46745 void v4f_rfprintf(FILE *file, v4f a, const char* format);
46756 void v4i_rfprintf(FILE *file, v4i a, const char* format);
46767 void v4l_rfprintf(FILE *file, v4l a, const char* format);
46778 void v8d_rfprintf(FILE *file, v8d a, const char* format);
46789 void v8f_rfprintf(FILE *file, v8f a, const char* format);
46800 void v8i_rfprintf(FILE *file, v8i a, const char* format);
46811 void v8l_rfprintf(FILE *file, v8l a, const char* format);
46822 void v16f_rfprintf(FILE *file, v16f a, const char* format);
46833 void v16i_rfprintf(FILE *file, v16i a, const char* format);
46834 
46845 void v1d_rprintf(v1d a, const char* format);
46856 void v1f_rprintf(v1f a, const char* format);
46867 void v1i_rprintf(v1i a, const char* format);
46878 void v1l_rprintf(v1l a, const char* format);
46889 void v2d_rprintf(v2d a, const char* format);
46900 void v2f_rprintf(v2f a, const char* format);
46911 void v2i_rprintf(v2i a, const char* format);
46922 void v2l_rprintf(v2l a, const char* format);
46933 void v4d_rprintf(v4d a, const char* format);
46944 void v4f_rprintf(v4f a, const char* format);
46955 void v4i_rprintf(v4i a, const char* format);
46966 void v4l_rprintf(v4l a, const char* format);
46977 void v8d_rprintf(v8d a, const char* format);
46988 void v8f_rprintf(v8f a, const char* format);
46999 void v8i_rprintf(v8i a, const char* format);
47010 void v8l_rprintf(v8l a, const char* format);
47021 void v16f_rprintf(v16f a, const char* format);
47032 void v16i_rprintf(v16i a, const char* format);
47033 
47043 void v1d_rfprint(FILE *file, v1d a);
47053 void v1f_rfprint(FILE *file, v1f a);
47063 void v1i_rfprint(FILE *file, v1i a);
47073 void v1l_rfprint(FILE *file, v1l a);
47083 void v2d_rfprint(FILE *file, v2d a);
47093 void v2f_rfprint(FILE *file, v2f a);
47103 void v2i_rfprint(FILE *file, v2i a);
47113 void v2l_rfprint(FILE *file, v2l a);
47123 void v4d_rfprint(FILE *file, v4d a);
47133 void v4f_rfprint(FILE *file, v4f a);
47143 void v4i_rfprint(FILE *file, v4i a);
47153 void v4l_rfprint(FILE *file, v4l a);
47163 void v8d_rfprint(FILE *file, v8d a);
47173 void v8f_rfprint(FILE *file, v8f a);
47183 void v8i_rfprint(FILE *file, v8i a);
47193 void v8l_rfprint(FILE *file, v8l a);
47203 void v16f_rfprint(FILE *file, v16f a);
47213 void v16i_rfprint(FILE *file, v16i a);
47214 
47223 void v1d_rprint(v1d a);
47232 void v1f_rprint(v1f a);
47241 void v1i_rprint(v1i a);
47250 void v1l_rprint(v1l a);
47259 void v2d_rprint(v2d a);
47268 void v2f_rprint(v2f a);
47277 void v2i_rprint(v2i a);
47286 void v2l_rprint(v2l a);
47295 void v4d_rprint(v4d a);
47304 void v4f_rprint(v4f a);
47313 void v4i_rprint(v4i a);
47322 void v4l_rprint(v4l a);
47331 void v8d_rprint(v8d a);
47340 void v8f_rprint(v8f a);
47349 void v8i_rprint(v8i a);
47358 void v8l_rprint(v8l a);
47367 void v16f_rprint(v16f a);
47376 void v16i_rprint(v16i a);
47377 
47378 /* CASTS */
47397 v1d v1d_cast_v1d(v1d a);
47413 v1f v1f_cast_v1d(v1d a);
47429 v1i v1i_cast_v1d(v1d a);
47444 v1l v1l_cast_v1d(v1d a);
47460 v2d v2d_cast_v1d(v1d a);
47475 v2f v2f_cast_v1d(v1d a);
47490 v2i v2i_cast_v1d(v1d a);
47506 v2l v2l_cast_v1d(v1d a);
47522 v4d v4d_cast_v1d(v1d a);
47538 v4f v4f_cast_v1d(v1d a);
47554 v4i v4i_cast_v1d(v1d a);
47570 v4l v4l_cast_v1d(v1d a);
47586 v8d v8d_cast_v1d(v1d a);
47602 v8f v8f_cast_v1d(v1d a);
47618 v8i v8i_cast_v1d(v1d a);
47634 v8l v8l_cast_v1d(v1d a);
47650 v16f v16f_cast_v1d(v1d a);
47666 v16i v16i_cast_v1d(v1d a);
47682 v1d v1d_cast_v1f(v1f a);
47697 v1f v1f_cast_v1f(v1f a);
47712 v1i v1i_cast_v1f(v1f a);
47728 v1l v1l_cast_v1f(v1f a);
47744 v2d v2d_cast_v1f(v1f a);
47760 v2f v2f_cast_v1f(v1f a);
47776 v2i v2i_cast_v1f(v1f a);
47792 v2l v2l_cast_v1f(v1f a);
47808 v4d v4d_cast_v1f(v1f a);
47824 v4f v4f_cast_v1f(v1f a);
47840 v4i v4i_cast_v1f(v1f a);
47856 v4l v4l_cast_v1f(v1f a);
47872 v8d v8d_cast_v1f(v1f a);
47888 v8f v8f_cast_v1f(v1f a);
47904 v8i v8i_cast_v1f(v1f a);
47920 v8l v8l_cast_v1f(v1f a);
47936 v16f v16f_cast_v1f(v1f a);
47952 v16i v16i_cast_v1f(v1f a);
47968 v1d v1d_cast_v1i(v1i a);
47983 v1f v1f_cast_v1i(v1i a);
47998 v1i v1i_cast_v1i(v1i a);
48014 v1l v1l_cast_v1i(v1i a);
48030 v2d v2d_cast_v1i(v1i a);
48046 v2f v2f_cast_v1i(v1i a);
48062 v2i v2i_cast_v1i(v1i a);
48078 v2l v2l_cast_v1i(v1i a);
48094 v4d v4d_cast_v1i(v1i a);
48110 v4f v4f_cast_v1i(v1i a);
48126 v4i v4i_cast_v1i(v1i a);
48142 v4l v4l_cast_v1i(v1i a);
48158 v8d v8d_cast_v1i(v1i a);
48174 v8f v8f_cast_v1i(v1i a);
48190 v8i v8i_cast_v1i(v1i a);
48206 v8l v8l_cast_v1i(v1i a);
48222 v16f v16f_cast_v1i(v1i a);
48238 v16i v16i_cast_v1i(v1i a);
48253 v1d v1d_cast_v1l(v1l a);
48269 v1f v1f_cast_v1l(v1l a);
48285 v1i v1i_cast_v1l(v1l a);
48300 v1l v1l_cast_v1l(v1l a);
48316 v2d v2d_cast_v1l(v1l a);
48331 v2f v2f_cast_v1l(v1l a);
48346 v2i v2i_cast_v1l(v1l a);
48362 v2l v2l_cast_v1l(v1l a);
48378 v4d v4d_cast_v1l(v1l a);
48394 v4f v4f_cast_v1l(v1l a);
48410 v4i v4i_cast_v1l(v1l a);
48426 v4l v4l_cast_v1l(v1l a);
48442 v8d v8d_cast_v1l(v1l a);
48458 v8f v8f_cast_v1l(v1l a);
48474 v8i v8i_cast_v1l(v1l a);
48490 v8l v8l_cast_v1l(v1l a);
48506 v16f v16f_cast_v1l(v1l a);
48522 v16i v16i_cast_v1l(v1l a);
48538 v1d v1d_cast_v2d(v2d a);
48554 v1f v1f_cast_v2d(v2d a);
48570 v1i v1i_cast_v2d(v2d a);
48586 v1l v1l_cast_v2d(v2d a);
48601 v2d v2d_cast_v2d(v2d a);
48617 v2f v2f_cast_v2d(v2d a);
48633 v2i v2i_cast_v2d(v2d a);
48648 v2l v2l_cast_v2d(v2d a);
48664 v4d v4d_cast_v2d(v2d a);
48679 v4f v4f_cast_v2d(v2d a);
48694 v4i v4i_cast_v2d(v2d a);
48710 v4l v4l_cast_v2d(v2d a);
48726 v8d v8d_cast_v2d(v2d a);
48742 v8f v8f_cast_v2d(v2d a);
48758 v8i v8i_cast_v2d(v2d a);
48774 v8l v8l_cast_v2d(v2d a);
48790 v16f v16f_cast_v2d(v2d a);
48806 v16i v16i_cast_v2d(v2d a);
48821 v1d v1d_cast_v2f(v2f a);
48837 v1f v1f_cast_v2f(v2f a);
48853 v1i v1i_cast_v2f(v2f a);
48868 v1l v1l_cast_v2f(v2f a);
48884 v2d v2d_cast_v2f(v2f a);
48899 v2f v2f_cast_v2f(v2f a);
48914 v2i v2i_cast_v2f(v2f a);
48930 v2l v2l_cast_v2f(v2f a);
48946 v4d v4d_cast_v2f(v2f a);
48962 v4f v4f_cast_v2f(v2f a);
48978 v4i v4i_cast_v2f(v2f a);
48994 v4l v4l_cast_v2f(v2f a);
49010 v8d v8d_cast_v2f(v2f a);
49026 v8f v8f_cast_v2f(v2f a);
49042 v8i v8i_cast_v2f(v2f a);
49058 v8l v8l_cast_v2f(v2f a);
49074 v16f v16f_cast_v2f(v2f a);
49090 v16i v16i_cast_v2f(v2f a);
49105 v1d v1d_cast_v2i(v2i a);
49121 v1f v1f_cast_v2i(v2i a);
49137 v1i v1i_cast_v2i(v2i a);
49152 v1l v1l_cast_v2i(v2i a);
49168 v2d v2d_cast_v2i(v2i a);
49183 v2f v2f_cast_v2i(v2i a);
49198 v2i v2i_cast_v2i(v2i a);
49214 v2l v2l_cast_v2i(v2i a);
49230 v4d v4d_cast_v2i(v2i a);
49246 v4f v4f_cast_v2i(v2i a);
49262 v4i v4i_cast_v2i(v2i a);
49278 v4l v4l_cast_v2i(v2i a);
49294 v8d v8d_cast_v2i(v2i a);
49310 v8f v8f_cast_v2i(v2i a);
49326 v8i v8i_cast_v2i(v2i a);
49342 v8l v8l_cast_v2i(v2i a);
49358 v16f v16f_cast_v2i(v2i a);
49374 v16i v16i_cast_v2i(v2i a);
49390 v1d v1d_cast_v2l(v2l a);
49406 v1f v1f_cast_v2l(v2l a);
49422 v1i v1i_cast_v2l(v2l a);
49438 v1l v1l_cast_v2l(v2l a);
49453 v2d v2d_cast_v2l(v2l a);
49469 v2f v2f_cast_v2l(v2l a);
49485 v2i v2i_cast_v2l(v2l a);
49500 v2l v2l_cast_v2l(v2l a);
49516 v4d v4d_cast_v2l(v2l a);
49531 v4f v4f_cast_v2l(v2l a);
49546 v4i v4i_cast_v2l(v2l a);
49562 v4l v4l_cast_v2l(v2l a);
49578 v8d v8d_cast_v2l(v2l a);
49594 v8f v8f_cast_v2l(v2l a);
49610 v8i v8i_cast_v2l(v2l a);
49626 v8l v8l_cast_v2l(v2l a);
49642 v16f v16f_cast_v2l(v2l a);
49658 v16i v16i_cast_v2l(v2l a);
49674 v1d v1d_cast_v4d(v4d a);
49690 v1f v1f_cast_v4d(v4d a);
49706 v1i v1i_cast_v4d(v4d a);
49722 v1l v1l_cast_v4d(v4d a);
49738 v2d v2d_cast_v4d(v4d a);
49754 v2f v2f_cast_v4d(v4d a);
49770 v2i v2i_cast_v4d(v4d a);
49786 v2l v2l_cast_v4d(v4d a);
49801 v4d v4d_cast_v4d(v4d a);
49817 v4f v4f_cast_v4d(v4d a);
49833 v4i v4i_cast_v4d(v4d a);
49848 v4l v4l_cast_v4d(v4d a);
49864 v8d v8d_cast_v4d(v4d a);
49879 v8f v8f_cast_v4d(v4d a);
49894 v8i v8i_cast_v4d(v4d a);
49910 v8l v8l_cast_v4d(v4d a);
49926 v16f v16f_cast_v4d(v4d a);
49942 v16i v16i_cast_v4d(v4d a);
49958 v1d v1d_cast_v4f(v4f a);
49974 v1f v1f_cast_v4f(v4f a);
49990 v1i v1i_cast_v4f(v4f a);
50006 v1l v1l_cast_v4f(v4f a);
50021 v2d v2d_cast_v4f(v4f a);
50037 v2f v2f_cast_v4f(v4f a);
50053 v2i v2i_cast_v4f(v4f a);
50068 v2l v2l_cast_v4f(v4f a);
50084 v4d v4d_cast_v4f(v4f a);
50099 v4f v4f_cast_v4f(v4f a);
50114 v4i v4i_cast_v4f(v4f a);
50130 v4l v4l_cast_v4f(v4f a);
50146 v8d v8d_cast_v4f(v4f a);
50162 v8f v8f_cast_v4f(v4f a);
50178 v8i v8i_cast_v4f(v4f a);
50194 v8l v8l_cast_v4f(v4f a);
50210 v16f v16f_cast_v4f(v4f a);
50226 v16i v16i_cast_v4f(v4f a);
50242 v1d v1d_cast_v4i(v4i a);
50258 v1f v1f_cast_v4i(v4i a);
50274 v1i v1i_cast_v4i(v4i a);
50290 v1l v1l_cast_v4i(v4i a);
50305 v2d v2d_cast_v4i(v4i a);
50321 v2f v2f_cast_v4i(v4i a);
50337 v2i v2i_cast_v4i(v4i a);
50352 v2l v2l_cast_v4i(v4i a);
50368 v4d v4d_cast_v4i(v4i a);
50383 v4f v4f_cast_v4i(v4i a);
50398 v4i v4i_cast_v4i(v4i a);
50414 v4l v4l_cast_v4i(v4i a);
50430 v8d v8d_cast_v4i(v4i a);
50446 v8f v8f_cast_v4i(v4i a);
50462 v8i v8i_cast_v4i(v4i a);
50478 v8l v8l_cast_v4i(v4i a);
50494 v16f v16f_cast_v4i(v4i a);
50510 v16i v16i_cast_v4i(v4i a);
50526 v1d v1d_cast_v4l(v4l a);
50542 v1f v1f_cast_v4l(v4l a);
50558 v1i v1i_cast_v4l(v4l a);
50574 v1l v1l_cast_v4l(v4l a);
50590 v2d v2d_cast_v4l(v4l a);
50606 v2f v2f_cast_v4l(v4l a);
50622 v2i v2i_cast_v4l(v4l a);
50638 v2l v2l_cast_v4l(v4l a);
50653 v4d v4d_cast_v4l(v4l a);
50669 v4f v4f_cast_v4l(v4l a);
50685 v4i v4i_cast_v4l(v4l a);
50700 v4l v4l_cast_v4l(v4l a);
50716 v8d v8d_cast_v4l(v4l a);
50731 v8f v8f_cast_v4l(v4l a);
50746 v8i v8i_cast_v4l(v4l a);
50762 v8l v8l_cast_v4l(v4l a);
50778 v16f v16f_cast_v4l(v4l a);
50794 v16i v16i_cast_v4l(v4l a);
50810 v1d v1d_cast_v8d(v8d a);
50826 v1f v1f_cast_v8d(v8d a);
50842 v1i v1i_cast_v8d(v8d a);
50858 v1l v1l_cast_v8d(v8d a);
50874 v2d v2d_cast_v8d(v8d a);
50890 v2f v2f_cast_v8d(v8d a);
50906 v2i v2i_cast_v8d(v8d a);
50922 v2l v2l_cast_v8d(v8d a);
50938 v4d v4d_cast_v8d(v8d a);
50954 v4f v4f_cast_v8d(v8d a);
50970 v4i v4i_cast_v8d(v8d a);
50986 v4l v4l_cast_v8d(v8d a);
51001 v8d v8d_cast_v8d(v8d a);
51017 v8f v8f_cast_v8d(v8d a);
51033 v8i v8i_cast_v8d(v8d a);
51048 v8l v8l_cast_v8d(v8d a);
51063 v16f v16f_cast_v8d(v8d a);
51078 v16i v16i_cast_v8d(v8d a);
51094 v1d v1d_cast_v8f(v8f a);
51110 v1f v1f_cast_v8f(v8f a);
51126 v1i v1i_cast_v8f(v8f a);
51142 v1l v1l_cast_v8f(v8f a);
51158 v2d v2d_cast_v8f(v8f a);
51174 v2f v2f_cast_v8f(v8f a);
51190 v2i v2i_cast_v8f(v8f a);
51206 v2l v2l_cast_v8f(v8f a);
51221 v4d v4d_cast_v8f(v8f a);
51237 v4f v4f_cast_v8f(v8f a);
51253 v4i v4i_cast_v8f(v8f a);
51268 v4l v4l_cast_v8f(v8f a);
51284 v8d v8d_cast_v8f(v8f a);
51299 v8f v8f_cast_v8f(v8f a);
51314 v8i v8i_cast_v8f(v8f a);
51330 v8l v8l_cast_v8f(v8f a);
51346 v16f v16f_cast_v8f(v8f a);
51362 v16i v16i_cast_v8f(v8f a);
51378 v1d v1d_cast_v8i(v8i a);
51394 v1f v1f_cast_v8i(v8i a);
51410 v1i v1i_cast_v8i(v8i a);
51426 v1l v1l_cast_v8i(v8i a);
51442 v2d v2d_cast_v8i(v8i a);
51458 v2f v2f_cast_v8i(v8i a);
51474 v2i v2i_cast_v8i(v8i a);
51490 v2l v2l_cast_v8i(v8i a);
51505 v4d v4d_cast_v8i(v8i a);
51521 v4f v4f_cast_v8i(v8i a);
51537 v4i v4i_cast_v8i(v8i a);
51552 v4l v4l_cast_v8i(v8i a);
51568 v8d v8d_cast_v8i(v8i a);
51583 v8f v8f_cast_v8i(v8i a);
51598 v8i v8i_cast_v8i(v8i a);
51614 v8l v8l_cast_v8i(v8i a);
51630 v16f v16f_cast_v8i(v8i a);
51646 v16i v16i_cast_v8i(v8i a);
51662 v1d v1d_cast_v8l(v8l a);
51678 v1f v1f_cast_v8l(v8l a);
51694 v1i v1i_cast_v8l(v8l a);
51710 v1l v1l_cast_v8l(v8l a);
51726 v2d v2d_cast_v8l(v8l a);
51742 v2f v2f_cast_v8l(v8l a);
51758 v2i v2i_cast_v8l(v8l a);
51774 v2l v2l_cast_v8l(v8l a);
51790 v4d v4d_cast_v8l(v8l a);
51806 v4f v4f_cast_v8l(v8l a);
51822 v4i v4i_cast_v8l(v8l a);
51838 v4l v4l_cast_v8l(v8l a);
51853 v8d v8d_cast_v8l(v8l a);
51869 v8f v8f_cast_v8l(v8l a);
51885 v8i v8i_cast_v8l(v8l a);
51900 v8l v8l_cast_v8l(v8l a);
51915 v16f v16f_cast_v8l(v8l a);
51930 v16i v16i_cast_v8l(v8l a);
51946 v1d v1d_cast_v16f(v16f a);
51962 v1f v1f_cast_v16f(v16f a);
51978 v1i v1i_cast_v16f(v16f a);
51994 v1l v1l_cast_v16f(v16f a);
52010 v2d v2d_cast_v16f(v16f a);
52026 v2f v2f_cast_v16f(v16f a);
52042 v2i v2i_cast_v16f(v16f a);
52058 v2l v2l_cast_v16f(v16f a);
52074 v4d v4d_cast_v16f(v16f a);
52090 v4f v4f_cast_v16f(v16f a);
52106 v4i v4i_cast_v16f(v16f a);
52122 v4l v4l_cast_v16f(v16f a);
52137 v8d v8d_cast_v16f(v16f a);
52153 v8f v8f_cast_v16f(v16f a);
52169 v8i v8i_cast_v16f(v16f a);
52184 v8l v8l_cast_v16f(v16f a);
52199 v16f v16f_cast_v16f(v16f a);
52214 v16i v16i_cast_v16f(v16f a);
52230 v1d v1d_cast_v16i(v16i a);
52246 v1f v1f_cast_v16i(v16i a);
52262 v1i v1i_cast_v16i(v16i a);
52278 v1l v1l_cast_v16i(v16i a);
52294 v2d v2d_cast_v16i(v16i a);
52310 v2f v2f_cast_v16i(v16i a);
52326 v2i v2i_cast_v16i(v16i a);
52342 v2l v2l_cast_v16i(v16i a);
52358 v4d v4d_cast_v16i(v16i a);
52374 v4f v4f_cast_v16i(v16i a);
52390 v4i v4i_cast_v16i(v16i a);
52406 v4l v4l_cast_v16i(v16i a);
52421 v8d v8d_cast_v16i(v16i a);
52437 v8f v8f_cast_v16i(v16i a);
52453 v8i v8i_cast_v16i(v16i a);
52468 v8l v8l_cast_v16i(v16i a);
52483 v16f v16f_cast_v16i(v16i a);
52498 v16i v16i_cast_v16i(v16i a);
52499 
52530 m1d m1d_cast_v1d(v1d a);
52556 m1f m1f_cast_v1f(v1f a);
52582 m1i m1i_cast_v1i(v1i a);
52608 m1l m1l_cast_v1l(v1l a);
52634 m2d m2d_cast_v2d(v2d a);
52660 m2f m2f_cast_v2f(v2f a);
52686 m2i m2i_cast_v2i(v2i a);
52712 m2l m2l_cast_v2l(v2l a);
52738 m4d m4d_cast_v4d(v4d a);
52764 m4f m4f_cast_v4f(v4f a);
52790 m4i m4i_cast_v4i(v4i a);
52816 m4l m4l_cast_v4l(v4l a);
52842 m8d m8d_cast_v8d(v8d a);
52868 m8f m8f_cast_v8f(v8f a);
52894 m8i m8i_cast_v8i(v8i a);
52920 m8l m8l_cast_v8l(v8l a);
52946 m16f m16f_cast_v16f(v16f a);
52972 m16i m16i_cast_v16i(v16i a);
52996 v1d v1d_cast_m1d(m1d a);
53020 v1f v1f_cast_m1f(m1f a);
53044 v1i v1i_cast_m1i(m1i a);
53068 v1l v1l_cast_m1l(m1l a);
53092 v2d v2d_cast_m2d(m2d a);
53116 v2f v2f_cast_m2f(m2f a);
53140 v2i v2i_cast_m2i(m2i a);
53164 v2l v2l_cast_m2l(m2l a);
53188 v4d v4d_cast_m4d(m4d a);
53212 v4f v4f_cast_m4f(m4f a);
53236 v4i v4i_cast_m4i(m4i a);
53260 v4l v4l_cast_m4l(m4l a);
53284 v8d v8d_cast_m8d(m8d a);
53308 v8f v8f_cast_m8f(m8f a);
53332 v8i v8i_cast_m8i(m8i a);
53356 v8l v8l_cast_m8l(m8l a);
53380 v16f v16f_cast_m16f(m16f a);
53404 v16i v16i_cast_m16i(m16i a);
53405 
53406 
53407 /* CONVERTS */
53425 v1d v1d_cvt_v1d(v1d a);
53439 v1f v1f_cvt_v1d(v1d a);
53453 v1i v1i_cvt_v1d(v1d a);
53467 v1l v1l_cvt_v1d(v1d a);
53482 v2d v2d_cvt_v1d(v1d a);
53497 v2f v2f_cvt_v1d(v1d a);
53512 v2i v2i_cvt_v1d(v1d a);
53527 v2l v2l_cvt_v1d(v1d a);
53542 v4d v4d_cvt_v1d(v1d a);
53557 v4f v4f_cvt_v1d(v1d a);
53572 v4i v4i_cvt_v1d(v1d a);
53587 v4l v4l_cvt_v1d(v1d a);
53602 v8d v8d_cvt_v1d(v1d a);
53617 v8f v8f_cvt_v1d(v1d a);
53632 v8i v8i_cvt_v1d(v1d a);
53647 v8l v8l_cvt_v1d(v1d a);
53662 v16f v16f_cvt_v1d(v1d a);
53677 v16i v16i_cvt_v1d(v1d a);
53691 v1d v1d_cvt_v1f(v1f a);
53705 v1f v1f_cvt_v1f(v1f a);
53719 v1i v1i_cvt_v1f(v1f a);
53733 v1l v1l_cvt_v1f(v1f a);
53748 v2d v2d_cvt_v1f(v1f a);
53763 v2f v2f_cvt_v1f(v1f a);
53778 v2i v2i_cvt_v1f(v1f a);
53793 v2l v2l_cvt_v1f(v1f a);
53808 v4d v4d_cvt_v1f(v1f a);
53823 v4f v4f_cvt_v1f(v1f a);
53838 v4i v4i_cvt_v1f(v1f a);
53853 v4l v4l_cvt_v1f(v1f a);
53868 v8d v8d_cvt_v1f(v1f a);
53883 v8f v8f_cvt_v1f(v1f a);
53898 v8i v8i_cvt_v1f(v1f a);
53913 v8l v8l_cvt_v1f(v1f a);
53928 v16f v16f_cvt_v1f(v1f a);
53943 v16i v16i_cvt_v1f(v1f a);
53957 v1d v1d_cvt_v1i(v1i a);
53971 v1f v1f_cvt_v1i(v1i a);
53985 v1i v1i_cvt_v1i(v1i a);
53999 v1l v1l_cvt_v1i(v1i a);
54014 v2d v2d_cvt_v1i(v1i a);
54029 v2f v2f_cvt_v1i(v1i a);
54044 v2i v2i_cvt_v1i(v1i a);
54059 v2l v2l_cvt_v1i(v1i a);
54074 v4d v4d_cvt_v1i(v1i a);
54089 v4f v4f_cvt_v1i(v1i a);
54104 v4i v4i_cvt_v1i(v1i a);
54119 v4l v4l_cvt_v1i(v1i a);
54134 v8d v8d_cvt_v1i(v1i a);
54149 v8f v8f_cvt_v1i(v1i a);
54164 v8i v8i_cvt_v1i(v1i a);
54179 v8l v8l_cvt_v1i(v1i a);
54194 v16f v16f_cvt_v1i(v1i a);
54209 v16i v16i_cvt_v1i(v1i a);
54223 v1d v1d_cvt_v1l(v1l a);
54237 v1f v1f_cvt_v1l(v1l a);
54251 v1i v1i_cvt_v1l(v1l a);
54265 v1l v1l_cvt_v1l(v1l a);
54280 v2d v2d_cvt_v1l(v1l a);
54295 v2f v2f_cvt_v1l(v1l a);
54310 v2i v2i_cvt_v1l(v1l a);
54325 v2l v2l_cvt_v1l(v1l a);
54340 v4d v4d_cvt_v1l(v1l a);
54355 v4f v4f_cvt_v1l(v1l a);
54370 v4i v4i_cvt_v1l(v1l a);
54385 v4l v4l_cvt_v1l(v1l a);
54400 v8d v8d_cvt_v1l(v1l a);
54415 v8f v8f_cvt_v1l(v1l a);
54430 v8i v8i_cvt_v1l(v1l a);
54445 v8l v8l_cvt_v1l(v1l a);
54460 v16f v16f_cvt_v1l(v1l a);
54475 v16i v16i_cvt_v1l(v1l a);
54490 v1d v1d_cvt_v2d(v2d a);
54505 v1f v1f_cvt_v2d(v2d a);
54520 v1i v1i_cvt_v2d(v2d a);
54535 v1l v1l_cvt_v2d(v2d a);
54549 v2d v2d_cvt_v2d(v2d a);
54563 v2f v2f_cvt_v2d(v2d a);
54577 v2i v2i_cvt_v2d(v2d a);
54591 v2l v2l_cvt_v2d(v2d a);
54606 v4d v4d_cvt_v2d(v2d a);
54621 v4f v4f_cvt_v2d(v2d a);
54636 v4i v4i_cvt_v2d(v2d a);
54651 v4l v4l_cvt_v2d(v2d a);
54666 v8d v8d_cvt_v2d(v2d a);
54681 v8f v8f_cvt_v2d(v2d a);
54696 v8i v8i_cvt_v2d(v2d a);
54711 v8l v8l_cvt_v2d(v2d a);
54726 v16f v16f_cvt_v2d(v2d a);
54741 v16i v16i_cvt_v2d(v2d a);
54756 v1d v1d_cvt_v2f(v2f a);
54771 v1f v1f_cvt_v2f(v2f a);
54786 v1i v1i_cvt_v2f(v2f a);
54801 v1l v1l_cvt_v2f(v2f a);
54815 v2d v2d_cvt_v2f(v2f a);
54829 v2f v2f_cvt_v2f(v2f a);
54843 v2i v2i_cvt_v2f(v2f a);
54857 v2l v2l_cvt_v2f(v2f a);
54872 v4d v4d_cvt_v2f(v2f a);
54887 v4f v4f_cvt_v2f(v2f a);
54902 v4i v4i_cvt_v2f(v2f a);
54917 v4l v4l_cvt_v2f(v2f a);
54932 v8d v8d_cvt_v2f(v2f a);
54947 v8f v8f_cvt_v2f(v2f a);
54962 v8i v8i_cvt_v2f(v2f a);
54977 v8l v8l_cvt_v2f(v2f a);
54992 v16f v16f_cvt_v2f(v2f a);
55007 v16i v16i_cvt_v2f(v2f a);
55022 v1d v1d_cvt_v2i(v2i a);
55037 v1f v1f_cvt_v2i(v2i a);
55052 v1i v1i_cvt_v2i(v2i a);
55067 v1l v1l_cvt_v2i(v2i a);
55081 v2d v2d_cvt_v2i(v2i a);
55095 v2f v2f_cvt_v2i(v2i a);
55109 v2i v2i_cvt_v2i(v2i a);
55123 v2l v2l_cvt_v2i(v2i a);
55138 v4d v4d_cvt_v2i(v2i a);
55153 v4f v4f_cvt_v2i(v2i a);
55168 v4i v4i_cvt_v2i(v2i a);
55183 v4l v4l_cvt_v2i(v2i a);
55198 v8d v8d_cvt_v2i(v2i a);
55213 v8f v8f_cvt_v2i(v2i a);
55228 v8i v8i_cvt_v2i(v2i a);
55243 v8l v8l_cvt_v2i(v2i a);
55258 v16f v16f_cvt_v2i(v2i a);
55273 v16i v16i_cvt_v2i(v2i a);
55288 v1d v1d_cvt_v2l(v2l a);
55303 v1f v1f_cvt_v2l(v2l a);
55318 v1i v1i_cvt_v2l(v2l a);
55333 v1l v1l_cvt_v2l(v2l a);
55347 v2d v2d_cvt_v2l(v2l a);
55361 v2f v2f_cvt_v2l(v2l a);
55375 v2i v2i_cvt_v2l(v2l a);
55389 v2l v2l_cvt_v2l(v2l a);
55404 v4d v4d_cvt_v2l(v2l a);
55419 v4f v4f_cvt_v2l(v2l a);
55434 v4i v4i_cvt_v2l(v2l a);
55449 v4l v4l_cvt_v2l(v2l a);
55464 v8d v8d_cvt_v2l(v2l a);
55479 v8f v8f_cvt_v2l(v2l a);
55494 v8i v8i_cvt_v2l(v2l a);
55509 v8l v8l_cvt_v2l(v2l a);
55524 v16f v16f_cvt_v2l(v2l a);
55539 v16i v16i_cvt_v2l(v2l a);
55554 v1d v1d_cvt_v4d(v4d a);
55569 v1f v1f_cvt_v4d(v4d a);
55584 v1i v1i_cvt_v4d(v4d a);
55599 v1l v1l_cvt_v4d(v4d a);
55614 v2d v2d_cvt_v4d(v4d a);
55629 v2f v2f_cvt_v4d(v4d a);
55644 v2i v2i_cvt_v4d(v4d a);
55659 v2l v2l_cvt_v4d(v4d a);
55673 v4d v4d_cvt_v4d(v4d a);
55687 v4f v4f_cvt_v4d(v4d a);
55701 v4i v4i_cvt_v4d(v4d a);
55715 v4l v4l_cvt_v4d(v4d a);
55730 v8d v8d_cvt_v4d(v4d a);
55745 v8f v8f_cvt_v4d(v4d a);
55760 v8i v8i_cvt_v4d(v4d a);
55775 v8l v8l_cvt_v4d(v4d a);
55790 v16f v16f_cvt_v4d(v4d a);
55805 v16i v16i_cvt_v4d(v4d a);
55820 v1d v1d_cvt_v4f(v4f a);
55835 v1f v1f_cvt_v4f(v4f a);
55850 v1i v1i_cvt_v4f(v4f a);
55865 v1l v1l_cvt_v4f(v4f a);
55880 v2d v2d_cvt_v4f(v4f a);
55895 v2f v2f_cvt_v4f(v4f a);
55910 v2i v2i_cvt_v4f(v4f a);
55925 v2l v2l_cvt_v4f(v4f a);
55939 v4d v4d_cvt_v4f(v4f a);
55953 v4f v4f_cvt_v4f(v4f a);
55967 v4i v4i_cvt_v4f(v4f a);
55981 v4l v4l_cvt_v4f(v4f a);
55996 v8d v8d_cvt_v4f(v4f a);
56011 v8f v8f_cvt_v4f(v4f a);
56026 v8i v8i_cvt_v4f(v4f a);
56041 v8l v8l_cvt_v4f(v4f a);
56056 v16f v16f_cvt_v4f(v4f a);
56071 v16i v16i_cvt_v4f(v4f a);
56086 v1d v1d_cvt_v4i(v4i a);
56101 v1f v1f_cvt_v4i(v4i a);
56116 v1i v1i_cvt_v4i(v4i a);
56131 v1l v1l_cvt_v4i(v4i a);
56146 v2d v2d_cvt_v4i(v4i a);
56161 v2f v2f_cvt_v4i(v4i a);
56176 v2i v2i_cvt_v4i(v4i a);
56191 v2l v2l_cvt_v4i(v4i a);
56205 v4d v4d_cvt_v4i(v4i a);
56219 v4f v4f_cvt_v4i(v4i a);
56233 v4i v4i_cvt_v4i(v4i a);
56247 v4l v4l_cvt_v4i(v4i a);
56262 v8d v8d_cvt_v4i(v4i a);
56277 v8f v8f_cvt_v4i(v4i a);
56292 v8i v8i_cvt_v4i(v4i a);
56307 v8l v8l_cvt_v4i(v4i a);
56322 v16f v16f_cvt_v4i(v4i a);
56337 v16i v16i_cvt_v4i(v4i a);
56352 v1d v1d_cvt_v4l(v4l a);
56367 v1f v1f_cvt_v4l(v4l a);
56382 v1i v1i_cvt_v4l(v4l a);
56397 v1l v1l_cvt_v4l(v4l a);
56412 v2d v2d_cvt_v4l(v4l a);
56427 v2f v2f_cvt_v4l(v4l a);
56442 v2i v2i_cvt_v4l(v4l a);
56457 v2l v2l_cvt_v4l(v4l a);
56471 v4d v4d_cvt_v4l(v4l a);
56485 v4f v4f_cvt_v4l(v4l a);
56499 v4i v4i_cvt_v4l(v4l a);
56513 v4l v4l_cvt_v4l(v4l a);
56528 v8d v8d_cvt_v4l(v4l a);
56543 v8f v8f_cvt_v4l(v4l a);
56558 v8i v8i_cvt_v4l(v4l a);
56573 v8l v8l_cvt_v4l(v4l a);
56588 v16f v16f_cvt_v4l(v4l a);
56603 v16i v16i_cvt_v4l(v4l a);
56618 v1d v1d_cvt_v8d(v8d a);
56633 v1f v1f_cvt_v8d(v8d a);
56648 v1i v1i_cvt_v8d(v8d a);
56663 v1l v1l_cvt_v8d(v8d a);
56678 v2d v2d_cvt_v8d(v8d a);
56693 v2f v2f_cvt_v8d(v8d a);
56708 v2i v2i_cvt_v8d(v8d a);
56723 v2l v2l_cvt_v8d(v8d a);
56738 v4d v4d_cvt_v8d(v8d a);
56753 v4f v4f_cvt_v8d(v8d a);
56768 v4i v4i_cvt_v8d(v8d a);
56783 v4l v4l_cvt_v8d(v8d a);
56797 v8d v8d_cvt_v8d(v8d a);
56811 v8f v8f_cvt_v8d(v8d a);
56825 v8i v8i_cvt_v8d(v8d a);
56839 v8l v8l_cvt_v8d(v8d a);
56854 v16f v16f_cvt_v8d(v8d a);
56869 v16i v16i_cvt_v8d(v8d a);
56884 v1d v1d_cvt_v8f(v8f a);
56899 v1f v1f_cvt_v8f(v8f a);
56914 v1i v1i_cvt_v8f(v8f a);
56929 v1l v1l_cvt_v8f(v8f a);
56944 v2d v2d_cvt_v8f(v8f a);
56959 v2f v2f_cvt_v8f(v8f a);
56974 v2i v2i_cvt_v8f(v8f a);
56989 v2l v2l_cvt_v8f(v8f a);
57004 v4d v4d_cvt_v8f(v8f a);
57019 v4f v4f_cvt_v8f(v8f a);
57034 v4i v4i_cvt_v8f(v8f a);
57049 v4l v4l_cvt_v8f(v8f a);
57063 v8d v8d_cvt_v8f(v8f a);
57077 v8f v8f_cvt_v8f(v8f a);
57091 v8i v8i_cvt_v8f(v8f a);
57105 v8l v8l_cvt_v8f(v8f a);
57120 v16f v16f_cvt_v8f(v8f a);
57135 v16i v16i_cvt_v8f(v8f a);
57150 v1d v1d_cvt_v8i(v8i a);
57165 v1f v1f_cvt_v8i(v8i a);
57180 v1i v1i_cvt_v8i(v8i a);
57195 v1l v1l_cvt_v8i(v8i a);
57210 v2d v2d_cvt_v8i(v8i a);
57225 v2f v2f_cvt_v8i(v8i a);
57240 v2i v2i_cvt_v8i(v8i a);
57255 v2l v2l_cvt_v8i(v8i a);
57270 v4d v4d_cvt_v8i(v8i a);
57285 v4f v4f_cvt_v8i(v8i a);
57300 v4i v4i_cvt_v8i(v8i a);
57315 v4l v4l_cvt_v8i(v8i a);
57329 v8d v8d_cvt_v8i(v8i a);
57343 v8f v8f_cvt_v8i(v8i a);
57357 v8i v8i_cvt_v8i(v8i a);
57371 v8l v8l_cvt_v8i(v8i a);
57386 v16f v16f_cvt_v8i(v8i a);
57401 v16i v16i_cvt_v8i(v8i a);
57416 v1d v1d_cvt_v8l(v8l a);
57431 v1f v1f_cvt_v8l(v8l a);
57446 v1i v1i_cvt_v8l(v8l a);
57461 v1l v1l_cvt_v8l(v8l a);
57476 v2d v2d_cvt_v8l(v8l a);
57491 v2f v2f_cvt_v8l(v8l a);
57506 v2i v2i_cvt_v8l(v8l a);
57521 v2l v2l_cvt_v8l(v8l a);
57536 v4d v4d_cvt_v8l(v8l a);
57551 v4f v4f_cvt_v8l(v8l a);
57566 v4i v4i_cvt_v8l(v8l a);
57581 v4l v4l_cvt_v8l(v8l a);
57595 v8d v8d_cvt_v8l(v8l a);
57609 v8f v8f_cvt_v8l(v8l a);
57623 v8i v8i_cvt_v8l(v8l a);
57637 v8l v8l_cvt_v8l(v8l a);
57652 v16f v16f_cvt_v8l(v8l a);
57667 v16i v16i_cvt_v8l(v8l a);
57682 v1d v1d_cvt_v16f(v16f a);
57697 v1f v1f_cvt_v16f(v16f a);
57712 v1i v1i_cvt_v16f(v16f a);
57727 v1l v1l_cvt_v16f(v16f a);
57742 v2d v2d_cvt_v16f(v16f a);
57757 v2f v2f_cvt_v16f(v16f a);
57772 v2i v2i_cvt_v16f(v16f a);
57787 v2l v2l_cvt_v16f(v16f a);
57802 v4d v4d_cvt_v16f(v16f a);
57817 v4f v4f_cvt_v16f(v16f a);
57832 v4i v4i_cvt_v16f(v16f a);
57847 v4l v4l_cvt_v16f(v16f a);
57862 v8d v8d_cvt_v16f(v16f a);
57877 v8f v8f_cvt_v16f(v16f a);
57892 v8i v8i_cvt_v16f(v16f a);
57907 v8l v8l_cvt_v16f(v16f a);
57921 v16f v16f_cvt_v16f(v16f a);
57935 v16i v16i_cvt_v16f(v16f a);
57950 v1d v1d_cvt_v16i(v16i a);
57965 v1f v1f_cvt_v16i(v16i a);
57980 v1i v1i_cvt_v16i(v16i a);
57995 v1l v1l_cvt_v16i(v16i a);
58010 v2d v2d_cvt_v16i(v16i a);
58025 v2f v2f_cvt_v16i(v16i a);
58040 v2i v2i_cvt_v16i(v16i a);
58055 v2l v2l_cvt_v16i(v16i a);
58070 v4d v4d_cvt_v16i(v16i a);
58085 v4f v4f_cvt_v16i(v16i a);
58100 v4i v4i_cvt_v16i(v16i a);
58115 v4l v4l_cvt_v16i(v16i a);
58130 v8d v8d_cvt_v16i(v16i a);
58145 v8f v8f_cvt_v16i(v16i a);
58160 v8i v8i_cvt_v16i(v16i a);
58175 v8l v8l_cvt_v16i(v16i a);
58189 v16f v16f_cvt_v16i(v16i a);
58203 v16i v16i_cvt_v16i(v16i a);
58204 
58220 double sd_cvt_v1d(v1d a);
58232 float sf_cvt_v1d(v1d a);
58244 int32_t si_cvt_v1d(v1d a);
58256 int64_t sl_cvt_v1d(v1d a);
58268 double sd_cvt_v1f(v1f a);
58280 float sf_cvt_v1f(v1f a);
58292 int32_t si_cvt_v1f(v1f a);
58304 int64_t sl_cvt_v1f(v1f a);
58316 double sd_cvt_v1i(v1i a);
58328 float sf_cvt_v1i(v1i a);
58340 int32_t si_cvt_v1i(v1i a);
58352 int64_t sl_cvt_v1i(v1i a);
58364 double sd_cvt_v1l(v1l a);
58376 float sf_cvt_v1l(v1l a);
58388 int32_t si_cvt_v1l(v1l a);
58400 int64_t sl_cvt_v1l(v1l a);
58412 double sd_cvt_v2d(v2d a);
58424 float sf_cvt_v2d(v2d a);
58436 int32_t si_cvt_v2d(v2d a);
58448 int64_t sl_cvt_v2d(v2d a);
58460 double sd_cvt_v2f(v2f a);
58472 float sf_cvt_v2f(v2f a);
58484 int32_t si_cvt_v2f(v2f a);
58496 int64_t sl_cvt_v2f(v2f a);
58508 double sd_cvt_v2i(v2i a);
58520 float sf_cvt_v2i(v2i a);
58532 int32_t si_cvt_v2i(v2i a);
58544 int64_t sl_cvt_v2i(v2i a);
58556 double sd_cvt_v2l(v2l a);
58568 float sf_cvt_v2l(v2l a);
58580 int32_t si_cvt_v2l(v2l a);
58592 int64_t sl_cvt_v2l(v2l a);
58604 double sd_cvt_v4d(v4d a);
58616 float sf_cvt_v4d(v4d a);
58628 int32_t si_cvt_v4d(v4d a);
58640 int64_t sl_cvt_v4d(v4d a);
58652 double sd_cvt_v4f(v4f a);
58664 float sf_cvt_v4f(v4f a);
58676 int32_t si_cvt_v4f(v4f a);
58688 int64_t sl_cvt_v4f(v4f a);
58700 double sd_cvt_v4i(v4i a);
58712 float sf_cvt_v4i(v4i a);
58724 int32_t si_cvt_v4i(v4i a);
58736 int64_t sl_cvt_v4i(v4i a);
58748 double sd_cvt_v4l(v4l a);
58760 float sf_cvt_v4l(v4l a);
58772 int32_t si_cvt_v4l(v4l a);
58784 int64_t sl_cvt_v4l(v4l a);
58796 double sd_cvt_v8d(v8d a);
58808 float sf_cvt_v8d(v8d a);
58820 int32_t si_cvt_v8d(v8d a);
58832 int64_t sl_cvt_v8d(v8d a);
58844 double sd_cvt_v8f(v8f a);
58856 float sf_cvt_v8f(v8f a);
58868 int32_t si_cvt_v8f(v8f a);
58880 int64_t sl_cvt_v8f(v8f a);
58892 double sd_cvt_v8i(v8i a);
58904 float sf_cvt_v8i(v8i a);
58916 int32_t si_cvt_v8i(v8i a);
58928 int64_t sl_cvt_v8i(v8i a);
58940 double sd_cvt_v8l(v8l a);
58952 float sf_cvt_v8l(v8l a);
58964 int32_t si_cvt_v8l(v8l a);
58976 int64_t sl_cvt_v8l(v8l a);
58988 double sd_cvt_v16f(v16f a);
59000 float sf_cvt_v16f(v16f a);
59012 int32_t si_cvt_v16f(v16f a);
59024 int64_t sl_cvt_v16f(v16f a);
59036 double sd_cvt_v16i(v16i a);
59048 float sf_cvt_v16i(v16i a);
59060 int32_t si_cvt_v16i(v16i a);
59072 int64_t sl_cvt_v16i(v16i a);
59073 
59093 m1d m1d_cvt_v1d(v1d a);
59108 m1f m1f_cvt_v1f(v1f a);
59123 m1i m1i_cvt_v1i(v1i a);
59138 m1l m1l_cvt_v1l(v1l a);
59153 m2d m2d_cvt_v2d(v2d a);
59168 m2f m2f_cvt_v2f(v2f a);
59183 m2i m2i_cvt_v2i(v2i a);
59198 m2l m2l_cvt_v2l(v2l a);
59213 m4d m4d_cvt_v4d(v4d a);
59228 m4f m4f_cvt_v4f(v4f a);
59243 m4i m4i_cvt_v4i(v4i a);
59258 m4l m4l_cvt_v4l(v4l a);
59273 m8d m8d_cvt_v8d(v8d a);
59288 m8f m8f_cvt_v8f(v8f a);
59303 m8i m8i_cvt_v8i(v8i a);
59318 m8l m8l_cvt_v8l(v8l a);
59333 m16f m16f_cvt_v16f(v16f a);
59348 m16i m16i_cvt_v16i(v16i a);
59371 v1d v1d_cvt_m1d(m1d a);
59394 v1f v1f_cvt_m1f(m1f a);
59417 v1i v1i_cvt_m1i(m1i a);
59440 v1l v1l_cvt_m1l(m1l a);
59463 v2d v2d_cvt_m2d(m2d a);
59486 v2f v2f_cvt_m2f(m2f a);
59509 v2i v2i_cvt_m2i(m2i a);
59532 v2l v2l_cvt_m2l(m2l a);
59555 v4d v4d_cvt_m4d(m4d a);
59578 v4f v4f_cvt_m4f(m4f a);
59601 v4i v4i_cvt_m4i(m4i a);
59624 v4l v4l_cvt_m4l(m4l a);
59647 v8d v8d_cvt_m8d(m8d a);
59670 v8f v8f_cvt_m8f(m8f a);
59693 v8i v8i_cvt_m8i(m8i a);
59716 v8l v8l_cvt_m8l(m8l a);
59739 v16f v16f_cvt_m16f(m16f a);
59762 v16i v16i_cvt_m16i(m16i a);
59763 
59778 m1d m1d_cvt_m1d(m1d a);
59793 m1f m1f_cvt_m1d(m1d a);
59808 m1i m1i_cvt_m1d(m1d a);
59823 m1l m1l_cvt_m1d(m1d a);
59838 m2d m2d_cvt_m2d(m2d a);
59853 m2f m2f_cvt_m2d(m2d a);
59868 m2i m2i_cvt_m2d(m2d a);
59883 m2l m2l_cvt_m2d(m2d a);
59898 m4d m4d_cvt_m4d(m4d a);
59913 m4f m4f_cvt_m4d(m4d a);
59928 m4i m4i_cvt_m4d(m4d a);
59943 m4l m4l_cvt_m4d(m4d a);
59958 m8d m8d_cvt_m8d(m8d a);
59973 m8f m8f_cvt_m8d(m8d a);
59988 m8i m8i_cvt_m8d(m8d a);
60003 m8l m8l_cvt_m8d(m8d a);
60018 m1d m1d_cvt_m1f(m1f a);
60033 m1f m1f_cvt_m1f(m1f a);
60048 m1i m1i_cvt_m1f(m1f a);
60063 m1l m1l_cvt_m1f(m1f a);
60078 m2d m2d_cvt_m2f(m2f a);
60093 m2f m2f_cvt_m2f(m2f a);
60108 m2i m2i_cvt_m2f(m2f a);
60123 m2l m2l_cvt_m2f(m2f a);
60138 m4d m4d_cvt_m4f(m4f a);
60153 m4f m4f_cvt_m4f(m4f a);
60168 m4i m4i_cvt_m4f(m4f a);
60183 m4l m4l_cvt_m4f(m4f a);
60198 m8d m8d_cvt_m8f(m8f a);
60213 m8f m8f_cvt_m8f(m8f a);
60228 m8i m8i_cvt_m8f(m8f a);
60243 m8l m8l_cvt_m8f(m8f a);
60258 m16f m16f_cvt_m16f(m16f a);
60273 m16i m16i_cvt_m16f(m16f a);
60288 m1d m1d_cvt_m1i(m1i a);
60303 m1f m1f_cvt_m1i(m1i a);
60318 m1i m1i_cvt_m1i(m1i a);
60333 m1l m1l_cvt_m1i(m1i a);
60348 m2d m2d_cvt_m2i(m2i a);
60363 m2f m2f_cvt_m2i(m2i a);
60378 m2i m2i_cvt_m2i(m2i a);
60393 m2l m2l_cvt_m2i(m2i a);
60408 m4d m4d_cvt_m4i(m4i a);
60423 m4f m4f_cvt_m4i(m4i a);
60438 m4i m4i_cvt_m4i(m4i a);
60453 m4l m4l_cvt_m4i(m4i a);
60468 m8d m8d_cvt_m8i(m8i a);
60483 m8f m8f_cvt_m8i(m8i a);
60498 m8i m8i_cvt_m8i(m8i a);
60513 m8l m8l_cvt_m8i(m8i a);
60528 m16f m16f_cvt_m16i(m16i a);
60543 m16i m16i_cvt_m16i(m16i a);
60558 m1d m1d_cvt_m1l(m1l a);
60573 m1f m1f_cvt_m1l(m1l a);
60588 m1i m1i_cvt_m1l(m1l a);
60603 m1l m1l_cvt_m1l(m1l a);
60618 m2d m2d_cvt_m2l(m2l a);
60633 m2f m2f_cvt_m2l(m2l a);
60648 m2i m2i_cvt_m2l(m2l a);
60663 m2l m2l_cvt_m2l(m2l a);
60678 m4d m4d_cvt_m4l(m4l a);
60693 m4f m4f_cvt_m4l(m4l a);
60708 m4i m4i_cvt_m4l(m4l a);
60723 m4l m4l_cvt_m4l(m4l a);
60738 m8d m8d_cvt_m8l(m8l a);
60753 m8f m8f_cvt_m8l(m8l a);
60768 m8i m8i_cvt_m8l(m8l a);
60783 m8l m8l_cvt_m8l(m8l a);
60784 
60785 /* compatible CONVERTS */
60786 
60787 //#endif //PINTS_DOC_H
v4l::v4l_max
v4l v4l_max(v4l a, v4l b)
Elementwise max ( a > b ? a : b )
v8d::v8d_print
void v8d_print(v8d a)
Prints a v8d vector.
v1i::si_cvt_v4d
int32_t si_cvt_v4d(v4d a)
Converts the first value of a v4d vector into int32_t.
v1d::v1d_div
v1d v1d_div(v1d a, v1d b)
Elementwise division ( a / b )
v8l::m8l_eq
m8l m8l_eq(v8l a, v8l b)
Compares the equality of the two input vectors.
v1f::v1f_geq
v1f v1f_geq(v1f a, v1f b)
Compares if elements of a are greater than or equal to those of b.
v8f::v8f_fnmsub
v8f v8f_fnmsub(v8f a, v8f b, v8f acc)
Fused Multiply-Add ( -(a * b) - acc )
v2l::v2l_cvt_v8f
v2l v2l_cvt_v8f(v8f a)
Converts a v8f vector into a v2l vector.
v8d::v8d_permute2x4
v8d v8d_permute2x4(v8d a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v1l::sl_reduce_and_v1l
v1l sl_reduce_and_v1l(v1l a)
Reduction and ( & )
v8i::v8i_cvt_v1i
v8i v8i_cvt_v1i(v1i a)
Converts a v1i vector into a v8i vector.
v8l::v8l_rfprintf
void v8l_rfprintf(FILE *file, v8l a, const char *format)
Prints a v8l vector (reversed order)
v2i::v2i_hshuffle2x1
v2i v2i_hshuffle2x1(v2i a, v2i b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v2d::v2d_cvt_v16i
v2d v2d_cvt_v16i(v16i a)
Converts a v16i vector into a v2d vector.
v1l::v1l_rfprint
void v1l_rfprint(FILE *file, v1l a)
Prints a v1l vector (reversed order)
v16i::v16i_rmerge16_v1i
v16i v16i_rmerge16_v1i(v1i a15, v1i a14, v1i a13, v1i a12, v1i a11, v1i a10, v1i a9, v1i a8, v1i a7, v1i a6, v1i a5, v1i a4, v1i a3, v1i a2, v1i a1, v1i a0)
Merges 16 v1i vectors together (reverse order).
v4i::v4i_hshuffle2
v4i v4i_hshuffle2(v4i a, v4i b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v1l::v1l_reduce_or_v4l
v1l v1l_reduce_or_v4l(v4l a)
Reduction or ( | )
v1i::v1i_reduce_add_v2i
v1i v1i_reduce_add_v2i(v2i a)
Reduction add ( + )
v8d::v8d_cvt_m8d
v8d v8d_cvt_m8d(m8d a)
Converts a m8d vector-mask into a v8d vector.
v1l::v1l_maskz_move
v1l v1l_maskz_move(m1l mask, v1l a)
Mask the input.
v8i::v8i_fnmsub
v8i v8i_fnmsub(v8i a, v8i b, v8i acc)
Fused Multiply-Add ( -(a * b) - acc )
v4f::v4f_sqrt
v4f v4f_sqrt(v4f a)
Elementwise square root ( sqrt(a) )
v8f
Type for the manipulation of 8 float packed into one single vector.
Definition: pints-doc.h:571
v16i::v16i_blend8
v16i v16i_blend8(v16i a, v16i b, uint_fast8_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v1d::v1d_and
v1d v1d_and(v1d a, v1d b)
Bitwise and ( a & b )
v8d::v8d_fshuffle2x4
v8d v8d_fshuffle2x4(v8d a, v8d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8f::v8f_add
v8f v8f_add(v8f a, v8f b)
Elementwise addition ( a + b )
v1f::sf_cvt_v2i
float sf_cvt_v2i(v2i a)
Converts the first value of a v2i vector into float.
v8l::v8l_reduce_min_v4l
v8l v8l_reduce_min_v4l(v4l a)
Reduction min ( min )
v16i::v16i_abs
v16i v16i_abs(v16i a)
Elementwise absolute value ( a > 0 ? a : -a )
v4i::v4i_rcp
v4i v4i_rcp(v4i a)
Elementwise reciprocal ( 1 / a )
v4d::v4d_cast_v1f
v4d v4d_cast_v1f(v1f a)
Casts a v1f vector into a v4d vector.
v1d::v1d_reduce_max_v8d
v1d v1d_reduce_max_v8d(v8d a)
Reduction max ( max )
v16i::v16i_printf
void v16i_printf(v16i a, const char *format)
Prints a v16i vector.
v4f::v4f_fshuffle2
v4f v4f_fshuffle2(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2l::v2l_set_hilo_v1l
v2l v2l_set_hilo_v1l(v2l src, v1l a, int high)
Conditionally sets the low or the high part of a v2l vector.
v2f::v2f_cvt_v2d
v2f v2f_cvt_v2d(v2d a)
Converts a v2d vector into a v2f vector.
v1l::v1l_cvt_v4f
v1l v1l_cvt_v4f(v4f a)
Converts a v4f vector into a v1l vector.
v2f::v2f_reduce_mul_v8f
v2f v2f_reduce_mul_v8f(v8f a)
Reduction mul ( * )
v8i::v8i_max
v8i v8i_max(v8i a, v8i b)
Elementwise max ( a > b ? a : b )
v4l::v4l_merge2_v2l
v4l v4l_merge2_v2l(v2l a0, v2l a1)
Merges 2 v2l vectors together.
v8f::v8f_one
v8f v8f_one()
Sets all elements to 1.
v8f::sf_reduce_mul_v8f
v8f sf_reduce_mul_v8f(v8f a)
Reduction mul ( * )
v1f::v1f_cvt_v8d
v1f v1f_cvt_v8d(v8d a)
Converts a v8d vector into a v1f vector.
v4f::v4f_reduce_add_v8f
v4f v4f_reduce_add_v8f(v8f a)
Reduction add ( + )
v16i::v16i_cast_v1f
v16i v16i_cast_v1f(v1f a)
Casts a v1f vector into a v16i vector.
v4i::si_reduce_or_v4i
v4i si_reduce_or_v4i(v4i a)
Reduction or ( | )
v16f::v16f_nor
v16f v16f_nor(v16f a, v16f b)
Bitwise nor ( ~(a | b) )
v8i::si_reduce_or_v8i
v8i si_reduce_or_v8i(v8i a)
Reduction or ( | )
v8i::v8i_blend1
v8i v8i_blend1(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v2f::v2f_reduce_max
v2f v2f_reduce_max(v2f a)
Reduction max ( max )
v8i::v8i_cast_v1l
v8i v8i_cast_v1l(v1l a)
Casts a v1l vector into a v8i vector.
v4l::v4l_permute4x1
v4l v4l_permute4x1(v4l a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v8d::v8d_blend2x4
v8d v8d_blend2x4(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v8f::v8f_reduce_and_v8f
v8f v8f_reduce_and_v8f(v8f a)
Reduction and ( & )
v8l::m8l_nxor
m8l m8l_nxor(m8l a, m8l b)
Bitwise nxor ( ~(a ^ b) )
v2d::v2d_cast_m2d
v2d v2d_cast_m2d(m2d a)
Casts a m2d vector-mask into a v2d vector.
v4f::v2f_get_low_v4f
v2f v2f_get_low_v4f(v4f a)
Gets the low part of a v4f vector.
v16i::v16i_hshuffle16
v16i v16i_hshuffle16(v16i a, v16i b, uint_fast64_t rule)
Shuffles (outer) a and b together using the control in rule.
v2l::v2l_reduce_add_v2l
v2l v2l_reduce_add_v2l(v2l a)
Reduction add ( + )
v1f::sf_reduce_max_v1f
v1f sf_reduce_max_v1f(v1f a)
Reduction max ( max )
v8d::v8d_reduce_and_v2d
v8d v8d_reduce_and_v2d(v2d a)
Reduction and ( & )
v8d::v8d_rmerge2_v4d
v8d v8d_rmerge2_v4d(v4d a1, v4d a0)
Merges 2 v4d vectors together (reverse order).
v2d::v2d_blend1
v2d v2d_blend1(v2d a, v2d b, uint_fast8_t mask)
Creates a new v2d vector whose elements are from a and b choosed by mask.
v2i::v2i_reduce_min_v1i
v2i v2i_reduce_min_v1i(v1i a)
Reduction min ( min )
v1i::v1i_reduce_or_v4i
v1i v1i_reduce_or_v4i(v4i a)
Reduction or ( | )
v8f::sf_reduce_min_v8f
v8f sf_reduce_min_v8f(v8f a)
Reduction min ( min )
v8l::v8l_rset
v8l v8l_rset(int64_t v7, int64_t v6, int64_t v5, int64_t v4, int64_t v3, int64_t v2, int64_t v1, int64_t v0)
Sets the elements of a v8l vector (reverse order).
v1i::m1i_cvt_m1l
m1i m1i_cvt_m1l(m1l a)
Converts a m1l vector-mask into a m1i vector-mask.
v16f::v16f_sqrt
v16f v16f_sqrt(v16f a)
Elementwise square root ( sqrt(a) )
v2i::v2i_gt
v2i v2i_gt(v2i a, v2i b)
Compares if elements of a are greater than those of b.
v8f::m8f_ornot
m8f m8f_ornot(m8f a, m8f b)
Bitwise ornot ( a | ~b )
v4l::v4l_reduce_or_v8l
v4l v4l_reduce_or_v8l(v8l a)
Reduction or ( | )
v4i::v4i_rmerge_v2i
v4i v4i_rmerge_v2i(v2i high, v2i low)
Merges 2 v2i vectors together (reversed order).
v16i::v16i_set_hilo_v8i
v16i v16i_set_hilo_v8i(v16i src, v8i a, int high)
Conditionally sets the low or the high part of a v16i vector.
v8d::v8d_andnot
v8d v8d_andnot(v8d a, v8d b)
Bitwise andnot ( a & ~b )
v8i::v8i_permute8
v8i v8i_permute8(v8i a, uint_fast32_t rule)
Shuffles (outer) a using the control in rule.
v2i::v2i_nxor
v2i v2i_nxor(v2i a, v2i b)
Bitwise nxor ( ~(a ^ b) )
v8l::v8l_neq
v8l v8l_neq(v8l a, v8l b)
Compares the inequality of the two input vectors.
v16i::v16i_andnot
v16i v16i_andnot(v16i a, v16i b)
Bitwise andnot ( a & ~b )
v4f::v2f_get_high_v4f
v2f v2f_get_high_v4f(v4f a)
Gets the high part of a v4f vector.
v1f::v1f_mul
v1f v1f_mul(v1f a, v1f b)
Elementwise multiplication ( a * b )
v1i::v1i_neq
v1i v1i_neq(v1i a, v1i b)
Compares the inequality of the two input vectors.
v2l::v2l_cvt_v8i
v2l v2l_cvt_v8i(v8i a)
Converts a v8i vector into a v2l vector.
v1i::si_reduce_and_v1i
v1i si_reduce_and_v1i(v1i a)
Reduction and ( & )
v8d::v8d_cvt_v1l
v8d v8d_cvt_v1l(v1l a)
Converts a v1l vector into a v8d vector.
v4f::v4f_reduce_or_v2f
v4f v4f_reduce_or_v2f(v2f a)
Reduction or ( | )
v4d::v4d_or
v4d v4d_or(v4d a, v4d b)
Bitwise or ( a | b )
v8l::v8l_cvt_m8l
v8l v8l_cvt_m8l(m8l a)
Converts a m8l vector-mask into a v8l vector.
v1f::v1f_xor
v1f v1f_xor(v1f a, v1f b)
Bitwise xor ( a ^ b )
v16f::v16f_reduce_max_v2f
v16f v16f_reduce_max_v2f(v2f a)
Reduction max ( max )
v1d::sd_cvt_v8i
double sd_cvt_v8i(v8i a)
Converts the first value of a v8i vector into double.
v8l::v8l_hshuffle4
v8l v8l_hshuffle4(v8l a, v8l b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v1i::v1i_cvt_v8d
v1i v1i_cvt_v8d(v8d a)
Converts a v8d vector into a v1i vector.
v1i::v1i_cast_v4f
v1i v1i_cast_v4f(v4f a)
Casts a v4f vector into a v1i vector.
v4f::v4f_blend1x4
v4f v4f_blend1x4(v4f a, v4f b, uint_fast8_t mask)
Creates a new v4f vector whose elements are from a and b choosed by mask.
v2i::v2i_printf
void v2i_printf(v2i a, const char *format)
Prints a v2i vector.
v1i::v1i_neg
v1i v1i_neg(v1i a)
Elementwise negation ( -a )
v1f::v1f_store1
void v1f_store1(float *p, v1f a)
Stores the first element of a v1f vector into memory.
v4l::v4l_rfprintf
void v4l_rfprintf(FILE *file, v4l a, const char *format)
Prints a v4l vector (reversed order)
v4d::m4d_xor
m4d m4d_xor(m4d a, m4d b)
Bitwise xor ( a ^ b )
v4i::v4i_cvt_m4i
v4i v4i_cvt_m4i(m4i a)
Converts a m4i vector-mask into a v4i vector.
v4d::v4d_cvt_v1i
v4d v4d_cvt_v1i(v1i a)
Converts a v1i vector into a v4d vector.
v2l::m2l_and
m2l m2l_and(m2l a, m2l b)
Bitwise and ( a & b )
m4l
Type for the manipulation of vector-masks.
Definition: pints-doc.h:512
v1l::v1l_rcp
v1l v1l_rcp(v1l a)
Elementwise reciprocal ( 1 / a )
v2i::v1i_get_hilo_v2i
v1i v1i_get_hilo_v2i(v2i a, int high)
Conditionnaly gets the low or the high part of a v2i vector.
v16f::v16f_reduce_or_v4f
v16f v16f_reduce_or_v4f(v4f a)
Reduction or ( | )
v1f::sf_cvt_v1d
float sf_cvt_v1d(v1d a)
Converts the first value of a v1d vector into float.
v1l::v1l_move
v1l v1l_move(v1l a)
Forwards the input.
v8f::v8f_cvt_v2i
v8f v8f_cvt_v2i(v2i a)
Converts a v2i vector into a v8f vector.
v16i::v16i_blend16x1
v16i v16i_blend16x1(v16i a, v16i b, uint_fast16_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v1l::v1l_cast_v4d
v1l v1l_cast_v4d(v4d a)
Casts a v4d vector into a v1l vector.
v4f::v4f_cast_v2l
v4f v4f_cast_v2l(v2l a)
Casts a v2l vector into a v4f vector.
v16f::m16f_not
m16f m16f_not(m16f a)
Bitwise not ( ~a )
v16i::v16i_rfprintf
void v16i_rfprintf(FILE *file, v16i a, const char *format)
Prints a v16i vector (reversed order)
v1d::v1d_reduce_mul
v1d v1d_reduce_mul(v1d a)
Reduction mul ( * )
v8d::sd_reduce_add_v8d
v8d sd_reduce_add_v8d(v8d a)
Reduction add ( + )
v4f::v4f_reduce_and_v2f
v4f v4f_reduce_and_v2f(v2f a)
Reduction and ( & )
v1d::v1d_cast_v2d
v1d v1d_cast_v2d(v2d a)
Casts a v2d vector into a v1d vector.
v4l::m4l_nor
m4l m4l_nor(m4l a, m4l b)
Bitwise nor ( ~(a | b) )
v8l::v8l_merge_v4l
v8l v8l_merge_v4l(v4l low, v4l high)
Merges 2 v4l vectors together.
v16f::sf_reduce_mul_v16f
v16f sf_reduce_mul_v16f(v16f a)
Reduction mul ( * )
v4i::v4i_store
void v4i_store(int32_t *p, v4i a)
Stores a v4i vector into memory.
v1d::v1d_cast_v2f
v1d v1d_cast_v2f(v2f a)
Casts a v2f vector into a v1d vector.
v8l::v8l_reduce_add_v4l
v8l v8l_reduce_add_v4l(v4l a)
Reduction add ( + )
v4i::v4i_cast_v8f
v4i v4i_cast_v8f(v8f a)
Casts a v8f vector into a v4i vector.
v8d::v8d_cvt_v2d
v8d v8d_cvt_v2d(v2d a)
Converts a v2d vector into a v8d vector.
v1i::m1i_or
m1i m1i_or(m1i a, m1i b)
Bitwise or ( a | b )
v1f::v1f_store
void v1f_store(float *p, v1f a)
Stores a v1f vector into memory.
v1f::v1f_reduce_min_v1f
v1f v1f_reduce_min_v1f(v1f a)
Reduction min ( min )
v8f::v8f_reduce_mul_v4f
v8f v8f_reduce_mul_v4f(v4f a)
Reduction mul ( * )
v8f::v8f_fshuffle2x4
v8f v8f_fshuffle2x4(v8f a, v8f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v2f::v2f_cast_v2i
v2f v2f_cast_v2i(v2i a)
Casts a v2i vector into a v2f vector.
v2l::m2l_ornot
m2l m2l_ornot(m2l a, m2l b)
Bitwise ornot ( a | ~b )
v8d::v8d_reduce_mul_v1d
v8d v8d_reduce_mul_v1d(v1d a)
Reduction mul ( * )
v8i::v4i_get_low_v8i
v4i v4i_get_low_v8i(v8i a)
Gets the low part of a v8i vector.
v4d::v4d_reduce_add_v2d
v4d v4d_reduce_add_v2d(v2d a)
Reduction add ( + )
v2i::v2i_cvt_v16i
v2i v2i_cvt_v16i(v16i a)
Converts a v16i vector into a v2i vector.
v1l::v1l_neg
v1l v1l_neg(v1l a)
Elementwise negation ( -a )
v1d::v1d_gt
v1d v1d_gt(v1d a, v1d b)
Compares if elements of a are greater than those of b.
v8i::v8i_reduce_or_v16i
v8i v8i_reduce_or_v16i(v16i a)
Reduction or ( | )
v2i::v2i_rmerge2_v1i
v2i v2i_rmerge2_v1i(v1i a1, v1i a0)
Merges 2 v1i vectors together (reverse order).
v8i::v8i_cvt_v1l
v8i v8i_cvt_v1l(v1l a)
Converts a v1l vector into a v8i vector.
v4f::m4f_lt
m4f m4f_lt(v4f a, v4f b)
Compares if elements of a are less than those of b.
v2i::v2i_fmsub
v2i v2i_fmsub(v2i a, v2i b, v2i acc)
Fused Multiply-Sub ( (a * b) - acc )
v2f::v2f_reduce_or_v16f
v2f v2f_reduce_or_v16f(v16f a)
Reduction or ( | )
v4i::v4i_cvt_v4f
v4i v4i_cvt_v4f(v4f a)
Converts a v4f vector into a v4i vector.
v8l::v8l_reduce_min_v2l
v8l v8l_reduce_min_v2l(v2l a)
Reduction min ( min )
v2d::v2d_cvt_v4d
v2d v2d_cvt_v4d(v4d a)
Converts a v4d vector into a v2d vector.
v2f::m2f_geq
m2f m2f_geq(v2f a, v2f b)
Compares if elements of a are greater than or equal to those of b.
v1l::v1l_fnmsub
v1l v1l_fnmsub(v1l a, v1l b, v1l acc)
Fused Multiply-Add ( -(a * b) - acc )
v8d::v8d_reduce_mul
v8d v8d_reduce_mul(v8d a)
Reduction mul ( * )
v2i::v2i_reduce_max_v4i
v2i v2i_reduce_max_v4i(v4i a)
Reduction max ( max )
v1f::v1f_blend
v1f v1f_blend(v1f a, v1f b, uint_fast8_t mask)
Creates a new v1f vector whose elements are from a and b choosed by mask.
v4l::sl_reduce_and_v4l
v4l sl_reduce_and_v4l(v4l a)
Reduction and ( & )
v1d::v1d_or
v1d v1d_or(v1d a, v1d b)
Bitwise or ( a | b )
v16f::v16f_cvt_v1d
v16f v16f_cvt_v1d(v1d a)
Converts a v1d vector into a v16f vector.
v4i::v4i_blend
v4i v4i_blend(v4i a, v4i b, uint_fast8_t mask)
Creates a new v4i vector whose elements are from a and b choosed by mask.
v8i::v8i_rsqrt
v8i v8i_rsqrt(v8i a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v1i::v1i_reduce_and_v2i
v1i v1i_reduce_and_v2i(v2i a)
Reduction and ( & )
v1d::v1d_mul
v1d v1d_mul(v1d a, v1d b)
Elementwise multiplication ( a * b )
v4d::m4d_ornot
m4d m4d_ornot(m4d a, m4d b)
Bitwise ornot ( a | ~b )
v4f::v4f_cvt_v2f
v4f v4f_cvt_v2f(v2f a)
Converts a v2f vector into a v4f vector.
v4f::v4f_reduce_or_v16f
v4f v4f_reduce_or_v16f(v16f a)
Reduction or ( | )
v4d::v4d_reduce_and_v8d
v4d v4d_reduce_and_v8d(v8d a)
Reduction and ( & )
v1f::v1f_hshuffle
v1f v1f_hshuffle(v1f a, v1f b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v1i::v1i_reduce_and
v1i v1i_reduce_and(v1i a)
Reduction and ( & )
v8i::v8i_reduce_max_v4i
v8i v8i_reduce_max_v4i(v4i a)
Reduction max ( max )
v8f::v8f_move
v8f v8f_move(v8f a)
Forwards the input.
v2f::v2f_reduce_max_v16f
v2f v2f_reduce_max_v16f(v16f a)
Reduction max ( max )
v8d::v8d_cast_v2d
v8d v8d_cast_v2d(v2d a)
Casts a v2d vector into a v8d vector.
v16i::v16i_mul
v16i v16i_mul(v16i a, v16i b)
Elementwise multiplication ( a * b )
v1d::v1d_reduce_or
v1d v1d_reduce_or(v1d a)
Reduction or ( | )
v16f::v16f_fshuffle
v16f v16f_fshuffle(v16f a, v16f b, uint_fast64_t rule, uint_fast16_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8d::v8d_cast_m8d
v8d v8d_cast_m8d(m8d a)
Casts a m8d vector-mask into a v8d vector.
v1f::v1f_neq
v1f v1f_neq(v1f a, v1f b)
Compares the inequality of the two input vectors.
v4i::m4i_xor
m4i m4i_xor(m4i a, m4i b)
Bitwise xor ( a ^ b )
v8f::v4f_get_low_v8f
v4f v4f_get_low_v8f(v8f a)
Gets the low part of a v8f vector.
v1i::v1i_cast_v8l
v1i v1i_cast_v8l(v8l a)
Casts a v8l vector into a v1i vector.
v4i::v4i_not
v4i v4i_not(v4i a)
Bitwise not ( ~a )
v4l::v4l_maskz_move
v4l v4l_maskz_move(m4l mask, v4l a)
Mask the input.
v1f::v1f_reduce_and
v1f v1f_reduce_and(v1f a)
Reduction and ( & )
v4l::v4l_set_hilo_v2l
v4l v4l_set_hilo_v2l(v4l src, v2l a, int high)
Conditionally sets the low or the high part of a v4l vector.
v1d::m1d_not
m1d m1d_not(m1d a)
Bitwise not ( ~a )
v16f::v16f_leq
v16f v16f_leq(v16f a, v16f b)
Compares if elements of a are less than or equal to those of b.
v8l::v8l_mul
v8l v8l_mul(v8l a, v8l b)
Elementwise multiplication ( a * b )
v16f::v16f_reduce_mul_v2f
v16f v16f_reduce_mul_v2f(v2f a)
Reduction mul ( * )
v1i::v1i_rset
v1i v1i_rset(int32_t v0)
Sets the elements of a v1i vector (reverse order).
v1d::v1d_cast_v4l
v1d v1d_cast_v4l(v4l a)
Casts a v4l vector into a v1d vector.
v1f::v1f_cvt_v16f
v1f v1f_cvt_v16f(v16f a)
Converts a v16f vector into a v1f vector.
v8f::m8f_cvt_m8i
m8f m8f_cvt_m8i(m8i a)
Converts a m8i vector-mask into a m8f vector-mask.
v8l::v8l_fmsub
v8l v8l_fmsub(v8l a, v8l b, v8l acc)
Fused Multiply-Sub ( (a * b) - acc )
v8d::v8d_permute4x2
v8d v8d_permute4x2(v8d a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v16i::m16i_ornot
m16i m16i_ornot(m16i a, m16i b)
Bitwise ornot ( a | ~b )
v2l::v2l_store1
void v2l_store1(int64_t *p, v2l a)
Stores the first element of a v2l vector into memory.
v4f::v4f_eq
v4f v4f_eq(v4f a, v4f b)
Compares the equality of the two input vectors.
m1l
Type for the manipulation of vector-masks.
Definition: pints-doc.h:192
v2i::v2i_reduce_or_v4i
v2i v2i_reduce_or_v4i(v4i a)
Reduction or ( | )
v4d::v4d_ones
v4d v4d_ones()
Sets all bits to 1.
v4i::v4i_fshuffle4x1
v4i v4i_fshuffle4x1(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1d::sd_reduce_or_v1d
v1d sd_reduce_or_v1d(v1d a)
Reduction or ( | )
v2l::v2l_sqrt
v2l v2l_sqrt(v2l a)
Elementwise square root ( sqrt(a) )
v4i::v4i_cvt_v8l
v4i v4i_cvt_v8l(v8l a)
Converts a v8l vector into a v4i vector.
v1f::v1f_cast_v8d
v1f v1f_cast_v8d(v8d a)
Casts a v8d vector into a v1f vector.
v2f::m2f_cvt_v2f
m2f m2f_cvt_v2f(v2f a)
Converts a v2f vector into a m2f vector-mask.
v8f::v8f_merge4_v2f
v8f v8f_merge4_v2f(v2f a0, v2f a1, v2f a2, v2f a3)
Merges 4 v2f vectors together.
v4l::v4l_cvt_v1f
v4l v4l_cvt_v1f(v1f a)
Converts a v1f vector into a v4l vector.
v4l::v4l_reduce_mul_v4l
v4l v4l_reduce_mul_v4l(v4l a)
Reduction mul ( * )
v4i::v4i_rmerge2_v2i
v4i v4i_rmerge2_v2i(v2i a1, v2i a0)
Merges 2 v2i vectors together (reverse order).
v2i::v2i_cast_v4d
v2i v2i_cast_v4d(v4d a)
Casts a v4d vector into a v2i vector.
v1f::v1f_cast_v1f
v1f v1f_cast_v1f(v1f a)
Casts a v1f vector into a v1f vector.
v8i::v8i_add
v8i v8i_add(v8i a, v8i b)
Elementwise addition ( a + b )
v4l
Type for the manipulation of 4 int64_t packed into one single vector.
Definition: pints-doc.h:491
v1l::m1l_xor
m1l m1l_xor(m1l a, m1l b)
Bitwise xor ( a ^ b )
v2d::v2d_reduce_add_v4d
v2d v2d_reduce_add_v4d(v4d a)
Reduction add ( + )
v4f::v4f_not
v4f v4f_not(v4f a)
Bitwise not ( ~a )
v16f::v16f_cvt_v8i
v16f v16f_cvt_v8i(v8i a)
Converts a v8i vector into a v16f vector.
v8i::v8i_hshuffle
v8i v8i_hshuffle(v8i a, v8i b, uint_fast32_t rule)
Shuffles a and b together using the control in rule.
v4i::v4i_reduce_min_v2i
v4i v4i_reduce_min_v2i(v2i a)
Reduction min ( min )
v2d::v2d_gt
v2d v2d_gt(v2d a, v2d b)
Compares if elements of a are greater than those of b.
v16i::v16i_rprintf
void v16i_rprintf(v16i a, const char *format)
Prints a v16i vector (reversed order)
v1i::si_cvt_v8l
int32_t si_cvt_v8l(v8l a)
Converts the first value of a v8l vector into int32_t.
v1i::v1i_cast_v4l
v1i v1i_cast_v4l(v4l a)
Casts a v4l vector into a v1i vector.
v4i::v4i_reduce_max_v8i
v4i v4i_reduce_max_v8i(v8i a)
Reduction max ( max )
v16i::v16i_blend
v16i v16i_blend(v16i a, v16i b, uint_fast16_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v8l::v8l_permute8
v8l v8l_permute8(v8l a, uint_fast32_t rule)
Shuffles (outer) a using the control in rule.
v4d::v4d_frsqrt
v4d v4d_frsqrt(v4d a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v4f::v4f_reduce_max_v8f
v4f v4f_reduce_max_v8f(v8f a)
Reduction max ( max )
v2i::v2i_cast_v1i
v2i v2i_cast_v1i(v1i a)
Casts a v1i vector into a v2i vector.
v4f::v4f_set1
v4f v4f_set1(float v)
Broadcasts a single value into all elements of a v4f vector.
v2f::v2f_nand
v2f v2f_nand(v2f a, v2f b)
Bitwise nand ( ~(a & b) )
v1f::v1f_print
void v1f_print(v1f a)
Prints a v1f vector.
v1i::v1i_reduce_or_v16i
v1i v1i_reduce_or_v16i(v16i a)
Reduction or ( | )
v1f::v1f_fprintf
void v1f_fprintf(FILE *file, v1f a, const char *format)
Prints a v1f vector.
v16i::m16i_cvt_v16i
m16i m16i_cvt_v16i(v16i a)
Converts a v16i vector into a m16i vector-mask.
v16i::si_reduce_min_v16i
v16i si_reduce_min_v16i(v16i a)
Reduction min ( min )
v1d::v1d_reduce_add
v1d v1d_reduce_add(v1d a)
Reduction add ( + )
v1i::m1i_neq
m1i m1i_neq(v1i a, v1i b)
Compares the inequality of the two input vectors.
v8d::v8d_reduce_add_v4d
v8d v8d_reduce_add_v4d(v4d a)
Reduction add ( + )
v8d::v8d_mul
v8d v8d_mul(v8d a, v8d b)
Elementwise multiplication ( a * b )
v1f::sf_reduce_min_v1f
v1f sf_reduce_min_v1f(v1f a)
Reduction min ( min )
v1f::v1f_cast_v4i
v1f v1f_cast_v4i(v4i a)
Casts a v4i vector into a v1f vector.
v4l::v4l_cast_v2l
v4l v4l_cast_v2l(v2l a)
Casts a v2l vector into a v4l vector.
v2i::v2i_reduce_max_v8i
v2i v2i_reduce_max_v8i(v8i a)
Reduction max ( max )
v2l::v1l_get_low_v2l
v1l v1l_get_low_v2l(v2l a)
Gets the low part of a v2l vector.
v1f::sf_cvt_v1i
float sf_cvt_v1i(v1i a)
Converts the first value of a v1i vector into float.
v8f::sf_reduce_and_v8f
v8f sf_reduce_and_v8f(v8f a)
Reduction and ( & )
v1f::v1f_cast_v16f
v1f v1f_cast_v16f(v16f a)
Casts a v16f vector into a v1f vector.
v2i::v2i_fprint
void v2i_fprint(FILE *file, v2i a)
Prints a v2i vector.
v4d::v4d_nor
v4d v4d_nor(v4d a, v4d b)
Bitwise nor ( ~(a | b) )
v4d::v4d_rfprint
void v4d_rfprint(FILE *file, v4d a)
Prints a v4d vector (reversed order)
v16f::v16f_reduce_max_v16f
v16f v16f_reduce_max_v16f(v16f a)
Reduction max ( max )
v2l::v2l_gt
v2l v2l_gt(v2l a, v2l b)
Compares if elements of a are greater than those of b.
v4l::v4l_fprintf
void v4l_fprintf(FILE *file, v4l a, const char *format)
Prints a v4l vector.
v16f::v16f_hshuffle8x2
v16f v16f_hshuffle8x2(v16f a, v16f b, uint_fast32_t rule)
Shuffles (inner) a and b together using the control in rule.
v16i::v16i_cvt_v1d
v16i v16i_cvt_v1d(v1d a)
Converts a v1d vector into a v16i vector.
v2f::v2f_loadu
v2f v2f_loadu(const float *p)
Loads 2 float from memory into a v2f vector.
v4i::v4i_blend1
v4i v4i_blend1(v4i a, v4i b, uint_fast8_t mask)
Creates a new v4i vector whose elements are from a and b choosed by mask.
v4l::sl_reduce_or_v4l
v4l sl_reduce_or_v4l(v4l a)
Reduction or ( | )
v1i::m1i_cvt_m1f
m1i m1i_cvt_m1f(m1f a)
Converts a m1f vector-mask into a m1i vector-mask.
v2f::v2f_max
v2f v2f_max(v2f a, v2f b)
Elementwise max ( a > b ? a : b )
v4l::v4l_blend
v4l v4l_blend(v4l a, v4l b, uint_fast8_t mask)
Creates a new v4l vector whose elements are from a and b choosed by mask.
v4d::v4d_cast_v8l
v4d v4d_cast_v8l(v8l a)
Casts a v8l vector into a v4d vector.
v4l::v4l_hshuffle4x1
v4l v4l_hshuffle4x1(v4l a, v4l b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v8l::v8l_blend4x2
v8l v8l_blend4x2(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v1i::v1i_cast_v8f
v1i v1i_cast_v8f(v8f a)
Casts a v8f vector into a v1i vector.
v8f::v8f_rprint
void v8f_rprint(v8f a)
Prints a v8f vector (reversed order)
v1f::m1f_cvt_m1d
m1f m1f_cvt_m1d(m1d a)
Converts a m1d vector-mask into a m1f vector-mask.
v8d::v8d_geq
v8d v8d_geq(v8d a, v8d b)
Compares if elements of a are greater than or equal to those of b.
v8l::m8l_nor
m8l m8l_nor(m8l a, m8l b)
Bitwise nor ( ~(a | b) )
v1l::v1l_reduce_and_v1l
v1l v1l_reduce_and_v1l(v1l a)
Reduction and ( & )
v16f::v16f_fshuffle4x4
v16f v16f_fshuffle4x4(v16f a, v16f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v2f::m2f_eq
m2f m2f_eq(v2f a, v2f b)
Compares the equality of the two input vectors.
v16i::v16i_set_low_v8i
v16i v16i_set_low_v8i(v16i src, v8i low)
Sets the low part of a v16i vector.
v8f::v8f_cvt_v1i
v8f v8f_cvt_v1i(v1i a)
Converts a v1i vector into a v8f vector.
v8f::v8f_fshuffle2
v8f v8f_fshuffle2(v8f a, v8f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2l::m2l_cvt_v2l
m2l m2l_cvt_v2l(v2l a)
Converts a v2l vector into a m2l vector-mask.
v2l::v2l_load1
v2l v2l_load1(const int64_t *p)
Loads 1 int64_t from memory and broadcasts it into a v2l vector.
v16f::v16f_printf
void v16f_printf(v16f a, const char *format)
Prints a v16f vector.
v8i::v8i_cast_v4f
v8i v8i_cast_v4f(v4f a)
Casts a v4f vector into a v8i vector.
v8i::v8i_cvt_v4d
v8i v8i_cvt_v4d(v4d a)
Converts a v4d vector into a v8i vector.
v1l::v1l_zeros
v1l v1l_zeros()
Sets all bits to 0.
v4d::v4d_printf
void v4d_printf(v4d a, const char *format)
Prints a v4d vector.
v16f::v16f_blend1
v16f v16f_blend1(v16f a, v16f b, uint_fast8_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v1d::v1d_frsqrt
v1d v1d_frsqrt(v1d a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v16f::v16f_reduce_mul_v16f
v16f v16f_reduce_mul_v16f(v16f a)
Reduction mul ( * )
v1d::v1d_fprint
void v1d_fprint(FILE *file, v1d a)
Prints a v1d vector.
v2d::v2d_cvt_v4i
v2d v2d_cvt_v4i(v4i a)
Converts a v4i vector into a v2d vector.
v8f::v8f_cvt_v2l
v8f v8f_cvt_v2l(v2l a)
Converts a v2l vector into a v8f vector.
v2i::v2i_merge_v1i
v2i v2i_merge_v1i(v1i low, v1i high)
Merges 2 v1i vectors together.
v16i::v16i_add
v16i v16i_add(v16i a, v16i b)
Elementwise addition ( a + b )
v8l::v8l_cast_v1l
v8l v8l_cast_v1l(v1l a)
Casts a v1l vector into a v8l vector.
v4f::v4f_reduce_and_v8f
v4f v4f_reduce_and_v8f(v8f a)
Reduction and ( & )
v8i::v8i_and
v8i v8i_and(v8i a, v8i b)
Bitwise and ( a & b )
v4i::v4i_rmerge4_v1i
v4i v4i_rmerge4_v1i(v1i a3, v1i a2, v1i a1, v1i a0)
Merges 4 v1i vectors together (reverse order).
v4i::v4i_fshuffle2x2
v4i v4i_fshuffle2x2(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1d::m1d_cvt_m1i
m1d m1d_cvt_m1i(m1i a)
Converts a m1i vector-mask into a m1d vector-mask.
v4l::v4l_fprint
void v4l_fprint(FILE *file, v4l a)
Prints a v4l vector.
v8f::v8f_nxor
v8f v8f_nxor(v8f a, v8f b)
Bitwise nxor ( ~(a ^ b) )
v1l
Type for the manipulation of 1 int64_t packed into one single vector.
Definition: pints-doc.h:171
v1d::m1d_gt
m1d m1d_gt(v1d a, v1d b)
Compares if elements of a are greater than those of b.
v1i::v1i_reduce_and_v1i
v1i v1i_reduce_and_v1i(v1i a)
Reduction and ( & )
v2d::v1d_get_low_v2d
v1d v1d_get_low_v2d(v2d a)
Gets the low part of a v2d vector.
v2f::v2f_reduce_or_v4f
v2f v2f_reduce_or_v4f(v4f a)
Reduction or ( | )
v1d::v1d_reduce_min_v2d
v1d v1d_reduce_min_v2d(v2d a)
Reduction min ( min )
v16i::v16i_fshuffle8x2
v16i v16i_fshuffle8x2(v16i a, v16i b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4i::v4i_reduce_max_v1i
v4i v4i_reduce_max_v1i(v1i a)
Reduction max ( max )
v8d::v8d_nor
v8d v8d_nor(v8d a, v8d b)
Bitwise nor ( ~(a | b) )
v8i::v8i_cast_v1f
v8i v8i_cast_v1f(v1f a)
Casts a v1f vector into a v8i vector.
v4f::v4f_reduce_mul
v4f v4f_reduce_mul(v4f a)
Reduction mul ( * )
v4i::m4i_not
m4i m4i_not(m4i a)
Bitwise not ( ~a )
v4i::v4i_cast_v2d
v4i v4i_cast_v2d(v2d a)
Casts a v2d vector into a v4i vector.
v8f::v8f_cast_v1l
v8f v8f_cast_v1l(v1l a)
Casts a v1l vector into a v8f vector.
v4l::v4l_cast_v1i
v4l v4l_cast_v1i(v1i a)
Casts a v1i vector into a v4l vector.
v4i::v4i_ones
v4i v4i_ones()
Sets all bits to 1.
v4i::v4i_reduce_and_v1i
v4i v4i_reduce_and_v1i(v1i a)
Reduction and ( & )
v8i::v8i_ornot
v8i v8i_ornot(v8i a, v8i b)
Bitwise ornot ( a | ~b )
v1d::m1d_neq
m1d m1d_neq(v1d a, v1d b)
Compares the inequality of the two input vectors.
v4l::v4l_blend4x1
v4l v4l_blend4x1(v4l a, v4l b, uint_fast8_t mask)
Creates a new v4l vector whose elements are from a and b choosed by mask.
v8i::v8i_hshuffle4
v8i v8i_hshuffle4(v8i a, v8i b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v4l::v4l_cast_v1l
v4l v4l_cast_v1l(v1l a)
Casts a v1l vector into a v4l vector.
v8l::v8l_cast_v8l
v8l v8l_cast_v8l(v8l a)
Casts a v8l vector into a v8l vector.
v1l::m1l_cvt_v1l
m1l m1l_cvt_v1l(v1l a)
Converts a v1l vector into a m1l vector-mask.
v1f::v1f_reduce_mul_v1f
v1f v1f_reduce_mul_v1f(v1f a)
Reduction mul ( * )
v8l::v8l_cast_m8l
v8l v8l_cast_m8l(m8l a)
Casts a m8l vector-mask into a v8l vector.
v16i::si_reduce_max_v16i
v16i si_reduce_max_v16i(v16i a)
Reduction max ( max )
v16i::v16i_set1
v16i v16i_set1(int32_t v)
Broadcasts a single value into all elements of a v16i vector.
v1f::v1f_cvt_v1f
v1f v1f_cvt_v1f(v1f a)
Converts a v1f vector into a v1f vector.
v8f::v8f_cast_v1f
v8f v8f_cast_v1f(v1f a)
Casts a v1f vector into a v8f vector.
v8l::v8l_cvt_v1l
v8l v8l_cvt_v1l(v1l a)
Converts a v1l vector into a v8l vector.
v2d::v2d_neq
v2d v2d_neq(v2d a, v2d b)
Compares the inequality of the two input vectors.
v4l::v4l_gt
v4l v4l_gt(v4l a, v4l b)
Compares if elements of a are greater than those of b.
v1f::v1f_cvt_v4l
v1f v1f_cvt_v4l(v4l a)
Converts a v4l vector into a v1f vector.
v1d::v1d_one
v1d v1d_one()
Sets all elements to 1.
v2i::v2i_rset
v2i v2i_rset(int32_t v1, int32_t v0)
Sets the elements of a v2i vector (reverse order).
v4d::v4d_hshuffle4
v4d v4d_hshuffle4(v4d a, v4d b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v16f::v16f_frcp
v16f v16f_frcp(v16f a)
Fast elementwise reciprocal ( 1 / a )
v1f::sf_cvt_v8d
float sf_cvt_v8d(v8d a)
Converts the first value of a v8d vector into float.
v1f::v1f_reduce_max_v4f
v1f v1f_reduce_max_v4f(v4f a)
Reduction max ( max )
v4f::v4f_andnot
v4f v4f_andnot(v4f a, v4f b)
Bitwise andnot ( a & ~b )
v1l::v1l_cvt_v8f
v1l v1l_cvt_v8f(v8f a)
Converts a v8f vector into a v1l vector.
v1i::v1i_cvt_v1i
v1i v1i_cvt_v1i(v1i a)
Converts a v1i vector into a v1i vector.
v1d::m1d_and
m1d m1d_and(m1d a, m1d b)
Bitwise and ( a & b )
v8i::v8i_blend4x2
v8i v8i_blend4x2(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v4l::m4l_cvt_m4d
m4l m4l_cvt_m4d(m4d a)
Converts a m4d vector-mask into a m4l vector-mask.
v2f::v2f_fshuffle2x1
v2f v2f_fshuffle2x1(v2f a, v2f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8l::v8l_set_low_v4l
v8l v8l_set_low_v4l(v8l src, v4l low)
Sets the low part of a v8l vector.
v8l::m8l_xor
m8l m8l_xor(m8l a, m8l b)
Bitwise xor ( a ^ b )
v1l::v1l_rprint
void v1l_rprint(v1l a)
Prints a v1l vector (reversed order)
v1f::v1f_reduce_mul_v4f
v1f v1f_reduce_mul_v4f(v4f a)
Reduction mul ( * )
v8f::v8f_blend8
v8f v8f_blend8(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v4f::v4f_hshuffle
v4f v4f_hshuffle(v4f a, v4f b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v8f::v8f_set_hilo_v4f
v8f v8f_set_hilo_v4f(v8f src, v4f a, int high)
Conditionally sets the low or the high part of a v8f vector.
v4i::v4i_div
v4i v4i_div(v4i a, v4i b)
Elementwise division ( a / b )
v1i::v1i_reduce_min_v1i
v1i v1i_reduce_min_v1i(v1i a)
Reduction min ( min )
v4i::v4i_reduce_or_v4i
v4i v4i_reduce_or_v4i(v4i a)
Reduction or ( | )
v2f::v2f_permute
v2f v2f_permute(v2f a, uint_fast8_t rule)
Shuffles a using the control in rule.
v8l::v8l_cast_v16f
v8l v8l_cast_v16f(v16f a)
Casts a v16f vector into a v8l vector.
v4i::v4i_cvt_v2f
v4i v4i_cvt_v2f(v2f a)
Converts a v2f vector into a v4i vector.
v1i::v1i_reduce_mul_v8i
v1i v1i_reduce_mul_v8i(v8i a)
Reduction mul ( * )
v2l::v2l_zeros
v2l v2l_zeros()
Sets all bits to 0.
v2f::m2f_cast_v2f
m2f m2f_cast_v2f(v2f a)
Casts a v2f vector into a m2f vector-mask.
v2i::v2i_cvt_v4i
v2i v2i_cvt_v4i(v4i a)
Converts a v4i vector into a v2i vector.
v4d::v4d_reduce_min_v8d
v4d v4d_reduce_min_v8d(v8d a)
Reduction min ( min )
v4f::v4f_nand
v4f v4f_nand(v4f a, v4f b)
Bitwise nand ( ~(a & b) )
v4i::v4i_merge4_v1i
v4i v4i_merge4_v1i(v1i a0, v1i a1, v1i a2, v1i a3)
Merges 4 v1i vectors together.
v2d::v2d_cast_v16f
v2d v2d_cast_v16f(v16f a)
Casts a v16f vector into a v2d vector.
v2f::v2f_lt
v2f v2f_lt(v2f a, v2f b)
Compares if elements of a are less than those of b.
v4d::v4d_reduce_add_v1d
v4d v4d_reduce_add_v1d(v1d a)
Reduction add ( + )
v4f::v4f_merge4_v1f
v4f v4f_merge4_v1f(v1f a0, v1f a1, v1f a2, v1f a3)
Merges 4 v1f vectors together.
v2i::v2i_hshuffle
v2i v2i_hshuffle(v2i a, v2i b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v8d::v8d_rmerge_v4d
v8d v8d_rmerge_v4d(v4d high, v4d low)
Merges 2 v4d vectors together (reversed order).
v8l::v8l_reduce_min_v1l
v8l v8l_reduce_min_v1l(v1l a)
Reduction min ( min )
v1f::v1f_cvt_v2f
v1f v1f_cvt_v2f(v2f a)
Converts a v2f vector into a v1f vector.
v1i::v1i_max
v1i v1i_max(v1i a, v1i b)
Elementwise max ( a > b ? a : b )
v1d::sd_cvt_v16f
double sd_cvt_v16f(v16f a)
Converts the first value of a v16f vector into double.
v2d::v2d_cvt_v8i
v2d v2d_cvt_v8i(v8i a)
Converts a v8i vector into a v2d vector.
v1l::m1l_nand
m1l m1l_nand(m1l a, m1l b)
Bitwise nand ( ~(a & b) )
v2l::v2l_eq
v2l v2l_eq(v2l a, v2l b)
Compares the equality of the two input vectors.
v2i::v2i_cast_v8f
v2i v2i_cast_v8f(v8f a)
Casts a v8f vector into a v2i vector.
v8i::v8i_blend4
v8i v8i_blend4(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v16f::v16f_hshuffle2
v16f v16f_hshuffle2(v16f a, v16f b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v4f::v4f_rprint
void v4f_rprint(v4f a)
Prints a v4f vector (reversed order)
v8f::v8f_reduce_mul_v8f
v8f v8f_reduce_mul_v8f(v8f a)
Reduction mul ( * )
v8f::v8f_maskz_move
v8f v8f_maskz_move(m8f mask, v8f a)
Mask the input.
v1i::v1i_rcp
v1i v1i_rcp(v1i a)
Elementwise reciprocal ( 1 / a )
v16i::m16i_andnot
m16i m16i_andnot(m16i a, m16i b)
Bitwise andnot ( a & ~b )
m2l
Type for the manipulation of vector-masks.
Definition: pints-doc.h:352
v4i::v4i_reduce_or_v1i
v4i v4i_reduce_or_v1i(v1i a)
Reduction or ( | )
v16f::m16f_neq
m16f m16f_neq(v16f a, v16f b)
Compares the inequality of the two input vectors.
v4f::m4f_xor
m4f m4f_xor(m4f a, m4f b)
Bitwise xor ( a ^ b )
v4f::v4f_cast_v8i
v4f v4f_cast_v8i(v8i a)
Casts a v8i vector into a v4f vector.
v1d::v1d_reduce_or_v4d
v1d v1d_reduce_or_v4d(v4d a)
Reduction or ( | )
v1l::v1l_cvt_v2f
v1l v1l_cvt_v2f(v2f a)
Converts a v2f vector into a v1l vector.
v1f::v1f_reduce_add_v4f
v1f v1f_reduce_add_v4f(v4f a)
Reduction add ( + )
v2i::v2i_reduce_min_v16i
v2i v2i_reduce_min_v16i(v16i a)
Reduction min ( min )
v4l::v4l_cast_v16f
v4l v4l_cast_v16f(v16f a)
Casts a v16f vector into a v4l vector.
v1l::sl_reduce_or_v1l
v1l sl_reduce_or_v1l(v1l a)
Reduction or ( | )
v2i::v2i_or
v2i v2i_or(v2i a, v2i b)
Bitwise or ( a | b )
v8i::v8i_cvt_m8i
v8i v8i_cvt_m8i(m8i a)
Converts a m8i vector-mask into a v8i vector.
v8l::v8l_cast_v1f
v8l v8l_cast_v1f(v1f a)
Casts a v1f vector into a v8l vector.
v8f::v8f_reduce_min_v2f
v8f v8f_reduce_min_v2f(v2f a)
Reduction min ( min )
v4l::v4l_print
void v4l_print(v4l a)
Prints a v4l vector.
v16f::v16f_reduce_add_v4f
v16f v16f_reduce_add_v4f(v4f a)
Reduction add ( + )
v1d::v1d_nxor
v1d v1d_nxor(v1d a, v1d b)
Bitwise nxor ( ~(a ^ b) )
v2i::v2i_loadu
v2i v2i_loadu(const int32_t *p)
Loads 2 int32_t from memory into a v2i vector.
v16i::v16i_print
void v16i_print(v16i a)
Prints a v16i vector.
v1i::v1i_reduce_and_v16i
v1i v1i_reduce_and_v16i(v16i a)
Reduction and ( & )
v4i::v4i_gt
v4i v4i_gt(v4i a, v4i b)
Compares if elements of a are greater than those of b.
v8l::v8l_printf
void v8l_printf(v8l a, const char *format)
Prints a v8l vector.
v2l::v2l_mul
v2l v2l_mul(v2l a, v2l b)
Elementwise multiplication ( a * b )
v1i::m1i_geq
m1i m1i_geq(v1i a, v1i b)
Compares if elements of a are greater than or equal to those of b.
v4d::v4d_fnmadd
v4d v4d_fnmadd(v4d a, v4d b, v4d acc)
Fused Multiply-Add ( -(a * b) + acc )
v1l::v1l_abs
v1l v1l_abs(v1l a)
Elementwise absolute value ( a > 0 ? a : -a )
m16i
Type for the manipulation of vector-masks.
Definition: pints-doc.h:752
v2f::v2f_reduce_or_v8f
v2f v2f_reduce_or_v8f(v8f a)
Reduction or ( | )
v2l::v2l_lt
v2l v2l_lt(v2l a, v2l b)
Compares if elements of a are less than those of b.
v2d::v2d_cvt_v16f
v2d v2d_cvt_v16f(v16f a)
Converts a v16f vector into a v2d vector.
v4l::v4l_blend1
v4l v4l_blend1(v4l a, v4l b, uint_fast8_t mask)
Creates a new v4l vector whose elements are from a and b choosed by mask.
v8f::m8f_cvt_m8d
m8f m8f_cvt_m8d(m8d a)
Converts a m8d vector-mask into a m8f vector-mask.
v16i::v16i_cvt_v4f
v16i v16i_cvt_v4f(v4f a)
Converts a v4f vector into a v16i vector.
v16f::v16f_reduce_max
v16f v16f_reduce_max(v16f a)
Reduction max ( max )
v2i::v2i_cvt_v8d
v2i v2i_cvt_v8d(v8d a)
Converts a v8d vector into a v2i vector.
v1i::m1i_lt
m1i m1i_lt(v1i a, v1i b)
Compares if elements of a are less than those of b.
v4d::m4d_cvt_m4l
m4d m4d_cvt_m4l(m4l a)
Converts a m4l vector-mask into a m4d vector-mask.
v16f::v16f_cvt_m16f
v16f v16f_cvt_m16f(m16f a)
Converts a m16f vector-mask into a v16f vector.
v2f::sf_reduce_max_v2f
v2f sf_reduce_max_v2f(v2f a)
Reduction max ( max )
v8d::v8d_cvt_v4d
v8d v8d_cvt_v4d(v4d a)
Converts a v4d vector into a v8d vector.
v1d::v1d_store
void v1d_store(double *p, v1d a)
Stores a v1d vector into memory.
v1i::v1i_permute
v1i v1i_permute(v1i a, uint_fast8_t rule)
Shuffles a using the control in rule.
v1i::v1i_reduce_add_v1i
v1i v1i_reduce_add_v1i(v1i a)
Reduction add ( + )
v8f::v8f_fprintf
void v8f_fprintf(FILE *file, v8f a, const char *format)
Prints a v8f vector.
v4i::v4i_hshuffle2x2
v4i v4i_hshuffle2x2(v4i a, v4i b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v1f::v1f_div
v1f v1f_div(v1f a, v1f b)
Elementwise division ( a / b )
v4i::v4i_cvt_v1i
v4i v4i_cvt_v1i(v1i a)
Converts a v1i vector into a v4i vector.
v8i::v8i_cvt_v4i
v8i v8i_cvt_v4i(v4i a)
Converts a v4i vector into a v8i vector.
v4d::v4d_set1
v4d v4d_set1(double v)
Broadcasts a single value into all elements of a v4d vector.
v2l::v2l_loadu
v2l v2l_loadu(const int64_t *p)
Loads 2 int64_t from memory into a v2l vector.
v2f::v2f_nxor
v2f v2f_nxor(v2f a, v2f b)
Bitwise nxor ( ~(a ^ b) )
v2f::v2f_cvt_v8f
v2f v2f_cvt_v8f(v8f a)
Converts a v8f vector into a v2f vector.
v16i::v16i_merge4_v4i
v16i v16i_merge4_v4i(v4i a0, v4i a1, v4i a2, v4i a3)
Merges 4 v4i vectors together.
v4i::v4i_cvt_v16f
v4i v4i_cvt_v16f(v16f a)
Converts a v16f vector into a v4i vector.
v2l::v2l_reduce_min_v8l
v2l v2l_reduce_min_v8l(v8l a)
Reduction min ( min )
v4i::v4i_set_low_v2i
v4i v4i_set_low_v2i(v4i src, v2i low)
Sets the low part of a v4i vector.
v1l::m1l_nor
m1l m1l_nor(m1l a, m1l b)
Bitwise nor ( ~(a | b) )
v2d::v2d_rprint
void v2d_rprint(v2d a)
Prints a v2d vector (reversed order)
v16f::v16f_fshuffle2
v16f v16f_fshuffle2(v16f a, v16f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2f::v2f_set1
v2f v2f_set1(float v)
Broadcasts a single value into all elements of a v2f vector.
v8l::m8l_cvt_m8l
m8l m8l_cvt_m8l(m8l a)
Converts a m8l vector-mask into a m8l vector-mask.
v4d::v4d_cast_v1i
v4d v4d_cast_v1i(v1i a)
Casts a v1i vector into a v4d vector.
v4f::v4f_rsqrt
v4f v4f_rsqrt(v4f a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v8l::v8l_or
v8l v8l_or(v8l a, v8l b)
Bitwise or ( a | b )
v8f::v8f_nor
v8f v8f_nor(v8f a, v8f b)
Bitwise nor ( ~(a | b) )
v2d::v2d_cvt_v4l
v2d v2d_cvt_v4l(v4l a)
Converts a v4l vector into a v2d vector.
v4l::v4l_storeu
void v4l_storeu(int64_t *p, v4l a)
Stores a v4l vector into memory.
v8i::v8i_fshuffle
v8i v8i_fshuffle(v8i a, v8i b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8d::v8d_cast_v8f
v8d v8d_cast_v8f(v8f a)
Casts a v8f vector into a v8d vector.
v8l::v8l_fshuffle8x1
v8l v8l_fshuffle8x1(v8l a, v8l b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v16i::v16i_permute4x4
v16i v16i_permute4x4(v16i a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v8i::v8i_reduce_mul_v4i
v8i v8i_reduce_mul_v4i(v4i a)
Reduction mul ( * )
v8i::v8i_blend2x4
v8i v8i_blend2x4(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v16i::v16i_rmerge8_v2i
v16i v16i_rmerge8_v2i(v2i a7, v2i a6, v2i a5, v2i a4, v2i a3, v2i a2, v2i a1, v2i a0)
Merges 8 v2i vectors together (reverse order).
v4f::v4f_rmerge_v2f
v4f v4f_rmerge_v2f(v2f high, v2f low)
Merges 2 v2f vectors together (reversed order).
v4f::v4f_reduce_and_v1f
v4f v4f_reduce_and_v1f(v1f a)
Reduction and ( & )
v4d::v4d_reduce_max_v2d
v4d v4d_reduce_max_v2d(v2d a)
Reduction max ( max )
v1l::v1l_cvt_v2d
v1l v1l_cvt_v2d(v2d a)
Converts a v2d vector into a v1l vector.
v8l::v8l_permute4
v8l v8l_permute4(v8l a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v2l::v2l_ones
v2l v2l_ones()
Sets all bits to 1.
v1d::v1d_permute
v1d v1d_permute(v1d a, uint_fast8_t rule)
Shuffles a using the control in rule.
v4d::v4d_cast_v8f
v4d v4d_cast_v8f(v8f a)
Casts a v8f vector into a v4d vector.
v2i::v2i_ornot
v2i v2i_ornot(v2i a, v2i b)
Bitwise ornot ( a | ~b )
v2i::v1i_get_high_v2i
v1i v1i_get_high_v2i(v2i a)
Gets the high part of a v2i vector.
v2f::v2f_cast_v16f
v2f v2f_cast_v16f(v16f a)
Casts a v16f vector into a v2f vector.
v1l::v1l_reduce_and_v8l
v1l v1l_reduce_and_v8l(v8l a)
Reduction and ( & )
v4i::v4i_leq
v4i v4i_leq(v4i a, v4i b)
Compares if elements of a are less than or equal to those of b.
v8f::m8f_gt
m8f m8f_gt(v8f a, v8f b)
Compares if elements of a are greater than those of b.
v4d::v4d_cast_v4l
v4d v4d_cast_v4l(v4l a)
Casts a v4l vector into a v4d vector.
v1f::v1f_permute
v1f v1f_permute(v1f a, uint_fast8_t rule)
Shuffles a using the control in rule.
v4i::v4i_cast_v8d
v4i v4i_cast_v8d(v8d a)
Casts a v8d vector into a v4i vector.
v1f::v1f_cast_v8f
v1f v1f_cast_v8f(v8f a)
Casts a v8f vector into a v1f vector.
v8d::m8d_cast_v8d
m8d m8d_cast_v8d(v8d a)
Casts a v8d vector into a m8d vector-mask.
v4d::v4d_reduce_add_v8d
v4d v4d_reduce_add_v8d(v8d a)
Reduction add ( + )
v2f::v2f_reduce_and_v8f
v2f v2f_reduce_and_v8f(v8f a)
Reduction and ( & )
v1i::v1i_maskz_move
v1i v1i_maskz_move(m1i mask, v1i a)
Mask the input.
v8f::v8f_rprintf
void v8f_rprintf(v8f a, const char *format)
Prints a v8f vector (reversed order)
v16f::v16f_cast_v8d
v16f v16f_cast_v8d(v8d a)
Casts a v8d vector into a v16f vector.
v1l::v1l_sub
v1l v1l_sub(v1l a, v1l b)
Elementwise subtraction ( a - b )
v8l::m8l_cvt_m8f
m8l m8l_cvt_m8f(m8f a)
Converts a m8f vector-mask into a m8l vector-mask.
v2d::v2d_reduce_or_v4d
v2d v2d_reduce_or_v4d(v4d a)
Reduction or ( | )
v1f::v1f_gt
v1f v1f_gt(v1f a, v1f b)
Compares if elements of a are greater than those of b.
v4i::v4i_cvt_v1l
v4i v4i_cvt_v1l(v1l a)
Converts a v1l vector into a v4i vector.
v1l::m1l_ornot
m1l m1l_ornot(m1l a, m1l b)
Bitwise ornot ( a | ~b )
v1d::v1d_reduce_add_v4d
v1d v1d_reduce_add_v4d(v4d a)
Reduction add ( + )
v2i::v2i_fshuffle2
v2i v2i_fshuffle2(v2i a, v2i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8i::v8i_reduce_add_v16i
v8i v8i_reduce_add_v16i(v16i a)
Reduction add ( + )
v1f::v1f_max
v1f v1f_max(v1f a, v1f b)
Elementwise max ( a > b ? a : b )
v1l::v1l_eq
v1l v1l_eq(v1l a, v1l b)
Compares the equality of the two input vectors.
v2l::m2l_gt
m2l m2l_gt(v2l a, v2l b)
Compares if elements of a are greater than those of b.
v16f::v16f_rfprint
void v16f_rfprint(FILE *file, v16f a)
Prints a v16f vector (reversed order)
v8d::v8d_min
v8d v8d_min(v8d a, v8d b)
Elementwise min ( a < b ? a : b )
v2l::m2l_xor
m2l m2l_xor(m2l a, m2l b)
Bitwise xor ( a ^ b )
v4l::m4l_or
m4l m4l_or(m4l a, m4l b)
Bitwise or ( a | b )
v2l
Type for the manipulation of 2 int64_t packed into one single vector.
Definition: pints-doc.h:331
v4i::v4i_reduce_mul
v4i v4i_reduce_mul(v4i a)
Reduction mul ( * )
v8f::v8f_reduce_max_v4f
v8f v8f_reduce_max_v4f(v4f a)
Reduction max ( max )
v2d::v2d_reduce_min_v1d
v2d v2d_reduce_min_v1d(v1d a)
Reduction min ( min )
v4d::v4d_permute2x2
v4d v4d_permute2x2(v4d a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v4i::v4i_lt
v4i v4i_lt(v4i a, v4i b)
Compares if elements of a are less than those of b.
v1i::v1i_cvt_v16i
v1i v1i_cvt_v16i(v16i a)
Converts a v16i vector into a v1i vector.
v2d::m2d_cvt_m2i
m2d m2d_cvt_m2i(m2i a)
Converts a m2i vector-mask into a m2d vector-mask.
v8i::v8i_neg
v8i v8i_neg(v8i a)
Elementwise negation ( -a )
v2f::v2f_cast_m2f
v2f v2f_cast_m2f(m2f a)
Casts a m2f vector-mask into a v2f vector.
v2i::m2i_lt
m2i m2i_lt(v2i a, v2i b)
Compares if elements of a are less than those of b.
v16i::v16i_cast_v4i
v16i v16i_cast_v4i(v4i a)
Casts a v4i vector into a v16i vector.
v4d::v4d_cvt_v4d
v4d v4d_cvt_v4d(v4d a)
Converts a v4d vector into a v4d vector.
v1i::v1i_add
v1i v1i_add(v1i a, v1i b)
Elementwise addition ( a + b )
v4d::v4d_cast_v2i
v4d v4d_cast_v2i(v2i a)
Casts a v2i vector into a v4d vector.
v1d::v1d_zeros
v1d v1d_zeros()
Sets all bits to 0.
v4d::v4d_reduce_max
v4d v4d_reduce_max(v4d a)
Reduction max ( max )
v2f::v2f_merge2_v1f
v2f v2f_merge2_v1f(v1f a0, v1f a1)
Merges 2 v1f vectors together.
v2i::m2i_gt
m2i m2i_gt(v2i a, v2i b)
Compares if elements of a are greater than those of b.
v4i::v4i_printf
void v4i_printf(v4i a, const char *format)
Prints a v4i vector.
v1d::sd_reduce_mul_v1d
v1d sd_reduce_mul_v1d(v1d a)
Reduction mul ( * )
v16i::v16i_rprint
void v16i_rprint(v16i a)
Prints a v16i vector (reversed order)
v2d::v2d_rfprint
void v2d_rfprint(FILE *file, v2d a)
Prints a v2d vector (reversed order)
v1f::v1f_cvt_v2l
v1f v1f_cvt_v2l(v2l a)
Converts a v2l vector into a v1f vector.
v1d::v1d_cvt_v1l
v1d v1d_cvt_v1l(v1l a)
Converts a v1l vector into a v1d vector.
v4d::m4d_nxor
m4d m4d_nxor(m4d a, m4d b)
Bitwise nxor ( ~(a ^ b) )
v1d::m1d_geq
m1d m1d_geq(v1d a, v1d b)
Compares if elements of a are greater than or equal to those of b.
v2l::v2l_load
v2l v2l_load(const int64_t *p)
Loads 2 int64_t from memory into a v2l vector.
v2i::v2i_cast_v4l
v2i v2i_cast_v4l(v4l a)
Casts a v4l vector into a v2i vector.
v8f::v8f_cvt_m8f
v8f v8f_cvt_m8f(m8f a)
Converts a m8f vector-mask into a v8f vector.
v4f::m4f_neq
m4f m4f_neq(v4f a, v4f b)
Compares the inequality of the two input vectors.
v1i::si_cvt_v2l
int32_t si_cvt_v2l(v2l a)
Converts the first value of a v2l vector into int32_t.
v8d::v8d_rfprintf
void v8d_rfprintf(FILE *file, v8d a, const char *format)
Prints a v8d vector (reversed order)
v8l::v8l_nand
v8l v8l_nand(v8l a, v8l b)
Bitwise nand ( ~(a & b) )
v1d::m1d_nand
m1d m1d_nand(m1d a, m1d b)
Bitwise nand ( ~(a & b) )
v4l::v2l_get_hilo_v4l
v2l v2l_get_hilo_v4l(v4l a, int high)
Conditionnaly gets the low or the high part of a v4l vector.
v1d::v1d_cast_v16i
v1d v1d_cast_v16i(v16i a)
Casts a v16i vector into a v1d vector.
v4f::v4f_cast_v16f
v4f v4f_cast_v16f(v16f a)
Casts a v16f vector into a v4f vector.
v2f::m2f_cvt_m2d
m2f m2f_cvt_m2d(m2d a)
Converts a m2d vector-mask into a m2f vector-mask.
v16i::v16i_reduce_add_v4i
v16i v16i_reduce_add_v4i(v4i a)
Reduction add ( + )
v4i::v4i_nor
v4i v4i_nor(v4i a, v4i b)
Bitwise nor ( ~(a | b) )
v16i::v16i_cast_v16f
v16i v16i_cast_v16f(v16f a)
Casts a v16f vector into a v16i vector.
v16f::v16f_cvt_v4i
v16f v16f_cvt_v4i(v4i a)
Converts a v4i vector into a v16f vector.
v2l::v2l_set
v2l v2l_set(int64_t v0, int64_t v1)
Sets the elements of a v2l vector.
v8l::v8l_hshuffle4x2
v8l v8l_hshuffle4x2(v8l a, v8l b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v8d::m8d_cvt_m8f
m8d m8d_cvt_m8f(m8f a)
Converts a m8f vector-mask into a m8d vector-mask.
v1f::v1f_cvt_v4d
v1f v1f_cvt_v4d(v4d a)
Converts a v4d vector into a v1f vector.
v8l::m8l_and
m8l m8l_and(m8l a, m8l b)
Bitwise and ( a & b )
v4f::v4f_cast_v2i
v4f v4f_cast_v2i(v2i a)
Casts a v2i vector into a v4f vector.
v2d::m2d_nxor
m2d m2d_nxor(m2d a, m2d b)
Bitwise nxor ( ~(a ^ b) )
v2l::sl_reduce_max_v2l
v2l sl_reduce_max_v2l(v2l a)
Reduction max ( max )
v4d::v4d_andnot
v4d v4d_andnot(v4d a, v4d b)
Bitwise andnot ( a & ~b )
v16f::v16f_add
v16f v16f_add(v16f a, v16f b)
Elementwise addition ( a + b )
v4i::v4i_neg
v4i v4i_neg(v4i a)
Elementwise negation ( -a )
v1d::v1d_cvt_v4f
v1d v1d_cvt_v4f(v4f a)
Converts a v4f vector into a v1d vector.
v1f::v1f_cvt_v2i
v1f v1f_cvt_v2i(v2i a)
Converts a v2i vector into a v1f vector.
v2f::v2f_one
v2f v2f_one()
Sets all elements to 1.
v8i::v8i_reduce_mul_v16i
v8i v8i_reduce_mul_v16i(v16i a)
Reduction mul ( * )
v4i::m4i_ornot
m4i m4i_ornot(m4i a, m4i b)
Bitwise ornot ( a | ~b )
v8f::v8f_set1
v8f v8f_set1(float v)
Broadcasts a single value into all elements of a v8f vector.
v1d::m1d_cvt_m1d
m1d m1d_cvt_m1d(m1d a)
Converts a m1d vector-mask into a m1d vector-mask.
v1d::v1d_reduce_or_v8d
v1d v1d_reduce_or_v8d(v8d a)
Reduction or ( | )
v4d::v4d_merge_v2d
v4d v4d_merge_v2d(v2d low, v2d high)
Merges 2 v2d vectors together.
v2f::v2f_blend1
v2f v2f_blend1(v2f a, v2f b, uint_fast8_t mask)
Creates a new v2f vector whose elements are from a and b choosed by mask.
v1d::v1d_cvt_v4d
v1d v1d_cvt_v4d(v4d a)
Converts a v4d vector into a v1d vector.
v8d::v8d_cvt_v16f
v8d v8d_cvt_v16f(v16f a)
Converts a v16f vector into a v8d vector.
v8f::v4f_get_hilo_v8f
v4f v4f_get_hilo_v8f(v8f a, int high)
Conditionnaly gets the low or the high part of a v8f vector.
v16i
Type for the manipulation of 16 int32_t packed into one single vector.
Definition: pints-doc.h:731
v16f::v16f_ornot
v16f v16f_ornot(v16f a, v16f b)
Bitwise ornot ( a | ~b )
v2d::v2d_cast_v8i
v2d v2d_cast_v8i(v8i a)
Casts a v8i vector into a v2d vector.
v2l::v2l_reduce_mul_v2l
v2l v2l_reduce_mul_v2l(v2l a)
Reduction mul ( * )
v4f::v4f_reduce_mul_v1f
v4f v4f_reduce_mul_v1f(v1f a)
Reduction mul ( * )
v1i::v1i_print
void v1i_print(v1i a)
Prints a v1i vector.
v4l::v4l_zero
v4l v4l_zero()
Sets all elements to 0.
v8l::v8l_nor
v8l v8l_nor(v8l a, v8l b)
Bitwise nor ( ~(a | b) )
v4l::v4l_printf
void v4l_printf(v4l a, const char *format)
Prints a v4l vector.
v1i::v1i_blend1
v1i v1i_blend1(v1i a, v1i b, uint_fast8_t mask)
Creates a new v1i vector whose elements are from a and b choosed by mask.
v16i::v16i_merge2_v8i
v16i v16i_merge2_v8i(v8i a0, v8i a1)
Merges 2 v8i vectors together.
v8l::v8l_cast_v8f
v8l v8l_cast_v8f(v8f a)
Casts a v8f vector into a v8l vector.
v16f::v16f_hshuffle2x8
v16f v16f_hshuffle2x8(v16f a, v16f b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v8d::v8d_leq
v8d v8d_leq(v8d a, v8d b)
Compares if elements of a are less than or equal to those of b.
v1f::v1f_reduce_add
v1f v1f_reduce_add(v1f a)
Reduction add ( + )
v1d::v1d_not
v1d v1d_not(v1d a)
Bitwise not ( ~a )
v4i::m4i_cvt_m4d
m4i m4i_cvt_m4d(m4d a)
Converts a m4d vector-mask into a m4i vector-mask.
v8f::v8f_hshuffle4x2
v8f v8f_hshuffle4x2(v8f a, v8f b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v1d::v1d_cvt_v1f
v1d v1d_cvt_v1f(v1f a)
Converts a v1f vector into a v1d vector.
v8d::v8d_set
v8d v8d_set(double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7)
Sets the elements of a v8d vector.
v8l::v8l_storeu
void v8l_storeu(int64_t *p, v8l a)
Stores a v8l vector into memory.
v8d::v8d_merge_v4d
v8d v8d_merge_v4d(v4d low, v4d high)
Merges 2 v4d vectors together.
v2d::v2d_cvt_v8d
v2d v2d_cvt_v8d(v8d a)
Converts a v8d vector into a v2d vector.
v16i::si_reduce_mul_v16i
v16i si_reduce_mul_v16i(v16i a)
Reduction mul ( * )
v8i::v8i_geq
v8i v8i_geq(v8i a, v8i b)
Compares if elements of a are greater than or equal to those of b.
v2l::v2l_cvt_v8l
v2l v2l_cvt_v8l(v8l a)
Converts a v8l vector into a v2l vector.
v1d::v1d_cvt_v8l
v1d v1d_cvt_v8l(v8l a)
Converts a v8l vector into a v1d vector.
v8l::v8l_sqrt
v8l v8l_sqrt(v8l a)
Elementwise square root ( sqrt(a) )
v1d::v1d_cvt_v2l
v1d v1d_cvt_v2l(v2l a)
Converts a v2l vector into a v1d vector.
v4i::v4i_reduce_add_v8i
v4i v4i_reduce_add_v8i(v8i a)
Reduction add ( + )
v4f::v4f_zeros
v4f v4f_zeros()
Sets all bits to 0.
v1i::m1i_nxor
m1i m1i_nxor(m1i a, m1i b)
Bitwise nxor ( ~(a ^ b) )
v1i::v1i_loadu
v1i v1i_loadu(const int32_t *p)
Loads 1 int32_t from memory into a v1i vector.
v8i::v8i_reduce_max_v16i
v8i v8i_reduce_max_v16i(v16i a)
Reduction max ( max )
v2l::v2l_xor
v2l v2l_xor(v2l a, v2l b)
Bitwise xor ( a ^ b )
v8d::v8d_fprintf
void v8d_fprintf(FILE *file, v8d a, const char *format)
Prints a v8d vector.
v2i::si_reduce_or_v2i
v2i si_reduce_or_v2i(v2i a)
Reduction or ( | )
v8l::v8l_geq
v8l v8l_geq(v8l a, v8l b)
Compares if elements of a are greater than or equal to those of b.
v1i::v1i_ones
v1i v1i_ones()
Sets all bits to 1.
v8d::v8d_cast_v4i
v8d v8d_cast_v4i(v4i a)
Casts a v4i vector into a v8d vector.
v4f::v4f_reduce_or
v4f v4f_reduce_or(v4f a)
Reduction or ( | )
v1f::sf_cvt_v8f
float sf_cvt_v8f(v8f a)
Converts the first value of a v8f vector into float.
v2d::v2d_reduce_and
v2d v2d_reduce_and(v2d a)
Reduction and ( & )
v8i::v8i_merge8_v1i
v8i v8i_merge8_v1i(v1i a0, v1i a1, v1i a2, v1i a3, v1i a4, v1i a5, v1i a6, v1i a7)
Merges 8 v1i vectors together.
v4i::v4i_blend2x2
v4i v4i_blend2x2(v4i a, v4i b, uint_fast8_t mask)
Creates a new v4i vector whose elements are from a and b choosed by mask.
v2f::v2f_reduce_add
v2f v2f_reduce_add(v2f a)
Reduction add ( + )
v8i::v8i_print
void v8i_print(v8i a)
Prints a v8i vector.
v8d::v8d_cvt_v8i
v8d v8d_cvt_v8i(v8i a)
Converts a v8i vector into a v8d vector.
v8f::v8f_reduce_or_v16f
v8f v8f_reduce_or_v16f(v16f a)
Reduction or ( | )
v1d::v1d_loadu
v1d v1d_loadu(const double *p)
Loads 1 double from memory into a v1d vector.
v8l::v8l_permute2
v8l v8l_permute2(v8l a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v8i::v8i_mask_move
v8i v8i_mask_move(m8i mask, v8i src, v8i a)
Mask the input.
v8i::v8i_permute2x4
v8i v8i_permute2x4(v8i a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v4d::v4d_load
v4d v4d_load(const double *p)
Loads 4 double from memory into a v4d vector.
v1i::v1i_cvt_v1d
v1i v1i_cvt_v1d(v1d a)
Converts a v1d vector into a v1i vector.
v1i::v1i_or
v1i v1i_or(v1i a, v1i b)
Bitwise or ( a | b )
v1l::v1l_storeu
void v1l_storeu(int64_t *p, v1l a)
Stores a v1l vector into memory.
v4d::m4d_neq
m4d m4d_neq(v4d a, v4d b)
Compares the inequality of the two input vectors.
v8i::v8i_reduce_min_v8i
v8i v8i_reduce_min_v8i(v8i a)
Reduction min ( min )
v8f::v8f_cast_v16f
v8f v8f_cast_v16f(v16f a)
Casts a v16f vector into a v8f vector.
v16f::v16f_rsqrt
v16f v16f_rsqrt(v16f a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v2f::v2f_merge_v1f
v2f v2f_merge_v1f(v1f low, v1f high)
Merges 2 v1f vectors together.
v4d::v4d_reduce_and_v2d
v4d v4d_reduce_and_v2d(v2d a)
Reduction and ( & )
v8d::v8d_sub
v8d v8d_sub(v8d a, v8d b)
Elementwise subtraction ( a - b )
v1i::v1i_cast_v1l
v1i v1i_cast_v1l(v1l a)
Casts a v1l vector into a v1i vector.
v8f::v8f_cast_v8i
v8f v8f_cast_v8i(v8i a)
Casts a v8i vector into a v8f vector.
v1i::v1i_rfprintf
void v1i_rfprintf(FILE *file, v1i a, const char *format)
Prints a v1i vector (reversed order)
v2l::v2l_reduce_min
v2l v2l_reduce_min(v2l a)
Reduction min ( min )
v8l::v8l_fshuffle2
v8l v8l_fshuffle2(v8l a, v8l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8l::v8l_frcp
v8l v8l_frcp(v8l a)
Fast elementwise reciprocal ( 1 / a )
v2l::v2l_reduce_or_v4l
v2l v2l_reduce_or_v4l(v4l a)
Reduction or ( | )
v2d::v2d_cast_v4i
v2d v2d_cast_v4i(v4i a)
Casts a v4i vector into a v2d vector.
v8f::v8f_and
v8f v8f_and(v8f a, v8f b)
Bitwise and ( a & b )
m4d
Type for the manipulation of vector-masks.
Definition: pints-doc.h:392
v16f::v16f_xor
v16f v16f_xor(v16f a, v16f b)
Bitwise xor ( a ^ b )
v4d::v4d_rmerge_v2d
v4d v4d_rmerge_v2d(v2d high, v2d low)
Merges 2 v2d vectors together (reversed order).
v1l::v1l_printf
void v1l_printf(v1l a, const char *format)
Prints a v1l vector.
v4d::v4d_reduce_min
v4d v4d_reduce_min(v4d a)
Reduction min ( min )
v2i::v2i_reduce_mul_v16i
v2i v2i_reduce_mul_v16i(v16i a)
Reduction mul ( * )
v8i::v8i_cast_v8d
v8i v8i_cast_v8d(v8d a)
Casts a v8d vector into a v8i vector.
v4f::v4f_rmerge4_v1f
v4f v4f_rmerge4_v1f(v1f a3, v1f a2, v1f a1, v1f a0)
Merges 4 v1f vectors together (reverse order).
v1d::v1d_cast_v1d
v1d v1d_cast_v1d(v1d a)
Casts a v1d vector into a v1d vector.
v1f::v1f_zero
v1f v1f_zero()
Sets all elements to 0.
v8f::v8f_reduce_and_v1f
v8f v8f_reduce_and_v1f(v1f a)
Reduction and ( & )
v2d::v2d_ones
v2d v2d_ones()
Sets all bits to 1.
v4l::v4l_merge4_v1l
v4l v4l_merge4_v1l(v1l a0, v1l a1, v1l a2, v1l a3)
Merges 4 v1l vectors together.
v8l::v8l_reduce_and
v8l v8l_reduce_and(v8l a)
Reduction and ( & )
v1i::v1i_cvt_v8i
v1i v1i_cvt_v8i(v8i a)
Converts a v8i vector into a v1i vector.
v8l::v8l_hshuffle8x1
v8l v8l_hshuffle8x1(v8l a, v8l b, uint_fast32_t rule)
Shuffles (inner) a and b together using the control in rule.
v16f::m16f_cvt_m16f
m16f m16f_cvt_m16f(m16f a)
Converts a m16f vector-mask into a m16f vector-mask.
v2f::m2f_xor
m2f m2f_xor(m2f a, m2f b)
Bitwise xor ( a ^ b )
m16f
Type for the manipulation of vector-masks.
Definition: pints-doc.h:712
v1i::v1i_reduce_or
v1i v1i_reduce_or(v1i a)
Reduction or ( | )
v8l::v8l_print
void v8l_print(v8l a)
Prints a v8l vector.
v16i::m16i_nand
m16i m16i_nand(m16i a, m16i b)
Bitwise nand ( ~(a & b) )
v16f::m16f_cast_v16f
m16f m16f_cast_v16f(v16f a)
Casts a v16f vector into a m16f vector-mask.
v1l::v1l_reduce_min_v1l
v1l v1l_reduce_min_v1l(v1l a)
Reduction min ( min )
v4d::v4d_reduce_max_v4d
v4d v4d_reduce_max_v4d(v4d a)
Reduction max ( max )
v1l::v1l_reduce_add_v1l
v1l v1l_reduce_add_v1l(v1l a)
Reduction add ( + )
v8d::v8d_permute8x1
v8d v8d_permute8x1(v8d a, uint_fast32_t rule)
Shuffles (inner) a using the control in rule.
v8l::m8l_not
m8l m8l_not(m8l a)
Bitwise not ( ~a )
v1i::v1i_cast_v1d
v1i v1i_cast_v1d(v1d a)
Casts a v1d vector into a v1i vector.
v4l::v4l_cvt_v1l
v4l v4l_cvt_v1l(v1l a)
Converts a v1l vector into a v4l vector.
v2i::v2i_fshuffle2x1
v2i v2i_fshuffle2x1(v2i a, v2i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4f::v4f_reduce_min_v2f
v4f v4f_reduce_min_v2f(v2f a)
Reduction min ( min )
v4l::v4l_set
v4l v4l_set(int64_t v0, int64_t v1, int64_t v2, int64_t v3)
Sets the elements of a v4l vector.
v8i::v8i_reduce_max_v8i
v8i v8i_reduce_max_v8i(v8i a)
Reduction max ( max )
v8f::v8f_reduce_or_v1f
v8f v8f_reduce_or_v1f(v1f a)
Reduction or ( | )
v8i::v8i_set_hilo_v4i
v8i v8i_set_hilo_v4i(v8i src, v4i a, int high)
Conditionally sets the low or the high part of a v8i vector.
v4l::v4l_loadu
v4l v4l_loadu(const int64_t *p)
Loads 4 int64_t from memory into a v4l vector.
v2f::v2f_cvt_v1l
v2f v2f_cvt_v1l(v1l a)
Converts a v1l vector into a v2f vector.
v8i::v8i_cast_v2f
v8i v8i_cast_v2f(v2f a)
Casts a v2f vector into a v8i vector.
v4d::m4d_gt
m4d m4d_gt(v4d a, v4d b)
Compares if elements of a are greater than those of b.
v1i::v1i_abs
v1i v1i_abs(v1i a)
Elementwise absolute value ( a > 0 ? a : -a )
v4i::v4i_cast_v1f
v4i v4i_cast_v1f(v1f a)
Casts a v1f vector into a v4i vector.
m8l
Type for the manipulation of vector-masks.
Definition: pints-doc.h:672
v8d::v8d_blend4
v8d v8d_blend4(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v1l::sl_reduce_min_v1l
v1l sl_reduce_min_v1l(v1l a)
Reduction min ( min )
v16f::v16f_permute
v16f v16f_permute(v16f a, uint_fast64_t rule)
Shuffles a using the control in rule.
v2d::v2d_frcp
v2d v2d_frcp(v2d a)
Fast elementwise reciprocal ( 1 / a )
v8l::v8l_add
v8l v8l_add(v8l a, v8l b)
Elementwise addition ( a + b )
v16f::v16f_gt
v16f v16f_gt(v16f a, v16f b)
Compares if elements of a are greater than those of b.
v16f::v8f_get_low_v16f
v8f v8f_get_low_v16f(v16f a)
Gets the low part of a v16f vector.
v8d::v8d_set_low_v4d
v8d v8d_set_low_v4d(v8d src, v4d low)
Sets the low part of a v8d vector.
v2l::v2l_rmerge2_v1l
v2l v2l_rmerge2_v1l(v1l a1, v1l a0)
Merges 2 v1l vectors together (reverse order).
v2d::v2d_reduce_max_v1d
v2d v2d_reduce_max_v1d(v1d a)
Reduction max ( max )
v4f::v4f_cast_v1d
v4f v4f_cast_v1d(v1d a)
Casts a v1d vector into a v4f vector.
v4f::v4f_rfprintf
void v4f_rfprintf(FILE *file, v4f a, const char *format)
Prints a v4f vector (reversed order)
v16f::v16f_one
v16f v16f_one()
Sets all elements to 1.
v16i::v16i_zeros
v16i v16i_zeros()
Sets all bits to 0.
v16i::v16i_reduce_max_v16i
v16i v16i_reduce_max_v16i(v16i a)
Reduction max ( max )
v8l::v8l_min
v8l v8l_min(v8l a, v8l b)
Elementwise min ( a < b ? a : b )
v4d::v4d_frcp
v4d v4d_frcp(v4d a)
Fast elementwise reciprocal ( 1 / a )
v16i::v16i_cvt_v2l
v16i v16i_cvt_v2l(v2l a)
Converts a v2l vector into a v16i vector.
v16i::v16i_neq
v16i v16i_neq(v16i a, v16i b)
Compares the inequality of the two input vectors.
v2l::sl_reduce_min_v2l
v2l sl_reduce_min_v2l(v2l a)
Reduction min ( min )
v16f::v8f_get_hilo_v16f
v8f v8f_get_hilo_v16f(v16f a, int high)
Conditionnaly gets the low or the high part of a v16f vector.
v8l::v8l_blend1
v8l v8l_blend1(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v1d::v1d_fnmadd
v1d v1d_fnmadd(v1d a, v1d b, v1d acc)
Fused Multiply-Add ( -(a * b) + acc )
v4f::v4f_fshuffle2x2
v4f v4f_fshuffle2x2(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1i::v1i_one
v1i v1i_one()
Sets all elements to 1.
v8l::m8l_or
m8l m8l_or(m8l a, m8l b)
Bitwise or ( a | b )
v8f::sf_reduce_max_v8f
v8f sf_reduce_max_v8f(v8f a)
Reduction max ( max )
v8f::v8f_xor
v8f v8f_xor(v8f a, v8f b)
Bitwise xor ( a ^ b )
v8i::v8i_frsqrt
v8i v8i_frsqrt(v8i a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v2d::v2d_rset
v2d v2d_rset(double v1, double v0)
Sets the elements of a v2d vector (reverse order).
v1l::v1l_cast_v16i
v1l v1l_cast_v16i(v16i a)
Casts a v16i vector into a v1l vector.
v2d::m2d_cvt_v2d
m2d m2d_cvt_v2d(v2d a)
Converts a v2d vector into a m2d vector-mask.
v1l::m1l_cvt_m1l
m1l m1l_cvt_m1l(m1l a)
Converts a m1l vector-mask into a m1l vector-mask.
v2l::v2l_reduce_and_v4l
v2l v2l_reduce_and_v4l(v4l a)
Reduction and ( & )
v8i::v8i_store
void v8i_store(int32_t *p, v8i a)
Stores a v8i vector into memory.
m1d
Type for the manipulation of vector-masks.
Definition: pints-doc.h:72
v8i::v8i_nxor
v8i v8i_nxor(v8i a, v8i b)
Bitwise nxor ( ~(a ^ b) )
v8d::v8d_nxor
v8d v8d_nxor(v8d a, v8d b)
Bitwise nxor ( ~(a ^ b) )
v2i::v2i_reduce_or_v1i
v2i v2i_reduce_or_v1i(v1i a)
Reduction or ( | )
v1i::v1i_cast_v8d
v1i v1i_cast_v8d(v8d a)
Casts a v8d vector into a v1i vector.
v8l::v8l_reduce_add_v8l
v8l v8l_reduce_add_v8l(v8l a)
Reduction add ( + )
v2i::m2i_neq
m2i m2i_neq(v2i a, v2i b)
Compares the inequality of the two input vectors.
v1i::v1i_nxor
v1i v1i_nxor(v1i a, v1i b)
Bitwise nxor ( ~(a ^ b) )
v8f::m8f_geq
m8f m8f_geq(v8f a, v8f b)
Compares if elements of a are greater than or equal to those of b.
v4i::v4i_blend4x1
v4i v4i_blend4x1(v4i a, v4i b, uint_fast8_t mask)
Creates a new v4i vector whose elements are from a and b choosed by mask.
v8f::v8f_cast_v2d
v8f v8f_cast_v2d(v2d a)
Casts a v2d vector into a v8f vector.
v16f::m16f_xor
m16f m16f_xor(m16f a, m16f b)
Bitwise xor ( a ^ b )
v8f::v8f_storeu
void v8f_storeu(float *p, v8f a)
Stores a v8f vector into memory.
v4d::v4d_cast_v16i
v4d v4d_cast_v16i(v16i a)
Casts a v16i vector into a v4d vector.
v1f::v1f_fshuffle
v1f v1f_fshuffle(v1f a, v1f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1d::v1d_fmsub
v1d v1d_fmsub(v1d a, v1d b, v1d acc)
Fused Multiply-Sub ( (a * b) - acc )
v16i::v16i_rmerge_v8i
v16i v16i_rmerge_v8i(v8i high, v8i low)
Merges 2 v8i vectors together (reversed order).
v1l::v1l_cast_v1f
v1l v1l_cast_v1f(v1f a)
Casts a v1f vector into a v1l vector.
v1l::v1l_reduce_or
v1l v1l_reduce_or(v1l a)
Reduction or ( | )
v2i::v2i_and
v2i v2i_and(v2i a, v2i b)
Bitwise and ( a & b )
v4f::v4f_load
v4f v4f_load(const float *p)
Loads 4 float from memory into a v4f vector.
v4i::v4i_fmsub
v4i v4i_fmsub(v4i a, v4i b, v4i acc)
Fused Multiply-Sub ( (a * b) - acc )
v8l::v8l_reduce_and_v2l
v8l v8l_reduce_and_v2l(v2l a)
Reduction and ( & )
v2l::v2l_reduce_min_v2l
v2l v2l_reduce_min_v2l(v2l a)
Reduction min ( min )
v1l::v1l_nxor
v1l v1l_nxor(v1l a, v1l b)
Bitwise nxor ( ~(a ^ b) )
v8l::m8l_andnot
m8l m8l_andnot(m8l a, m8l b)
Bitwise andnot ( a & ~b )
v1l::sl_reduce_mul_v1l
v1l sl_reduce_mul_v1l(v1l a)
Reduction mul ( * )
v4l::v4l_reduce_add_v8l
v4l v4l_reduce_add_v8l(v8l a)
Reduction add ( + )
v8i::v8i_reduce_add
v8i v8i_reduce_add(v8i a)
Reduction add ( + )
v1f::v1f_reduce_min
v1f v1f_reduce_min(v1f a)
Reduction min ( min )
v2l::v2l_reduce_max_v4l
v2l v2l_reduce_max_v4l(v4l a)
Reduction max ( max )
v1l::v1l_rfprintf
void v1l_rfprintf(FILE *file, v1l a, const char *format)
Prints a v1l vector (reversed order)
v1i::v1i_cvt_v4d
v1i v1i_cvt_v4d(v4d a)
Converts a v4d vector into a v1i vector.
v4d
Type for the manipulation of 4 double packed into one single vector.
Definition: pints-doc.h:371
v8i::m8i_nand
m8i m8i_nand(m8i a, m8i b)
Bitwise nand ( ~(a & b) )
v2i::v2i_blend2x1
v2i v2i_blend2x1(v2i a, v2i b, uint_fast8_t mask)
Creates a new v2i vector whose elements are from a and b choosed by mask.
v4d::v4d_xor
v4d v4d_xor(v4d a, v4d b)
Bitwise xor ( a ^ b )
v2i::v2i_reduce_add
v2i v2i_reduce_add(v2i a)
Reduction add ( + )
v1i::v1i_cast_v2d
v1i v1i_cast_v2d(v2d a)
Casts a v2d vector into a v1i vector.
v8f::v8f_reduce_max_v8f
v8f v8f_reduce_max_v8f(v8f a)
Reduction max ( max )
v4d::m4d_not
m4d m4d_not(m4d a)
Bitwise not ( ~a )
v4d::v4d_rmerge4_v1d
v4d v4d_rmerge4_v1d(v1d a3, v1d a2, v1d a1, v1d a0)
Merges 4 v1d vectors together (reverse order).
v1l::v1l_reduce_and_v2l
v1l v1l_reduce_and_v2l(v2l a)
Reduction and ( & )
v1d::sd_cvt_v16i
double sd_cvt_v16i(v16i a)
Converts the first value of a v16i vector into double.
v2d::v2d_max
v2d v2d_max(v2d a, v2d b)
Elementwise max ( a > b ? a : b )
v4l::v4l_reduce_mul_v1l
v4l v4l_reduce_mul_v1l(v1l a)
Reduction mul ( * )
v8i::v8i_zeros
v8i v8i_zeros()
Sets all bits to 0.
v16i::v16i_reduce_and_v1i
v16i v16i_reduce_and_v1i(v1i a)
Reduction and ( & )
v1l::v1l_neq
v1l v1l_neq(v1l a, v1l b)
Compares the inequality of the two input vectors.
v2i::v2i_cvt_v2d
v2i v2i_cvt_v2d(v2d a)
Converts a v2d vector into a v2i vector.
v8i::v8i_cast_v2l
v8i v8i_cast_v2l(v2l a)
Casts a v2l vector into a v8i vector.
v4f::v4f_reduce_mul_v8f
v4f v4f_reduce_mul_v8f(v8f a)
Reduction mul ( * )
v1i::v1i_cast_v4d
v1i v1i_cast_v4d(v4d a)
Casts a v4d vector into a v1i vector.
v1d::sd_cvt_v2d
double sd_cvt_v2d(v2d a)
Converts the first value of a v2d vector into double.
v16i::m16i_not
m16i m16i_not(m16i a)
Bitwise not ( ~a )
v4d::v4d_neq
v4d v4d_neq(v4d a, v4d b)
Compares the inequality of the two input vectors.
v4i::v4i_reduce_add
v4i v4i_reduce_add(v4i a)
Reduction add ( + )
v4f::m4f_leq
m4f m4f_leq(v4f a, v4f b)
Compares if elements of a are less than or equal to those of b.
v8f::v8f_cast_v2i
v8f v8f_cast_v2i(v2i a)
Casts a v2i vector into a v8f vector.
v2l::v2l_merge_v1l
v2l v2l_merge_v1l(v1l low, v1l high)
Merges 2 v1l vectors together.
v2i::v2i_reduce_max_v16i
v2i v2i_reduce_max_v16i(v16i a)
Reduction max ( max )
v4l::v4l_sqrt
v4l v4l_sqrt(v4l a)
Elementwise square root ( sqrt(a) )
v4f::v4f_store1
void v4f_store1(float *p, v4f a)
Stores the first element of a v4f vector into memory.
v8i::v8i_rmerge2_v4i
v8i v8i_rmerge2_v4i(v4i a1, v4i a0)
Merges 2 v4i vectors together (reverse order).
v8l::v8l_reduce_max_v8l
v8l v8l_reduce_max_v8l(v8l a)
Reduction max ( max )
v2i::v2i_leq
v2i v2i_leq(v2i a, v2i b)
Compares if elements of a are less than or equal to those of b.
v2d::v2d_fprintf
void v2d_fprintf(FILE *file, v2d a, const char *format)
Prints a v2d vector.
v1d::v1d_cvt_v16i
v1d v1d_cvt_v16i(v16i a)
Converts a v16i vector into a v1d vector.
v4d::v4d_cvt_v8l
v4d v4d_cvt_v8l(v8l a)
Converts a v8l vector into a v4d vector.
v8l
Type for the manipulation of 8 int64_t packed into one single vector.
Definition: pints-doc.h:651
v1d::v1d_rfprint
void v1d_rfprint(FILE *file, v1d a)
Prints a v1d vector (reversed order)
v4l::m4l_and
m4l m4l_and(m4l a, m4l b)
Bitwise and ( a & b )
v2i::v2i_reduce_add_v1i
v2i v2i_reduce_add_v1i(v1i a)
Reduction add ( + )
v8l::v8l_cvt_v16f
v8l v8l_cvt_v16f(v16f a)
Converts a v16f vector into a v8l vector.
v8f::v8f_fshuffle8
v8f v8f_fshuffle8(v8f a, v8f b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8f::v8f_leq
v8f v8f_leq(v8f a, v8f b)
Compares if elements of a are less than or equal to those of b.
v1l::v1l_cvt_v16i
v1l v1l_cvt_v16i(v16i a)
Converts a v16i vector into a v1l vector.
v4l::v4l_xor
v4l v4l_xor(v4l a, v4l b)
Bitwise xor ( a ^ b )
v4d::v4d_rprint
void v4d_rprint(v4d a)
Prints a v4d vector (reversed order)
v1i::v1i_reduce_max_v4i
v1i v1i_reduce_max_v4i(v4i a)
Reduction max ( max )
v1l::v1l_reduce_mul
v1l v1l_reduce_mul(v1l a)
Reduction mul ( * )
v1l::sl_cvt_v8i
int64_t sl_cvt_v8i(v8i a)
Converts the first value of a v8i vector into int64_t.
v8d::v8d_cast_v4f
v8d v8d_cast_v4f(v4f a)
Casts a v4f vector into a v8d vector.
v8d::v8d_div
v8d v8d_div(v8d a, v8d b)
Elementwise division ( a / b )
v4l::v4l_permute2x2
v4l v4l_permute2x2(v4l a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v8f::v8f_reduce_add_v16f
v8f v8f_reduce_add_v16f(v16f a)
Reduction add ( + )
v4f::v4f_reduce_or_v8f
v4f v4f_reduce_or_v8f(v8f a)
Reduction or ( | )
v1f::m1f_cvt_v1f
m1f m1f_cvt_v1f(v1f a)
Converts a v1f vector into a m1f vector-mask.
v1l::v1l_cast_v1i
v1l v1l_cast_v1i(v1i a)
Casts a v1i vector into a v1l vector.
v4d::v4d_reduce_and
v4d v4d_reduce_and(v4d a)
Reduction and ( & )
v8d::v8d_fshuffle4x2
v8d v8d_fshuffle4x2(v8d a, v8d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1d::v1d_reduce_min_v1d
v1d v1d_reduce_min_v1d(v1d a)
Reduction min ( min )
v16f
Type for the manipulation of 16 float packed into one single vector.
Definition: pints-doc.h:691
v2f::v2f_cast_v4l
v2f v2f_cast_v4l(v4l a)
Casts a v4l vector into a v2f vector.
v8i::si_reduce_mul_v8i
v8i si_reduce_mul_v8i(v8i a)
Reduction mul ( * )
v1f::v1f_cvt_v8f
v1f v1f_cvt_v8f(v8f a)
Converts a v8f vector into a v1f vector.
v1i::m1i_not
m1i m1i_not(m1i a)
Bitwise not ( ~a )
v1i::v1i_cast_v2i
v1i v1i_cast_v2i(v2i a)
Casts a v2i vector into a v1i vector.
v8d::v8d_cast_v16i
v8d v8d_cast_v16i(v16i a)
Casts a v16i vector into a v8d vector.
v2f::v2f_rset
v2f v2f_rset(float v1, float v0)
Sets the elements of a v2f vector (reverse order).
v2l::v2l_blend2x1
v2l v2l_blend2x1(v2l a, v2l b, uint_fast8_t mask)
Creates a new v2l vector whose elements are from a and b choosed by mask.
v4f::v4f_cast_v4f
v4f v4f_cast_v4f(v4f a)
Casts a v4f vector into a v4f vector.
v2l::v2l_and
v2l v2l_and(v2l a, v2l b)
Bitwise and ( a & b )
v8i::v8i_reduce_min_v4i
v8i v8i_reduce_min_v4i(v4i a)
Reduction min ( min )
v16f::v16f_cvt_v16i
v16f v16f_cvt_v16i(v16i a)
Converts a v16i vector into a v16f vector.
v2f::v2f_blend1x2
v2f v2f_blend1x2(v2f a, v2f b, uint_fast8_t mask)
Creates a new v2f vector whose elements are from a and b choosed by mask.
v2i::v2i_neg
v2i v2i_neg(v2i a)
Elementwise negation ( -a )
v1l::v1l_cvt_v4l
v1l v1l_cvt_v4l(v4l a)
Converts a v4l vector into a v1l vector.
v16i::v16i_reduce_or_v8i
v16i v16i_reduce_or_v8i(v8i a)
Reduction or ( | )
v2l::v2l_reduce_max
v2l v2l_reduce_max(v2l a)
Reduction max ( max )
v2d::v2d_set1
v2d v2d_set1(double v)
Broadcasts a single value into all elements of a v2d vector.
v8d::v8d_rsqrt
v8d v8d_rsqrt(v8d a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v1f::v1f_cast_v4l
v1f v1f_cast_v4l(v4l a)
Casts a v4l vector into a v1f vector.
v2f::v2f_fmsub
v2f v2f_fmsub(v2f a, v2f b, v2f acc)
Fused Multiply-Sub ( (a * b) - acc )
v16f::m16f_cvt_v16f
m16f m16f_cvt_v16f(v16f a)
Converts a v16f vector into a m16f vector-mask.
v1l::sl_cvt_v1d
int64_t sl_cvt_v1d(v1d a)
Converts the first value of a v1d vector into int64_t.
v1d::v1d_reduce_add_v2d
v1d v1d_reduce_add_v2d(v2d a)
Reduction add ( + )
v1l::v1l_blend1
v1l v1l_blend1(v1l a, v1l b, uint_fast8_t mask)
Creates a new v1l vector whose elements are from a and b choosed by mask.
v16i::m16i_and
m16i m16i_and(m16i a, m16i b)
Bitwise and ( a & b )
v16i::v16i_permute16
v16i v16i_permute16(v16i a, uint_fast64_t rule)
Shuffles (outer) a using the control in rule.
v4i::m4i_gt
m4i m4i_gt(v4i a, v4i b)
Compares if elements of a are greater than those of b.
v1l::v1l_reduce_or_v1l
v1l v1l_reduce_or_v1l(v1l a)
Reduction or ( | )
v2f::v2f_reduce_add_v1f
v2f v2f_reduce_add_v1f(v1f a)
Reduction add ( + )
v1f::v1f_rset
v1f v1f_rset(float v0)
Sets the elements of a v1f vector (reverse order).
v8l::v8l_cvt_v4l
v8l v8l_cvt_v4l(v4l a)
Converts a v4l vector into a v8l vector.
v2l::v2l_cast_m2l
v2l v2l_cast_m2l(m2l a)
Casts a m2l vector-mask into a v2l vector.
v2l::v2l_reduce_and
v2l v2l_reduce_and(v2l a)
Reduction and ( & )
v8f::v8f_ones
v8f v8f_ones()
Sets all bits to 1.
v16f::v16f_cvt_v4l
v16f v16f_cvt_v4l(v4l a)
Converts a v4l vector into a v16f vector.
v16f::v16f_set_hilo_v8f
v16f v16f_set_hilo_v8f(v16f src, v8f a, int high)
Conditionally sets the low or the high part of a v16f vector.
v4d::v4d_hshuffle
v4d v4d_hshuffle(v4d a, v4d b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v2i::v2i_rfprintf
void v2i_rfprintf(FILE *file, v2i a, const char *format)
Prints a v2i vector (reversed order)
v16i::v16i_permute16x1
v16i v16i_permute16x1(v16i a, uint_fast64_t rule)
Shuffles (inner) a using the control in rule.
v1d::v1d_cvt_m1d
v1d v1d_cvt_m1d(m1d a)
Converts a m1d vector-mask into a v1d vector.
v4l::v4l_reduce_or
v4l v4l_reduce_or(v4l a)
Reduction or ( | )
v16i::v16i_cvt_v1i
v16i v16i_cvt_v1i(v1i a)
Converts a v1i vector into a v16i vector.
v8i::v8i_cast_v4l
v8i v8i_cast_v4l(v4l a)
Casts a v4l vector into a v8i vector.
v16i::v16i_neg
v16i v16i_neg(v16i a)
Elementwise negation ( -a )
v1d
Type for the manipulation of 1 double packed into one single vector.
Definition: pints-doc.h:51
v16f::sf_reduce_add_v16f
v16f sf_reduce_add_v16f(v16f a)
Reduction add ( + )
v2f::v2f_set
v2f v2f_set(float v0, float v1)
Sets the elements of a v2f vector.
v4l::v4l_store
void v4l_store(int64_t *p, v4l a)
Stores a v4l vector into memory.
v4f::v4f_fshuffle4
v4f v4f_fshuffle4(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2f::v2f_gt
v2f v2f_gt(v2f a, v2f b)
Compares if elements of a are greater than those of b.
v2f::v2f_neg
v2f v2f_neg(v2f a)
Elementwise negation ( -a )
v8d::v8d_cast_v1f
v8d v8d_cast_v1f(v1f a)
Casts a v1f vector into a v8d vector.
v4d::v4d_cast_v2f
v4d v4d_cast_v2f(v2f a)
Casts a v2f vector into a v4d vector.
v8f::v8f_rmerge_v4f
v8f v8f_rmerge_v4f(v4f high, v4f low)
Merges 2 v4f vectors together (reversed order).
v2i::m2i_or
m2i m2i_or(m2i a, m2i b)
Bitwise or ( a | b )
v16f::v16f_reduce_or_v8f
v16f v16f_reduce_or_v8f(v8f a)
Reduction or ( | )
v8d::v8d_reduce_add_v8d
v8d v8d_reduce_add_v8d(v8d a)
Reduction add ( + )
v1l::sl_reduce_max_v1l
v1l sl_reduce_max_v1l(v1l a)
Reduction max ( max )
v8l::v8l_set_high_v4l
v8l v8l_set_high_v4l(v8l src, v4l high)
Sets the high part of a v8l vector.
v1l::v1l_cast_v8f
v1l v1l_cast_v8f(v8f a)
Casts a v8f vector into a v1l vector.
v2i::v2i_fprintf
void v2i_fprintf(FILE *file, v2i a, const char *format)
Prints a v2i vector.
v1d::v1d_reduce_min_v4d
v1d v1d_reduce_min_v4d(v4d a)
Reduction min ( min )
v4l::v4l_load
v4l v4l_load(const int64_t *p)
Loads 4 int64_t from memory into a v4l vector.
v2l::v2l_blend1
v2l v2l_blend1(v2l a, v2l b, uint_fast8_t mask)
Creates a new v2l vector whose elements are from a and b choosed by mask.
v1l::v1l_add
v1l v1l_add(v1l a, v1l b)
Elementwise addition ( a + b )
v1l::v1l_cast_v2i
v1l v1l_cast_v2i(v2i a)
Casts a v2i vector into a v1l vector.
v4f::v4f_cast_v8d
v4f v4f_cast_v8d(v8d a)
Casts a v8d vector into a v4f vector.
v1d::m1d_ornot
m1d m1d_ornot(m1d a, m1d b)
Bitwise ornot ( a | ~b )
v4d::v4d_reduce_or_v4d
v4d v4d_reduce_or_v4d(v4d a)
Reduction or ( | )
v2f::v2f_mask_move
v2f v2f_mask_move(m2f mask, v2f src, v2f a)
Mask the input.
v16f::v16f_reduce_and_v8f
v16f v16f_reduce_and_v8f(v8f a)
Reduction and ( & )
v2f::v2f_cvt_v1d
v2f v2f_cvt_v1d(v1d a)
Converts a v1d vector into a v2f vector.
v16f::v16f_cast_v1d
v16f v16f_cast_v1d(v1d a)
Casts a v1d vector into a v16f vector.
v8f::m8f_cast_v8f
m8f m8f_cast_v8f(v8f a)
Casts a v8f vector into a m8f vector-mask.
v16f::v16f_reduce_and_v16f
v16f v16f_reduce_and_v16f(v16f a)
Reduction and ( & )
v4f::v2f_get_hilo_v4f
v2f v2f_get_hilo_v4f(v4f a, int high)
Conditionnaly gets the low or the high part of a v4f vector.
v1f::sf_cvt_v8l
float sf_cvt_v8l(v8l a)
Converts the first value of a v8l vector into float.
v2d::v2d_hshuffle
v2d v2d_hshuffle(v2d a, v2d b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v2d::v2d_set
v2d v2d_set(double v0, double v1)
Sets the elements of a v2d vector.
v2d::v2d_reduce_min_v8d
v2d v2d_reduce_min_v8d(v8d a)
Reduction min ( min )
v1f::m1f_leq
m1f m1f_leq(v1f a, v1f b)
Compares if elements of a are less than or equal to those of b.
v4f::v4f_reduce_add_v4f
v4f v4f_reduce_add_v4f(v4f a)
Reduction add ( + )
v8l::v8l_cvt_v4f
v8l v8l_cvt_v4f(v4f a)
Converts a v4f vector into a v8l vector.
v4i::v4i_fnmadd
v4i v4i_fnmadd(v4i a, v4i b, v4i acc)
Fused Multiply-Add ( -(a * b) + acc )
v2f::v2f_reduce_and_v4f
v2f v2f_reduce_and_v4f(v4f a)
Reduction and ( & )
v2d::v2d_load
v2d v2d_load(const double *p)
Loads 2 double from memory into a v2d vector.
v1i::v1i_sub
v1i v1i_sub(v1i a, v1i b)
Elementwise subtraction ( a - b )
v4f::v4f_one
v4f v4f_one()
Sets all elements to 1.
v8i::v8i_permute4x2
v8i v8i_permute4x2(v8i a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v8f::v8f_printf
void v8f_printf(v8f a, const char *format)
Prints a v8f vector.
v1d::v1d_add
v1d v1d_add(v1d a, v1d b)
Elementwise addition ( a + b )
v1l::sl_cvt_v1f
int64_t sl_cvt_v1f(v1f a)
Converts the first value of a v1f vector into int64_t.
v2i::v2i_rfprint
void v2i_rfprint(FILE *file, v2i a)
Prints a v2i vector (reversed order)
v4d::v4d_fprintf
void v4d_fprintf(FILE *file, v4d a, const char *format)
Prints a v4d vector.
v8d::m8d_xor
m8d m8d_xor(m8d a, m8d b)
Bitwise xor ( a ^ b )
v2i::m2i_eq
m2i m2i_eq(v2i a, v2i b)
Compares the equality of the two input vectors.
v4i::v4i_blend1x4
v4i v4i_blend1x4(v4i a, v4i b, uint_fast8_t mask)
Creates a new v4i vector whose elements are from a and b choosed by mask.
v4f::v4f_ornot
v4f v4f_ornot(v4f a, v4f b)
Bitwise ornot ( a | ~b )
v4i::v4i_cvt_v8d
v4i v4i_cvt_v8d(v8d a)
Converts a v8d vector into a v4i vector.
v4l::v4l_reduce_add_v1l
v4l v4l_reduce_add_v1l(v1l a)
Reduction add ( + )
v8i::v8i_cast_v2i
v8i v8i_cast_v2i(v2i a)
Casts a v2i vector into a v8i vector.
v1i::v1i_zero
v1i v1i_zero()
Sets all elements to 0.
v1f::sf_reduce_and_v1f
v1f sf_reduce_and_v1f(v1f a)
Reduction and ( & )
v8d::v8d_rprint
void v8d_rprint(v8d a)
Prints a v8d vector (reversed order)
v2f::v2f_abs
v2f v2f_abs(v2f a)
Elementwise absolute value ( a > 0 ? a : -a )
v1f::v1f_load1
v1f v1f_load1(const float *p)
Loads 1 float from memory and broadcasts it into a v1f vector.
v4l::v4l_cast_v8i
v4l v4l_cast_v8i(v8i a)
Casts a v8i vector into a v4l vector.
v8f::v8f_cvt_v16f
v8f v8f_cvt_v16f(v16f a)
Converts a v16f vector into a v8f vector.
v2l::v2l_geq
v2l v2l_geq(v2l a, v2l b)
Compares if elements of a are greater than or equal to those of b.
v2l::v2l_cvt_v16f
v2l v2l_cvt_v16f(v16f a)
Converts a v16f vector into a v2l vector.
v8i::v8i_fprint
void v8i_fprint(FILE *file, v8i a)
Prints a v8i vector.
v8l::v8l_reduce_max_v1l
v8l v8l_reduce_max_v1l(v1l a)
Reduction max ( max )
v4d::v4d_fshuffle2
v4d v4d_fshuffle2(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v16i::v16i_reduce_or_v1i
v16i v16i_reduce_or_v1i(v1i a)
Reduction or ( | )
v4l::v4l_set_low_v2l
v4l v4l_set_low_v2l(v4l src, v2l low)
Sets the low part of a v4l vector.
v16f::v16f_permute8
v16f v16f_permute8(v16f a, uint_fast32_t rule)
Shuffles (outer) a using the control in rule.
v4d::m4d_cvt_m4f
m4d m4d_cvt_m4f(m4f a)
Converts a m4f vector-mask into a m4d vector-mask.
v16i::v16i_cast_v2f
v16i v16i_cast_v2f(v2f a)
Casts a v2f vector into a v16i vector.
v8i::v8i_cvt_v4l
v8i v8i_cvt_v4l(v4l a)
Converts a v4l vector into a v8i vector.
v1d::v1d_printf
void v1d_printf(v1d a, const char *format)
Prints a v1d vector.
v8l::m8l_nand
m8l m8l_nand(m8l a, m8l b)
Bitwise nand ( ~(a & b) )
v16f::v16f_reduce_mul
v16f v16f_reduce_mul(v16f a)
Reduction mul ( * )
v1i::si_cvt_v8f
int32_t si_cvt_v8f(v8f a)
Converts the first value of a v8f vector into int32_t.
v4i::v4i_reduce_min_v4i
v4i v4i_reduce_min_v4i(v4i a)
Reduction min ( min )
v8l::v8l_rmerge_v4l
v8l v8l_rmerge_v4l(v4l high, v4l low)
Merges 2 v4l vectors together (reversed order).
v4i::v4i_max
v4i v4i_max(v4i a, v4i b)
Elementwise max ( a > b ? a : b )
v8i::v8i_hshuffle8x1
v8i v8i_hshuffle8x1(v8i a, v8i b, uint_fast32_t rule)
Shuffles (inner) a and b together using the control in rule.
v16i::v16i_reduce_min_v2i
v16i v16i_reduce_min_v2i(v2i a)
Reduction min ( min )
v4i::m4i_and
m4i m4i_and(m4i a, m4i b)
Bitwise and ( a & b )
v4i::m4i_cvt_m4l
m4i m4i_cvt_m4l(m4l a)
Converts a m4l vector-mask into a m4i vector-mask.
v1i::v1i_sqrt
v1i v1i_sqrt(v1i a)
Elementwise square root ( sqrt(a) )
v2i::si_reduce_max_v2i
v2i si_reduce_max_v2i(v2i a)
Reduction max ( max )
v8f::v8f_reduce_and
v8f v8f_reduce_and(v8f a)
Reduction and ( & )
v8l::v8l_cvt_v1i
v8l v8l_cvt_v1i(v1i a)
Converts a v1i vector into a v8l vector.
v1f::sf_cvt_v4i
float sf_cvt_v4i(v4i a)
Converts the first value of a v4i vector into float.
v4i::v4i_fprintf
void v4i_fprintf(FILE *file, v4i a, const char *format)
Prints a v4i vector.
v2f::m2f_not
m2f m2f_not(m2f a)
Bitwise not ( ~a )
v4d::v4d_fprint
void v4d_fprint(FILE *file, v4d a)
Prints a v4d vector.
v1f::m1f_ornot
m1f m1f_ornot(m1f a, m1f b)
Bitwise ornot ( a | ~b )
v4d::v4d_rset
v4d v4d_rset(double v3, double v2, double v1, double v0)
Sets the elements of a v4d vector (reverse order).
v4l::v4l_hshuffle
v4l v4l_hshuffle(v4l a, v4l b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v1d::v1d_zero
v1d v1d_zero()
Sets all elements to 0.
m2d
Type for the manipulation of vector-masks.
Definition: pints-doc.h:232
v2i::v2i_cvt_m2i
v2i v2i_cvt_m2i(m2i a)
Converts a m2i vector-mask into a v2i vector.
v16i::v16i_reduce_mul_v1i
v16i v16i_reduce_mul_v1i(v1i a)
Reduction mul ( * )
v1i::v1i_reduce_add_v4i
v1i v1i_reduce_add_v4i(v4i a)
Reduction add ( + )
v8l::v8l_reduce_add_v2l
v8l v8l_reduce_add_v2l(v2l a)
Reduction add ( + )
v8l::v8l_one
v8l v8l_one()
Sets all elements to 1.
v2f::v2f_rmerge_v1f
v2f v2f_rmerge_v1f(v1f high, v1f low)
Merges 2 v1f vectors together (reversed order).
v16i::v16i_cast_v2d
v16i v16i_cast_v2d(v2d a)
Casts a v2d vector into a v16i vector.
v1i::v1i_reduce_min_v8i
v1i v1i_reduce_min_v8i(v8i a)
Reduction min ( min )
v2d::m2d_cast_v2d
m2d m2d_cast_v2d(v2d a)
Casts a v2d vector into a m2d vector-mask.
v8i::v8i_frcp
v8i v8i_frcp(v8i a)
Fast elementwise reciprocal ( 1 / a )
v8i::v8i_rcp
v8i v8i_rcp(v8i a)
Elementwise reciprocal ( 1 / a )
v16f::m16f_lt
m16f m16f_lt(v16f a, v16f b)
Compares if elements of a are less than those of b.
v1l::v1l_reduce_add_v2l
v1l v1l_reduce_add_v2l(v2l a)
Reduction add ( + )
v8d::v8d_reduce_mul_v2d
v8d v8d_reduce_mul_v2d(v2d a)
Reduction mul ( * )
v2l::v2l_cast_v8d
v2l v2l_cast_v8d(v8d a)
Casts a v8d vector into a v2l vector.
v2i::v2i_cvt_v8i
v2i v2i_cvt_v8i(v8i a)
Converts a v8i vector into a v2i vector.
v4i::v4i_reduce_or_v2i
v4i v4i_reduce_or_v2i(v2i a)
Reduction or ( | )
v4l::v4l_nor
v4l v4l_nor(v4l a, v4l b)
Bitwise nor ( ~(a | b) )
v8f::m8f_not
m8f m8f_not(m8f a)
Bitwise not ( ~a )
v2i::v2i_rprint
void v2i_rprint(v2i a)
Prints a v2i vector (reversed order)
v16i::v16i_fshuffle4x4
v16i v16i_fshuffle4x4(v16i a, v16i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v16i::v16i_sqrt
v16i v16i_sqrt(v16i a)
Elementwise square root ( sqrt(a) )
v4f::v4f_cvt_v4i
v4f v4f_cvt_v4i(v4i a)
Converts a v4i vector into a v4f vector.
v2f::v2f_frcp
v2f v2f_frcp(v2f a)
Fast elementwise reciprocal ( 1 / a )
v1i::v1i_reduce_mul_v1i
v1i v1i_reduce_mul_v1i(v1i a)
Reduction mul ( * )
v4d::v4d_geq
v4d v4d_geq(v4d a, v4d b)
Compares if elements of a are greater than or equal to those of b.
v2d::v2d_min
v2d v2d_min(v2d a, v2d b)
Elementwise min ( a < b ? a : b )
v8f::v8f_cast_v4f
v8f v8f_cast_v4f(v4f a)
Casts a v4f vector into a v8f vector.
v1i::v1i_cvt_v2i
v1i v1i_cvt_v2i(v2i a)
Converts a v2i vector into a v1i vector.
v2l::v2l_min
v2l v2l_min(v2l a, v2l b)
Elementwise min ( a < b ? a : b )
v4d::v4d_set
v4d v4d_set(double v0, double v1, double v2, double v3)
Sets the elements of a v4d vector.
v4l::m4l_cvt_m4i
m4l m4l_cvt_m4i(m4i a)
Converts a m4i vector-mask into a m4l vector-mask.
v2d::v2d_cast_v2f
v2d v2d_cast_v2f(v2f a)
Casts a v2f vector into a v2d vector.
v1f::v1f_cast_v8i
v1f v1f_cast_v8i(v8i a)
Casts a v8i vector into a v1f vector.
v1f::v1f_sqrt
v1f v1f_sqrt(v1f a)
Elementwise square root ( sqrt(a) )
v8f::m8f_cvt_m8f
m8f m8f_cvt_m8f(m8f a)
Converts a m8f vector-mask into a m8f vector-mask.
v8d::v8d_fmsub
v8d v8d_fmsub(v8d a, v8d b, v8d acc)
Fused Multiply-Sub ( (a * b) - acc )
v8d::v8d_zeros
v8d v8d_zeros()
Sets all bits to 0.
v2f::v2f_cast_v1i
v2f v2f_cast_v1i(v1i a)
Casts a v1i vector into a v2f vector.
v2i::v2i_cast_v2d
v2i v2i_cast_v2d(v2d a)
Casts a v2d vector into a v2i vector.
v2d::v2d_fshuffle2x1
v2d v2d_fshuffle2x1(v2d a, v2d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4l::v4l_rcp
v4l v4l_rcp(v4l a)
Elementwise reciprocal ( 1 / a )
v8f::m8f_cvt_v8f
m8f m8f_cvt_v8f(v8f a)
Converts a v8f vector into a m8f vector-mask.
v2l::v2l_cvt_v4d
v2l v2l_cvt_v4d(v4d a)
Converts a v4d vector into a v2l vector.
v4d::v4d_cvt_v1f
v4d v4d_cvt_v1f(v1f a)
Converts a v1f vector into a v4d vector.
v1f::v1f_cvt_v2d
v1f v1f_cvt_v2d(v2d a)
Converts a v2d vector into a v1f vector.
v4i::v4i_reduce_min
v4i v4i_reduce_min(v4i a)
Reduction min ( min )
v16f::v16f_cvt_v1f
v16f v16f_cvt_v1f(v1f a)
Converts a v1f vector into a v16f vector.
v1f::m1f_or
m1f m1f_or(m1f a, m1f b)
Bitwise or ( a | b )
v16f::v16f_fmsub
v16f v16f_fmsub(v16f a, v16f b, v16f acc)
Fused Multiply-Sub ( (a * b) - acc )
v4d::sd_reduce_add_v4d
v4d sd_reduce_add_v4d(v4d a)
Reduction add ( + )
v8d::v8d_hshuffle4
v8d v8d_hshuffle4(v8d a, v8d b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v8d::v8d_cvt_v1i
v8d v8d_cvt_v1i(v1i a)
Converts a v1i vector into a v8d vector.
v1f::v1f_reduce_min_v16f
v1f v1f_reduce_min_v16f(v16f a)
Reduction min ( min )
v1i::m1i_nor
m1i m1i_nor(m1i a, m1i b)
Bitwise nor ( ~(a | b) )
v4i::v4i_rfprintf
void v4i_rfprintf(FILE *file, v4i a, const char *format)
Prints a v4i vector (reversed order)
v8d::v8d_ornot
v8d v8d_ornot(v8d a, v8d b)
Bitwise ornot ( a | ~b )
v2i::v2i_reduce_min
v2i v2i_reduce_min(v2i a)
Reduction min ( min )
v4l::v4l_fshuffle
v4l v4l_fshuffle(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1l::v1l_cvt_v8d
v1l v1l_cvt_v8d(v8d a)
Converts a v8d vector into a v1l vector.
v16i::v16i_set
v16i v16i_set(int32_t v0, int32_t v1, int32_t v2, int32_t v3, int32_t v4, int32_t v5, int32_t v6, int32_t v7, int32_t v8, int32_t v9, int32_t v10, int32_t v11, int32_t v12, int32_t v13, int32_t v14, int32_t v15)
Sets the elements of a v16i vector.
v4d::v4d_ornot
v4d v4d_ornot(v4d a, v4d b)
Bitwise ornot ( a | ~b )
v2i::v2i_min
v2i v2i_min(v2i a, v2i b)
Elementwise min ( a < b ? a : b )
v16i::v16i_gt
v16i v16i_gt(v16i a, v16i b)
Compares if elements of a are greater than those of b.
v8l::v8l_reduce_add_v1l
v8l v8l_reduce_add_v1l(v1l a)
Reduction add ( + )
v2l::m2l_cvt_m2i
m2l m2l_cvt_m2i(m2i a)
Converts a m2i vector-mask into a m2l vector-mask.
v1i::si_cvt_v1i
int32_t si_cvt_v1i(v1i a)
Converts the first value of a v1i vector into int32_t.
v2i::v2i_ones
v2i v2i_ones()
Sets all bits to 1.
v4l::m4l_cvt_v4l
m4l m4l_cvt_v4l(v4l a)
Converts a v4l vector into a m4l vector-mask.
v16i::v16i_fshuffle16x1
v16i v16i_fshuffle16x1(v16i a, v16i b, uint_fast64_t rule, uint_fast16_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1f::m1f_geq
m1f m1f_geq(v1f a, v1f b)
Compares if elements of a are greater than or equal to those of b.
v16f::v16f_fshuffle4
v16f v16f_fshuffle4(v16f a, v16f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8d::v8d_reduce_or_v4d
v8d v8d_reduce_or_v4d(v4d a)
Reduction or ( | )
v1i::v1i_reduce_max_v8i
v1i v1i_reduce_max_v8i(v8i a)
Reduction max ( max )
v4f::v4f_permute4
v4f v4f_permute4(v4f a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v2d::v2d_blend1x2
v2d v2d_blend1x2(v2d a, v2d b, uint_fast8_t mask)
Creates a new v2d vector whose elements are from a and b choosed by mask.
v8i::v8i_cast_v16f
v8i v8i_cast_v16f(v16f a)
Casts a v16f vector into a v8i vector.
v4f::v4f_reduce_min
v4f v4f_reduce_min(v4f a)
Reduction min ( min )
v2l::v2l_cast_v2f
v2l v2l_cast_v2f(v2f a)
Casts a v2f vector into a v2l vector.
v2d::v2d_fshuffle2
v2d v2d_fshuffle2(v2d a, v2d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2i::v2i_cast_v1f
v2i v2i_cast_v1f(v1f a)
Casts a v1f vector into a v2i vector.
v2i::v2i_andnot
v2i v2i_andnot(v2i a, v2i b)
Bitwise andnot ( a & ~b )
v8l::m8l_cvt_v8l
m8l m8l_cvt_v8l(v8l a)
Converts a v8l vector into a m8l vector-mask.
v2i::m2i_cvt_m2d
m2i m2i_cvt_m2d(m2d a)
Converts a m2d vector-mask into a m2i vector-mask.
v4f::v4f_mask_move
v4f v4f_mask_move(m4f mask, v4f src, v4f a)
Mask the input.
v4i::m4i_neq
m4i m4i_neq(v4i a, v4i b)
Compares the inequality of the two input vectors.
v4d::v4d_cast_m4d
v4d v4d_cast_m4d(m4d a)
Casts a m4d vector-mask into a v4d vector.
v8f::v8f_cast_v2f
v8f v8f_cast_v2f(v2f a)
Casts a v2f vector into a v8f vector.
v2l::v2l_set_low_v1l
v2l v2l_set_low_v1l(v2l src, v1l low)
Sets the low part of a v2l vector.
v4l::m4l_eq
m4l m4l_eq(v4l a, v4l b)
Compares the equality of the two input vectors.
v4i::v4i_frsqrt
v4i v4i_frsqrt(v4i a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v16i::v16i_permute8x2
v16i v16i_permute8x2(v16i a, uint_fast32_t rule)
Shuffles (inner) a using the control in rule.
v8i::v8i_reduce_min_v2i
v8i v8i_reduce_min_v2i(v2i a)
Reduction min ( min )
v2l::v2l_zero
v2l v2l_zero()
Sets all elements to 0.
v4f::v4f_neq
v4f v4f_neq(v4f a, v4f b)
Compares the inequality of the two input vectors.
v4l::v4l_cvt_v4d
v4l v4l_cvt_v4d(v4d a)
Converts a v4d vector into a v4l vector.
v4l::v4l_and
v4l v4l_and(v4l a, v4l b)
Bitwise and ( a & b )
v4f::v4f_cvt_v2d
v4f v4f_cvt_v2d(v2d a)
Converts a v2d vector into a v4f vector.
v8f::v8f_cast_v8f
v8f v8f_cast_v8f(v8f a)
Casts a v8f vector into a v8f vector.
v8i::v8i_printf
void v8i_printf(v8i a, const char *format)
Prints a v8i vector.
v4i::v4i_reduce_mul_v8i
v4i v4i_reduce_mul_v8i(v8i a)
Reduction mul ( * )
v16f::v16f_cast_v4l
v16f v16f_cast_v4l(v4l a)
Casts a v4l vector into a v16f vector.
v8i::v8i_cast_v8l
v8i v8i_cast_v8l(v8l a)
Casts a v8l vector into a v8i vector.
v1f::sf_reduce_mul_v1f
v1f sf_reduce_mul_v1f(v1f a)
Reduction mul ( * )
v2f::v2f_xor
v2f v2f_xor(v2f a, v2f b)
Bitwise xor ( a ^ b )
v4l::m4l_lt
m4l m4l_lt(v4l a, v4l b)
Compares if elements of a are less than those of b.
v16i::v8i_get_hilo_v16i
v8i v8i_get_hilo_v16i(v16i a, int high)
Conditionnaly gets the low or the high part of a v16i vector.
v1i::v1i_eq
v1i v1i_eq(v1i a, v1i b)
Compares the equality of the two input vectors.
v1d::sd_cvt_v4l
double sd_cvt_v4l(v4l a)
Converts the first value of a v4l vector into double.
v4d::v4d_blend2x2
v4d v4d_blend2x2(v4d a, v4d b, uint_fast8_t mask)
Creates a new v4d vector whose elements are from a and b choosed by mask.
v4d::v4d_reduce_add_v4d
v4d v4d_reduce_add_v4d(v4d a)
Reduction add ( + )
v1l::v1l_cvt_m1l
v1l v1l_cvt_m1l(m1l a)
Converts a m1l vector-mask into a v1l vector.
v2l::v2l_rfprintf
void v2l_rfprintf(FILE *file, v2l a, const char *format)
Prints a v2l vector (reversed order)
v2d::v2d_rmerge_v1d
v2d v2d_rmerge_v1d(v1d high, v1d low)
Merges 2 v1d vectors together (reversed order).
v16i::v16i_blend2
v16i v16i_blend2(v16i a, v16i b, uint_fast8_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v1f::v1f_sub
v1f v1f_sub(v1f a, v1f b)
Elementwise subtraction ( a - b )
v2f::v2f_zero
v2f v2f_zero()
Sets all elements to 0.
v16f::v16f_permute8x2
v16f v16f_permute8x2(v16f a, uint_fast32_t rule)
Shuffles (inner) a using the control in rule.
v2i::v2i_max
v2i v2i_max(v2i a, v2i b)
Elementwise max ( a > b ? a : b )
v8f::v8f_reduce_or_v4f
v8f v8f_reduce_or_v4f(v4f a)
Reduction or ( | )
v8d::v8d_permute4
v8d v8d_permute4(v8d a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v2i::v2i_sqrt
v2i v2i_sqrt(v2i a)
Elementwise square root ( sqrt(a) )
v16i::v16i_reduce_add_v8i
v16i v16i_reduce_add_v8i(v8i a)
Reduction add ( + )
v4f::v4f_cast_v1i
v4f v4f_cast_v1i(v1i a)
Casts a v1i vector into a v4f vector.
v2d::v2d_printf
void v2d_printf(v2d a, const char *format)
Prints a v2d vector.
v1d::sd_cvt_v1d
double sd_cvt_v1d(v1d a)
Converts the first value of a v1d vector into double.
v4f::v4f_reduce_add_v1f
v4f v4f_reduce_add_v1f(v1f a)
Reduction add ( + )
v4l::v4l_fshuffle2
v4l v4l_fshuffle2(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v1d::v1d_cvt_v8i
v1d v1d_cvt_v8i(v8i a)
Converts a v8i vector into a v1d vector.
v1f::v1f_nand
v1f v1f_nand(v1f a, v1f b)
Bitwise nand ( ~(a & b) )
v8f::m8f_lt
m8f m8f_lt(v8f a, v8f b)
Compares if elements of a are less than those of b.
v16f::v16f_reduce_or_v2f
v16f v16f_reduce_or_v2f(v2f a)
Reduction or ( | )
v16f::v16f_rprintf
void v16f_rprintf(v16f a, const char *format)
Prints a v16f vector (reversed order)
v4d::v4d_reduce_or_v1d
v4d v4d_reduce_or_v1d(v1d a)
Reduction or ( | )
v1d::v1d_fnmsub
v1d v1d_fnmsub(v1d a, v1d b, v1d acc)
Fused Multiply-Add ( -(a * b) - acc )
v1i::m1i_leq
m1i m1i_leq(v1i a, v1i b)
Compares if elements of a are less than or equal to those of b.
v1l::v1l_cast_v1d
v1l v1l_cast_v1d(v1d a)
Casts a v1d vector into a v1l vector.
v16f::v16f_blend4x4
v16f v16f_blend4x4(v16f a, v16f b, uint_fast8_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v1i::v1i_load1
v1i v1i_load1(const int32_t *p)
Loads 1 int32_t from memory and broadcasts it into a v1i vector.
v4l::v4l_reduce_and_v8l
v4l v4l_reduce_and_v8l(v8l a)
Reduction and ( & )
v2d::v2d_set_low_v1d
v2d v2d_set_low_v1d(v2d src, v1d low)
Sets the low part of a v2d vector.
v16f::v16f_abs
v16f v16f_abs(v16f a)
Elementwise absolute value ( a > 0 ? a : -a )
v8d::v8d_hshuffle
v8d v8d_hshuffle(v8d a, v8d b, uint_fast32_t rule)
Shuffles a and b together using the control in rule.
v1i::si_cvt_v2i
int32_t si_cvt_v2i(v2i a)
Converts the first value of a v2i vector into int32_t.
v1l::v1l_reduce_or_v2l
v1l v1l_reduce_or_v2l(v2l a)
Reduction or ( | )
v4i::v4i_cast_v1l
v4i v4i_cast_v1l(v1l a)
Casts a v1l vector into a v4i vector.
v4d::v4d_fshuffle4
v4d v4d_fshuffle4(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v16f::m16f_cvt_m16i
m16f m16f_cvt_m16i(m16i a)
Converts a m16i vector-mask into a m16f vector-mask.
v2d
Type for the manipulation of 2 double packed into one single vector.
Definition: pints-doc.h:211
v2i::v2i_cvt_v1f
v2i v2i_cvt_v1f(v1f a)
Converts a v1f vector into a v2i vector.
v4f::v4f_reduce_max_v2f
v4f v4f_reduce_max_v2f(v2f a)
Reduction max ( max )
v4l::v4l_store1
void v4l_store1(int64_t *p, v4l a)
Stores the first element of a v4l vector into memory.
v4i::v4i_cvt_v1f
v4i v4i_cvt_v1f(v1f a)
Converts a v1f vector into a v4i vector.
v1f::v1f_rcp
v1f v1f_rcp(v1f a)
Elementwise reciprocal ( 1 / a )
v4i::v4i_add
v4i v4i_add(v4i a, v4i b)
Elementwise addition ( a + b )
v2i::v2i_sub
v2i v2i_sub(v2i a, v2i b)
Elementwise subtraction ( a - b )
v1i::v1i_reduce_max_v16i
v1i v1i_reduce_max_v16i(v16i a)
Reduction max ( max )
v8i::v8i_cast_v16i
v8i v8i_cast_v16i(v16i a)
Casts a v16i vector into a v8i vector.
v4d::m4d_cast_v4d
m4d m4d_cast_v4d(v4d a)
Casts a v4d vector into a m4d vector-mask.
v16f::v16f_reduce_min_v8f
v16f v16f_reduce_min_v8f(v8f a)
Reduction min ( min )
v4d::v4d_cvt_v1d
v4d v4d_cvt_v1d(v1d a)
Converts a v1d vector into a v4d vector.
v16i::v16i_permute8
v16i v16i_permute8(v16i a, uint_fast32_t rule)
Shuffles (outer) a using the control in rule.
v16i::m16i_xor
m16i m16i_xor(m16i a, m16i b)
Bitwise xor ( a ^ b )
v1f::v1f_reduce_max_v1f
v1f v1f_reduce_max_v1f(v1f a)
Reduction max ( max )
v4d::v4d_and
v4d v4d_and(v4d a, v4d b)
Bitwise and ( a & b )
v16f::v16f_cast_v2d
v16f v16f_cast_v2d(v2d a)
Casts a v2d vector into a v16f vector.
v8d::v8d_cast_v1i
v8d v8d_cast_v1i(v1i a)
Casts a v1i vector into a v8d vector.
v16f::v16f_permute2x8
v16f v16f_permute2x8(v16f a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v2i::v2i_cast_v16f
v2i v2i_cast_v16f(v16f a)
Casts a v16f vector into a v2i vector.
v4l::v4l_lt
v4l v4l_lt(v4l a, v4l b)
Compares if elements of a are less than those of b.
v16f::v16f_blend8
v16f v16f_blend8(v16f a, v16f b, uint_fast8_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v2d::v2d_reduce_min_v2d
v2d v2d_reduce_min_v2d(v2d a)
Reduction min ( min )
v2l::v2l_reduce_add
v2l v2l_reduce_add(v2l a)
Reduction add ( + )
v2d::v2d_reduce_mul_v4d
v2d v2d_reduce_mul_v4d(v4d a)
Reduction mul ( * )
v2d::v2d_rfprintf
void v2d_rfprintf(FILE *file, v2d a, const char *format)
Prints a v2d vector (reversed order)
v8d::v8d_fshuffle2
v8d v8d_fshuffle2(v8d a, v8d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8f::v4f_get_high_v8f
v4f v4f_get_high_v8f(v8f a)
Gets the high part of a v8f vector.
v2f::v2f_load
v2f v2f_load(const float *p)
Loads 2 float from memory into a v2f vector.
v4d::v4d_set_high_v2d
v4d v4d_set_high_v2d(v4d src, v2d high)
Sets the high part of a v4d vector.
v4l::m4l_cast_v4l
m4l m4l_cast_v4l(v4l a)
Casts a v4l vector into a m4l vector-mask.
v8i::v8i_leq
v8i v8i_leq(v8i a, v8i b)
Compares if elements of a are less than or equal to those of b.
v1f::v1f_frsqrt
v1f v1f_frsqrt(v1f a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v1f::v1f_cvt_v4f
v1f v1f_cvt_v4f(v4f a)
Converts a v4f vector into a v1f vector.
v1i::v1i_cast_v4i
v1i v1i_cast_v4i(v4i a)
Casts a v4i vector into a v1i vector.
v8d::m8d_neq
m8d m8d_neq(v8d a, v8d b)
Compares the inequality of the two input vectors.
v16f::v16f_cvt_v2i
v16f v16f_cvt_v2i(v2i a)
Converts a v2i vector into a v16f vector.
v4i::v4i_cvt_v8f
v4i v4i_cvt_v8f(v8f a)
Converts a v8f vector into a v4i vector.
v2f::v2f_reduce_min_v4f
v2f v2f_reduce_min_v4f(v4f a)
Reduction min ( min )
v2d::v2d_ornot
v2d v2d_ornot(v2d a, v2d b)
Bitwise ornot ( a | ~b )
v16f::v16f_merge_v8f
v16f v16f_merge_v8f(v8f low, v8f high)
Merges 2 v8f vectors together.
v2l::v2l_cast_v16f
v2l v2l_cast_v16f(v16f a)
Casts a v16f vector into a v2l vector.
v4f::v4f_blend1
v4f v4f_blend1(v4f a, v4f b, uint_fast8_t mask)
Creates a new v4f vector whose elements are from a and b choosed by mask.
v8d::v8d_permute2
v8d v8d_permute2(v8d a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v8l::v8l_reduce_or
v8l v8l_reduce_or(v8l a)
Reduction or ( | )
v2d::v2d_or
v2d v2d_or(v2d a, v2d b)
Bitwise or ( a | b )
v16i::v16i_fshuffle4
v16i v16i_fshuffle4(v16i a, v16i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8l::v8l_blend2
v8l v8l_blend2(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v4i::v4i_cast_v4d
v4i v4i_cast_v4d(v4d a)
Casts a v4d vector into a v4i vector.
v16i::v16i_permute2
v16i v16i_permute2(v16i a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v1l::v1l_reduce_min_v2l
v1l v1l_reduce_min_v2l(v2l a)
Reduction min ( min )
v4l::v4l_frsqrt
v4l v4l_frsqrt(v4l a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v2i::v2i_reduce_add_v4i
v2i v2i_reduce_add_v4i(v4i a)
Reduction add ( + )
v1d::v1d_hshuffle
v1d v1d_hshuffle(v1d a, v1d b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v8l::v8l_frsqrt
v8l v8l_frsqrt(v8l a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v2f::v2f_cast_v2d
v2f v2f_cast_v2d(v2d a)
Casts a v2d vector into a v2f vector.
v2l::v2l_mask_move
v2l v2l_mask_move(m2l mask, v2l src, v2l a)
Mask the input.
v8i::si_reduce_and_v8i
v8i si_reduce_and_v8i(v8i a)
Reduction and ( & )
v1f::v1f_min
v1f v1f_min(v1f a, v1f b)
Elementwise min ( a < b ? a : b )
v2d::v2d_reduce_and_v1d
v2d v2d_reduce_and_v1d(v1d a)
Reduction and ( & )
v1f::v1f_cast_m1f
v1f v1f_cast_m1f(m1f a)
Casts a m1f vector-mask into a v1f vector.
v2i::v2i_move
v2i v2i_move(v2i a)
Forwards the input.
v1i::v1i_geq
v1i v1i_geq(v1i a, v1i b)
Compares if elements of a are greater than or equal to those of b.
v2l::v2l_reduce_or_v8l
v2l v2l_reduce_or_v8l(v8l a)
Reduction or ( | )
v8f::v8f_reduce_mul_v1f
v8f v8f_reduce_mul_v1f(v1f a)
Reduction mul ( * )
v8d::v8d_store
void v8d_store(double *p, v8d a)
Stores a v8d vector into memory.
v1f::v1f_reduce_or_v4f
v1f v1f_reduce_or_v4f(v4f a)
Reduction or ( | )
v16i::v16i_cvt_v2f
v16i v16i_cvt_v2f(v2f a)
Converts a v2f vector into a v16i vector.
v4d::v4d_reduce_max_v8d
v4d v4d_reduce_max_v8d(v8d a)
Reduction max ( max )
v2i::v2i_reduce_min_v2i
v2i v2i_reduce_min_v2i(v2i a)
Reduction min ( min )
v1f::v1f_rprintf
void v1f_rprintf(v1f a, const char *format)
Prints a v1f vector (reversed order)
v8d::v8d_cast_v8l
v8d v8d_cast_v8l(v8l a)
Casts a v8l vector into a v8d vector.
v1i::v1i_reduce_min_v4i
v1i v1i_reduce_min_v4i(v4i a)
Reduction min ( min )
v2d::sd_reduce_and_v2d
v2d sd_reduce_and_v2d(v2d a)
Reduction and ( & )
v4i::v4i_set1
v4i v4i_set1(int32_t v)
Broadcasts a single value into all elements of a v4i vector.
v16f::v16f_fprint
void v16f_fprint(FILE *file, v16f a)
Prints a v16f vector.
v2i::v2i_cvt_v16f
v2i v2i_cvt_v16f(v16f a)
Converts a v16f vector into a v2i vector.
v8i::m8i_nor
m8i m8i_nor(m8i a, m8i b)
Bitwise nor ( ~(a | b) )
v2d::m2d_ornot
m2d m2d_ornot(m2d a, m2d b)
Bitwise ornot ( a | ~b )
v2l::v2l_move
v2l v2l_move(v2l a)
Forwards the input.
v4l::v4l_geq
v4l v4l_geq(v4l a, v4l b)
Compares if elements of a are greater than or equal to those of b.
v16i::v16i_hshuffle16x1
v16i v16i_hshuffle16x1(v16i a, v16i b, uint_fast64_t rule)
Shuffles (inner) a and b together using the control in rule.
v4i::v4i_load1
v4i v4i_load1(const int32_t *p)
Loads 1 int32_t from memory and broadcasts it into a v4i vector.
v16f::v16f_hshuffle4
v16f v16f_hshuffle4(v16f a, v16f b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v8l::v8l_merge4_v2l
v8l v8l_merge4_v2l(v2l a0, v2l a1, v2l a2, v2l a3)
Merges 4 v2l vectors together.
v1l::sl_cvt_v4l
int64_t sl_cvt_v4l(v4l a)
Converts the first value of a v4l vector into int64_t.
v1l::sl_cvt_v2d
int64_t sl_cvt_v2d(v2d a)
Converts the first value of a v2d vector into int64_t.
v4i::v4i_reduce_and_v4i
v4i v4i_reduce_and_v4i(v4i a)
Reduction and ( & )
v2f::v2f_and
v2f v2f_and(v2f a, v2f b)
Bitwise and ( a & b )
v2l::v2l_rfprint
void v2l_rfprint(FILE *file, v2l a)
Prints a v2l vector (reversed order)
v4d::v4d_cast_v8i
v4d v4d_cast_v8i(v8i a)
Casts a v8i vector into a v4d vector.
v1l::v1l_reduce_mul_v4l
v1l v1l_reduce_mul_v4l(v4l a)
Reduction mul ( * )
v1l::v1l_set
v1l v1l_set(int64_t v0)
Sets the elements of a v1l vector.
v16f::v16f_neq
v16f v16f_neq(v16f a, v16f b)
Compares the inequality of the two input vectors.
v2l::v2l_nor
v2l v2l_nor(v2l a, v2l b)
Bitwise nor ( ~(a | b) )
v8d::v8d_fprint
void v8d_fprint(FILE *file, v8d a)
Prints a v8d vector.
v1l::v1l_cvt_v2l
v1l v1l_cvt_v2l(v2l a)
Converts a v2l vector into a v1l vector.
v2f::v2f_frsqrt
v2f v2f_frsqrt(v2f a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v1l::m1l_lt
m1l m1l_lt(v1l a, v1l b)
Compares if elements of a are less than those of b.
v2i::v2i_cvt_v2i
v2i v2i_cvt_v2i(v2i a)
Converts a v2i vector into a v2i vector.
v8d::m8d_nxor
m8d m8d_nxor(m8d a, m8d b)
Bitwise nxor ( ~(a ^ b) )
v8d::v8d_not
v8d v8d_not(v8d a)
Bitwise not ( ~a )
v2i::v2i_nand
v2i v2i_nand(v2i a, v2i b)
Bitwise nand ( ~(a & b) )
v1f::v1f_cvt_v16i
v1f v1f_cvt_v16i(v16i a)
Converts a v16i vector into a v1f vector.
v8d::v8d_xor
v8d v8d_xor(v8d a, v8d b)
Bitwise xor ( a ^ b )
v8f::v8f_eq
v8f v8f_eq(v8f a, v8f b)
Compares the equality of the two input vectors.
v16f::v16f_hshuffle8
v16f v16f_hshuffle8(v16f a, v16f b, uint_fast32_t rule)
Shuffles (outer) a and b together using the control in rule.
v2i::v2i_reduce_add_v8i
v2i v2i_reduce_add_v8i(v8i a)
Reduction add ( + )
v16f::v16f_rmerge_v8f
v16f v16f_rmerge_v8f(v8f high, v8f low)
Merges 2 v8f vectors together (reversed order).
v4i::v4i_rprintf
void v4i_rprintf(v4i a, const char *format)
Prints a v4i vector (reversed order)
v8l::v8l_cast_v2d
v8l v8l_cast_v2d(v2d a)
Casts a v2d vector into a v8l vector.
v8l::v8l_set
v8l v8l_set(int64_t v0, int64_t v1, int64_t v2, int64_t v3, int64_t v4, int64_t v5, int64_t v6, int64_t v7)
Sets the elements of a v8l vector.
v4i::v4i_move
v4i v4i_move(v4i a)
Forwards the input.
v4d::v4d_fmsub
v4d v4d_fmsub(v4d a, v4d b, v4d acc)
Fused Multiply-Sub ( (a * b) - acc )
v1l::v1l_reduce_and_v4l
v1l v1l_reduce_and_v4l(v4l a)
Reduction and ( & )
v8f::v8f_reduce_add
v8f v8f_reduce_add(v8f a)
Reduction add ( + )
v8d::v8d_set1
v8d v8d_set1(double v)
Broadcasts a single value into all elements of a v8d vector.
v8d::v8d_set_high_v4d
v8d v8d_set_high_v4d(v8d src, v4d high)
Sets the high part of a v8d vector.
v2d::m2d_xor
m2d m2d_xor(m2d a, m2d b)
Bitwise xor ( a ^ b )
v4f::v4f_storeu
void v4f_storeu(float *p, v4f a)
Stores a v4f vector into memory.
v16i::v16i_reduce_max_v2i
v16i v16i_reduce_max_v2i(v2i a)
Reduction max ( max )
v1f::v1f_reduce_min_v4f
v1f v1f_reduce_min_v4f(v4f a)
Reduction min ( min )
v2l::v2l_reduce_mul_v4l
v2l v2l_reduce_mul_v4l(v4l a)
Reduction mul ( * )
v16i::v16i_reduce_add_v1i
v16i v16i_reduce_add_v1i(v1i a)
Reduction add ( + )
v2f::v2f_rfprint
void v2f_rfprint(FILE *file, v2f a)
Prints a v2f vector (reversed order)
v4i::v4i_reduce_add_v4i
v4i v4i_reduce_add_v4i(v4i a)
Reduction add ( + )
v1f::v1f_rfprintf
void v1f_rfprintf(FILE *file, v1f a, const char *format)
Prints a v1f vector (reversed order)
v16f::v16f_nxor
v16f v16f_nxor(v16f a, v16f b)
Bitwise nxor ( ~(a ^ b) )
v4d::m4d_andnot
m4d m4d_andnot(m4d a, m4d b)
Bitwise andnot ( a & ~b )
v8d::v8d_cast_v8d
v8d v8d_cast_v8d(v8d a)
Casts a v8d vector into a v8d vector.
v2f::v2f_cast_v8i
v2f v2f_cast_v8i(v8i a)
Casts a v8i vector into a v2f vector.
v2i::m2i_leq
m2i m2i_leq(v2i a, v2i b)
Compares if elements of a are less than or equal to those of b.
v8i::v8i_reduce_add_v1i
v8i v8i_reduce_add_v1i(v1i a)
Reduction add ( + )
v2f::v2f_permute2x1
v2f v2f_permute2x1(v2f a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v2d::v2d_fnmsub
v2d v2d_fnmsub(v2d a, v2d b, v2d acc)
Fused Multiply-Add ( -(a * b) - acc )
v8d::v8d_cvt_v16i
v8d v8d_cvt_v16i(v16i a)
Converts a v16i vector into a v8d vector.
v16f::v16f_reduce_min
v16f v16f_reduce_min(v16f a)
Reduction min ( min )
v8d::v8d_lt
v8d v8d_lt(v8d a, v8d b)
Compares if elements of a are less than those of b.
v4i::v4i_cast_v8i
v4i v4i_cast_v8i(v8i a)
Casts a v8i vector into a v4i vector.
v2l::v2l_cvt_v2d
v2l v2l_cvt_v2d(v2d a)
Converts a v2d vector into a v2l vector.
v2i::v2i_permute2
v2i v2i_permute2(v2i a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v1l::sl_cvt_v16f
int64_t sl_cvt_v16f(v16f a)
Converts the first value of a v16f vector into int64_t.
v8f::v8f_cvt_v8i
v8f v8f_cvt_v8i(v8i a)
Converts a v8i vector into a v8f vector.
v4i::si_reduce_add_v4i
v4i si_reduce_add_v4i(v4i a)
Reduction add ( + )
v8i::m8i_cvt_m8i
m8i m8i_cvt_m8i(m8i a)
Converts a m8i vector-mask into a m8i vector-mask.
v2i::v2i_set_low_v1i
v2i v2i_set_low_v1i(v2i src, v1i low)
Sets the low part of a v2i vector.
v8i::m8i_lt
m8i m8i_lt(v8i a, v8i b)
Compares if elements of a are less than those of b.
v8f::v8f_mask_move
v8f v8f_mask_move(m8f mask, v8f src, v8f a)
Mask the input.
v1f::v1f_blend1x1
v1f v1f_blend1x1(v1f a, v1f b, uint_fast8_t mask)
Creates a new v1f vector whose elements are from a and b choosed by mask.
v1i::v1i_and
v1i v1i_and(v1i a, v1i b)
Bitwise and ( a & b )
v16i::v16i_geq
v16i v16i_geq(v16i a, v16i b)
Compares if elements of a are greater than or equal to those of b.
v4i::si_reduce_min_v4i
v4i si_reduce_min_v4i(v4i a)
Reduction min ( min )
v1f::v1f_reduce_or_v8f
v1f v1f_reduce_or_v8f(v8f a)
Reduction or ( | )
v8i::v8i_nor
v8i v8i_nor(v8i a, v8i b)
Bitwise nor ( ~(a | b) )
v2l::v2l_reduce_or_v1l
v2l v2l_reduce_or_v1l(v1l a)
Reduction or ( | )
v1i::si_cvt_v1f
int32_t si_cvt_v1f(v1f a)
Converts the first value of a v1f vector into int32_t.
v1f::v1f_reduce_max_v2f
v1f v1f_reduce_max_v2f(v2f a)
Reduction max ( max )
v16f::v16f_eq
v16f v16f_eq(v16f a, v16f b)
Compares the equality of the two input vectors.
v8f::v8f_frsqrt
v8f v8f_frsqrt(v8f a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v1d::v1d_reduce_and_v8d
v1d v1d_reduce_and_v8d(v8d a)
Reduction and ( & )
v1d::v1d_reduce_max_v1d
v1d v1d_reduce_max_v1d(v1d a)
Reduction max ( max )
v2d::v2d_reduce_min
v2d v2d_reduce_min(v2d a)
Reduction min ( min )
v8i::v8i_or
v8i v8i_or(v8i a, v8i b)
Bitwise or ( a | b )
v1l::m1l_not
m1l m1l_not(m1l a)
Bitwise not ( ~a )
v16i::v16i_nor
v16i v16i_nor(v16i a, v16i b)
Bitwise nor ( ~(a | b) )
v8l::v8l_abs
v8l v8l_abs(v8l a)
Elementwise absolute value ( a > 0 ? a : -a )
v2d::v2d_cvt_v1f
v2d v2d_cvt_v1f(v1f a)
Converts a v1f vector into a v2d vector.
v1l::v1l_mul
v1l v1l_mul(v1l a, v1l b)
Elementwise multiplication ( a * b )
v1f::v1f_zeros
v1f v1f_zeros()
Sets all bits to 0.
v16f::v16f_fshuffle16x1
v16f v16f_fshuffle16x1(v16f a, v16f b, uint_fast64_t rule, uint_fast16_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1d::v1d_cvt_v4i
v1d v1d_cvt_v4i(v4i a)
Converts a v4i vector into a v1d vector.
v1d::v1d_nor
v1d v1d_nor(v1d a, v1d b)
Bitwise nor ( ~(a | b) )
v8i::m8i_geq
m8i m8i_geq(v8i a, v8i b)
Compares if elements of a are greater than or equal to those of b.
v4f::v4f_nor
v4f v4f_nor(v4f a, v4f b)
Bitwise nor ( ~(a | b) )
v4i::v4i_mul
v4i v4i_mul(v4i a, v4i b)
Elementwise multiplication ( a * b )
v2i::v2i_abs
v2i v2i_abs(v2i a)
Elementwise absolute value ( a > 0 ? a : -a )
v1f::v1f_cast_v16i
v1f v1f_cast_v16i(v16i a)
Casts a v16i vector into a v1f vector.
v4l::v4l_hshuffle2x2
v4l v4l_hshuffle2x2(v4l a, v4l b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v1d::v1d_reduce_max_v4d
v1d v1d_reduce_max_v4d(v4d a)
Reduction max ( max )
v4d::v4d_zeros
v4d v4d_zeros()
Sets all bits to 0.
v2f::v2f_cvt_v4l
v2f v2f_cvt_v4l(v4l a)
Converts a v4l vector into a v2f vector.
v2d::v2d_cast_v8l
v2d v2d_cast_v8l(v8l a)
Casts a v8l vector into a v2d vector.
v4f::v4f_reduce_add_v2f
v4f v4f_reduce_add_v2f(v2f a)
Reduction add ( + )
v16f::v16f_store1
void v16f_store1(float *p, v16f a)
Stores the first element of a v16f vector into memory.
v1f::sf_cvt_v16i
float sf_cvt_v16i(v16i a)
Converts the first value of a v16i vector into float.
v16i::v16i_blend16
v16i v16i_blend16(v16i a, v16i b, uint_fast16_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v1i::v1i_cvt_v4l
v1i v1i_cvt_v4l(v4l a)
Converts a v4l vector into a v1i vector.
v4l::v4l_blend1x4
v4l v4l_blend1x4(v4l a, v4l b, uint_fast8_t mask)
Creates a new v4l vector whose elements are from a and b choosed by mask.
v8l::m8l_cvt_m8i
m8l m8l_cvt_m8i(m8i a)
Converts a m8i vector-mask into a m8l vector-mask.
v1i::m1i_eq
m1i m1i_eq(v1i a, v1i b)
Compares the equality of the two input vectors.
v8f::v8f_blend4x2
v8f v8f_blend4x2(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v4l::v4l_fmsub
v4l v4l_fmsub(v4l a, v4l b, v4l acc)
Fused Multiply-Sub ( (a * b) - acc )
v16i::v16i_merge8_v2i
v16i v16i_merge8_v2i(v2i a0, v2i a1, v2i a2, v2i a3, v2i a4, v2i a5, v2i a6, v2i a7)
Merges 8 v2i vectors together.
v2i::v2i_cast_v16i
v2i v2i_cast_v16i(v16i a)
Casts a v16i vector into a v2i vector.
v8d::v8d_reduce_max_v8d
v8d v8d_reduce_max_v8d(v8d a)
Reduction max ( max )
v8f::v8f_div
v8f v8f_div(v8f a, v8f b)
Elementwise division ( a / b )
v2i::m2i_geq
m2i m2i_geq(v2i a, v2i b)
Compares if elements of a are greater than or equal to those of b.
v1f::sf_cvt_v2f
float sf_cvt_v2f(v2f a)
Converts the first value of a v2f vector into float.
v2l::v2l_one
v2l v2l_one()
Sets all elements to 1.
v8d::v8d_reduce_min_v1d
v8d v8d_reduce_min_v1d(v1d a)
Reduction min ( min )
v16f::v16f_rmerge16_v1f
v16f v16f_rmerge16_v1f(v1f a15, v1f a14, v1f a13, v1f a12, v1f a11, v1f a10, v1f a9, v1f a8, v1f a7, v1f a6, v1f a5, v1f a4, v1f a3, v1f a2, v1f a1, v1f a0)
Merges 16 v1f vectors together (reverse order).
v1f::v1f_reduce_and_v4f
v1f v1f_reduce_and_v4f(v4f a)
Reduction and ( & )
v4i::v4i_reduce_mul_v1i
v4i v4i_reduce_mul_v1i(v1i a)
Reduction mul ( * )
v1f::v1f_rprint
void v1f_rprint(v1f a)
Prints a v1f vector (reversed order)
v8d::v8d_fshuffle
v8d v8d_fshuffle(v8d a, v8d b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8f::v8f_andnot
v8f v8f_andnot(v8f a, v8f b)
Bitwise andnot ( a & ~b )
v8l::m8l_lt
m8l m8l_lt(v8l a, v8l b)
Compares if elements of a are less than those of b.
v16f::v16f_reduce_mul_v1f
v16f v16f_reduce_mul_v1f(v1f a)
Reduction mul ( * )
v8i::v8i_set1
v8i v8i_set1(int32_t v)
Broadcasts a single value into all elements of a v8i vector.
v8f::v8f_rmerge2_v4f
v8f v8f_rmerge2_v4f(v4f a1, v4f a0)
Merges 2 v4f vectors together (reverse order).
v1l::v1l_reduce_max_v4l
v1l v1l_reduce_max_v4l(v4l a)
Reduction max ( max )
v1d::v1d_reduce_or_v1d
v1d v1d_reduce_or_v1d(v1d a)
Reduction or ( | )
v16f::v16f_reduce_add_v1f
v16f v16f_reduce_add_v1f(v1f a)
Reduction add ( + )
m8d
Type for the manipulation of vector-masks.
Definition: pints-doc.h:552
v4i::v4i_cvt_v1d
v4i v4i_cvt_v1d(v1d a)
Converts a v1d vector into a v4i vector.
v16i::v16i_fshuffle8
v16i v16i_fshuffle8(v16i a, v16i b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v4i::m4i_eq
m4i m4i_eq(v4i a, v4i b)
Compares the equality of the two input vectors.
v2l::v2l_cast_v2l
v2l v2l_cast_v2l(v2l a)
Casts a v2l vector into a v2l vector.
v16f::v16f_reduce_mul_v8f
v16f v16f_reduce_mul_v8f(v8f a)
Reduction mul ( * )
v4l::v4l_cvt_v16i
v4l v4l_cvt_v16i(v16i a)
Converts a v16i vector into a v4l vector.
v16i::v16i_reduce_or_v16i
v16i v16i_reduce_or_v16i(v16i a)
Reduction or ( | )
v8d::v8d_reduce_or_v8d
v8d v8d_reduce_or_v8d(v8d a)
Reduction or ( | )
v2d::sd_reduce_add_v2d
v2d sd_reduce_add_v2d(v2d a)
Reduction add ( + )
v4d::v4d_mask_move
v4d v4d_mask_move(m4d mask, v4d src, v4d a)
Mask the input.
v2f::v2f_neq
v2f v2f_neq(v2f a, v2f b)
Compares the inequality of the two input vectors.
v1l::v1l_cvt_v1f
v1l v1l_cvt_v1f(v1f a)
Converts a v1f vector into a v1l vector.
v4i::v4i_ornot
v4i v4i_ornot(v4i a, v4i b)
Bitwise ornot ( a | ~b )
v4f::v4f_cvt_v2l
v4f v4f_cvt_v2l(v2l a)
Converts a v2l vector into a v4f vector.
v4f::v4f_fnmsub
v4f v4f_fnmsub(v4f a, v4f b, v4f acc)
Fused Multiply-Add ( -(a * b) - acc )
v4d::v4d_load1
v4d v4d_load1(const double *p)
Loads 1 double from memory and broadcasts it into a v4d vector.
v8f::v8f_cast_v1i
v8f v8f_cast_v1i(v1i a)
Casts a v1i vector into a v8f vector.
v1d::m1d_xor
m1d m1d_xor(m1d a, m1d b)
Bitwise xor ( a ^ b )
v8f::v8f_permute2
v8f v8f_permute2(v8f a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v1i::v1i_lt
v1i v1i_lt(v1i a, v1i b)
Compares if elements of a are less than those of b.
v2d::v2d_permute2x1
v2d v2d_permute2x1(v2d a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v4f::v4f_hshuffle4x1
v4f v4f_hshuffle4x1(v4f a, v4f b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v16i::v16i_fshuffle16
v16i v16i_fshuffle16(v16i a, v16i b, uint_fast64_t rule, uint_fast16_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8l::v8l_merge8_v1l
v8l v8l_merge8_v1l(v1l a0, v1l a1, v1l a2, v1l a3, v1l a4, v1l a5, v1l a6, v1l a7)
Merges 8 v1l vectors together.
v2d::v2d_cast_v1f
v2d v2d_cast_v1f(v1f a)
Casts a v1f vector into a v2d vector.
v8d::sd_reduce_or_v8d
v8d sd_reduce_or_v8d(v8d a)
Reduction or ( | )
v4i::v4i_reduce_or_v8i
v4i v4i_reduce_or_v8i(v8i a)
Reduction or ( | )
v8d::v8d_zero
v8d v8d_zero()
Sets all elements to 0.
v4l::v4l_cvt_v2i
v4l v4l_cvt_v2i(v2i a)
Converts a v2i vector into a v4l vector.
v8d::v8d_hshuffle4x2
v8d v8d_hshuffle4x2(v8d a, v8d b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v1l::sl_cvt_v2i
int64_t sl_cvt_v2i(v2i a)
Converts the first value of a v2i vector into int64_t.
v8f::v8f_set_low_v4f
v8f v8f_set_low_v4f(v8f src, v4f low)
Sets the low part of a v8f vector.
v1f::m1f_cvt_m1l
m1f m1f_cvt_m1l(m1l a)
Converts a m1l vector-mask into a m1f vector-mask.
v8i::v8i_load1
v8i v8i_load1(const int32_t *p)
Loads 1 int32_t from memory and broadcasts it into a v8i vector.
v2l::v2l_reduce_max_v8l
v2l v2l_reduce_max_v8l(v8l a)
Reduction max ( max )
v8l::v8l_max
v8l v8l_max(v8l a, v8l b)
Elementwise max ( a > b ? a : b )
v4l::v4l_nand
v4l v4l_nand(v4l a, v4l b)
Bitwise nand ( ~(a & b) )
v2i::m2i_cast_v2i
m2i m2i_cast_v2i(v2i a)
Casts a v2i vector into a m2i vector-mask.
v4d::v4d_store
void v4d_store(double *p, v4d a)
Stores a v4d vector into memory.
v8d::v8d_reduce_add_v2d
v8d v8d_reduce_add_v2d(v2d a)
Reduction add ( + )
v1l::m1l_cvt_m1i
m1l m1l_cvt_m1i(m1i a)
Converts a m1i vector-mask into a m1l vector-mask.
v8l::v8l_blend8x1
v8l v8l_blend8x1(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v8i::v8i_fmadd
v8i v8i_fmadd(v8i a, v8i b, v8i acc)
Fused Multiply-Add ( (a * b) + acc )
v1f::v1f_move
v1f v1f_move(v1f a)
Forwards the input.
v2i::v2i_reduce_or_v2i
v2i v2i_reduce_or_v2i(v2i a)
Reduction or ( | )
v4d::v4d_reduce_mul_v8d
v4d v4d_reduce_mul_v8d(v8d a)
Reduction mul ( * )
v8d::v8d_cvt_v4l
v8d v8d_cvt_v4l(v4l a)
Converts a v4l vector into a v8d vector.
v4d::v4d_div
v4d v4d_div(v4d a, v4d b)
Elementwise division ( a / b )
v2f::v2f_fprintf
void v2f_fprintf(FILE *file, v2f a, const char *format)
Prints a v2f vector.
v8l::m8l_leq
m8l m8l_leq(v8l a, v8l b)
Compares if elements of a are less than or equal to those of b.
v1l::v1l_cvt_v16f
v1l v1l_cvt_v16f(v16f a)
Converts a v16f vector into a v1l vector.
v4i::v4i_reduce_mul_v2i
v4i v4i_reduce_mul_v2i(v2i a)
Reduction mul ( * )
v8f::m8f_leq
m8f m8f_leq(v8f a, v8f b)
Compares if elements of a are less than or equal to those of b.
v16i::v16i_cvt_v16f
v16i v16i_cvt_v16f(v16f a)
Converts a v16f vector into a v16i vector.
v1i::si_reduce_min_v1i
v1i si_reduce_min_v1i(v1i a)
Reduction min ( min )
v16i::si_reduce_add_v16i
v16i si_reduce_add_v16i(v16i a)
Reduction add ( + )
v2l::m2l_leq
m2l m2l_leq(v2l a, v2l b)
Compares if elements of a are less than or equal to those of b.
v2i::v2i_permute
v2i v2i_permute(v2i a, uint_fast8_t rule)
Shuffles a using the control in rule.
v8l::v4l_get_low_v8l
v4l v4l_get_low_v8l(v8l a)
Gets the low part of a v8l vector.
v16f::v16f_reduce_min_v1f
v16f v16f_reduce_min_v1f(v1f a)
Reduction min ( min )
v16f::v16f_cvt_v8f
v16f v16f_cvt_v8f(v8f a)
Converts a v8f vector into a v16f vector.
v4i::m4i_leq
m4i m4i_leq(v4i a, v4i b)
Compares if elements of a are less than or equal to those of b.
v1l::v1l_cvt_v4d
v1l v1l_cvt_v4d(v4d a)
Converts a v4d vector into a v1l vector.
v8l::v8l_rsqrt
v8l v8l_rsqrt(v8l a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v8d::v8d_nand
v8d v8d_nand(v8d a, v8d b)
Bitwise nand ( ~(a & b) )
v4l::v4l_set1
v4l v4l_set1(int64_t v)
Broadcasts a single value into all elements of a v4l vector.
v2l::v2l_rprintf
void v2l_rprintf(v2l a, const char *format)
Prints a v2l vector (reversed order)
v4d::v4d_cvt_v4i
v4d v4d_cvt_v4i(v4i a)
Converts a v4i vector into a v4d vector.
v4i::v4i_reduce_mul_v16i
v4i v4i_reduce_mul_v16i(v16i a)
Reduction mul ( * )
v2i::v2i_cvt_v4f
v2i v2i_cvt_v4f(v4f a)
Converts a v4f vector into a v2i vector.
v2f::v2f_reduce_mul_v1f
v2f v2f_reduce_mul_v1f(v1f a)
Reduction mul ( * )
v4d::m4d_cvt_m4i
m4d m4d_cvt_m4i(m4i a)
Converts a m4i vector-mask into a m4d vector-mask.
v8f::v8f_blend2
v8f v8f_blend2(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v16i::v16i_reduce_min_v16i
v16i v16i_reduce_min_v16i(v16i a)
Reduction min ( min )
v4i::v4i_reduce_add_v2i
v4i v4i_reduce_add_v2i(v2i a)
Reduction add ( + )
v4d::v4d_hshuffle2x2
v4d v4d_hshuffle2x2(v4d a, v4d b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v4i::v4i_min
v4i v4i_min(v4i a, v4i b)
Elementwise min ( a < b ? a : b )
v8f::v8f_store
void v8f_store(float *p, v8f a)
Stores a v8f vector into memory.
v2l::v2l_cvt_v1f
v2l v2l_cvt_v1f(v1f a)
Converts a v1f vector into a v2l vector.
v2l::v2l_rmerge_v1l
v2l v2l_rmerge_v1l(v1l high, v1l low)
Merges 2 v1l vectors together (reversed order).
v1f::m1f_and
m1f m1f_and(m1f a, m1f b)
Bitwise and ( a & b )
v4l::v4l_reduce_max_v2l
v4l v4l_reduce_max_v2l(v2l a)
Reduction max ( max )
v4l::v4l_fshuffle4
v4l v4l_fshuffle4(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2f::v1f_get_low_v2f
v1f v1f_get_low_v2f(v2f a)
Gets the low part of a v2f vector.
v1d::m1d_cvt_m1l
m1d m1d_cvt_m1l(m1l a)
Converts a m1l vector-mask into a m1d vector-mask.
v4d::v4d_cvt_v4f
v4d v4d_cvt_v4f(v4f a)
Converts a v4f vector into a v4d vector.
v1l::v1l_set1
v1l v1l_set1(int64_t v)
Broadcasts a single value into all elements of a v1l vector.
v8d::sd_reduce_and_v8d
v8d sd_reduce_and_v8d(v8d a)
Reduction and ( & )
v8d::v8d_cvt_v8d
v8d v8d_cvt_v8d(v8d a)
Converts a v8d vector into a v8d vector.
v2d::v2d_fnmadd
v2d v2d_fnmadd(v2d a, v2d b, v2d acc)
Fused Multiply-Add ( -(a * b) + acc )
v16i::v16i_load
v16i v16i_load(const int32_t *p)
Loads 16 int32_t from memory into a v16i vector.
v4f::v4f_rcp
v4f v4f_rcp(v4f a)
Elementwise reciprocal ( 1 / a )
v2f::v2f_fprint
void v2f_fprint(FILE *file, v2f a)
Prints a v2f vector.
v16f::v16f_rmerge2_v8f
v16f v16f_rmerge2_v8f(v8f a1, v8f a0)
Merges 2 v8f vectors together (reverse order).
v1d::v1d_cast_v8f
v1d v1d_cast_v8f(v8f a)
Casts a v8f vector into a v1d vector.
v1l::sl_cvt_v8f
int64_t sl_cvt_v8f(v8f a)
Converts the first value of a v8f vector into int64_t.
v8f::v8f_reduce_max
v8f v8f_reduce_max(v8f a)
Reduction max ( max )
v1i::v1i_cvt_v1l
v1i v1i_cvt_v1l(v1l a)
Converts a v1l vector into a v1i vector.
v1l::v1l_reduce_min_v4l
v1l v1l_reduce_min_v4l(v4l a)
Reduction min ( min )
v2d::v2d_reduce_max
v2d v2d_reduce_max(v2d a)
Reduction max ( max )
v1f::v1f_cast_v2i
v1f v1f_cast_v2i(v2i a)
Casts a v2i vector into a v1f vector.
v4f::v4f_hshuffle4
v4f v4f_hshuffle4(v4f a, v4f b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v2i::v2i_rmerge_v1i
v2i v2i_rmerge_v1i(v1i high, v1i low)
Merges 2 v1i vectors together (reversed order).
v1f::v1f_one
v1f v1f_one()
Sets all elements to 1.
v8f::v8f_lt
v8f v8f_lt(v8f a, v8f b)
Compares if elements of a are less than those of b.
v1f::v1f_cast_v2d
v1f v1f_cast_v2d(v2d a)
Casts a v2d vector into a v1f vector.
v2f::v2f_storeu
void v2f_storeu(float *p, v2f a)
Stores a v2f vector into memory.
v2i::m2i_cvt_v2i
m2i m2i_cvt_v2i(v2i a)
Converts a v2i vector into a m2i vector-mask.
v4f::m4f_not
m4f m4f_not(m4f a)
Bitwise not ( ~a )
v4i::v4i_cast_v2i
v4i v4i_cast_v2i(v2i a)
Casts a v2i vector into a v4i vector.
v4i::v4i_reduce_max
v4i v4i_reduce_max(v4i a)
Reduction max ( max )
v16i::m16i_neq
m16i m16i_neq(v16i a, v16i b)
Compares the inequality of the two input vectors.
v2d::m2d_and
m2d m2d_and(m2d a, m2d b)
Bitwise and ( a & b )
v8f::v8f_min
v8f v8f_min(v8f a, v8f b)
Elementwise min ( a < b ? a : b )
v1l::v1l_cast_v8d
v1l v1l_cast_v8d(v8d a)
Casts a v8d vector into a v1l vector.
v16f::v16f_merge2_v8f
v16f v16f_merge2_v8f(v8f a0, v8f a1)
Merges 2 v8f vectors together.
v1d::v1d_reduce_max
v1d v1d_reduce_max(v1d a)
Reduction max ( max )
v1f::m1f_cvt_m1i
m1f m1f_cvt_m1i(m1i a)
Converts a m1i vector-mask into a m1f vector-mask.
v4d::v4d_blend1x4
v4d v4d_blend1x4(v4d a, v4d b, uint_fast8_t mask)
Creates a new v4d vector whose elements are from a and b choosed by mask.
v1d::sd_reduce_and_v1d
v1d sd_reduce_and_v1d(v1d a)
Reduction and ( & )
v4f::v4f_fmadd
v4f v4f_fmadd(v4f a, v4f b, v4f acc)
Fused Multiply-Add ( (a * b) + acc )
v16f::m16f_and
m16f m16f_and(m16f a, m16f b)
Bitwise and ( a & b )
v16i::v16i_rset
v16i v16i_rset(int32_t v15, int32_t v14, int32_t v13, int32_t v12, int32_t v11, int32_t v10, int32_t v9, int32_t v8, int32_t v7, int32_t v6, int32_t v5, int32_t v4, int32_t v3, int32_t v2, int32_t v1, int32_t v0)
Sets the elements of a v16i vector (reverse order).
v8l::sl_reduce_max_v8l
v8l sl_reduce_max_v8l(v8l a)
Reduction max ( max )
v1d::sd_cvt_v1l
double sd_cvt_v1l(v1l a)
Converts the first value of a v1l vector into double.
v8l::v8l_reduce_mul_v1l
v8l v8l_reduce_mul_v1l(v1l a)
Reduction mul ( * )
v4f::v4f_cast_v2d
v4f v4f_cast_v2d(v2d a)
Casts a v2d vector into a v4f vector.
v4f::v4f_frcp
v4f v4f_frcp(v4f a)
Fast elementwise reciprocal ( 1 / a )
v8f::v8f_rsqrt
v8f v8f_rsqrt(v8f a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v2d::m2d_leq
m2d m2d_leq(v2d a, v2d b)
Compares if elements of a are less than or equal to those of b.
v2l::m2l_lt
m2l m2l_lt(v2l a, v2l b)
Compares if elements of a are less than those of b.
v8d::m8d_nand
m8d m8d_nand(m8d a, m8d b)
Bitwise nand ( ~(a & b) )
v4i::v4i_cast_v2l
v4i v4i_cast_v2l(v2l a)
Casts a v2l vector into a v4i vector.
v2f::v2f_store1
void v2f_store1(float *p, v2f a)
Stores the first element of a v2f vector into memory.
v4l::v4l_not
v4l v4l_not(v4l a)
Bitwise not ( ~a )
v8f::v8f_reduce_or_v8f
v8f v8f_reduce_or_v8f(v8f a)
Reduction or ( | )
v8f::v8f_permute8x1
v8f v8f_permute8x1(v8f a, uint_fast32_t rule)
Shuffles (inner) a using the control in rule.
v2d::v2d_set_high_v1d
v2d v2d_set_high_v1d(v2d src, v1d high)
Sets the high part of a v2d vector.
v1f::v1f_nor
v1f v1f_nor(v1f a, v1f b)
Bitwise nor ( ~(a | b) )
v8d
Type for the manipulation of 8 double packed into one single vector.
Definition: pints-doc.h:531
v16i::v8i_get_low_v16i
v8i v8i_get_low_v16i(v16i a)
Gets the low part of a v16i vector.
v1l::v1l_reduce_max
v1l v1l_reduce_max(v1l a)
Reduction max ( max )
v8d::v8d_blend8x1
v8d v8d_blend8x1(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v2l::v2l_hshuffle2
v2l v2l_hshuffle2(v2l a, v2l b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v1i::v1i_reduce_add_v16i
v1i v1i_reduce_add_v16i(v16i a)
Reduction add ( + )
v4l::v4l_reduce_or_v4l
v4l v4l_reduce_or_v4l(v4l a)
Reduction or ( | )
v1l::sl_cvt_v16i
int64_t sl_cvt_v16i(v16i a)
Converts the first value of a v16i vector into int64_t.
v4l::v4l_hshuffle2
v4l v4l_hshuffle2(v4l a, v4l b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v1d::v1d_rcp
v1d v1d_rcp(v1d a)
Elementwise reciprocal ( 1 / a )
v1l::v1l_frcp
v1l v1l_frcp(v1l a)
Fast elementwise reciprocal ( 1 / a )
v8l::v8l_blend1x8
v8l v8l_blend1x8(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v4f::v4f_cvt_m4f
v4f v4f_cvt_m4f(m4f a)
Converts a m4f vector-mask into a v4f vector.
v8i::v8i_reduce_max_v1i
v8i v8i_reduce_max_v1i(v1i a)
Reduction max ( max )
v8f::v8f_cast_v4i
v8f v8f_cast_v4i(v4i a)
Casts a v4i vector into a v8f vector.
v8i::v8i_cvt_v2d
v8i v8i_cvt_v2d(v2d a)
Converts a v2d vector into a v8i vector.
v8i::v8i_reduce_max
v8i v8i_reduce_max(v8i a)
Reduction max ( max )
v2l::v2l_blend1x2
v2l v2l_blend1x2(v2l a, v2l b, uint_fast8_t mask)
Creates a new v2l vector whose elements are from a and b choosed by mask.
v1f::m1f_nxor
m1f m1f_nxor(m1f a, m1f b)
Bitwise nxor ( ~(a ^ b) )
v2l::m2l_nand
m2l m2l_nand(m2l a, m2l b)
Bitwise nand ( ~(a & b) )
v1d::v1d_fshuffle
v1d v1d_fshuffle(v1d a, v1d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4f::v4f_reduce_max_v4f
v4f v4f_reduce_max_v4f(v4f a)
Reduction max ( max )
v8l::v8l_fprintf
void v8l_fprintf(FILE *file, v8l a, const char *format)
Prints a v8l vector.
v16i::v16i_reduce_min
v16i v16i_reduce_min(v16i a)
Reduction min ( min )
v8i::v8i_loadu
v8i v8i_loadu(const int32_t *p)
Loads 8 int32_t from memory into a v8i vector.
v16f::v16f_and
v16f v16f_and(v16f a, v16f b)
Bitwise and ( a & b )
v4l::sl_reduce_add_v4l
v4l sl_reduce_add_v4l(v4l a)
Reduction add ( + )
v16f::v16f_reduce_add
v16f v16f_reduce_add(v16f a)
Reduction add ( + )
v2f::v1f_get_hilo_v2f
v1f v1f_get_hilo_v2f(v2f a, int high)
Conditionnaly gets the low or the high part of a v2f vector.
v4d::v4d_set_low_v2d
v4d v4d_set_low_v2d(v4d src, v2d low)
Sets the low part of a v4d vector.
v16i::v16i_fmadd
v16i v16i_fmadd(v16i a, v16i b, v16i acc)
Fused Multiply-Add ( (a * b) + acc )
v4l::v4l_blend4
v4l v4l_blend4(v4l a, v4l b, uint_fast8_t mask)
Creates a new v4l vector whose elements are from a and b choosed by mask.
v8d::v4d_get_hilo_v8d
v4d v4d_get_hilo_v8d(v8d a, int high)
Conditionnaly gets the low or the high part of a v8d vector.
v2l::v2l_print
void v2l_print(v2l a)
Prints a v2l vector.
v1f::sf_cvt_v1l
float sf_cvt_v1l(v1l a)
Converts the first value of a v1l vector into float.
v1i::si_cvt_v16f
int32_t si_cvt_v16f(v16f a)
Converts the first value of a v16f vector into int32_t.
v2f::v2f_reduce_min_v1f
v2f v2f_reduce_min_v1f(v1f a)
Reduction min ( min )
v1i::v1i_reduce_mul_v16i
v1i v1i_reduce_mul_v16i(v16i a)
Reduction mul ( * )
v2i::v2i_merge2_v1i
v2i v2i_merge2_v1i(v1i a0, v1i a1)
Merges 2 v1i vectors together.
v2f::v2f_reduce_add_v8f
v2f v2f_reduce_add_v8f(v8f a)
Reduction add ( + )
v2f::v2f_cast_v4f
v2f v2f_cast_v4f(v4f a)
Casts a v4f vector into a v2f vector.
v8d::v8d_reduce_min
v8d v8d_reduce_min(v8d a)
Reduction min ( min )
v8i::v8i_store1
void v8i_store1(int32_t *p, v8i a)
Stores the first element of a v8i vector into memory.
v1l::v1l_load
v1l v1l_load(const int64_t *p)
Loads 1 int64_t from memory into a v1l vector.
v16f::m16f_geq
m16f m16f_geq(v16f a, v16f b)
Compares if elements of a are greater than or equal to those of b.
v2i::si_reduce_and_v2i
v2i si_reduce_and_v2i(v2i a)
Reduction and ( & )
v8d::v8d_fshuffle8x1
v8d v8d_fshuffle8x1(v8d a, v8d b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8i::v8i_merge_v4i
v8i v8i_merge_v4i(v4i low, v4i high)
Merges 2 v4i vectors together.
v4l::v4l_fmadd
v4l v4l_fmadd(v4l a, v4l b, v4l acc)
Fused Multiply-Add ( (a * b) + acc )
v8d::v8d_cvt_v1d
v8d v8d_cvt_v1d(v1d a)
Converts a v1d vector into a v8d vector.
v8d::sd_reduce_max_v8d
v8d sd_reduce_max_v8d(v8d a)
Reduction max ( max )
v4i::v4i_reduce_max_v16i
v4i v4i_reduce_max_v16i(v16i a)
Reduction max ( max )
v4i::v4i_nxor
v4i v4i_nxor(v4i a, v4i b)
Bitwise nxor ( ~(a ^ b) )
v2d::v2d_cvt_v8l
v2d v2d_cvt_v8l(v8l a)
Converts a v8l vector into a v2d vector.
v2i::v2i_add
v2i v2i_add(v2i a, v2i b)
Elementwise addition ( a + b )
v2i::v2i_reduce_min_v4i
v2i v2i_reduce_min_v4i(v4i a)
Reduction min ( min )
v4i::m4i_cast_v4i
m4i m4i_cast_v4i(v4i a)
Casts a v4i vector into a m4i vector-mask.
v2f::v2f_rprint
void v2f_rprint(v2f a)
Prints a v2f vector (reversed order)
v1i::v1i_cvt_v2d
v1i v1i_cvt_v2d(v2d a)
Converts a v2d vector into a v1i vector.
v8d::v8d_reduce_and_v1d
v8d v8d_reduce_and_v1d(v1d a)
Reduction and ( & )
v2l::v2l_abs
v2l v2l_abs(v2l a)
Elementwise absolute value ( a > 0 ? a : -a )
v4i::v4i_reduce_mul_v4i
v4i v4i_reduce_mul_v4i(v4i a)
Reduction mul ( * )
v2i::v2i_cast_m2i
v2i v2i_cast_m2i(m2i a)
Casts a m2i vector-mask into a v2i vector.
v8i::m8i_cvt_m8d
m8i m8i_cvt_m8d(m8d a)
Converts a m8d vector-mask into a m8i vector-mask.
v16i::v16i_frcp
v16i v16i_frcp(v16i a)
Fast elementwise reciprocal ( 1 / a )
v4i::m4i_nor
m4i m4i_nor(m4i a, m4i b)
Bitwise nor ( ~(a | b) )
v8d::v8d_rfprint
void v8d_rfprint(FILE *file, v8d a)
Prints a v8d vector (reversed order)
v16i::v16i_fprintf
void v16i_fprintf(FILE *file, v16i a, const char *format)
Prints a v16i vector.
v4f::v4f_cvt_v1f
v4f v4f_cvt_v1f(v1f a)
Converts a v1f vector into a v4f vector.
v4i::v4i_cast_v2f
v4i v4i_cast_v2f(v2f a)
Casts a v2f vector into a v4i vector.
v1i::v1i_load
v1i v1i_load(const int32_t *p)
Loads 1 int32_t from memory into a v1i vector.
v4i::v4i_neq
v4i v4i_neq(v4i a, v4i b)
Compares the inequality of the two input vectors.
v4f::v4f_cvt_v4d
v4f v4f_cvt_v4d(v4d a)
Converts a v4d vector into a v4f vector.
v4i::v4i_reduce_min_v8i
v4i v4i_reduce_min_v8i(v8i a)
Reduction min ( min )
v2l::v2l_reduce_or_v2l
v2l v2l_reduce_or_v2l(v2l a)
Reduction or ( | )
v2l::v2l_fnmsub
v2l v2l_fnmsub(v2l a, v2l b, v2l acc)
Fused Multiply-Add ( -(a * b) - acc )
v4i::v4i_eq
v4i v4i_eq(v4i a, v4i b)
Compares the equality of the two input vectors.
v1l::v1l_fnmadd
v1l v1l_fnmadd(v1l a, v1l b, v1l acc)
Fused Multiply-Add ( -(a * b) + acc )
v2i::v2i_fshuffle
v2i v2i_fshuffle(v2i a, v2i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4l::v4l_reduce_and_v2l
v4l v4l_reduce_and_v2l(v2l a)
Reduction and ( & )
v16i::v16i_reduce_and_v2i
v16i v16i_reduce_and_v2i(v2i a)
Reduction and ( & )
v8i::v8i_reduce_min_v1i
v8i v8i_reduce_min_v1i(v1i a)
Reduction min ( min )
v16i::v16i_zero
v16i v16i_zero()
Sets all elements to 0.
v8i::v4i_get_hilo_v8i
v4i v4i_get_hilo_v8i(v8i a, int high)
Conditionnaly gets the low or the high part of a v8i vector.
v8d::v8d_reduce_min_v2d
v8d v8d_reduce_min_v2d(v2d a)
Reduction min ( min )
v2l::v2l_sub
v2l v2l_sub(v2l a, v2l b)
Elementwise subtraction ( a - b )
v8l::v8l_fshuffle4
v8l v8l_fshuffle4(v8l a, v8l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2i::v2i_set_high_v1i
v2i v2i_set_high_v1i(v2i src, v1i high)
Sets the high part of a v2i vector.
v8l::v8l_cvt_v2d
v8l v8l_cvt_v2d(v2d a)
Converts a v2d vector into a v8l vector.
v8f::v8f_blend1
v8f v8f_blend1(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v1d::v1d_mask_move
v1d v1d_mask_move(m1d mask, v1d src, v1d a)
Mask the input.
v8l::sl_reduce_add_v8l
v8l sl_reduce_add_v8l(v8l a)
Reduction add ( + )
v1f::v1f_neg
v1f v1f_neg(v1f a)
Elementwise negation ( -a )
v4l::m4l_ornot
m4l m4l_ornot(m4l a, m4l b)
Bitwise ornot ( a | ~b )
v8l::v8l_cast_v2f
v8l v8l_cast_v2f(v2f a)
Casts a v2f vector into a v8l vector.
v2i::v2i_permute2x1
v2i v2i_permute2x1(v2i a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v4l::v4l_permute
v4l v4l_permute(v4l a, uint_fast8_t rule)
Shuffles a using the control in rule.
v4d::v4d_rsqrt
v4d v4d_rsqrt(v4d a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v4d::v4d_cvt_v4l
v4d v4d_cvt_v4l(v4l a)
Converts a v4l vector into a v4d vector.
v4d::v4d_reduce_and_v1d
v4d v4d_reduce_and_v1d(v1d a)
Reduction and ( & )
v2f::v2f_sqrt
v2f v2f_sqrt(v2f a)
Elementwise square root ( sqrt(a) )
v4i::v4i_one
v4i v4i_one()
Sets all elements to 1.
v8i::v8i_reduce_add_v4i
v8i v8i_reduce_add_v4i(v4i a)
Reduction add ( + )
v2i::v2i_cvt_v1l
v2i v2i_cvt_v1l(v1l a)
Converts a v1l vector into a v2i vector.
v4l::v4l_fnmadd
v4l v4l_fnmadd(v4l a, v4l b, v4l acc)
Fused Multiply-Add ( -(a * b) + acc )
v4f::v4f_cvt_v4l
v4f v4f_cvt_v4l(v4l a)
Converts a v4l vector into a v4f vector.
v2d::v2d_storeu
void v2d_storeu(double *p, v2d a)
Stores a v2d vector into memory.
v4f::m4f_eq
m4f m4f_eq(v4f a, v4f b)
Compares the equality of the two input vectors.
v1i::si_cvt_v4i
int32_t si_cvt_v4i(v4i a)
Converts the first value of a v4i vector into int32_t.
v2d::v2d_cvt_v2f
v2d v2d_cvt_v2f(v2f a)
Converts a v2f vector into a v2d vector.
v2i::v2i_blend2
v2i v2i_blend2(v2i a, v2i b, uint_fast8_t mask)
Creates a new v2i vector whose elements are from a and b choosed by mask.
v8i::v8i_cvt_v8f
v8i v8i_cvt_v8f(v8f a)
Converts a v8f vector into a v8i vector.
v2i::v2i_rcp
v2i v2i_rcp(v2i a)
Elementwise reciprocal ( 1 / a )
v4i::si_reduce_mul_v4i
v4i si_reduce_mul_v4i(v4i a)
Reduction mul ( * )
v1d::sd_reduce_max_v1d
v1d sd_reduce_max_v1d(v1d a)
Reduction max ( max )
v4d::v4d_hshuffle4x1
v4d v4d_hshuffle4x1(v4d a, v4d b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v2f::v2f_reduce_add_v16f
v2f v2f_reduce_add_v16f(v16f a)
Reduction add ( + )
v2d::sd_reduce_mul_v2d
v2d sd_reduce_mul_v2d(v2d a)
Reduction mul ( * )
v8d::v8d_cvt_v2i
v8d v8d_cvt_v2i(v2i a)
Converts a v2i vector into a v8d vector.
v8l::v8l_cast_v4l
v8l v8l_cast_v4l(v4l a)
Casts a v4l vector into a v8l vector.
v8l::v8l_blend8
v8l v8l_blend8(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v2f::v2f_cvt_v4f
v2f v2f_cvt_v4f(v4f a)
Converts a v4f vector into a v2f vector.
v2f::sf_reduce_add_v2f
v2f sf_reduce_add_v2f(v2f a)
Reduction add ( + )
v8d::v8d_store1
void v8d_store1(double *p, v8d a)
Stores the first element of a v8d vector into memory.
v1d::v1d_maskz_move
v1d v1d_maskz_move(m1d mask, v1d a)
Mask the input.
v8d::m8d_not
m8d m8d_not(m8d a)
Bitwise not ( ~a )
v16f::v16f_print
void v16f_print(v16f a)
Prints a v16f vector.
v16i::v16i_eq
v16i v16i_eq(v16i a, v16i b)
Compares the equality of the two input vectors.
v8f::v8f_reduce_mul_v16f
v8f v8f_reduce_mul_v16f(v16f a)
Reduction mul ( * )
v4l::v4l_cast_v16i
v4l v4l_cast_v16i(v16i a)
Casts a v16i vector into a v4l vector.
v4f::m4f_or
m4f m4f_or(m4f a, m4f b)
Bitwise or ( a | b )
v16i::v16i_reduce_or_v4i
v16i v16i_reduce_or_v4i(v4i a)
Reduction or ( | )
v16f::v16f_reduce_min_v2f
v16f v16f_reduce_min_v2f(v2f a)
Reduction min ( min )
v2d::v2d_reduce_add
v2d v2d_reduce_add(v2d a)
Reduction add ( + )
v1i::m1i_gt
m1i m1i_gt(v1i a, v1i b)
Compares if elements of a are greater than those of b.
v1d::sd_reduce_add_v1d
v1d sd_reduce_add_v1d(v1d a)
Reduction add ( + )
v2f::m2f_leq
m2f m2f_leq(v2f a, v2f b)
Compares if elements of a are less than or equal to those of b.
v4l::v4l_reduce_and
v4l v4l_reduce_and(v4l a)
Reduction and ( & )
v4i::v4i_rprint
void v4i_rprint(v4i a)
Prints a v4i vector (reversed order)
v1d::sd_cvt_v4i
double sd_cvt_v4i(v4i a)
Converts the first value of a v4i vector into double.
v4i::v4i_cast_m4i
v4i v4i_cast_m4i(m4i a)
Casts a m4i vector-mask into a v4i vector.
v8i::v8i_reduce_and_v1i
v8i v8i_reduce_and_v1i(v1i a)
Reduction and ( & )
v16i::v16i_rmerge4_v4i
v16i v16i_rmerge4_v4i(v4i a3, v4i a2, v4i a1, v4i a0)
Merges 4 v4i vectors together (reverse order).
v16i::v16i_hshuffle4x4
v16i v16i_hshuffle4x4(v16i a, v16i b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v1d::v1d_blend1
v1d v1d_blend1(v1d a, v1d b, uint_fast8_t mask)
Creates a new v1d vector whose elements are from a and b choosed by mask.
v2i::v2i_blend
v2i v2i_blend(v2i a, v2i b, uint_fast8_t mask)
Creates a new v2i vector whose elements are from a and b choosed by mask.
v2f::v2f_cast_v4i
v2f v2f_cast_v4i(v4i a)
Casts a v4i vector into a v2f vector.
v4f::v4f_permute2x2
v4f v4f_permute2x2(v4f a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v2d::m2d_lt
m2d m2d_lt(v2d a, v2d b)
Compares if elements of a are less than those of b.
v8l::v8l_cvt_v2l
v8l v8l_cvt_v2l(v2l a)
Converts a v2l vector into a v8l vector.
v4i::v4i_nand
v4i v4i_nand(v4i a, v4i b)
Bitwise nand ( ~(a & b) )
v16i::v16i_store
void v16i_store(int32_t *p, v16i a)
Stores a v16i vector into memory.
v8f::v8f_blend1x8
v8f v8f_blend1x8(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v2f::v2f_reduce_add_v2f
v2f v2f_reduce_add_v2f(v2f a)
Reduction add ( + )
v4f::v4f_reduce_and_v16f
v4f v4f_reduce_and_v16f(v16f a)
Reduction and ( & )
v1l::v1l_max
v1l v1l_max(v1l a, v1l b)
Elementwise max ( a > b ? a : b )
v8l::v8l_sub
v8l v8l_sub(v8l a, v8l b)
Elementwise subtraction ( a - b )
v1i::v1i_reduce_or_v1i
v1i v1i_reduce_or_v1i(v1i a)
Reduction or ( | )
v1f::m1f_lt
m1f m1f_lt(v1f a, v1f b)
Compares if elements of a are less than those of b.
v16f::v16f_zeros
v16f v16f_zeros()
Sets all bits to 0.
v16f::v16f_hshuffle16x1
v16f v16f_hshuffle16x1(v16f a, v16f b, uint_fast64_t rule)
Shuffles (inner) a and b together using the control in rule.
v1d::v1d_geq
v1d v1d_geq(v1d a, v1d b)
Compares if elements of a are greater than or equal to those of b.
v1l::v1l_cvt_v2i
v1l v1l_cvt_v2i(v2i a)
Converts a v2i vector into a v1l vector.
v16i::v16i_lt
v16i v16i_lt(v16i a, v16i b)
Compares if elements of a are less than those of b.
v1f::v1f_reduce_and_v16f
v1f v1f_reduce_and_v16f(v16f a)
Reduction and ( & )
v2f::v2f_hshuffle
v2f v2f_hshuffle(v2f a, v2f b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v8f::v8f_reduce_max_v2f
v8f v8f_reduce_max_v2f(v2f a)
Reduction max ( max )
v8l::v8l_leq
v8l v8l_leq(v8l a, v8l b)
Compares if elements of a are less than or equal to those of b.
v2l::v2l_store
void v2l_store(int64_t *p, v2l a)
Stores a v2l vector into memory.
v16f::v16f_fnmsub
v16f v16f_fnmsub(v16f a, v16f b, v16f acc)
Fused Multiply-Add ( -(a * b) - acc )
v2d::v2d_sqrt
v2d v2d_sqrt(v2d a)
Elementwise square root ( sqrt(a) )
v8i::v8i_fshuffle2
v8i v8i_fshuffle2(v8i a, v8i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2i::v2i_store
void v2i_store(int32_t *p, v2i a)
Stores a v2i vector into memory.
v4i::m4i_cvt_m4i
m4i m4i_cvt_m4i(m4i a)
Converts a m4i vector-mask into a m4i vector-mask.
v16f::v16f_cvt_v2l
v16f v16f_cvt_v2l(v2l a)
Converts a v2l vector into a v16f vector.
v2f::m2f_nor
m2f m2f_nor(m2f a, m2f b)
Bitwise nor ( ~(a | b) )
v1i::si_cvt_v16i
int32_t si_cvt_v16i(v16i a)
Converts the first value of a v16i vector into int32_t.
v8l::v8l_reduce_mul_v4l
v8l v8l_reduce_mul_v4l(v4l a)
Reduction mul ( * )
v4l::v4l_eq
v4l v4l_eq(v4l a, v4l b)
Compares the equality of the two input vectors.
v4d::v4d_fshuffle
v4d v4d_fshuffle(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v16i::v16i_fnmsub
v16i v16i_fnmsub(v16i a, v16i b, v16i acc)
Fused Multiply-Add ( -(a * b) - acc )
v4d::v4d_loadu
v4d v4d_loadu(const double *p)
Loads 4 double from memory into a v4d vector.
v4i::v4i_loadu
v4i v4i_loadu(const int32_t *p)
Loads 4 int32_t from memory into a v4i vector.
v4d::v4d_cvt_v8d
v4d v4d_cvt_v8d(v8d a)
Converts a v8d vector into a v4d vector.
v4d::v4d_cvt_v2l
v4d v4d_cvt_v2l(v2l a)
Converts a v2l vector into a v4d vector.
v2i::v1i_get_low_v2i
v1i v1i_get_low_v2i(v2i a)
Gets the low part of a v2i vector.
v16i::v16i_fprint
void v16i_fprint(FILE *file, v16i a)
Prints a v16i vector.
v4f::sf_reduce_mul_v4f
v4f sf_reduce_mul_v4f(v4f a)
Reduction mul ( * )
v4d::v4d_blend1
v4d v4d_blend1(v4d a, v4d b, uint_fast8_t mask)
Creates a new v4d vector whose elements are from a and b choosed by mask.
v2d::v2d_sub
v2d v2d_sub(v2d a, v2d b)
Elementwise subtraction ( a - b )
v16i::v16i_rfprint
void v16i_rfprint(FILE *file, v16i a)
Prints a v16i vector (reversed order)
v4d::v2d_get_low_v4d
v2d v2d_get_low_v4d(v4d a)
Gets the low part of a v4d vector.
v1l::v1l_reduce_or_v8l
v1l v1l_reduce_or_v8l(v8l a)
Reduction or ( | )
v4l::v4l_andnot
v4l v4l_andnot(v4l a, v4l b)
Bitwise andnot ( a & ~b )
v8i::v8i_fshuffle4
v8i v8i_fshuffle4(v8i a, v8i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v16f::v16f_neg
v16f v16f_neg(v16f a)
Elementwise negation ( -a )
v8d::v8d_reduce_max_v2d
v8d v8d_reduce_max_v2d(v2d a)
Reduction max ( max )
v4l::v4l_reduce_min_v1l
v4l v4l_reduce_min_v1l(v1l a)
Reduction min ( min )
v2l::v2l_rcp
v2l v2l_rcp(v2l a)
Elementwise reciprocal ( 1 / a )
v1d::v1d_storeu
void v1d_storeu(double *p, v1d a)
Stores a v1d vector into memory.
v2i::v2i_reduce_and
v2i v2i_reduce_and(v2i a)
Reduction and ( & )
v16f::v16f_fshuffle16
v16f v16f_fshuffle16(v16f a, v16f b, uint_fast64_t rule, uint_fast16_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v4i::v4i_reduce_add_v16i
v4i v4i_reduce_add_v16i(v16i a)
Reduction add ( + )
v8f::v8f_fshuffle8x1
v8f v8f_fshuffle8x1(v8f a, v8f b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1i::v1i_fmadd
v1i v1i_fmadd(v1i a, v1i b, v1i acc)
Fused Multiply-Add ( (a * b) + acc )
v4f::v4f_abs
v4f v4f_abs(v4f a)
Elementwise absolute value ( a > 0 ? a : -a )
v4l::m4l_nand
m4l m4l_nand(m4l a, m4l b)
Bitwise nand ( ~(a & b) )
v1d::v1d_reduce_max_v2d
v1d v1d_reduce_max_v2d(v2d a)
Reduction max ( max )
v4i::si_reduce_and_v4i
v4i si_reduce_and_v4i(v4i a)
Reduction and ( & )
v16f::v16f_cast_v4i
v16f v16f_cast_v4i(v4i a)
Casts a v4i vector into a v16f vector.
v1i::v1i_blend
v1i v1i_blend(v1i a, v1i b, uint_fast8_t mask)
Creates a new v1i vector whose elements are from a and b choosed by mask.
v8f::v8f_or
v8f v8f_or(v8f a, v8f b)
Bitwise or ( a | b )
v8f::v8f_blend4
v8f v8f_blend4(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v16i::v16i_reduce_min_v8i
v16i v16i_reduce_min_v8i(v8i a)
Reduction min ( min )
v8f::v8f_rmerge4_v2f
v8f v8f_rmerge4_v2f(v2f a3, v2f a2, v2f a1, v2f a0)
Merges 4 v2f vectors together (reverse order).
v2i::v2i_frsqrt
v2i v2i_frsqrt(v2i a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v4l::v4l_permute2
v4l v4l_permute2(v4l a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v1d::v1d_cvt_v8d
v1d v1d_cvt_v8d(v8d a)
Converts a v8d vector into a v1d vector.
v4d::v4d_cvt_v2d
v4d v4d_cvt_v2d(v2d a)
Converts a v2d vector into a v4d vector.
v4l::v4l_zeros
v4l v4l_zeros()
Sets all bits to 0.
v8i::v8i_rmerge4_v2i
v8i v8i_rmerge4_v2i(v2i a3, v2i a2, v2i a1, v2i a0)
Merges 4 v2i vectors together (reverse order).
v1f::v1f_cvt_v1i
v1f v1f_cvt_v1i(v1i a)
Converts a v1i vector into a v1f vector.
v2i::v2i_storeu
void v2i_storeu(int32_t *p, v2i a)
Stores a v2i vector into memory.
v2d::v2d_zeros
v2d v2d_zeros()
Sets all bits to 0.
v2d::v2d_reduce_or_v2d
v2d v2d_reduce_or_v2d(v2d a)
Reduction or ( | )
v4i::m4i_cvt_v4i
m4i m4i_cvt_v4i(v4i a)
Converts a v4i vector into a m4i vector-mask.
v2l::v2l_leq
v2l v2l_leq(v2l a, v2l b)
Compares if elements of a are less than or equal to those of b.
v2l::v2l_reduce_min_v4l
v2l v2l_reduce_min_v4l(v4l a)
Reduction min ( min )
v8l::v8l_hshuffle2x4
v8l v8l_hshuffle2x4(v8l a, v8l b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v16f::v16f_set_high_v8f
v16f v16f_set_high_v8f(v16f src, v8f high)
Sets the high part of a v16f vector.
v2d::sd_reduce_or_v2d
v2d sd_reduce_or_v2d(v2d a)
Reduction or ( | )
v1d::v1d_reduce_and_v2d
v1d v1d_reduce_and_v2d(v2d a)
Reduction and ( & )
v1f::sf_cvt_v8i
float sf_cvt_v8i(v8i a)
Converts the first value of a v8i vector into float.
v4l::v4l_cvt_v2d
v4l v4l_cvt_v2d(v2d a)
Converts a v2d vector into a v4l vector.
v2l::v2l_maskz_move
v2l v2l_maskz_move(m2l mask, v2l a)
Mask the input.
v2i::v2i_reduce_mul
v2i v2i_reduce_mul(v2i a)
Reduction mul ( * )
v1l::v1l_permute
v1l v1l_permute(v1l a, uint_fast8_t rule)
Shuffles a using the control in rule.
v2d::v2d_cast_v4l
v2d v2d_cast_v4l(v4l a)
Casts a v4l vector into a v2d vector.
v4l::v4l_cvt_v8i
v4l v4l_cvt_v8i(v8i a)
Converts a v8i vector into a v4l vector.
v16f::v16f_max
v16f v16f_max(v16f a, v16f b)
Elementwise max ( a > b ? a : b )
v4d::v4d_cvt_v8f
v4d v4d_cvt_v8f(v8f a)
Converts a v8f vector into a v4d vector.
v8l::v8l_fshuffle4x2
v8l v8l_fshuffle4x2(v8l a, v8l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v2d::v2d_frsqrt
v2d v2d_frsqrt(v2d a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v1i::v1i_cvt_v2l
v1i v1i_cvt_v2l(v2l a)
Converts a v2l vector into a v1i vector.
v8d::v8d_reduce_and_v4d
v8d v8d_reduce_and_v4d(v4d a)
Reduction and ( & )
v1d::v1d_leq
v1d v1d_leq(v1d a, v1d b)
Compares if elements of a are less than or equal to those of b.
v8f::v8f_blend
v8f v8f_blend(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v8d::m8d_cvt_m8d
m8d m8d_cvt_m8d(m8d a)
Converts a m8d vector-mask into a m8d vector-mask.
v8f::v8f_cvt_v4i
v8f v8f_cvt_v4i(v4i a)
Converts a v4i vector into a v8f vector.
v1i::v1i_reduce_max
v1i v1i_reduce_max(v1i a)
Reduction max ( max )
v1d::v1d_load
v1d v1d_load(const double *p)
Loads 1 double from memory into a v1d vector.
v2l::v2l_cast_v4i
v2l v2l_cast_v4i(v4i a)
Casts a v4i vector into a v2l vector.
v2l::v2l_cast_v8i
v2l v2l_cast_v8i(v8i a)
Casts a v8i vector into a v2l vector.
v4l::v4l_reduce_min_v8l
v4l v4l_reduce_min_v8l(v8l a)
Reduction min ( min )
v8l::v4l_get_high_v8l
v4l v4l_get_high_v8l(v8l a)
Gets the high part of a v8l vector.
v1i::v1i_mask_move
v1i v1i_mask_move(m1i mask, v1i src, v1i a)
Mask the input.
v8d::m8d_andnot
m8d m8d_andnot(m8d a, m8d b)
Bitwise andnot ( a & ~b )
v8d::m8d_geq
m8d m8d_geq(v8d a, v8d b)
Compares if elements of a are greater than or equal to those of b.
v8f::m8f_nxor
m8f m8f_nxor(m8f a, m8f b)
Bitwise nxor ( ~(a ^ b) )
v1d::m1d_andnot
m1d m1d_andnot(m1d a, m1d b)
Bitwise andnot ( a & ~b )
v2d::v2d_cast_v4d
v2d v2d_cast_v4d(v4d a)
Casts a v4d vector into a v2d vector.
v8i::m8i_leq
m8i m8i_leq(v8i a, v8i b)
Compares if elements of a are less than or equal to those of b.
v8l::v8l_and
v8l v8l_and(v8l a, v8l b)
Bitwise and ( a & b )
v8i::m8i_or
m8i m8i_or(m8i a, m8i b)
Bitwise or ( a | b )
v8d::v8d_cast_v2l
v8d v8d_cast_v2l(v2l a)
Casts a v2l vector into a v8d vector.
v8d::v8d_set_hilo_v4d
v8d v8d_set_hilo_v4d(v8d src, v4d a, int high)
Conditionally sets the low or the high part of a v8d vector.
v2d::v2d_reduce_max_v8d
v2d v2d_reduce_max_v8d(v8d a)
Reduction max ( max )
v16i::v16i_blend8x2
v16i v16i_blend8x2(v16i a, v16i b, uint_fast8_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v1d::m1d_lt
m1d m1d_lt(v1d a, v1d b)
Compares if elements of a are less than those of b.
v16i::v16i_load1
v16i v16i_load1(const int32_t *p)
Loads 1 int32_t from memory and broadcasts it into a v16i vector.
v2d::v2d_geq
v2d v2d_geq(v2d a, v2d b)
Compares if elements of a are greater than or equal to those of b.
v2f::v2f_reduce_max_v1f
v2f v2f_reduce_max_v1f(v1f a)
Reduction max ( max )
v1f::sf_reduce_add_v1f
v1f sf_reduce_add_v1f(v1f a)
Reduction add ( + )
v8d::m8d_cvt_m8l
m8d m8d_cvt_m8l(m8l a)
Converts a m8l vector-mask into a m8d vector-mask.
v1l::v1l_print
void v1l_print(v1l a)
Prints a v1l vector.
v8d::v8d_fmadd
v8d v8d_fmadd(v8d a, v8d b, v8d acc)
Fused Multiply-Add ( (a * b) + acc )
v1i::v1i_cast_v8i
v1i v1i_cast_v8i(v8i a)
Casts a v8i vector into a v1i vector.
v2i::m2i_nor
m2i m2i_nor(m2i a, m2i b)
Bitwise nor ( ~(a | b) )
v2d::v2d_cvt_v8f
v2d v2d_cvt_v8f(v8f a)
Converts a v8f vector into a v2d vector.
v4l::v4l_cvt_v4f
v4l v4l_cvt_v4f(v4f a)
Converts a v4f vector into a v4l vector.
v8l::v8l_fshuffle
v8l v8l_fshuffle(v8l a, v8l b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8d::v8d_reduce_and
v8d v8d_reduce_and(v8d a)
Reduction and ( & )
v1f::v1f_reduce_max_v8f
v1f v1f_reduce_max_v8f(v8f a)
Reduction max ( max )
v4l::v4l_ornot
v4l v4l_ornot(v4l a, v4l b)
Bitwise ornot ( a | ~b )
v4i::v4i_reduce_max_v4i
v4i v4i_reduce_max_v4i(v4i a)
Reduction max ( max )
v1l::v1l_andnot
v1l v1l_andnot(v1l a, v1l b)
Bitwise andnot ( a & ~b )
v2l::v2l_cast_v4d
v2l v2l_cast_v4d(v4d a)
Casts a v4d vector into a v2l vector.
v16f::v16f_set_low_v8f
v16f v16f_set_low_v8f(v16f src, v8f low)
Sets the low part of a v16f vector.
v8l::v8l_set1
v8l v8l_set1(int64_t v)
Broadcasts a single value into all elements of a v8l vector.
v4i::v4i_cast_v4i
v4i v4i_cast_v4i(v4i a)
Casts a v4i vector into a v4i vector.
v2l::v2l_cast_v2i
v2l v2l_cast_v2i(v2i a)
Casts a v2i vector into a v2l vector.
v16i::v16i_cast_v1l
v16i v16i_cast_v1l(v1l a)
Casts a v1l vector into a v16i vector.
v4i::v4i_frcp
v4i v4i_frcp(v4i a)
Fast elementwise reciprocal ( 1 / a )
v2i::v2i_cast_v8l
v2i v2i_cast_v8l(v8l a)
Casts a v8l vector into a v2i vector.
v8f::v8f_fshuffle4
v8f v8f_fshuffle4(v8f a, v8f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v4d::v4d_maskz_move
v4d v4d_maskz_move(m4d mask, v4d a)
Mask the input.
v8f::v8f_fshuffle4x2
v8f v8f_fshuffle4x2(v8f a, v8f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1l::v1l_lt
v1l v1l_lt(v1l a, v1l b)
Compares if elements of a are less than those of b.
v1i::m1i_xor
m1i m1i_xor(m1i a, m1i b)
Bitwise xor ( a ^ b )
v1d::v1d_eq
v1d v1d_eq(v1d a, v1d b)
Compares the equality of the two input vectors.
v2f::v2f_printf
void v2f_printf(v2f a, const char *format)
Prints a v2f vector.
v4d::v4d_sqrt
v4d v4d_sqrt(v4d a)
Elementwise square root ( sqrt(a) )
v16i::v16i_nxor
v16i v16i_nxor(v16i a, v16i b)
Bitwise nxor ( ~(a ^ b) )
v8l::v8l_cvt_v1d
v8l v8l_cvt_v1d(v1d a)
Converts a v1d vector into a v8l vector.
v8f::v8f_cast_v1d
v8f v8f_cast_v1d(v1d a)
Casts a v1d vector into a v8f vector.
v8i::v8i_reduce_and_v16i
v8i v8i_reduce_and_v16i(v16i a)
Reduction and ( & )
v2f::v2f_reduce_min
v2f v2f_reduce_min(v2f a)
Reduction min ( min )
v16i::v16i_fmsub
v16i v16i_fmsub(v16i a, v16i b, v16i acc)
Fused Multiply-Sub ( (a * b) - acc )
v8f::v8f_merge8_v1f
v8f v8f_merge8_v1f(v1f a0, v1f a1, v1f a2, v1f a3, v1f a4, v1f a5, v1f a6, v1f a7)
Merges 8 v1f vectors together.
v2f::v2f_ornot
v2f v2f_ornot(v2f a, v2f b)
Bitwise ornot ( a | ~b )
v16f::v16f_hshuffle4x4
v16f v16f_hshuffle4x4(v16f a, v16f b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v2i::v2i_cast_v2i
v2i v2i_cast_v2i(v2i a)
Casts a v2i vector into a v2i vector.
v8d::m8d_cvt_v8d
m8d m8d_cvt_v8d(v8d a)
Converts a v8d vector into a m8d vector-mask.
v4f::v4f_ones
v4f v4f_ones()
Sets all bits to 1.
v4i::v4i_cast_v8l
v4i v4i_cast_v8l(v8l a)
Casts a v8l vector into a v4i vector.
v8d::v8d_rset
v8d v8d_rset(double v7, double v6, double v5, double v4, double v3, double v2, double v1, double v0)
Sets the elements of a v8d vector (reverse order).
v2i::v2i_lt
v2i v2i_lt(v2i a, v2i b)
Compares if elements of a are less than those of b.
v2i::v2i_neq
v2i v2i_neq(v2i a, v2i b)
Compares the inequality of the two input vectors.
v8l::v8l_andnot
v8l v8l_andnot(v8l a, v8l b)
Bitwise andnot ( a & ~b )
v1l::v1l_nand
v1l v1l_nand(v1l a, v1l b)
Bitwise nand ( ~(a & b) )
v1i::v1i_cast_m1i
v1i v1i_cast_m1i(m1i a)
Casts a m1i vector-mask into a v1i vector.
v2i::v2i_reduce_and_v1i
v2i v2i_reduce_and_v1i(v1i a)
Reduction and ( & )
v4d::v4d_cvt_v1l
v4d v4d_cvt_v1l(v1l a)
Converts a v1l vector into a v4d vector.
v16i::v16i_cast_v2l
v16i v16i_cast_v2l(v2l a)
Casts a v2l vector into a v16i vector.
v4i::v4i_reduce_and_v16i
v4i v4i_reduce_and_v16i(v16i a)
Reduction and ( & )
v16f::v16f_cast_v2i
v16f v16f_cast_v2i(v2i a)
Casts a v2i vector into a v16f vector.
v8l::v8l_rmerge4_v2l
v8l v8l_rmerge4_v2l(v2l a3, v2l a2, v2l a1, v2l a0)
Merges 4 v2l vectors together (reverse order).
v16i::v16i_store1
void v16i_store1(int32_t *p, v16i a)
Stores the first element of a v16i vector into memory.
v4d::sd_reduce_max_v4d
v4d sd_reduce_max_v4d(v4d a)
Reduction max ( max )
v4l::v4l_cvt_v8l
v4l v4l_cvt_v8l(v8l a)
Converts a v8l vector into a v4l vector.
v4f::v4f_reduce_min_v1f
v4f v4f_reduce_min_v1f(v1f a)
Reduction min ( min )
v1f::v1f_ones
v1f v1f_ones()
Sets all bits to 1.
v2d::v2d_mul
v2d v2d_mul(v2d a, v2d b)
Elementwise multiplication ( a * b )
v2l::m2l_nor
m2l m2l_nor(m2l a, m2l b)
Bitwise nor ( ~(a | b) )
v1l::m1l_leq
m1l m1l_leq(v1l a, v1l b)
Compares if elements of a are less than or equal to those of b.
v2f::v2f_cast_v16i
v2f v2f_cast_v16i(v16i a)
Casts a v16i vector into a v2f vector.
v1d::v1d_cast_v1l
v1d v1d_cast_v1l(v1l a)
Casts a v1l vector into a v1d vector.
v1d::v1d_cvt_v8f
v1d v1d_cvt_v8f(v8f a)
Converts a v8f vector into a v1d vector.
v1i::v1i_reduce_or_v2i
v1i v1i_reduce_or_v2i(v2i a)
Reduction or ( | )
v4f::v4f_frsqrt
v4f v4f_frsqrt(v4f a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v8i::v8i_storeu
void v8i_storeu(int32_t *p, v8i a)
Stores a v8i vector into memory.
v2l::m2l_cvt_m2d
m2l m2l_cvt_m2d(m2d a)
Converts a m2d vector-mask into a m2l vector-mask.
v8d::v8d_rmerge4_v2d
v8d v8d_rmerge4_v2d(v2d a3, v2d a2, v2d a1, v2d a0)
Merges 4 v2d vectors together (reverse order).
v2l::v2l_frsqrt
v2l v2l_frsqrt(v2l a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v4d::m4d_cvt_v4d
m4d m4d_cvt_v4d(v4d a)
Converts a v4d vector into a m4d vector-mask.
v4f::v4f_permute4x1
v4f v4f_permute4x1(v4f a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v8l::v8l_not
v8l v8l_not(v8l a)
Bitwise not ( ~a )
v16i::v16i_reduce_or
v16i v16i_reduce_or(v16i a)
Reduction or ( | )
v2f::v2f_cast_v8d
v2f v2f_cast_v8d(v8d a)
Casts a v8d vector into a v2f vector.
v2d::v2d_mask_move
v2d v2d_mask_move(m2d mask, v2d src, v2d a)
Mask the input.
v2l::v2l_set_high_v1l
v2l v2l_set_high_v1l(v2l src, v1l high)
Sets the high part of a v2l vector.
v2d::v2d_and
v2d v2d_and(v2d a, v2d b)
Bitwise and ( a & b )
v8i::v8i_load
v8i v8i_load(const int32_t *p)
Loads 8 int32_t from memory into a v8i vector.
v16i::v16i_cast_v4f
v16i v16i_cast_v4f(v4f a)
Casts a v4f vector into a v16i vector.
v1l::v1l_min
v1l v1l_min(v1l a, v1l b)
Elementwise min ( a < b ? a : b )
v2d::v2d_blend2x1
v2d v2d_blend2x1(v2d a, v2d b, uint_fast8_t mask)
Creates a new v2d vector whose elements are from a and b choosed by mask.
v4f::v4f_cast_v4d
v4f v4f_cast_v4d(v4d a)
Casts a v4d vector into a v4f vector.
v2l::v2l_fprint
void v2l_fprint(FILE *file, v2l a)
Prints a v2l vector.
v8d::m8d_ornot
m8d m8d_ornot(m8d a, m8d b)
Bitwise ornot ( a | ~b )
v8d::v8d_blend
v8d v8d_blend(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v8i::v8i_rset
v8i v8i_rset(int32_t v7, int32_t v6, int32_t v5, int32_t v4, int32_t v3, int32_t v2, int32_t v1, int32_t v0)
Sets the elements of a v8i vector (reverse order).
v8l::v8l_rfprint
void v8l_rfprint(FILE *file, v8l a)
Prints a v8l vector (reversed order)
v1f::v1f_cvt_v4i
v1f v1f_cvt_v4i(v4i a)
Converts a v4i vector into a v1f vector.
v2i::v2i_fnmsub
v2i v2i_fnmsub(v2i a, v2i b, v2i acc)
Fused Multiply-Add ( -(a * b) - acc )
v16i::v16i_ones
v16i v16i_ones()
Sets all bits to 1.
v16i::v16i_cast_v8i
v16i v16i_cast_v8i(v8i a)
Casts a v8i vector into a v16i vector.
v4l::v4l_div
v4l v4l_div(v4l a, v4l b)
Elementwise division ( a / b )
v4d::v4d_not
v4d v4d_not(v4d a)
Bitwise not ( ~a )
v4i::v4i_andnot
v4i v4i_andnot(v4i a, v4i b)
Bitwise andnot ( a & ~b )
v1i::v1i_rprintf
void v1i_rprintf(v1i a, const char *format)
Prints a v1i vector (reversed order)
v8l::v8l_reduce_mul_v2l
v8l v8l_reduce_mul_v2l(v2l a)
Reduction mul ( * )
v16f::v16f_reduce_add_v16f
v16f v16f_reduce_add_v16f(v16f a)
Reduction add ( + )
v1i::v1i_reduce_or_v8i
v1i v1i_reduce_or_v8i(v8i a)
Reduction or ( | )
v16f::v16f_min
v16f v16f_min(v16f a, v16f b)
Elementwise min ( a < b ? a : b )
v2f::v2f_reduce_and_v16f
v2f v2f_reduce_and_v16f(v16f a)
Reduction and ( & )
v8d::v8d_reduce_max_v4d
v8d v8d_reduce_max_v4d(v4d a)
Reduction max ( max )
v4l::v4l_neq
v4l v4l_neq(v4l a, v4l b)
Compares the inequality of the two input vectors.
v8f::v8f_hshuffle2x4
v8f v8f_hshuffle2x4(v8f a, v8f b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v16i::v16i_leq
v16i v16i_leq(v16i a, v16i b)
Compares if elements of a are less than or equal to those of b.
v4l::v4l_cvt_v8d
v4l v4l_cvt_v8d(v8d a)
Converts a v8d vector into a v4l vector.
v16f::v16f_move
v16f v16f_move(v16f a)
Forwards the input.
v8f::v8f_reduce_and_v16f
v8f v8f_reduce_and_v16f(v16f a)
Reduction and ( & )
v8d::v8d_cvt_v2l
v8d v8d_cvt_v2l(v2l a)
Converts a v2l vector into a v8d vector.
v4i::v4i_cast_v4f
v4i v4i_cast_v4f(v4f a)
Casts a v4f vector into a v4i vector.
v1d::v1d_cvt_v1i
v1d v1d_cvt_v1i(v1i a)
Converts a v1i vector into a v1d vector.
v4d::v4d_cvt_v2i
v4d v4d_cvt_v2i(v2i a)
Converts a v2i vector into a v4d vector.
v4d::v4d_rprintf
void v4d_rprintf(v4d a, const char *format)
Prints a v4d vector (reversed order)
v1l::v1l_reduce_max_v2l
v1l v1l_reduce_max_v2l(v2l a)
Reduction max ( max )
v4f::m4f_nor
m4f m4f_nor(m4f a, m4f b)
Bitwise nor ( ~(a | b) )
v4f::v4f_blend
v4f v4f_blend(v4f a, v4f b, uint_fast8_t mask)
Creates a new v4f vector whose elements are from a and b choosed by mask.
v2l::v2l_reduce_and_v1l
v2l v2l_reduce_and_v1l(v1l a)
Reduction and ( & )
v4i::v4i_permute
v4i v4i_permute(v4i a, uint_fast8_t rule)
Shuffles a using the control in rule.
v2i::v2i_cvt_v1d
v2i v2i_cvt_v1d(v1d a)
Converts a v1d vector into a v2i vector.
v2i::v2i_reduce_add_v16i
v2i v2i_reduce_add_v16i(v16i a)
Reduction add ( + )
v1i::v1i_min
v1i v1i_min(v1i a, v1i b)
Elementwise min ( a < b ? a : b )
v16f::v16f_reduce_max_v1f
v16f v16f_reduce_max_v1f(v1f a)
Reduction max ( max )
v1d::m1d_eq
m1d m1d_eq(v1d a, v1d b)
Compares the equality of the two input vectors.
v8d::v8d_reduce_mul_v4d
v8d v8d_reduce_mul_v4d(v4d a)
Reduction mul ( * )
v1f::sf_cvt_v2l
float sf_cvt_v2l(v2l a)
Converts the first value of a v2l vector into float.
v16i::v16i_hshuffle2x8
v16i v16i_hshuffle2x8(v16i a, v16i b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v8l::v8l_permute
v8l v8l_permute(v8l a, uint_fast32_t rule)
Shuffles a using the control in rule.
v1d::v1d_cvt_v16f
v1d v1d_cvt_v16f(v16f a)
Converts a v16f vector into a v1d vector.
v2l::v2l_permute2x1
v2l v2l_permute2x1(v2l a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v8f::v8f_sub
v8f v8f_sub(v8f a, v8f b)
Elementwise subtraction ( a - b )
v4i::v4i_fmadd
v4i v4i_fmadd(v4i a, v4i b, v4i acc)
Fused Multiply-Add ( (a * b) + acc )
v16f::v16f_blend
v16f v16f_blend(v16f a, v16f b, uint_fast16_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v8i::v8i_reduce_max_v2i
v8i v8i_reduce_max_v2i(v2i a)
Reduction max ( max )
v4i::v4i_fshuffle2
v4i v4i_fshuffle2(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v16f::v16f_permute16x1
v16f v16f_permute16x1(v16f a, uint_fast64_t rule)
Shuffles (inner) a using the control in rule.
v8f::v8f_permute2x4
v8f v8f_permute2x4(v8f a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v16i::m16i_leq
m16i m16i_leq(v16i a, v16i b)
Compares if elements of a are less than or equal to those of b.
v4d::m4d_cvt_m4d
m4d m4d_cvt_m4d(m4d a)
Converts a m4d vector-mask into a m4d vector-mask.
v1d::v1d_set1
v1d v1d_set1(double v)
Broadcasts a single value into all elements of a v1d vector.
v8l::v8l_cast_v4i
v8l v8l_cast_v4i(v4i a)
Casts a v4i vector into a v8l vector.
v1l::v1l_reduce_mul_v1l
v1l v1l_reduce_mul_v1l(v1l a)
Reduction mul ( * )
v2i::v2i_cast_v1d
v2i v2i_cast_v1d(v1d a)
Casts a v1d vector into a v2i vector.
v2i::v2i_reduce_and_v4i
v2i v2i_reduce_and_v4i(v4i a)
Reduction and ( & )
v2i::v2i_zero
v2i v2i_zero()
Sets all elements to 0.
v4f::v4f_geq
v4f v4f_geq(v4f a, v4f b)
Compares if elements of a are greater than or equal to those of b.
v2d::v2d_cvt_v1i
v2d v2d_cvt_v1i(v1i a)
Converts a v1i vector into a v2d vector.
v8f::v8f_load1
v8f v8f_load1(const float *p)
Loads 1 float from memory and broadcasts it into a v8f vector.
v2i::m2i_cvt_m2l
m2i m2i_cvt_m2l(m2l a)
Converts a m2l vector-mask into a m2i vector-mask.
v4l::v4l_reduce_min
v4l v4l_reduce_min(v4l a)
Reduction min ( min )
v8d::v8d_neg
v8d v8d_neg(v8d a)
Elementwise negation ( -a )
v16i::v16i_cvt_v2i
v16i v16i_cvt_v2i(v2i a)
Converts a v2i vector into a v16i vector.
v1d::v1d_cast_v1i
v1d v1d_cast_v1i(v1i a)
Casts a v1i vector into a v1d vector.
v8d::v8d_neq
v8d v8d_neq(v8d a, v8d b)
Compares the inequality of the two input vectors.
v4l::v4l_cast_v8f
v4l v4l_cast_v8f(v8f a)
Casts a v8f vector into a v4l vector.
v1f::sf_cvt_v4f
float sf_cvt_v4f(v4f a)
Converts the first value of a v4f vector into float.
v1f::v1f_add
v1f v1f_add(v1f a, v1f b)
Elementwise addition ( a + b )
v8f::v8f_fshuffle
v8f v8f_fshuffle(v8f a, v8f b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1i::m1i_andnot
m1i m1i_andnot(m1i a, m1i b)
Bitwise andnot ( a & ~b )
v16f::v16f_reduce_or
v16f v16f_reduce_or(v16f a)
Reduction or ( | )
v8i::v8i_cast_v1d
v8i v8i_cast_v1d(v1d a)
Casts a v1d vector into a v8i vector.
v2d::sd_reduce_max_v2d
v2d sd_reduce_max_v2d(v2d a)
Reduction max ( max )
v16i::m16i_or
m16i m16i_or(m16i a, m16i b)
Bitwise or ( a | b )
v1f::v1f_reduce_mul_v16f
v1f v1f_reduce_mul_v16f(v16f a)
Reduction mul ( * )
v16f::v16f_blend8x2
v16f v16f_blend8x2(v16f a, v16f b, uint_fast8_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v2l::v2l_cvt_v4i
v2l v2l_cvt_v4i(v4i a)
Converts a v4i vector into a v2l vector.
v2l::v2l_cast_v1d
v2l v2l_cast_v1d(v1d a)
Casts a v1d vector into a v2l vector.
v2i::v2i_cast_v2l
v2i v2i_cast_v2l(v2l a)
Casts a v2l vector into a v2i vector.
v2d::v2d_reduce_add_v2d
v2d v2d_reduce_add_v2d(v2d a)
Reduction add ( + )
v2i::v2i_cast_v1l
v2i v2i_cast_v1l(v1l a)
Casts a v1l vector into a v2i vector.
v8i::v8i_fshuffle8x1
v8i v8i_fshuffle8x1(v8i a, v8i b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v2f::v2f_nor
v2f v2f_nor(v2f a, v2f b)
Bitwise nor ( ~(a | b) )
v8i::v8i_reduce_mul_v8i
v8i v8i_reduce_mul_v8i(v8i a)
Reduction mul ( * )
v8l::v8l_cast_v16i
v8l v8l_cast_v16i(v16i a)
Casts a v16i vector into a v8l vector.
v8l::v8l_zero
v8l v8l_zero()
Sets all elements to 0.
v4f::v4f_reduce_mul_v2f
v4f v4f_reduce_mul_v2f(v2f a)
Reduction mul ( * )
v1l::m1l_eq
m1l m1l_eq(v1l a, v1l b)
Compares the equality of the two input vectors.
v4l::v4l_permute4
v4l v4l_permute4(v4l a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v16f::sf_reduce_min_v16f
v16f sf_reduce_min_v16f(v16f a)
Reduction min ( min )
v2l::m2l_nxor
m2l m2l_nxor(m2l a, m2l b)
Bitwise nxor ( ~(a ^ b) )
v8l::v8l_eq
v8l v8l_eq(v8l a, v8l b)
Compares the equality of the two input vectors.
v2i::v2i_not
v2i v2i_not(v2i a)
Bitwise not ( ~a )
v1l::v1l_or
v1l v1l_or(v1l a, v1l b)
Bitwise or ( a | b )
v16f::v16f_lt
v16f v16f_lt(v16f a, v16f b)
Compares if elements of a are less than those of b.
v2i::v2i_set_hilo_v1i
v2i v2i_set_hilo_v1i(v2i src, v1i a, int high)
Conditionally sets the low or the high part of a v2i vector.
v4f::v4f_neg
v4f v4f_neg(v4f a)
Elementwise negation ( -a )
v1f::v1f_reduce_add_v2f
v1f v1f_reduce_add_v2f(v2f a)
Reduction add ( + )
v2l::v2l_fshuffle
v2l v2l_fshuffle(v2l a, v2l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4i::v4i_reduce_max_v2i
v4i v4i_reduce_max_v2i(v2i a)
Reduction max ( max )
v1d::v1d_blend
v1d v1d_blend(v1d a, v1d b, uint_fast8_t mask)
Creates a new v1d vector whose elements are from a and b choosed by mask.
v2f::v2f_hshuffle2
v2f v2f_hshuffle2(v2f a, v2f b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v4l::v4l_cvt_v1i
v4l v4l_cvt_v1i(v1i a)
Converts a v1i vector into a v4l vector.
v1i::v1i_reduce_min_v16i
v1i v1i_reduce_min_v16i(v16i a)
Reduction min ( min )
v8f::v8f_not
v8f v8f_not(v8f a)
Bitwise not ( ~a )
v4l::v4l_cast_v4l
v4l v4l_cast_v4l(v4l a)
Casts a v4l vector into a v4l vector.
v8f::v8f_hshuffle
v8f v8f_hshuffle(v8f a, v8f b, uint_fast32_t rule)
Shuffles a and b together using the control in rule.
v2d::v2d_reduce_and_v8d
v2d v2d_reduce_and_v8d(v8d a)
Reduction and ( & )
v16f::v16f_zero
v16f v16f_zero()
Sets all elements to 0.
v8l::v8l_fshuffle2x4
v8l v8l_fshuffle2x4(v8l a, v8l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v2i::v2i_cvt_v2l
v2i v2i_cvt_v2l(v2l a)
Converts a v2l vector into a v2i vector.
v2l::v2l_cvt_m2l
v2l v2l_cvt_m2l(m2l a)
Converts a m2l vector-mask into a v2l vector.
v4l::m4l_xor
m4l m4l_xor(m4l a, m4l b)
Bitwise xor ( a ^ b )
v1d::v1d_cast_v4f
v1d v1d_cast_v4f(v4f a)
Casts a v4f vector into a v1d vector.
v16f::v16f_reduce_and_v2f
v16f v16f_reduce_and_v2f(v2f a)
Reduction and ( & )
v2i::v2i_fnmadd
v2i v2i_fnmadd(v2i a, v2i b, v2i acc)
Fused Multiply-Add ( -(a * b) + acc )
v4l::v4l_rsqrt
v4l v4l_rsqrt(v4l a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v8l::v8l_loadu
v8l v8l_loadu(const int64_t *p)
Loads 8 int64_t from memory into a v8l vector.
v16f::v16f_fprintf
void v16f_fprintf(FILE *file, v16f a, const char *format)
Prints a v16f vector.
v4f::v4f_cvt_v16f
v4f v4f_cvt_v16f(v16f a)
Converts a v16f vector into a v4f vector.
v2i::v2i_reduce_or
v2i v2i_reduce_or(v2i a)
Reduction or ( | )
v16f::m16f_or
m16f m16f_or(m16f a, m16f b)
Bitwise or ( a | b )
v8f::m8f_neq
m8f m8f_neq(v8f a, v8f b)
Compares the inequality of the two input vectors.
v4l::v4l_rprintf
void v4l_rprintf(v4l a, const char *format)
Prints a v4l vector (reversed order)
v8i::v8i_not
v8i v8i_not(v8i a)
Bitwise not ( ~a )
v2i::m2i_cvt_m2i
m2i m2i_cvt_m2i(m2i a)
Converts a m2i vector-mask into a m2i vector-mask.
v2f::v2f_rfprintf
void v2f_rfprintf(FILE *file, v2f a, const char *format)
Prints a v2f vector (reversed order)
v1f::v1f_reduce_mul
v1f v1f_reduce_mul(v1f a)
Reduction mul ( * )
v2d::v2d_hshuffle2
v2d v2d_hshuffle2(v2d a, v2d b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v16i::m16i_gt
m16i m16i_gt(v16i a, v16i b)
Compares if elements of a are greater than those of b.
v2f::v2f_add
v2f v2f_add(v2f a, v2f b)
Elementwise addition ( a + b )
v4i::m4i_nxor
m4i m4i_nxor(m4i a, m4i b)
Bitwise nxor ( ~(a ^ b) )
v16i::v16i_fnmadd
v16i v16i_fnmadd(v16i a, v16i b, v16i acc)
Fused Multiply-Add ( -(a * b) + acc )
v4f::v4f_fprint
void v4f_fprint(FILE *file, v4f a)
Prints a v4f vector.
v1i::v1i_cast_v2f
v1i v1i_cast_v2f(v2f a)
Casts a v2f vector into a v1i vector.
v2f::v2f_hshuffle2x1
v2f v2f_hshuffle2x1(v2f a, v2f b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v1i::v1i_cvt_v8l
v1i v1i_cvt_v8l(v8l a)
Converts a v8l vector into a v1i vector.
v8l::v8l_reduce_or_v2l
v8l v8l_reduce_or_v2l(v2l a)
Reduction or ( | )
v1d::sd_cvt_v2f
double sd_cvt_v2f(v2f a)
Converts the first value of a v2f vector into double.
v2l::v2l_nxor
v2l v2l_nxor(v2l a, v2l b)
Bitwise nxor ( ~(a ^ b) )
v16f::v16f_storeu
void v16f_storeu(float *p, v16f a)
Stores a v16f vector into memory.
v2f::m2f_nxor
m2f m2f_nxor(m2f a, m2f b)
Bitwise nxor ( ~(a ^ b) )
v1l::m1l_cvt_m1f
m1l m1l_cvt_m1f(m1f a)
Converts a m1f vector-mask into a m1l vector-mask.
v1d::v1d_min
v1d v1d_min(v1d a, v1d b)
Elementwise min ( a < b ? a : b )
v16f::v16f_sub
v16f v16f_sub(v16f a, v16f b)
Elementwise subtraction ( a - b )
v1i::v1i_rsqrt
v1i v1i_rsqrt(v1i a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v8f::v8f_zero
v8f v8f_zero()
Sets all elements to 0.
v8d::v8d_cast_v2f
v8d v8d_cast_v2f(v2f a)
Casts a v2f vector into a v8d vector.
v8d::v8d_cast_v1l
v8d v8d_cast_v1l(v1l a)
Casts a v1l vector into a v8d vector.
v8d::v8d_cvt_v2f
v8d v8d_cvt_v2f(v2f a)
Converts a v2f vector into a v8d vector.
v4f::v4f_load1
v4f v4f_load1(const float *p)
Loads 1 float from memory and broadcasts it into a v4f vector.
v2l::v2l_not
v2l v2l_not(v2l a)
Bitwise not ( ~a )
v16f::v16f_rmerge4_v4f
v16f v16f_rmerge4_v4f(v4f a3, v4f a2, v4f a1, v4f a0)
Merges 4 v4f vectors together (reverse order).
v2l::m2l_or
m2l m2l_or(m2l a, m2l b)
Bitwise or ( a | b )
v16i::v16i_blend2x8
v16i v16i_blend2x8(v16i a, v16i b, uint_fast8_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v4d::v2d_get_high_v4d
v2d v2d_get_high_v4d(v4d a)
Gets the high part of a v4d vector.
v16f::v16f_reduce_min_v16f
v16f v16f_reduce_min_v16f(v16f a)
Reduction min ( min )
v4f::v4f_reduce_and
v4f v4f_reduce_and(v4f a)
Reduction and ( & )
v2i::v2i_blend1x2
v2i v2i_blend1x2(v2i a, v2i b, uint_fast8_t mask)
Creates a new v2i vector whose elements are from a and b choosed by mask.
v4l::v4l_cvt_v8f
v4l v4l_cvt_v8f(v8f a)
Converts a v8f vector into a v4l vector.
v2f::v2f_set_low_v1f
v2f v2f_set_low_v1f(v2f src, v1f low)
Sets the low part of a v2f vector.
v4d::v4d_rmerge2_v2d
v4d v4d_rmerge2_v2d(v2d a1, v2d a0)
Merges 2 v2d vectors together (reverse order).
v1f::v1f_cvt_v8i
v1f v1f_cvt_v8i(v8i a)
Converts a v8i vector into a v1f vector.
v2i::v2i_blend1
v2i v2i_blend1(v2i a, v2i b, uint_fast8_t mask)
Creates a new v2i vector whose elements are from a and b choosed by mask.
v1i::v1i_storeu
void v1i_storeu(int32_t *p, v1i a)
Stores a v1i vector into memory.
v16i::v16i_ornot
v16i v16i_ornot(v16i a, v16i b)
Bitwise ornot ( a | ~b )
v16f::v16f_geq
v16f v16f_geq(v16f a, v16f b)
Compares if elements of a are greater than or equal to those of b.
v1l::v1l_leq
v1l v1l_leq(v1l a, v1l b)
Compares if elements of a are less than or equal to those of b.
v16i::v16i_reduce_mul
v16i v16i_reduce_mul(v16i a)
Reduction mul ( * )
v2f::v2f_cvt_v8i
v2f v2f_cvt_v8i(v8i a)
Converts a v8i vector into a v2f vector.
v16f::v16f_hshuffle16
v16f v16f_hshuffle16(v16f a, v16f b, uint_fast64_t rule)
Shuffles (outer) a and b together using the control in rule.
v1i::v1i_reduce_max_v1i
v1i v1i_reduce_max_v1i(v1i a)
Reduction max ( max )
v8l::v8l_lt
v8l v8l_lt(v8l a, v8l b)
Compares if elements of a are less than those of b.
v1f::v1f_reduce_and_v1f
v1f v1f_reduce_and_v1f(v1f a)
Reduction and ( & )
v2d::v2d_blend2
v2d v2d_blend2(v2d a, v2d b, uint_fast8_t mask)
Creates a new v2d vector whose elements are from a and b choosed by mask.
v8f::m8f_cvt_m8l
m8f m8f_cvt_m8l(m8l a)
Converts a m8l vector-mask into a m8f vector-mask.
v1l::v1l_and
v1l v1l_and(v1l a, v1l b)
Bitwise and ( a & b )
v2d::v2d_cvt_v4f
v2d v2d_cvt_v4f(v4f a)
Converts a v4f vector into a v2d vector.
v4i::v4i_reduce_or_v16i
v4i v4i_reduce_or_v16i(v16i a)
Reduction or ( | )
v16f::v16f_cvt_v4d
v16f v16f_cvt_v4d(v4d a)
Converts a v4d vector into a v16f vector.
v4f::v4f_cvt_v1l
v4f v4f_cvt_v1l(v1l a)
Converts a v1l vector into a v4f vector.
v8l::v8l_rprintf
void v8l_rprintf(v8l a, const char *format)
Prints a v8l vector (reversed order)
v4i::v4i_permute2x2
v4i v4i_permute2x2(v4i a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v1l::v1l_rset
v1l v1l_rset(int64_t v0)
Sets the elements of a v1l vector (reverse order).
v2i::v2i_set1
v2i v2i_set1(int32_t v)
Broadcasts a single value into all elements of a v2i vector.
v8i::v8i_reduce_and_v2i
v8i v8i_reduce_and_v2i(v2i a)
Reduction and ( & )
v1d::sd_cvt_v2i
double sd_cvt_v2i(v2i a)
Converts the first value of a v2i vector into double.
v4d::m4d_and
m4d m4d_and(m4d a, m4d b)
Bitwise and ( a & b )
v16i::v16i_sub
v16i v16i_sub(v16i a, v16i b)
Elementwise subtraction ( a - b )
v8d::sd_reduce_min_v8d
v8d sd_reduce_min_v8d(v8d a)
Reduction min ( min )
v4l::v4l_rmerge_v2l
v4l v4l_rmerge_v2l(v2l high, v2l low)
Merges 2 v2l vectors together (reversed order).
v1l::sl_cvt_v4i
int64_t sl_cvt_v4i(v4i a)
Converts the first value of a v4i vector into int64_t.
v8l::v8l_neg
v8l v8l_neg(v8l a)
Elementwise negation ( -a )
v16f::v16f_load1
v16f v16f_load1(const float *p)
Loads 1 float from memory and broadcasts it into a v16f vector.
v4d::v4d_add
v4d v4d_add(v4d a, v4d b)
Elementwise addition ( a + b )
v16i::v16i_one
v16i v16i_one()
Sets all elements to 1.
v4d::v4d_cast_v4f
v4d v4d_cast_v4f(v4f a)
Casts a v4f vector into a v4d vector.
v4l::m4l_neq
m4l m4l_neq(v4l a, v4l b)
Compares the inequality of the two input vectors.
v4f::v4f_leq
v4f v4f_leq(v4f a, v4f b)
Compares if elements of a are less than or equal to those of b.
v2l::m2l_eq
m2l m2l_eq(v2l a, v2l b)
Compares the equality of the two input vectors.
v2d::v1d_get_hilo_v2d
v1d v1d_get_hilo_v2d(v2d a, int high)
Conditionnaly gets the low or the high part of a v2d vector.
v2l::v2l_cast_v1l
v2l v2l_cast_v1l(v1l a)
Casts a v1l vector into a v2l vector.
v8l::v8l_blend
v8l v8l_blend(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v2d::v2d_reduce_max_v2d
v2d v2d_reduce_max_v2d(v2d a)
Reduction max ( max )
v8i::v8i_cvt_v2i
v8i v8i_cvt_v2i(v2i a)
Converts a v2i vector into a v8i vector.
v2d::v2d_reduce_or_v1d
v2d v2d_reduce_or_v1d(v1d a)
Reduction or ( | )
v1f::v1f_reduce_mul_v2f
v1f v1f_reduce_mul_v2f(v2f a)
Reduction mul ( * )
v8f::v8f_load
v8f v8f_load(const float *p)
Loads 8 float from memory into a v8f vector.
v1l::v1l_reduce_add_v8l
v1l v1l_reduce_add_v8l(v8l a)
Reduction add ( + )
v8l::v8l_move
v8l v8l_move(v8l a)
Forwards the input.
v16i::v16i_and
v16i v16i_and(v16i a, v16i b)
Bitwise and ( a & b )
v4i::v4i_cvt_v4l
v4i v4i_cvt_v4l(v4l a)
Converts a v4l vector into a v4i vector.
v8d::v8d_ones
v8d v8d_ones()
Sets all bits to 1.
v2f::v2f_cast_v4d
v2f v2f_cast_v4d(v4d a)
Casts a v4d vector into a v2f vector.
v8i::v8i_neq
v8i v8i_neq(v8i a, v8i b)
Compares the inequality of the two input vectors.
v8f::v8f_reduce_min_v8f
v8f v8f_reduce_min_v8f(v8f a)
Reduction min ( min )
v1l::v1l_div
v1l v1l_div(v1l a, v1l b)
Elementwise division ( a / b )
v16i::v16i_permute
v16i v16i_permute(v16i a, uint_fast64_t rule)
Shuffles a using the control in rule.
v8i::v8i_rprintf
void v8i_rprintf(v8i a, const char *format)
Prints a v8i vector (reversed order)
v16i::v16i_cast_v1d
v16i v16i_cast_v1d(v1d a)
Casts a v1d vector into a v16i vector.
v8i::v8i_permute8x1
v8i v8i_permute8x1(v8i a, uint_fast32_t rule)
Shuffles (inner) a using the control in rule.
v8f::m8f_nand
m8f m8f_nand(m8f a, m8f b)
Bitwise nand ( ~(a & b) )
v1f::v1f_reduce_or
v1f v1f_reduce_or(v1f a)
Reduction or ( | )
v2f::v2f_cvt_v8l
v2f v2f_cvt_v8l(v8l a)
Converts a v8l vector into a v2f vector.
v1f::v1f_fprint
void v1f_fprint(FILE *file, v1f a)
Prints a v1f vector.
v16i::v16i_or
v16i v16i_or(v16i a, v16i b)
Bitwise or ( a | b )
v8f::v8f_hshuffle4
v8f v8f_hshuffle4(v8f a, v8f b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v16f::v16f_reduce_or_v1f
v16f v16f_reduce_or_v1f(v1f a)
Reduction or ( | )
v1f::v1f_fnmadd
v1f v1f_fnmadd(v1f a, v1f b, v1f acc)
Fused Multiply-Add ( -(a * b) + acc )
v4i::si_reduce_max_v4i
v4i si_reduce_max_v4i(v4i a)
Reduction max ( max )
v8i::v8i_rmerge_v4i
v8i v8i_rmerge_v4i(v4i high, v4i low)
Merges 2 v4i vectors together (reversed order).
v8l::v8l_nxor
v8l v8l_nxor(v8l a, v8l b)
Bitwise nxor ( ~(a ^ b) )
v1l::m1l_andnot
m1l m1l_andnot(m1l a, m1l b)
Bitwise andnot ( a & ~b )
v4d::v4d_reduce_and_v4d
v4d v4d_reduce_and_v4d(v4d a)
Reduction and ( & )
v4l::v4l_nxor
v4l v4l_nxor(v4l a, v4l b)
Bitwise nxor ( ~(a ^ b) )
v8d::v8d_cast_v8i
v8d v8d_cast_v8i(v8i a)
Casts a v8i vector into a v8d vector.
v4l::m4l_andnot
m4l m4l_andnot(m4l a, m4l b)
Bitwise andnot ( a & ~b )
v4d::v4d_one
v4d v4d_one()
Sets all elements to 1.
v8l::v8l_cvt_v2f
v8l v8l_cvt_v2f(v2f a)
Converts a v2f vector into a v8l vector.
v16f::v16f_cvt_v4f
v16f v16f_cvt_v4f(v4f a)
Converts a v4f vector into a v16f vector.
v8i::v8i_gt
v8i v8i_gt(v8i a, v8i b)
Compares if elements of a are greater than those of b.
v2i::v2i_div
v2i v2i_div(v2i a, v2i b)
Elementwise division ( a / b )
v4l::v4l_cast_v4d
v4l v4l_cast_v4d(v4d a)
Casts a v4d vector into a v4l vector.
v8l::v8l_reduce_or_v8l
v8l v8l_reduce_or_v8l(v8l a)
Reduction or ( | )
v8i::v8i_ones
v8i v8i_ones()
Sets all bits to 1.
v4d::v4d_blend4
v4d v4d_blend4(v4d a, v4d b, uint_fast8_t mask)
Creates a new v4d vector whose elements are from a and b choosed by mask.
v8d::m8d_nor
m8d m8d_nor(m8d a, m8d b)
Bitwise nor ( ~(a | b) )
v8i::v8i_cvt_v2l
v8i v8i_cvt_v2l(v2l a)
Converts a v2l vector into a v8i vector.
v8l::v8l_reduce_and_v1l
v8l v8l_reduce_and_v1l(v1l a)
Reduction and ( & )
v4i::v4i_reduce_and_v2i
v4i v4i_reduce_and_v2i(v2i a)
Reduction and ( & )
v2i::m2i_nxor
m2i m2i_nxor(m2i a, m2i b)
Bitwise nxor ( ~(a ^ b) )
v16i::v16i_reduce_or_v2i
v16i v16i_reduce_or_v2i(v2i a)
Reduction or ( | )
v2f::v2f_reduce_min_v8f
v2f v2f_reduce_min_v8f(v8f a)
Reduction min ( min )
v2i::v2i_cast_v8d
v2i v2i_cast_v8d(v8d a)
Casts a v8d vector into a v2i vector.
v1d::v1d_cast_v2l
v1d v1d_cast_v2l(v2l a)
Casts a v2l vector into a v1d vector.
v4l::v4l_cvt_v2f
v4l v4l_cvt_v2f(v2f a)
Converts a v2f vector into a v4l vector.
v2d::v2d_cast_v2l
v2d v2d_cast_v2l(v2l a)
Casts a v2l vector into a v2d vector.
v1f::v1f_cast_v4d
v1f v1f_cast_v4d(v4d a)
Casts a v4d vector into a v1f vector.
v2f::v2f_reduce_and_v1f
v2f v2f_reduce_and_v1f(v1f a)
Reduction and ( & )
v1d::m1d_cvt_v1d
m1d m1d_cvt_v1d(v1d a)
Converts a v1d vector into a m1d vector-mask.
v2f::sf_reduce_min_v2f
v2f sf_reduce_min_v2f(v2f a)
Reduction min ( min )
v1l::v1l_cast_v1l
v1l v1l_cast_v1l(v1l a)
Casts a v1l vector into a v1l vector.
v4d::v2d_get_hilo_v4d
v2d v2d_get_hilo_v4d(v4d a, int high)
Conditionnaly gets the low or the high part of a v4d vector.
v16i::v16i_cast_v1i
v16i v16i_cast_v1i(v1i a)
Casts a v1i vector into a v16i vector.
v1l::v1l_cvt_v1d
v1l v1l_cvt_v1d(v1d a)
Converts a v1d vector into a v1l vector.
v1i::v1i_reduce_min_v2i
v1i v1i_reduce_min_v2i(v2i a)
Reduction min ( min )
v2d::v2d_andnot
v2d v2d_andnot(v2d a, v2d b)
Bitwise andnot ( a & ~b )
v4d::v4d_lt
v4d v4d_lt(v4d a, v4d b)
Compares if elements of a are less than those of b.
v4f::v4f_fmsub
v4f v4f_fmsub(v4f a, v4f b, v4f acc)
Fused Multiply-Sub ( (a * b) - acc )
v8d::v4d_get_high_v8d
v4d v4d_get_high_v8d(v8d a)
Gets the high part of a v8d vector.
v2i::m2i_cvt_m2f
m2i m2i_cvt_m2f(m2f a)
Converts a m2f vector-mask into a m2i vector-mask.
v4i::v4i_reduce_min_v1i
v4i v4i_reduce_min_v1i(v1i a)
Reduction min ( min )
v16i::v16i_nand
v16i v16i_nand(v16i a, v16i b)
Bitwise nand ( ~(a & b) )
v1l::v1l_gt
v1l v1l_gt(v1l a, v1l b)
Compares if elements of a are greater than those of b.
v2d::v2d_neg
v2d v2d_neg(v2d a)
Elementwise negation ( -a )
v1d::m1d_nxor
m1d m1d_nxor(m1d a, m1d b)
Bitwise nxor ( ~(a ^ b) )
v16f::v16f_rmerge8_v2f
v16f v16f_rmerge8_v2f(v2f a7, v2f a6, v2f a5, v2f a4, v2f a3, v2f a2, v2f a1, v2f a0)
Merges 8 v2f vectors together (reverse order).
v2i::v2i_cast_v2f
v2i v2i_cast_v2f(v2f a)
Casts a v2f vector into a v2i vector.
v1f::sf_reduce_or_v1f
v1f sf_reduce_or_v1f(v1f a)
Reduction or ( | )
v1f::m1f_eq
m1f m1f_eq(v1f a, v1f b)
Compares the equality of the two input vectors.
v2f::v2f_reduce_min_v2f
v2f v2f_reduce_min_v2f(v2f a)
Reduction min ( min )
v16f::v16f_reduce_and_v1f
v16f v16f_reduce_and_v1f(v1f a)
Reduction and ( & )
v8f::v8f_fmadd
v8f v8f_fmadd(v8f a, v8f b, v8f acc)
Fused Multiply-Add ( (a * b) + acc )
v2l::v2l_hshuffle
v2l v2l_hshuffle(v2l a, v2l b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v4l::v4l_cast_v4f
v4l v4l_cast_v4f(v4f a)
Casts a v4f vector into a v4l vector.
v4i::m4i_geq
m4i m4i_geq(v4i a, v4i b)
Compares if elements of a are greater than or equal to those of b.
v2f::v2f_cast_v1l
v2f v2f_cast_v1l(v1l a)
Casts a v1l vector into a v2f vector.
v2f::v2f_blend2
v2f v2f_blend2(v2f a, v2f b, uint_fast8_t mask)
Creates a new v2f vector whose elements are from a and b choosed by mask.
v16i::v16i_cast_v8d
v16i v16i_cast_v8d(v8d a)
Casts a v8d vector into a v16i vector.
v4f::v4f_rfprint
void v4f_rfprint(FILE *file, v4f a)
Prints a v4f vector (reversed order)
v16i::v16i_permute4
v16i v16i_permute4(v16i a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v2i::v2i_reduce_or_v8i
v2i v2i_reduce_or_v8i(v8i a)
Reduction or ( | )
v2d::v2d_permute
v2d v2d_permute(v2d a, uint_fast8_t rule)
Shuffles a using the control in rule.
v16i::v16i_blend4x4
v16i v16i_blend4x4(v16i a, v16i b, uint_fast8_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v1l::v1l_cvt_v8l
v1l v1l_cvt_v8l(v8l a)
Converts a v8l vector into a v1l vector.
v8f::v8f_hshuffle8x1
v8f v8f_hshuffle8x1(v8f a, v8f b, uint_fast32_t rule)
Shuffles (inner) a and b together using the control in rule.
v16f::v16f_reduce_and
v16f v16f_reduce_and(v16f a)
Reduction and ( & )
v4i::v4i_cvt_v8i
v4i v4i_cvt_v8i(v8i a)
Converts a v8i vector into a v4i vector.
v4l::v4l_reduce_max_v4l
v4l v4l_reduce_max_v4l(v4l a)
Reduction max ( max )
v1f::v1f_loadu
v1f v1f_loadu(const float *p)
Loads 1 float from memory into a v1f vector.
v2i::v2i_print
void v2i_print(v2i a)
Prints a v2i vector.
v4i::v4i_blend4
v4i v4i_blend4(v4i a, v4i b, uint_fast8_t mask)
Creates a new v4i vector whose elements are from a and b choosed by mask.
v8l::m8l_ornot
m8l m8l_ornot(m8l a, m8l b)
Bitwise ornot ( a | ~b )
v1l::v1l_fprintf
void v1l_fprintf(FILE *file, v1l a, const char *format)
Prints a v1l vector.
v2f::m2f_neq
m2f m2f_neq(v2f a, v2f b)
Compares the inequality of the two input vectors.
v4i::v4i_fshuffle
v4i v4i_fshuffle(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v16f::m16f_eq
m16f m16f_eq(v16f a, v16f b)
Compares the equality of the two input vectors.
v4l::v4l_cast_v2f
v4l v4l_cast_v2f(v2f a)
Casts a v2f vector into a v4l vector.
v2l::sl_reduce_or_v2l
v2l sl_reduce_or_v2l(v2l a)
Reduction or ( | )
v16i::v16i_fshuffle2x8
v16i v16i_fshuffle2x8(v16i a, v16i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1f::v1f_set1
v1f v1f_set1(float v)
Broadcasts a single value into all elements of a v1f vector.
v16f::v16f_cvt_v16f
v16f v16f_cvt_v16f(v16f a)
Converts a v16f vector into a v16f vector.
v2d::v2d_fshuffle
v2d v2d_fshuffle(v2d a, v2d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8f::v8f_max
v8f v8f_max(v8f a, v8f b)
Elementwise max ( a > b ? a : b )
v8d::v8d_rcp
v8d v8d_rcp(v8d a)
Elementwise reciprocal ( 1 / a )
v8d::v8d_reduce_or_v2d
v8d v8d_reduce_or_v2d(v2d a)
Reduction or ( | )
v2f::v2f_permute2
v2f v2f_permute2(v2f a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v8f::m8f_eq
m8f m8f_eq(v8f a, v8f b)
Compares the equality of the two input vectors.
v16f::v16f_blend2x8
v16f v16f_blend2x8(v16f a, v16f b, uint_fast8_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v1d::v1d_abs
v1d v1d_abs(v1d a)
Elementwise absolute value ( a > 0 ? a : -a )
v4d::m4d_eq
m4d m4d_eq(v4d a, v4d b)
Compares the equality of the two input vectors.
v16f::v8f_get_high_v16f
v8f v8f_get_high_v16f(v16f a)
Gets the high part of a v16f vector.
v8f::v8f_merge2_v4f
v8f v8f_merge2_v4f(v4f a0, v4f a1)
Merges 2 v4f vectors together.
v4f::m4f_nand
m4f m4f_nand(m4f a, m4f b)
Bitwise nand ( ~(a & b) )
v4l::v4l_reduce_max
v4l v4l_reduce_max(v4l a)
Reduction max ( max )
v1d::v1d_reduce_min
v1d v1d_reduce_min(v1d a)
Reduction min ( min )
v8f::v8f_reduce_add_v8f
v8f v8f_reduce_add_v8f(v8f a)
Reduction add ( + )
v2f::v2f_sub
v2f v2f_sub(v2f a, v2f b)
Elementwise subtraction ( a - b )
v8d::v8d_one
v8d v8d_one()
Sets all elements to 1.
v1f::m1f_gt
m1f m1f_gt(v1f a, v1f b)
Compares if elements of a are greater than those of b.
v8f::v8f_cvt_v8l
v8f v8f_cvt_v8l(v8l a)
Converts a v8l vector into a v8f vector.
v2d::v2d_rprintf
void v2d_rprintf(v2d a, const char *format)
Prints a v2d vector (reversed order)
v4l::v4l_blend2x2
v4l v4l_blend2x2(v4l a, v4l b, uint_fast8_t mask)
Creates a new v4l vector whose elements are from a and b choosed by mask.
v1i::v1i_andnot
v1i v1i_andnot(v1i a, v1i b)
Bitwise andnot ( a & ~b )
v1d::m1d_cvt_m1f
m1d m1d_cvt_m1f(m1f a)
Converts a m1f vector-mask into a m1d vector-mask.
v2f::v2f_cast_v1d
v2f v2f_cast_v1d(v1d a)
Casts a v1d vector into a v2f vector.
v8f::v8f_zeros
v8f v8f_zeros()
Sets all bits to 0.
v2i::v2i_reduce_and_v2i
v2i v2i_reduce_and_v2i(v2i a)
Reduction and ( & )
v2f::v2f_cvt_v2f
v2f v2f_cvt_v2f(v2f a)
Converts a v2f vector into a v2f vector.
v8i::v8i_cast_v4d
v8i v8i_cast_v4d(v4d a)
Casts a v4d vector into a v8i vector.
v8l::v8l_cast_v2l
v8l v8l_cast_v2l(v2l a)
Casts a v2l vector into a v8l vector.
v1d::v1d_xor
v1d v1d_xor(v1d a, v1d b)
Bitwise xor ( a ^ b )
v4d::v4d_permute
v4d v4d_permute(v4d a, uint_fast8_t rule)
Shuffles a using the control in rule.
v4f::v4f_reduce_max_v16f
v4f v4f_reduce_max_v16f(v16f a)
Reduction max ( max )
v8i::v8i_reduce_or_v4i
v8i v8i_reduce_or_v4i(v4i a)
Reduction or ( | )
v1l::v1l_store
void v1l_store(int64_t *p, v1l a)
Stores a v1l vector into memory.
v16i::v16i_rsqrt
v16i v16i_rsqrt(v16i a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v16i::v16i_cvt_v8l
v16i v16i_cvt_v8l(v8l a)
Converts a v8l vector into a v16i vector.
v2d::v2d_reduce_max_v4d
v2d v2d_reduce_max_v4d(v4d a)
Reduction max ( max )
v8l::sl_reduce_or_v8l
v8l sl_reduce_or_v8l(v8l a)
Reduction or ( | )
v8i::v8i_zero
v8i v8i_zero()
Sets all elements to 0.
v4i::v4i_permute4
v4i v4i_permute4(v4i a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v1d::v1d_rsqrt
v1d v1d_rsqrt(v1d a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v2i::v2i_cvt_v4d
v2i v2i_cvt_v4d(v4d a)
Converts a v4d vector into a v2i vector.
v1f::m1f_cast_v1f
m1f m1f_cast_v1f(v1f a)
Casts a v1f vector into a m1f vector-mask.
v2f::v2f_cast_v2f
v2f v2f_cast_v2f(v2f a)
Casts a v2f vector into a v2f vector.
v2i::v2i_cast_v8i
v2i v2i_cast_v8i(v8i a)
Casts a v8i vector into a v2i vector.
v2f::sf_reduce_or_v2f
v2f sf_reduce_or_v2f(v2f a)
Reduction or ( | )
v16i::v16i_xor
v16i v16i_xor(v16i a, v16i b)
Bitwise xor ( a ^ b )
v2i::v2i_reduce_mul_v4i
v2i v2i_reduce_mul_v4i(v4i a)
Reduction mul ( * )
v4i::v4i_fshuffle4
v4i v4i_fshuffle4(v4i a, v4i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v1d::v1d_cvt_v2d
v1d v1d_cvt_v2d(v2d a)
Converts a v2d vector into a v1d vector.
v2f::v2f_blend
v2f v2f_blend(v2f a, v2f b, uint_fast8_t mask)
Creates a new v2f vector whose elements are from a and b choosed by mask.
v16f::v16f_fshuffle8
v16f v16f_fshuffle8(v16f a, v16f b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v4i::v4i_rsqrt
v4i v4i_rsqrt(v4i a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v16i::m16i_cast_v16i
m16i m16i_cast_v16i(v16i a)
Casts a v16i vector into a m16i vector-mask.
v1l::v1l_one
v1l v1l_one()
Sets all elements to 1.
v2d::v2d_cvt_v1d
v2d v2d_cvt_v1d(v1d a)
Converts a v1d vector into a v2d vector.
v4f::v4f_reduce_mul_v16f
v4f v4f_reduce_mul_v16f(v16f a)
Reduction mul ( * )
v1l::v1l_cast_v4f
v1l v1l_cast_v4f(v4f a)
Casts a v4f vector into a v1l vector.
v4f::sf_reduce_and_v4f
v4f sf_reduce_and_v4f(v4f a)
Reduction and ( & )
v2l::v2l_or
v2l v2l_or(v2l a, v2l b)
Bitwise or ( a | b )
v8d::v8d_and
v8d v8d_and(v8d a, v8d b)
Bitwise and ( a & b )
v16i::v16i_reduce_min_v1i
v16i v16i_reduce_min_v1i(v1i a)
Reduction min ( min )
v8i::si_reduce_max_v8i
v8i si_reduce_max_v8i(v8i a)
Reduction max ( max )
v4f::v4f_max
v4f v4f_max(v4f a, v4f b)
Elementwise max ( a > b ? a : b )
v2l::v2l_cast_v1i
v2l v2l_cast_v1i(v1i a)
Casts a v1i vector into a v2l vector.
v2f::v2f_or
v2f v2f_or(v2f a, v2f b)
Bitwise or ( a | b )
v1i::v1i_mul
v1i v1i_mul(v1i a, v1i b)
Elementwise multiplication ( a * b )
v8f::m8f_or
m8f m8f_or(m8f a, m8f b)
Bitwise or ( a | b )
v1f::v1f_cast_v1i
v1f v1f_cast_v1i(v1i a)
Casts a v1i vector into a v1f vector.
v4d::v4d_nand
v4d v4d_nand(v4d a, v4d b)
Bitwise nand ( ~(a & b) )
v4f::m4f_cvt_v4f
m4f m4f_cvt_v4f(v4f a)
Converts a v4f vector into a m4f vector-mask.
v16i::v16i_maskz_move
v16i v16i_maskz_move(m16i mask, v16i a)
Mask the input.
v1l::v1l_blend
v1l v1l_blend(v1l a, v1l b, uint_fast8_t mask)
Creates a new v1l vector whose elements are from a and b choosed by mask.
v8f::v8f_set_high_v4f
v8f v8f_set_high_v4f(v8f src, v4f high)
Sets the high part of a v8f vector.
v1i::v1i_frcp
v1i v1i_frcp(v1i a)
Fast elementwise reciprocal ( 1 / a )
v16i::v16i_reduce_max
v16i v16i_reduce_max(v16i a)
Reduction max ( max )
v4l::sl_reduce_min_v4l
v4l sl_reduce_min_v4l(v4l a)
Reduction min ( min )
v16f::v16f_cast_v2l
v16f v16f_cast_v2l(v2l a)
Casts a v2l vector into a v16f vector.
v4f::v4f_rmerge2_v2f
v4f v4f_rmerge2_v2f(v2f a1, v2f a0)
Merges 2 v2f vectors together (reverse order).
v4d::v4d_permute4x1
v4d v4d_permute4x1(v4d a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v8l::v8l_blend2x4
v8l v8l_blend2x4(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v1i::v1i_nand
v1i v1i_nand(v1i a, v1i b)
Bitwise nand ( ~(a & b) )
v1d::v1d_ornot
v1d v1d_ornot(v1d a, v1d b)
Bitwise ornot ( a | ~b )
v8l::v8l_permute2x4
v8l v8l_permute2x4(v8l a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v1d::v1d_max
v1d v1d_max(v1d a, v1d b)
Elementwise max ( a > b ? a : b )
v2f::v2f_reduce_or_v1f
v2f v2f_reduce_or_v1f(v1f a)
Reduction or ( | )
v4f::v4f_move
v4f v4f_move(v4f a)
Forwards the input.
v8l::v8l_fshuffle8
v8l v8l_fshuffle8(v8l a, v8l b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8i::v8i_reduce_mul_v1i
v8i v8i_reduce_mul_v1i(v1i a)
Reduction mul ( * )
v2d::v2d_cvt_v2d
v2d v2d_cvt_v2d(v2d a)
Converts a v2d vector into a v2d vector.
v2d::v2d_reduce_or
v2d v2d_reduce_or(v2d a)
Reduction or ( | )
v8f::v8f_merge_v4f
v8f v8f_merge_v4f(v4f low, v4f high)
Merges 2 v4f vectors together.
v2l::v2l_printf
void v2l_printf(v2l a, const char *format)
Prints a v2l vector.
v8l::v8l_cvt_v8l
v8l v8l_cvt_v8l(v8l a)
Converts a v8l vector into a v8l vector.
v1i::v1i_cvt_v4i
v1i v1i_cvt_v4i(v4i a)
Converts a v4i vector into a v1i vector.
v4i::v4i_cast_v1i
v4i v4i_cast_v1i(v1i a)
Casts a v1i vector into a v4i vector.
v2i::v2i_one
v2i v2i_one()
Sets all elements to 1.
v2l::v2l_cast_v8l
v2l v2l_cast_v8l(v8l a)
Casts a v8l vector into a v2l vector.
v4l::v4l_cast_v2d
v4l v4l_cast_v2d(v2d a)
Casts a v2d vector into a v4l vector.
v8i::v8i_hshuffle2
v8i v8i_hshuffle2(v8i a, v8i b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v4l::v4l_reduce_add_v4l
v4l v4l_reduce_add_v4l(v4l a)
Reduction add ( + )
v4l::v4l_fnmsub
v4l v4l_fnmsub(v4l a, v4l b, v4l acc)
Fused Multiply-Add ( -(a * b) - acc )
v1f::v1f_rfprint
void v1f_rfprint(FILE *file, v1f a)
Prints a v1f vector (reversed order)
v8i::v8i_permute
v8i v8i_permute(v8i a, uint_fast32_t rule)
Shuffles a using the control in rule.
v4f::sf_reduce_or_v4f
v4f sf_reduce_or_v4f(v4f a)
Reduction or ( | )
v8l::v8l_cast_v1d
v8l v8l_cast_v1d(v1d a)
Casts a v1d vector into a v8l vector.
v4l::v4l_reduce_mul_v2l
v4l v4l_reduce_mul_v2l(v2l a)
Reduction mul ( * )
v8l::v8l_cast_v2i
v8l v8l_cast_v2i(v2i a)
Casts a v2i vector into a v8l vector.
v8l::v8l_cast_v4f
v8l v8l_cast_v4f(v4f a)
Casts a v4f vector into a v8l vector.
v8f::v8f_print
void v8f_print(v8f a)
Prints a v8f vector.
v16i::v16i_min
v16i v16i_min(v16i a, v16i b)
Elementwise min ( a < b ? a : b )
v1i::m1i_ornot
m1i m1i_ornot(m1i a, m1i b)
Bitwise ornot ( a | ~b )
v4i::v4i_permute4x1
v4i v4i_permute4x1(v4i a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v8l::v8l_load
v8l v8l_load(const int64_t *p)
Loads 8 int64_t from memory into a v8l vector.
v4i::v4i_zeros
v4i v4i_zeros()
Sets all bits to 0.
v16i::m16i_nxor
m16i m16i_nxor(m16i a, m16i b)
Bitwise nxor ( ~(a ^ b) )
v1i::v1i_reduce_add_v8i
v1i v1i_reduce_add_v8i(v8i a)
Reduction add ( + )
v8d::m8d_gt
m8d m8d_gt(v8d a, v8d b)
Compares if elements of a are greater than those of b.
v8d::v8d_reduce_add
v8d v8d_reduce_add(v8d a)
Reduction add ( + )
v4l::v4l_neg
v4l v4l_neg(v4l a)
Elementwise negation ( -a )
v16i::v16i_cast_v4l
v16i v16i_cast_v4l(v4l a)
Casts a v4l vector into a v16i vector.
v1l::v1l_mask_move
v1l v1l_mask_move(m1l mask, v1l src, v1l a)
Mask the input.
v8f::v8f_fprint
void v8f_fprint(FILE *file, v8f a)
Prints a v8f vector.
v8l::v8l_cast_v4d
v8l v8l_cast_v4d(v4d a)
Casts a v4d vector into a v8l vector.
v1i::si_reduce_add_v1i
v1i si_reduce_add_v1i(v1i a)
Reduction add ( + )
v4l::v4l_frcp
v4l v4l_frcp(v4l a)
Fast elementwise reciprocal ( 1 / a )
v8l::v8l_reduce_and_v8l
v8l v8l_reduce_and_v8l(v8l a)
Reduction and ( & )
v16f::v16f_cvt_v2f
v16f v16f_cvt_v2f(v2f a)
Converts a v2f vector into a v16f vector.
v2d::v2d_cast_v1l
v2d v2d_cast_v1l(v1l a)
Casts a v1l vector into a v2d vector.
v1f::v1f_set
v1f v1f_set(float v0)
Sets the elements of a v1f vector.
v4f::sf_reduce_max_v4f
v4f sf_reduce_max_v4f(v4f a)
Reduction max ( max )
v2l::v2l_set1
v2l v2l_set1(int64_t v)
Broadcasts a single value into all elements of a v2l vector.
v16i::v16i_rcp
v16i v16i_rcp(v16i a)
Elementwise reciprocal ( 1 / a )
v1f::sf_cvt_v1f
float sf_cvt_v1f(v1f a)
Converts the first value of a v1f vector into float.
v4f::v4f_cvt_v1d
v4f v4f_cvt_v1d(v1d a)
Converts a v1d vector into a v4f vector.
v8l::m8l_geq
m8l m8l_geq(v8l a, v8l b)
Compares if elements of a are greater than or equal to those of b.
v2d::v2d_cvt_v2i
v2d v2d_cvt_v2i(v2i a)
Converts a v2i vector into a v2d vector.
v8d::v8d_merge4_v2d
v8d v8d_merge4_v2d(v2d a0, v2d a1, v2d a2, v2d a3)
Merges 4 v2d vectors together.
v1d::v1d_cast_v8i
v1d v1d_cast_v8i(v8i a)
Casts a v8i vector into a v1d vector.
v4i::v2i_get_hilo_v4i
v2i v2i_get_hilo_v4i(v4i a, int high)
Conditionnaly gets the low or the high part of a v4i vector.
v2l::v2l_fnmadd
v2l v2l_fnmadd(v2l a, v2l b, v2l acc)
Fused Multiply-Add ( -(a * b) + acc )
v2f::v2f_fnmadd
v2f v2f_fnmadd(v2f a, v2f b, v2f acc)
Fused Multiply-Add ( -(a * b) + acc )
v4d::m4d_or
m4d m4d_or(m4d a, m4d b)
Bitwise or ( a | b )
v2d::m2d_cvt_m2d
m2d m2d_cvt_m2d(m2d a)
Converts a m2d vector-mask into a m2d vector-mask.
v2f::v2f_reduce_mul_v2f
v2f v2f_reduce_mul_v2f(v2f a)
Reduction mul ( * )
v8f::v8f_store1
void v8f_store1(float *p, v8f a)
Stores the first element of a v8f vector into memory.
v2d::v2d_cvt_v1l
v2d v2d_cvt_v1l(v1l a)
Converts a v1l vector into a v2d vector.
v1d::v1d_cvt_v2f
v1d v1d_cvt_v2f(v2f a)
Converts a v2f vector into a v1d vector.
v16i::m16i_cvt_m16f
m16i m16i_cvt_m16f(m16f a)
Converts a m16f vector-mask into a m16i vector-mask.
v1f::sf_cvt_v2d
float sf_cvt_v2d(v2d a)
Converts the first value of a v2d vector into float.
v2i::m2i_ornot
m2i m2i_ornot(m2i a, m2i b)
Bitwise ornot ( a | ~b )
v4f::v4f_cvt_v8d
v4f v4f_cvt_v8d(v8d a)
Converts a v8d vector into a v4f vector.
v2i::v2i_reduce_mul_v8i
v2i v2i_reduce_mul_v8i(v8i a)
Reduction mul ( * )
v8i::v8i_blend8
v8i v8i_blend8(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v4f::v4f_nxor
v4f v4f_nxor(v4f a, v4f b)
Bitwise nxor ( ~(a ^ b) )
v2l::v2l_reduce_mul_v8l
v2l v2l_reduce_mul_v8l(v8l a)
Reduction mul ( * )
v4l::v2l_get_low_v4l
v2l v2l_get_low_v4l(v4l a)
Gets the low part of a v4l vector.
v4i::v4i_zero
v4i v4i_zero()
Sets all elements to 0.
v8f::v8f_cvt_v4f
v8f v8f_cvt_v4f(v4f a)
Converts a v4f vector into a v8f vector.
v16f::v16f_cast_v16f
v16f v16f_cast_v16f(v16f a)
Casts a v16f vector into a v16f vector.
v8d::v8d_fshuffle8
v8d v8d_fshuffle8(v8d a, v8d b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v8l::v8l_cvt_v2i
v8l v8l_cvt_v2i(v2i a)
Converts a v2i vector into a v8l vector.
v2i::v2i_reduce_or_v16i
v2i v2i_reduce_or_v16i(v16i a)
Reduction or ( | )
v1l::v1l_frsqrt
v1l v1l_frsqrt(v1l a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v4l::v4l_reduce_min_v4l
v4l v4l_reduce_min_v4l(v4l a)
Reduction min ( min )
v2l::v2l_permute
v2l v2l_permute(v2l a, uint_fast8_t rule)
Shuffles a using the control in rule.
v1l::v1l_reduce_max_v1l
v1l v1l_reduce_max_v1l(v1l a)
Reduction max ( max )
v16i::v16i_hshuffle2
v16i v16i_hshuffle2(v16i a, v16i b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v16f::m16f_nxor
m16f m16f_nxor(m16f a, m16f b)
Bitwise nxor ( ~(a ^ b) )
v4l::v4l_reduce_add_v2l
v4l v4l_reduce_add_v2l(v2l a)
Reduction add ( + )
v8d::v8d_cast_v4d
v8d v8d_cast_v4d(v4d a)
Casts a v4d vector into a v8d vector.
v8i::v8i_nand
v8i v8i_nand(v8i a, v8i b)
Bitwise nand ( ~(a & b) )
v4l::v4l_cast_v2i
v4l v4l_cast_v2i(v2i a)
Casts a v2i vector into a v4l vector.
v1d::v1d_nand
v1d v1d_nand(v1d a, v1d b)
Bitwise nand ( ~(a & b) )
v16f::v16f_cvt_v8d
v16f v16f_cvt_v8d(v8d a)
Converts a v8d vector into a v16f vector.
v1i::si_cvt_v8d
int32_t si_cvt_v8d(v8d a)
Converts the first value of a v8d vector into int32_t.
v8i::v8i_reduce_add_v2i
v8i v8i_reduce_add_v2i(v2i a)
Reduction add ( + )
v8l::v8l_store1
void v8l_store1(int64_t *p, v8l a)
Stores the first element of a v8l vector into memory.
v4f::v4f_cast_m4f
v4f v4f_cast_m4f(m4f a)
Casts a m4f vector-mask into a v4f vector.
v1f::v1f_cast_v4f
v1f v1f_cast_v4f(v4f a)
Casts a v4f vector into a v1f vector.
v1d::v1d_neq
v1d v1d_neq(v1d a, v1d b)
Compares the inequality of the two input vectors.
v4i::m4i_lt
m4i m4i_lt(v4i a, v4i b)
Compares if elements of a are less than those of b.
v8i::v8i_fmsub
v8i v8i_fmsub(v8i a, v8i b, v8i acc)
Fused Multiply-Sub ( (a * b) - acc )
v2f::v2f_fshuffle2
v2f v2f_fshuffle2(v2f a, v2f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v1f::m1f_nand
m1f m1f_nand(m1f a, m1f b)
Bitwise nand ( ~(a & b) )
v2f::v2f_cvt_v2l
v2f v2f_cvt_v2l(v2l a)
Converts a v2l vector into a v2f vector.
v2d::v2d_rsqrt
v2d v2d_rsqrt(v2d a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v8f::v8f_cvt_v1l
v8f v8f_cvt_v1l(v1l a)
Converts a v1l vector into a v8f vector.
v1i::v1i_cast_v16i
v1i v1i_cast_v16i(v16i a)
Casts a v16i vector into a v1i vector.
v8l::v8l_rprint
void v8l_rprint(v8l a)
Prints a v8l vector (reversed order)
v8l::v8l_cast_v8i
v8l v8l_cast_v8i(v8i a)
Casts a v8i vector into a v8l vector.
v1i::v1i_cast_v1i
v1i v1i_cast_v1i(v1i a)
Casts a v1i vector into a v1i vector.
m4i
Type for the manipulation of vector-masks.
Definition: pints-doc.h:472
v1i::v1i_reduce_mul_v2i
v1i v1i_reduce_mul_v2i(v2i a)
Reduction mul ( * )
v1f::v1f_reduce_max_v16f
v1f v1f_reduce_max_v16f(v16f a)
Reduction max ( max )
v8f::v8f_reduce_mul_v2f
v8f v8f_reduce_mul_v2f(v2f a)
Reduction mul ( * )
v1f::m1f_neq
m1f m1f_neq(v1f a, v1f b)
Compares the inequality of the two input vectors.
v4d::v4d_blend
v4d v4d_blend(v4d a, v4d b, uint_fast8_t mask)
Creates a new v4d vector whose elements are from a and b choosed by mask.
v2d::v2d_set_hilo_v1d
v2d v2d_set_hilo_v1d(v2d src, v1d a, int high)
Conditionally sets the low or the high part of a v2d vector.
v1l::m1l_or
m1l m1l_or(m1l a, m1l b)
Bitwise or ( a | b )
v1i::m1i_cvt_v1i
m1i m1i_cvt_v1i(v1i a)
Converts a v1i vector into a m1i vector-mask.
v1i::v1i_cvt_v4f
v1i v1i_cvt_v4f(v4f a)
Converts a v4f vector into a v1i vector.
v16f::v16f_not
v16f v16f_not(v16f a)
Bitwise not ( ~a )
v8d::v8d_load
v8d v8d_load(const double *p)
Loads 8 double from memory into a v8d vector.
v8l::v8l_merge2_v4l
v8l v8l_merge2_v4l(v4l a0, v4l a1)
Merges 2 v4l vectors together.
v16i::si_reduce_or_v16i
v16i si_reduce_or_v16i(v16i a)
Reduction or ( | )
v2d::v2d_reduce_mul_v2d
v2d v2d_reduce_mul_v2d(v2d a)
Reduction mul ( * )
v8d::v8d_reduce_and_v8d
v8d v8d_reduce_and_v8d(v8d a)
Reduction and ( & )
v8i::v8i_rmerge8_v1i
v8i v8i_rmerge8_v1i(v1i a7, v1i a6, v1i a5, v1i a4, v1i a3, v1i a2, v1i a1, v1i a0)
Merges 8 v1i vectors together (reverse order).
v1d::m1d_or
m1d m1d_or(m1d a, m1d b)
Bitwise or ( a | b )
v2f::v2f_cast_v1f
v2f v2f_cast_v1f(v1f a)
Casts a v1f vector into a v2f vector.
v2i::v2i_load1
v2i v2i_load1(const int32_t *p)
Loads 1 int32_t from memory and broadcasts it into a v2i vector.
v2i::v2i_reduce_max
v2i v2i_reduce_max(v2i a)
Reduction max ( max )
v8d::v8d_gt
v8d v8d_gt(v8d a, v8d b)
Compares if elements of a are greater than those of b.
v2l::v2l_rprint
void v2l_rprint(v2l a)
Prints a v2l vector (reversed order)
v8l::v8l_reduce_max_v2l
v8l v8l_reduce_max_v2l(v2l a)
Reduction max ( max )
v2i::v2i_cast_v4i
v2i v2i_cast_v4i(v4i a)
Casts a v4i vector into a v2i vector.
v1i::m1i_cvt_m1d
m1i m1i_cvt_m1d(m1d a)
Converts a m1d vector-mask into a m1i vector-mask.
v4l::v4l_rset
v4l v4l_rset(int64_t v3, int64_t v2, int64_t v1, int64_t v0)
Sets the elements of a v4l vector (reverse order).
v8f::v8f_cvt_v4d
v8f v8f_cvt_v4d(v4d a)
Converts a v4d vector into a v8f vector.
v1f::sf_cvt_v4l
float sf_cvt_v4l(v4l a)
Converts the first value of a v4l vector into float.
v2i::si_reduce_min_v2i
v2i si_reduce_min_v2i(v2i a)
Reduction min ( min )
v2i::v2i_frcp
v2i v2i_frcp(v2i a)
Fast elementwise reciprocal ( 1 / a )
v4d::v4d_reduce_or_v8d
v4d v4d_reduce_or_v8d(v8d a)
Reduction or ( | )
v4f::v4f_set_hilo_v2f
v4f v4f_set_hilo_v2f(v4f src, v2f a, int high)
Conditionally sets the low or the high part of a v4f vector.
v2l::v2l_reduce_min_v1l
v2l v2l_reduce_min_v1l(v1l a)
Reduction min ( min )
v2d::v2d_reduce_add_v8d
v2d v2d_reduce_add_v8d(v8d a)
Reduction add ( + )
v2d::v2d_nxor
v2d v2d_nxor(v2d a, v2d b)
Bitwise nxor ( ~(a ^ b) )
v4f::m4f_and
m4f m4f_and(m4f a, m4f b)
Bitwise and ( a & b )
v16f::v16f_cast_v8l
v16f v16f_cast_v8l(v8l a)
Casts a v8l vector into a v16f vector.
v1l::v1l_zero
v1l v1l_zero()
Sets all elements to 0.
v2d::m2d_cvt_m2l
m2d m2d_cvt_m2l(m2l a)
Converts a m2l vector-mask into a m2d vector-mask.
v8l::v8l_reduce_min_v8l
v8l v8l_reduce_min_v8l(v8l a)
Reduction min ( min )
v8d::v8d_reduce_add_v1d
v8d v8d_reduce_add_v1d(v1d a)
Reduction add ( + )
v4d::v4d_blend4x1
v4d v4d_blend4x1(v4d a, v4d b, uint_fast8_t mask)
Creates a new v4d vector whose elements are from a and b choosed by mask.
v2f::v2f_cvt_v4i
v2f v2f_cvt_v4i(v4i a)
Converts a v4i vector into a v2f vector.
v2l::v2l_max
v2l v2l_max(v2l a, v2l b)
Elementwise max ( a > b ? a : b )
v2d::v2d_cvt_v2l
v2d v2d_cvt_v2l(v2l a)
Converts a v2l vector into a v2d vector.
v1f::v1f_or
v1f v1f_or(v1f a, v1f b)
Bitwise or ( a | b )
v16i::v16i_cast_v8f
v16i v16i_cast_v8f(v8f a)
Casts a v8f vector into a v16i vector.
v2f::m2f_cvt_m2i
m2f m2f_cvt_m2i(m2i a)
Converts a m2i vector-mask into a m2f vector-mask.
v1l::m1l_and
m1l m1l_and(m1l a, m1l b)
Bitwise and ( a & b )
v16f::v16f_ones
v16f v16f_ones()
Sets all bits to 1.
v8d::v8d_cast_v2i
v8d v8d_cast_v2i(v2i a)
Casts a v2i vector into a v8d vector.
v8l::v8l_permute4x2
v8l v8l_permute4x2(v8l a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v4i::v4i_rfprint
void v4i_rfprint(FILE *file, v4i a)
Prints a v4i vector (reversed order)
v2l::v2l_reduce_or
v2l v2l_reduce_or(v2l a)
Reduction or ( | )
v8f::v8f_geq
v8f v8f_geq(v8f a, v8f b)
Compares if elements of a are greater than or equal to those of b.
v4l::v4l_cast_v1d
v4l v4l_cast_v1d(v1d a)
Casts a v1d vector into a v4l vector.
v8d::v8d_cvt_v8l
v8d v8d_cvt_v8l(v8l a)
Converts a v8l vector into a v8d vector.
v4l::v4l_min
v4l v4l_min(v4l a, v4l b)
Elementwise min ( a < b ? a : b )
v2f::v2f_cvt_v16f
v2f v2f_cvt_v16f(v16f a)
Converts a v16f vector into a v2f vector.
v2l::v2l_reduce_mul_v1l
v2l v2l_reduce_mul_v1l(v1l a)
Reduction mul ( * )
v4d::v4d_cvt_v16f
v4d v4d_cvt_v16f(v16f a)
Converts a v16f vector into a v4d vector.
v16f::v16f_permute4x4
v16f v16f_permute4x4(v16f a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v1i::v1i_cvt_v16f
v1i v1i_cvt_v16f(v16f a)
Converts a v16f vector into a v1i vector.
v16i::v16i_reduce_mul_v8i
v16i v16i_reduce_mul_v8i(v8i a)
Reduction mul ( * )
v8f::v8f_cast_v4d
v8f v8f_cast_v4d(v4d a)
Casts a v4d vector into a v8f vector.
v1l::v1l_fprint
void v1l_fprint(FILE *file, v1l a)
Prints a v1l vector.
v8f::v8f_cvt_v16i
v8f v8f_cvt_v16i(v16i a)
Converts a v16i vector into a v8f vector.
v1l::v1l_reduce_min
v1l v1l_reduce_min(v1l a)
Reduction min ( min )
v16f::v16f_cast_v1f
v16f v16f_cast_v1f(v1f a)
Casts a v1f vector into a v16f vector.
v8i::v8i_fnmadd
v8i v8i_fnmadd(v8i a, v8i b, v8i acc)
Fused Multiply-Add ( -(a * b) + acc )
v4l::v4l_reduce_mul
v4l v4l_reduce_mul(v4l a)
Reduction mul ( * )
v2i::m2i_xor
m2i m2i_xor(m2i a, m2i b)
Bitwise xor ( a ^ b )
v2d::v2d_reduce_mul
v2d v2d_reduce_mul(v2d a)
Reduction mul ( * )
v8l::v8l_rmerge8_v1l
v8l v8l_rmerge8_v1l(v1l a7, v1l a6, v1l a5, v1l a4, v1l a3, v1l a2, v1l a1, v1l a0)
Merges 8 v1l vectors together (reverse order).
v2f::v2f_load1
v2f v2f_load1(const float *p)
Loads 1 float from memory and broadcasts it into a v2f vector.
v16i::v16i_storeu
void v16i_storeu(int32_t *p, v16i a)
Stores a v16i vector into memory.
v8l::v8l_mask_move
v8l v8l_mask_move(m8l mask, v8l src, v8l a)
Mask the input.
v1l::v1l_loadu
v1l v1l_loadu(const int64_t *p)
Loads 1 int64_t from memory into a v1l vector.
v2l::v2l_cast_v2d
v2l v2l_cast_v2d(v2d a)
Casts a v2d vector into a v2l vector.
v2f::sf_reduce_mul_v2f
v2f sf_reduce_mul_v2f(v2f a)
Reduction mul ( * )
v4i::v4i_permute2
v4i v4i_permute2(v4i a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v2f::v2f_min
v2f v2f_min(v2f a, v2f b)
Elementwise min ( a < b ? a : b )
v16i::v16i_cast_v8l
v16i v16i_cast_v8l(v8l a)
Casts a v8l vector into a v16i vector.
v4d::v4d_leq
v4d v4d_leq(v4d a, v4d b)
Compares if elements of a are less than or equal to those of b.
v1i::si_cvt_v1l
int32_t si_cvt_v1l(v1l a)
Converts the first value of a v1l vector into int32_t.
v1d::sd_reduce_min_v1d
v1d sd_reduce_min_v1d(v1d a)
Reduction min ( min )
v1f::v1f_frcp
v1f v1f_frcp(v1f a)
Fast elementwise reciprocal ( 1 / a )
v2i::si_reduce_mul_v2i
v2i si_reduce_mul_v2i(v2i a)
Reduction mul ( * )
v1d::v1d_reduce_and
v1d v1d_reduce_and(v1d a)
Reduction and ( & )
v1f::v1f_reduce_or_v16f
v1f v1f_reduce_or_v16f(v16f a)
Reduction or ( | )
v2d::v2d_fmsub
v2d v2d_fmsub(v2d a, v2d b, v2d acc)
Fused Multiply-Sub ( (a * b) - acc )
v16i::v16i_cvt_v4l
v16i v16i_cvt_v4l(v4l a)
Converts a v4l vector into a v16i vector.
v8d::v8d_permute
v8d v8d_permute(v8d a, uint_fast32_t rule)
Shuffles a using the control in rule.
v2l::sl_reduce_add_v2l
v2l sl_reduce_add_v2l(v2l a)
Reduction add ( + )
v1l::v1l_reduce_mul_v8l
v1l v1l_reduce_mul_v8l(v8l a)
Reduction mul ( * )
v1i::v1i_cast_v16f
v1i v1i_cast_v16f(v16f a)
Casts a v16f vector into a v1i vector.
v4d::v4d_reduce_min_v4d
v4d v4d_reduce_min_v4d(v4d a)
Reduction min ( min )
v8d::v8d_cvt_v4i
v8d v8d_cvt_v4i(v4i a)
Converts a v4i vector into a v8d vector.
v4f::v4f_rprintf
void v4f_rprintf(v4f a, const char *format)
Prints a v4f vector (reversed order)
v8l::v8l_div
v8l v8l_div(v8l a, v8l b)
Elementwise division ( a / b )
v8l::m8l_cast_v8l
m8l m8l_cast_v8l(v8l a)
Casts a v8l vector into a m8l vector-mask.
v2d::v2d_fprint
void v2d_fprint(FILE *file, v2d a)
Prints a v2d vector.
m1i
Type for the manipulation of vector-masks.
Definition: pints-doc.h:152
v1i::v1i_not
v1i v1i_not(v1i a)
Bitwise not ( ~a )
v1l::v1l_cvt_v1l
v1l v1l_cvt_v1l(v1l a)
Converts a v1l vector into a v1l vector.
v16f::v16f_store
void v16f_store(float *p, v16f a)
Stores a v16f vector into memory.
v8d::m8d_lt
m8d m8d_lt(v8d a, v8d b)
Compares if elements of a are less than those of b.
v8i::v8i_rfprint
void v8i_rfprint(FILE *file, v8i a)
Prints a v8i vector (reversed order)
v8i::m8i_cast_v8i
m8i m8i_cast_v8i(v8i a)
Casts a v8i vector into a m8i vector-mask.
v2f::m2f_and
m2f m2f_and(m2f a, m2f b)
Bitwise and ( a & b )
v16f::v16f_set
v16f v16f_set(float v0, float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8, float v9, float v10, float v11, float v12, float v13, float v14, float v15)
Sets the elements of a v16f vector.
v4l::v4l_mask_move
v4l v4l_mask_move(m4l mask, v4l src, v4l a)
Mask the input.
v8l::v8l_rcp
v8l v8l_rcp(v8l a)
Elementwise reciprocal ( 1 / a )
v8f::v8f_cvt_v2d
v8f v8f_cvt_v2d(v2d a)
Converts a v2d vector into a v8f vector.
v8i::v8i_reduce_min
v8i v8i_reduce_min(v8i a)
Reduction min ( min )
v4d::v4d_reduce_or_v2d
v4d v4d_reduce_or_v2d(v2d a)
Reduction or ( | )
v8d::v8d_cvt_v8f
v8d v8d_cvt_v8f(v8f a)
Converts a v8f vector into a v8d vector.
v1l::v1l_ones
v1l v1l_ones()
Sets all bits to 1.
v16f::v16f_reduce_max_v4f
v16f v16f_reduce_max_v4f(v4f a)
Reduction max ( max )
v1i::v1i_zeros
v1i v1i_zeros()
Sets all bits to 0.
v8d::v8d_hshuffle2x4
v8d v8d_hshuffle2x4(v8d a, v8d b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v8i::v8i_cvt_v1f
v8i v8i_cvt_v1f(v1f a)
Converts a v1f vector into a v8i vector.
v8i::v8i_hshuffle4x2
v8i v8i_hshuffle4x2(v8i a, v8i b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v4d::v4d_cast_v4i
v4d v4d_cast_v4i(v4i a)
Casts a v4i vector into a v4d vector.
v8f::m8f_andnot
m8f m8f_andnot(m8f a, m8f b)
Bitwise andnot ( a & ~b )
v4i
Type for the manipulation of 4 int32_t packed into one single vector.
Definition: pints-doc.h:451
v2f::v2f_ones
v2f v2f_ones()
Sets all bits to 1.
v8l::v8l_reduce_max_v4l
v8l v8l_reduce_max_v4l(v4l a)
Reduction max ( max )
v4f::v4f_reduce_max
v4f v4f_reduce_max(v4f a)
Reduction max ( max )
v2d::v2d_not
v2d v2d_not(v2d a)
Bitwise not ( ~a )
v8f::v8f_cvt_v8d
v8f v8f_cvt_v8d(v8d a)
Converts a v8d vector into a v8f vector.
v4f::v4f_cvt_v8i
v4f v4f_cvt_v8i(v8i a)
Converts a v8i vector into a v4f vector.
v2i::si_reduce_add_v2i
v2i si_reduce_add_v2i(v2i a)
Reduction add ( + )
v16i::v16i_merge_v8i
v16i v16i_merge_v8i(v8i low, v8i high)
Merges 2 v8i vectors together.
v2d::v2d_cvt_m2d
v2d v2d_cvt_m2d(m2d a)
Converts a m2d vector-mask into a v2d vector.
v4f::v4f_cast_v2f
v4f v4f_cast_v2f(v2f a)
Casts a v2f vector into a v4f vector.
v16f::v16f_cvt_v2d
v16f v16f_cvt_v2d(v2d a)
Converts a v2d vector into a v16f vector.
v2d::v2d_move
v2d v2d_move(v2d a)
Forwards the input.
v8l::v8l_set_hilo_v4l
v8l v8l_set_hilo_v4l(v8l src, v4l a, int high)
Conditionally sets the low or the high part of a v8l vector.
v8d::v8d_fnmsub
v8d v8d_fnmsub(v8d a, v8d b, v8d acc)
Fused Multiply-Add ( -(a * b) - acc )
v1f::v1f_cast_v8l
v1f v1f_cast_v8l(v8l a)
Casts a v8l vector into a v1f vector.
v1f::v1f_reduce_max
v1f v1f_reduce_max(v1f a)
Reduction max ( max )
v8l::v8l_fprint
void v8l_fprint(FILE *file, v8l a)
Prints a v8l vector.
v4d::v4d_set_hilo_v2d
v4d v4d_set_hilo_v2d(v4d src, v2d a, int high)
Conditionally sets the low or the high part of a v4d vector.
v2l::v2l_neg
v2l v2l_neg(v2l a)
Elementwise negation ( -a )
v1i::m1i_nand
m1i m1i_nand(m1i a, m1i b)
Bitwise nand ( ~(a & b) )
v1f::v1f_abs
v1f v1f_abs(v1f a)
Elementwise absolute value ( a > 0 ? a : -a )
v16f::v16f_cast_v8i
v16f v16f_cast_v8i(v8i a)
Casts a v8i vector into a v16f vector.
v2l::sl_reduce_and_v2l
v2l sl_reduce_and_v2l(v2l a)
Reduction and ( & )
v8f::v8f_reduce_and_v4f
v8f v8f_reduce_and_v4f(v4f a)
Reduction and ( & )
v1d::sd_cvt_v8l
double sd_cvt_v8l(v8l a)
Converts the first value of a v8l vector into double.
v8i::v8i_reduce_add_v8i
v8i v8i_reduce_add_v8i(v8i a)
Reduction add ( + )
v2i::v2i_set
v2i v2i_set(int32_t v0, int32_t v1)
Sets the elements of a v2i vector.
v16i::v16i_reduce_mul_v4i
v16i v16i_reduce_mul_v4i(v4i a)
Reduction mul ( * )
v2d::v2d_blend
v2d v2d_blend(v2d a, v2d b, uint_fast8_t mask)
Creates a new v2d vector whose elements are from a and b choosed by mask.
v1i::v1i_reduce_min
v1i v1i_reduce_min(v1i a)
Reduction min ( min )
v1d::v1d_cast_v4i
v1d v1d_cast_v4i(v4i a)
Casts a v4i vector into a v1d vector.
v2l::v2l_andnot
v2l v2l_andnot(v2l a, v2l b)
Bitwise andnot ( a & ~b )
v8l::v8l_rmerge2_v4l
v8l v8l_rmerge2_v4l(v4l a1, v4l a0)
Merges 2 v4l vectors together (reverse order).
v8d::v8d_frsqrt
v8d v8d_frsqrt(v8d a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v16f::m16f_ornot
m16f m16f_ornot(m16f a, m16f b)
Bitwise ornot ( a | ~b )
v2i::v2i_fmadd
v2i v2i_fmadd(v2i a, v2i b, v2i acc)
Fused Multiply-Add ( (a * b) + acc )
v1d::sd_cvt_v4d
double sd_cvt_v4d(v4d a)
Converts the first value of a v4d vector into double.
v4i::v4i_set
v4i v4i_set(int32_t v0, int32_t v1, int32_t v2, int32_t v3)
Sets the elements of a v4i vector.
v1i::si_cvt_v4l
int32_t si_cvt_v4l(v4l a)
Converts the first value of a v4l vector into int32_t.
v2f::m2f_andnot
m2f m2f_andnot(m2f a, m2f b)
Bitwise andnot ( a & ~b )
v8i::v8i_permute2
v8i v8i_permute2(v8i a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v2f::v2f_move
v2f v2f_move(v2f a)
Forwards the input.
v16f::v16f_merge4_v4f
v16f v16f_merge4_v4f(v4f a0, v4f a1, v4f a2, v4f a3)
Merges 4 v4f vectors together.
v8i::m8i_gt
m8i m8i_gt(v8i a, v8i b)
Compares if elements of a are greater than those of b.
v8d::v8d_storeu
void v8d_storeu(double *p, v8d a)
Stores a v8d vector into memory.
v1d::v1d_cast_m1d
v1d v1d_cast_m1d(m1d a)
Casts a m1d vector-mask into a v1d vector.
v8d::v8d_hshuffle2
v8d v8d_hshuffle2(v8d a, v8d b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v16f::m16f_leq
m16f m16f_leq(v16f a, v16f b)
Compares if elements of a are less than or equal to those of b.
v8i::v8i_one
v8i v8i_one()
Sets all elements to 1.
v2f::v2f_reduce_and
v2f v2f_reduce_and(v2f a)
Reduction and ( & )
v2d::v2d_zero
v2d v2d_zero()
Sets all elements to 0.
v1i::v1i_cast_v2l
v1i v1i_cast_v2l(v2l a)
Casts a v2l vector into a v1i vector.
v4d::v4d_move
v4d v4d_move(v4d a)
Forwards the input.
v4f::v4f_fshuffle4x1
v4f v4f_fshuffle4x1(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v16f::v16f_cast_v1l
v16f v16f_cast_v1l(v1l a)
Casts a v1l vector into a v16f vector.
v8i::v8i_reduce_mul
v8i v8i_reduce_mul(v8i a)
Reduction mul ( * )
v1d::v1d_cast_v16f
v1d v1d_cast_v16f(v16f a)
Casts a v16f vector into a v1d vector.
v1i::v1i_div
v1i v1i_div(v1i a, v1i b)
Elementwise division ( a / b )
v4d::v4d_cvt_v8i
v4d v4d_cvt_v8i(v8i a)
Converts a v8i vector into a v4d vector.
v2f::v2f_reduce_add_v4f
v2f v2f_reduce_add_v4f(v4f a)
Reduction add ( + )
v16f::v16f_permute16
v16f v16f_permute16(v16f a, uint_fast64_t rule)
Shuffles (outer) a using the control in rule.
v8d::v8d_merge2_v4d
v8d v8d_merge2_v4d(v4d a0, v4d a1)
Merges 2 v4d vectors together.
v8l::v8l_fnmadd
v8l v8l_fnmadd(v8l a, v8l b, v8l acc)
Fused Multiply-Add ( -(a * b) + acc )
v4f::v4f_cast_v4l
v4f v4f_cast_v4l(v4l a)
Casts a v4l vector into a v4f vector.
v1f::v1f_reduce_add_v1f
v1f v1f_reduce_add_v1f(v1f a)
Reduction add ( + )
v2f::v2f_eq
v2f v2f_eq(v2f a, v2f b)
Compares the equality of the two input vectors.
v4f::m4f_cvt_m4l
m4f m4f_cvt_m4l(m4l a)
Converts a m4l vector-mask into a m4f vector-mask.
v1d::v1d_reduce_and_v4d
v1d v1d_reduce_and_v4d(v4d a)
Reduction and ( & )
v8i::v8i_hshuffle2x4
v8i v8i_hshuffle2x4(v8i a, v8i b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v8f::v8f_permute4x2
v8f v8f_permute4x2(v8f a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v2i::v2i_nor
v2i v2i_nor(v2i a, v2i b)
Bitwise nor ( ~(a | b) )
v8i::v8i_cvt_v2f
v8i v8i_cvt_v2f(v2f a)
Converts a v2f vector into a v8i vector.
v2l::v2l_fmsub
v2l v2l_fmsub(v2l a, v2l b, v2l acc)
Fused Multiply-Sub ( (a * b) - acc )
v2l::v2l_hshuffle2x1
v2l v2l_hshuffle2x1(v2l a, v2l b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v2d::v2d_div
v2d v2d_div(v2d a, v2d b)
Elementwise division ( a / b )
v2d::v2d_lt
v2d v2d_lt(v2d a, v2d b)
Compares if elements of a are less than those of b.
v8f::v8f_reduce_and_v2f
v8f v8f_reduce_and_v2f(v2f a)
Reduction and ( & )
v4l::sl_reduce_mul_v4l
v4l sl_reduce_mul_v4l(v4l a)
Reduction mul ( * )
v8f::v8f_hshuffle2
v8f v8f_hshuffle2(v8f a, v8f b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v1f::v1f_blend1
v1f v1f_blend1(v1f a, v1f b, uint_fast8_t mask)
Creates a new v1f vector whose elements are from a and b choosed by mask.
v4l::v4l_reduce_max_v8l
v4l v4l_reduce_max_v8l(v8l a)
Reduction max ( max )
v1i::v1i_cast_v1f
v1i v1i_cast_v1f(v1f a)
Casts a v1f vector into a v1i vector.
v2i::v2i_reduce_max_v2i
v2i v2i_reduce_max_v2i(v2i a)
Reduction max ( max )
v4f::v4f_reduce_min_v16f
v4f v4f_reduce_min_v16f(v16f a)
Reduction min ( min )
v8l::v8l_load1
v8l v8l_load1(const int64_t *p)
Loads 1 int64_t from memory and broadcasts it into a v8l vector.
v4d::v4d_print
void v4d_print(v4d a)
Prints a v4d vector.
v1l::m1l_cast_v1l
m1l m1l_cast_v1l(v1l a)
Casts a v1l vector into a m1l vector-mask.
v4i::v4i_print
void v4i_print(v4i a)
Prints a v4i vector.
v8l::v8l_cvt_v8f
v8l v8l_cvt_v8f(v8f a)
Converts a v8f vector into a v8l vector.
v2i::v2i_reduce_and_v8i
v2i v2i_reduce_and_v8i(v8i a)
Reduction and ( & )
v4d::v4d_fmadd
v4d v4d_fmadd(v4d a, v4d b, v4d acc)
Fused Multiply-Add ( (a * b) + acc )
v2l::v2l_cast_v4l
v2l v2l_cast_v4l(v4l a)
Casts a v4l vector into a v2l vector.
v1f::v1f_not
v1f v1f_not(v1f a)
Bitwise not ( ~a )
v4l::v4l_cvt_v4l
v4l v4l_cvt_v4l(v4l a)
Converts a v4l vector into a v4l vector.
v8d::v8d_blend1x8
v8d v8d_blend1x8(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v16f::v16f_blend2
v16f v16f_blend2(v16f a, v16f b, uint_fast8_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v2i::v2i_reduce_mul_v1i
v2i v2i_reduce_mul_v1i(v1i a)
Reduction mul ( * )
v4l::m4l_cvt_m4f
m4l m4l_cvt_m4f(m4f a)
Converts a m4f vector-mask into a m4l vector-mask.
v4d::sd_reduce_min_v4d
v4d sd_reduce_min_v4d(v4d a)
Reduction min ( min )
v8l::v8l_cast_v1i
v8l v8l_cast_v1i(v1i a)
Casts a v1i vector into a v8l vector.
v1i::m1i_and
m1i m1i_and(m1i a, m1i b)
Bitwise and ( a & b )
v1l::v1l_rprintf
void v1l_rprintf(v1l a, const char *format)
Prints a v1l vector (reversed order)
v16f::v16f_cast_v8f
v16f v16f_cast_v8f(v8f a)
Casts a v8f vector into a v16f vector.
v2l::v2l_fshuffle2x1
v2l v2l_fshuffle2x1(v2l a, v2l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8f::v8f_sqrt
v8f v8f_sqrt(v8f a)
Elementwise square root ( sqrt(a) )
v2l::m2l_neq
m2l m2l_neq(v2l a, v2l b)
Compares the inequality of the two input vectors.
v1i
Type for the manipulation of 1 int32_t packed into one single vector.
Definition: pints-doc.h:131
v4f::v4f_cvt_v2i
v4f v4f_cvt_v2i(v2i a)
Converts a v2i vector into a v4f vector.
v16f::v16f_cast_v16i
v16f v16f_cast_v16i(v16i a)
Casts a v16i vector into a v16f vector.
v1d::v1d_move
v1d v1d_move(v1d a)
Forwards the input.
v8i::v8i_reduce_or_v2i
v8i v8i_reduce_or_v2i(v2i a)
Reduction or ( | )
v2d::v2d_reduce_mul_v8d
v2d v2d_reduce_mul_v8d(v8d a)
Reduction mul ( * )
v2l::v2l_cast_v16i
v2l v2l_cast_v16i(v16i a)
Casts a v16i vector into a v2l vector.
v2i::v2i_cvt_v1i
v2i v2i_cvt_v1i(v1i a)
Converts a v1i vector into a v2i vector.
v1l::v1l_store1
void v1l_store1(int64_t *p, v1l a)
Stores the first element of a v1l vector into memory.
v8f::v8f_reduce_or
v8f v8f_reduce_or(v8f a)
Reduction or ( | )
v2f::v2f_blend2x1
v2f v2f_blend2x1(v2f a, v2f b, uint_fast8_t mask)
Creates a new v2f vector whose elements are from a and b choosed by mask.
v1d::sd_cvt_v4f
double sd_cvt_v4f(v4f a)
Converts the first value of a v4f vector into double.
v4d::v4d_cast_v2d
v4d v4d_cast_v2d(v2d a)
Casts a v2d vector into a v4d vector.
v8d::v8d_blend8
v8d v8d_blend8(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v1f::m1f_andnot
m1f m1f_andnot(m1f a, m1f b)
Bitwise andnot ( a & ~b )
v8f::v8f_reduce_min_v1f
v8f v8f_reduce_min_v1f(v1f a)
Reduction min ( min )
v2f::v2f_cvt_v2i
v2f v2f_cvt_v2i(v2i a)
Converts a v2i vector into a v2f vector.
v8f::m8f_and
m8f m8f_and(m8f a, m8f b)
Bitwise and ( a & b )
v1f::v1f_leq
v1f v1f_leq(v1f a, v1f b)
Compares if elements of a are less than or equal to those of b.
v2d::v2d_rmerge2_v1d
v2d v2d_rmerge2_v1d(v1d a1, v1d a0)
Merges 2 v1d vectors together (reverse order).
v1i::v1i_cvt_m1i
v1i v1i_cvt_m1i(m1i a)
Converts a m1i vector-mask into a v1i vector.
v2d::v2d_hshuffle2x1
v2d v2d_hshuffle2x1(v2d a, v2d b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v2l::v2l_reduce_mul
v2l v2l_reduce_mul(v2l a)
Reduction mul ( * )
v8i::m8i_cvt_m8l
m8i m8i_cvt_m8l(m8l a)
Converts a m8l vector-mask into a m8i vector-mask.
v1f::v1f_reduce_or_v2f
v1f v1f_reduce_or_v2f(v2f a)
Reduction or ( | )
v2l::v2l_cvt_v4l
v2l v2l_cvt_v4l(v4l a)
Converts a v4l vector into a v2l vector.
v8f::v8f_cast_v8l
v8f v8f_cast_v8l(v8l a)
Casts a v8l vector into a v8f vector.
v8i::v8i_abs
v8i v8i_abs(v8i a)
Elementwise absolute value ( a > 0 ? a : -a )
v4i::v4i_or
v4i v4i_or(v4i a, v4i b)
Bitwise or ( a | b )
v1l::v1l_cast_m1l
v1l v1l_cast_m1l(m1l a)
Casts a m1l vector-mask into a v1l vector.
v16i::m16i_lt
m16i m16i_lt(v16i a, v16i b)
Compares if elements of a are less than those of b.
v8i::v8i_move
v8i v8i_move(v8i a)
Forwards the input.
v2f::v2f_cast_v2l
v2f v2f_cast_v2l(v2l a)
Casts a v2l vector into a v2f vector.
v1f::v1f_ornot
v1f v1f_ornot(v1f a, v1f b)
Bitwise ornot ( a | ~b )
v8i::m8i_eq
m8i m8i_eq(v8i a, v8i b)
Compares the equality of the two input vectors.
v1d::v1d_reduce_mul_v4d
v1d v1d_reduce_mul_v4d(v4d a)
Reduction mul ( * )
v2f::v2f_rmerge2_v1f
v2f v2f_rmerge2_v1f(v1f a1, v1f a0)
Merges 2 v1f vectors together (reverse order).
v8i::v8i_cast_v8i
v8i v8i_cast_v8i(v8i a)
Casts a v8i vector into a v8i vector.
v16f::v16f_rprint
void v16f_rprint(v16f a)
Prints a v16f vector (reversed order)
v8f::v8f_rmerge8_v1f
v8f v8f_rmerge8_v1f(v1f a7, v1f a6, v1f a5, v1f a4, v1f a3, v1f a2, v1f a1, v1f a0)
Merges 8 v1f vectors together (reverse order).
v4f::v4f_sub
v4f v4f_sub(v4f a, v4f b)
Elementwise subtraction ( a - b )
v8l::v8l_hshuffle
v8l v8l_hshuffle(v8l a, v8l b, uint_fast32_t rule)
Shuffles a and b together using the control in rule.
v4i::v4i_cast_v4l
v4i v4i_cast_v4l(v4l a)
Casts a v4l vector into a v4i vector.
v8i::m8i_not
m8i m8i_not(m8i a)
Bitwise not ( ~a )
v16i::v16i_permute2x8
v16i v16i_permute2x8(v16i a, uint_fast8_t rule)
Shuffles (inner) a using the control in rule.
v2f::v2f_store
void v2f_store(float *p, v2f a)
Stores a v2f vector into memory.
v1d::v1d_reduce_add_v8d
v1d v1d_reduce_add_v8d(v8d a)
Reduction add ( + )
v2i::v2i_mul
v2i v2i_mul(v2i a, v2i b)
Elementwise multiplication ( a * b )
v1d::v1d_andnot
v1d v1d_andnot(v1d a, v1d b)
Bitwise andnot ( a & ~b )
v4f::v4f_maskz_move
v4f v4f_maskz_move(m4f mask, v4f a)
Mask the input.
v1f::sf_cvt_v4d
float sf_cvt_v4d(v4d a)
Converts the first value of a v4d vector into float.
v8l::v8l_reduce_min
v8l v8l_reduce_min(v8l a)
Reduction min ( min )
v2d::m2d_geq
m2d m2d_geq(v2d a, v2d b)
Compares if elements of a are greater than or equal to those of b.
v8f::sf_reduce_add_v8f
v8f sf_reduce_add_v8f(v8f a)
Reduction add ( + )
v2i::v2i_reduce_and_v16i
v2i v2i_reduce_and_v16i(v16i a)
Reduction and ( & )
v8d::m8d_eq
m8d m8d_eq(v8d a, v8d b)
Compares the equality of the two input vectors.
v1l::v1l_blend1x1
v1l v1l_blend1x1(v1l a, v1l b, uint_fast8_t mask)
Creates a new v1l vector whose elements are from a and b choosed by mask.
v8l::m8l_gt
m8l m8l_gt(v8l a, v8l b)
Compares if elements of a are greater than those of b.
v2f::v2f_reduce_or
v2f v2f_reduce_or(v2f a)
Reduction or ( | )
v16i::v16i_blend4
v16i v16i_blend4(v16i a, v16i b, uint_fast8_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v8d::v8d_move
v8d v8d_move(v8d a)
Forwards the input.
m4f
Type for the manipulation of vector-masks.
Definition: pints-doc.h:432
v16i::v16i_cvt_v1l
v16i v16i_cvt_v1l(v1l a)
Converts a v1l vector into a v16i vector.
v8i::m8i_nxor
m8i m8i_nxor(m8i a, m8i b)
Bitwise nxor ( ~(a ^ b) )
v4i::v4i_cast_v16f
v4i v4i_cast_v16f(v16f a)
Casts a v16f vector into a v4i vector.
v1d::v1d_reduce_mul_v2d
v1d v1d_reduce_mul_v2d(v2d a)
Reduction mul ( * )
v8f::v8f_blend8x1
v8f v8f_blend8x1(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v4l::v2l_get_high_v4l
v2l v2l_get_high_v4l(v4l a)
Gets the high part of a v4l vector.
v2f::v2f_geq
v2f v2f_geq(v2f a, v2f b)
Compares if elements of a are greater than or equal to those of b.
v1i::si_cvt_v1d
int32_t si_cvt_v1d(v1d a)
Converts the first value of a v1d vector into int32_t.
v2l::v2l_reduce_and_v8l
v2l v2l_reduce_and_v8l(v8l a)
Reduction and ( & )
v16i::v16i_cvt_v16i
v16i v16i_cvt_v16i(v16i a)
Converts a v16i vector into a v16i vector.
v2l::v2l_cvt_v16i
v2l v2l_cvt_v16i(v16i a)
Converts a v16i vector into a v2l vector.
v4f::v4f_merge_v2f
v4f v4f_merge_v2f(v2f low, v2f high)
Merges 2 v2f vectors together.
v16i::v16i_reduce_mul_v2i
v16i v16i_reduce_mul_v2i(v2i a)
Reduction mul ( * )
v1l::v1l_cast_v4i
v1l v1l_cast_v4i(v4i a)
Casts a v4i vector into a v1l vector.
v8f::v8f_neg
v8f v8f_neg(v8f a)
Elementwise negation ( -a )
v4i::v2i_get_low_v4i
v2i v2i_get_low_v4i(v4i a)
Gets the low part of a v4i vector.
v4f::m4f_cvt_m4d
m4f m4f_cvt_m4d(m4d a)
Converts a m4d vector-mask into a m4f vector-mask.
v2l::v2l_cvt_v1l
v2l v2l_cvt_v1l(v1l a)
Converts a v1l vector into a v2l vector.
v1f::v1f_eq
v1f v1f_eq(v1f a, v1f b)
Compares the equality of the two input vectors.
v1d::sd_cvt_v2l
double sd_cvt_v2l(v2l a)
Converts the first value of a v2l vector into double.
v4f::sf_reduce_min_v4f
v4f sf_reduce_min_v4f(v4f a)
Reduction min ( min )
v16f::v16f_fshuffle2x8
v16f v16f_fshuffle2x8(v16f a, v16f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v16f::v16f_fmadd
v16f v16f_fmadd(v16f a, v16f b, v16f acc)
Fused Multiply-Add ( (a * b) + acc )
v8i::v8i_cvt_v16i
v8i v8i_cvt_v16i(v16i a)
Converts a v16i vector into a v8i vector.
v16f::v16f_cast_v2f
v16f v16f_cast_v2f(v2f a)
Casts a v2f vector into a v16f vector.
v1i::si_cvt_v2f
int32_t si_cvt_v2f(v2f a)
Converts the first value of a v2f vector into int32_t.
v1i::v1i_frsqrt
v1i v1i_frsqrt(v1i a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v4l::v4l_rmerge4_v1l
v4l v4l_rmerge4_v1l(v1l a3, v1l a2, v1l a1, v1l a0)
Merges 4 v1l vectors together (reverse order).
v2i::v2i_rprintf
void v2i_rprintf(v2i a, const char *format)
Prints a v2i vector (reversed order)
v8d::v8d_merge8_v1d
v8d v8d_merge8_v1d(v1d a0, v1d a1, v1d a2, v1d a3, v1d a4, v1d a5, v1d a6, v1d a7)
Merges 8 v1d vectors together.
v8d::v8d_fshuffle4
v8d v8d_fshuffle4(v8d a, v8d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v16f::v16f_cvt_v1l
v16f v16f_cvt_v1l(v1l a)
Converts a v1l vector into a v16f vector.
v8d::v8d_printf
void v8d_printf(v8d a, const char *format)
Prints a v8d vector.
v1i::si_reduce_max_v1i
v1i si_reduce_max_v1i(v1i a)
Reduction max ( max )
v8l::v8l_reduce_or_v1l
v8l v8l_reduce_or_v1l(v1l a)
Reduction or ( | )
v4f::v4f_fprintf
void v4f_fprintf(FILE *file, v4f a, const char *format)
Prints a v4f vector.
v4d::v4d_permute4
v4d v4d_permute4(v4d a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v8l::v8l_hshuffle8
v8l v8l_hshuffle8(v8l a, v8l b, uint_fast32_t rule)
Shuffles (outer) a and b together using the control in rule.
v4l::v4l_add
v4l v4l_add(v4l a, v4l b)
Elementwise addition ( a + b )
v1l::sl_cvt_v4f
int64_t sl_cvt_v4f(v4f a)
Converts the first value of a v4f vector into int64_t.
v4d::v4d_nxor
v4d v4d_nxor(v4d a, v4d b)
Bitwise nxor ( ~(a ^ b) )
v16i::v16i_blend1x16
v16i v16i_blend1x16(v16i a, v16i b, uint_fast8_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v1f::v1f_cast_v2f
v1f v1f_cast_v2f(v2f a)
Casts a v2f vector into a v1f vector.
v1f::v1f_reduce_add_v8f
v1f v1f_reduce_add_v8f(v8f a)
Reduction add ( + )
v4l::v4l_cast_v1f
v4l v4l_cast_v1f(v1f a)
Casts a v1f vector into a v4l vector.
v2f::v2f_cvt_m2f
v2f v2f_cvt_m2f(m2f a)
Converts a m2f vector-mask into a v2f vector.
v4l::v4l_one
v4l v4l_one()
Sets all elements to 1.
v8f::v8f_fnmadd
v8f v8f_fnmadd(v8f a, v8f b, v8f acc)
Fused Multiply-Add ( -(a * b) + acc )
v8l::v8l_blend4
v8l v8l_blend4(v8l a, v8l b, uint_fast8_t mask)
Creates a new v8l vector whose elements are from a and b choosed by mask.
v16f::v16f_rfprintf
void v16f_rfprintf(FILE *file, v16f a, const char *format)
Prints a v16f vector (reversed order)
v8f::v8f_loadu
v8f v8f_loadu(const float *p)
Loads 8 float from memory into a v8f vector.
v1d::v1d_reduce_mul_v8d
v1d v1d_reduce_mul_v8d(v8d a)
Reduction mul ( * )
v1l::v1l_reduce_and
v1l v1l_reduce_and(v1l a)
Reduction and ( & )
v4i::v4i_cvt_v16i
v4i v4i_cvt_v16i(v16i a)
Converts a v16i vector into a v4i vector.
v1f::v1f_mask_move
v1f v1f_mask_move(m1f mask, v1f src, v1f a)
Mask the input.
v1f::m1f_not
m1f m1f_not(m1f a)
Bitwise not ( ~a )
v1f::v1f_reduce_or_v1f
v1f v1f_reduce_or_v1f(v1f a)
Reduction or ( | )
v4d::v4d_reduce_min_v2d
v4d v4d_reduce_min_v2d(v2d a)
Reduction min ( min )
v8i::v8i_reduce_or_v8i
v8i v8i_reduce_or_v8i(v8i a)
Reduction or ( | )
v1f::v1f_printf
void v1f_printf(v1f a, const char *format)
Prints a v1f vector.
v16i::v16i_cvt_v8i
v16i v16i_cvt_v8i(v8i a)
Converts a v8i vector into a v16i vector.
v1l::v1l_cvt_v1i
v1l v1l_cvt_v1i(v1i a)
Converts a v1i vector into a v1l vector.
v1f::v1f_reduce_mul_v8f
v1f v1f_reduce_mul_v8f(v8f a)
Reduction mul ( * )
m2i
Type for the manipulation of vector-masks.
Definition: pints-doc.h:312
v8i::v8i_permute4
v8i v8i_permute4(v8i a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v2d::m2d_nand
m2d m2d_nand(m2d a, m2d b)
Bitwise nand ( ~(a & b) )
v1d::sd_cvt_v8d
double sd_cvt_v8d(v8d a)
Converts the first value of a v8d vector into double.
v2d::v2d_fmadd
v2d v2d_fmadd(v2d a, v2d b, v2d acc)
Fused Multiply-Add ( (a * b) + acc )
v1l::m1l_nxor
m1l m1l_nxor(m1l a, m1l b)
Bitwise nxor ( ~(a ^ b) )
v16i::v16i_reduce_and_v8i
v16i v16i_reduce_and_v8i(v8i a)
Reduction and ( & )
v8i::m8i_neq
m8i m8i_neq(v8i a, v8i b)
Compares the inequality of the two input vectors.
v1i::v1i_xor
v1i v1i_xor(v1i a, v1i b)
Bitwise xor ( a ^ b )
v2d::v1d_get_high_v2d
v1d v1d_get_high_v2d(v2d a)
Gets the high part of a v2d vector.
v16i::m16i_eq
m16i m16i_eq(v16i a, v16i b)
Compares the equality of the two input vectors.
v4l::v4l_cvt_v4i
v4l v4l_cvt_v4i(v4i a)
Converts a v4i vector into a v4l vector.
v1l::sl_reduce_add_v1l
v1l sl_reduce_add_v1l(v1l a)
Reduction add ( + )
v1f::v1f_reduce_min_v2f
v1f v1f_reduce_min_v2f(v2f a)
Reduction min ( min )
v8i::v8i_cast_m8i
v8i v8i_cast_m8i(m8i a)
Casts a m8i vector-mask into a v8i vector.
v16i::v16i_cvt_v2d
v16i v16i_cvt_v2d(v2d a)
Converts a v2d vector into a v16i vector.
v4d::v4d_cast_v1d
v4d v4d_cast_v1d(v1d a)
Casts a v1d vector into a v4d vector.
v8f::v8f_hshuffle8
v8f v8f_hshuffle8(v8f a, v8f b, uint_fast32_t rule)
Shuffles (outer) a and b together using the control in rule.
v8i::v8i_blend
v8i v8i_blend(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v1l::v1l_cast_v2l
v1l v1l_cast_v2l(v2l a)
Casts a v2l vector into a v1l vector.
v4l::v4l_rprint
void v4l_rprint(v4l a)
Prints a v4l vector (reversed order)
v8f::v8f_set
v8f v8f_set(float v0, float v1, float v2, float v3, float v4, float v5, float v6, float v7)
Sets the elements of a v8f vector.
v1l::m1l_neq
m1l m1l_neq(v1l a, v1l b)
Compares the inequality of the two input vectors.
v2l::v2l_reduce_and_v2l
v2l v2l_reduce_and_v2l(v2l a)
Reduction and ( & )
v2d::v2d_permute2
v2d v2d_permute2(v2d a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v1i::m1i_cvt_m1i
m1i m1i_cvt_m1i(m1i a)
Converts a m1i vector-mask into a m1i vector-mask.
v1d::v1d_rset
v1d v1d_rset(double v0)
Sets the elements of a v1d vector (reverse order).
v2f::v2f_fmadd
v2f v2f_fmadd(v2f a, v2f b, v2f acc)
Fused Multiply-Add ( (a * b) + acc )
v1d::v1d_cast_v2i
v1d v1d_cast_v2i(v2i a)
Casts a v2i vector into a v1d vector.
v2i::v2i_hshuffle2
v2i v2i_hshuffle2(v2i a, v2i b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v1d::v1d_reduce_add_v1d
v1d v1d_reduce_add_v1d(v1d a)
Reduction add ( + )
v4d::v4d_mul
v4d v4d_mul(v4d a, v4d b)
Elementwise multiplication ( a * b )
v2f::v2f_cvt_v1i
v2f v2f_cvt_v1i(v1i a)
Converts a v1i vector into a v2f vector.
v2f::v2f_print
void v2f_print(v2f a)
Prints a v2f vector.
v8d::m8d_and
m8d m8d_and(m8d a, m8d b)
Bitwise and ( a & b )
v1f::m1f_cvt_m1f
m1f m1f_cvt_m1f(m1f a)
Converts a m1f vector-mask into a m1f vector-mask.
v4d::v4d_rfprintf
void v4d_rfprintf(FILE *file, v4d a, const char *format)
Prints a v4d vector (reversed order)
v16f::v16f_blend16x1
v16f v16f_blend16x1(v16f a, v16f b, uint_fast16_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v16f::v16f_cvt_v1i
v16f v16f_cvt_v1i(v1i a)
Converts a v1i vector into a v16f vector.
v16i::v16i_reduce_and
v16i v16i_reduce_and(v16i a)
Reduction and ( & )
v2i::v2i_reduce_mul_v2i
v2i v2i_reduce_mul_v2i(v2i a)
Reduction mul ( * )
v8f::v8f_fmsub
v8f v8f_fmsub(v8f a, v8f b, v8f acc)
Fused Multiply-Sub ( (a * b) - acc )
v4i::v4i_merge2_v2i
v4i v4i_merge2_v2i(v2i a0, v2i a1)
Merges 2 v2i vectors together.
v8f::v8f_reduce_add_v2f
v8f v8f_reduce_add_v2f(v2f a)
Reduction add ( + )
v2f::v2f_cast_v8l
v2f v2f_cast_v8l(v8l a)
Casts a v8l vector into a v2f vector.
v4d::v4d_reduce_min_v1d
v4d v4d_reduce_min_v1d(v1d a)
Reduction min ( min )
v8i::v8i_cast_v2d
v8i v8i_cast_v2d(v2d a)
Casts a v2d vector into a v8i vector.
m1f
Type for the manipulation of vector-masks.
Definition: pints-doc.h:112
v1f::v1f_lt
v1f v1f_lt(v1f a, v1f b)
Compares if elements of a are less than those of b.
v8i::v8i_reduce_or_v1i
v8i v8i_reduce_or_v1i(v1i a)
Reduction or ( | )
v4f::v4f_reduce_min_v8f
v4f v4f_reduce_min_v8f(v8f a)
Reduction min ( min )
v1i::v1i_fmsub
v1i v1i_fmsub(v1i a, v1i b, v1i acc)
Fused Multiply-Sub ( (a * b) - acc )
v16f::v16f_hshuffle
v16f v16f_hshuffle(v16f a, v16f b, uint_fast64_t rule)
Shuffles a and b together using the control in rule.
v8i::v8i_lt
v8i v8i_lt(v8i a, v8i b)
Compares if elements of a are less than those of b.
v1f::v1f_cast_v1d
v1f v1f_cast_v1d(v1d a)
Casts a v1d vector into a v1f vector.
v4i::m4i_or
m4i m4i_or(m4i a, m4i b)
Bitwise or ( a | b )
v1f::v1f_maskz_move
v1f v1f_maskz_move(m1f mask, v1f a)
Mask the input.
v2f::v2f_cvt_v16i
v2f v2f_cvt_v16i(v16i a)
Converts a v16i vector into a v2f vector.
v8i::v8i_andnot
v8i v8i_andnot(v8i a, v8i b)
Bitwise andnot ( a & ~b )
v1f::v1f_storeu
void v1f_storeu(float *p, v1f a)
Stores a v1f vector into memory.
v8f::v8f_cvt_v8f
v8f v8f_cvt_v8f(v8f a)
Converts a v8f vector into a v8f vector.
v2d::v2d_load1
v2d v2d_load1(const double *p)
Loads 1 double from memory and broadcasts it into a v2d vector.
v1d::m1d_cast_v1d
m1d m1d_cast_v1d(v1d a)
Casts a v1d vector into a m1d vector-mask.
v2f::v2f_cvt_v1f
v2f v2f_cvt_v1f(v1f a)
Converts a v1f vector into a v2f vector.
v1d::v1d_fmadd
v1d v1d_fmadd(v1d a, v1d b, v1d acc)
Fused Multiply-Add ( (a * b) + acc )
v4f::v4f_or
v4f v4f_or(v4f a, v4f b)
Bitwise or ( a | b )
v4l::m4l_leq
m4l m4l_leq(v4l a, v4l b)
Compares if elements of a are less than or equal to those of b.
v4f::m4f_ornot
m4f m4f_ornot(m4f a, m4f b)
Bitwise ornot ( a | ~b )
v4f::m4f_cast_v4f
m4f m4f_cast_v4f(v4f a)
Casts a v4f vector into a m4f vector-mask.
v4i::v4i_store1
void v4i_store1(int32_t *p, v4i a)
Stores the first element of a v4i vector into memory.
v2d::v2d_reduce_min_v4d
v2d v2d_reduce_min_v4d(v4d a)
Reduction min ( min )
v4l::v4l_cvt_v1d
v4l v4l_cvt_v1d(v1d a)
Converts a v1d vector into a v4l vector.
v16f::m16f_nand
m16f m16f_nand(m16f a, m16f b)
Bitwise nand ( ~(a & b) )
v1d::m1d_leq
m1d m1d_leq(v1d a, v1d b)
Compares if elements of a are less than or equal to those of b.
v2f::v2f_div
v2f v2f_div(v2f a, v2f b)
Elementwise division ( a / b )
v4f
Type for the manipulation of 4 float packed into one single vector.
Definition: pints-doc.h:411
v8i::v8i_cvt_v8d
v8i v8i_cvt_v8d(v8d a)
Converts a v8d vector into a v8i vector.
v4l::v4l_cast_v8l
v4l v4l_cast_v8l(v8l a)
Casts a v8l vector into a v4l vector.
v2i::v2i_cvt_v4l
v2i v2i_cvt_v4l(v4l a)
Converts a v4l vector into a v2i vector.
v16f::v16f_div
v16f v16f_div(v16f a, v16f b)
Elementwise division ( a / b )
v4f::v4f_gt
v4f v4f_gt(v4f a, v4f b)
Compares if elements of a are greater than those of b.
v8l::v8l_cvt_v4i
v8l v8l_cvt_v4i(v4i a)
Converts a v4i vector into a v8l vector.
v2f::m2f_cvt_m2l
m2f m2f_cvt_m2l(m2l a)
Converts a m2l vector-mask into a m2f vector-mask.
v1d::v1d_sub
v1d v1d_sub(v1d a, v1d b)
Elementwise subtraction ( a - b )
v2d::v2d_nand
v2d v2d_nand(v2d a, v2d b)
Bitwise nand ( ~(a & b) )
v4d::v4d_store1
void v4d_store1(double *p, v4d a)
Stores the first element of a v4d vector into memory.
v4d::v4d_cvt_m4d
v4d v4d_cvt_m4d(m4d a)
Converts a m4d vector-mask into a v4d vector.
v8i::v8i_merge2_v4i
v8i v8i_merge2_v4i(v4i a0, v4i a1)
Merges 2 v4i vectors together.
v1i::v1i_reduce_and_v8i
v1i v1i_reduce_and_v8i(v8i a)
Reduction and ( & )
v2f::v2f_cvt_v4d
v2f v2f_cvt_v4d(v4d a)
Converts a v4d vector into a v2f vector.
v1i::v1i_fnmsub
v1i v1i_fnmsub(v1i a, v1i b, v1i acc)
Fused Multiply-Add ( -(a * b) - acc )
v4d::sd_reduce_mul_v4d
v4d sd_reduce_mul_v4d(v4d a)
Reduction mul ( * )
v16f::sf_reduce_and_v16f
v16f sf_reduce_and_v16f(v16f a)
Reduction and ( & )
v2f::m2f_ornot
m2f m2f_ornot(m2f a, m2f b)
Bitwise ornot ( a | ~b )
v8i::v8i_min
v8i v8i_min(v8i a, v8i b)
Elementwise min ( a < b ? a : b )
v2l::v2l_add
v2l v2l_add(v2l a, v2l b)
Elementwise addition ( a + b )
v16i::v16i_cvt_v4d
v16i v16i_cvt_v4d(v4d a)
Converts a v4d vector into a v16i vector.
v4l::v4l_cast_v4i
v4l v4l_cast_v4i(v4i a)
Casts a v4i vector into a v4l vector.
v4l::v4l_merge_v2l
v4l v4l_merge_v2l(v2l low, v2l high)
Merges 2 v2l vectors together.
v4d::sd_reduce_and_v4d
v4d sd_reduce_and_v4d(v4d a)
Reduction and ( & )
v4i::v4i_cvt_v2l
v4i v4i_cvt_v2l(v2l a)
Converts a v2l vector into a v4i vector.
v1i::v1i_reduce_and_v4i
v1i v1i_reduce_and_v4i(v4i a)
Reduction and ( & )
v1l::v1l_cvt_v8i
v1l v1l_cvt_v8i(v8i a)
Converts a v8i vector into a v1l vector.
v1l::v1l_fmadd
v1l v1l_fmadd(v1l a, v1l b, v1l acc)
Fused Multiply-Add ( (a * b) + acc )
v4f::v4f_cast_v1l
v4f v4f_cast_v1l(v1l a)
Casts a v1l vector into a v4f vector.
v16f::v16f_rcp
v16f v16f_rcp(v16f a)
Elementwise reciprocal ( 1 / a )
v4l::v4l_sub
v4l v4l_sub(v4l a, v4l b)
Elementwise subtraction ( a - b )
v2f::v2f_leq
v2f v2f_leq(v2f a, v2f b)
Compares if elements of a are less than or equal to those of b.
v8i::v8i_blend8x1
v8i v8i_blend8x1(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v8i::v8i_reduce_and_v4i
v8i v8i_reduce_and_v4i(v4i a)
Reduction and ( & )
v4l::v4l_abs
v4l v4l_abs(v4l a)
Elementwise absolute value ( a > 0 ? a : -a )
v4l::v4l_reduce_and_v4l
v4l v4l_reduce_and_v4l(v4l a)
Reduction and ( & )
v16f::v16f_frsqrt
v16f v16f_frsqrt(v16f a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v4d::v4d_reduce_add
v4d v4d_reduce_add(v4d a)
Reduction add ( + )
v1i::v1i_store1
void v1i_store1(int32_t *p, v1i a)
Stores the first element of a v1i vector into memory.
v4d::v4d_fshuffle2x2
v4d v4d_fshuffle2x2(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4l::v4l_cvt_v2l
v4l v4l_cvt_v2l(v2l a)
Converts a v2l vector into a v4l vector.
v8f::v8f_reduce_or_v2f
v8f v8f_reduce_or_v2f(v2f a)
Reduction or ( | )
v2f::v2f_rcp
v2f v2f_rcp(v2f a)
Elementwise reciprocal ( 1 / a )
v8f::v8f_cast_v16i
v8f v8f_cast_v16i(v16i a)
Casts a v16i vector into a v8f vector.
v8i::v8i_set_high_v4i
v8i v8i_set_high_v4i(v8i src, v4i high)
Sets the high part of a v8i vector.
v4d::v4d_reduce_mul_v2d
v4d v4d_reduce_mul_v2d(v2d a)
Reduction mul ( * )
v2i::v2i_maskz_move
v2i v2i_maskz_move(m2i mask, v2i a)
Mask the input.
v4d::v4d_cast_v16f
v4d v4d_cast_v16f(v16f a)
Casts a v16f vector into a v4d vector.
v8d::v4d_get_low_v8d
v4d v4d_get_low_v8d(v8d a)
Gets the low part of a v8d vector.
v2d::v2d_reduce_or_v8d
v2d v2d_reduce_or_v8d(v8d a)
Reduction or ( | )
v4f::v4f_set_low_v2f
v4f v4f_set_low_v2f(v4f src, v2f low)
Sets the low part of a v4f vector.
v8f::v8f_reduce_max_v16f
v8f v8f_reduce_max_v16f(v16f a)
Reduction max ( max )
v2l::v2l_reduce_add_v1l
v2l v2l_reduce_add_v1l(v1l a)
Reduction add ( + )
v16i::v16i_hshuffle8
v16i v16i_hshuffle8(v16i a, v16i b, uint_fast32_t rule)
Shuffles (outer) a and b together using the control in rule.
v4f::v4f_reduce_add_v16f
v4f v4f_reduce_add_v16f(v16f a)
Reduction add ( + )
v1i::v1i_printf
void v1i_printf(v1i a, const char *format)
Prints a v1i vector.
v4i::v4i_maskz_move
v4i v4i_maskz_move(m4i mask, v4i a)
Mask the input.
v8i::v8i_xor
v8i v8i_xor(v8i a, v8i b)
Bitwise xor ( a ^ b )
v2i
Type for the manipulation of 2 int32_t packed into one single vector.
Definition: pints-doc.h:291
v2d::sd_reduce_min_v2d
v2d sd_reduce_min_v2d(v2d a)
Reduction min ( min )
v8i::v8i_reduce_and_v8i
v8i v8i_reduce_and_v8i(v8i a)
Reduction and ( & )
v16i::v16i_fshuffle
v16i v16i_fshuffle(v16i a, v16i b, uint_fast64_t rule, uint_fast16_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4d::v4d_abs
v4d v4d_abs(v4d a)
Elementwise absolute value ( a > 0 ? a : -a )
v1f::m1f_xor
m1f m1f_xor(m1f a, m1f b)
Bitwise xor ( a ^ b )
v8i::v4i_get_high_v8i
v4i v4i_get_high_v8i(v8i a)
Gets the high part of a v8i vector.
v8i::v8i_div
v8i v8i_div(v8i a, v8i b)
Elementwise division ( a / b )
v2d::v2d_reduce_add_v1d
v2d v2d_reduce_add_v1d(v1d a)
Reduction add ( + )
v8d::v8d_add
v8d v8d_add(v8d a, v8d b)
Elementwise addition ( a + b )
v1d::v1d_fprintf
void v1d_fprintf(FILE *file, v1d a, const char *format)
Prints a v1d vector.
v8i::v8i_rfprintf
void v8i_rfprintf(FILE *file, v8i a, const char *format)
Prints a v8i vector (reversed order)
v2d::v2d_cast_v4f
v2d v2d_cast_v4f(v4f a)
Casts a v4f vector into a v2d vector.
v1l::v1l_load1
v1l v1l_load1(const int64_t *p)
Loads 1 int64_t from memory and broadcasts it into a v1l vector.
v8f::v8f_permute8
v8f v8f_permute8(v8f a, uint_fast32_t rule)
Shuffles (outer) a using the control in rule.
v4f::v4f_add
v4f v4f_add(v4f a, v4f b)
Elementwise addition ( a + b )
v1l::m1l_gt
m1l m1l_gt(v1l a, v1l b)
Compares if elements of a are greater than those of b.
v1l::v1l_nor
v1l v1l_nor(v1l a, v1l b)
Bitwise nor ( ~(a | b) )
v2l::v2l_blend2
v2l v2l_blend2(v2l a, v2l b, uint_fast8_t mask)
Creates a new v2l vector whose elements are from a and b choosed by mask.
v2i::m2i_and
m2i m2i_and(m2i a, m2i b)
Bitwise and ( a & b )
v4f::v4f_cast_v8f
v4f v4f_cast_v8f(v8f a)
Casts a v8f vector into a v4f vector.
v4f::v4f_cvt_v8f
v4f v4f_cvt_v8f(v8f a)
Converts a v8f vector into a v4f vector.
v1f::v1f_reduce_min_v8f
v1f v1f_reduce_min_v8f(v8f a)
Reduction min ( min )
v8i::m8i_xor
m8i m8i_xor(m8i a, m8i b)
Bitwise xor ( a ^ b )
v16f::v16f_rset
v16f v16f_rset(float v15, float v14, float v13, float v12, float v11, float v10, float v9, float v8, float v7, float v6, float v5, float v4, float v3, float v2, float v1, float v0)
Sets the elements of a v16f vector (reverse order).
v4i::v4i_hshuffle4x1
v4i v4i_hshuffle4x1(v4i a, v4i b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v8l::v8l_reduce_or_v4l
v8l v8l_reduce_or_v4l(v4l a)
Reduction or ( | )
v16i::m16i_cvt_m16i
m16i m16i_cvt_m16i(m16i a)
Converts a m16i vector-mask into a m16i vector-mask.
v1i::v1i_fprint
void v1i_fprint(FILE *file, v1i a)
Prints a v1i vector.
v16f::v16f_permute4
v16f v16f_permute4(v16f a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v8l::sl_reduce_min_v8l
v8l sl_reduce_min_v8l(v8l a)
Reduction min ( min )
v2i::v2i_reduce_min_v8i
v2i v2i_reduce_min_v8i(v8i a)
Reduction min ( min )
v16f::v16f_cast_v4f
v16f v16f_cast_v4f(v4f a)
Casts a v4f vector into a v16f vector.
v4i::v4i_hshuffle
v4i v4i_hshuffle(v4i a, v4i b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v16i::v16i_reduce_and_v16i
v16i v16i_reduce_and_v16i(v16i a)
Reduction and ( & )
v2i::v2i_rsqrt
v2i v2i_rsqrt(v2i a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v8i::v8i_mul
v8i v8i_mul(v8i a, v8i b)
Elementwise multiplication ( a * b )
v8f::v8f_blend2x4
v8f v8f_blend2x4(v8f a, v8f b, uint_fast8_t mask)
Creates a new v8f vector whose elements are from a and b choosed by mask.
v1i::v1i_fprintf
void v1i_fprintf(FILE *file, v1i a, const char *format)
Prints a v1i vector.
v16f::v16f_cvt_v8l
v16f v16f_cvt_v8l(v8l a)
Converts a v8l vector into a v16f vector.
v2d::m2d_andnot
m2d m2d_andnot(m2d a, m2d b)
Bitwise andnot ( a & ~b )
v4d::v4d_eq
v4d v4d_eq(v4d a, v4d b)
Compares the equality of the two input vectors.
v16i::v16i_set_high_v8i
v16i v16i_set_high_v8i(v16i src, v8i high)
Sets the high part of a v16i vector.
v4i::v4i_cast_v16i
v4i v4i_cast_v16i(v16i a)
Casts a v16i vector into a v4i vector.
v16f::m16f_gt
m16f m16f_gt(v16f a, v16f b)
Compares if elements of a are greater than those of b.
v1f
Type for the manipulation of 1 float packed into one single vector.
Definition: pints-doc.h:91
v16f::v16f_andnot
v16f v16f_andnot(v16f a, v16f b)
Bitwise andnot ( a & ~b )
v2d::m2d_cvt_m2f
m2d m2d_cvt_m2f(m2f a)
Converts a m2f vector-mask into a m2d vector-mask.
v4f::v4f_rset
v4f v4f_rset(float v3, float v2, float v1, float v0)
Sets the elements of a v4f vector (reverse order).
v8f::v8f_cast_v8d
v8f v8f_cast_v8d(v8d a)
Casts a v8d vector into a v8f vector.
v4d::v4d_gt
v4d v4d_gt(v4d a, v4d b)
Compares if elements of a are greater than those of b.
v2l::m2l_not
m2l m2l_not(m2l a)
Bitwise not ( ~a )
v8l::v4l_get_hilo_v8l
v4l v4l_get_hilo_v8l(v8l a, int high)
Conditionnaly gets the low or the high part of a v8l vector.
v4d::v4d_merge4_v1d
v4d v4d_merge4_v1d(v1d a0, v1d a1, v1d a2, v1d a3)
Merges 4 v1d vectors together.
v8l::v8l_reduce_mul
v8l v8l_reduce_mul(v8l a)
Reduction mul ( * )
v2l::v2l_cvt_v1i
v2l v2l_cvt_v1i(v1i a)
Converts a v1i vector into a v2l vector.
v8i::v8i_cast_v1i
v8i v8i_cast_v1i(v1i a)
Casts a v1i vector into a v8i vector.
v8l::v8l_fmadd
v8l v8l_fmadd(v8l a, v8l b, v8l acc)
Fused Multiply-Add ( (a * b) + acc )
v16i::v16i_reduce_and_v4i
v16i v16i_reduce_and_v4i(v4i a)
Reduction and ( & )
v1l::sl_cvt_v1i
int64_t sl_cvt_v1i(v1i a)
Converts the first value of a v1i vector into int64_t.
v8l::v8l_permute8x1
v8l v8l_permute8x1(v8l a, uint_fast32_t rule)
Shuffles (inner) a using the control in rule.
v1f::v1f_cvt_v1l
v1f v1f_cvt_v1l(v1l a)
Converts a v1l vector into a v1f vector.
v8i::m8i_cvt_v8i
m8i m8i_cvt_v8i(v8i a)
Converts a v8i vector into a m8i vector-mask.
v1l::v1l_cast_v4l
v1l v1l_cast_v4l(v4l a)
Casts a v4l vector into a v1l vector.
v8f::v8f_rset
v8f v8f_rset(float v7, float v6, float v5, float v4, float v3, float v2, float v1, float v0)
Sets the elements of a v8f vector (reverse order).
v2l::v2l_blend
v2l v2l_blend(v2l a, v2l b, uint_fast8_t mask)
Creates a new v2l vector whose elements are from a and b choosed by mask.
v2i::v2i_cvt_v8l
v2i v2i_cvt_v8l(v8l a)
Converts a v8l vector into a v2i vector.
v1i::v1i_set1
v1i v1i_set1(int32_t v)
Broadcasts a single value into all elements of a v1i vector.
v8f::v8f_frcp
v8f v8f_frcp(v8f a)
Fast elementwise reciprocal ( 1 / a )
v4i::v4i_set_high_v2i
v4i v4i_set_high_v2i(v4i src, v2i high)
Sets the high part of a v4i vector.
v4l::v4l_reduce_and_v1l
v4l v4l_reduce_and_v1l(v1l a)
Reduction and ( & )
v1d::v1d_reduce_or_v2d
v1d v1d_reduce_or_v2d(v2d a)
Reduction or ( | )
v16i::v16i_fshuffle2
v16i v16i_fshuffle2(v16i a, v16i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v1l::sl_cvt_v2f
int64_t sl_cvt_v2f(v2f a)
Converts the first value of a v2f vector into int64_t.
v4l::v4l_reduce_min_v2l
v4l v4l_reduce_min_v2l(v2l a)
Reduction min ( min )
v4l::v4l_cvt_v16f
v4l v4l_cvt_v16f(v16f a)
Converts a v16f vector into a v4l vector.
v8i::v8i_set
v8i v8i_set(int32_t v0, int32_t v1, int32_t v2, int32_t v3, int32_t v4, int32_t v5, int32_t v6, int32_t v7)
Sets the elements of a v8i vector.
v4f::v4f_lt
v4f v4f_lt(v4f a, v4f b)
Compares if elements of a are less than those of b.
v16i::v16i_reduce_add
v16i v16i_reduce_add(v16i a)
Reduction add ( + )
v8i::v8i_reduce_and
v8i v8i_reduce_and(v8i a)
Reduction and ( & )
v16f::v16f_mask_move
v16f v16f_mask_move(m16f mask, v16f src, v16f a)
Mask the input.
v2d::v2d_cast_v16i
v2d v2d_cast_v16i(v16i a)
Casts a v16i vector into a v2d vector.
v4d::v4d_fshuffle4x1
v4d v4d_fshuffle4x1(v4d a, v4d b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v16i::v16i_hshuffle
v16i v16i_hshuffle(v16i a, v16i b, uint_fast64_t rule)
Shuffles a and b together using the control in rule.
v4f::v4f_reduce_or_v1f
v4f v4f_reduce_or_v1f(v1f a)
Reduction or ( | )
v2d::v2d_cast_v8f
v2d v2d_cast_v8f(v8f a)
Casts a v8f vector into a v2d vector.
v8d::v8d_blend4x2
v8d v8d_blend4x2(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v2d::v2d_merge2_v1d
v2d v2d_merge2_v1d(v1d a0, v1d a1)
Merges 2 v1d vectors together.
v4i::v4i_sub
v4i v4i_sub(v4i a, v4i b)
Elementwise subtraction ( a - b )
v4l::v4l_or
v4l v4l_or(v4l a, v4l b)
Bitwise or ( a | b )
v8l::v8l_cvt_v8i
v8l v8l_cvt_v8i(v8i a)
Converts a v8i vector into a v8l vector.
v1i::v1i_cvt_v2f
v1i v1i_cvt_v2f(v2f a)
Converts a v2f vector into a v1i vector.
v16f::v16f_reduce_add_v8f
v16f v16f_reduce_add_v8f(v8f a)
Reduction add ( + )
v8f::v8f_reduce_min_v16f
v8f v8f_reduce_min_v16f(v16f a)
Reduction min ( min )
v2f::v2f_reduce_mul_v4f
v2f v2f_reduce_mul_v4f(v4f a)
Reduction mul ( * )
v4f::m4f_nxor
m4f m4f_nxor(m4f a, m4f b)
Bitwise nxor ( ~(a ^ b) )
v2l::v2l_fprintf
void v2l_fprintf(FILE *file, v2l a, const char *format)
Prints a v2l vector.
v4l::v4l_move
v4l v4l_move(v4l a)
Forwards the input.
v4i::v4i_reduce_min_v16i
v4i v4i_reduce_min_v16i(v16i a)
Reduction min ( min )
v1d::v1d_cast_v1f
v1d v1d_cast_v1f(v1f a)
Casts a v1f vector into a v1d vector.
v8l::v8l_cast_v8d
v8l v8l_cast_v8d(v8d a)
Casts a v8d vector into a v8l vector.
v16i::v16i_merge16_v1i
v16i v16i_merge16_v1i(v1i a0, v1i a1, v1i a2, v1i a3, v1i a4, v1i a5, v1i a6, v1i a7, v1i a8, v1i a9, v1i a10, v1i a11, v1i a12, v1i a13, v1i a14, v1i a15)
Merges 16 v1i vectors together.
v2d::v2d_reduce_and_v4d
v2d v2d_reduce_and_v4d(v4d a)
Reduction and ( & )
v8l::v8l_store
void v8l_store(int64_t *p, v8l a)
Stores a v8l vector into memory.
v8l::sl_reduce_mul_v8l
v8l sl_reduce_mul_v8l(v8l a)
Reduction mul ( * )
v1l::sl_cvt_v4d
int64_t sl_cvt_v4d(v4d a)
Converts the first value of a v4d vector into int64_t.
v4i::v4i_reduce_and_v8i
v4i v4i_reduce_and_v8i(v8i a)
Reduction and ( & )
v2i::m2i_not
m2i m2i_not(m2i a)
Bitwise not ( ~a )
v8i::v8i_fshuffle4x2
v8i v8i_fshuffle4x2(v8i a, v8i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1l::v1l_geq
v1l v1l_geq(v1l a, v1l b)
Compares if elements of a are greater than or equal to those of b.
v4f::m4f_gt
m4f m4f_gt(v4f a, v4f b)
Compares if elements of a are greater than those of b.
v4d::v4d_cast_v1l
v4d v4d_cast_v1l(v1l a)
Casts a v1l vector into a v4d vector.
v1l::v1l_not
v1l v1l_not(v1l a)
Bitwise not ( ~a )
v4d::v4d_reduce_mul
v4d v4d_reduce_mul(v4d a)
Reduction mul ( * )
v2i::v2i_store1
void v2i_store1(int32_t *p, v2i a)
Stores the first element of a v2i vector into memory.
v1l::v1l_cast_v16f
v1l v1l_cast_v16f(v16f a)
Casts a v16f vector into a v1l vector.
v16f::v16f_reduce_or_v16f
v16f v16f_reduce_or_v16f(v16f a)
Reduction or ( | )
v8l::v8l_cvt_v4d
v8l v8l_cvt_v4d(v4d a)
Converts a v4d vector into a v8l vector.
v8d::v8d_cast_v4l
v8d v8d_cast_v4l(v4l a)
Casts a v4l vector into a v8d vector.
v1f::v1f_cast_v2l
v1f v1f_cast_v2l(v2l a)
Casts a v2l vector into a v1f vector.
v4f::v4f_permute
v4f v4f_permute(v4f a, uint_fast8_t rule)
Shuffles a using the control in rule.
v2l::v2l_frcp
v2l v2l_frcp(v2l a)
Fast elementwise reciprocal ( 1 / a )
v1d::v1d_print
void v1d_print(v1d a)
Prints a v1d vector.
v16f::v16f_blend4
v16f v16f_blend4(v16f a, v16f b, uint_fast8_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v2f::v2f_fnmsub
v2f v2f_fnmsub(v2f a, v2f b, v2f acc)
Fused Multiply-Add ( -(a * b) - acc )
v2f::v2f_rsqrt
v2f v2f_rsqrt(v2f a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v8i::v8i_cvt_v8i
v8i v8i_cvt_v8i(v8i a)
Converts a v8i vector into a v8i vector.
v2l::v2l_cast_v1f
v2l v2l_cast_v1f(v1f a)
Casts a v1f vector into a v2l vector.
v8f::m8f_xor
m8f m8f_xor(m8f a, m8f b)
Bitwise xor ( a ^ b )
v8i::v8i_fshuffle8
v8i v8i_fshuffle8(v8i a, v8i b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v2l::v2l_cvt_v2i
v2l v2l_cvt_v2i(v2i a)
Converts a v2i vector into a v2l vector.
v4i::v4i_blend2
v4i v4i_blend2(v4i a, v4i b, uint_fast8_t mask)
Creates a new v4i vector whose elements are from a and b choosed by mask.
v4i::v4i_xor
v4i v4i_xor(v4i a, v4i b)
Bitwise xor ( a ^ b )
v16f::v16f_mul
v16f v16f_mul(v16f a, v16f b)
Elementwise multiplication ( a * b )
v2l::v2l_neq
v2l v2l_neq(v2l a, v2l b)
Compares the inequality of the two input vectors.
v8d::v8d_reduce_min_v4d
v8d v8d_reduce_min_v4d(v4d a)
Reduction min ( min )
v8d::v8d_maskz_move
v8d v8d_maskz_move(m8d mask, v8d a)
Mask the input.
v1l::v1l_ornot
v1l v1l_ornot(v1l a, v1l b)
Bitwise ornot ( a | ~b )
v8l::v8l_reduce_and_v4l
v8l v8l_reduce_and_v4l(v4l a)
Reduction and ( & )
v8f::v8f_cast_m8f
v8f v8f_cast_m8f(m8f a)
Casts a m8f vector-mask into a v8f vector.
v4i::v4i_set_hilo_v2i
v4i v4i_set_hilo_v2i(v4i src, v2i a, int high)
Conditionally sets the low or the high part of a v4i vector.
v4i::v4i_reduce_and
v4i v4i_reduce_and(v4i a)
Reduction and ( & )
v4f::v4f_fnmadd
v4f v4f_fnmadd(v4f a, v4f b, v4f acc)
Fused Multiply-Add ( -(a * b) + acc )
v1i::v1i_rprint
void v1i_rprint(v1i a)
Prints a v1i vector (reversed order)
v4f::v4f_reduce_or_v4f
v4f v4f_reduce_or_v4f(v4f a)
Reduction or ( | )
v8f::v8f_reduce_max_v1f
v8f v8f_reduce_max_v1f(v1f a)
Reduction max ( max )
v8d::v8d_reduce_min_v8d
v8d v8d_reduce_min_v8d(v8d a)
Reduction min ( min )
v8l::v8l_cvt_v16i
v8l v8l_cvt_v16i(v16i a)
Converts a v16i vector into a v8l vector.
v16i::v16i_max
v16i v16i_max(v16i a, v16i b)
Elementwise max ( a > b ? a : b )
v8i::v8i_cast_v4i
v8i v8i_cast_v4i(v4i a)
Casts a v4i vector into a v8i vector.
v4l::m4l_gt
m4l m4l_gt(v4l a, v4l b)
Compares if elements of a are greater than those of b.
v8d::v8d_blend2
v8d v8d_blend2(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v16f::v16f_merge16_v1f
v16f v16f_merge16_v1f(v1f a0, v1f a1, v1f a2, v1f a3, v1f a4, v1f a5, v1f a6, v1f a7, v1f a8, v1f a9, v1f a10, v1f a11, v1f a12, v1f a13, v1f a14, v1f a15)
Merges 16 v1f vectors together.
v2d::v2d_reduce_mul_v1d
v2d v2d_reduce_mul_v1d(v1d a)
Reduction mul ( * )
v2l::v2l_nand
v2l v2l_nand(v2l a, v2l b)
Bitwise nand ( ~(a & b) )
v2l::v2l_merge2_v1l
v2l v2l_merge2_v1l(v1l a0, v1l a1)
Merges 2 v1l vectors together.
v2l::v2l_div
v2l v2l_div(v2l a, v2l b)
Elementwise division ( a / b )
v8l::v8l_maskz_move
v8l v8l_maskz_move(m8l mask, v8l a)
Mask the input.
v16f::v16f_fnmadd
v16f v16f_fnmadd(v16f a, v16f b, v16f acc)
Fused Multiply-Add ( -(a * b) + acc )
v2d::v2d_store1
void v2d_store1(double *p, v2d a)
Stores the first element of a v2d vector into memory.
v16i::v16i_cast_v2i
v16i v16i_cast_v2i(v2i a)
Casts a v2i vector into a v16i vector.
v1f::v1f_fnmsub
v1f v1f_fnmsub(v1f a, v1f b, v1f acc)
Fused Multiply-Add ( -(a * b) - acc )
v4i::v4i_cvt_v4i
v4i v4i_cvt_v4i(v4i a)
Converts a v4i vector into a v4i vector.
v8f::v8f_neq
v8f v8f_neq(v8f a, v8f b)
Compares the inequality of the two input vectors.
v4i::v4i_reduce_or
v4i v4i_reduce_or(v4i a)
Reduction or ( | )
v1d::v1d_set
v1d v1d_set(double v0)
Sets the elements of a v1d vector.
v4f::v4f_loadu
v4f v4f_loadu(const float *p)
Loads 4 float from memory into a v4f vector.
v4f::v4f_cast_v4i
v4f v4f_cast_v4i(v4i a)
Casts a v4i vector into a v4f vector.
v1d::v1d_load1
v1d v1d_load1(const double *p)
Loads 1 double from memory and broadcasts it into a v1d vector.
v4d::v4d_reduce_mul_v4d
v4d v4d_reduce_mul_v4d(v4d a)
Reduction mul ( * )
v1i::v1i_hshuffle
v1i v1i_hshuffle(v1i a, v1i b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v16i::v16i_move
v16i v16i_move(v16i a)
Forwards the input.
v2d::v2d_one
v2d v2d_one()
Sets all elements to 1.
v1i::v1i_cvt_v1f
v1i v1i_cvt_v1f(v1f a)
Converts a v1f vector into a v1i vector.
m2f
Type for the manipulation of vector-masks.
Definition: pints-doc.h:272
v4d::m4d_nor
m4d m4d_nor(m4d a, m4d b)
Bitwise nor ( ~(a | b) )
v2l::v2l_permute2
v2l v2l_permute2(v2l a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v8f::v8f_permute
v8f v8f_permute(v8f a, uint_fast32_t rule)
Shuffles a using the control in rule.
v8l::v8l_ones
v8l v8l_ones()
Sets all bits to 1.
v4l::m4l_not
m4l m4l_not(m4l a)
Bitwise not ( ~a )
v2l::v2l_fshuffle2
v2l v2l_fshuffle2(v2l a, v2l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (outer) a and b using the control in rule, and blends them together using mask...
v16f::m16f_nor
m16f m16f_nor(m16f a, m16f b)
Bitwise nor ( ~(a | b) )
v8d::sd_reduce_mul_v8d
v8d sd_reduce_mul_v8d(v8d a)
Reduction mul ( * )
v16i::m16i_nor
m16i m16i_nor(m16i a, m16i b)
Bitwise nor ( ~(a | b) )
v1f::v1f_and
v1f v1f_and(v1f a, v1f b)
Bitwise and ( a & b )
v8i::v8i_reduce_min_v16i
v8i v8i_reduce_min_v16i(v16i a)
Reduction min ( min )
v8f::v8f_rfprint
void v8f_rfprint(FILE *file, v8f a)
Prints a v8f vector (reversed order)
v8i::v8i_cvt_v16f
v8i v8i_cvt_v16f(v16f a)
Converts a v16f vector into a v8i vector.
v16f::v16f_reduce_and_v4f
v16f v16f_reduce_and_v4f(v4f a)
Reduction and ( & )
v4l::v4l_rmerge2_v2l
v4l v4l_rmerge2_v2l(v2l a1, v2l a0)
Merges 2 v2l vectors together (reverse order).
v2f::v2f_cvt_v8d
v2f v2f_cvt_v8d(v8d a)
Converts a v8d vector into a v2f vector.
v8d::v8d_reduce_mul_v8d
v8d v8d_reduce_mul_v8d(v8d a)
Reduction mul ( * )
v4l::v4l_blend2
v4l v4l_blend2(v4l a, v4l b, uint_fast8_t mask)
Creates a new v4l vector whose elements are from a and b choosed by mask.
v4f::v4f_xor
v4f v4f_xor(v4f a, v4f b)
Bitwise xor ( a ^ b )
v2d::v2d_store
void v2d_store(double *p, v2d a)
Stores a v2d vector into memory.
v1d::v1d_frcp
v1d v1d_frcp(v1d a)
Fast elementwise reciprocal ( 1 / a )
v4l::v4l_cvt_m4l
v4l v4l_cvt_m4l(m4l a)
Converts a m4l vector-mask into a v4l vector.
v4f::m4f_geq
m4f m4f_geq(v4f a, v4f b)
Compares if elements of a are greater than or equal to those of b.
v2f::m2f_gt
m2f m2f_gt(v2f a, v2f b)
Compares if elements of a are greater than those of b.
v8d::m8d_cvt_m8i
m8d m8d_cvt_m8i(m8i a)
Converts a m8i vector-mask into a m8d vector-mask.
v1d::v1d_rprintf
void v1d_rprintf(v1d a, const char *format)
Prints a v1d vector (reversed order)
v2l::v2l_cvt_v2f
v2l v2l_cvt_v2f(v2f a)
Converts a v2f vector into a v2l vector.
v2d::v2d_reduce_and_v2d
v2d v2d_reduce_and_v2d(v2d a)
Reduction and ( & )
v16i::v16i_reduce_add_v2i
v16i v16i_reduce_add_v2i(v2i a)
Reduction add ( + )
v2l::m2l_cvt_m2f
m2l m2l_cvt_m2f(m2f a)
Converts a m2f vector-mask into a m2l vector-mask.
v1i::v1i_ornot
v1i v1i_ornot(v1i a, v1i b)
Bitwise ornot ( a | ~b )
v1i::v1i_leq
v1i v1i_leq(v1i a, v1i b)
Compares if elements of a are less than or equal to those of b.
v4l::v4l_hshuffle4
v4l v4l_hshuffle4(v4l a, v4l b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v16i::v16i_reduce_mul_v16i
v16i v16i_reduce_mul_v16i(v16i a)
Reduction mul ( * )
v16f::sf_reduce_max_v16f
v16f sf_reduce_max_v16f(v16f a)
Reduction max ( max )
v4l::sl_reduce_max_v4l
v4l sl_reduce_max_v4l(v4l a)
Reduction max ( max )
v8d::v8d_reduce_or
v8d v8d_reduce_or(v8d a)
Reduction or ( | )
v16i::v16i_loadu
v16i v16i_loadu(const int32_t *p)
Loads 16 int32_t from memory into a v16i vector.
v4d::v4d_cast_v8d
v4d v4d_cast_v8d(v8d a)
Casts a v8d vector into a v4d vector.
v4d::v4d_max
v4d v4d_max(v4d a, v4d b)
Elementwise max ( a > b ? a : b )
v4f::v4f_and
v4f v4f_and(v4f a, v4f b)
Bitwise and ( a & b )
v4f::m4f_cvt_m4i
m4f m4f_cvt_m4i(m4i a)
Converts a m4i vector-mask into a m4f vector-mask.
v4f::v4f_set_high_v2f
v4f v4f_set_high_v2f(v4f src, v2f high)
Sets the high part of a v4f vector.
v1i::v1i_cvt_v8f
v1i v1i_cvt_v8f(v8f a)
Converts a v8f vector into a v1i vector.
v4f::v4f_cvt_v1i
v4f v4f_cvt_v1i(v1i a)
Converts a v1i vector into a v4f vector.
v2f::v2f_reduce_max_v2f
v2f v2f_reduce_max_v2f(v2f a)
Reduction max ( max )
v8f::v8f_cvt_v1d
v8f v8f_cvt_v1d(v1d a)
Converts a v1d vector into a v8f vector.
v4d::v4d_hshuffle2
v4d v4d_hshuffle2(v4d a, v4d b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v16i::m16i_geq
m16i m16i_geq(v16i a, v16i b)
Compares if elements of a are greater than or equal to those of b.
v2i::v2i_mask_move
v2i v2i_mask_move(m2i mask, v2i src, v2i a)
Mask the input.
v2d::v2d_cast_v1d
v2d v2d_cast_v1d(v1d a)
Casts a v1d vector into a v2d vector.
v4f::v4f_min
v4f v4f_min(v4f a, v4f b)
Elementwise min ( a < b ? a : b )
v4d::v4d_reduce_mul_v1d
v4d v4d_reduce_mul_v1d(v1d a)
Reduction mul ( * )
v4l::v4l_reduce_or_v1l
v4l v4l_reduce_or_v1l(v1l a)
Reduction or ( | )
v8f::v8f_reduce_add_v1f
v8f v8f_reduce_add_v1f(v1f a)
Reduction add ( + )
m8i
Type for the manipulation of vector-masks.
Definition: pints-doc.h:632
v8l::v8l_reduce_max
v8l v8l_reduce_max(v8l a)
Reduction max ( max )
v1d::sd_cvt_v8f
double sd_cvt_v8f(v8f a)
Converts the first value of a v8f vector into double.
v2d::v2d_abs
v2d v2d_abs(v2d a)
Elementwise absolute value ( a > 0 ? a : -a )
v4f::v4f_reduce_mul_v4f
v4f v4f_reduce_mul_v4f(v4f a)
Reduction mul ( * )
v2d::v2d_maskz_move
v2d v2d_maskz_move(m2d mask, v2d a)
Mask the input.
v16i::v16i_cvt_v4i
v16i v16i_cvt_v4i(v4i a)
Converts a v4i vector into a v16i vector.
v4i::v4i_rset
v4i v4i_rset(int32_t v3, int32_t v2, int32_t v1, int32_t v0)
Sets the elements of a v4i vector (reverse order).
v1l::v1l_reduce_min_v8l
v1l v1l_reduce_min_v8l(v8l a)
Reduction min ( min )
v8d::v8d_load1
v8d v8d_load1(const double *p)
Loads 1 double from memory and broadcasts it into a v8d vector.
v4i::v4i_sqrt
v4i v4i_sqrt(v4i a)
Elementwise square root ( sqrt(a) )
v4l::v4l_fshuffle2x2
v4l v4l_fshuffle2x2(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v16f::v16f_reduce_min_v4f
v16f v16f_reduce_min_v4f(v4f a)
Reduction min ( min )
v16f::v16f_load
v16f v16f_load(const float *p)
Loads 16 float from memory into a v16f vector.
v4f::m4f_cvt_m4f
m4f m4f_cvt_m4f(m4f a)
Converts a m4f vector-mask into a m4f vector-mask.
v2l::v2l_reduce_max_v2l
v2l v2l_reduce_max_v2l(v2l a)
Reduction max ( max )
v8l::v8l_fnmsub
v8l v8l_fnmsub(v8l a, v8l b, v8l acc)
Fused Multiply-Add ( -(a * b) - acc )
v2d::v2d_add
v2d v2d_add(v2d a, v2d b)
Elementwise addition ( a + b )
v16f::v16f_cast_v1i
v16f v16f_cast_v1i(v1i a)
Casts a v1i vector into a v16f vector.
v8l::v8l_reduce_mul_v8l
v8l v8l_reduce_mul_v8l(v8l a)
Reduction mul ( * )
v16f::v16f_blend1x16
v16f v16f_blend1x16(v16f a, v16f b, uint_fast8_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v2f::m2f_or
m2f m2f_or(m2f a, m2f b)
Bitwise or ( a | b )
v4f::v4f_cvt_v8l
v4f v4f_cvt_v8l(v8l a)
Converts a v8l vector into a v4f vector.
v4i::v4i_cvt_v2i
v4i v4i_cvt_v2i(v2i a)
Converts a v2i vector into a v4i vector.
v1i::v1i_rfprint
void v1i_rfprint(FILE *file, v1i a)
Prints a v1i vector (reversed order)
v4d::v4d_reduce_max_v1d
v4d v4d_reduce_max_v1d(v1d a)
Reduction max ( max )
v1d::v1d_blend1x1
v1d v1d_blend1x1(v1d a, v1d b, uint_fast8_t mask)
Creates a new v1d vector whose elements are from a and b choosed by mask.
v1f::v1f_andnot
v1f v1f_andnot(v1f a, v1f b)
Bitwise andnot ( a & ~b )
v2f::v1f_get_high_v2f
v1f v1f_get_high_v2f(v2f a)
Gets the high part of a v2f vector.
v1f::v1f_fmsub
v1f v1f_fmsub(v1f a, v1f b, v1f acc)
Fused Multiply-Sub ( (a * b) - acc )
v2l::v2l_ornot
v2l v2l_ornot(v2l a, v2l b)
Bitwise ornot ( a | ~b )
v1l::v1l_reduce_max_v8l
v1l v1l_reduce_max_v8l(v8l a)
Reduction max ( max )
v4f::v4f_set
v4f v4f_set(float v0, float v1, float v2, float v3)
Sets the elements of a v4f vector.
v8i::v8i_set_low_v4i
v8i v8i_set_low_v4i(v8i src, v4i low)
Sets the low part of a v8i vector.
v2l::m2l_geq
m2l m2l_geq(v2l a, v2l b)
Compares if elements of a are greater than or equal to those of b.
v8d::v8d_cvt_v1f
v8d v8d_cvt_v1f(v1f a)
Converts a v1f vector into a v8d vector.
v8d::v8d_reduce_max_v1d
v8d v8d_reduce_max_v1d(v1d a)
Reduction max ( max )
v2f::sf_reduce_and_v2f
v2f sf_reduce_and_v2f(v2f a)
Reduction and ( & )
v1d::sd_cvt_v1i
double sd_cvt_v1i(v1i a)
Converts the first value of a v1i vector into double.
v4f::v4f_print
void v4f_print(v4f a)
Prints a v4f vector.
v2f::m2f_cvt_m2f
m2f m2f_cvt_m2f(m2f a)
Converts a m2f vector-mask into a m2f vector-mask.
v4d::v4d_fnmsub
v4d v4d_fnmsub(v4d a, v4d b, v4d acc)
Fused Multiply-Add ( -(a * b) - acc )
v2f::v2f_cast_v8f
v2f v2f_cast_v8f(v8f a)
Casts a v8f vector into a v2f vector.
v2i::v2i_cvt_v8f
v2i v2i_cvt_v8f(v8f a)
Converts a v8f vector into a v2i vector.
v1f::sf_cvt_v16f
float sf_cvt_v16f(v16f a)
Converts the first value of a v16f vector into float.
v1l::v1l_cast_v2f
v1l v1l_cast_v2f(v2f a)
Casts a v2f vector into a v1l vector.
v2f::v2f_reduce_mul
v2f v2f_reduce_mul(v2f a)
Reduction mul ( * )
v2i::m2i_nand
m2i m2i_nand(m2i a, m2i b)
Bitwise nand ( ~(a & b) )
v4f::v4f_mul
v4f v4f_mul(v4f a, v4f b)
Elementwise multiplication ( a * b )
v8d::v8d_cast_v16f
v8d v8d_cast_v16f(v16f a)
Casts a v16f vector into a v8d vector.
v1l::v1l_rsqrt
v1l v1l_rsqrt(v1l a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v1d::m1d_nor
m1d m1d_nor(m1d a, m1d b)
Bitwise nor ( ~(a | b) )
v1d::v1d_cast_v8l
v1d v1d_cast_v8l(v8l a)
Casts a v8l vector into a v1d vector.
v2f::v2f_reduce_and_v2f
v2f v2f_reduce_and_v2f(v2f a)
Reduction and ( & )
v4d::v4d_neg
v4d v4d_neg(v4d a)
Elementwise negation ( -a )
v8i::v8i_blend2
v8i v8i_blend2(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v4i::v4i_cast_v1d
v4i v4i_cast_v1d(v1d a)
Casts a v1d vector into a v4i vector.
v4l::v4l_rfprint
void v4l_rfprint(FILE *file, v4l a)
Prints a v4l vector (reversed order)
v1i::v1i_reduce_add
v1i v1i_reduce_add(v1i a)
Reduction add ( + )
v8i::m8i_andnot
m8i m8i_andnot(m8i a, m8i b)
Bitwise andnot ( a & ~b )
v1l::v1l_xor
v1l v1l_xor(v1l a, v1l b)
Bitwise xor ( a ^ b )
v16i::v16i_rmerge2_v8i
v16i v16i_rmerge2_v8i(v8i a1, v8i a0)
Merges 2 v8i vectors together (reverse order).
v1l::v1l_reduce_add_v4l
v1l v1l_reduce_add_v4l(v4l a)
Reduction add ( + )
v4f::v4f_cast_v16i
v4f v4f_cast_v16i(v16i a)
Casts a v16i vector into a v4f vector.
v4f::m4f_andnot
m4f m4f_andnot(m4f a, m4f b)
Bitwise andnot ( a & ~b )
v4f::v4f_cvt_v4f
v4f v4f_cvt_v4f(v4f a)
Converts a v4f vector into a v4f vector.
v16i::v8i_get_high_v16i
v8i v8i_get_high_v16i(v16i a)
Gets the high part of a v16i vector.
v2f
Type for the manipulation of 2 float packed into one single vector.
Definition: pints-doc.h:251
v4d::m4d_geq
m4d m4d_geq(v4d a, v4d b)
Compares if elements of a are greater than or equal to those of b.
v16i::v16i_not
v16i v16i_not(v16i a)
Bitwise not ( ~a )
v8d::v8d_rmerge8_v1d
v8d v8d_rmerge8_v1d(v1d a7, v1d a6, v1d a5, v1d a4, v1d a3, v1d a2, v1d a1, v1d a0)
Merges 8 v1d vectors together (reverse order).
v2d::v2d_rcp
v2d v2d_rcp(v2d a)
Elementwise reciprocal ( 1 / a )
v8i::m8i_and
m8i m8i_and(m8i a, m8i b)
Bitwise and ( a & b )
v2f::v2f_zeros
v2f v2f_zeros()
Sets all bits to 0.
v8f::v8f_reduce_add_v4f
v8f v8f_reduce_add_v4f(v4f a)
Reduction add ( + )
v1i::si_cvt_v2d
int32_t si_cvt_v2d(v2d a)
Converts the first value of a v2d vector into int32_t.
v2f::v2f_reduce_max_v4f
v2f v2f_reduce_max_v4f(v4f a)
Reduction max ( max )
v1d::v1d_lt
v1d v1d_lt(v1d a, v1d b)
Compares if elements of a are less than those of b.
v4d::v4d_permute2
v4d v4d_permute2(v4d a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v4l::v4l_ones
v4l v4l_ones()
Sets all bits to 1.
v1i::v1i_fshuffle
v1i v1i_fshuffle(v1i a, v1i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1d::v1d_ones
v1d v1d_ones()
Sets all bits to 1.
v16i::v16i_cvt_v1f
v16i v16i_cvt_v1f(v1f a)
Converts a v1f vector into a v16i vector.
v1f::v1f_reduce_and_v2f
v1f v1f_reduce_and_v2f(v2f a)
Reduction and ( & )
v8d::m8d_or
m8d m8d_or(m8d a, m8d b)
Bitwise or ( a | b )
v16f::v16f_maskz_move
v16f v16f_maskz_move(m16f mask, v16f a)
Mask the input.
v2d::v2d_merge_v1d
v2d v2d_merge_v1d(v1d low, v1d high)
Merges 2 v1d vectors together.
v8d::v8d_hshuffle8x1
v8d v8d_hshuffle8x1(v8d a, v8d b, uint_fast32_t rule)
Shuffles (inner) a and b together using the control in rule.
v1l::v1l_sqrt
v1l v1l_sqrt(v1l a)
Elementwise square root ( sqrt(a) )
v2i::v2i_reduce_max_v1i
v2i v2i_reduce_max_v1i(v1i a)
Reduction max ( max )
v8l::v8l_zeros
v8l v8l_zeros()
Sets all bits to 0.
v4i::v4i_cvt_v2d
v4i v4i_cvt_v2d(v2d a)
Converts a v2d vector into a v4i vector.
v2d::v2d_loadu
v2d v2d_loadu(const double *p)
Loads 2 double from memory into a v2d vector.
v2d::v2d_xor
v2d v2d_xor(v2d a, v2d b)
Bitwise xor ( a ^ b )
v4l::v4l_reduce_max_v1l
v4l v4l_reduce_max_v1l(v1l a)
Reduction max ( max )
v1f::v1f_reduce_and_v8f
v1f v1f_reduce_and_v8f(v8f a)
Reduction and ( & )
v1d::v1d_cast_v4d
v1d v1d_cast_v4d(v4d a)
Casts a v4d vector into a v1d vector.
v2i::v2i_eq
v2i v2i_eq(v2i a, v2i b)
Compares the equality of the two input vectors.
v4f::v4f_hshuffle2x2
v4f v4f_hshuffle2x2(v4f a, v4f b, uint_fast8_t rule)
Shuffles (inner) a and b together using the control in rule.
v8l::m8l_cvt_m8d
m8l m8l_cvt_m8d(m8d a)
Converts a m8d vector-mask into a m8l vector-mask.
v4l::m4l_geq
m4l m4l_geq(v4l a, v4l b)
Compares if elements of a are greater than or equal to those of b.
v2l::v2l_fmadd
v2l v2l_fmadd(v2l a, v2l b, v2l acc)
Fused Multiply-Add ( (a * b) + acc )
v4l::v4l_mul
v4l v4l_mul(v4l a, v4l b)
Elementwise multiplication ( a * b )
v4f::v4f_reduce_add
v4f v4f_reduce_add(v4f a)
Reduction add ( + )
v4i::v4i_geq
v4i v4i_geq(v4i a, v4i b)
Compares if elements of a are greater than or equal to those of b.
v4l::v4l_fshuffle4x1
v4l v4l_fshuffle4x1(v4l a, v4l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8f::v8f_nand
v8f v8f_nand(v8f a, v8f b)
Bitwise nand ( ~(a & b) )
v4i::v4i_abs
v4i v4i_abs(v4i a)
Elementwise absolute value ( a > 0 ? a : -a )
v16f::v16f_cast_v4d
v16f v16f_cast_v4d(v4d a)
Casts a v4d vector into a v16f vector.
v1l::v1l_cast_v2d
v1l v1l_cast_v2d(v2d a)
Casts a v2d vector into a v1l vector.
v8f::v8f_mul
v8f v8f_mul(v8f a, v8f b)
Elementwise multiplication ( a * b )
v4i::v4i_fprint
void v4i_fprint(FILE *file, v4i a)
Prints a v4i vector.
v8d::v8d_reduce_or_v1d
v8d v8d_reduce_or_v1d(v1d a)
Reduction or ( | )
v1l::sl_cvt_v8d
int64_t sl_cvt_v8d(v8d a)
Converts the first value of a v8d vector into int64_t.
v4f::v4f_reduce_min_v4f
v4f v4f_reduce_min_v4f(v4f a)
Reduction min ( min )
v8f::v8f_reduce_mul
v8f v8f_reduce_mul(v8f a)
Reduction mul ( * )
v8i
Type for the manipulation of 8 int32_t packed into one single vector.
Definition: pints-doc.h:611
v16i::v16i_reduce_max_v1i
v16i v16i_reduce_max_v1i(v1i a)
Reduction max ( max )
v4d::v4d_sub
v4d v4d_sub(v4d a, v4d b)
Elementwise subtraction ( a - b )
v4f::v4f_printf
void v4f_printf(v4f a, const char *format)
Prints a v4f vector.
v4f::v4f_cvt_v16i
v4f v4f_cvt_v16i(v16i a)
Converts a v16i vector into a v4f vector.
v16f::v16f_blend16
v16f v16f_blend16(v16f a, v16f b, uint_fast16_t mask)
Creates a new v16f vector whose elements are from a and b choosed by mask.
v4f::v4f_cast_v1f
v4f v4f_cast_v1f(v1f a)
Casts a v1f vector into a v4f vector.
v2f::v2f_reduce_mul_v16f
v2f v2f_reduce_mul_v16f(v16f a)
Reduction mul ( * )
v8f::v8f_rfprintf
void v8f_rfprintf(FILE *file, v8f a, const char *format)
Prints a v8f vector (reversed order)
v4d::v4d_zero
v4d v4d_zero()
Sets all elements to 0.
v2d::m2d_gt
m2d m2d_gt(v2d a, v2d b)
Compares if elements of a are greater than those of b.
v2l::v2l_reduce_add_v4l
v2l v2l_reduce_add_v4l(v4l a)
Reduction add ( + )
v1d::v1d_sqrt
v1d v1d_sqrt(v1d a)
Elementwise square root ( sqrt(a) )
v16i::v16i_reduce_min_v4i
v16i v16i_reduce_min_v4i(v4i a)
Reduction min ( min )
v2f::v2f_reduce_or_v2f
v2f v2f_reduce_or_v2f(v2f a)
Reduction or ( | )
v1l::v1l_reduce_add
v1l v1l_reduce_add(v1l a)
Reduction add ( + )
v2i::v2i_load
v2i v2i_load(const int32_t *p)
Loads 2 int32_t from memory into a v2i vector.
v8i::v8i_eq
v8i v8i_eq(v8i a, v8i b)
Compares the equality of the two input vectors.
v4f::v4f_hshuffle2
v4f v4f_hshuffle2(v4f a, v4f b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v8i::v8i_maskz_move
v8i v8i_maskz_move(m8i mask, v8i a)
Mask the input.
v4d::v4d_blend2
v4d v4d_blend2(v4d a, v4d b, uint_fast8_t mask)
Creates a new v4d vector whose elements are from a and b choosed by mask.
v1f::v1f_nxor
v1f v1f_nxor(v1f a, v1f b)
Bitwise nxor ( ~(a ^ b) )
v4d::sd_reduce_or_v4d
v4d sd_reduce_or_v4d(v4d a)
Reduction or ( | )
v8d::v8d_permute8
v8d v8d_permute8(v8d a, uint_fast32_t rule)
Shuffles (outer) a using the control in rule.
v2l::v2l_cast_v4f
v2l v2l_cast_v4f(v4f a)
Casts a v4f vector into a v2l vector.
v2d::m2d_nor
m2d m2d_nor(m2d a, m2d b)
Bitwise nor ( ~(a | b) )
v8f::v8f_cast_v2l
v8f v8f_cast_v2l(v2l a)
Casts a v2l vector into a v8f vector.
v8f::v8f_cvt_v1f
v8f v8f_cvt_v1f(v1f a)
Converts a v1f vector into a v8f vector.
v8i::si_reduce_min_v8i
v8i si_reduce_min_v8i(v8i a)
Reduction min ( min )
v1l::m1l_cvt_m1d
m1l m1l_cvt_m1d(m1d a)
Converts a m1d vector-mask into a m1l vector-mask.
v16i::v16i_div
v16i v16i_div(v16i a, v16i b)
Elementwise division ( a / b )
v2f::m2f_lt
m2f m2f_lt(v2f a, v2f b)
Compares if elements of a are less than those of b.
v8i::m8i_cvt_m8f
m8i m8i_cvt_m8f(m8f a)
Converts a m8f vector-mask into a m8i vector-mask.
v1l::sl_cvt_v2l
int64_t sl_cvt_v2l(v2l a)
Converts the first value of a v2l vector into int64_t.
v4l::v4l_reduce_add
v4l v4l_reduce_add(v4l a)
Reduction add ( + )
v16i::v16i_cast_v16i
v16i v16i_cast_v16i(v16i a)
Casts a v16i vector into a v16i vector.
v8f::sf_reduce_or_v8f
v8f sf_reduce_or_v8f(v8f a)
Reduction or ( | )
v1i::v1i_blend1x1
v1i v1i_blend1x1(v1i a, v1i b, uint_fast8_t mask)
Creates a new v1i vector whose elements are from a and b choosed by mask.
v4l::v4l_load1
v4l v4l_load1(const int64_t *p)
Loads 1 int64_t from memory and broadcasts it into a v4l vector.
v1i::v1i_reduce_max_v2i
v1i v1i_reduce_max_v2i(v2i a)
Reduction max ( max )
v4d::m4d_lt
m4d m4d_lt(v4d a, v4d b)
Compares if elements of a are less than those of b.
v1i::si_cvt_v8i
int32_t si_cvt_v8i(v8i a)
Converts the first value of a v8i vector into int32_t.
v8f::v8f_reduce_min
v8f v8f_reduce_min(v8f a)
Reduction min ( min )
v4i::v4i_merge_v2i
v4i v4i_merge_v2i(v2i low, v2i high)
Merges 2 v2i vectors together.
v16i::v16i_frsqrt
v16i v16i_frsqrt(v16i a)
Fast elementwise square root reciprocal ( 1 / sqrt(a) )
v8i::si_reduce_add_v8i
v8i si_reduce_add_v8i(v8i a)
Reduction add ( + )
v1d::v1d_rprint
void v1d_rprint(v1d a)
Prints a v1d vector (reversed order)
v1d::v1d_cvt_v2i
v1d v1d_cvt_v2i(v2i a)
Converts a v2i vector into a v1d vector.
v2f::v2f_rprintf
void v2f_rprintf(v2f a, const char *format)
Prints a v2f vector (reversed order)
v4i::v2i_get_high_v4i
v2i v2i_get_high_v4i(v4i a)
Gets the high part of a v4i vector.
v2f::v2f_maskz_move
v2f v2f_maskz_move(m2f mask, v2f a)
Mask the input.
v16i::v16i_reduce_max_v4i
v16i v16i_reduce_max_v4i(v4i a)
Reduction max ( max )
v4f::v4f_blend4
v4f v4f_blend4(v4f a, v4f b, uint_fast8_t mask)
Creates a new v4f vector whose elements are from a and b choosed by mask.
v4i::v4i_mask_move
v4i v4i_mask_move(m4i mask, v4i src, v4i a)
Mask the input.
v8d::v8d_frcp
v8d v8d_frcp(v8d a)
Fast elementwise reciprocal ( 1 / a )
v2f::v2f_andnot
v2f v2f_andnot(v2f a, v2f b)
Bitwise andnot ( a & ~b )
v4f::v4f_cast_v8l
v4f v4f_cast_v8l(v8l a)
Casts a v8l vector into a v4f vector.
v2d::v2d_print
void v2d_print(v2d a)
Prints a v2d vector.
v2i::v2i_zeros
v2i v2i_zeros()
Sets all bits to 0.
v4i::m4i_cvt_m4f
m4i m4i_cvt_m4f(m4f a)
Converts a m4f vector-mask into a m4i vector-mask.
v2l::v2l_cvt_v8d
v2l v2l_cvt_v8d(v8d a)
Converts a v8d vector into a v2l vector.
v8i::m8i_ornot
m8i m8i_ornot(m8i a, m8i b)
Bitwise ornot ( a | ~b )
v16i::v16i_cast_v4d
v16i v16i_cast_v4d(v4d a)
Casts a v4d vector into a v16i vector.
v8l::m8l_neq
m8l m8l_neq(v8l a, v8l b)
Compares the inequality of the two input vectors.
v4f::v4f_blend2x2
v4f v4f_blend2x2(v4f a, v4f b, uint_fast8_t mask)
Creates a new v4f vector whose elements are from a and b choosed by mask.
v4d::v4d_cvt_v2f
v4d v4d_cvt_v2f(v2f a)
Converts a v2f vector into a v4d vector.
v8l::v8l_hshuffle2
v8l v8l_hshuffle2(v8l a, v8l b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v8d::v8d_max
v8d v8d_max(v8d a, v8d b)
Elementwise max ( a > b ? a : b )
v1l::v1l_reduce_mul_v2l
v1l v1l_reduce_mul_v2l(v2l a)
Reduction mul ( * )
v8f::v8f_rcp
v8f v8f_rcp(v8f a)
Elementwise reciprocal ( 1 / a )
v4l::v4l_cast_m4l
v4l v4l_cast_m4l(m4l a)
Casts a m4l vector-mask into a v4l vector.
v1d::v1d_cvt_v4l
v1d v1d_cvt_v4l(v4l a)
Converts a v4l vector into a v1d vector.
v4l::v4l_reduce_mul_v8l
v4l v4l_reduce_mul_v8l(v8l a)
Reduction mul ( * )
v8i::v8i_cast_v8f
v8i v8i_cast_v8f(v8f a)
Casts a v8f vector into a v8i vector.
v2f::v2f_reduce_max_v8f
v2f v2f_reduce_max_v8f(v8f a)
Reduction max ( max )
v1l::v1l_fshuffle
v1l v1l_fshuffle(v1l a, v1l b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v4d::v4d_min
v4d v4d_min(v4d a, v4d b)
Elementwise min ( a < b ? a : b )
v1i::si_reduce_mul_v1i
v1i si_reduce_mul_v1i(v1i a)
Reduction mul ( * )
v8l::v8l_reduce_add
v8l v8l_reduce_add(v8l a)
Reduction add ( + )
v8i::v8i_fprintf
void v8i_fprintf(FILE *file, v8i a, const char *format)
Prints a v8i vector.
v2l::m2l_cvt_m2l
m2l m2l_cvt_m2l(m2l a)
Converts a m2l vector-mask into a m2l vector-mask.
v4l::m4l_nxor
m4l m4l_nxor(m4l a, m4l b)
Bitwise nxor ( ~(a ^ b) )
v2l::m2l_andnot
m2l m2l_andnot(m2l a, m2l b)
Bitwise andnot ( a & ~b )
v1l::sl_cvt_v8l
int64_t sl_cvt_v8l(v8l a)
Converts the first value of a v8l vector into int64_t.
v8d::v8d_abs
v8d v8d_abs(v8d a)
Elementwise absolute value ( a > 0 ? a : -a )
v16f::sf_reduce_or_v16f
v16f sf_reduce_or_v16f(v16f a)
Reduction or ( | )
v4d::m4d_leq
m4d m4d_leq(v4d a, v4d b)
Compares if elements of a are less than or equal to those of b.
v8i::v8i_rprint
void v8i_rprint(v8i a)
Prints a v8i vector (reversed order)
v1d::v1d_store1
void v1d_store1(double *p, v1d a)
Stores the first element of a v1d vector into memory.
v1f::v1f_load
v1f v1f_load(const float *p)
Loads 1 float from memory into a v1f vector.
v1l::m1l_geq
m1l m1l_geq(v1l a, v1l b)
Compares if elements of a are greater than or equal to those of b.
v4d::v4d_merge2_v2d
v4d v4d_merge2_v2d(v2d a0, v2d a1)
Merges 2 v2d vectors together.
v2l::v2l_cvt_v2l
v2l v2l_cvt_v2l(v2l a)
Converts a v2l vector into a v2l vector.
v1i::m1i_cast_v1i
m1i m1i_cast_v1i(v1i a)
Casts a v1i vector into a m1i vector-mask.
v2d::v2d_nor
v2d v2d_nor(v2d a, v2d b)
Bitwise nor ( ~(a | b) )
v2l::sl_reduce_mul_v2l
v2l sl_reduce_mul_v2l(v2l a)
Reduction mul ( * )
v4f::v4f_reduce_and_v4f
v4f v4f_reduce_and_v4f(v4f a)
Reduction and ( & )
v8d::m8d_leq
m8d m8d_leq(v8d a, v8d b)
Compares if elements of a are less than or equal to those of b.
v2l::v1l_get_high_v2l
v1l v1l_get_high_v2l(v2l a)
Gets the high part of a v2l vector.
v1d::sd_cvt_v1f
double sd_cvt_v1f(v1f a)
Converts the first value of a v1f vector into double.
v1i::v1i_move
v1i v1i_move(v1i a)
Forwards the input.
v16i::v16i_cvt_v8f
v16i v16i_cvt_v8f(v8f a)
Converts a v8f vector into a v16i vector.
v1d::v1d_cvt_v1d
v1d v1d_cvt_v1d(v1d a)
Converts a v1d vector into a v1d vector.
v1f::v1f_cvt_m1f
v1f v1f_cvt_m1f(m1f a)
Converts a m1f vector-mask into a v1f vector.
v8i::v8i_reduce_mul_v2i
v8i v8i_reduce_mul_v2i(v2i a)
Reduction mul ( * )
v1i::v1i_gt
v1i v1i_gt(v1i a, v1i b)
Compares if elements of a are greater than those of b.
v1d::v1d_rfprintf
void v1d_rfprintf(FILE *file, v1d a, const char *format)
Prints a v1d vector (reversed order)
v1d::v1d_reduce_and_v1d
v1d v1d_reduce_and_v1d(v1d a)
Reduction and ( & )
v8d::v8d_rprintf
void v8d_rprintf(v8d a, const char *format)
Prints a v8d vector (reversed order)
v1f::v1f_fmadd
v1f v1f_fmadd(v1f a, v1f b, v1f acc)
Fused Multiply-Add ( (a * b) + acc )
v2l::v2l_reduce_max_v1l
v2l v2l_reduce_max_v1l(v1l a)
Reduction max ( max )
v2d::v2d_eq
v2d v2d_eq(v2d a, v2d b)
Compares the equality of the two input vectors.
v2l::v2l_storeu
void v2l_storeu(int64_t *p, v2l a)
Stores a v2l vector into memory.
v1l::v1l_cvt_v4i
v1l v1l_cvt_v4i(v4i a)
Converts a v4i vector into a v1l vector.
v8l::v8l_cvt_v8d
v8l v8l_cvt_v8d(v8d a)
Converts a v8d vector into a v8l vector.
v16i::v16i_reduce_add_v16i
v16i v16i_reduce_add_v16i(v16i a)
Reduction add ( + )
v4l::v4l_leq
v4l v4l_leq(v4l a, v4l b)
Compares if elements of a are less than or equal to those of b.
v16f::m16f_andnot
m16f m16f_andnot(m16f a, m16f b)
Bitwise andnot ( a & ~b )
v4f::v4f_permute2
v4f v4f_permute2(v4f a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v1f::v1f_cvt_v8l
v1f v1f_cvt_v8l(v8l a)
Converts a v8l vector into a v1f vector.
v16i::v16i_cast_m16i
v16i v16i_cast_m16i(m16i a)
Casts a m16i vector-mask into a v16i vector.
v8f::v8f_reduce_min_v4f
v8f v8f_reduce_min_v4f(v4f a)
Reduction min ( min )
v1f::v1f_cast_v1l
v1f v1f_cast_v1l(v1l a)
Casts a v1l vector into a v1f vector.
v8i::v8i_reduce_or
v8i v8i_reduce_or(v8i a)
Reduction or ( | )
v4f::v4f_blend2
v4f v4f_blend2(v4f a, v4f b, uint_fast8_t mask)
Creates a new v4f vector whose elements are from a and b choosed by mask.
v4d::v4d_cvt_v16i
v4d v4d_cvt_v16i(v16i a)
Converts a v16i vector into a v4d vector.
v2l::v2l_reduce_add_v8l
v2l v2l_reduce_add_v8l(v8l a)
Reduction add ( + )
v16i::v16i_blend1
v16i v16i_blend1(v16i a, v16i b, uint_fast8_t mask)
Creates a new v16i vector whose elements are from a and b choosed by mask.
v16f::v16f_or
v16f v16f_or(v16f a, v16f b)
Bitwise or ( a | b )
v1d::v1d_cast_v8d
v1d v1d_cast_v8d(v8d a)
Casts a v8d vector into a v1d vector.
v8l::sl_reduce_and_v8l
v8l sl_reduce_and_v8l(v8l a)
Reduction and ( & )
v2i::v2i_cvt_v2f
v2i v2i_cvt_v2f(v2f a)
Converts a v2f vector into a v2i vector.
v4f::sf_reduce_add_v4f
v4f sf_reduce_add_v4f(v4f a)
Reduction add ( + )
v1f::m1f_nor
m1f m1f_nor(m1f a, m1f b)
Bitwise nor ( ~(a | b) )
v8d::v8d_hshuffle8
v8d v8d_hshuffle8(v8d a, v8d b, uint_fast32_t rule)
Shuffles (outer) a and b together using the control in rule.
v2l::v2l_cvt_v1d
v2l v2l_cvt_v1d(v1d a)
Converts a v1d vector into a v2l vector.
v16f::v16f_cast_m16f
v16f v16f_cast_m16f(m16f a)
Casts a m16f vector-mask into a v16f vector.
v2f::v2f_mul
v2f v2f_mul(v2f a, v2f b)
Elementwise multiplication ( a * b )
v2f::v2f_set_hilo_v1f
v2f v2f_set_hilo_v1f(v2f src, v1f a, int high)
Conditionally sets the low or the high part of a v2f vector.
v2l::v2l_rsqrt
v2l v2l_rsqrt(v2l a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v4i::v4i_and
v4i v4i_and(v4i a, v4i b)
Bitwise and ( a & b )
v4l::v4l_cast_v8d
v4l v4l_cast_v8d(v8d a)
Casts a v8d vector into a v4l vector.
v2d::v2d_leq
v2d v2d_leq(v2d a, v2d b)
Compares if elements of a are less than or equal to those of b.
v1i::si_cvt_v4f
int32_t si_cvt_v4f(v4f a)
Converts the first value of a v4f vector into int32_t.
v8d::v8d_fnmadd
v8d v8d_fnmadd(v8d a, v8d b, v8d acc)
Fused Multiply-Add ( -(a * b) + acc )
v16i::v16i_hshuffle4
v16i v16i_hshuffle4(v16i a, v16i b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v8i::v8i_merge4_v2i
v8i v8i_merge4_v2i(v2i a0, v2i a1, v2i a2, v2i a3)
Merges 4 v2i vectors together.
v1l::v1l_cast_v8l
v1l v1l_cast_v8l(v8l a)
Casts a v8l vector into a v1l vector.
v1f::v1f_reduce_add_v16f
v1f v1f_reduce_add_v16f(v16f a)
Reduction add ( + )
v16f::v16f_reduce_add_v2f
v16f v16f_reduce_add_v2f(v2f a)
Reduction add ( + )
v1l::v1l_fmsub
v1l v1l_fmsub(v1l a, v1l b, v1l acc)
Fused Multiply-Sub ( (a * b) - acc )
v2d::v2d_cast_v2d
v2d v2d_cast_v2d(v2d a)
Casts a v2d vector into a v2d vector.
v8i::v8i_cvt_v8l
v8i v8i_cvt_v8l(v8l a)
Converts a v8l vector into a v8i vector.
v2f::m2f_nand
m2f m2f_nand(m2f a, m2f b)
Bitwise nand ( ~(a & b) )
m8f
Type for the manipulation of vector-masks.
Definition: pints-doc.h:592
v2d::m2d_neq
m2d m2d_neq(v2d a, v2d b)
Compares the inequality of the two input vectors.
v8l::v8l_cvt_v1f
v8l v8l_cvt_v1f(v1f a)
Converts a v1f vector into a v8l vector.
v2d::v2d_cast_v8d
v2d v2d_cast_v8d(v8d a)
Casts a v8d vector into a v2d vector.
v4d::v4d_rcp
v4d v4d_rcp(v4d a)
Elementwise reciprocal ( 1 / a )
v1d::v1d_reduce_mul_v1d
v1d v1d_reduce_mul_v1d(v1d a)
Reduction mul ( * )
v2d::m2d_not
m2d m2d_not(m2d a)
Bitwise not ( ~a )
v1i::v1i_reduce_mul_v4i
v1i v1i_reduce_mul_v4i(v4i a)
Reduction mul ( * )
v16f::v16f_set1
v16f v16f_set1(float v)
Broadcasts a single value into all elements of a v16f vector.
v1l::v1l_cast_v8i
v1l v1l_cast_v8i(v8i a)
Casts a v8i vector into a v1l vector.
v16f::v16f_fshuffle8x2
v16f v16f_fshuffle8x2(v16f a, v16f b, uint_fast32_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8l::v8l_gt
v8l v8l_gt(v8l a, v8l b)
Compares if elements of a are greater than those of b.
v1f::v1f_cvt_v1d
v1f v1f_cvt_v1d(v1d a)
Converts a v1d vector into a v1f vector.
v4d::v4d_reduce_or
v4d v4d_reduce_or(v4d a)
Reduction or ( | )
v8f::v8f_cvt_v4l
v8f v8f_cvt_v4l(v4l a)
Converts a v4l vector into a v8f vector.
v1l::v1l_hshuffle
v1l v1l_hshuffle(v1l a, v1l b, uint_fast8_t rule)
Shuffles a and b together using the control in rule.
v4i::v4i_hshuffle4
v4i v4i_hshuffle4(v4i a, v4i b, uint_fast8_t rule)
Shuffles (outer) a and b together using the control in rule.
v4l::m4l_cvt_m4l
m4l m4l_cvt_m4l(m4l a)
Converts a m4l vector-mask into a m4l vector-mask.
v4i::v4i_cvt_v4d
v4i v4i_cvt_v4d(v4d a)
Converts a v4d vector into a v4i vector.
v4i::v4i_fnmsub
v4i v4i_fnmsub(v4i a, v4i b, v4i acc)
Fused Multiply-Add ( -(a * b) - acc )
v16i::si_reduce_and_v16i
v16i si_reduce_and_v16i(v16i a)
Reduction and ( & )
v8d::v8d_cvt_v4f
v8d v8d_cvt_v4f(v4f a)
Converts a v4f vector into a v8d vector.
v2f::v2f_reduce_min_v16f
v2f v2f_reduce_min_v16f(v16f a)
Reduction min ( min )
v2f::v2f_fshuffle
v2f v2f_fshuffle(v2f a, v2f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v1i::v1i_nor
v1i v1i_nor(v1i a, v1i b)
Bitwise nor ( ~(a | b) )
v4i::v4i_storeu
void v4i_storeu(int32_t *p, v4i a)
Stores a v4i vector into memory.
v8i::v8i_sub
v8i v8i_sub(v8i a, v8i b)
Elementwise subtraction ( a - b )
v8d::v8d_reduce_max
v8d v8d_reduce_max(v8d a)
Reduction max ( max )
v8l::v8l_xor
v8l v8l_xor(v8l a, v8l b)
Bitwise xor ( a ^ b )
v8l::v8l_ornot
v8l v8l_ornot(v8l a, v8l b)
Bitwise ornot ( a | ~b )
v2i::v2i_reduce_add_v2i
v2i v2i_reduce_add_v2i(v2i a)
Reduction add ( + )
v8f::v8f_permute4
v8f v8f_permute4(v8f a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v8f::v8f_cast_v4l
v8f v8f_cast_v4l(v4l a)
Casts a v4l vector into a v8f vector.
v8i::v8i_sqrt
v8i v8i_sqrt(v8i a)
Elementwise square root ( sqrt(a) )
v2i::m2i_andnot
m2i m2i_andnot(m2i a, m2i b)
Bitwise andnot ( a & ~b )
v8i::v8i_blend1x8
v8i v8i_blend1x8(v8i a, v8i b, uint_fast8_t mask)
Creates a new v8i vector whose elements are from a and b choosed by mask.
v1i::v1i_reduce_mul
v1i v1i_reduce_mul(v1i a)
Reduction mul ( * )
v8f::v8f_abs
v8f v8f_abs(v8f a)
Elementwise absolute value ( a > 0 ? a : -a )
v2d::v2d_cast_v2i
v2d v2d_cast_v2i(v2i a)
Casts a v2i vector into a v2d vector.
v16f::v16f_permute2
v16f v16f_permute2(v16f a, uint_fast8_t rule)
Shuffles (outer) a using the control in rule.
v1i::si_reduce_or_v1i
v1i si_reduce_or_v1i(v1i a)
Reduction or ( | )
v1f::v1f_rsqrt
v1f v1f_rsqrt(v1f a)
Elementwise square root reciprocal ( 1 / sqrt(a) )
v2d::m2d_eq
m2d m2d_eq(v2d a, v2d b)
Compares the equality of the two input vectors.
v16i::v16i_mask_move
v16i v16i_mask_move(m16i mask, v16i src, v16i a)
Mask the input.
v4d::v4d_cast_v2l
v4d v4d_cast_v2l(v2l a)
Casts a v2l vector into a v4d vector.
v1d::v1d_reduce_min_v8d
v1d v1d_reduce_min_v8d(v8d a)
Reduction min ( min )
v16i::v16i_reduce_max_v8i
v16i v16i_reduce_max_v8i(v8i a)
Reduction max ( max )
v8d::v8d_eq
v8d v8d_eq(v8d a, v8d b)
Compares the equality of the two input vectors.
v16i::v16i_cvt_v8d
v16i v16i_cvt_v8d(v8d a)
Converts a v8d vector into a v16i vector.
v2l::v2l_rset
v2l v2l_rset(int64_t v1, int64_t v0)
Sets the elements of a v2l vector (reverse order).
v16f::v16f_reduce_mul_v4f
v16f v16f_reduce_mul_v4f(v4f a)
Reduction mul ( * )
v2f::v2f_not
v2f v2f_not(v2f a)
Bitwise not ( ~a )
v4f::v4f_zero
v4f v4f_zero()
Sets all elements to 0.
v8i::v8i_hshuffle8
v8i v8i_hshuffle8(v8i a, v8i b, uint_fast32_t rule)
Shuffles (outer) a and b together using the control in rule.
v4i::m4i_andnot
m4i m4i_andnot(m4i a, m4i b)
Bitwise andnot ( a & ~b )
v4f::v4f_blend4x1
v4f v4f_blend4x1(v4f a, v4f b, uint_fast8_t mask)
Creates a new v4f vector whose elements are from a and b choosed by mask.
v8d::v8d_sqrt
v8d v8d_sqrt(v8d a)
Elementwise square root ( sqrt(a) )
v4d::m4d_nand
m4d m4d_nand(m4d a, m4d b)
Bitwise nand ( ~(a & b) )
v4l::v4l_reduce_or_v2l
v4l v4l_reduce_or_v2l(v2l a)
Reduction or ( | )
v8d::v8d_loadu
v8d v8d_loadu(const double *p)
Loads 8 double from memory into a v8d vector.
v4f::v4f_reduce_max_v1f
v4f v4f_reduce_max_v1f(v1f a)
Reduction max ( max )
v4d::v4d_cast_v4d
v4d v4d_cast_v4d(v4d a)
Casts a v4d vector into a v4d vector.
v4f::v4f_div
v4f v4f_div(v4f a, v4f b)
Elementwise division ( a / b )
v4i::m4i_nand
m4i m4i_nand(m4i a, m4i b)
Bitwise nand ( ~(a & b) )
v8i::v8i_fshuffle2x4
v8i v8i_fshuffle2x4(v8i a, v8i b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v2l::v2l_cast_v8f
v2l v2l_cast_v8f(v8f a)
Casts a v8f vector into a v2l vector.
v8d::v8d_or
v8d v8d_or(v8d a, v8d b)
Bitwise or ( a | b )
v16f::v16f_merge8_v2f
v16f v16f_merge8_v2f(v2f a0, v2f a1, v2f a2, v2f a3, v2f a4, v2f a5, v2f a6, v2f a7)
Merges 8 v2f vectors together.
v1i::v1i_set
v1i v1i_set(int32_t v0)
Sets the elements of a v1i vector.
v8f::v8f_ornot
v8f v8f_ornot(v8f a, v8f b)
Bitwise ornot ( a | ~b )
v8d::v8d_cast_v1d
v8d v8d_cast_v1d(v1d a)
Casts a v1d vector into a v8d vector.
v4f::v4f_fshuffle
v4f v4f_fshuffle(v4f a, v4f b, uint_fast8_t rule, uint_fast8_t mask)
Fully shuffles (inner) a and b using the control in rule, and blends them together using mask...
v8d::v8d_mask_move
v8d v8d_mask_move(m8d mask, v8d src, v8d a)
Mask the input.
v8f::v8f_cvt_v2f
v8f v8f_cvt_v2f(v2f a)
Converts a v2f vector into a v8f vector.
v4f::v4f_store
void v4f_store(float *p, v4f a)
Stores a v4f vector into memory.
v2l::m2l_cast_v2l
m2l m2l_cast_v2l(v2l a)
Casts a v2l vector into a m2l vector-mask.
v2d::v2d_cast_v1i
v2d v2d_cast_v1i(v1i a)
Casts a v1i vector into a v2d vector.
v4l::v4l_set_high_v2l
v4l v4l_set_high_v2l(v4l src, v2l high)
Sets the high part of a v4l vector.
v2l::v1l_get_hilo_v2l
v1l v1l_get_hilo_v2l(v2l a, int high)
Conditionnaly gets the low or the high part of a v2l vector.
v4i::v4i_reduce_add_v1i
v4i v4i_reduce_add_v1i(v1i a)
Reduction add ( + )
v2l::v2l_cvt_v4f
v2l v2l_cvt_v4f(v4f a)
Converts a v4f vector into a v2l vector.
v2i::v2i_xor
v2i v2i_xor(v2i a, v2i b)
Bitwise xor ( a ^ b )
v1l::sl_cvt_v1l
int64_t sl_cvt_v1l(v1l a)
Converts the first value of a v1l vector into int64_t.
v1i::v1i_fnmadd
v1i v1i_fnmadd(v1i a, v1i b, v1i acc)
Fused Multiply-Add ( -(a * b) + acc )
v8i::v8i_cvt_v4f
v8i v8i_cvt_v4f(v4f a)
Converts a v4f vector into a v8i vector.
v16f::v16f_reduce_max_v8f
v16f v16f_reduce_max_v8f(v8f a)
Reduction max ( max )
v16f::v16f_loadu
v16f v16f_loadu(const float *p)
Loads 16 float from memory into a v16f vector.
v1i::v1i_store
void v1i_store(int32_t *p, v1i a)
Stores a v1i vector into memory.
v2f::v2f_set_high_v1f
v2f v2f_set_high_v1f(v2f src, v1f high)
Sets the high part of a v2f vector.
v8f::v8f_gt
v8f v8f_gt(v8f a, v8f b)
Compares if elements of a are greater than those of b.
v1d::v1d_neg
v1d v1d_neg(v1d a)
Elementwise negation ( -a )
v4d::v4d_storeu
void v4d_storeu(double *p, v4d a)
Stores a v4d vector into memory.
v2d::m2d_or
m2d m2d_or(m2d a, m2d b)
Bitwise or ( a | b )
v16i::v16i_hshuffle8x2
v16i v16i_hshuffle8x2(v16i a, v16i b, uint_fast32_t rule)
Shuffles (inner) a and b together using the control in rule.
v16f::v16f_nand
v16f v16f_nand(v16f a, v16f b)
Bitwise nand ( ~(a & b) )
v16i::v16i_cvt_m16i
v16i v16i_cvt_m16i(m16i a)
Converts a m16i vector-mask into a v16i vector.
v2i::v2i_cast_v4f
v2i v2i_cast_v4f(v4f a)
Casts a v4f vector into a v2i vector.
v2i::v2i_geq
v2i v2i_geq(v2i a, v2i b)
Compares if elements of a are greater than or equal to those of b.
v4f::v4f_merge2_v2f
v4f v4f_merge2_v2f(v2f a0, v2f a1)
Merges 2 v2f vectors together.
v8i::v8i_cvt_v1d
v8i v8i_cvt_v1d(v1d a)
Converts a v1d vector into a v8i vector.
v8d::v8d_blend1
v8d v8d_blend1(v8d a, v8d b, uint_fast8_t mask)
Creates a new v8d vector whose elements are from a and b choosed by mask.
v8f::m8f_nor
m8f m8f_nor(m8f a, m8f b)
Bitwise nor ( ~(a | b) )
v4i::v4i_load
v4i v4i_load(const int32_t *p)
Loads 4 int32_t from memory into a v4i vector.
Generated by   doxygen 1.8.5