| AI Engine Intrinsics User Guide (v2026.1)

Loading...
Searching...
No Matches
Updates
Intrinsics » Vector Conversions

Vector update intrinsic functions allow substitution of the lanes within a vector value. More...

## Overview

Vector update intrinsic functions allow substitution of the lanes within a vector value.

Below the buffer sizes are as follows: V - 128 bit W - 256 bit X - 512 bit Y - 1024 bit

For more information see Integer Vector Types.

Note
  All intrinsics require a compile time constant for the idx parameter.

### load_hi and load_lo intrinsic functions

Updates the a 48/80 bit accumulator from a 64/128 bit integer vector. Uses the saturation mode set by the user. load_lo updates the lower lanes of the accumulator and load_hi the higher ones.

### upd_hi and upd_lo intrinsic functions

Update the top half or bottom half of the lanes within a data type.

### upd_v({W,X,Y} buf,int idx,V val) 128-bit intrinsic functions

`upd_v(buf,0...7,val)` update the successive 128-bit lanes into a 256/512/1024 bit vector.

In the following example, a large 32-way complex vector is updated 4 elements at-a-time using a 128-bit update. The notation "XX++" in comments shows the starting element index of the lane being updated. While the notation "XX.." shows that the lane update was initiated in a prior cycle. This example also shows that the updates can be pipelined.

const v4cint16 * input = d_in;
v32cint16 sbuff = undef_v32cint16();
...
sbuff = upd_v(sbuff,0, *input++); // 00++|____|____|____ ____|____|____|____
sbuff = upd_v(sbuff,1, *input++); // 00..|04++|____|____ ____|____|____|____
v32cint16
Definition me_chess.h:456
v4cint16
Definition me_chess.h:413
upd_v
promotion v32int8 upd_v(v32int8, int, v16int8)
Update a 256-bit vector 16 elements at a time using a 128-bit update.
undef_v32cint16
v32cint16 undef_v32cint16()

### upd_w({X,Y} buf,int idx,W val) 256-bit intrinsic functions

`upd_w(buf,0...3,val)` update the successive 256-bit lanes into a 512/1024 bit vector.

The following example shows the update of a large 32-way complex vector 8 elements at-a-time using a 256-bit update. These updates are also pipelined.

const v8cint16 * input = d_in;
v32cint16 sbuff = undef_v32cint16();
...
sbuff = upd_w(sbuff,0, *input_++); // 00++|04++|____|____ ____|____|____|____
sbuff = upd_w(sbuff,1, *input_++); // 00..|04..|08++|12++ ____|____|____|____
v8cint16
Definition me_chess.h:428
upd_w
promotion v64int8 upd_w(v64int8, int, v32int8)
Update a 512-bit vector 32 elements at a time using a 256-bit update.

### upd_x(Y buf,int idx,X val) 512-bit intrinsic functions

`upd_x(buf,0...1,val)` update the successive 512-bit lanes into a 1024 bit vector.

The following example shows the update of a large 32-way complex vector 16 elements at-a-time using a 512-bit update. These updates are also pipelined.

const v16cint16 * input = d_in;
v32cint16 sbuff = undef_v32cint16();
...
sbuff = upd_x(sbuff,0, *input_++); // 00++|04++|08++|12++ ____|____|____|____
sbuff = upd_x(sbuff,1, *input_++); // 00..|04..|08..|12.. 16++|20++|24++|28++
v16cint16
Definition me_chess.h:442
upd_x
promotion v128int8 upd_x(v128int8, int, v64int8)
Update a 1024-bit vector 64 elements at a time using a 512-bit update.

## Accumulator load operations
v8acc48 | load_lo (v8acc48 acc, v4int64 vec)
| Load the 64 bit from the vector saturated in a 48 bit accumulator. This is done for the 4 lower lanes.
v8acc48 | load_hi (v8acc48 acc, v4int64 vec)
| Load the 64 bit from the vector saturated in a 48 bit accumulator. This is done for the 4 higher lanes.
v4cacc48 | load_lo (v4cacc48 acc, v2cint64 vec)
| Load the 64 bit from the vector saturated in a 48 bit accumulator. This is done for the 2 lower lanes.
v4cacc48 | load_hi (v4cacc48 acc, v2cint64 vec)
| Load the 64 bit from the vector saturated in a 48 bit accumulator. This is done for the 2 higher lanes.
v4acc80 | load_lo (v4acc80 acc, v2int128 vec)
| Load the 128 bit from the vector saturated in a 80 bit accumulator. This is done for the 2 lower lanes.
v4acc80 | load_hi (v4acc80 acc, v2int128 vec)
| Load the 128 bit from the vector saturated in a 80 bit accumulator. This is done for the 2 higher lanes.
v2cacc80 | load_lo (v2cacc80 acc, v1cint128 vec)
| Load the 128 bit from the vector saturated in a 80 bit accumulator. This is done for the 1 lower lanes.
v2cacc80 | load_hi (v2cacc80 acc, v1cint128 vec)
| Load the 128 bit from the vector saturated in a 80 bit accumulator. This is done for the 1 higher lanes.

