comparison functions

Functions
v1d	v1d_eq (v1d a, v1d b)
	Compares the equality of the two input vectors. More...
v1f	v1f_eq (v1f a, v1f b)
	Compares the equality of the two input vectors. More...
v1i	v1i_eq (v1i a, v1i b)
	Compares the equality of the two input vectors. More...
v1l	v1l_eq (v1l a, v1l b)
	Compares the equality of the two input vectors. More...
v2d	v2d_eq (v2d a, v2d b)
	Compares the equality of the two input vectors. More...
v2f	v2f_eq (v2f a, v2f b)
	Compares the equality of the two input vectors. More...
v2i	v2i_eq (v2i a, v2i b)
	Compares the equality of the two input vectors. More...
v2l	v2l_eq (v2l a, v2l b)
	Compares the equality of the two input vectors. More...
v4d	v4d_eq (v4d a, v4d b)
	Compares the equality of the two input vectors. More...
v4f	v4f_eq (v4f a, v4f b)
	Compares the equality of the two input vectors. More...
v4i	v4i_eq (v4i a, v4i b)
	Compares the equality of the two input vectors. More...
v4l	v4l_eq (v4l a, v4l b)
	Compares the equality of the two input vectors. More...
v8d	v8d_eq (v8d a, v8d b)
	Compares the equality of the two input vectors. More...
v8f	v8f_eq (v8f a, v8f b)
	Compares the equality of the two input vectors. More...
v8i	v8i_eq (v8i a, v8i b)
	Compares the equality of the two input vectors. More...
v8l	v8l_eq (v8l a, v8l b)
	Compares the equality of the two input vectors. More...
v16f	v16f_eq (v16f a, v16f b)
	Compares the equality of the two input vectors. More...
v16i	v16i_eq (v16i a, v16i b)
	Compares the equality of the two input vectors. More...
v1d	v1d_neq (v1d a, v1d b)
	Compares the inequality of the two input vectors. More...
v1f	v1f_neq (v1f a, v1f b)
	Compares the inequality of the two input vectors. More...
v1i	v1i_neq (v1i a, v1i b)
	Compares the inequality of the two input vectors. More...
v1l	v1l_neq (v1l a, v1l b)
	Compares the inequality of the two input vectors. More...
v2d	v2d_neq (v2d a, v2d b)
	Compares the inequality of the two input vectors. More...
v2f	v2f_neq (v2f a, v2f b)
	Compares the inequality of the two input vectors. More...
v2i	v2i_neq (v2i a, v2i b)
	Compares the inequality of the two input vectors. More...
v2l	v2l_neq (v2l a, v2l b)
	Compares the inequality of the two input vectors. More...
v4d	v4d_neq (v4d a, v4d b)
	Compares the inequality of the two input vectors. More...
v4f	v4f_neq (v4f a, v4f b)
	Compares the inequality of the two input vectors. More...
v4i	v4i_neq (v4i a, v4i b)
	Compares the inequality of the two input vectors. More...
v4l	v4l_neq (v4l a, v4l b)
	Compares the inequality of the two input vectors. More...
v8d	v8d_neq (v8d a, v8d b)
	Compares the inequality of the two input vectors. More...
v8f	v8f_neq (v8f a, v8f b)
	Compares the inequality of the two input vectors. More...
v8i	v8i_neq (v8i a, v8i b)
	Compares the inequality of the two input vectors. More...
v8l	v8l_neq (v8l a, v8l b)
	Compares the inequality of the two input vectors. More...
v16f	v16f_neq (v16f a, v16f b)
	Compares the inequality of the two input vectors. More...
v16i	v16i_neq (v16i a, v16i b)
	Compares the inequality of the two input vectors. More...
v1d	v1d_gt (v1d a, v1d b)
	Compares if elements of a are greater than those of b. More...
v1f	v1f_gt (v1f a, v1f b)
	Compares if elements of a are greater than those of b. More...
v1i	v1i_gt (v1i a, v1i b)
	Compares if elements of a are greater than those of b. More...
v1l	v1l_gt (v1l a, v1l b)
	Compares if elements of a are greater than those of b. More...
v2d	v2d_gt (v2d a, v2d b)
	Compares if elements of a are greater than those of b. More...
v2f	v2f_gt (v2f a, v2f b)
	Compares if elements of a are greater than those of b. More...
v2i	v2i_gt (v2i a, v2i b)
	Compares if elements of a are greater than those of b. More...
v2l	v2l_gt (v2l a, v2l b)
	Compares if elements of a are greater than those of b. More...
v4d	v4d_gt (v4d a, v4d b)
	Compares if elements of a are greater than those of b. More...
v4f	v4f_gt (v4f a, v4f b)
	Compares if elements of a are greater than those of b. More...
v4i	v4i_gt (v4i a, v4i b)
	Compares if elements of a are greater than those of b. More...
v4l	v4l_gt (v4l a, v4l b)
	Compares if elements of a are greater than those of b. More...
v8d	v8d_gt (v8d a, v8d b)
	Compares if elements of a are greater than those of b. More...
v8f	v8f_gt (v8f a, v8f b)
	Compares if elements of a are greater than those of b. More...
