| AI Engine-ML Intrinsics User Guide (v2026.1)

Loading...
Searching...
No Matches
Shift
Vector Operations

## Overview

These intrinsics allow shifting full vectors.

## Special shift used to perform unaligned loads
v128int4 | shiftx (v128int4 a, v128int4 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v64int8 | shiftx (v64int8 a, v64int8 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v32int16 | shiftx (v32int16 a, v32int16 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v16int32 | shiftx (v16int32 a, v16int32 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v128uint4 | shiftx (v128uint4 a, v128uint4 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v64uint8 | shiftx (v64uint8 a, v64uint8 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v32uint16 | shiftx (v32uint16 a, v32uint16 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v16uint32 | shiftx (v16uint32 a, v16uint32 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v16cint16 | shiftx (v16cint16 a, v16cint16 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v8cint32 | shiftx (v8cint32 a, v8cint32 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v32bfloat16 | shiftx (v32bfloat16 a, v32bfloat16 b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v16cbfloat16 | shiftx (v16cbfloat16 a, v16cbfloat16 b, int step, int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v16accfloat | shiftx (v16accfloat a, v16accfloat b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v16float | shiftx (v16float a, v16float b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:
v8cfloat | shiftx (v8cfloat a, v8cfloat b, int step, unsigned int shift)
| Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

## Lane-by-lane vector shift (in bytes)
v128int4 | shift_bytes (v128int4 a, v128int4 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v64int8 | shift_bytes (v64int8 a, v64int8 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v32int16 | shift_bytes (v32int16 a, v32int16 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v16int32 | shift_bytes (v16int32 a, v16int32 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v128uint4 | shift_bytes (v128uint4 a, v128uint4 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v64uint8 | shift_bytes (v64uint8 a, v64uint8 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v32uint16 | shift_bytes (v32uint16 a, v32uint16 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v16uint32 | shift_bytes (v16uint32 a, v16uint32 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v16cint16 | shift_bytes (v16cint16 a, v16cint16 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v8cint32 | shift_bytes (v8cint32 a, v8cint32 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v32bfloat16 | shift_bytes (v32bfloat16 a, v32bfloat16 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v16cbfloat16 | shift_bytes (v16cbfloat16 a, v16cbfloat16 b, int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v16accfloat | shift_bytes (v16accfloat a, v16accfloat b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v16float | shift_bytes (v16float a, v16float b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].
v8cfloat | shift_bytes (v8cfloat a, v8cfloat b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

## Lane-by-lane vector shift (in elems)
v64int8 | shift (v64int8 a, v64int8 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v32int16 | shift (v32int16 a, v32int16 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v16int32 | shift (v16int32 a, v16int32 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v64uint8 | shift (v64uint8 a, v64uint8 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v32uint16 | shift (v32uint16 a, v32uint16 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v16uint32 | shift (v16uint32 a, v16uint32 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v16cint16 | shift (v16cint16 a, v16cint16 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v8cint32 | shift (v8cint32 a, v8cint32 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v32bfloat16 | shift (v32bfloat16 a, v32bfloat16 b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v16cbfloat16 | shift (v16cbfloat16 a, v16cbfloat16 b, int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v16accfloat | shift (v16accfloat a, v16accfloat b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v16float | shift (v16float a, v16float b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].
v8cfloat | shift (v8cfloat a, v8cfloat b, unsigned int shift)
| Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

## Function Documentation

## ◆ shift() [1/13]

v16accfloat shift | ( | v16accfloat | a,
|  | v16accfloat | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [2/13]

v16cbfloat16 shift | ( | v16cbfloat16 | a,
|  | v16cbfloat16 | b,
|  | int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [3/13]

v16cint16 shift | ( | v16cint16 | a,
|  | v16cint16 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [4/13]

v16float shift | ( | v16float | a,
|  | v16float | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [5/13]

v16int32 shift | ( | v16int32 | a,
|  | v16int32 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [6/13]

v16uint32 shift | ( | v16uint32 | a,
|  | v16uint32 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [7/13]

v32bfloat16 shift | ( | v32bfloat16 | a,
|  | v32bfloat16 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [8/13]

v32int16 shift | ( | v32int16 | a,
|  | v32int16 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [9/13]

v32uint16 shift | ( | v32uint16 | a,
|  | v32uint16 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [10/13]

v64int8 shift | ( | v64int8 | a,
|  | v64int8 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [11/13]

v64uint8 shift | ( | v64uint8 | a,
|  | v64uint8 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [12/13]

v8cfloat shift | ( | v8cfloat | a,
|  | v8cfloat | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift() [13/13]

v8cint32 shift | ( | v8cint32 | a,
|  | v8cint32 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift*elem_size+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of elements to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [1/15]

v128int4 shift_bytes | ( | v128int4 | a,
|  | v128int4 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [2/15]

v128uint4 shift_bytes | ( | v128uint4 | a,
|  | v128uint4 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [3/15]

v16accfloat shift_bytes | ( | v16accfloat | a,
|  | v16accfloat | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [4/15]

v16cbfloat16 shift_bytes | ( | v16cbfloat16 | a,
|  | v16cbfloat16 | b,
|  | int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [5/15]

v16cint16 shift_bytes | ( | v16cint16 | a,
|  | v16cint16 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [6/15]

v16float shift_bytes | ( | v16float | a,
|  | v16float | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [7/15]

v16int32 shift_bytes | ( | v16int32 | a,
|  | v16int32 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [8/15]

v16uint32 shift_bytes | ( | v16uint32 | a,
|  | v16uint32 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [9/15]

v32bfloat16 shift_bytes | ( | v32bfloat16 | a,
|  | v32bfloat16 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [10/15]

v32int16 shift_bytes | ( | v32int16 | a,
|  | v32int16 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [11/15]

v32uint16 shift_bytes | ( | v32uint16 | a,
|  | v32uint16 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [12/15]

v64int8 shift_bytes | ( | v64int8 | a,
|  | v64int8 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [13/15]

v64uint8 shift_bytes | ( | v64uint8 | a,
|  | v64uint8 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [14/15]

v8cfloat shift_bytes | ( | v8cfloat | a,
|  | v8cfloat | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shift_bytes() [15/15]

v8cint32 shift_bytes | ( | v8cint32 | a,
|  | v8cint32 | b,
|  | unsigned int | shift )

Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift:shift+64].

Parameters

  a | value to be concatenated
  b | value to be concatenated
  shift | number of bytes to be shifted

Returns
  shifted vector

## ◆ shiftx() [1/15]

v128int4 shiftx | ( | v128int4 | a,
|  | v128int4 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;
shift
v64int8 shift(v64int8 a, v64int8 b, unsigned int shift)
Concatenates a and b, interprets them as a vector of 128 bytes and returns a::b[shift*elem_size:shift...
Definition me_scl2vec.h:164
concat
unsigned long long concat(unsigned int a, unsigned int b)
Definition me_upd_ext.h:838

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [2/15]

v128uint4 shiftx | ( | v128uint4 | a,
|  | v128uint4 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [3/15]

v16accfloat shiftx | ( | v16accfloat | a,
|  | v16accfloat | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [4/15]

v16cbfloat16 shiftx | ( | v16cbfloat16 | a,
|  | v16cbfloat16 | b,
|  | int | step,
|  | int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [5/15]

v16cint16 shiftx | ( | v16cint16 | a,
|  | v16cint16 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [6/15]

v16float shiftx | ( | v16float | a,
|  | v16float | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [7/15]

v16int32 shiftx | ( | v16int32 | a,
|  | v16int32 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [8/15]

v16uint32 shiftx | ( | v16uint32 | a,
|  | v16uint32 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [9/15]

v32bfloat16 shiftx | ( | v32bfloat16 | a,
|  | v32bfloat16 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [10/15]

v32int16 shiftx | ( | v32int16 | a,
|  | v32int16 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [11/15]

v32uint16 shiftx | ( | v32uint16 | a,
|  | v32uint16 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [12/15]

v64int8 shiftx | ( | v64int8 | a,
|  | v64int8 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [13/15]

v64uint8 shiftx | ( | v64uint8 | a,
|  | v64uint8 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [14/15]

v8cfloat shiftx | ( | v8cfloat | a,
|  | v8cfloat | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector

## ◆ shiftx() [15/15]

v8cint32 shiftx | ( | v8cint32 | a,
|  | v8cint32 | b,
|  | int | step,
|  | unsigned int | shift )

Shifts `a` by 2^step for step >= 1. Then it ORs the result with b right-shifted shift bytes. Each value except of shift are considered to be 64 elements of bytes. When step is zero, then it behaves like a regular shift. The pseudo-code can be described as follows:

mask = concat(-1, 0) >> shift;
a' = concat (a, 0);
a' = (a' >> step) & mask;
c = concat(0, b) >> shift;
return a' | c;

Parameters

  a | value to be concatenated
  b | value to be concatenated
  step | amount of preshift on a (0: 0 bits, 1: 32 bits, 2: 64 bits, 3: 128 bits, 4: 256 bits)
  shift | number of bytes to shift b

Returns
  shifted vector