## Vector Unpacking Operations
v16int16 | unpack (v16int8 vec)
| Load and unpack vectors These intrinsics can only be used coupled with a memory access operation. Ex: v16int16 vec = unpack(<em>src);//where src is v16int8
v16int16 | unpack (v16uint8 vec)
| Load and unpack vectors These intrinsics can only be used coupled with a memory access operation. Ex: v16int16 vec = unpack(<em>src);//where src is v16int8
v32int16 | unpack (v32int8 vec)
| Load and unpack vectors These intrinsics can only be used coupled with a memory access operation. Ex: v16int16 vec = unpack(<em>src);//where src is v16int8
v32int16 | unpack (v32uint8 vec)
| Load and unpack vectors These intrinsics can only be used coupled with a memory access operation. Ex: v16int16 vec = unpack(<em>src);//where src is v16int8

## 128-bit lane update into 256-bit vector
Update the successive 128-bit lanes in a 256-bit vector. idx parameter must be a compile time constant.
promotion v32int8 | upd_v (v32int8, int, v16int8)
| Update a 256-bit vector 16 elements at a time using a 128-bit update.
promotion v32uint8 | upd_v (v32uint8, int, v16uint8)
| Update a 256-bit vector 16 elements at a time using a 128-bit update.
promotion v16int16 | upd_v (v16int16, int, v8int16)
| Update a 256-bit vector 8 elements at a time using a 128-bit update.
promotion v8cint16 | upd_v (v8cint16, int, v4cint16)
| Update a 256-bit vector 4 elements at a time using a 128-bit update.
promotion v8int32 | upd_v (v8int32, int, v4int32)
| Update a 256-bit vector 4 elements at a time using a 128-bit update.
promotion v4cint32 | upd_v (v4cint32, int, v2cint32)
| Update a 256-bit vector 2 elements at a time using a 128-bit update.
promotion v8float | upd_v (v8float, int, v4float)
| Update a 256-bit vector 4 elements at a time using a 128-bit update.
promotion v4cfloat | upd_v (v4cfloat, int, v2cfloat)
| Update a 256-bit vector 2 elements at a time using a 128-bit update.

## 128-bit lane update into 512-bit vector
Update the successive 128-bit lanes in a 512-bit vector. idx parameter must be a compile time constant.
promotion v64int8 | upd_v (v64int8, int, v16int8)
| Update a 512-bit vector 16 elements at a time using a 128-bit update.
promotion v64uint8 | upd_v (v64uint8, int, v16uint8)
| Update a 512-bit vector 16 elements at a time using a 128-bit update.
promotion v32int16 | upd_v (v32int16, int, v8int16)
| Update a 512-bit vector 8 elements at a time using a 128-bit update.
promotion v16cint16 | upd_v (v16cint16, int, v4cint16)
| Update a 512-bit vector 4 elements at a time using a 128-bit update.
promotion v16int32 | upd_v (v16int32, int, v4int32)
| Update a 512-bit vector 4 elements at a time using a 128-bit update.
promotion v8cint32 | upd_v (v8cint32, int, v2cint32)
| Update a 512-bit vector 2 elements at a time using a 128-bit update.
promotion v16float | upd_v (v16float, int, v4float)
| Update a 512-bit vector 4 elements at a time using a 128-bit update.
promotion v8cfloat | upd_v (v8cfloat, int, v2cfloat)
| Update a 512-bit vector 2 elements at a time using a 128-bit update.

## 128-bit lane update into 1024-bit vector
Set 128-bit lanes in a 1024-bit vector.
promotion v128int8 | upd_v (v128int8, int, v16int8)
| Update a 1024-bit vector 16 elements at a time using a 128-bit update.
promotion v128uint8 | upd_v (v128uint8, int, v16uint8)
| Update a 1024-bit vector 16 elements at a time using a 128-bit update.
promotion v64int16 | upd_v (v64int16, int, v8int16)
| Update a 1024-bit vector 8 elements at a time using a 128-bit update.
promotion v32cint16 | upd_v (v32cint16, int, v4cint16)
| Update a 1024-bit vector 4 elements at a time using a 128-bit update.
promotion v32int32 | upd_v (v32int32, int, v4int32)
| Update a 1024-bit vector 4 elements at a time using a 128-bit update.
promotion v16cint32 | upd_v (v16cint32, int, v2cint32)
| Update a 1024-bit vector 2 elements at a time using a 128-bit update.
promotion v32float | upd_v (v32float, int, v4float)
| Update a 1024-bit vector 4 elements at a time using a 128-bit update.
promotion v16cfloat | upd_v (v16cfloat, int, v2cfloat)
| Update a 1024-bit vector 2 elements at a time using a 128-bit update.
promotion v128int8 | yset_v (int, v16int8)
| Creates a new 1024-bit vector with 16 elements already set using a 128-bit set.
promotion v128uint8 | yset_v (int, v16uint8)
| Creates a new 1024-bit vector with 16 elements already set using a 128-bit set.
promotion v64int16 | yset_v (int, v8int16)
| Creates a new 1024-bit vector with 8 elements already set using a 128-bit set.
promotion v32cint16 | yset_v (int, v4cint16)
| Creates a new 1024-bit vector with 4 elements already set using a 128-bit set.
promotion v32int32 | yset_v (int, v4int32)
| Creates a new 1024-bit vector with 4 elements already set using a 128-bit set.
promotion v16cint32 | yset_v (int, v2cint32)
| Creates a new 1024-bit vector with 2 elements already set using a 128-bit set.
promotion v32float | yset_v (int, v4float)
| Creates a new 1024-bit vector with 4 elements already set using a 128-bit set.
promotion v16cfloat | yset_v (int, v2cfloat)
| Creates a new 1024-bit vector with 2 elements already set using a 128-bit set.

