blend functions

Functions
v1d	v1d_blend1 (v1d a, v1d b, uint_fast8_t mask)
	Creates a new v1d vector whose elements are from a and b choosed by mask. More...
v1f	v1f_blend1 (v1f a, v1f b, uint_fast8_t mask)
	Creates a new v1f vector whose elements are from a and b choosed by mask. More...
v1i	v1i_blend1 (v1i a, v1i b, uint_fast8_t mask)
	Creates a new v1i vector whose elements are from a and b choosed by mask. More...
v1l	v1l_blend1 (v1l a, v1l b, uint_fast8_t mask)
	Creates a new v1l vector whose elements are from a and b choosed by mask. More...
v2d	v2d_blend1 (v2d a, v2d b, uint_fast8_t mask)
	Creates a new v2d vector whose elements are from a and b choosed by mask. More...
v2f	v2f_blend1 (v2f a, v2f b, uint_fast8_t mask)
	Creates a new v2f vector whose elements are from a and b choosed by mask. More...
v2i	v2i_blend1 (v2i a, v2i b, uint_fast8_t mask)
	Creates a new v2i vector whose elements are from a and b choosed by mask. More...
v2l	v2l_blend1 (v2l a, v2l b, uint_fast8_t mask)
	Creates a new v2l vector whose elements are from a and b choosed by mask. More...
v4d	v4d_blend1 (v4d a, v4d b, uint_fast8_t mask)
	Creates a new v4d vector whose elements are from a and b choosed by mask. More...
v4f	v4f_blend1 (v4f a, v4f b, uint_fast8_t mask)
	Creates a new v4f vector whose elements are from a and b choosed by mask. More...
v4i	v4i_blend1 (v4i a, v4i b, uint_fast8_t mask)
	Creates a new v4i vector whose elements are from a and b choosed by mask. More...