v8i	v8i_gt (v8i a, v8i b)
	Compares if elements of a are greater than those of b. More...
v8l	v8l_gt (v8l a, v8l b)
	Compares if elements of a are greater than those of b. More...
v16f	v16f_gt (v16f a, v16f b)
	Compares if elements of a are greater than those of b. More...
v16i	v16i_gt (v16i a, v16i b)
	Compares if elements of a are greater than those of b. More...
v1d	v1d_geq (v1d a, v1d b)
	Compares if elements of a are greater than or equal to those of b. More...
v1f	v1f_geq (v1f a, v1f b)
	Compares if elements of a are greater than or equal to those of b. More...
v1i	v1i_geq (v1i a, v1i b)
	Compares if elements of a are greater than or equal to those of b. More...
v1l	v1l_geq (v1l a, v1l b)
	Compares if elements of a are greater than or equal to those of b. More...
v2d	v2d_geq (v2d a, v2d b)
	Compares if elements of a are greater than or equal to those of b. More...
v2f	v2f_geq (v2f a, v2f b)
	Compares if elements of a are greater than or equal to those of b. More...
v2i	v2i_geq (v2i a, v2i b)
	Compares if elements of a are greater than or equal to those of b. More...
v2l	v2l_geq (v2l a, v2l b)
	Compares if elements of a are greater than or equal to those of b. More...
v4d	v4d_geq (v4d a, v4d b)
	Compares if elements of a are greater than or equal to those of b. More...
v4f	v4f_geq (v4f a, v4f b)
	Compares if elements of a are greater than or equal to those of b. More...
v4i	v4i_geq (v4i a, v4i b)
	Compares if elements of a are greater than or equal to those of b. More...
v4l	v4l_geq (v4l a, v4l b)
	Compares if elements of a are greater than or equal to those of b. More...
v8d	v8d_geq (v8d a, v8d b)
	Compares if elements of a are greater than or equal to those of b. More...
v8f	v8f_geq (v8f a, v8f b)
	Compares if elements of a are greater than or equal to those of b. More...
v8i	v8i_geq (v8i a, v8i b)
	Compares if elements of a are greater than or equal to those of b. More...
v8l	v8l_geq (v8l a, v8l b)
	Compares if elements of a are greater than or equal to those of b. More...
v16f	v16f_geq (v16f a, v16f b)
	Compares if elements of a are greater than or equal to those of b. More...
v16i	v16i_geq (v16i a, v16i b)
	Compares if elements of a are greater than or equal to those of b. More...
v1d	v1d_lt (v1d a, v1d b)
	Compares if elements of a are less than those of b. More...
v1f	v1f_lt (v1f a, v1f b)
	Compares if elements of a are less than those of b. More...
v1i	v1i_lt (v1i a, v1i b)
	Compares if elements of a are less than those of b. More...
v1l	v1l_lt (v1l a, v1l b)
	Compares if elements of a are less than those of b. More...
v2d	v2d_lt (v2d a, v2d b)
	Compares if elements of a are less than those of b. More...
v2f	v2f_lt (v2f a, v2f b)
	Compares if elements of a are less than those of b. More...
v2i	v2i_lt (v2i a, v2i b)
	Compares if elements of a are less than those of b. More...
v2l	v2l_lt (v2l a, v2l b)
	Compares if elements of a are less than those of b. More...
v4d	v4d_lt (v4d a, v4d b)
	Compares if elements of a are less than those of b. More...
v4f	v4f_lt (v4f a, v4f b)
	Compares if elements of a are less than those of b. More...
v4i	v4i_lt (v4i a, v4i b)
	Compares if elements of a are less than those of b. More...
v4l	v4l_lt (v4l a, v4l b)
	Compares if elements of a are less than those of b. More...
v8d	v8d_lt (v8d a, v8d b)
	Compares if elements of a are less than those of b. More...
v8f	v8f_lt (v8f a, v8f b)
	Compares if elements of a are less than those of b. More...
v8i	v8i_lt (v8i a, v8i b)
	Compares if elements of a are less than those of b. More...
v8l	v8l_lt (v8l a, v8l b)
	Compares if elements of a are less than those of b. More...
v16f	v16f_lt (v16f a, v16f b)
	Compares if elements of a are less than those of b. More...
v16i	v16i_lt (v16i a, v16i b)
	Compares if elements of a are less than those of b. More...
v1d	v1d_leq (v1d a, v1d b)
	Compares if elements of a are less than or equal to those of b. More...
v1f	v1f_leq (v1f a, v1f b)
	Compares if elements of a are less than or equal to those of b. More...
v1i	v1i_leq (v1i a, v1i b)
	Compares if elements of a are less than or equal to those of b. More...
v1l	v1l_leq (v1l a, v1l b)
	Compares if elements of a are less than or equal to those of b. More...
v2d	v2d_leq (v2d a, v2d b)
	Compares if elements of a are less than or equal to those of b. More...
v2f	v2f_leq (v2f a, v2f b)
	Compares if elements of a are less than or equal to those of b. More...
v2i	v2i_leq (v2i a, v2i b)
	Compares if elements of a are less than or equal to those of b. More...
v2l	v2l_leq (v2l a, v2l b)
	Compares if elements of a are less than or equal to those of b. More...