## 256-bit lane update into 512-bit vector
Update 256-bit lanes in a 512-bit vector. idx parameter must be a compile time constant.
promotion v64int8 | upd_w (v64int8, int, v32int8)
| Update a 512-bit vector 32 elements at a time using a 256-bit update.
promotion v64uint8 | upd_w (v64uint8, int, v32uint8)
| Update a 512-bit vector 32 elements at a time using a 256-bit update.
promotion v32int16 | upd_w (v32int16, int, v16int16)
| Update a 512-bit vector 16 elements at a time using a 256-bit update.
promotion v16cint16 | upd_w (v16cint16, int, v8cint16)
| Update a 512-bit vector 8 elements at a time using a 256-bit update.
promotion v16int32 | upd_w (v16int32, int, v8int32)
| Update a 512-bit vector 8 elements at a time using a 256-bit update.
promotion v8cint32 | upd_w (v8cint32, int, v4cint32)
| Update a 512-bit vector 4 elements at a time using a 256-bit update.
promotion v16float | upd_w (v16float, int, v8float)
| Update a 512-bit vector 8 elements at a time using a 256-bit update.
promotion v8cfloat | upd_w (v8cfloat, int, v4cfloat)
| Update a 512-bit vector 4 elements at a time using a 256-bit update.

## 256-bit lane update into 1024-bit vector
Update 256-bit lanes in a 1024-bit vector.
promotion v128int8 | upd_w (v128int8, int, v32int8)
| Update a 1024-bit vector 32 elements at a time using a 256-bit update.
promotion v128uint8 | upd_w (v128uint8, int, v32uint8)
| Update a 1024-bit vector 32 elements at a time using a 256-bit update.
promotion v64int16 | upd_w (v64int16, int, v16int16)
| Update a 1024-bit vector 16 elements at a time using a 256-bit update.
promotion v32cint16 | upd_w (v32cint16, int, v8cint16)
| Update a 1024-bit vector 8 elements at a time using a 256-bit update.
promotion v32int32 | upd_w (v32int32, int, v8int32)
| Update a 1024-bit vector 8 elements at a time using a 256-bit update.
promotion v16cint32 | upd_w (v16cint32, int, v4cint32)
| Update a 1024-bit vector 4 elements at a time using a 256-bit update.
promotion v32float | upd_w (v32float, int, v8float)
| Update a 1024-bit vector 8 elements at a time using a 256-bit update.
promotion v16cfloat | upd_w (v16cfloat, int, v4cfloat)
| Update a 1024-bit vector 4 elements at a time using a 256-bit update.

## 512-bit lane update into 1024-bit vector
Update 512-bit lanes in a 1024-bit vector. idx parameter must be a compile time constant.
promotion v128int8 | upd_x (v128int8, int, v64int8)
| Update a 1024-bit vector 64 elements at a time using a 512-bit update.
promotion v128uint8 | upd_x (v128uint8, int, v64uint8)
| Update a 1024-bit vector 64 elements at a time using a 512-bit update.
promotion v64int16 | upd_x (v64int16, int, v32int16)
| Update a 1024-bit vector 32 elements at a time using a 512-bit update.
promotion v32cint16 | upd_x (v32cint16, int, v16cint16)
| Update a 1024-bit vector 16 elements at a time using a 512-bit update.
promotion v32int32 | upd_x (v32int32, int, v16int32)
| Update a 1024-bit vector 16 elements at a time using a 512-bit update.
promotion v16cint32 | upd_x (v16cint32, int, v8cint32)
| Update a 1024-bit vector 8 elements at a time using a 512-bit update.
promotion v32float | upd_x (v32float, int, v16float)
| Update a 1024-bit vector 16 elements at a time using a 512-bit update.
promotion v16cfloat | upd_x (v16cfloat, int, v8cfloat)
| Update a 1024-bit vector 8 elements at a time using a 512-bit update.

## 320/384-bit lane update into 640/768-bit accumulator
v16acc48 | upd_lo (v16acc48, v8acc48)
v16acc48 | upd_hi (v16acc48, v8acc48)
v8cacc48 | upd_lo (v8cacc48, v4cacc48)
v8cacc48 | upd_hi (v8cacc48, v4cacc48)
v8acc80 | upd_lo (v8acc80, v4acc80)
v8acc80 | upd_hi (v8acc80, v4acc80)
v4cacc80 | upd_lo (v4cacc80, v2cacc80)
v4cacc80 | upd_hi (v4cacc80, v2cacc80)

## Float accumulator updates
v8accfloat | upd_lo (v8accfloat, v4accfloat)
v16accfloat | upd_lo (v16accfloat, v8accfloat)
v32accfloat | upd_lo (v32accfloat, v16accfloat)
v8accfloat | upd_hi (v8accfloat, v4accfloat)
v16accfloat | upd_hi (v16accfloat, v8accfloat)
v32accfloat | upd_hi (v32accfloat, v16accfloat)
v4caccfloat | upd_lo (v4caccfloat, v2caccfloat)
v8caccfloat | upd_lo (v8caccfloat, v4caccfloat)
v16caccfloat | upd_lo (v4caccfloat, v8caccfloat)
v4caccfloat | upd_hi (v4caccfloat, v2caccfloat)
v8caccfloat | upd_hi (v8caccfloat, v4caccfloat)
v16caccfloat | upd_hi (v4caccfloat, v8caccfloat)