v4l	v4l_blend1 (v4l a, v4l b, uint_fast8_t mask)
	Creates a new v4l vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend1 (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend1 (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend1 (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend1 (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend1 (v16f a, v16f b, uint_fast8_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend1 (v16i a, v16i b, uint_fast8_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v2d	v2d_blend2 (v2d a, v2d b, uint_fast8_t mask)
	Creates a new v2d vector whose elements are from a and b choosed by mask. More...
v2f	v2f_blend2 (v2f a, v2f b, uint_fast8_t mask)
	Creates a new v2f vector whose elements are from a and b choosed by mask. More...
v2i	v2i_blend2 (v2i a, v2i b, uint_fast8_t mask)
	Creates a new v2i vector whose elements are from a and b choosed by mask. More...
v2l	v2l_blend2 (v2l a, v2l b, uint_fast8_t mask)
	Creates a new v2l vector whose elements are from a and b choosed by mask. More...
v4d	v4d_blend2 (v4d a, v4d b, uint_fast8_t mask)
	Creates a new v4d vector whose elements are from a and b choosed by mask. More...
v4f	v4f_blend2 (v4f a, v4f b, uint_fast8_t mask)
	Creates a new v4f vector whose elements are from a and b choosed by mask. More...
v4i	v4i_blend2 (v4i a, v4i b, uint_fast8_t mask)
	Creates a new v4i vector whose elements are from a and b choosed by mask. More...
v4l	v4l_blend2 (v4l a, v4l b, uint_fast8_t mask)
	Creates a new v4l vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend2 (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend2 (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend2 (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend2 (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend2 (v16f a, v16f b, uint_fast8_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend2 (v16i a, v16i b, uint_fast8_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v4d	v4d_blend4 (v4d a, v4d b, uint_fast8_t mask)
	Creates a new v4d vector whose elements are from a and b choosed by mask. More...
v4f	v4f_blend4 (v4f a, v4f b, uint_fast8_t mask)
	Creates a new v4f vector whose elements are from a and b choosed by mask. More...
v4i	v4i_blend4 (v4i a, v4i b, uint_fast8_t mask)
	Creates a new v4i vector whose elements are from a and b choosed by mask. More...
v4l	v4l_blend4 (v4l a, v4l b, uint_fast8_t mask)
	Creates a new v4l vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend4 (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend4 (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend4 (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend4 (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend4 (v16f a, v16f b, uint_fast8_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend4 (v16i a, v16i b, uint_fast8_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend8 (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend8 (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend8 (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend8 (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend8 (v16f a, v16f b, uint_fast8_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend8 (v16i a, v16i b, uint_fast8_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend16 (v16f a, v16f b, uint_fast16_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend16 (v16i a, v16i b, uint_fast16_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v1d	v1d_blend1x1 (v1d a, v1d b, uint_fast8_t mask)
	Creates a new v1d vector whose elements are from a and b choosed by mask. More...
v1f	v1f_blend1x1 (v1f a, v1f b, uint_fast8_t mask)
	Creates a new v1f vector whose elements are from a and b choosed by mask. More...
v1i	v1i_blend1x1 (v1i a, v1i b, uint_fast8_t mask)
	Creates a new v1i vector whose elements are from a and b choosed by mask. More...
v1l	v1l_blend1x1 (v1l a, v1l b, uint_fast8_t mask)
	Creates a new v1l vector whose elements are from a and b choosed by mask. More...
v2d	v2d_blend1x2 (v2d a, v2d b, uint_fast8_t mask)
	Creates a new v2d vector whose elements are from a and b choosed by mask. More...
v2f	v2f_blend1x2 (v2f a, v2f b, uint_fast8_t mask)
	Creates a new v2f vector whose elements are from a and b choosed by mask. More...
v2i	v2i_blend1x2 (v2i a, v2i b, uint_fast8_t mask)
	Creates a new v2i vector whose elements are from a and b choosed by mask. More...
v2l	v2l_blend1x2 (v2l a, v2l b, uint_fast8_t mask)
	Creates a new v2l vector whose elements are from a and b choosed by mask. More...
v4d	v4d_blend1x4 (v4d a, v4d b, uint_fast8_t mask)
	Creates a new v4d vector whose elements are from a and b choosed by mask. More...
v4f	v4f_blend1x4 (v4f a, v4f b, uint_fast8_t mask)
	Creates a new v4f vector whose elements are from a and b choosed by mask. More...
v4i	v4i_blend1x4 (v4i a, v4i b, uint_fast8_t mask)
	Creates a new v4i vector whose elements are from a and b choosed by mask. More...
v4l	v4l_blend1x4 (v4l a, v4l b, uint_fast8_t mask)
	Creates a new v4l vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend1x8 (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend1x8 (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend1x8 (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend1x8 (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend1x16 (v16f a, v16f b, uint_fast8_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend1x16 (v16i a, v16i b, uint_fast8_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v2d	v2d_blend2x1 (v2d a, v2d b, uint_fast8_t mask)
	Creates a new v2d vector whose elements are from a and b choosed by mask. More...
v2f	v2f_blend2x1 (v2f a, v2f b, uint_fast8_t mask)
	Creates a new v2f vector whose elements are from a and b choosed by mask. More...
v2i	v2i_blend2x1 (v2i a, v2i b, uint_fast8_t mask)
	Creates a new v2i vector whose elements are from a and b choosed by mask. More...
v2l	v2l_blend2x1 (v2l a, v2l b, uint_fast8_t mask)
	Creates a new v2l vector whose elements are from a and b choosed by mask. More...
v4d	v4d_blend2x2 (v4d a, v4d b, uint_fast8_t mask)
	Creates a new v4d vector whose elements are from a and b choosed by mask. More...
v4f	v4f_blend2x2 (v4f a, v4f b, uint_fast8_t mask)
	Creates a new v4f vector whose elements are from a and b choosed by mask. More...
v4i	v4i_blend2x2 (v4i a, v4i b, uint_fast8_t mask)
	Creates a new v4i vector whose elements are from a and b choosed by mask. More...
v4l	v4l_blend2x2 (v4l a, v4l b, uint_fast8_t mask)
	Creates a new v4l vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend2x4 (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend2x4 (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend2x4 (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend2x4 (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend2x8 (v16f a, v16f b, uint_fast8_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend2x8 (v16i a, v16i b, uint_fast8_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v4d	v4d_blend4x1 (v4d a, v4d b, uint_fast8_t mask)
	Creates a new v4d vector whose elements are from a and b choosed by mask. More...
v4f	v4f_blend4x1 (v4f a, v4f b, uint_fast8_t mask)
	Creates a new v4f vector whose elements are from a and b choosed by mask. More...
v4i	v4i_blend4x1 (v4i a, v4i b, uint_fast8_t mask)
	Creates a new v4i vector whose elements are from a and b choosed by mask. More...
v4l	v4l_blend4x1 (v4l a, v4l b, uint_fast8_t mask)
	Creates a new v4l vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend4x2 (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend4x2 (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend4x2 (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend4x2 (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend4x4 (v16f a, v16f b, uint_fast8_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend4x4 (v16i a, v16i b, uint_fast8_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend8x1 (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend8x1 (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend8x1 (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend8x1 (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend8x2 (v16f a, v16f b, uint_fast8_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend8x2 (v16i a, v16i b, uint_fast8_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend16x1 (v16f a, v16f b, uint_fast16_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend16x1 (v16i a, v16i b, uint_fast16_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...
v1d	v1d_blend (v1d a, v1d b, uint_fast8_t mask)
	Creates a new v1d vector whose elements are from a and b choosed by mask. More...
v1f	v1f_blend (v1f a, v1f b, uint_fast8_t mask)
	Creates a new v1f vector whose elements are from a and b choosed by mask. More...
v1i	v1i_blend (v1i a, v1i b, uint_fast8_t mask)
	Creates a new v1i vector whose elements are from a and b choosed by mask. More...
v1l	v1l_blend (v1l a, v1l b, uint_fast8_t mask)
	Creates a new v1l vector whose elements are from a and b choosed by mask. More...
v2d	v2d_blend (v2d a, v2d b, uint_fast8_t mask)
	Creates a new v2d vector whose elements are from a and b choosed by mask. More...
v2f	v2f_blend (v2f a, v2f b, uint_fast8_t mask)
	Creates a new v2f vector whose elements are from a and b choosed by mask. More...
v2i	v2i_blend (v2i a, v2i b, uint_fast8_t mask)
	Creates a new v2i vector whose elements are from a and b choosed by mask. More...
v2l	v2l_blend (v2l a, v2l b, uint_fast8_t mask)
	Creates a new v2l vector whose elements are from a and b choosed by mask. More...
v4d	v4d_blend (v4d a, v4d b, uint_fast8_t mask)
	Creates a new v4d vector whose elements are from a and b choosed by mask. More...
v4f	v4f_blend (v4f a, v4f b, uint_fast8_t mask)
	Creates a new v4f vector whose elements are from a and b choosed by mask. More...
v4i	v4i_blend (v4i a, v4i b, uint_fast8_t mask)
	Creates a new v4i vector whose elements are from a and b choosed by mask. More...
v4l	v4l_blend (v4l a, v4l b, uint_fast8_t mask)
	Creates a new v4l vector whose elements are from a and b choosed by mask. More...
v8d	v8d_blend (v8d a, v8d b, uint_fast8_t mask)
	Creates a new v8d vector whose elements are from a and b choosed by mask. More...
v8f	v8f_blend (v8f a, v8f b, uint_fast8_t mask)
	Creates a new v8f vector whose elements are from a and b choosed by mask. More...
v8i	v8i_blend (v8i a, v8i b, uint_fast8_t mask)
	Creates a new v8i vector whose elements are from a and b choosed by mask. More...
v8l	v8l_blend (v8l a, v8l b, uint_fast8_t mask)
	Creates a new v8l vector whose elements are from a and b choosed by mask. More...
v16f	v16f_blend (v16f a, v16f b, uint_fast16_t mask)
	Creates a new v16f vector whose elements are from a and b choosed by mask. More...
v16i	v16i_blend (v16i a, v16i b, uint_fast16_t mask)
	Creates a new v16i vector whose elements are from a and b choosed by mask. More...

Detailed Description

Function Documentation

v1d v1d_blend1 ( v1d  a, v1d  b, uint_fast8_t  mask  )

related

Creates a new v1d vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v1d input vector
b	second v1d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1f v1f_blend1 ( v1f  a, v1f  b, uint_fast8_t  mask  )

related

Creates a new v1f vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v1f input vector
b	second v1f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1i v1i_blend1 ( v1i  a, v1i  b, uint_fast8_t  mask  )

related

Creates a new v1i vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v1i input vector
b	second v1i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1l v1l_blend1 ( v1l  a, v1l  b, uint_fast8_t  mask  )

related

Creates a new v1l vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v1l input vector
b	second v1l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2d v2d_blend1 ( v2d  a, v2d  b, uint_fast8_t  mask  )

related

Creates a new v2d vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v2d input vector
b	second v2d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2f v2f_blend1 ( v2f  a, v2f  b, uint_fast8_t  mask  )

related

Creates a new v2f vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v2f input vector
b	second v2f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2i v2i_blend1 ( v2i  a, v2i  b, uint_fast8_t  mask  )

related

Creates a new v2i vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v2i input vector
b	second v2i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2l v2l_blend1 ( v2l  a, v2l  b, uint_fast8_t  mask  )

related

Creates a new v2l vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v2l input vector
b	second v2l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4d v4d_blend1 ( v4d  a, v4d  b, uint_fast8_t  mask  )

related

Creates a new v4d vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4f v4f_blend1 ( v4f  a, v4f  b, uint_fast8_t  mask  )

related

Creates a new v4f vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4i v4i_blend1 ( v4i  a, v4i  b, uint_fast8_t  mask  )

related

Creates a new v4i vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4l v4l_blend1 ( v4l  a, v4l  b, uint_fast8_t  mask  )

related

Creates a new v4l vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend1 ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith block of 8 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 8
  if mask.bits[j]
    dst[i:i+7] = b[i:i+7]
  else
    dst[i:i+7] = a[i:i+7]
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend1 ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith block of 8 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 8
  if mask.bits[j]
    dst[i:i+7] = b[i:i+7]
  else
    dst[i:i+7] = a[i:i+7]
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend1 ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith block of 8 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 8
  if mask.bits[j]
    dst[i:i+7] = b[i:i+7]
  else
    dst[i:i+7] = a[i:i+7]
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend1 ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith block of 8 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 8
  if mask.bits[j]
    dst[i:i+7] = b[i:i+7]
  else
    dst[i:i+7] = a[i:i+7]
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend1 ( v16f  a, v16f  b, uint_fast8_t  mask  )

related

Creates a new v16f vector where the ith block of 16 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 16
  if mask.bits[j]
    dst[i:i+15] = b[i:i+15]
  else
    dst[i:i+15] = a[i:i+15]
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend1 ( v16i  a, v16i  b, uint_fast8_t  mask  )

related

Creates a new v16i vector where the ith block of 16 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 0
  i = j * 16
  if mask.bits[j]
    dst[i:i+15] = b[i:i+15]
  else
    dst[i:i+15] = a[i:i+15]
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2d v2d_blend2 ( v2d  a, v2d  b, uint_fast8_t  mask  )

related

Creates a new v2d vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v2d input vector
b	second v2d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2f v2f_blend2 ( v2f  a, v2f  b, uint_fast8_t  mask  )

related

Creates a new v2f vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v2f input vector
b	second v2f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2i v2i_blend2 ( v2i  a, v2i  b, uint_fast8_t  mask  )

related

Creates a new v2i vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v2i input vector
b	second v2i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2l v2l_blend2 ( v2l  a, v2l  b, uint_fast8_t  mask  )

related

Creates a new v2l vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v2l input vector
b	second v2l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4d v4d_blend2 ( v4d  a, v4d  b, uint_fast8_t  mask  )

related

Creates a new v4d vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4f v4f_blend2 ( v4f  a, v4f  b, uint_fast8_t  mask  )

related

Creates a new v4f vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4i v4i_blend2 ( v4i  a, v4i  b, uint_fast8_t  mask  )

related

Creates a new v4i vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4l v4l_blend2 ( v4l  a, v4l  b, uint_fast8_t  mask  )

related

Creates a new v4l vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend2 ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend2 ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend2 ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend2 ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend2 ( v16f  a, v16f  b, uint_fast8_t  mask  )

related

Creates a new v16f vector where the ith block of 8 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 8
  if mask.bits[j]
    dst[i:i+7] = b[i:i+7]
  else
    dst[i:i+7] = a[i:i+7]
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend2 ( v16i  a, v16i  b, uint_fast8_t  mask  )

related

Creates a new v16i vector where the ith block of 8 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 1
  i = j * 8
  if mask.bits[j]
    dst[i:i+7] = b[i:i+7]
  else
    dst[i:i+7] = a[i:i+7]
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4d v4d_blend4 ( v4d  a, v4d  b, uint_fast8_t  mask  )

related

Creates a new v4d vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4f v4f_blend4 ( v4f  a, v4f  b, uint_fast8_t  mask  )

related

Creates a new v4f vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4i v4i_blend4 ( v4i  a, v4i  b, uint_fast8_t  mask  )

related

Creates a new v4i vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4l v4l_blend4 ( v4l  a, v4l  b, uint_fast8_t  mask  )

related

Creates a new v4l vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend4 ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend4 ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend4 ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend4 ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend4 ( v16f  a, v16f  b, uint_fast8_t  mask  )

related

Creates a new v16f vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend4 ( v16i  a, v16i  b, uint_fast8_t  mask  )

related

Creates a new v16i vector where the ith block of 4 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 3
  i = j * 4
  if mask.bits[j]
    dst[i:i+3] = b[i:i+3]
  else
    dst[i:i+3] = a[i:i+3]
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend8 ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 7
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend8 ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 7
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend8 ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 7
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend8 ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 7
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend8 ( v16f  a, v16f  b, uint_fast8_t  mask  )

related

Creates a new v16f vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 7
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend8 ( v16i  a, v16i  b, uint_fast8_t  mask  )

related

Creates a new v16i vector where the ith block of 2 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 7
  i = j * 2
  if mask.bits[j]
    dst[i:i+1] = b[i:i+1]
  else
    dst[i:i+1] = a[i:i+1]
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend16 ( v16f  a, v16f  b, uint_fast16_t  mask  )

related

Creates a new v16f vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 15
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend16 ( v16i  a, v16i  b, uint_fast16_t  mask  )

related

Creates a new v16i vector where the ith block of 1 elements is from b if the ith bit of mask is 1 and from a otherwise.

Operation

for j from 0 to 15
  i = j * 1
  if mask.bits[j]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1d v1d_blend1x1 ( v1d  a, v1d  b, uint_fast8_t  mask  )

related

Creates a new v1d vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v1d input vector
b	second v1d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1f v1f_blend1x1 ( v1f  a, v1f  b, uint_fast8_t  mask  )

related

Creates a new v1f vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v1f input vector
b	second v1f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1i v1i_blend1x1 ( v1i  a, v1i  b, uint_fast8_t  mask  )

related

Creates a new v1i vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v1i input vector
b	second v1i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1l v1l_blend1x1 ( v1l  a, v1l  b, uint_fast8_t  mask  )

related

Creates a new v1l vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v1l input vector
b	second v1l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2d v2d_blend1x2 ( v2d  a, v2d  b, uint_fast8_t  mask  )

related

Creates a new v2d vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v2d input vector
b	second v2d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2f v2f_blend1x2 ( v2f  a, v2f  b, uint_fast8_t  mask  )

related

Creates a new v2f vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v2f input vector
b	second v2f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2i v2i_blend1x2 ( v2i  a, v2i  b, uint_fast8_t  mask  )

related

Creates a new v2i vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v2i input vector
b	second v2i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2l v2l_blend1x2 ( v2l  a, v2l  b, uint_fast8_t  mask  )

related

Creates a new v2l vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v2l input vector
b	second v2l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4d v4d_blend1x4 ( v4d  a, v4d  b, uint_fast8_t  mask  )

related

Creates a new v4d vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v4d input vector
b	second v4d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4f v4f_blend1x4 ( v4f  a, v4f  b, uint_fast8_t  mask  )

related

Creates a new v4f vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v4f input vector
b	second v4f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4i v4i_blend1x4 ( v4i  a, v4i  b, uint_fast8_t  mask  )

related

Creates a new v4i vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v4i input vector
b	second v4i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4l v4l_blend1x4 ( v4l  a, v4l  b, uint_fast8_t  mask  )

related

Creates a new v4l vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v4l input vector
b	second v4l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend1x8 ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 7
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend1x8 ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 7
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend1x8 ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 7
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend1x8 ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 7
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend1x16 ( v16f  a, v16f  b, uint_fast8_t  mask  )

related

Creates a new v16f vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 15
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend1x16 ( v16i  a, v16i  b, uint_fast8_t  mask  )

related

Creates a new v16i vector where the ith element is from b if the (i % 1)th bit of mask is 1 and from a otherwise.

Operation

function BLEND1(_a, _b, _m) {
  for i from 0 to 0
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 15
  i = j * 1
  dst[i] = BLEND1(a[i], b[i], mask)
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2d v2d_blend2x1 ( v2d  a, v2d  b, uint_fast8_t  mask  )

related

Creates a new v2d vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v2d input vector
b	second v2d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2f v2f_blend2x1 ( v2f  a, v2f  b, uint_fast8_t  mask  )

related

Creates a new v2f vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v2f input vector
b	second v2f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2i v2i_blend2x1 ( v2i  a, v2i  b, uint_fast8_t  mask  )

related

Creates a new v2i vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v2i input vector
b	second v2i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2l v2l_blend2x1 ( v2l  a, v2l  b, uint_fast8_t  mask  )

related

Creates a new v2l vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v2l input vector
b	second v2l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4d v4d_blend2x2 ( v4d  a, v4d  b, uint_fast8_t  mask  )

related

Creates a new v4d vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v4d input vector
b	second v4d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4f v4f_blend2x2 ( v4f  a, v4f  b, uint_fast8_t  mask  )

related

Creates a new v4f vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v4f input vector
b	second v4f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4i v4i_blend2x2 ( v4i  a, v4i  b, uint_fast8_t  mask  )

related

Creates a new v4i vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v4i input vector
b	second v4i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4l v4l_blend2x2 ( v4l  a, v4l  b, uint_fast8_t  mask  )

related

Creates a new v4l vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v4l input vector
b	second v4l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend2x4 ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend2x4 ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend2x4 ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend2x4 ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend2x8 ( v16f  a, v16f  b, uint_fast8_t  mask  )

related

Creates a new v16f vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 7
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend2x8 ( v16i  a, v16i  b, uint_fast8_t  mask  )

related

Creates a new v16i vector where the ith element is from b if the (i % 2)th bit of mask is 1 and from a otherwise.

Operation

function BLEND2(_a, _b, _m) {
  for i from 0 to 1
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 7
  i = j * 2
  dst[i:i+1] = BLEND2(a[i:i+1], b[i:i+1], mask)
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4d v4d_blend4x1 ( v4d  a, v4d  b, uint_fast8_t  mask  )

related

Creates a new v4d vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v4d input vector
b	second v4d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4f v4f_blend4x1 ( v4f  a, v4f  b, uint_fast8_t  mask  )

related

Creates a new v4f vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v4f input vector
b	second v4f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4i v4i_blend4x1 ( v4i  a, v4i  b, uint_fast8_t  mask  )

related

Creates a new v4i vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v4i input vector
b	second v4i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4l v4l_blend4x1 ( v4l  a, v4l  b, uint_fast8_t  mask  )

related

Creates a new v4l vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v4l input vector
b	second v4l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend4x2 ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend4x2 ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend4x2 ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend4x2 ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend4x4 ( v16f  a, v16f  b, uint_fast8_t  mask  )

related

Creates a new v16f vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend4x4 ( v16i  a, v16i  b, uint_fast8_t  mask  )

related

Creates a new v16i vector where the ith element is from b if the (i % 4)th bit of mask is 1 and from a otherwise.

Operation

function BLEND4(_a, _b, _m) {
  for i from 0 to 3
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 3
  i = j * 4
  dst[i:i+3] = BLEND4(a[i:i+3], b[i:i+3], mask)
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend8x1 ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith element is from b if the (i % 8)th bit of mask is 1 and from a otherwise.

Operation

function BLEND8(_a, _b, _m) {
  for i from 0 to 7
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 8
  dst[i:i+7] = BLEND8(a[i:i+7], b[i:i+7], mask)
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend8x1 ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith element is from b if the (i % 8)th bit of mask is 1 and from a otherwise.

Operation

function BLEND8(_a, _b, _m) {
  for i from 0 to 7
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 8
  dst[i:i+7] = BLEND8(a[i:i+7], b[i:i+7], mask)
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend8x1 ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith element is from b if the (i % 8)th bit of mask is 1 and from a otherwise.

Operation

function BLEND8(_a, _b, _m) {
  for i from 0 to 7
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 8
  dst[i:i+7] = BLEND8(a[i:i+7], b[i:i+7], mask)
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend8x1 ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith element is from b if the (i % 8)th bit of mask is 1 and from a otherwise.

Operation

function BLEND8(_a, _b, _m) {
  for i from 0 to 7
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 8
  dst[i:i+7] = BLEND8(a[i:i+7], b[i:i+7], mask)
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend8x2 ( v16f  a, v16f  b, uint_fast8_t  mask  )

related

Creates a new v16f vector where the ith element is from b if the (i % 8)th bit of mask is 1 and from a otherwise.

Operation

function BLEND8(_a, _b, _m) {
  for i from 0 to 7
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 8
  dst[i:i+7] = BLEND8(a[i:i+7], b[i:i+7], mask)
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend8x2 ( v16i  a, v16i  b, uint_fast8_t  mask  )

related

Creates a new v16i vector where the ith element is from b if the (i % 8)th bit of mask is 1 and from a otherwise.

Operation

function BLEND8(_a, _b, _m) {
  for i from 0 to 7
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 1
  i = j * 8
  dst[i:i+7] = BLEND8(a[i:i+7], b[i:i+7], mask)
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend16x1 ( v16f  a, v16f  b, uint_fast16_t  mask  )

related

Creates a new v16f vector where the ith element is from b if the (i % 16)th bit of mask is 1 and from a otherwise.

Operation

function BLEND16(_a, _b, _m) {
  for i from 0 to 15
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 16
  dst[i:i+15] = BLEND16(a[i:i+15], b[i:i+15], mask)
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend16x1 ( v16i  a, v16i  b, uint_fast16_t  mask  )

related

Creates a new v16i vector where the ith element is from b if the (i % 16)th bit of mask is 1 and from a otherwise.

Operation

function BLEND16(_a, _b, _m) {
  for i from 0 to 15
    if _m.bits[i]
      _tmp[i] = _b[i]
    else
      _tmp[i] = _a[i]
    endif
  endfor
  return _tmp
}

for j from 0 to 0
  i = j * 16
  dst[i:i+15] = BLEND16(a[i:i+15], b[i:i+15], mask)
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1d v1d_blend ( v1d  a, v1d  b, uint_fast8_t  mask  )

related

Creates a new v1d vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v1d_blend1(v1d a, v1d b, uint_fast8_t mask)

Operation

for i from 0 to 0
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v1d input vector
b	second v1d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1f v1f_blend ( v1f  a, v1f  b, uint_fast8_t  mask  )

related

Creates a new v1f vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v1f_blend1(v1f a, v1f b, uint_fast8_t mask)

Operation

for i from 0 to 0
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v1f input vector
b	second v1f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1i v1i_blend ( v1i  a, v1i  b, uint_fast8_t  mask  )

related

Creates a new v1i vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v1i_blend1(v1i a, v1i b, uint_fast8_t mask)

Operation

for i from 0 to 0
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v1i input vector
b	second v1i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v1l v1l_blend ( v1l  a, v1l  b, uint_fast8_t  mask  )

related

Creates a new v1l vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v1l_blend1(v1l a, v1l b, uint_fast8_t mask)

Operation

for i from 0 to 0
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v1l input vector
b	second v1l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2d v2d_blend ( v2d  a, v2d  b, uint_fast8_t  mask  )

related

Creates a new v2d vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v2d_blend2(v2d a, v2d b, uint_fast8_t mask)

Operation

for i from 0 to 1
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v2d input vector
b	second v2d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2f v2f_blend ( v2f  a, v2f  b, uint_fast8_t  mask  )

related

Creates a new v2f vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v2f_blend2(v2f a, v2f b, uint_fast8_t mask)

Operation

for i from 0 to 1
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v2f input vector
b	second v2f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2i v2i_blend ( v2i  a, v2i  b, uint_fast8_t  mask  )

related

Creates a new v2i vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v2i_blend2(v2i a, v2i b, uint_fast8_t mask)

Operation

for i from 0 to 1
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v2i input vector
b	second v2i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v2l v2l_blend ( v2l  a, v2l  b, uint_fast8_t  mask  )

related

Creates a new v2l vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v2l_blend2(v2l a, v2l b, uint_fast8_t mask)

Operation

for i from 0 to 1
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v2l input vector
b	second v2l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4d v4d_blend ( v4d  a, v4d  b, uint_fast8_t  mask  )

related

Creates a new v4d vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v4d_blend4(v4d a, v4d b, uint_fast8_t mask)

Operation

for i from 0 to 3
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4f v4f_blend ( v4f  a, v4f  b, uint_fast8_t  mask  )

related

Creates a new v4f vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v4f_blend4(v4f a, v4f b, uint_fast8_t mask)

Operation

for i from 0 to 3
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4i v4i_blend ( v4i  a, v4i  b, uint_fast8_t  mask  )

related

Creates a new v4i vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v4i_blend4(v4i a, v4i b, uint_fast8_t mask)

Operation

for i from 0 to 3
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v4l v4l_blend ( v4l  a, v4l  b, uint_fast8_t  mask  )

related

Creates a new v4l vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v4l_blend4(v4l a, v4l b, uint_fast8_t mask)

Operation

for i from 0 to 3
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8d v8d_blend ( v8d  a, v8d  b, uint_fast8_t  mask  )

related

Creates a new v8d vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v8d_blend8(v8d a, v8d b, uint_fast8_t mask)

Operation

for i from 0 to 7
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8f v8f_blend ( v8f  a, v8f  b, uint_fast8_t  mask  )

related

Creates a new v8f vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v8f_blend8(v8f a, v8f b, uint_fast8_t mask)

Operation

for i from 0 to 7
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8i v8i_blend ( v8i  a, v8i  b, uint_fast8_t  mask  )

related

Creates a new v8i vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v8i_blend8(v8i a, v8i b, uint_fast8_t mask)

Operation

for i from 0 to 7
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v8l v8l_blend ( v8l  a, v8l  b, uint_fast8_t  mask  )

related

Creates a new v8l vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v8l_blend8(v8l a, v8l b, uint_fast8_t mask)

Operation

for i from 0 to 7
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16f v16f_blend ( v16f  a, v16f  b, uint_fast16_t  mask  )

related

Creates a new v16f vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v16f_blend16(v16f a, v16f b, uint_fast16_t mask)

Operation

for i from 0 to 15
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector

v16i v16i_blend ( v16i  a, v16i  b, uint_fast16_t  mask  )

related

Creates a new v16i vector where the ith element is from b if the ith bit of mask is 1 and from a otherwise. Alias of v16i_blend16(v16i a, v16i b, uint_fast16_t mask)

Operation

for i from 0 to 15
  if mask.bits[i]
    dst[i] = b[i]
  else
    dst[i] = a[i]
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector
mask	integer mask choosing the input for each element. Must be an immediate!

Returns

blended vector