v4d	v4d_leq (v4d a, v4d b)
	Compares if elements of a are less than or equal to those of b. More...
v4f	v4f_leq (v4f a, v4f b)
	Compares if elements of a are less than or equal to those of b. More...
v4i	v4i_leq (v4i a, v4i b)
	Compares if elements of a are less than or equal to those of b. More...
v4l	v4l_leq (v4l a, v4l b)
	Compares if elements of a are less than or equal to those of b. More...
v8d	v8d_leq (v8d a, v8d b)
	Compares if elements of a are less than or equal to those of b. More...
v8f	v8f_leq (v8f a, v8f b)
	Compares if elements of a are less than or equal to those of b. More...
v8i	v8i_leq (v8i a, v8i b)
	Compares if elements of a are less than or equal to those of b. More...
v8l	v8l_leq (v8l a, v8l b)
	Compares if elements of a are less than or equal to those of b. More...
v16f	v16f_leq (v16f a, v16f b)
	Compares if elements of a are less than or equal to those of b. More...
v16i	v16i_leq (v16i a, v16i b)
	Compares if elements of a are less than or equal to those of b. More...

Detailed Description

Function Documentation

v1d v1d_eq ( v1d  a, v1d  b  )

related

Compares the equality of the v1d vectors a and b. The result is a v1d vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1d_and(v1d, v1d)

Operation

for j from 0 to 0
  i = j*64
  if a[j] == b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1d input vector
b	second v1d input vector

Returns

v1d vector acting like a mask

v1f v1f_eq ( v1f  a, v1f  b  )

related

Compares the equality of the v1f vectors a and b. The result is a v1f vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1f_and(v1f, v1f)

Operation

for j from 0 to 0
  i = j*32
  if a[j] == b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1f input vector
b	second v1f input vector

Returns

v1f vector acting like a mask

v1i v1i_eq ( v1i  a, v1i  b  )

related

Compares the equality of the v1i vectors a and b. The result is a v1i vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1i_and(v1i, v1i)

Operation

for j from 0 to 0
  i = j*32
  if a[j] == b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1i input vector
b	second v1i input vector

Returns

v1i vector acting like a mask

v1l v1l_eq ( v1l  a, v1l  b  )

related

Compares the equality of the v1l vectors a and b. The result is a v1l vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1l_and(v1l, v1l)

Operation

for j from 0 to 0
  i = j*64
  if a[j] == b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1l input vector
b	second v1l input vector

Returns

v1l vector acting like a mask

v2d v2d_eq ( v2d  a, v2d  b  )

related

Compares the equality of the v2d vectors a and b. The result is a v2d vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2d_and(v2d, v2d)

Operation

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

Parameters

a	first v2d input vector
b	second v2d input vector

Returns

v2d vector acting like a mask

v2f v2f_eq ( v2f  a, v2f  b  )

related

Compares the equality of the v2f vectors a and b. The result is a v2f vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2f_and(v2f, v2f)

Operation

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

Parameters

a	first v2f input vector
b	second v2f input vector

Returns

v2f vector acting like a mask

v2i v2i_eq ( v2i  a, v2i  b  )

related

Compares the equality of the v2i vectors a and b. The result is a v2i vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2i_and(v2i, v2i)

Operation

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

Parameters

a	first v2i input vector
b	second v2i input vector

Returns

v2i vector acting like a mask

v2l v2l_eq ( v2l  a, v2l  b  )

related

Compares the equality of the v2l vectors a and b. The result is a v2l vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2l_and(v2l, v2l)

Operation

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

Parameters

a	first v2l input vector
b	second v2l input vector

Returns

v2l vector acting like a mask

v4d v4d_eq ( v4d  a, v4d  b  )

related

Compares the equality of the v4d vectors a and b. The result is a v4d vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4d_and(v4d, v4d)

Operation

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

Parameters

a	first v4d input vector
b	second v4d input vector

Returns

v4d vector acting like a mask

v4f v4f_eq ( v4f  a, v4f  b  )

related

Compares the equality of the v4f vectors a and b. The result is a v4f vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4f_and(v4f, v4f)

Operation

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

Parameters

a	first v4f input vector
b	second v4f input vector

Returns

v4f vector acting like a mask

v4i v4i_eq ( v4i  a, v4i  b  )

related

Compares the equality of the v4i vectors a and b. The result is a v4i vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4i_and(v4i, v4i)

Operation

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

Parameters

a	first v4i input vector
b	second v4i input vector

Returns

v4i vector acting like a mask

v4l v4l_eq ( v4l  a, v4l  b  )

related

Compares the equality of the v4l vectors a and b. The result is a v4l vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4l_and(v4l, v4l)

Operation

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

Parameters

a	first v4l input vector
b	second v4l input vector

Returns

v4l vector acting like a mask

v8d v8d_eq ( v8d  a, v8d  b  )

related

Compares the equality of the v8d vectors a and b. The result is a v8d vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8d_and(v8d, v8d)

Operation

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

Parameters

a	first v8d input vector
b	second v8d input vector

Returns

v8d vector acting like a mask

v8f v8f_eq ( v8f  a, v8f  b  )

related