## Updates for configuration registers
mac_idx | upd0 (mac_idx, unsigned int)
mac_idx | upd1 (mac_idx, unsigned int)
pmx_idx | upd0 (pmx_idx, unsigned int)
pmx_idx | upd1 (pmx_idx, unsigned int)
pmx_idx | upd2 (pmx_idx, unsigned int)

## Function Documentation

## ◆ load_hi() [1/4]

v2cacc80 load_hi | ( | v2cacc80 | acc,
|  | v1cint128 | vec )

Load the 128 bit from the vector saturated in a 80 bit accumulator. This is done for the 1 higher lanes.

Parameters

  acc | Target accumulator
  vec | Input vector

Returns
  The Updated accumulator

## ◆ load_hi() [2/4]

v4acc80 load_hi | ( | v4acc80 | acc,
|  | v2int128 | vec )

Load the 128 bit from the vector saturated in a 80 bit accumulator. This is done for the 2 higher lanes.

Parameters

  acc | Target accumulator
  vec | Input vector

Returns
  The Updated accumulator

## ◆ load_hi() [3/4]

v4cacc48 load_hi | ( | v4cacc48 | acc,
|  | v2cint64 | vec )

Load the 64 bit from the vector saturated in a 48 bit accumulator. This is done for the 2 higher lanes.

Parameters

  acc | Target accumulator
  vec | Input vector

Returns
  The Updated accumulator

## ◆ load_hi() [4/4]

v8acc48 load_hi | ( | v8acc48 | acc,
|  | v4int64 | vec )

Load the 64 bit from the vector saturated in a 48 bit accumulator. This is done for the 4 higher lanes.

Parameters

  acc | Target accumulator
  vec | Input vector

Returns
  The Updated accumulator

## ◆ load_lo() [1/4]

v2cacc80 load_lo | ( | v2cacc80 | acc,
|  | v1cint128 | vec )

Load the 128 bit from the vector saturated in a 80 bit accumulator. This is done for the 1 lower lanes.

Parameters

  acc | Target accumulator
  vec | Input vector

Returns
  The Updated accumulator

## ◆ load_lo() [2/4]

v4acc80 load_lo | ( | v4acc80 | acc,
|  | v2int128 | vec )

Load the 128 bit from the vector saturated in a 80 bit accumulator. This is done for the 2 lower lanes.

Parameters

  acc | Target accumulator
  vec | Input vector

Returns
  The Updated accumulator

## ◆ load_lo() [3/4]

v4cacc48 load_lo | ( | v4cacc48 | acc,
|  | v2cint64 | vec )

Load the 64 bit from the vector saturated in a 48 bit accumulator. This is done for the 2 lower lanes.

Parameters

  acc | Target accumulator
  vec | Input vector

Returns
  The Updated accumulator

## ◆ load_lo() [4/4]

v8acc48 load_lo | ( | v8acc48 | acc,
|  | v4int64 | vec )

Load the 64 bit from the vector saturated in a 48 bit accumulator. This is done for the 4 lower lanes.

Parameters

  acc | Target accumulator
  vec | Input vector

Returns
  The Updated accumulator

## ◆ unpack() [1/4]

v16int16 unpack | ( | v16int8 | vec | ) |

Load and unpack vectors These intrinsics can only be used coupled with a memory access operation. Ex: v16int16 vec = unpack(<em>src);//where src is v16int8

## ◆ unpack() [2/4]

v16int16 unpack | ( | v16uint8 | vec | ) |

Load and unpack vectors These intrinsics can only be used coupled with a memory access operation. Ex: v16int16 vec = unpack(<em>src);//where src is v16int8

## ◆ unpack() [3/4]

v32int16 unpack | ( | v32int8 | vec | ) |

Load and unpack vectors These intrinsics can only be used coupled with a memory access operation. Ex: v16int16 vec = unpack(<em>src);//where src is v16int8

## ◆ unpack() [4/4]

v32int16 unpack | ( | v32uint8 | vec | ) |

Load and unpack vectors These intrinsics can only be used coupled with a memory access operation. Ex: v16int16 vec = unpack(<em>src);//where src is v16int8

## ◆ upd0() [1/2]

mac_idx upd0 | ( | mac_idx | ,
|  | unsigned int | )

## ◆ upd0() [2/2]

pmx_idx upd0 | ( | pmx_idx | ,
|  | unsigned int | )

## ◆ upd1() [1/2]

mac_idx upd1 | ( | mac_idx | ,
|  | unsigned int | )

## ◆ upd1() [2/2]

pmx_idx upd1 | ( | pmx_idx | ,
|  | unsigned int | )

## ◆ upd2()

pmx_idx upd2 | ( | pmx_idx | ,
|  | unsigned int | )

## ◆ upd_hi() [1/10]

v16acc48 upd_hi | ( | v16acc48 | ,
|  | v8acc48 | )

## ◆ upd_hi() [2/10]

v16accfloat upd_hi | ( | v16accfloat | ,
|  | v8accfloat | )

## ◆ upd_hi() [3/10]

