PintS  0.1
Portable Intrinsics for SIMD
 All Data Structures Files Functions Groups
Functions
shuffling and permutation functions

Functions

v2d v2d_hshuffle2 (v2d a, v2d b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v2f v2f_hshuffle2 (v2f a, v2f b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v2i v2i_hshuffle2 (v2i a, v2i b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v2l v2l_hshuffle2 (v2l a, v2l b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v4d v4d_hshuffle2 (v4d a, v4d b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v4f v4f_hshuffle2 (v4f a, v4f b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v4i v4i_hshuffle2 (v4i a, v4i b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v4l v4l_hshuffle2 (v4l a, v4l b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8d v8d_hshuffle2 (v8d a, v8d b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8f v8f_hshuffle2 (v8f a, v8f b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8i v8i_hshuffle2 (v8i a, v8i b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8l v8l_hshuffle2 (v8l a, v8l b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v16f v16f_hshuffle2 (v16f a, v16f b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v16i v16i_hshuffle2 (v16i a, v16i b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v4d v4d_hshuffle4 (v4d a, v4d b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v4f v4f_hshuffle4 (v4f a, v4f b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v4i v4i_hshuffle4 (v4i a, v4i b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v4l v4l_hshuffle4 (v4l a, v4l b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8d v8d_hshuffle4 (v8d a, v8d b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8f v8f_hshuffle4 (v8f a, v8f b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8i v8i_hshuffle4 (v8i a, v8i b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8l v8l_hshuffle4 (v8l a, v8l b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v16f v16f_hshuffle4 (v16f a, v16f b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v16i v16i_hshuffle4 (v16i a, v16i b, uint_fast8_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8d v8d_hshuffle8 (v8d a, v8d b, uint_fast32_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8f v8f_hshuffle8 (v8f a, v8f b, uint_fast32_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8i v8i_hshuffle8 (v8i a, v8i b, uint_fast32_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v8l v8l_hshuffle8 (v8l a, v8l b, uint_fast32_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v16f v16f_hshuffle8 (v16f a, v16f b, uint_fast32_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v16i v16i_hshuffle8 (v16i a, v16i b, uint_fast32_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v16f v16f_hshuffle16 (v16f a, v16f b, uint_fast64_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v16i v16i_hshuffle16 (v16i a, v16i b, uint_fast64_t rule)
 Shuffles (outer) a and b together using the control in rule. More...
 
v2d v2d_hshuffle2x1 (v2d a, v2d b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v2f v2f_hshuffle2x1 (v2f a, v2f b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v2i v2i_hshuffle2x1 (v2i a, v2i b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v2l v2l_hshuffle2x1 (v2l a, v2l b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v4d v4d_hshuffle2x2 (v4d a, v4d b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v4f v4f_hshuffle2x2 (v4f a, v4f b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v4i v4i_hshuffle2x2 (v4i a, v4i b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v4l v4l_hshuffle2x2 (v4l a, v4l b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8d v8d_hshuffle2x4 (v8d a, v8d b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8f v8f_hshuffle2x4 (v8f a, v8f b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8i v8i_hshuffle2x4 (v8i a, v8i b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8l v8l_hshuffle2x4 (v8l a, v8l b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v16f v16f_hshuffle2x8 (v16f a, v16f b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v16i v16i_hshuffle2x8 (v16i a, v16i b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v4d v4d_hshuffle4x1 (v4d a, v4d b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v4f v4f_hshuffle4x1 (v4f a, v4f b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v4i v4i_hshuffle4x1 (v4i a, v4i b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v4l v4l_hshuffle4x1 (v4l a, v4l b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8d v8d_hshuffle4x2 (v8d a, v8d b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8f v8f_hshuffle4x2 (v8f a, v8f b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8i v8i_hshuffle4x2 (v8i a, v8i b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8l v8l_hshuffle4x2 (v8l a, v8l b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v16f v16f_hshuffle4x4 (v16f a, v16f b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v16i v16i_hshuffle4x4 (v16i a, v16i b, uint_fast8_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8d v8d_hshuffle8x1 (v8d a, v8d b, uint_fast32_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8f v8f_hshuffle8x1 (v8f a, v8f b, uint_fast32_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8i v8i_hshuffle8x1 (v8i a, v8i b, uint_fast32_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v8l v8l_hshuffle8x1 (v8l a, v8l b, uint_fast32_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v16f v16f_hshuffle8x2 (v16f a, v16f b, uint_fast32_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v16i v16i_hshuffle8x2 (v16i a, v16i b, uint_fast32_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v16f v16f_hshuffle16x1 (v16f a, v16f b, uint_fast64_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v16i v16i_hshuffle16x1 (v16i a, v16i b, uint_fast64_t rule)
 Shuffles (inner) a and b together using the control in rule. More...
 
v2d v2d_permute2 (v2d a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v2f v2f_permute2 (v2f a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v2i v2i_permute2 (v2i a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v2l v2l_permute2 (v2l a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v4d v4d_permute2 (v4d a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v4f v4f_permute2 (v4f a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v4i v4i_permute2 (v4i a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v4l v4l_permute2 (v4l a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8d v8d_permute2 (v8d a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8f v8f_permute2 (v8f a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8i v8i_permute2 (v8i a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8l v8l_permute2 (v8l a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v16f v16f_permute2 (v16f a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v16i v16i_permute2 (v16i a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v4d v4d_permute4 (v4d a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v4f v4f_permute4 (v4f a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v4i v4i_permute4 (v4i a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v4l v4l_permute4 (v4l a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8d v8d_permute4 (v8d a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8f v8f_permute4 (v8f a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8i v8i_permute4 (v8i a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8l v8l_permute4 (v8l a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v16f v16f_permute4 (v16f a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v16i v16i_permute4 (v16i a, uint_fast8_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8d v8d_permute8 (v8d a, uint_fast32_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8f v8f_permute8 (v8f a, uint_fast32_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8i v8i_permute8 (v8i a, uint_fast32_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v8l v8l_permute8 (v8l a, uint_fast32_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v16f v16f_permute8 (v16f a, uint_fast32_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v16i v16i_permute8 (v16i a, uint_fast32_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v16f v16f_permute16 (v16f a, uint_fast64_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v16i v16i_permute16 (v16i a, uint_fast64_t rule)
 Shuffles (outer) a using the control in rule. More...
 
v2d v2d_permute2x1 (v2d a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v2f v2f_permute2x1 (v2f a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v2i v2i_permute2x1 (v2i a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v2l v2l_permute2x1 (v2l a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v4d v4d_permute2x2 (v4d a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v4f v4f_permute2x2 (v4f a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v4i v4i_permute2x2 (v4i a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v4l v4l_permute2x2 (v4l a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8d v8d_permute2x4 (v8d a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8f v8f_permute2x4 (v8f a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8i v8i_permute2x4 (v8i a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8l v8l_permute2x4 (v8l a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v16f v16f_permute2x8 (v16f a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v16i v16i_permute2x8 (v16i a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v4d v4d_permute4x1 (v4d a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v4f v4f_permute4x1 (v4f a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v4i v4i_permute4x1 (v4i a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v4l v4l_permute4x1 (v4l a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8d v8d_permute4x2 (v8d a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8f v8f_permute4x2 (v8f a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8i v8i_permute4x2 (v8i a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8l v8l_permute4x2 (v8l a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v16f v16f_permute4x4 (v16f a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v16i v16i_permute4x4 (v16i a, uint_fast8_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8d v8d_permute8x1 (v8d a, uint_fast32_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8f v8f_permute8x1 (v8f a, uint_fast32_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8i v8i_permute8x1 (v8i a, uint_fast32_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v8l v8l_permute8x1 (v8l a, uint_fast32_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v16f v16f_permute8x2 (v16f a, uint_fast32_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v16i v16i_permute8x2 (v16i a, uint_fast32_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v16f v16f_permute16x1 (v16f a, uint_fast64_t rule)
 Shuffles (inner) a using the control in rule. More...
 
v16i v16i_permute16x1 (v16i a, uint_fast64_t rule)
 Shuffles (inner) a using the control in rule. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
v1d v1d_hshuffle (v1d a, v1d b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v1f v1f_hshuffle (v1f a, v1f b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v1i v1i_hshuffle (v1i a, v1i b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v1l v1l_hshuffle (v1l a, v1l b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v2d v2d_hshuffle (v2d a, v2d b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v2f v2f_hshuffle (v2f a, v2f b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v2i v2i_hshuffle (v2i a, v2i b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v2l v2l_hshuffle (v2l a, v2l b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v4d v4d_hshuffle (v4d a, v4d b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v4f v4f_hshuffle (v4f a, v4f b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v4i v4i_hshuffle (v4i a, v4i b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v4l v4l_hshuffle (v4l a, v4l b, uint_fast8_t rule)
 Shuffles a and b together using the control in rule. More...
 
v8d v8d_hshuffle (v8d a, v8d b, uint_fast32_t rule)
 Shuffles a and b together using the control in rule. More...
 
v8f v8f_hshuffle (v8f a, v8f b, uint_fast32_t rule)
 Shuffles a and b together using the control in rule. More...
 
v8i v8i_hshuffle (v8i a, v8i b, uint_fast32_t rule)
 Shuffles a and b together using the control in rule. More...
 
v8l v8l_hshuffle (v8l a, v8l b, uint_fast32_t rule)
 Shuffles a and b together using the control in rule. More...
 
v16f v16f_hshuffle (v16f a, v16f b, uint_fast64_t rule)
 Shuffles a and b together using the control in rule. More...
 
v16i v16i_hshuffle (v16i a, v16i b, uint_fast64_t rule)
 Shuffles a and b together using the control in rule. More...
 
v1d v1d_permute (v1d a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v1f v1f_permute (v1f a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v1i v1i_permute (v1i a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v1l v1l_permute (v1l a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v2d v2d_permute (v2d a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v2f v2f_permute (v2f a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v2i v2i_permute (v2i a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v2l v2l_permute (v2l a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v4d v4d_permute (v4d a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v4f v4f_permute (v4f a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v4i v4i_permute (v4i a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v4l v4l_permute (v4l a, uint_fast8_t rule)
 Shuffles a using the control in rule. More...
 
v8d v8d_permute (v8d a, uint_fast32_t rule)
 Shuffles a using the control in rule. More...
 
v8f v8f_permute (v8f a, uint_fast32_t rule)
 Shuffles a using the control in rule. More...
 
v8i v8i_permute (v8i a, uint_fast32_t rule)
 Shuffles a using the control in rule. More...
 
v8l v8l_permute (v8l a, uint_fast32_t rule)
 Shuffles a using the control in rule. More...
 
v16f v16f_permute (v16f a, uint_fast64_t rule)
 Shuffles a using the control in rule. More...
 
v16i v16i_permute (v16i a, uint_fast64_t rule)
 Shuffles a using the control in rule. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 

Detailed Description

Function Documentation

v2d v2d_hshuffle2 ( v2d  a,
v2d  b,
uint_fast8_t  rule 
)
related

Shuffles v2d vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 1 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(b, rule[1])
Parameters
afirst v2d input vector
bsecond v2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2f v2f_hshuffle2 ( v2f  a,
v2f  b,
uint_fast8_t  rule 
)
related

Shuffles v2f vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 1 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(b, rule[1])
Parameters
afirst v2f input vector
bsecond v2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2i v2i_hshuffle2 ( v2i  a,
v2i  b,
uint_fast8_t  rule 
)
related

Shuffles v2i vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 1 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(b, rule[1])
Parameters
afirst v2i input vector
bsecond v2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2l v2l_hshuffle2 ( v2l  a,
v2l  b,
uint_fast8_t  rule 
)
related

Shuffles v2l vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 1 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(b, rule[1])
Parameters
afirst v2l input vector
bsecond v2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_hshuffle2 ( v4d  a,
v4d  b,
uint_fast8_t  rule 
)
related

Shuffles v4d vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2(a, rule[0])
dst[2:3] := SELECT2(b, rule[1])
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_hshuffle2 ( v4f  a,
v4f  b,
uint_fast8_t  rule 
)
related

Shuffles v4f vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2(a, rule[0])
dst[2:3] := SELECT2(b, rule[1])
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_hshuffle2 ( v4i  a,
v4i  b,
uint_fast8_t  rule 
)
related

Shuffles v4i vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2(a, rule[0])
dst[2:3] := SELECT2(b, rule[1])
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_hshuffle2 ( v4l  a,
v4l  b,
uint_fast8_t  rule 
)
related

Shuffles v4l vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2(a, rule[0])
dst[2:3] := SELECT2(b, rule[1])
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_hshuffle2 ( v8d  a,
v8d  b,
uint_fast8_t  rule 
)
related

Shuffles v8d vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 4 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2(a, rule[0])
dst[4:7] := SELECT2(b, rule[1])
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_hshuffle2 ( v8f  a,
v8f  b,
uint_fast8_t  rule 
)
related

Shuffles v8f vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 4 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2(a, rule[0])
dst[4:7] := SELECT2(b, rule[1])
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_hshuffle2 ( v8i  a,
v8i  b,
uint_fast8_t  rule 
)
related

Shuffles v8i vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 4 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2(a, rule[0])
dst[4:7] := SELECT2(b, rule[1])
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_hshuffle2 ( v8l  a,
v8l  b,
uint_fast8_t  rule 
)
related

Shuffles v8l vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 4 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2(a, rule[0])
dst[4:7] := SELECT2(b, rule[1])
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle2 ( v16f  a,
v16f  b,
uint_fast8_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 8 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:7]
0x1: _tmp := _src[8:15]
endcase
return _tmp
}
dst[0:7] := SELECT2(a, rule[0])
dst[8:15] := SELECT2(b, rule[1])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle2 ( v16i  a,
v16i  b,
uint_fast8_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done by moving 2 blocks of 8 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:7]
0x1: _tmp := _src[8:15]
endcase
return _tmp
}
dst[0:7] := SELECT2(a, rule[0])
dst[8:15] := SELECT2(b, rule[1])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_hshuffle4 ( v4d  a,
v4d  b,
uint_fast8_t  rule 
)
related

Shuffles v4d vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 1 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(b, rule[4:5])
dst[3] := SELECT4(b, rule[6:7])
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_hshuffle4 ( v4f  a,
v4f  b,
uint_fast8_t  rule 
)
related

Shuffles v4f vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 1 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(b, rule[4:5])
dst[3] := SELECT4(b, rule[6:7])
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_hshuffle4 ( v4i  a,
v4i  b,
uint_fast8_t  rule 
)
related

Shuffles v4i vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 1 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(b, rule[4:5])
dst[3] := SELECT4(b, rule[6:7])
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_hshuffle4 ( v4l  a,
v4l  b,
uint_fast8_t  rule 
)
related

Shuffles v4l vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 1 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(b, rule[4:5])
dst[3] := SELECT4(b, rule[6:7])
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_hshuffle4 ( v8d  a,
v8d  b,
uint_fast8_t  rule 
)
related

Shuffles v8d vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 2 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4(a, rule[0:1])
dst[2:3] := SELECT4(a, rule[2:3])
dst[4:5] := SELECT4(b, rule[4:5])
dst[6:7] := SELECT4(b, rule[6:7])
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_hshuffle4 ( v8f  a,
v8f  b,
uint_fast8_t  rule 
)
related

Shuffles v8f vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 2 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4(a, rule[0:1])
dst[2:3] := SELECT4(a, rule[2:3])
dst[4:5] := SELECT4(b, rule[4:5])
dst[6:7] := SELECT4(b, rule[6:7])
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_hshuffle4 ( v8i  a,
v8i  b,
uint_fast8_t  rule 
)
related

Shuffles v8i vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 2 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4(a, rule[0:1])
dst[2:3] := SELECT4(a, rule[2:3])
dst[4:5] := SELECT4(b, rule[4:5])
dst[6:7] := SELECT4(b, rule[6:7])
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_hshuffle4 ( v8l  a,
v8l  b,
uint_fast8_t  rule 
)
related

Shuffles v8l vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 2 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4(a, rule[0:1])
dst[2:3] := SELECT4(a, rule[2:3])
dst[4:5] := SELECT4(b, rule[4:5])
dst[6:7] := SELECT4(b, rule[6:7])
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle4 ( v16f  a,
v16f  b,
uint_fast8_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
0x2: _tmp := _src[8:11]
0x3: _tmp := _src[12:15]
endcase
return _tmp
}
dst[0:3] := SELECT4(a, rule[0:1])
dst[4:7] := SELECT4(a, rule[2:3])
dst[8:11] := SELECT4(b, rule[4:5])
dst[12:15] := SELECT4(b, rule[6:7])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle4 ( v16i  a,
v16i  b,
uint_fast8_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done by moving 4 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
0x2: _tmp := _src[8:11]
0x3: _tmp := _src[12:15]
endcase
return _tmp
}
dst[0:3] := SELECT4(a, rule[0:1])
dst[4:7] := SELECT4(a, rule[2:3])
dst[8:11] := SELECT4(b, rule[4:5])
dst[12:15] := SELECT4(b, rule[6:7])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_hshuffle8 ( v8d  a,
v8d  b,
uint_fast32_t  rule 
)
related

Shuffles v8d vectors a and b together using the control in rule. The shuffle is done by moving 8 blocks of 1 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(b, rule[12:14])
dst[5] := SELECT8(b, rule[15:17])
dst[6] := SELECT8(b, rule[18:20])
dst[7] := SELECT8(b, rule[21:23])
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_hshuffle8 ( v8f  a,
v8f  b,
uint_fast32_t  rule 
)
related

Shuffles v8f vectors a and b together using the control in rule. The shuffle is done by moving 8 blocks of 1 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(b, rule[12:14])
dst[5] := SELECT8(b, rule[15:17])
dst[6] := SELECT8(b, rule[18:20])
dst[7] := SELECT8(b, rule[21:23])
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_hshuffle8 ( v8i  a,
v8i  b,
uint_fast32_t  rule 
)
related

Shuffles v8i vectors a and b together using the control in rule. The shuffle is done by moving 8 blocks of 1 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(b, rule[12:14])
dst[5] := SELECT8(b, rule[15:17])
dst[6] := SELECT8(b, rule[18:20])
dst[7] := SELECT8(b, rule[21:23])
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_hshuffle8 ( v8l  a,
v8l  b,
uint_fast32_t  rule 
)
related

Shuffles v8l vectors a and b together using the control in rule. The shuffle is done by moving 8 blocks of 1 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(b, rule[12:14])
dst[5] := SELECT8(b, rule[15:17])
dst[6] := SELECT8(b, rule[18:20])
dst[7] := SELECT8(b, rule[21:23])
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle8 ( v16f  a,
v16f  b,
uint_fast32_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done by moving 8 blocks of 2 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
0x4: _tmp := _src[8:9]
0x5: _tmp := _src[10:11]
0x6: _tmp := _src[12:13]
0x7: _tmp := _src[14:15]
endcase
return _tmp
}
dst[0:1] := SELECT8(a, rule[0:2])
dst[2:3] := SELECT8(a, rule[3:5])
dst[4:5] := SELECT8(a, rule[6:8])
dst[6:7] := SELECT8(a, rule[9:11])
dst[8:9] := SELECT8(b, rule[12:14])
dst[10:11] := SELECT8(b, rule[15:17])
dst[12:13] := SELECT8(b, rule[18:20])
dst[14:15] := SELECT8(b, rule[21:23])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle8 ( v16i  a,
v16i  b,
uint_fast32_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done by moving 8 blocks of 2 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
0x4: _tmp := _src[8:9]
0x5: _tmp := _src[10:11]
0x6: _tmp := _src[12:13]
0x7: _tmp := _src[14:15]
endcase
return _tmp
}
dst[0:1] := SELECT8(a, rule[0:2])
dst[2:3] := SELECT8(a, rule[3:5])
dst[4:5] := SELECT8(a, rule[6:8])
dst[6:7] := SELECT8(a, rule[9:11])
dst[8:9] := SELECT8(b, rule[12:14])
dst[10:11] := SELECT8(b, rule[15:17])
dst[12:13] := SELECT8(b, rule[18:20])
dst[14:15] := SELECT8(b, rule[21:23])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle16 ( v16f  a,
v16f  b,
uint_fast64_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done by moving 16 blocks of 1 elements.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16(a, rule[0:3])
dst[1] := SELECT16(a, rule[4:7])
dst[2] := SELECT16(a, rule[8:11])
dst[3] := SELECT16(a, rule[12:15])
dst[4] := SELECT16(a, rule[16:19])
dst[5] := SELECT16(a, rule[20:23])
dst[6] := SELECT16(a, rule[24:27])
dst[7] := SELECT16(a, rule[28:31])
dst[8] := SELECT16(b, rule[32:35])
dst[9] := SELECT16(b, rule[36:39])
dst[10] := SELECT16(b, rule[40:43])
dst[11] := SELECT16(b, rule[44:47])
dst[12] := SELECT16(b, rule[48:51])
dst[13] := SELECT16(b, rule[52:55])
dst[14] := SELECT16(b, rule[56:59])
dst[15] := SELECT16(b, rule[60:63])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle16 ( v16i  a,
v16i  b,
uint_fast64_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done by moving 16 blocks of 1 elements.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16(a, rule[0:3])
dst[1] := SELECT16(a, rule[4:7])
dst[2] := SELECT16(a, rule[8:11])
dst[3] := SELECT16(a, rule[12:15])
dst[4] := SELECT16(a, rule[16:19])
dst[5] := SELECT16(a, rule[20:23])
dst[6] := SELECT16(a, rule[24:27])
dst[7] := SELECT16(a, rule[28:31])
dst[8] := SELECT16(b, rule[32:35])
dst[9] := SELECT16(b, rule[36:39])
dst[10] := SELECT16(b, rule[40:43])
dst[11] := SELECT16(b, rule[44:47])
dst[12] := SELECT16(b, rule[48:51])
dst[13] := SELECT16(b, rule[52:55])
dst[14] := SELECT16(b, rule[56:59])
dst[15] := SELECT16(b, rule[60:63])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2d v2d_hshuffle2x1 ( v2d  a,
v2d  b,
uint_fast8_t  rule 
)
related

Shuffles v2d vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v2d input vector
bsecond v2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2f v2f_hshuffle2x1 ( v2f  a,
v2f  b,
uint_fast8_t  rule 
)
related

Shuffles v2f vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v2f input vector
bsecond v2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2i v2i_hshuffle2x1 ( v2i  a,
v2i  b,
uint_fast8_t  rule 
)
related

Shuffles v2i vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v2i input vector
bsecond v2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2l v2l_hshuffle2x1 ( v2l  a,
v2l  b,
uint_fast8_t  rule 
)
related

Shuffles v2l vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v2l input vector
bsecond v2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_hshuffle2x2 ( v4d  a,
v4d  b,
uint_fast8_t  rule 
)
related

Shuffles v4d vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_hshuffle2x2 ( v4f  a,
v4f  b,
uint_fast8_t  rule 
)
related

Shuffles v4f vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_hshuffle2x2 ( v4i  a,
v4i  b,
uint_fast8_t  rule 
)
related

Shuffles v4i vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_hshuffle2x2 ( v4l  a,
v4l  b,
uint_fast8_t  rule 
)
related

Shuffles v4l vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_hshuffle2x4 ( v8d  a,
v8d  b,
uint_fast8_t  rule 
)
related

Shuffles v8d vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_hshuffle2x4 ( v8f  a,
v8f  b,
uint_fast8_t  rule 
)
related

Shuffles v8f vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_hshuffle2x4 ( v8i  a,
v8i  b,
uint_fast8_t  rule 
)
related

Shuffles v8i vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_hshuffle2x4 ( v8l  a,
v8l  b,
uint_fast8_t  rule 
)
related

Shuffles v8l vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle2x8 ( v16f  a,
v16f  b,
uint_fast8_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 8 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 7
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle2x8 ( v16i  a,
v16i  b,
uint_fast8_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 8 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 7
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(b[i:i+1], rule[1])
endfor
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_hshuffle4x1 ( v4d  a,
v4d  b,
uint_fast8_t  rule 
)
related

Shuffles v4d vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_hshuffle4x1 ( v4f  a,
v4f  b,
uint_fast8_t  rule 
)
related

Shuffles v4f vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_hshuffle4x1 ( v4i  a,
v4i  b,
uint_fast8_t  rule 
)
related

Shuffles v4i vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_hshuffle4x1 ( v4l  a,
v4l  b,
uint_fast8_t  rule 
)
related

Shuffles v4l vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_hshuffle4x2 ( v8d  a,
v8d  b,
uint_fast8_t  rule 
)
related

Shuffles v8d vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_hshuffle4x2 ( v8f  a,
v8f  b,
uint_fast8_t  rule 
)
related

Shuffles v8f vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_hshuffle4x2 ( v8i  a,
v8i  b,
uint_fast8_t  rule 
)
related

Shuffles v8i vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_hshuffle4x2 ( v8l  a,
v8l  b,
uint_fast8_t  rule 
)
related

Shuffles v8l vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle4x4 ( v16f  a,
v16f  b,
uint_fast8_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 4 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 3
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle4x4 ( v16i  a,
v16i  b,
uint_fast8_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 4 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 3
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(b[i:i+3], rule[4:5])
dst[i+3] := SELECT4(b[i:i+3], rule[6:7])
endfor
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_hshuffle8x1 ( v8d  a,
v8d  b,
uint_fast32_t  rule 
)
related

Shuffles v8d vectors a and b together using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(b[i:i+7], rule[12:14])
dst[i+5] := SELECT8(b[i:i+7], rule[15:17])
dst[i+6] := SELECT8(b[i:i+7], rule[18:20])
dst[i+7] := SELECT8(b[i:i+7], rule[21:23])
endfor
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_hshuffle8x1 ( v8f  a,
v8f  b,
uint_fast32_t  rule 
)
related

Shuffles v8f vectors a and b together using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(b[i:i+7], rule[12:14])
dst[i+5] := SELECT8(b[i:i+7], rule[15:17])
dst[i+6] := SELECT8(b[i:i+7], rule[18:20])
dst[i+7] := SELECT8(b[i:i+7], rule[21:23])
endfor
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_hshuffle8x1 ( v8i  a,
v8i  b,
uint_fast32_t  rule 
)
related

Shuffles v8i vectors a and b together using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(b[i:i+7], rule[12:14])
dst[i+5] := SELECT8(b[i:i+7], rule[15:17])
dst[i+6] := SELECT8(b[i:i+7], rule[18:20])
dst[i+7] := SELECT8(b[i:i+7], rule[21:23])
endfor
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_hshuffle8x1 ( v8l  a,
v8l  b,
uint_fast32_t  rule 
)
related

Shuffles v8l vectors a and b together using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(b[i:i+7], rule[12:14])
dst[i+5] := SELECT8(b[i:i+7], rule[15:17])
dst[i+6] := SELECT8(b[i:i+7], rule[18:20])
dst[i+7] := SELECT8(b[i:i+7], rule[21:23])
endfor
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle8x2 ( v16f  a,
v16f  b,
uint_fast32_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 2 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 1
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(b[i:i+7], rule[12:14])
dst[i+5] := SELECT8(b[i:i+7], rule[15:17])
dst[i+6] := SELECT8(b[i:i+7], rule[18:20])
dst[i+7] := SELECT8(b[i:i+7], rule[21:23])
endfor
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle8x2 ( v16i  a,
v16i  b,
uint_fast32_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 2 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 1
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(b[i:i+7], rule[12:14])
dst[i+5] := SELECT8(b[i:i+7], rule[15:17])
dst[i+6] := SELECT8(b[i:i+7], rule[18:20])
dst[i+7] := SELECT8(b[i:i+7], rule[21:23])
endfor
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle16x1 ( v16f  a,
v16f  b,
uint_fast64_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done by moving 16 elements with the same rule for every 1 blocks of 16 elements.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
for j from 0 to 0
i = j*16
dst[i] := SELECT16(a[i:i+15], rule[0:3])
dst[i+1] := SELECT16(a[i:i+15], rule[4:7])
dst[i+2] := SELECT16(a[i:i+15], rule[8:11])
dst[i+3] := SELECT16(a[i:i+15], rule[12:15])
dst[i+4] := SELECT16(a[i:i+15], rule[16:19])
dst[i+5] := SELECT16(a[i:i+15], rule[20:23])
dst[i+6] := SELECT16(a[i:i+15], rule[24:27])
dst[i+7] := SELECT16(a[i:i+15], rule[28:31])
dst[i+8] := SELECT16(b[i:i+15], rule[32:35])
dst[i+9] := SELECT16(b[i:i+15], rule[36:39])
dst[i+10] := SELECT16(b[i:i+15], rule[40:43])
dst[i+11] := SELECT16(b[i:i+15], rule[44:47])
dst[i+12] := SELECT16(b[i:i+15], rule[48:51])
dst[i+13] := SELECT16(b[i:i+15], rule[52:55])
dst[i+14] := SELECT16(b[i:i+15], rule[56:59])
dst[i+15] := SELECT16(b[i:i+15], rule[60:63])
endfor
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle16x1 ( v16i  a,
v16i  b,
uint_fast64_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done by moving 16 elements with the same rule for every 1 blocks of 16 elements.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
for j from 0 to 0
i = j*16
dst[i] := SELECT16(a[i:i+15], rule[0:3])
dst[i+1] := SELECT16(a[i:i+15], rule[4:7])
dst[i+2] := SELECT16(a[i:i+15], rule[8:11])
dst[i+3] := SELECT16(a[i:i+15], rule[12:15])
dst[i+4] := SELECT16(a[i:i+15], rule[16:19])
dst[i+5] := SELECT16(a[i:i+15], rule[20:23])
dst[i+6] := SELECT16(a[i:i+15], rule[24:27])
dst[i+7] := SELECT16(a[i:i+15], rule[28:31])
dst[i+8] := SELECT16(b[i:i+15], rule[32:35])
dst[i+9] := SELECT16(b[i:i+15], rule[36:39])
dst[i+10] := SELECT16(b[i:i+15], rule[40:43])
dst[i+11] := SELECT16(b[i:i+15], rule[44:47])
dst[i+12] := SELECT16(b[i:i+15], rule[48:51])
dst[i+13] := SELECT16(b[i:i+15], rule[52:55])
dst[i+14] := SELECT16(b[i:i+15], rule[56:59])
dst[i+15] := SELECT16(b[i:i+15], rule[60:63])
endfor
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2d v2d_permute2 ( v2d  a,
uint_fast8_t  rule 
)
related

Shuffles the v2d vector a using the control in rule. The shuffle is done by moving 2 blocks of 1 elements.

Functionally equivalent to v2d_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(a, rule[1])
See Also
v2d_hshuffle2(v2d a, v2d b, uint_fast8_t rule)
Parameters
av2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2f v2f_permute2 ( v2f  a,
uint_fast8_t  rule 
)
related

Shuffles the v2f vector a using the control in rule. The shuffle is done by moving 2 blocks of 1 elements.

Functionally equivalent to v2f_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(a, rule[1])
See Also
v2f_hshuffle2(v2f a, v2f b, uint_fast8_t rule)
Parameters
av2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2i v2i_permute2 ( v2i  a,
uint_fast8_t  rule 
)
related

Shuffles the v2i vector a using the control in rule. The shuffle is done by moving 2 blocks of 1 elements.

Functionally equivalent to v2i_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(a, rule[1])
See Also
v2i_hshuffle2(v2i a, v2i b, uint_fast8_t rule)
Parameters
av2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2l v2l_permute2 ( v2l  a,
uint_fast8_t  rule 
)
related

Shuffles the v2l vector a using the control in rule. The shuffle is done by moving 2 blocks of 1 elements.

Functionally equivalent to v2l_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(a, rule[1])
See Also
v2l_hshuffle2(v2l a, v2l b, uint_fast8_t rule)
Parameters
av2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_permute2 ( v4d  a,
uint_fast8_t  rule 
)
related

Shuffles the v4d vector a using the control in rule. The shuffle is done by moving 2 blocks of 2 elements.

Functionally equivalent to v4d_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2(a, rule[0])
dst[2:3] := SELECT2(a, rule[1])
See Also
v4d_hshuffle2(v4d a, v4d b, uint_fast8_t rule)
Parameters
av4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_permute2 ( v4f  a,
uint_fast8_t  rule 
)
related

Shuffles the v4f vector a using the control in rule. The shuffle is done by moving 2 blocks of 2 elements.

Functionally equivalent to v4f_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2(a, rule[0])
dst[2:3] := SELECT2(a, rule[1])
See Also
v4f_hshuffle2(v4f a, v4f b, uint_fast8_t rule)
Parameters
av4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_permute2 ( v4i  a,
uint_fast8_t  rule 
)
related

Shuffles the v4i vector a using the control in rule. The shuffle is done by moving 2 blocks of 2 elements.

Functionally equivalent to v4i_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2(a, rule[0])
dst[2:3] := SELECT2(a, rule[1])
See Also
v4i_hshuffle2(v4i a, v4i b, uint_fast8_t rule)
Parameters
av4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_permute2 ( v4l  a,
uint_fast8_t  rule 
)
related

Shuffles the v4l vector a using the control in rule. The shuffle is done by moving 2 blocks of 2 elements.

Functionally equivalent to v4l_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2(a, rule[0])
dst[2:3] := SELECT2(a, rule[1])
See Also
v4l_hshuffle2(v4l a, v4l b, uint_fast8_t rule)
Parameters
av4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_permute2 ( v8d  a,
uint_fast8_t  rule 
)
related

Shuffles the v8d vector a using the control in rule. The shuffle is done by moving 2 blocks of 4 elements.

Functionally equivalent to v8d_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2(a, rule[0])
dst[4:7] := SELECT2(a, rule[1])
See Also
v8d_hshuffle2(v8d a, v8d b, uint_fast32_t rule)
Parameters
av8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_permute2 ( v8f  a,
uint_fast8_t  rule 
)
related

Shuffles the v8f vector a using the control in rule. The shuffle is done by moving 2 blocks of 4 elements.

Functionally equivalent to v8f_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2(a, rule[0])
dst[4:7] := SELECT2(a, rule[1])
See Also
v8f_hshuffle2(v8f a, v8f b, uint_fast32_t rule)
Parameters
av8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_permute2 ( v8i  a,
uint_fast8_t  rule 
)
related

Shuffles the v8i vector a using the control in rule. The shuffle is done by moving 2 blocks of 4 elements.

Functionally equivalent to v8i_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2(a, rule[0])
dst[4:7] := SELECT2(a, rule[1])
See Also
v8i_hshuffle2(v8i a, v8i b, uint_fast32_t rule)
Parameters
av8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_permute2 ( v8l  a,
uint_fast8_t  rule 
)
related

Shuffles the v8l vector a using the control in rule. The shuffle is done by moving 2 blocks of 4 elements.

Functionally equivalent to v8l_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2(a, rule[0])
dst[4:7] := SELECT2(a, rule[1])
See Also
v8l_hshuffle2(v8l a, v8l b, uint_fast32_t rule)
Parameters
av8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute2 ( v16f  a,
uint_fast8_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 2 blocks of 8 elements.

Functionally equivalent to v16f_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:7]
0x1: _tmp := _src[8:15]
endcase
return _tmp
}
dst[0:7] := SELECT2(a, rule[0])
dst[8:15] := SELECT2(a, rule[1])
See Also
v16f_hshuffle2(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute2 ( v16i  a,
uint_fast8_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 2 blocks of 8 elements.

Functionally equivalent to v16i_hshuffle2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:7]
0x1: _tmp := _src[8:15]
endcase
return _tmp
}
dst[0:7] := SELECT2(a, rule[0])
dst[8:15] := SELECT2(a, rule[1])
See Also
v16i_hshuffle2(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_permute4 ( v4d  a,
uint_fast8_t  rule 
)
related

Shuffles the v4d vector a using the control in rule. The shuffle is done by moving 4 blocks of 1 elements.

Functionally equivalent to v4d_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(a, rule[4:5])
dst[3] := SELECT4(a, rule[6:7])
See Also
v4d_hshuffle4(v4d a, v4d b, uint_fast8_t rule)
Parameters
av4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_permute4 ( v4f  a,
uint_fast8_t  rule 
)
related

Shuffles the v4f vector a using the control in rule. The shuffle is done by moving 4 blocks of 1 elements.

Functionally equivalent to v4f_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(a, rule[4:5])
dst[3] := SELECT4(a, rule[6:7])
See Also
v4f_hshuffle4(v4f a, v4f b, uint_fast8_t rule)
Parameters
av4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_permute4 ( v4i  a,
uint_fast8_t  rule 
)
related

Shuffles the v4i vector a using the control in rule. The shuffle is done by moving 4 blocks of 1 elements.

Functionally equivalent to v4i_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(a, rule[4:5])
dst[3] := SELECT4(a, rule[6:7])
See Also
v4i_hshuffle4(v4i a, v4i b, uint_fast8_t rule)
Parameters
av4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_permute4 ( v4l  a,
uint_fast8_t  rule 
)
related

Shuffles the v4l vector a using the control in rule. The shuffle is done by moving 4 blocks of 1 elements.

Functionally equivalent to v4l_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(a, rule[4:5])
dst[3] := SELECT4(a, rule[6:7])
See Also
v4l_hshuffle4(v4l a, v4l b, uint_fast8_t rule)
Parameters
av4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_permute4 ( v8d  a,
uint_fast8_t  rule 
)
related

Shuffles the v8d vector a using the control in rule. The shuffle is done by moving 4 blocks of 2 elements.

Functionally equivalent to v8d_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4(a, rule[0:1])
dst[2:3] := SELECT4(a, rule[2:3])
dst[4:5] := SELECT4(a, rule[4:5])
dst[6:7] := SELECT4(a, rule[6:7])
See Also
v8d_hshuffle4(v8d a, v8d b, uint_fast32_t rule)
Parameters
av8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_permute4 ( v8f  a,
uint_fast8_t  rule 
)
related

Shuffles the v8f vector a using the control in rule. The shuffle is done by moving 4 blocks of 2 elements.

Functionally equivalent to v8f_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4(a, rule[0:1])
dst[2:3] := SELECT4(a, rule[2:3])
dst[4:5] := SELECT4(a, rule[4:5])
dst[6:7] := SELECT4(a, rule[6:7])
See Also
v8f_hshuffle4(v8f a, v8f b, uint_fast32_t rule)
Parameters
av8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_permute4 ( v8i  a,
uint_fast8_t  rule 
)
related

Shuffles the v8i vector a using the control in rule. The shuffle is done by moving 4 blocks of 2 elements.

Functionally equivalent to v8i_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4(a, rule[0:1])
dst[2:3] := SELECT4(a, rule[2:3])
dst[4:5] := SELECT4(a, rule[4:5])
dst[6:7] := SELECT4(a, rule[6:7])
See Also
v8i_hshuffle4(v8i a, v8i b, uint_fast32_t rule)
Parameters
av8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_permute4 ( v8l  a,
uint_fast8_t  rule 
)
related

Shuffles the v8l vector a using the control in rule. The shuffle is done by moving 4 blocks of 2 elements.

Functionally equivalent to v8l_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4(a, rule[0:1])
dst[2:3] := SELECT4(a, rule[2:3])
dst[4:5] := SELECT4(a, rule[4:5])
dst[6:7] := SELECT4(a, rule[6:7])
See Also
v8l_hshuffle4(v8l a, v8l b, uint_fast32_t rule)
Parameters
av8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute4 ( v16f  a,
uint_fast8_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 4 blocks of 4 elements.

Functionally equivalent to v16f_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
0x2: _tmp := _src[8:11]
0x3: _tmp := _src[12:15]
endcase
return _tmp
}
dst[0:3] := SELECT4(a, rule[0:1])
dst[4:7] := SELECT4(a, rule[2:3])
dst[8:11] := SELECT4(a, rule[4:5])
dst[12:15] := SELECT4(a, rule[6:7])
See Also
v16f_hshuffle4(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute4 ( v16i  a,
uint_fast8_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 4 blocks of 4 elements.

Functionally equivalent to v16i_hshuffle4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
0x2: _tmp := _src[8:11]
0x3: _tmp := _src[12:15]
endcase
return _tmp
}
dst[0:3] := SELECT4(a, rule[0:1])
dst[4:7] := SELECT4(a, rule[2:3])
dst[8:11] := SELECT4(a, rule[4:5])
dst[12:15] := SELECT4(a, rule[6:7])
See Also
v16i_hshuffle4(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_permute8 ( v8d  a,
uint_fast32_t  rule 
)
related

Shuffles the v8d vector a using the control in rule. The shuffle is done by moving 8 blocks of 1 elements.

Functionally equivalent to v8d_hshuffle8(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(a, rule[12:14])
dst[5] := SELECT8(a, rule[15:17])
dst[6] := SELECT8(a, rule[18:20])
dst[7] := SELECT8(a, rule[21:23])
See Also
v8d_hshuffle8(v8d a, v8d b, uint_fast32_t rule)
Parameters
av8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_permute8 ( v8f  a,
uint_fast32_t  rule 
)
related

Shuffles the v8f vector a using the control in rule. The shuffle is done by moving 8 blocks of 1 elements.

Functionally equivalent to v8f_hshuffle8(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(a, rule[12:14])
dst[5] := SELECT8(a, rule[15:17])
dst[6] := SELECT8(a, rule[18:20])
dst[7] := SELECT8(a, rule[21:23])
See Also
v8f_hshuffle8(v8f a, v8f b, uint_fast32_t rule)
Parameters
av8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_permute8 ( v8i  a,
uint_fast32_t  rule 
)
related

Shuffles the v8i vector a using the control in rule. The shuffle is done by moving 8 blocks of 1 elements.

Functionally equivalent to v8i_hshuffle8(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(a, rule[12:14])
dst[5] := SELECT8(a, rule[15:17])
dst[6] := SELECT8(a, rule[18:20])
dst[7] := SELECT8(a, rule[21:23])
See Also
v8i_hshuffle8(v8i a, v8i b, uint_fast32_t rule)
Parameters
av8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_permute8 ( v8l  a,
uint_fast32_t  rule 
)
related

Shuffles the v8l vector a using the control in rule. The shuffle is done by moving 8 blocks of 1 elements.

Functionally equivalent to v8l_hshuffle8(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(a, rule[12:14])
dst[5] := SELECT8(a, rule[15:17])
dst[6] := SELECT8(a, rule[18:20])
dst[7] := SELECT8(a, rule[21:23])
See Also
v8l_hshuffle8(v8l a, v8l b, uint_fast32_t rule)
Parameters
av8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute8 ( v16f  a,
uint_fast32_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 8 blocks of 2 elements.

Functionally equivalent to v16f_hshuffle8(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
0x4: _tmp := _src[8:9]
0x5: _tmp := _src[10:11]
0x6: _tmp := _src[12:13]
0x7: _tmp := _src[14:15]
endcase
return _tmp
}
dst[0:1] := SELECT8(a, rule[0:2])
dst[2:3] := SELECT8(a, rule[3:5])
dst[4:5] := SELECT8(a, rule[6:8])
dst[6:7] := SELECT8(a, rule[9:11])
dst[8:9] := SELECT8(a, rule[12:14])
dst[10:11] := SELECT8(a, rule[15:17])
dst[12:13] := SELECT8(a, rule[18:20])
dst[14:15] := SELECT8(a, rule[21:23])
See Also
v16f_hshuffle8(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute8 ( v16i  a,
uint_fast32_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 8 blocks of 2 elements.

Functionally equivalent to v16i_hshuffle8(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
0x4: _tmp := _src[8:9]
0x5: _tmp := _src[10:11]
0x6: _tmp := _src[12:13]
0x7: _tmp := _src[14:15]
endcase
return _tmp
}
dst[0:1] := SELECT8(a, rule[0:2])
dst[2:3] := SELECT8(a, rule[3:5])
dst[4:5] := SELECT8(a, rule[6:8])
dst[6:7] := SELECT8(a, rule[9:11])
dst[8:9] := SELECT8(a, rule[12:14])
dst[10:11] := SELECT8(a, rule[15:17])
dst[12:13] := SELECT8(a, rule[18:20])
dst[14:15] := SELECT8(a, rule[21:23])
See Also
v16i_hshuffle8(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute16 ( v16f  a,
uint_fast64_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 16 blocks of 1 elements.

Functionally equivalent to v16f_hshuffle16(a, a, rule)

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16(a, rule[0:3])
dst[1] := SELECT16(a, rule[4:7])
dst[2] := SELECT16(a, rule[8:11])
dst[3] := SELECT16(a, rule[12:15])
dst[4] := SELECT16(a, rule[16:19])
dst[5] := SELECT16(a, rule[20:23])
dst[6] := SELECT16(a, rule[24:27])
dst[7] := SELECT16(a, rule[28:31])
dst[8] := SELECT16(a, rule[32:35])
dst[9] := SELECT16(a, rule[36:39])
dst[10] := SELECT16(a, rule[40:43])
dst[11] := SELECT16(a, rule[44:47])
dst[12] := SELECT16(a, rule[48:51])
dst[13] := SELECT16(a, rule[52:55])
dst[14] := SELECT16(a, rule[56:59])
dst[15] := SELECT16(a, rule[60:63])
See Also
v16f_hshuffle16(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute16 ( v16i  a,
uint_fast64_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 16 blocks of 1 elements.

Functionally equivalent to v16i_hshuffle16(a, a, rule)

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16(a, rule[0:3])
dst[1] := SELECT16(a, rule[4:7])
dst[2] := SELECT16(a, rule[8:11])
dst[3] := SELECT16(a, rule[12:15])
dst[4] := SELECT16(a, rule[16:19])
dst[5] := SELECT16(a, rule[20:23])
dst[6] := SELECT16(a, rule[24:27])
dst[7] := SELECT16(a, rule[28:31])
dst[8] := SELECT16(a, rule[32:35])
dst[9] := SELECT16(a, rule[36:39])
dst[10] := SELECT16(a, rule[40:43])
dst[11] := SELECT16(a, rule[44:47])
dst[12] := SELECT16(a, rule[48:51])
dst[13] := SELECT16(a, rule[52:55])
dst[14] := SELECT16(a, rule[56:59])
dst[15] := SELECT16(a, rule[60:63])
See Also
v16i_hshuffle16(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2d v2d_permute2x1 ( v2d  a,
uint_fast8_t  rule 
)
related

Shuffles the v2d vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Functionally equivalent to v2d_hshuffle2x1(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v2d_hshuffle2x1(v2d a, v2d b, uint_fast8_t rule)
Parameters
av2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2f v2f_permute2x1 ( v2f  a,
uint_fast8_t  rule 
)
related

Shuffles the v2f vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Functionally equivalent to v2f_hshuffle2x1(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v2f_hshuffle2x1(v2f a, v2f b, uint_fast8_t rule)
Parameters
av2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2i v2i_permute2x1 ( v2i  a,
uint_fast8_t  rule 
)
related

Shuffles the v2i vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Functionally equivalent to v2i_hshuffle2x1(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v2i_hshuffle2x1(v2i a, v2i b, uint_fast8_t rule)
Parameters
av2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2l v2l_permute2x1 ( v2l  a,
uint_fast8_t  rule 
)
related

Shuffles the v2l vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Functionally equivalent to v2l_hshuffle2x1(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v2l_hshuffle2x1(v2l a, v2l b, uint_fast8_t rule)
Parameters
av2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_permute2x2 ( v4d  a,
uint_fast8_t  rule 
)
related

Shuffles the v4d vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Functionally equivalent to v4d_hshuffle2x2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v4d_hshuffle2x2(v4d a, v4d b, uint_fast8_t rule)
Parameters
av4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_permute2x2 ( v4f  a,
uint_fast8_t  rule 
)
related

Shuffles the v4f vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Functionally equivalent to v4f_hshuffle2x2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v4f_hshuffle2x2(v4f a, v4f b, uint_fast8_t rule)
Parameters
av4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_permute2x2 ( v4i  a,
uint_fast8_t  rule 
)
related

Shuffles the v4i vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Functionally equivalent to v4i_hshuffle2x2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v4i_hshuffle2x2(v4i a, v4i b, uint_fast8_t rule)
Parameters
av4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_permute2x2 ( v4l  a,
uint_fast8_t  rule 
)
related

Shuffles the v4l vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Functionally equivalent to v4l_hshuffle2x2(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v4l_hshuffle2x2(v4l a, v4l b, uint_fast8_t rule)
Parameters
av4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_permute2x4 ( v8d  a,
uint_fast8_t  rule 
)
related

Shuffles the v8d vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Functionally equivalent to v8d_hshuffle2x4(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v8d_hshuffle2x4(v8d a, v8d b, uint_fast32_t rule)
Parameters
av8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_permute2x4 ( v8f  a,
uint_fast8_t  rule 
)
related

Shuffles the v8f vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Functionally equivalent to v8f_hshuffle2x4(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v8f_hshuffle2x4(v8f a, v8f b, uint_fast32_t rule)
Parameters
av8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_permute2x4 ( v8i  a,
uint_fast8_t  rule 
)
related

Shuffles the v8i vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Functionally equivalent to v8i_hshuffle2x4(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v8i_hshuffle2x4(v8i a, v8i b, uint_fast32_t rule)
Parameters
av8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_permute2x4 ( v8l  a,
uint_fast8_t  rule 
)
related

Shuffles the v8l vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Functionally equivalent to v8l_hshuffle2x4(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v8l_hshuffle2x4(v8l a, v8l b, uint_fast32_t rule)
Parameters
av8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute2x8 ( v16f  a,
uint_fast8_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 8 blocks of 2 elements.

Functionally equivalent to v16f_hshuffle2x8(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 7
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v16f_hshuffle2x8(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute2x8 ( v16i  a,
uint_fast8_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 8 blocks of 2 elements.

Functionally equivalent to v16i_hshuffle2x8(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 7
i = j*2
dst[i] := SELECT2(a[i:i+1], rule[0])
dst[i+1] := SELECT2(a[i:i+1], rule[1])
endfor
See Also
v16i_hshuffle2x8(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_permute4x1 ( v4d  a,
uint_fast8_t  rule 
)
related

Shuffles the v4d vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Functionally equivalent to v4d_hshuffle4x1(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v4d_hshuffle4x1(v4d a, v4d b, uint_fast8_t rule)
Parameters
av4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_permute4x1 ( v4f  a,
uint_fast8_t  rule 
)
related

Shuffles the v4f vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Functionally equivalent to v4f_hshuffle4x1(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v4f_hshuffle4x1(v4f a, v4f b, uint_fast8_t rule)
Parameters
av4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_permute4x1 ( v4i  a,
uint_fast8_t  rule 
)
related

Shuffles the v4i vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Functionally equivalent to v4i_hshuffle4x1(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v4i_hshuffle4x1(v4i a, v4i b, uint_fast8_t rule)
Parameters
av4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_permute4x1 ( v4l  a,
uint_fast8_t  rule 
)
related

Shuffles the v4l vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Functionally equivalent to v4l_hshuffle4x1(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v4l_hshuffle4x1(v4l a, v4l b, uint_fast8_t rule)
Parameters
av4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_permute4x2 ( v8d  a,
uint_fast8_t  rule 
)
related

Shuffles the v8d vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Functionally equivalent to v8d_hshuffle4x2(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v8d_hshuffle4x2(v8d a, v8d b, uint_fast32_t rule)
Parameters
av8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_permute4x2 ( v8f  a,
uint_fast8_t  rule 
)
related

Shuffles the v8f vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Functionally equivalent to v8f_hshuffle4x2(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v8f_hshuffle4x2(v8f a, v8f b, uint_fast32_t rule)
Parameters
av8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_permute4x2 ( v8i  a,
uint_fast8_t  rule 
)
related

Shuffles the v8i vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Functionally equivalent to v8i_hshuffle4x2(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v8i_hshuffle4x2(v8i a, v8i b, uint_fast32_t rule)
Parameters
av8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_permute4x2 ( v8l  a,
uint_fast8_t  rule 
)
related

Shuffles the v8l vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Functionally equivalent to v8l_hshuffle4x2(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v8l_hshuffle4x2(v8l a, v8l b, uint_fast32_t rule)
Parameters
av8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute4x4 ( v16f  a,
uint_fast8_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 4 blocks of 4 elements.

Functionally equivalent to v16f_hshuffle4x4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 3
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v16f_hshuffle4x4(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute4x4 ( v16i  a,
uint_fast8_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 4 blocks of 4 elements.

Functionally equivalent to v16i_hshuffle4x4(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 3
i = j*4
dst[i] := SELECT4(a[i:i+3], rule[0:1])
dst[i+1] := SELECT4(a[i:i+3], rule[2:3])
dst[i+2] := SELECT4(a[i:i+3], rule[4:5])
dst[i+3] := SELECT4(a[i:i+3], rule[6:7])
endfor
See Also
v16i_hshuffle4x4(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_permute8x1 ( v8d  a,
uint_fast32_t  rule 
)
related

Shuffles the v8d vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Functionally equivalent to v8d_hshuffle8x1(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(a[i:i+7], rule[12:14])
dst[i+5] := SELECT8(a[i:i+7], rule[15:17])
dst[i+6] := SELECT8(a[i:i+7], rule[18:20])
dst[i+7] := SELECT8(a[i:i+7], rule[21:23])
endfor
See Also
v8d_hshuffle8x1(v8d a, v8d b, uint_fast32_t rule)
Parameters
av8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_permute8x1 ( v8f  a,
uint_fast32_t  rule 
)
related

Shuffles the v8f vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Functionally equivalent to v8f_hshuffle8x1(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(a[i:i+7], rule[12:14])
dst[i+5] := SELECT8(a[i:i+7], rule[15:17])
dst[i+6] := SELECT8(a[i:i+7], rule[18:20])
dst[i+7] := SELECT8(a[i:i+7], rule[21:23])
endfor
See Also
v8f_hshuffle8x1(v8f a, v8f b, uint_fast32_t rule)
Parameters
av8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_permute8x1 ( v8i  a,
uint_fast32_t  rule 
)
related

Shuffles the v8i vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Functionally equivalent to v8i_hshuffle8x1(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(a[i:i+7], rule[12:14])
dst[i+5] := SELECT8(a[i:i+7], rule[15:17])
dst[i+6] := SELECT8(a[i:i+7], rule[18:20])
dst[i+7] := SELECT8(a[i:i+7], rule[21:23])
endfor
See Also
v8i_hshuffle8x1(v8i a, v8i b, uint_fast32_t rule)
Parameters
av8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_permute8x1 ( v8l  a,
uint_fast32_t  rule 
)
related

Shuffles the v8l vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Functionally equivalent to v8l_hshuffle8x1(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(a[i:i+7], rule[12:14])
dst[i+5] := SELECT8(a[i:i+7], rule[15:17])
dst[i+6] := SELECT8(a[i:i+7], rule[18:20])
dst[i+7] := SELECT8(a[i:i+7], rule[21:23])
endfor
See Also
v8l_hshuffle8x1(v8l a, v8l b, uint_fast32_t rule)
Parameters
av8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute8x2 ( v16f  a,
uint_fast32_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 2 blocks of 8 elements.

Functionally equivalent to v16f_hshuffle8x2(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 1
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(a[i:i+7], rule[12:14])
dst[i+5] := SELECT8(a[i:i+7], rule[15:17])
dst[i+6] := SELECT8(a[i:i+7], rule[18:20])
dst[i+7] := SELECT8(a[i:i+7], rule[21:23])
endfor
See Also
v16f_hshuffle8x2(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute8x2 ( v16i  a,
uint_fast32_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 2 blocks of 8 elements.

Functionally equivalent to v16i_hshuffle8x2(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 1
i = j*8
dst[i] := SELECT8(a[i:i+7], rule[0:2])
dst[i+1] := SELECT8(a[i:i+7], rule[3:5])
dst[i+2] := SELECT8(a[i:i+7], rule[6:8])
dst[i+3] := SELECT8(a[i:i+7], rule[9:11])
dst[i+4] := SELECT8(a[i:i+7], rule[12:14])
dst[i+5] := SELECT8(a[i:i+7], rule[15:17])
dst[i+6] := SELECT8(a[i:i+7], rule[18:20])
dst[i+7] := SELECT8(a[i:i+7], rule[21:23])
endfor
See Also
v16i_hshuffle8x2(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute16x1 ( v16f  a,
uint_fast64_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 16 elements with the same rule for every 1 blocks of 16 elements.

Functionally equivalent to v16f_hshuffle16x1(a, a, rule)

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
for j from 0 to 0
i = j*16
dst[i] := SELECT16(a[i:i+15], rule[0:3])
dst[i+1] := SELECT16(a[i:i+15], rule[4:7])
dst[i+2] := SELECT16(a[i:i+15], rule[8:11])
dst[i+3] := SELECT16(a[i:i+15], rule[12:15])
dst[i+4] := SELECT16(a[i:i+15], rule[16:19])
dst[i+5] := SELECT16(a[i:i+15], rule[20:23])
dst[i+6] := SELECT16(a[i:i+15], rule[24:27])
dst[i+7] := SELECT16(a[i:i+15], rule[28:31])
dst[i+8] := SELECT16(a[i:i+15], rule[32:35])
dst[i+9] := SELECT16(a[i:i+15], rule[36:39])
dst[i+10] := SELECT16(a[i:i+15], rule[40:43])
dst[i+11] := SELECT16(a[i:i+15], rule[44:47])
dst[i+12] := SELECT16(a[i:i+15], rule[48:51])
dst[i+13] := SELECT16(a[i:i+15], rule[52:55])
dst[i+14] := SELECT16(a[i:i+15], rule[56:59])
dst[i+15] := SELECT16(a[i:i+15], rule[60:63])
endfor
See Also
v16f_hshuffle16x1(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute16x1 ( v16i  a,
uint_fast64_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 16 elements with the same rule for every 1 blocks of 16 elements.

Functionally equivalent to v16i_hshuffle16x1(a, a, rule)

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
for j from 0 to 0
i = j*16
dst[i] := SELECT16(a[i:i+15], rule[0:3])
dst[i+1] := SELECT16(a[i:i+15], rule[4:7])
dst[i+2] := SELECT16(a[i:i+15], rule[8:11])
dst[i+3] := SELECT16(a[i:i+15], rule[12:15])
dst[i+4] := SELECT16(a[i:i+15], rule[16:19])
dst[i+5] := SELECT16(a[i:i+15], rule[20:23])
dst[i+6] := SELECT16(a[i:i+15], rule[24:27])
dst[i+7] := SELECT16(a[i:i+15], rule[28:31])
dst[i+8] := SELECT16(a[i:i+15], rule[32:35])
dst[i+9] := SELECT16(a[i:i+15], rule[36:39])
dst[i+10] := SELECT16(a[i:i+15], rule[40:43])
dst[i+11] := SELECT16(a[i:i+15], rule[44:47])
dst[i+12] := SELECT16(a[i:i+15], rule[48:51])
dst[i+13] := SELECT16(a[i:i+15], rule[52:55])
dst[i+14] := SELECT16(a[i:i+15], rule[56:59])
dst[i+15] := SELECT16(a[i:i+15], rule[60:63])
endfor
See Also
v16i_hshuffle16x1(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2d v2d_fshuffle2 ( v2d  a,
v2d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 1 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[1] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v2d input vector
bsecond v2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2f v2f_fshuffle2 ( v2f  a,
v2f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 1 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[1] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v2f input vector
bsecond v2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2i v2i_fshuffle2 ( v2i  a,
v2i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 1 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[1] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v2i input vector
bsecond v2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2l v2l_fshuffle2 ( v2l  a,
v2l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 1 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[1] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v2l input vector
bsecond v2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4d v4d_fshuffle2 ( v4d  a,
v4d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[2:3] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4f v4f_fshuffle2 ( v4f  a,
v4f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[2:3] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4i v4i_fshuffle2 ( v4i  a,
v4i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[2:3] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4l v4l_fshuffle2 ( v4l  a,
v4l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
endcase
return _tmp
}
dst[0:1] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[2:3] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8d v8d_fshuffle2 ( v8d  a,
v8d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 4 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[4:7] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8f v8f_fshuffle2 ( v8f  a,
v8f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 4 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[4:7] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8i v8i_fshuffle2 ( v8i  a,
v8i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 4 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[4:7] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8l v8l_fshuffle2 ( v8l  a,
v8l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 4 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
endcase
return _tmp
}
dst[0:3] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[4:7] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle2 ( v16f  a,
v16f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 8 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:7]
0x1: _tmp := _src[8:15]
endcase
return _tmp
}
dst[0:7] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[8:15] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle2 ( v16i  a,
v16i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 blocks of 8 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0:7]
0x1: _tmp := _src[8:15]
endcase
return _tmp
}
dst[0:7] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[8:15] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4d v4d_fshuffle4 ( v4d  a,
v4d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 1 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[1] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[2] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[3] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4f v4f_fshuffle4 ( v4f  a,
v4f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 1 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[1] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[2] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[3] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4i v4i_fshuffle4 ( v4i  a,
v4i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 1 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[1] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[2] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[3] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4l v4l_fshuffle4 ( v4l  a,
v4l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 1 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[1] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[2] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[3] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8d v8d_fshuffle4 ( v8d  a,
v8d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 2 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[2:3] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[4:5] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[6:7] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8f v8f_fshuffle4 ( v8f  a,
v8f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 2 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[2:3] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[4:5] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[6:7] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8i v8i_fshuffle4 ( v8i  a,
v8i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 2 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[2:3] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[4:5] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[6:7] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8l v8l_fshuffle4 ( v8l  a,
v8l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 2 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
endcase
return _tmp
}
dst[0:1] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[2:3] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[4:5] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[6:7] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle4 ( v16f  a,
v16f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
0x2: _tmp := _src[8:11]
0x3: _tmp := _src[12:15]
endcase
return _tmp
}
dst[0:3] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[4:7] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[8:11] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[12:15] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle4 ( v16i  a,
v16i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0:3]
0x1: _tmp := _src[4:7]
0x2: _tmp := _src[8:11]
0x3: _tmp := _src[12:15]
endcase
return _tmp
}
dst[0:3] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[4:7] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[8:11] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[12:15] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8d v8d_fshuffle8 ( v8d  a,
v8d  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 blocks of 1 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[1] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[2] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[3] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[4] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[5] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[6] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[7] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8f v8f_fshuffle8 ( v8f  a,
v8f  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 blocks of 1 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[1] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[2] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[3] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[4] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[5] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[6] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[7] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8i v8i_fshuffle8 ( v8i  a,
v8i  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 blocks of 1 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[1] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[2] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[3] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[4] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[5] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[6] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[7] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8l v8l_fshuffle8 ( v8l  a,
v8l  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 blocks of 1 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[1] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[2] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[3] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[4] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[5] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[6] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[7] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle8 ( v16f  a,
v16f  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 blocks of 2 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
0x4: _tmp := _src[8:9]
0x5: _tmp := _src[10:11]
0x6: _tmp := _src[12:13]
0x7: _tmp := _src[14:15]
endcase
return _tmp
}
dst[0:1] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[2:3] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[4:5] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[6:7] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[8:9] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[10:11] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[12:13] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[14:15] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle8 ( v16i  a,
v16i  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 blocks of 2 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0:1]
0x1: _tmp := _src[2:3]
0x2: _tmp := _src[4:5]
0x3: _tmp := _src[6:7]
0x4: _tmp := _src[8:9]
0x5: _tmp := _src[10:11]
0x6: _tmp := _src[12:13]
0x7: _tmp := _src[14:15]
endcase
return _tmp
}
dst[0:1] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[2:3] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[4:5] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[6:7] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[8:9] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[10:11] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[12:13] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[14:15] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle16 ( v16f  a,
v16f  b,
uint_fast64_t  rule,
uint_fast16_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 16 blocks of 1 elements.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16((mask.bits[0] ? b : a), rule[0:3])
dst[1] := SELECT16((mask.bits[1] ? b : a), rule[4:7])
dst[2] := SELECT16((mask.bits[2] ? b : a), rule[8:11])
dst[3] := SELECT16((mask.bits[3] ? b : a), rule[12:15])
dst[4] := SELECT16((mask.bits[4] ? b : a), rule[16:19])
dst[5] := SELECT16((mask.bits[5] ? b : a), rule[20:23])
dst[6] := SELECT16((mask.bits[6] ? b : a), rule[24:27])
dst[7] := SELECT16((mask.bits[7] ? b : a), rule[28:31])
dst[8] := SELECT16((mask.bits[8] ? b : a), rule[32:35])
dst[9] := SELECT16((mask.bits[9] ? b : a), rule[36:39])
dst[10] := SELECT16((mask.bits[10] ? b : a), rule[40:43])
dst[11] := SELECT16((mask.bits[11] ? b : a), rule[44:47])
dst[12] := SELECT16((mask.bits[12] ? b : a), rule[48:51])
dst[13] := SELECT16((mask.bits[13] ? b : a), rule[52:55])
dst[14] := SELECT16((mask.bits[14] ? b : a), rule[56:59])
dst[15] := SELECT16((mask.bits[15] ? b : a), rule[60:63])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle16 ( v16i  a,
v16i  b,
uint_fast64_t  rule,
uint_fast16_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 16 blocks of 1 elements.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16((mask.bits[0] ? b : a), rule[0:3])
dst[1] := SELECT16((mask.bits[1] ? b : a), rule[4:7])
dst[2] := SELECT16((mask.bits[2] ? b : a), rule[8:11])
dst[3] := SELECT16((mask.bits[3] ? b : a), rule[12:15])
dst[4] := SELECT16((mask.bits[4] ? b : a), rule[16:19])
dst[5] := SELECT16((mask.bits[5] ? b : a), rule[20:23])
dst[6] := SELECT16((mask.bits[6] ? b : a), rule[24:27])
dst[7] := SELECT16((mask.bits[7] ? b : a), rule[28:31])
dst[8] := SELECT16((mask.bits[8] ? b : a), rule[32:35])
dst[9] := SELECT16((mask.bits[9] ? b : a), rule[36:39])
dst[10] := SELECT16((mask.bits[10] ? b : a), rule[40:43])
dst[11] := SELECT16((mask.bits[11] ? b : a), rule[44:47])
dst[12] := SELECT16((mask.bits[12] ? b : a), rule[48:51])
dst[13] := SELECT16((mask.bits[13] ? b : a), rule[52:55])
dst[14] := SELECT16((mask.bits[14] ? b : a), rule[56:59])
dst[15] := SELECT16((mask.bits[15] ? b : a), rule[60:63])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2d v2d_fshuffle2x1 ( v2d  a,
v2d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v2d input vector
bsecond v2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2f v2f_fshuffle2x1 ( v2f  a,
v2f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v2f input vector
bsecond v2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2i v2i_fshuffle2x1 ( v2i  a,
v2i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v2i input vector
bsecond v2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2l v2l_fshuffle2x1 ( v2l  a,
v2l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 1 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 0
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v2l input vector
bsecond v2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4d v4d_fshuffle2x2 ( v4d  a,
v4d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4f v4f_fshuffle2x2 ( v4f  a,
v4f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4i v4i_fshuffle2x2 ( v4i  a,
v4i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4l v4l_fshuffle2x2 ( v4l  a,
v4l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 2 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 1
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8d v8d_fshuffle2x4 ( v8d  a,
v8d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8f v8f_fshuffle2x4 ( v8f  a,
v8f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8i v8i_fshuffle2x4 ( v8i  a,
v8i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8l v8l_fshuffle2x4 ( v8l  a,
v8l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 4 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 3
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle2x8 ( v16f  a,
v16f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 8 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 7
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle2x8 ( v16i  a,
v16i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 2 elements with the same rule for every 8 blocks of 2 elements.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
for j from 0 to 7
i = j*2
dst[i] := SELECT2((mask.bits[i] ? a[i:i+1] : b[i:i+1]), rule[0])
dst[i+1] := SELECT2((mask.bits[i+1] ? a[i:i+1] : b[i:i+1]), rule[1])
endfor
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4d v4d_fshuffle4x1 ( v4d  a,
v4d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4f v4f_fshuffle4x1 ( v4f  a,
v4f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4i v4i_fshuffle4x1 ( v4i  a,
v4i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4l v4l_fshuffle4x1 ( v4l  a,
v4l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 1 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 0
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8d v8d_fshuffle4x2 ( v8d  a,
v8d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8f v8f_fshuffle4x2 ( v8f  a,
v8f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8i v8i_fshuffle4x2 ( v8i  a,
v8i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8l v8l_fshuffle4x2 ( v8l  a,
v8l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 2 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 1
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle4x4 ( v16f  a,
v16f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 4 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 3
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle4x4 ( v16i  a,
v16i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 4 elements with the same rule for every 4 blocks of 4 elements.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
for j from 0 to 3
i = j*4
dst[i] := SELECT4((mask.bits[i] ? a[i:i+3] : b[i:i+3]), rule[0:1])
dst[i+1] := SELECT4((mask.bits[i+1] ? a[i:i+3] : b[i:i+3]), rule[2:3])
dst[i+2] := SELECT4((mask.bits[i+2] ? a[i:i+3] : b[i:i+3]), rule[4:5])
dst[i+3] := SELECT4((mask.bits[i+3] ? a[i:i+3] : b[i:i+3]), rule[6:7])
endfor
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8d v8d_fshuffle8x1 ( v8d  a,
v8d  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8d vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8((mask.bits[i] ? a[i:i+7] : b[i:i+7]), rule[0:2])
dst[i+1] := SELECT8((mask.bits[i+1] ? a[i:i+7] : b[i:i+7]), rule[3:5])
dst[i+2] := SELECT8((mask.bits[i+2] ? a[i:i+7] : b[i:i+7]), rule[6:8])
dst[i+3] := SELECT8((mask.bits[i+3] ? a[i:i+7] : b[i:i+7]), rule[9:11])
dst[i+4] := SELECT8((mask.bits[i+4] ? a[i:i+7] : b[i:i+7]), rule[12:14])
dst[i+5] := SELECT8((mask.bits[i+5] ? a[i:i+7] : b[i:i+7]), rule[15:17])
dst[i+6] := SELECT8((mask.bits[i+6] ? a[i:i+7] : b[i:i+7]), rule[18:20])
dst[i+7] := SELECT8((mask.bits[i+7] ? a[i:i+7] : b[i:i+7]), rule[21:23])
endfor
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8f v8f_fshuffle8x1 ( v8f  a,
v8f  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8((mask.bits[i] ? a[i:i+7] : b[i:i+7]), rule[0:2])
dst[i+1] := SELECT8((mask.bits[i+1] ? a[i:i+7] : b[i:i+7]), rule[3:5])
dst[i+2] := SELECT8((mask.bits[i+2] ? a[i:i+7] : b[i:i+7]), rule[6:8])
dst[i+3] := SELECT8((mask.bits[i+3] ? a[i:i+7] : b[i:i+7]), rule[9:11])
dst[i+4] := SELECT8((mask.bits[i+4] ? a[i:i+7] : b[i:i+7]), rule[12:14])
dst[i+5] := SELECT8((mask.bits[i+5] ? a[i:i+7] : b[i:i+7]), rule[15:17])
dst[i+6] := SELECT8((mask.bits[i+6] ? a[i:i+7] : b[i:i+7]), rule[18:20])
dst[i+7] := SELECT8((mask.bits[i+7] ? a[i:i+7] : b[i:i+7]), rule[21:23])
endfor
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8i v8i_fshuffle8x1 ( v8i  a,
v8i  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8((mask.bits[i] ? a[i:i+7] : b[i:i+7]), rule[0:2])
dst[i+1] := SELECT8((mask.bits[i+1] ? a[i:i+7] : b[i:i+7]), rule[3:5])
dst[i+2] := SELECT8((mask.bits[i+2] ? a[i:i+7] : b[i:i+7]), rule[6:8])
dst[i+3] := SELECT8((mask.bits[i+3] ? a[i:i+7] : b[i:i+7]), rule[9:11])
dst[i+4] := SELECT8((mask.bits[i+4] ? a[i:i+7] : b[i:i+7]), rule[12:14])
dst[i+5] := SELECT8((mask.bits[i+5] ? a[i:i+7] : b[i:i+7]), rule[15:17])
dst[i+6] := SELECT8((mask.bits[i+6] ? a[i:i+7] : b[i:i+7]), rule[18:20])
dst[i+7] := SELECT8((mask.bits[i+7] ? a[i:i+7] : b[i:i+7]), rule[21:23])
endfor
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8l v8l_fshuffle8x1 ( v8l  a,
v8l  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8l vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 elements with the same rule for every 1 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 0
i = j*8
dst[i] := SELECT8((mask.bits[i] ? a[i:i+7] : b[i:i+7]), rule[0:2])
dst[i+1] := SELECT8((mask.bits[i+1] ? a[i:i+7] : b[i:i+7]), rule[3:5])
dst[i+2] := SELECT8((mask.bits[i+2] ? a[i:i+7] : b[i:i+7]), rule[6:8])
dst[i+3] := SELECT8((mask.bits[i+3] ? a[i:i+7] : b[i:i+7]), rule[9:11])
dst[i+4] := SELECT8((mask.bits[i+4] ? a[i:i+7] : b[i:i+7]), rule[12:14])
dst[i+5] := SELECT8((mask.bits[i+5] ? a[i:i+7] : b[i:i+7]), rule[15:17])
dst[i+6] := SELECT8((mask.bits[i+6] ? a[i:i+7] : b[i:i+7]), rule[18:20])
dst[i+7] := SELECT8((mask.bits[i+7] ? a[i:i+7] : b[i:i+7]), rule[21:23])
endfor
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle8x2 ( v16f  a,
v16f  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 elements with the same rule for every 2 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 1
i = j*8
dst[i] := SELECT8((mask.bits[i] ? a[i:i+7] : b[i:i+7]), rule[0:2])
dst[i+1] := SELECT8((mask.bits[i+1] ? a[i:i+7] : b[i:i+7]), rule[3:5])
dst[i+2] := SELECT8((mask.bits[i+2] ? a[i:i+7] : b[i:i+7]), rule[6:8])
dst[i+3] := SELECT8((mask.bits[i+3] ? a[i:i+7] : b[i:i+7]), rule[9:11])
dst[i+4] := SELECT8((mask.bits[i+4] ? a[i:i+7] : b[i:i+7]), rule[12:14])
dst[i+5] := SELECT8((mask.bits[i+5] ? a[i:i+7] : b[i:i+7]), rule[15:17])
dst[i+6] := SELECT8((mask.bits[i+6] ? a[i:i+7] : b[i:i+7]), rule[18:20])
dst[i+7] := SELECT8((mask.bits[i+7] ? a[i:i+7] : b[i:i+7]), rule[21:23])
endfor
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle8x2 ( v16i  a,
v16i  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 8 elements with the same rule for every 2 blocks of 8 elements.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
for j from 0 to 1
i = j*8
dst[i] := SELECT8((mask.bits[i] ? a[i:i+7] : b[i:i+7]), rule[0:2])
dst[i+1] := SELECT8((mask.bits[i+1] ? a[i:i+7] : b[i:i+7]), rule[3:5])
dst[i+2] := SELECT8((mask.bits[i+2] ? a[i:i+7] : b[i:i+7]), rule[6:8])
dst[i+3] := SELECT8((mask.bits[i+3] ? a[i:i+7] : b[i:i+7]), rule[9:11])
dst[i+4] := SELECT8((mask.bits[i+4] ? a[i:i+7] : b[i:i+7]), rule[12:14])
dst[i+5] := SELECT8((mask.bits[i+5] ? a[i:i+7] : b[i:i+7]), rule[15:17])
dst[i+6] := SELECT8((mask.bits[i+6] ? a[i:i+7] : b[i:i+7]), rule[18:20])
dst[i+7] := SELECT8((mask.bits[i+7] ? a[i:i+7] : b[i:i+7]), rule[21:23])
endfor
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle16x1 ( v16f  a,
v16f  b,
uint_fast64_t  rule,
uint_fast16_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 16 elements with the same rule for every 1 blocks of 16 elements.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
for j from 0 to 0
i = j*16
dst[i] := SELECT16((mask.bits[i] ? a[i:i+15] : b[i:i+15]), rule[0:3])
dst[i+1] := SELECT16((mask.bits[i+1] ? a[i:i+15] : b[i:i+15]), rule[4:7])
dst[i+2] := SELECT16((mask.bits[i+2] ? a[i:i+15] : b[i:i+15]), rule[8:11])
dst[i+3] := SELECT16((mask.bits[i+3] ? a[i:i+15] : b[i:i+15]), rule[12:15])
dst[i+4] := SELECT16((mask.bits[i+4] ? a[i:i+15] : b[i:i+15]), rule[16:19])
dst[i+5] := SELECT16((mask.bits[i+5] ? a[i:i+15] : b[i:i+15]), rule[20:23])
dst[i+6] := SELECT16((mask.bits[i+6] ? a[i:i+15] : b[i:i+15]), rule[24:27])
dst[i+7] := SELECT16((mask.bits[i+7] ? a[i:i+15] : b[i:i+15]), rule[28:31])
dst[i+8] := SELECT16((mask.bits[i+8] ? a[i:i+15] : b[i:i+15]), rule[32:35])
dst[i+9] := SELECT16((mask.bits[i+9] ? a[i:i+15] : b[i:i+15]), rule[36:39])
dst[i+10] := SELECT16((mask.bits[i+10] ? a[i:i+15] : b[i:i+15]), rule[40:43])
dst[i+11] := SELECT16((mask.bits[i+11] ? a[i:i+15] : b[i:i+15]), rule[44:47])
dst[i+12] := SELECT16((mask.bits[i+12] ? a[i:i+15] : b[i:i+15]), rule[48:51])
dst[i+13] := SELECT16((mask.bits[i+13] ? a[i:i+15] : b[i:i+15]), rule[52:55])
dst[i+14] := SELECT16((mask.bits[i+14] ? a[i:i+15] : b[i:i+15]), rule[56:59])
dst[i+15] := SELECT16((mask.bits[i+15] ? a[i:i+15] : b[i:i+15]), rule[60:63])
endfor
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle16x1 ( v16i  a,
v16i  b,
uint_fast64_t  rule,
uint_fast16_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle and the blend are done by moving 16 elements with the same rule for every 1 blocks of 16 elements.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
for j from 0 to 0
i = j*16
dst[i] := SELECT16((mask.bits[i] ? a[i:i+15] : b[i:i+15]), rule[0:3])
dst[i+1] := SELECT16((mask.bits[i+1] ? a[i:i+15] : b[i:i+15]), rule[4:7])
dst[i+2] := SELECT16((mask.bits[i+2] ? a[i:i+15] : b[i:i+15]), rule[8:11])
dst[i+3] := SELECT16((mask.bits[i+3] ? a[i:i+15] : b[i:i+15]), rule[12:15])
dst[i+4] := SELECT16((mask.bits[i+4] ? a[i:i+15] : b[i:i+15]), rule[16:19])
dst[i+5] := SELECT16((mask.bits[i+5] ? a[i:i+15] : b[i:i+15]), rule[20:23])
dst[i+6] := SELECT16((mask.bits[i+6] ? a[i:i+15] : b[i:i+15]), rule[24:27])
dst[i+7] := SELECT16((mask.bits[i+7] ? a[i:i+15] : b[i:i+15]), rule[28:31])
dst[i+8] := SELECT16((mask.bits[i+8] ? a[i:i+15] : b[i:i+15]), rule[32:35])
dst[i+9] := SELECT16((mask.bits[i+9] ? a[i:i+15] : b[i:i+15]), rule[36:39])
dst[i+10] := SELECT16((mask.bits[i+10] ? a[i:i+15] : b[i:i+15]), rule[40:43])
dst[i+11] := SELECT16((mask.bits[i+11] ? a[i:i+15] : b[i:i+15]), rule[44:47])
dst[i+12] := SELECT16((mask.bits[i+12] ? a[i:i+15] : b[i:i+15]), rule[48:51])
dst[i+13] := SELECT16((mask.bits[i+13] ? a[i:i+15] : b[i:i+15]), rule[52:55])
dst[i+14] := SELECT16((mask.bits[i+14] ? a[i:i+15] : b[i:i+15]), rule[56:59])
dst[i+15] := SELECT16((mask.bits[i+15] ? a[i:i+15] : b[i:i+15]), rule[60:63])
endfor
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v1d v1d_hshuffle ( v1d  a,
v1d  b,
uint_fast8_t  rule 
)
related

Shuffles v1d vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1(b, rule[])
Parameters
afirst v1d input vector
bsecond v1d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v1f v1f_hshuffle ( v1f  a,
v1f  b,
uint_fast8_t  rule 
)
related

Shuffles v1f vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1(b, rule[])
Parameters
afirst v1f input vector
bsecond v1f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v1i v1i_hshuffle ( v1i  a,
v1i  b,
uint_fast8_t  rule 
)
related

Shuffles v1i vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1(b, rule[])
Parameters
afirst v1i input vector
bsecond v1i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v1l v1l_hshuffle ( v1l  a,
v1l  b,
uint_fast8_t  rule 
)
related

Shuffles v1l vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1(b, rule[])
Parameters
afirst v1l input vector
bsecond v1l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2d v2d_hshuffle ( v2d  a,
v2d  b,
uint_fast8_t  rule 
)
related

Shuffles v2d vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(b, rule[1])
Parameters
afirst v2d input vector
bsecond v2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2f v2f_hshuffle ( v2f  a,
v2f  b,
uint_fast8_t  rule 
)
related

Shuffles v2f vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(b, rule[1])
Parameters
afirst v2f input vector
bsecond v2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2i v2i_hshuffle ( v2i  a,
v2i  b,
uint_fast8_t  rule 
)
related

Shuffles v2i vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(b, rule[1])
Parameters
afirst v2i input vector
bsecond v2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2l v2l_hshuffle ( v2l  a,
v2l  b,
uint_fast8_t  rule 
)
related

Shuffles v2l vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(b, rule[1])
Parameters
afirst v2l input vector
bsecond v2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_hshuffle ( v4d  a,
v4d  b,
uint_fast8_t  rule 
)
related

Shuffles v4d vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(b, rule[4:5])
dst[3] := SELECT4(b, rule[6:7])
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_hshuffle ( v4f  a,
v4f  b,
uint_fast8_t  rule 
)
related

Shuffles v4f vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(b, rule[4:5])
dst[3] := SELECT4(b, rule[6:7])
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_hshuffle ( v4i  a,
v4i  b,
uint_fast8_t  rule 
)
related

Shuffles v4i vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(b, rule[4:5])
dst[3] := SELECT4(b, rule[6:7])
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_hshuffle ( v4l  a,
v4l  b,
uint_fast8_t  rule 
)
related

Shuffles v4l vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(b, rule[4:5])
dst[3] := SELECT4(b, rule[6:7])
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_hshuffle ( v8d  a,
v8d  b,
uint_fast32_t  rule 
)
related

Shuffles v8d vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(b, rule[12:14])
dst[5] := SELECT8(b, rule[15:17])
dst[6] := SELECT8(b, rule[18:20])
dst[7] := SELECT8(b, rule[21:23])
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_hshuffle ( v8f  a,
v8f  b,
uint_fast32_t  rule 
)
related

Shuffles v8f vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(b, rule[12:14])
dst[5] := SELECT8(b, rule[15:17])
dst[6] := SELECT8(b, rule[18:20])
dst[7] := SELECT8(b, rule[21:23])
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_hshuffle ( v8i  a,
v8i  b,
uint_fast32_t  rule 
)
related

Shuffles v8i vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(b, rule[12:14])
dst[5] := SELECT8(b, rule[15:17])
dst[6] := SELECT8(b, rule[18:20])
dst[7] := SELECT8(b, rule[21:23])
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_hshuffle ( v8l  a,
v8l  b,
uint_fast32_t  rule 
)
related

Shuffles v8l vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(b, rule[12:14])
dst[5] := SELECT8(b, rule[15:17])
dst[6] := SELECT8(b, rule[18:20])
dst[7] := SELECT8(b, rule[21:23])
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_hshuffle ( v16f  a,
v16f  b,
uint_fast64_t  rule 
)
related

Shuffles v16f vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16(a, rule[0:3])
dst[1] := SELECT16(a, rule[4:7])
dst[2] := SELECT16(a, rule[8:11])
dst[3] := SELECT16(a, rule[12:15])
dst[4] := SELECT16(a, rule[16:19])
dst[5] := SELECT16(a, rule[20:23])
dst[6] := SELECT16(a, rule[24:27])
dst[7] := SELECT16(a, rule[28:31])
dst[8] := SELECT16(b, rule[32:35])
dst[9] := SELECT16(b, rule[36:39])
dst[10] := SELECT16(b, rule[40:43])
dst[11] := SELECT16(b, rule[44:47])
dst[12] := SELECT16(b, rule[48:51])
dst[13] := SELECT16(b, rule[52:55])
dst[14] := SELECT16(b, rule[56:59])
dst[15] := SELECT16(b, rule[60:63])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_hshuffle ( v16i  a,
v16i  b,
uint_fast64_t  rule 
)
related

Shuffles v16i vectors a and b together using the control in rule. The shuffle is done on whole vectors.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16(a, rule[0:3])
dst[1] := SELECT16(a, rule[4:7])
dst[2] := SELECT16(a, rule[8:11])
dst[3] := SELECT16(a, rule[12:15])
dst[4] := SELECT16(a, rule[16:19])
dst[5] := SELECT16(a, rule[20:23])
dst[6] := SELECT16(a, rule[24:27])
dst[7] := SELECT16(a, rule[28:31])
dst[8] := SELECT16(b, rule[32:35])
dst[9] := SELECT16(b, rule[36:39])
dst[10] := SELECT16(b, rule[40:43])
dst[11] := SELECT16(b, rule[44:47])
dst[12] := SELECT16(b, rule[48:51])
dst[13] := SELECT16(b, rule[52:55])
dst[14] := SELECT16(b, rule[56:59])
dst[15] := SELECT16(b, rule[60:63])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v1d v1d_permute ( v1d  a,
uint_fast8_t  rule 
)
related

Shuffles the v1d vector a using the control in rule. The shuffle is done by moving 1 elements with the same rule for every 1 blocks of 1 elements. The shuffle is done on the whole vector.

Functionally equivalent to v1d_hshuffle(a, a, rule)

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1(a, rule[])
See Also
v1d_hshuffle1x1(v1d a, v1d b, uint_fast8_t rule)
Parameters
av1d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v1f v1f_permute ( v1f  a,
uint_fast8_t  rule 
)
related

Shuffles the v1f vector a using the control in rule. The shuffle is done by moving 1 elements with the same rule for every 1 blocks of 1 elements. The shuffle is done on the whole vector.

Functionally equivalent to v1f_hshuffle(a, a, rule)

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1(a, rule[])
See Also
v1f_hshuffle1x1(v1f a, v1f b, uint_fast8_t rule)
Parameters
av1f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v1i v1i_permute ( v1i  a,
uint_fast8_t  rule 
)
related

Shuffles the v1i vector a using the control in rule. The shuffle is done by moving 1 elements with the same rule for every 1 blocks of 1 elements. The shuffle is done on the whole vector.

Functionally equivalent to v1i_hshuffle(a, a, rule)

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1(a, rule[])
See Also
v1i_hshuffle1x1(v1i a, v1i b, uint_fast8_t rule)
Parameters
av1i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v1l v1l_permute ( v1l  a,
uint_fast8_t  rule 
)
related

Shuffles the v1l vector a using the control in rule. The shuffle is done by moving 1 elements with the same rule for every 1 blocks of 1 elements. The shuffle is done on the whole vector.

Functionally equivalent to v1l_hshuffle(a, a, rule)

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1(a, rule[])
See Also
v1l_hshuffle1x1(v1l a, v1l b, uint_fast8_t rule)
Parameters
av1l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2d v2d_permute ( v2d  a,
uint_fast8_t  rule 
)
related

Shuffles the v2d vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements. The shuffle is done on the whole vector.

Functionally equivalent to v2d_hshuffle(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(a, rule[1])
See Also
v2d_hshuffle2x1(v2d a, v2d b, uint_fast8_t rule)
Parameters
av2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2f v2f_permute ( v2f  a,
uint_fast8_t  rule 
)
related

Shuffles the v2f vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements. The shuffle is done on the whole vector.

Functionally equivalent to v2f_hshuffle(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(a, rule[1])
See Also
v2f_hshuffle2x1(v2f a, v2f b, uint_fast8_t rule)
Parameters
av2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2i v2i_permute ( v2i  a,
uint_fast8_t  rule 
)
related

Shuffles the v2i vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements. The shuffle is done on the whole vector.

Functionally equivalent to v2i_hshuffle(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(a, rule[1])
See Also
v2i_hshuffle2x1(v2i a, v2i b, uint_fast8_t rule)
Parameters
av2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v2l v2l_permute ( v2l  a,
uint_fast8_t  rule 
)
related

Shuffles the v2l vector a using the control in rule. The shuffle is done by moving 2 elements with the same rule for every 1 blocks of 2 elements. The shuffle is done on the whole vector.

Functionally equivalent to v2l_hshuffle(a, a, rule)

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2(a, rule[0])
dst[1] := SELECT2(a, rule[1])
See Also
v2l_hshuffle2x1(v2l a, v2l b, uint_fast8_t rule)
Parameters
av2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4d v4d_permute ( v4d  a,
uint_fast8_t  rule 
)
related

Shuffles the v4d vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements. The shuffle is done on the whole vector.

Functionally equivalent to v4d_hshuffle(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(a, rule[4:5])
dst[3] := SELECT4(a, rule[6:7])
See Also
v4d_hshuffle4x1(v4d a, v4d b, uint_fast8_t rule)
Parameters
av4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4f v4f_permute ( v4f  a,
uint_fast8_t  rule 
)
related

Shuffles the v4f vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements. The shuffle is done on the whole vector.

Functionally equivalent to v4f_hshuffle(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(a, rule[4:5])
dst[3] := SELECT4(a, rule[6:7])
See Also
v4f_hshuffle4x1(v4f a, v4f b, uint_fast8_t rule)
Parameters
av4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4i v4i_permute ( v4i  a,
uint_fast8_t  rule 
)
related

Shuffles the v4i vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements. The shuffle is done on the whole vector.

Functionally equivalent to v4i_hshuffle(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(a, rule[4:5])
dst[3] := SELECT4(a, rule[6:7])
See Also
v4i_hshuffle4x1(v4i a, v4i b, uint_fast8_t rule)
Parameters
av4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v4l v4l_permute ( v4l  a,
uint_fast8_t  rule 
)
related

Shuffles the v4l vector a using the control in rule. The shuffle is done by moving 4 elements with the same rule for every 1 blocks of 4 elements. The shuffle is done on the whole vector.

Functionally equivalent to v4l_hshuffle(a, a, rule)

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4(a, rule[0:1])
dst[1] := SELECT4(a, rule[2:3])
dst[2] := SELECT4(a, rule[4:5])
dst[3] := SELECT4(a, rule[6:7])
See Also
v4l_hshuffle4x1(v4l a, v4l b, uint_fast8_t rule)
Parameters
av4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8d v8d_permute ( v8d  a,
uint_fast32_t  rule 
)
related

Shuffles the v8d vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements. The shuffle is done on the whole vector.

Functionally equivalent to v8d_hshuffle(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(a, rule[12:14])
dst[5] := SELECT8(a, rule[15:17])
dst[6] := SELECT8(a, rule[18:20])
dst[7] := SELECT8(a, rule[21:23])
See Also
v8d_hshuffle8x1(v8d a, v8d b, uint_fast32_t rule)
Parameters
av8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8f v8f_permute ( v8f  a,
uint_fast32_t  rule 
)
related

Shuffles the v8f vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements. The shuffle is done on the whole vector.

Functionally equivalent to v8f_hshuffle(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(a, rule[12:14])
dst[5] := SELECT8(a, rule[15:17])
dst[6] := SELECT8(a, rule[18:20])
dst[7] := SELECT8(a, rule[21:23])
See Also
v8f_hshuffle8x1(v8f a, v8f b, uint_fast32_t rule)
Parameters
av8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8i v8i_permute ( v8i  a,
uint_fast32_t  rule 
)
related

Shuffles the v8i vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements. The shuffle is done on the whole vector.

Functionally equivalent to v8i_hshuffle(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(a, rule[12:14])
dst[5] := SELECT8(a, rule[15:17])
dst[6] := SELECT8(a, rule[18:20])
dst[7] := SELECT8(a, rule[21:23])
See Also
v8i_hshuffle8x1(v8i a, v8i b, uint_fast32_t rule)
Parameters
av8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v8l v8l_permute ( v8l  a,
uint_fast32_t  rule 
)
related

Shuffles the v8l vector a using the control in rule. The shuffle is done by moving 8 elements with the same rule for every 1 blocks of 8 elements. The shuffle is done on the whole vector.

Functionally equivalent to v8l_hshuffle(a, a, rule)

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8(a, rule[0:2])
dst[1] := SELECT8(a, rule[3:5])
dst[2] := SELECT8(a, rule[6:8])
dst[3] := SELECT8(a, rule[9:11])
dst[4] := SELECT8(a, rule[12:14])
dst[5] := SELECT8(a, rule[15:17])
dst[6] := SELECT8(a, rule[18:20])
dst[7] := SELECT8(a, rule[21:23])
See Also
v8l_hshuffle8x1(v8l a, v8l b, uint_fast32_t rule)
Parameters
av8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16f v16f_permute ( v16f  a,
uint_fast64_t  rule 
)
related

Shuffles the v16f vector a using the control in rule. The shuffle is done by moving 16 elements with the same rule for every 1 blocks of 16 elements. The shuffle is done on the whole vector.

Functionally equivalent to v16f_hshuffle(a, a, rule)

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16(a, rule[0:3])
dst[1] := SELECT16(a, rule[4:7])
dst[2] := SELECT16(a, rule[8:11])
dst[3] := SELECT16(a, rule[12:15])
dst[4] := SELECT16(a, rule[16:19])
dst[5] := SELECT16(a, rule[20:23])
dst[6] := SELECT16(a, rule[24:27])
dst[7] := SELECT16(a, rule[28:31])
dst[8] := SELECT16(a, rule[32:35])
dst[9] := SELECT16(a, rule[36:39])
dst[10] := SELECT16(a, rule[40:43])
dst[11] := SELECT16(a, rule[44:47])
dst[12] := SELECT16(a, rule[48:51])
dst[13] := SELECT16(a, rule[52:55])
dst[14] := SELECT16(a, rule[56:59])
dst[15] := SELECT16(a, rule[60:63])
See Also
v16f_hshuffle16x1(v16f a, v16f b, uint_fast64_t rule)
Parameters
av16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v16i v16i_permute ( v16i  a,
uint_fast64_t  rule 
)
related

Shuffles the v16i vector a using the control in rule. The shuffle is done by moving 16 elements with the same rule for every 1 blocks of 16 elements. The shuffle is done on the whole vector.

Functionally equivalent to v16i_hshuffle(a, a, rule)

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16(a, rule[0:3])
dst[1] := SELECT16(a, rule[4:7])
dst[2] := SELECT16(a, rule[8:11])
dst[3] := SELECT16(a, rule[12:15])
dst[4] := SELECT16(a, rule[16:19])
dst[5] := SELECT16(a, rule[20:23])
dst[6] := SELECT16(a, rule[24:27])
dst[7] := SELECT16(a, rule[28:31])
dst[8] := SELECT16(a, rule[32:35])
dst[9] := SELECT16(a, rule[36:39])
dst[10] := SELECT16(a, rule[40:43])
dst[11] := SELECT16(a, rule[44:47])
dst[12] := SELECT16(a, rule[48:51])
dst[13] := SELECT16(a, rule[52:55])
dst[14] := SELECT16(a, rule[56:59])
dst[15] := SELECT16(a, rule[60:63])
See Also
v16i_hshuffle16x1(v16i a, v16i b, uint_fast64_t rule)
Parameters
av16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
Returns
shuffled vector
v1d v1d_fshuffle ( v1d  a,
v1d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v1d vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1((mask.bits[0] ? b : a), rule[])
Parameters
afirst v1d input vector
bsecond v1d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v1f v1f_fshuffle ( v1f  a,
v1f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v1f vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1((mask.bits[0] ? b : a), rule[])
Parameters
afirst v1f input vector
bsecond v1f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v1i v1i_fshuffle ( v1i  a,
v1i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v1i vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1((mask.bits[0] ? b : a), rule[])
Parameters
afirst v1i input vector
bsecond v1i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v1l v1l_fshuffle ( v1l  a,
v1l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v1l vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT1(_src, _ctrl) {
case _ctrl.bits[]
0x0: _tmp := _src[0]
endcase
return _tmp
}
dst[0] := SELECT1((mask.bits[0] ? b : a), rule[])
Parameters
afirst v1l input vector
bsecond v1l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2d v2d_fshuffle ( v2d  a,
v2d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2d vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[1] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v2d input vector
bsecond v2d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2f v2f_fshuffle ( v2f  a,
v2f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2f vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[1] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v2f input vector
bsecond v2f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2i v2i_fshuffle ( v2i  a,
v2i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2i vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[1] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v2i input vector
bsecond v2i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v2l v2l_fshuffle ( v2l  a,
v2l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v2l vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT2(_src, _ctrl) {
case _ctrl.bits[0]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
endcase
return _tmp
}
dst[0] := SELECT2((mask.bits[0] ? b : a), rule[0])
dst[1] := SELECT2((mask.bits[1] ? b : a), rule[1])
Parameters
afirst v2l input vector
bsecond v2l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4d v4d_fshuffle ( v4d  a,
v4d  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4d vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[1] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[2] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[3] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v4d input vector
bsecond v4d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4f v4f_fshuffle ( v4f  a,
v4f  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4f vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[1] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[2] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[3] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v4f input vector
bsecond v4f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4i v4i_fshuffle ( v4i  a,
v4i  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4i vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[1] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[2] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[3] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v4i input vector
bsecond v4i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v4l v4l_fshuffle ( v4l  a,
v4l  b,
uint_fast8_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v4l vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT4(_src, _ctrl) {
case _ctrl.bits[0:1]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
endcase
return _tmp
}
dst[0] := SELECT4((mask.bits[0] ? b : a), rule[0:1])
dst[1] := SELECT4((mask.bits[1] ? b : a), rule[2:3])
dst[2] := SELECT4((mask.bits[2] ? b : a), rule[4:5])
dst[3] := SELECT4((mask.bits[3] ? b : a), rule[6:7])
Parameters
afirst v4l input vector
bsecond v4l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8d v8d_fshuffle ( v8d  a,
v8d  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8d vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[1] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[2] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[3] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[4] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[5] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[6] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[7] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v8d input vector
bsecond v8d input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8f v8f_fshuffle ( v8f  a,
v8f  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8f vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[1] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[2] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[3] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[4] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[5] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[6] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[7] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v8f input vector
bsecond v8f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8i v8i_fshuffle ( v8i  a,
v8i  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8i vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[1] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[2] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[3] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[4] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[5] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[6] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[7] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v8i input vector
bsecond v8i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v8l v8l_fshuffle ( v8l  a,
v8l  b,
uint_fast32_t  rule,
uint_fast8_t  mask 
)
related

Fully shuffles v8l vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT8(_src, _ctrl) {
case _ctrl.bits[0:2]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
endcase
return _tmp
}
dst[0] := SELECT8((mask.bits[0] ? b : a), rule[0:2])
dst[1] := SELECT8((mask.bits[1] ? b : a), rule[3:5])
dst[2] := SELECT8((mask.bits[2] ? b : a), rule[6:8])
dst[3] := SELECT8((mask.bits[3] ? b : a), rule[9:11])
dst[4] := SELECT8((mask.bits[4] ? b : a), rule[12:14])
dst[5] := SELECT8((mask.bits[5] ? b : a), rule[15:17])
dst[6] := SELECT8((mask.bits[6] ? b : a), rule[18:20])
dst[7] := SELECT8((mask.bits[7] ? b : a), rule[21:23])
Parameters
afirst v8l input vector
bsecond v8l input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16f v16f_fshuffle ( v16f  a,
v16f  b,
uint_fast64_t  rule,
uint_fast16_t  mask 
)
related

Fully shuffles v16f vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16((mask.bits[0] ? b : a), rule[0:3])
dst[1] := SELECT16((mask.bits[1] ? b : a), rule[4:7])
dst[2] := SELECT16((mask.bits[2] ? b : a), rule[8:11])
dst[3] := SELECT16((mask.bits[3] ? b : a), rule[12:15])
dst[4] := SELECT16((mask.bits[4] ? b : a), rule[16:19])
dst[5] := SELECT16((mask.bits[5] ? b : a), rule[20:23])
dst[6] := SELECT16((mask.bits[6] ? b : a), rule[24:27])
dst[7] := SELECT16((mask.bits[7] ? b : a), rule[28:31])
dst[8] := SELECT16((mask.bits[8] ? b : a), rule[32:35])
dst[9] := SELECT16((mask.bits[9] ? b : a), rule[36:39])
dst[10] := SELECT16((mask.bits[10] ? b : a), rule[40:43])
dst[11] := SELECT16((mask.bits[11] ? b : a), rule[44:47])
dst[12] := SELECT16((mask.bits[12] ? b : a), rule[48:51])
dst[13] := SELECT16((mask.bits[13] ? b : a), rule[52:55])
dst[14] := SELECT16((mask.bits[14] ? b : a), rule[56:59])
dst[15] := SELECT16((mask.bits[15] ? b : a), rule[60:63])
Parameters
afirst v16f input vector
bsecond v16f input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector
v16i v16i_fshuffle ( v16i  a,
v16i  b,
uint_fast64_t  rule,
uint_fast16_t  mask 
)
related

Fully shuffles v16i vectors a and b using the control in rule, and blends them together using mask. The shuffle is done on whole vectors.

Operation
function SELECT16(_src, _ctrl) {
case _ctrl.bits[0:3]
0x0: _tmp := _src[0]
0x1: _tmp := _src[1]
0x2: _tmp := _src[2]
0x3: _tmp := _src[3]
0x4: _tmp := _src[4]
0x5: _tmp := _src[5]
0x6: _tmp := _src[6]
0x7: _tmp := _src[7]
0x8: _tmp := _src[8]
0x9: _tmp := _src[9]
0xA: _tmp := _src[10]
0xB: _tmp := _src[11]
0xC: _tmp := _src[12]
0xD: _tmp := _src[13]
0xE: _tmp := _src[14]
0xF: _tmp := _src[15]
endcase
return _tmp
}
dst[0] := SELECT16((mask.bits[0] ? b : a), rule[0:3])
dst[1] := SELECT16((mask.bits[1] ? b : a), rule[4:7])
dst[2] := SELECT16((mask.bits[2] ? b : a), rule[8:11])
dst[3] := SELECT16((mask.bits[3] ? b : a), rule[12:15])
dst[4] := SELECT16((mask.bits[4] ? b : a), rule[16:19])
dst[5] := SELECT16((mask.bits[5] ? b : a), rule[20:23])
dst[6] := SELECT16((mask.bits[6] ? b : a), rule[24:27])
dst[7] := SELECT16((mask.bits[7] ? b : a), rule[28:31])
dst[8] := SELECT16((mask.bits[8] ? b : a), rule[32:35])
dst[9] := SELECT16((mask.bits[9] ? b : a), rule[36:39])
dst[10] := SELECT16((mask.bits[10] ? b : a), rule[40:43])
dst[11] := SELECT16((mask.bits[11] ? b : a), rule[44:47])
dst[12] := SELECT16((mask.bits[12] ? b : a), rule[48:51])
dst[13] := SELECT16((mask.bits[13] ? b : a), rule[52:55])
dst[14] := SELECT16((mask.bits[14] ? b : a), rule[56:59])
dst[15] := SELECT16((mask.bits[15] ? b : a), rule[60:63])
Parameters
afirst v16i input vector
bsecond v16i input vector
ruleinteger controlling the shuffle. Must be an immediate!
maskinteger mask controlling the blend. Must be an immediate!
Returns
shuffled vector