Compares the equality of the v8f vectors a and b. The result is a v8f vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8f_and(v8f, v8f)

Operation

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

Parameters

a	first v8f input vector
b	second v8f input vector

Returns

v8f vector acting like a mask

v8i v8i_eq ( v8i  a, v8i  b  )

related

Compares the equality of the v8i vectors a and b. The result is a v8i vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8i_and(v8i, v8i)

Operation

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

Parameters

a	first v8i input vector
b	second v8i input vector

Returns

v8i vector acting like a mask

v8l v8l_eq ( v8l  a, v8l  b  )

related

Compares the equality of the v8l vectors a and b. The result is a v8l vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8l_and(v8l, v8l)

Operation

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

Parameters

a	first v8l input vector
b	second v8l input vector

Returns

v8l vector acting like a mask

v16f v16f_eq ( v16f  a, v16f  b  )

related

Compares the equality of the v16f vectors a and b. The result is a v16f vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16f_and(v16f, v16f)

Operation

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

Parameters

a	first v16f input vector
b	second v16f input vector

Returns

v16f vector acting like a mask

v16i v16i_eq ( v16i  a, v16i  b  )

related

Compares the equality of the v16i vectors a and b. The result is a v16i vector where the ith element is all one bits if a[i] == b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16i_and(v16i, v16i)

Operation

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

Parameters

a	first v16i input vector
b	second v16i input vector

Returns

v16i vector acting like a mask

v1d v1d_neq ( v1d  a, v1d  b  )

related

Compares the inequality of the v1d vectors a and b. The result is a v1d vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1d_and(v1d, v1d)

Operation

for j from 0 to 0
  i = j*64
  if a[j] != b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1d input vector
b	second v1d input vector

Returns

v1d vector acting like a mask

v1f v1f_neq ( v1f  a, v1f  b  )

related

Compares the inequality of the v1f vectors a and b. The result is a v1f vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1f_and(v1f, v1f)

Operation

for j from 0 to 0
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1f input vector
b	second v1f input vector

Returns

v1f vector acting like a mask

v1i v1i_neq ( v1i  a, v1i  b  )

related

Compares the inequality of the v1i vectors a and b. The result is a v1i vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1i_and(v1i, v1i)

Operation

for j from 0 to 0
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1i input vector
b	second v1i input vector

Returns

v1i vector acting like a mask

v1l v1l_neq ( v1l  a, v1l  b  )

related

Compares the inequality of the v1l vectors a and b. The result is a v1l vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1l_and(v1l, v1l)

Operation

for j from 0 to 0
  i = j*64
  if a[j] != b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1l input vector
b	second v1l input vector

Returns

v1l vector acting like a mask

v2d v2d_neq ( v2d  a, v2d  b  )

related

Compares the inequality of the v2d vectors a and b. The result is a v2d vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2d_and(v2d, v2d)

Operation

for j from 0 to 1
  i = j*64
  if a[j] != b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2d input vector
b	second v2d input vector

Returns

v2d vector acting like a mask

v2f v2f_neq ( v2f  a, v2f  b  )

related

Compares the inequality of the v2f vectors a and b. The result is a v2f vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2f_and(v2f, v2f)

Operation

for j from 0 to 1
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2f input vector
b	second v2f input vector

Returns

v2f vector acting like a mask

v2i v2i_neq ( v2i  a, v2i  b  )

related

Compares the inequality of the v2i vectors a and b. The result is a v2i vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2i_and(v2i, v2i)

Operation

for j from 0 to 1
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2i input vector
b	second v2i input vector

Returns

v2i vector acting like a mask

v2l v2l_neq ( v2l  a, v2l  b  )

related

Compares the inequality of the v2l vectors a and b. The result is a v2l vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2l_and(v2l, v2l)

Operation

for j from 0 to 1
  i = j*64
  if a[j] != b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2l input vector
b	second v2l input vector

Returns

v2l vector acting like a mask

v4d v4d_neq ( v4d  a, v4d  b  )

related

Compares the inequality of the v4d vectors a and b. The result is a v4d vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4d_and(v4d, v4d)

Operation

for j from 0 to 3
  i = j*64
  if a[j] != b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector

Returns

v4d vector acting like a mask

v4f v4f_neq ( v4f  a, v4f  b  )

related

Compares the inequality of the v4f vectors a and b. The result is a v4f vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4f_and(v4f, v4f)

Operation

for j from 0 to 3
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector

Returns

v4f vector acting like a mask

v4i v4i_neq ( v4i  a, v4i  b  )

related

Compares the inequality of the v4i vectors a and b. The result is a v4i vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4i_and(v4i, v4i)

Operation

for j from 0 to 3
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector

Returns

v4i vector acting like a mask

v4l v4l_neq ( v4l  a, v4l  b  )

related

Compares the inequality of the v4l vectors a and b. The result is a v4l vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4l_and(v4l, v4l)

Operation

for j from 0 to 3
  i = j*64
  if a[j] != b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector

Returns

v4l vector acting like a mask

v8d v8d_neq ( v8d  a, v8d  b  )

related

Compares the inequality of the v8d vectors a and b. The result is a v8d vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8d_and(v8d, v8d)

Operation