v32accfloat upd_hi | ( | v32accfloat | ,
|  | v16accfloat | )

## ◆ upd_hi() [4/10]

v4cacc80 upd_hi | ( | v4cacc80 | ,
|  | v2cacc80 | )

## ◆ upd_hi() [5/10]

v4caccfloat upd_hi | ( | v4caccfloat | ,
|  | v2caccfloat | )

## ◆ upd_hi() [6/10]

v16caccfloat upd_hi | ( | v4caccfloat | ,
|  | v8caccfloat | )

## ◆ upd_hi() [7/10]

v8acc80 upd_hi | ( | v8acc80 | ,
|  | v4acc80 | )

## ◆ upd_hi() [8/10]

v8accfloat upd_hi | ( | v8accfloat | ,
|  | v4accfloat | )

## ◆ upd_hi() [9/10]

v8cacc48 upd_hi | ( | v8cacc48 | ,
|  | v4cacc48 | )

## ◆ upd_hi() [10/10]

v8caccfloat upd_hi | ( | v8caccfloat | ,
|  | v4caccfloat | )

## ◆ upd_lo() [1/10]

v16acc48 upd_lo | ( | v16acc48 | ,
|  | v8acc48 | )

## ◆ upd_lo() [2/10]

v16accfloat upd_lo | ( | v16accfloat | ,
|  | v8accfloat | )

## ◆ upd_lo() [3/10]

v32accfloat upd_lo | ( | v32accfloat | ,
|  | v16accfloat | )

## ◆ upd_lo() [4/10]

v4cacc80 upd_lo | ( | v4cacc80 | ,
|  | v2cacc80 | )

## ◆ upd_lo() [5/10]

v4caccfloat upd_lo | ( | v4caccfloat | ,
|  | v2caccfloat | )

## ◆ upd_lo() [6/10]

v16caccfloat upd_lo | ( | v4caccfloat | ,
|  | v8caccfloat | )

## ◆ upd_lo() [7/10]

v8acc80 upd_lo | ( | v8acc80 | ,
|  | v4acc80 | )

## ◆ upd_lo() [8/10]

v8accfloat upd_lo | ( | v8accfloat | ,
|  | v4accfloat | )

## ◆ upd_lo() [9/10]

v8cacc48 upd_lo | ( | v8cacc48 | ,
|  | v4cacc48 | )

## ◆ upd_lo() [10/10]

v8caccfloat upd_lo | ( | v8caccfloat | ,
|  | v4caccfloat | )

## ◆ upd_v() [1/24]

promotion v128int8 upd_v | ( | v128int8 | ,
|  | int | ,
|  | v16int8 | )

Update a 1024-bit vector 16 elements at a time using a 128-bit update.

v128int8 sbuff = undef_v128int8();
v128int8
Definition me_chess.h:452
undef_v128int8
v128int8 undef_v128int8()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 7. Used to choose which set of 16 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_v() [2/24]

promotion v128uint8 upd_v | ( | v128uint8 | ,
|  | int | ,
|  | v16uint8 | )

Update a 1024-bit vector 16 elements at a time using a 128-bit update.

v128uint8 sbuff = undef_v128uint8();
v128uint8
Definition me_chess.h:453
undef_v128uint8
v128uint8 undef_v128uint8()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 7. Used to choose which set of 16 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_v() [3/24]

promotion v16cfloat upd_v | ( | v16cfloat | ,
|  | int | ,
|  | v2cfloat | )

Update a 1024-bit vector 2 elements at a time using a 128-bit update.

v16cfloat sbuff = undef_v16cfloat();
v16cfloat
Definition me_chess.h:499
undef_v16cfloat
v16cfloat undef_v16cfloat()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 7. Used to choose which set of 2 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_v() [4/24]

promotion v16cint16 upd_v | ( | v16cint16 | ,
|  | int | ,
|  | v4cint16 | )

Update a 512-bit vector 4 elements at a time using a 128-bit update.

v16cint16 sbuff = undef_v16cint16();
undef_v16cint16
v16cint16 undef_v16cint16()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 4 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [5/24]

promotion v16cint32 upd_v | ( | v16cint32 | ,
|  | int | ,
|  | v2cint32 | )

Update a 1024-bit vector 2 elements at a time using a 128-bit update.

v16cint32 sbuff = undef_v16cint32();
v16cint32
Definition me_chess.h:457
undef_v16cint32
v16cint32 undef_v16cint32()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 7. Used to choose which set of 2 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_v() [6/24]

promotion v16float upd_v | ( | v16float | ,
|  | int | ,
|  | v4float | )

Update a 512-bit vector 4 elements at a time using a 128-bit update.

v16float sbuff = undef_v16float();
v16float
Definition me_chess.h:494
undef_v16float
v16float undef_v16float()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 4 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [7/24]

promotion v16int16 upd_v | ( | v16int16 | ,
|  | int | ,
|  | v8int16 | )

Update a 256-bit vector 8 elements at a time using a 128-bit update.

v16int16 sbuff = undef_v16int16();
v16int16
Definition me_chess.h:421
undef_v16int16
v16int16 undef_v16int16()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 8 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [8/24]

promotion v16int32 upd_v | ( | v16int32 | ,
|  | int | ,
|  | v4int32 | )

Update a 512-bit vector 4 elements at a time using a 128-bit update.