for j from 0 to 7
  i = j*64
  if a[j] != b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector

Returns

v8d vector acting like a mask

v8f v8f_neq ( v8f  a, v8f  b  )

related

Compares the inequality of the v8f vectors a and b. The result is a v8f vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8f_and(v8f, v8f)

Operation

for j from 0 to 7
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector

Returns

v8f vector acting like a mask

v8i v8i_neq ( v8i  a, v8i  b  )

related

Compares the inequality of the v8i vectors a and b. The result is a v8i vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8i_and(v8i, v8i)

Operation

for j from 0 to 7
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector

Returns

v8i vector acting like a mask

v8l v8l_neq ( v8l  a, v8l  b  )

related

Compares the inequality of the v8l vectors a and b. The result is a v8l vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8l_and(v8l, v8l)

Operation

for j from 0 to 7
  i = j*64
  if a[j] != b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector

Returns

v8l vector acting like a mask

v16f v16f_neq ( v16f  a, v16f  b  )

related

Compares the inequality of the v16f vectors a and b. The result is a v16f vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16f_and(v16f, v16f)

Operation

for j from 0 to 15
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector

Returns

v16f vector acting like a mask

v16i v16i_neq ( v16i  a, v16i  b  )

related

Compares the inequality of the v16i vectors a and b. The result is a v16i vector where the ith element is all one bits if a[i] != b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16i_and(v16i, v16i)

Operation

for j from 0 to 15
  i = j*32
  if a[j] != b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector

Returns

v16i vector acting like a mask

v1d v1d_gt ( v1d  a, v1d  b  )

related

Compares if elements of a are greater than those of b. The result is a v1d vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1d_and(v1d, v1d)

Operation

for j from 0 to 0
  i = j*64
  if a[j] > b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1d input vector
b	second v1d input vector

Returns

v1d vector acting like a mask

v1f v1f_gt ( v1f  a, v1f  b  )

related

Compares if elements of a are greater than those of b. The result is a v1f vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1f_and(v1f, v1f)

Operation

for j from 0 to 0
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1f input vector
b	second v1f input vector

Returns

v1f vector acting like a mask

v1i v1i_gt ( v1i  a, v1i  b  )

related

Compares if elements of a are greater than those of b. The result is a v1i vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1i_and(v1i, v1i)

Operation

for j from 0 to 0
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1i input vector
b	second v1i input vector

Returns

v1i vector acting like a mask

v1l v1l_gt ( v1l  a, v1l  b  )

related

Compares if elements of a are greater than those of b. The result is a v1l vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1l_and(v1l, v1l)

Operation

for j from 0 to 0
  i = j*64
  if a[j] > b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1l input vector
b	second v1l input vector

Returns

v1l vector acting like a mask

v2d v2d_gt ( v2d  a, v2d  b  )

related

Compares if elements of a are greater than those of b. The result is a v2d vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2d_and(v2d, v2d)

Operation

for j from 0 to 1
  i = j*64
  if a[j] > b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2d input vector
b	second v2d input vector

Returns

v2d vector acting like a mask

v2f v2f_gt ( v2f  a, v2f  b  )

related

Compares if elements of a are greater than those of b. The result is a v2f vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2f_and(v2f, v2f)

Operation

for j from 0 to 1
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2f input vector
b	second v2f input vector

Returns

v2f vector acting like a mask

v2i v2i_gt ( v2i  a, v2i  b  )

related

Compares if elements of a are greater than those of b. The result is a v2i vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2i_and(v2i, v2i)

Operation

for j from 0 to 1
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2i input vector
b	second v2i input vector

Returns

v2i vector acting like a mask

v2l v2l_gt ( v2l  a, v2l  b  )

related

Compares if elements of a are greater than those of b. The result is a v2l vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2l_and(v2l, v2l)

Operation

for j from 0 to 1
  i = j*64
  if a[j] > b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2l input vector
b	second v2l input vector

Returns

v2l vector acting like a mask

v4d v4d_gt ( v4d  a, v4d  b  )

related

Compares if elements of a are greater than those of b. The result is a v4d vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4d_and(v4d, v4d)

Operation

for j from 0 to 3
  i = j*64
  if a[j] > b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector

Returns

v4d vector acting like a mask

v4f v4f_gt ( v4f  a, v4f  b  )

related

Compares if elements of a are greater than those of b. The result is a v4f vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4f_and(v4f, v4f)

Operation

for j from 0 to 3
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector

Returns

v4f vector acting like a mask

v4i v4i_gt ( v4i  a, v4i  b  )

related

Compares if elements of a are greater than those of b. The result is a v4i vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4i_and(v4i, v4i)

Operation

for j from 0 to 3
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector

Returns

v4i vector acting like a mask

v4l v4l_gt ( v4l  a, v4l  b  )

related

Compares if elements of a are greater than those of b. The result is a v4l vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4l_and(v4l, v4l)

Operation

for j from 0 to 3
  i = j*64
  if a[j] > b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector

Returns

v4l vector acting like a mask

v8d v8d_gt ( v8d  a, v8d  b  )

related

Compares if elements of a are greater than those of b. The result is a v8d vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8d_and(v8d, v8d)

Operation

for j from 0 to 7
  i = j*64
  if a[j] > b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector

Returns

v8d vector acting like a mask

v8f v8f_gt ( v8f  a, v8f  b  )

related

Compares if elements of a are greater than those of b. The result is a v8f vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8f_and(v8f, v8f)

Operation

for j from 0 to 7
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector

Returns

v8f vector acting like a mask

v8i v8i_gt ( v8i  a, v8i  b  )

related

Compares if elements of a are greater than those of b. The result is a v8i vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8i_and(v8i, v8i)

Operation

for j from 0 to 7
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector

Returns

v8i vector acting like a mask

v8l v8l_gt ( v8l  a, v8l  b  )

related

Compares if elements of a are greater than those of b. The result is a v8l vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8l_and(v8l, v8l)

Operation

for j from 0 to 7
  i = j*64
  if a[j] > b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector

Returns

v8l vector acting like a mask

v16f v16f_gt ( v16f  a, v16f  b  )

related

Compares if elements of a are greater than those of b. The result is a v16f vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16f_and(v16f, v16f)

Operation

for j from 0 to 15
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector

Returns

v16f vector acting like a mask

v16i v16i_gt ( v16i  a, v16i  b  )

related

Compares if elements of a are greater than those of b. The result is a v16i vector where the ith element is all one bits if a[i] > b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16i_and(v16i, v16i)

Operation

for j from 0 to 15
  i = j*32
  if a[j] > b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector

Returns

v16i vector acting like a mask