v16int32 sbuff = undef_v16int32();
v16int32
Definition me_chess.h:441
undef_v16int32
v16int32 undef_v16int32()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 4 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [9/24]

promotion v32cint16 upd_v | ( | v32cint16 | ,
|  | int | ,
|  | v4cint16 | )

Update a 1024-bit vector 4 elements at a time using a 128-bit update.

v32cint16 sbuff = undef_v32cint16();
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 7. Used to choose which set of 4 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_v() [10/24]

promotion v32float upd_v | ( | v32float | ,
|  | int | ,
|  | v4float | )

Update a 1024-bit vector 4 elements at a time using a 128-bit update.

v32float sbuff = undef_v32float();
v32float
Definition me_chess.h:495
undef_v32float
v32float undef_v32float()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 7. Used to choose which set of 4 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_v() [11/24]

promotion v32int16 upd_v | ( | v32int16 | ,
|  | int | ,
|  | v8int16 | )

Update a 512-bit vector 8 elements at a time using a 128-bit update.

v32int16 sbuff = undef_v32int16();
v32int16
Definition me_chess.h:440
undef_v32int16
v32int16 undef_v32int16()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 8 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [12/24]

promotion v32int32 upd_v | ( | v32int32 | ,
|  | int | ,
|  | v4int32 | )

Update a 1024-bit vector 4 elements at a time using a 128-bit update.

v32int32 sbuff = undef_v32int32();
v32int32
Definition me_chess.h:455
undef_v32int32
v32int32 undef_v32int32()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 7. Used to choose which set of 4 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_v() [13/24]

promotion v32int8 upd_v | ( | v32int8 | ,
|  | int | ,
|  | v16int8 | )

Update a 256-bit vector 16 elements at a time using a 128-bit update.

v32int8 sbuff = undef_v32int8();
v32int8
Definition me_chess.h:419
undef_v32int8
v32int8 undef_v32int8()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 16 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [14/24]

promotion v32uint8 upd_v | ( | v32uint8 | ,
|  | int | ,
|  | v16uint8 | )

Update a 256-bit vector 16 elements at a time using a 128-bit update.

v32uint8 sbuff = undef_v32uint8();
v32uint8
Definition me_chess.h:420
undef_v32uint8
v32uint8 undef_v32uint8()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 16 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [15/24]

promotion v4cfloat upd_v | ( | v4cfloat | ,
|  | int | ,
|  | v2cfloat | )

Update a 256-bit vector 2 elements at a time using a 128-bit update.

v4cfloat sbuff = undef_v4cfloat();
v4cfloat
Definition me_chess.h:497
undef_v4cfloat
v4cfloat undef_v4cfloat()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 2 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [16/24]

promotion v4cint32 upd_v | ( | v4cint32 | ,
|  | int | ,
|  | v2cint32 | )

Update a 256-bit vector 2 elements at a time using a 128-bit update.

v4cint32 sbuff = undef_v4cint32();
v4cint32
Definition me_chess.h:429
undef_v4cint32
v4cint32 undef_v4cint32()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 2 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [17/24]

promotion v64int16 upd_v | ( | v64int16 | ,
|  | int | ,
|  | v8int16 | )

Update a 1024-bit vector 8 elements at a time using a 128-bit update.

v64int16 sbuff = undef_v64int16();
v64int16
Definition me_chess.h:454
undef_v64int16
v64int16 undef_v64int16()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 7. Used to choose which set of 8 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_v() [18/24]

promotion v64int8 upd_v | ( | v64int8 | ,
|  | int | ,
|  | v16int8 | )

Update a 512-bit vector 16 elements at a time using a 128-bit update.

v64int8 sbuff = undef_v64int8();
v64int8
Definition me_chess.h:438
undef_v64int8
v64int8 undef_v64int8()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 16 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [19/24]

promotion v64uint8 upd_v | ( | v64uint8 | ,
|  | int | ,
|  | v16uint8 | )

Update a 512-bit vector 16 elements at a time using a 128-bit update.

v64uint8 sbuff = undef_v64uint8();
v64uint8
Definition me_chess.h:439
undef_v64uint8
v64uint8 undef_v64uint8()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 16 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [20/24]

promotion v8cfloat upd_v | ( | v8cfloat | ,
|  | int | ,
|  | v2cfloat | )

Update a 512-bit vector 2 elements at a time using a 128-bit update.

v8cfloat sbuff = undef_v8cfloat();
v8cfloat
Definition me_chess.h:498
undef_v8cfloat
v8cfloat undef_v8cfloat()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 2 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [21/24]

promotion v8cint16 upd_v | ( | v8cint16 | ,
|  | int | ,
|  | v4cint16 | )

Update a 256-bit vector 4 elements at a time using a 128-bit update.

v8cint16 sbuff = undef_v8cint16();
undef_v8cint16
v8cint16 undef_v8cint16()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 4 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [22/24]

promotion v8cint32 upd_v | ( | v8cint32 | ,
|  | int | ,
|  | v2cint32 | )

Update a 512-bit vector 2 elements at a time using a 128-bit update.

v8cint32 sbuff = undef_v8cint32();
v8cint32
Definition me_chess.h:443
undef_v8cint32
v8cint32 undef_v8cint32()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 2 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [23/24]

promotion v8float upd_v | ( | v8float | ,
|  | int | ,
|  | v4float | )

Update a 256-bit vector 4 elements at a time using a 128-bit update.

v8float sbuff = undef_v8float();
v8float
Definition me_chess.h:493
undef_v8float
v8float undef_v8float()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 4 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_v() [24/24]

promotion v8int32 upd_v | ( | v8int32 | ,
|  | int | ,
|  | v4int32 | )

Update a 256-bit vector 4 elements at a time using a 128-bit update.

v8int32 sbuff = undef_v8int32();
v8int32
Definition me_chess.h:422
undef_v8int32
v8int32 undef_v8int32()
sbuff = upd_v(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 4 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_w() [1/16]

promotion v128int8 upd_w | ( | v128int8 | ,
|  | int | ,
|  | v32int8 | )

Update a 1024-bit vector 32 elements at a time using a 256-bit update.

v128int8 sbuff = undef_v128int8();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 32 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_w() [2/16]

promotion v128uint8 upd_w | ( | v128uint8 | ,
|  | int | ,
|  | v32uint8 | )

Update a 1024-bit vector 32 elements at a time using a 256-bit update.

v128uint8 sbuff = undef_v128uint8();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 32 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_w() [3/16]

promotion v16cfloat upd_w | ( | v16cfloat | ,
|  | int | ,
|  | v4cfloat | )

Update a 1024-bit vector 4 elements at a time using a 256-bit update.

v16cfloat sbuff = undef_v16cfloat();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 4 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_w() [4/16]

promotion v16cint16 upd_w | ( | v16cint16 | ,
|  | int | ,
|  | v8cint16 | )

Update a 512-bit vector 8 elements at a time using a 256-bit update.

v16cint16 sbuff = undef_v16cint16();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 8 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_w() [5/16]

promotion v16cint32 upd_w | ( | v16cint32 | ,
|  | int | ,
|  | v4cint32 | )

Update a 1024-bit vector 4 elements at a time using a 256-bit update.

v16cint32 sbuff = undef_v16cint32();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 4 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_w() [6/16]

promotion v16float upd_w | ( | v16float | ,
|  | int | ,
|  | v8float | )

Update a 512-bit vector 8 elements at a time using a 256-bit update.

v16float sbuff = undef_v16float();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 8 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_w() [7/16]

promotion v16int32 upd_w | ( | v16int32 | ,
|  | int | ,
|  | v8int32 | )

Update a 512-bit vector 8 elements at a time using a 256-bit update.

v16int32 sbuff = undef_v16int32();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 8 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_w() [8/16]

promotion v32cint16 upd_w | ( | v32cint16 | ,
|  | int | ,
|  | v8cint16 | )

Update a 1024-bit vector 8 elements at a time using a 256-bit update.

v32cint16 sbuff = undef_v32cint16();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 8 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_w() [9/16]

promotion v32float upd_w | ( | v32float | ,
|  | int | ,
|  | v8float | )

Update a 1024-bit vector 8 elements at a time using a 256-bit update.

v32float sbuff = undef_v32float();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 8 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_w() [10/16]

promotion v32int16 upd_w | ( | v32int16 | ,
|  | int | ,
|  | v16int16 | )

Update a 512-bit vector 16 elements at a time using a 256-bit update.

v32int16 sbuff = undef_v32int16();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 16 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_w() [11/16]

promotion v32int32 upd_w | ( | v32int32 | ,
|  | int | ,
|  | v8int32 | )

Update a 1024-bit vector 8 elements at a time using a 256-bit update.

v32int32 sbuff = undef_v32int32();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 8 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_w() [12/16]

promotion v64int16 upd_w | ( | v64int16 | ,
|  | int | ,
|  | v16int16 | )

Update a 1024-bit vector 16 elements at a time using a 256-bit update.

v64int16 sbuff = undef_v64int16();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 3. Used to choose which set of 16 elements in buf will be updated by val. idx must be a compile time constant
  val | Input vector used to update buf

## ◆ upd_w() [13/16]

promotion v64int8 upd_w | ( | v64int8 | ,
|  | int | ,
|  | v32int8 | )

Update a 512-bit vector 32 elements at a time using a 256-bit update.

v64int8 sbuff = undef_v64int8();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 32 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_w() [14/16]

promotion v64uint8 upd_w | ( | v64uint8 | ,
|  | int | ,
|  | v32uint8 | )

Update a 512-bit vector 32 elements at a time using a 256-bit update.

v64uint8 sbuff = undef_v64uint8();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 32 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_w() [15/16]

promotion v8cfloat upd_w | ( | v8cfloat | ,
|  | int | ,
|  | v4cfloat | )

Update a 512-bit vector 4 elements at a time using a 256-bit update.

v8cfloat sbuff = undef_v8cfloat();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 4 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_w() [16/16]

promotion v8cint32 upd_w | ( | v8cint32 | ,
|  | int | ,
|  | v4cint32 | )

Update a 512-bit vector 4 elements at a time using a 256-bit update.

v8cint32 sbuff = undef_v8cint32();
sbuff = upd_w(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 4 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_x() [1/8]

promotion v128int8 upd_x | ( | v128int8 | ,
|  | int | ,
|  | v64int8 | )

Update a 1024-bit vector 64 elements at a time using a 512-bit update.

v128int8 sbuff = undef_v128int8();
sbuff = upd_x(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 64 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_x() [2/8]

promotion v128uint8 upd_x | ( | v128uint8 | ,
|  | int | ,
|  | v64uint8 | )

Update a 1024-bit vector 64 elements at a time using a 512-bit update.

v128uint8 sbuff = undef_v128uint8();
sbuff = upd_x(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 64 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_x() [3/8]

promotion v16cfloat upd_x | ( | v16cfloat | ,
|  | int | ,
|  | v8cfloat | )

Update a 1024-bit vector 8 elements at a time using a 512-bit update.

v16cfloat sbuff = undef_v16cfloat();
sbuff = upd_x(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 8 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_x() [4/8]

promotion v16cint32 upd_x | ( | v16cint32 | ,
|  | int | ,
|  | v8cint32 | )

Update a 1024-bit vector 8 elements at a time using a 512-bit update.

v16cint32 sbuff = undef_v16cint32();
sbuff = upd_x(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 8 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_x() [5/8]

promotion v32cint16 upd_x | ( | v32cint16 | ,
|  | int | ,
|  | v16cint16 | )

Update a 1024-bit vector 16 elements at a time using a 512-bit update.

v32cint16 sbuff = undef_v32cint16();
sbuff = upd_x(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 16 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_x() [6/8]

promotion v32float upd_x | ( | v32float | ,
|  | int | ,
|  | v16float | )

Update a 1024-bit vector 16 elements at a time using a 512-bit update.

v32float sbuff = undef_v32float();
sbuff = upd_x(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 16 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_x() [7/8]

promotion v32int32 upd_x | ( | v32int32 | ,
|  | int | ,
|  | v16int32 | )

Update a 1024-bit vector 16 elements at a time using a 512-bit update.

v32int32 sbuff = undef_v32int32();
sbuff = upd_x(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 16 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ upd_x() [8/8]

promotion v64int16 upd_x | ( | v64int16 | ,
|  | int | ,
|  | v32int16 | )

Update a 1024-bit vector 32 elements at a time using a 512-bit update.

v64int16 sbuff = undef_v64int16();
sbuff = upd_x(sbuff, idx, val);

Parameters

  buf | Vector which will be updated
  idx | Number in the range 0 to 1. Used to choose which set of 32 elements in buf will be updated by val.
  val | Input vector used to update buf

## ◆ yset_v() [1/8]

promotion v128int8 yset_v | ( | int | ,
|  | v16int8 | )

Creates a new 1024-bit vector with 16 elements already set using a 128-bit set.

sbuff = vset(idx, val);

Parameters

  idx | Number in the range 0 to 7. Used to choose which set of 16 elements in buf will be set to val. idx must be a compile time constant
  val | Input vector

## ◆ yset_v() [2/8]

promotion v128uint8 yset_v | ( | int | ,
|  | v16uint8 | )

Creates a new 1024-bit vector with 16 elements already set using a 128-bit set.

sbuff = vset(idx, val);

Parameters

  idx | Number in the range 0 to 7. Used to choose which set of 16 elements in buf will be set to val. idx must be a compile time constant
  val | Input vector

## ◆ yset_v() [3/8]

promotion v16cfloat yset_v | ( | int | ,
|  | v2cfloat | )

Creates a new 1024-bit vector with 2 elements already set using a 128-bit set.

sbuff = vset(idx, val);

Parameters

  idx | Number in the range 0 to 7. Used to choose which set of 2 elements in buf will be set to val. idx must be a compile time constant
  val | Input vector

## ◆ yset_v() [4/8]

promotion v16cint32 yset_v | ( | int | ,
|  | v2cint32 | )

Creates a new 1024-bit vector with 2 elements already set using a 128-bit set.

sbuff = vset(idx, val);

Parameters

  idx | Number in the range 0 to 7. Used to choose which set of 2 elements in buf will be set to val. idx must be a compile time constant
  val | Input vector

## ◆ yset_v() [5/8]

promotion v32cint16 yset_v | ( | int | ,
|  | v4cint16 | )

Creates a new 1024-bit vector with 4 elements already set using a 128-bit set.

sbuff = vset(idx, val);

Parameters

  idx | Number in the range 0 to 7. Used to choose which set of 4 elements in buf will be set to val. idx must be a compile time constant
  val | Input vector

## ◆ yset_v() [6/8]

promotion v32float yset_v | ( | int | ,
|  | v4float | )

Creates a new 1024-bit vector with 4 elements already set using a 128-bit set.

sbuff = vset(idx, val);

Parameters

  idx | Number in the range 0 to 7. Used to choose which set of 4 elements in buf will be set to val. idx must be a compile time constant
  val | Input vector

## ◆ yset_v() [7/8]

promotion v32int32 yset_v | ( | int | ,
|  | v4int32 | )

Creates a new 1024-bit vector with 4 elements already set using a 128-bit set.

sbuff = vset(idx, val);

Parameters

  idx | Number in the range 0 to 7. Used to choose which set of 4 elements in buf will be set to val. idx must be a compile time constant
  val | Input vector

## ◆ yset_v() [8/8]

promotion v64int16 yset_v | ( | int | ,
|  | v8int16 | )

Creates a new 1024-bit vector with 8 elements already set using a 128-bit set.

sbuff = vset(idx, val);

Parameters

  idx | Number in the range 0 to 7. Used to choose which set of 8 elements in buf will be set to val. idx must be a compile time constant
  val | Input vector