v1d v1d_geq ( v1d  a, v1d  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v1d vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1d_and(v1d, v1d)

Operation

for j from 0 to 0
  i = j*64
  if a[j] >= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1d input vector
b	second v1d input vector

Returns

v1d vector acting like a mask

v1f v1f_geq ( v1f  a, v1f  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v1f vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1f_and(v1f, v1f)

Operation

for j from 0 to 0
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1f input vector
b	second v1f input vector

Returns

v1f vector acting like a mask

v1i v1i_geq ( v1i  a, v1i  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v1i vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1i_and(v1i, v1i)

Operation

for j from 0 to 0
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1i input vector
b	second v1i input vector

Returns

v1i vector acting like a mask

v1l v1l_geq ( v1l  a, v1l  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v1l vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1l_and(v1l, v1l)

Operation

for j from 0 to 0
  i = j*64
  if a[j] >= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1l input vector
b	second v1l input vector

Returns

v1l vector acting like a mask

v2d v2d_geq ( v2d  a, v2d  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v2d vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2d_and(v2d, v2d)

Operation

for j from 0 to 1
  i = j*64
  if a[j] >= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2d input vector
b	second v2d input vector

Returns

v2d vector acting like a mask

v2f v2f_geq ( v2f  a, v2f  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v2f vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2f_and(v2f, v2f)

Operation

for j from 0 to 1
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2f input vector
b	second v2f input vector

Returns

v2f vector acting like a mask

v2i v2i_geq ( v2i  a, v2i  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v2i vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2i_and(v2i, v2i)

Operation

for j from 0 to 1
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2i input vector
b	second v2i input vector

Returns

v2i vector acting like a mask

v2l v2l_geq ( v2l  a, v2l  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v2l vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2l_and(v2l, v2l)

Operation

for j from 0 to 1
  i = j*64
  if a[j] >= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2l input vector
b	second v2l input vector

Returns

v2l vector acting like a mask

v4d v4d_geq ( v4d  a, v4d  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v4d vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4d_and(v4d, v4d)

Operation

for j from 0 to 3
  i = j*64
  if a[j] >= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector

Returns

v4d vector acting like a mask

v4f v4f_geq ( v4f  a, v4f  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v4f vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4f_and(v4f, v4f)

Operation

for j from 0 to 3
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector

Returns

v4f vector acting like a mask

v4i v4i_geq ( v4i  a, v4i  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v4i vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4i_and(v4i, v4i)

Operation

for j from 0 to 3
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector

Returns

v4i vector acting like a mask

v4l v4l_geq ( v4l  a, v4l  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v4l vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4l_and(v4l, v4l)

Operation

for j from 0 to 3
  i = j*64
  if a[j] >= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector

Returns

v4l vector acting like a mask

v8d v8d_geq ( v8d  a, v8d  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v8d vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8d_and(v8d, v8d)

Operation

for j from 0 to 7
  i = j*64
  if a[j] >= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector

Returns

v8d vector acting like a mask

v8f v8f_geq ( v8f  a, v8f  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v8f vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8f_and(v8f, v8f)

Operation

for j from 0 to 7
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector

Returns

v8f vector acting like a mask

v8i v8i_geq ( v8i  a, v8i  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v8i vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8i_and(v8i, v8i)

Operation

for j from 0 to 7
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector

Returns

v8i vector acting like a mask

v8l v8l_geq ( v8l  a, v8l  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v8l vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8l_and(v8l, v8l)

Operation

for j from 0 to 7
  i = j*64
  if a[j] >= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector

Returns

v8l vector acting like a mask

v16f v16f_geq ( v16f  a, v16f  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v16f vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16f_and(v16f, v16f)

Operation

for j from 0 to 15
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector

Returns

v16f vector acting like a mask

v16i v16i_geq ( v16i  a, v16i  b  )

related

Compares if elements of a are greater than or equal to those of b. The result is a v16i vector where the ith element is all one bits if a[i] >= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16i_and(v16i, v16i)

Operation

for j from 0 to 15
  i = j*32
  if a[j] >= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector

Returns

v16i vector acting like a mask

v1d v1d_lt ( v1d  a, v1d  b  )

related

Compares if elements of a are less than those of b. The result is a v1d vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1d_and(v1d, v1d)

Operation

for j from 0 to 0
  i = j*64
  if a[j] < b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1d input vector
b	second v1d input vector

Returns

v1d vector acting like a mask

v1f v1f_lt ( v1f  a, v1f  b  )

related

Compares if elements of a are less than those of b. The result is a v1f vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1f_and(v1f, v1f)

Operation

for j from 0 to 0
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1f input vector
b	second v1f input vector

Returns

v1f vector acting like a mask

v1i v1i_lt ( v1i  a, v1i  b  )

related

Compares if elements of a are less than those of b. The result is a v1i vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1i_and(v1i, v1i)

Operation

for j from 0 to 0
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1i input vector
b	second v1i input vector

Returns

v1i vector acting like a mask

v1l v1l_lt ( v1l  a, v1l  b  )

related

Compares if elements of a are less than those of b. The result is a v1l vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1l_and(v1l, v1l)

Operation

for j from 0 to 0
  i = j*64
  if a[j] < b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1l input vector
b	second v1l input vector

Returns

v1l vector acting like a mask

v2d v2d_lt ( v2d  a, v2d  b  )

related

Compares if elements of a are less than those of b. The result is a v2d vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2d_and(v2d, v2d)

Operation

for j from 0 to 1
  i = j*64
  if a[j] < b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2d input vector
b	second v2d input vector

Returns

v2d vector acting like a mask

v2f v2f_lt ( v2f  a, v2f  b  )

related

Compares if elements of a are less than those of b. The result is a v2f vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2f_and(v2f, v2f)

Operation

for j from 0 to 1
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2f input vector
b	second v2f input vector

Returns

v2f vector acting like a mask

v2i v2i_lt ( v2i  a, v2i  b  )

related

Compares if elements of a are less than those of b. The result is a v2i vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2i_and(v2i, v2i)

Operation

for j from 0 to 1
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2i input vector
b	second v2i input vector

Returns

v2i vector acting like a mask

v2l v2l_lt ( v2l  a, v2l  b  )

related

Compares if elements of a are less than those of b. The result is a v2l vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2l_and(v2l, v2l)

Operation

for j from 0 to 1
  i = j*64
  if a[j] < b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2l input vector
b	second v2l input vector

Returns

v2l vector acting like a mask

v4d v4d_lt ( v4d  a, v4d  b  )

related

Compares if elements of a are less than those of b. The result is a v4d vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4d_and(v4d, v4d)

Operation

for j from 0 to 3
  i = j*64
  if a[j] < b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector

Returns

v4d vector acting like a mask

v4f v4f_lt ( v4f  a, v4f  b  )

related

Compares if elements of a are less than those of b. The result is a v4f vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4f_and(v4f, v4f)

Operation

for j from 0 to 3
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector

Returns

v4f vector acting like a mask

v4i v4i_lt ( v4i  a, v4i  b  )

related

Compares if elements of a are less than those of b. The result is a v4i vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4i_and(v4i, v4i)

Operation

for j from 0 to 3
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector

Returns

v4i vector acting like a mask

v4l v4l_lt ( v4l  a, v4l  b  )

related

Compares if elements of a are less than those of b. The result is a v4l vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4l_and(v4l, v4l)

Operation

for j from 0 to 3
  i = j*64
  if a[j] < b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector

Returns

v4l vector acting like a mask

v8d v8d_lt ( v8d  a, v8d  b  )

related

Compares if elements of a are less than those of b. The result is a v8d vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8d_and(v8d, v8d)

Operation

for j from 0 to 7
  i = j*64
  if a[j] < b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector

Returns

v8d vector acting like a mask

v8f v8f_lt ( v8f  a, v8f  b  )

related

Compares if elements of a are less than those of b. The result is a v8f vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8f_and(v8f, v8f)

Operation

for j from 0 to 7
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector

Returns

v8f vector acting like a mask

v8i v8i_lt ( v8i  a, v8i  b  )

related

Compares if elements of a are less than those of b. The result is a v8i vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8i_and(v8i, v8i)

Operation

for j from 0 to 7
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector

Returns

v8i vector acting like a mask

v8l v8l_lt ( v8l  a, v8l  b  )

related

Compares if elements of a are less than those of b. The result is a v8l vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8l_and(v8l, v8l)

Operation

for j from 0 to 7
  i = j*64
  if a[j] < b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector

Returns

v8l vector acting like a mask

v16f v16f_lt ( v16f  a, v16f  b  )

related

Compares if elements of a are less than those of b. The result is a v16f vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16f_and(v16f, v16f)

Operation

for j from 0 to 15
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector

Returns

v16f vector acting like a mask

v16i v16i_lt ( v16i  a, v16i  b  )

related

Compares if elements of a are less than those of b. The result is a v16i vector where the ith element is all one bits if a[i] < b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16i_and(v16i, v16i)

Operation

for j from 0 to 15
  i = j*32
  if a[j] < b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector

Returns

v16i vector acting like a mask

v1d v1d_leq ( v1d  a, v1d  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v1d vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1d_and(v1d, v1d)

Operation

for j from 0 to 0
  i = j*64
  if a[j] <= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1d input vector
b	second v1d input vector

Returns

v1d vector acting like a mask

v1f v1f_leq ( v1f  a, v1f  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v1f vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1f_and(v1f, v1f)

Operation

for j from 0 to 0
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1f input vector
b	second v1f input vector

Returns

v1f vector acting like a mask

v1i v1i_leq ( v1i  a, v1i  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v1i vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1i_and(v1i, v1i)

Operation

for j from 0 to 0
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v1i input vector
b	second v1i input vector

Returns

v1i vector acting like a mask

v1l v1l_leq ( v1l  a, v1l  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v1l vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v1l_and(v1l, v1l)

Operation

for j from 0 to 0
  i = j*64
  if a[j] <= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v1l input vector
b	second v1l input vector

Returns

v1l vector acting like a mask

v2d v2d_leq ( v2d  a, v2d  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v2d vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2d_and(v2d, v2d)

Operation

for j from 0 to 1
  i = j*64
  if a[j] <= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2d input vector
b	second v2d input vector

Returns

v2d vector acting like a mask

v2f v2f_leq ( v2f  a, v2f  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v2f vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2f_and(v2f, v2f)

Operation

for j from 0 to 1
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2f input vector
b	second v2f input vector

Returns

v2f vector acting like a mask

v2i v2i_leq ( v2i  a, v2i  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v2i vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2i_and(v2i, v2i)

Operation

for j from 0 to 1
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v2i input vector
b	second v2i input vector

Returns

v2i vector acting like a mask

v2l v2l_leq ( v2l  a, v2l  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v2l vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v2l_and(v2l, v2l)

Operation

for j from 0 to 1
  i = j*64
  if a[j] <= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v2l input vector
b	second v2l input vector

Returns

v2l vector acting like a mask

v4d v4d_leq ( v4d  a, v4d  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v4d vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4d_and(v4d, v4d)

Operation

for j from 0 to 3
  i = j*64
  if a[j] <= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4d input vector
b	second v4d input vector

Returns

v4d vector acting like a mask

v4f v4f_leq ( v4f  a, v4f  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v4f vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4f_and(v4f, v4f)

Operation

for j from 0 to 3
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4f input vector
b	second v4f input vector

Returns

v4f vector acting like a mask

v4i v4i_leq ( v4i  a, v4i  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v4i vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4i_and(v4i, v4i)

Operation

for j from 0 to 3
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v4i input vector
b	second v4i input vector

Returns

v4i vector acting like a mask

v4l v4l_leq ( v4l  a, v4l  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v4l vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v4l_and(v4l, v4l)

Operation

for j from 0 to 3
  i = j*64
  if a[j] <= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v4l input vector
b	second v4l input vector

Returns

v4l vector acting like a mask

v8d v8d_leq ( v8d  a, v8d  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v8d vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8d_and(v8d, v8d)

Operation

for j from 0 to 7
  i = j*64
  if a[j] <= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8d input vector
b	second v8d input vector

Returns

v8d vector acting like a mask

v8f v8f_leq ( v8f  a, v8f  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v8f vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8f_and(v8f, v8f)

Operation

for j from 0 to 7
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8f input vector
b	second v8f input vector

Returns

v8f vector acting like a mask

v8i v8i_leq ( v8i  a, v8i  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v8i vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8i_and(v8i, v8i)

Operation

for j from 0 to 7
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v8i input vector
b	second v8i input vector

Returns

v8i vector acting like a mask

v8l v8l_leq ( v8l  a, v8l  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v8l vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v8l_and(v8l, v8l)

Operation

for j from 0 to 7
  i = j*64
  if a[j] <= b[j]
    dst.bits[i:i+63] := 0xFFFFFFFFFFFFFFFF
  else
    dst.bits[i:i+63] := 0
  endif
endfor

Parameters

a	first v8l input vector
b	second v8l input vector

Returns

v8l vector acting like a mask

v16f v16f_leq ( v16f  a, v16f  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v16f vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16f_and(v16f, v16f)

Operation

for j from 0 to 15
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16f input vector
b	second v16f input vector

Returns

v16f vector acting like a mask

v16i v16i_leq ( v16i  a, v16i  b  )

related

Compares if elements of a are less than or equal to those of b. The result is a v16i vector where the ith element is all one bits if a[i] <= b[i] and all zero bits otherwise. The result vector can then be used as a masked using the logical operations such as v16i_and(v16i, v16i)

Operation

for j from 0 to 15
  i = j*32
  if a[j] <= b[j]
    dst.bits[i:i+31] := 0xFFFFFFFF
  else
    dst.bits[i:i+31] := 0
  endif
endfor

Parameters

a	first v16i input vector
b	second v16i input vector

Returns

v16i vector acting like a mask