nlib
nn::nlib::simd::I128 クラス

128bitレジスタ(SSEではXMM0-XMM15, NEONではQ0-Q15)を用いた整数SIMD演算を行うためのクラスです。 [詳解]

#include "nn/nlib/simd/SimdInt.h"

静的公開メンバ関数

static i128 SetZero () noexcept
 全てのビットに0を設定します。
 
static i128 SetFull (i128arg dummy) noexcept
 全てのビットに1を設定します。
 
static i64 GetLo (i128 value) noexcept
 value の下位64bitを返します。
 
static i64 GetHi (i128 value) noexcept
 value の上位64bitを返します。
 
同一値の全レーンへのロード
static i128 SetValue (int8_t v, each_int8_tag) noexcept
 16個の8bitのレーンに8bitの符号付き整数を設定します。
 
static i128 SetValue (int16_t v, each_int16_tag) noexcept
 8個の16bitのレーンに16bitの符号付き整数を設定します。
 
static i128 SetValue (int32_t v, each_int32_tag) noexcept
 4個の32bitのレーンに32bitの符号付き整数を設定します。
 
static i128 SetValue (int64_t v, each_int64_tag) noexcept
 2個の64bitのレーンに64bitの符号付き整数を設定します。
 
static i128 SetValue (uint8_t v, each_uint8_tag) noexcept
 16個の8bitのレーンに8bitの符号なし整数を設定します。
 
static i128 SetValue (uint16_t v, each_uint16_tag) noexcept
 8個の16bitのレーンに16bitの符号なし整数を設定します。
 
static i128 SetValue (uint32_t v, each_uint32_tag) noexcept
 4個の32bitのレーンに32bitの符号なし整数を設定します。
 
static i128 SetValue (uint64_t v, each_uint64_tag) noexcept
 2個の64bitのレーンに64bitの符号なし整数を設定します。
 
特定レーンの値を全レーンへロード
template<size_t N>
static i128 SetValue (i128 value, each_select32_tag) noexcept
 value のレーンN の32bit値を全てのレーンに設定します。 [詳解]
 
template<size_t N>
static i128 SetValue (i128 value, each_select16_tag) noexcept
 value のレーンN の16bit値を全てのレーンに設定します。 [詳解]
 
template<size_t N>
static i128 SetValue (i128 value, each_select8_tag) noexcept
 value のレーンN の8bit値を全てのレーンに設定します。 [詳解]
 
メモリからのロード
static i128 LoadA16 (const void *p) noexcept
 16バイトアライメントのアドレスp から16バイトのデータを読み込み値を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadA8 (const void *p) noexcept
 8バイトアライメントのアドレスp から16バイトのデータを読み込み値を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadA4 (const void *p) noexcept
 4バイトアライメントのアドレスp から16バイトのデータを読み込み値を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadA2 (const void *p) noexcept
 2バイトアライメントのアドレスp から16バイトのデータを読み込み値を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadA1 (const void *p) noexcept
 アライメントされていないアドレスp から16バイトのデータを読み込み値を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadA16 (uintptr_t p) noexcept
 LoadA16(const void* p) をラップしています。
 
static i128 LoadA8 (uintptr_t p) noexcept
 LoadA8(const void* p) をラップしています。
 
static i128 LoadA4 (uintptr_t p) noexcept
 LoadA4(const void* p) をラップしています。
 
static i128 LoadA2 (uintptr_t p) noexcept
 LoadA2(const void* p) をラップしています。
 
static i128 LoadA1 (uintptr_t p) noexcept
 LoadA1(const void* p) をラップしています。
 
static i128 LoadA16 (intptr_t p) noexcept
 LoadA16(const void* p) をラップしています。
 
static i128 LoadA8 (intptr_t p) noexcept
 LoadA8(const void* p) をラップしています。
 
static i128 LoadA4 (intptr_t p) noexcept
 LoadA4(const void* p) をラップしています。
 
static i128 LoadA2 (intptr_t p) noexcept
 LoadA2(const void* p) をラップしています。
 
static i128 LoadA1 (intptr_t p) noexcept
 LoadA1(const void* p) をラップしています。
 
メモリへのストア
static void StoreA16 (void *p, i128arg value) noexcept
 16バイトアライメントのアドレスpvalue の16バイトのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreA8 (void *p, i128arg value) noexcept
 8バイトアライメントのアドレスpvalue の16バイトのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreA4 (void *p, i128arg value) noexcept
 4バイトアライメントのアドレスpvalue の16バイトのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreA2 (void *p, i128arg value) noexcept
 2バイトアライメントのアドレスpvalue の16バイトのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreA1 (void *p, i128arg value) noexcept
 アライメントされていないアドレスpvalue の16バイトのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreA16 (uintptr_t p, i128arg value) noexcept
 StoreA16(void* p, i128arg value) をラップしています。
 
static void StoreA8 (uintptr_t p, i128arg value) noexcept
 StoreA8(void* p, i128arg value) をラップしています。
 
static void StoreA4 (uintptr_t p, i128arg value) noexcept
 StoreA4(void* p, i128arg value) をラップしています。
 
static void StoreA2 (uintptr_t p, i128arg value) noexcept
 StoreA2(void* p, i128arg value) をラップしています。
 
static void StoreA1 (uintptr_t p, i128arg value) noexcept
 StoreA1(void* p, i128arg value) をラップしています。
 
static void StoreA16 (intptr_t p, i128arg value) noexcept
 StoreA16(void* p, i128arg value) をラップしています。
 
static void StoreA8 (intptr_t p, i128arg value) noexcept
 StoreA8(void* p, i128arg value) をラップしています。
 
static void StoreA4 (intptr_t p, i128arg value) noexcept
 StoreA4(void* p, i128arg value) をラップしています。
 
static void StoreA2 (intptr_t p, i128arg value) noexcept
 StoreA2(void* p, i128arg value) をラップしています。
 
static void StoreA1 (intptr_t p, i128arg value) noexcept
 StoreA1(void* p, i128arg value) をラップしています。
 
特定のレーンの値の取得と設定
template<size_t N>
static uint8_t GetUint8FromLane (i128arg value) noexcept
 value のレーン N の8bitの符号なし整数を取得します。 [詳解]
 
template<size_t N>
static uint16_t GetUint16FromLane (i128arg value) noexcept
 value のレーン N の16bitの符号なし整数を取得します。 [詳解]
 
template<size_t N>
static uint32_t GetUint32FromLane (i128arg value) noexcept
 value のレーン N の32bitの符号なし整数を取得します。 [詳解]
 
template<size_t N>
static uint64_t GetUint64FromLane (i128arg value) noexcept
 value のレーン N の64bitの符号なし整数を取得します。 [詳解]
 
template<size_t N>
static i128 SetUint8ToLane (i128arg value, uint8_t v) noexcept
 value のレーン N の8bit符号なし整数をv に設定します。 [詳解]
 
template<size_t N>
static i128 SetUint16ToLane (i128arg value, uint16_t v) noexcept
 value のレーン N の16bit符号なし整数をv に設定します。 [詳解]
 
template<size_t N>
static i128 SetUint32ToLane (i128arg value, uint32_t v) noexcept
 value のレーン N の32bit符号なし整数をv に設定します。 [詳解]
 
template<size_t N>
static i128 SetUint64ToLane (i128arg value, uint64_t v) noexcept
 value のレーン N の64bit符号なし整数をv に設定します。 [詳解]
 
算術演算
static i128 Add8 (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの整数値を加算します。 [詳解]
 
static i128 Add16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの整数値を加算します。 [詳解]
 
static i128 Add32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの整数値を加算します。 [詳解]
 
static i128 Add64 (i128arg a, i128arg b) noexcept
 ab の64bitの各レーンの整数値を加算します。 [詳解]
 
static i128 AddInt8Saturated (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号付き整数値を飽和加算します。 [詳解]
 
static i128 AddInt16Saturated (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号付き整数値を飽和加算します。 [詳解]
 
static i128 AddUint8Saturated (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号なし整数値を飽和加算します。 [詳解]
 
static i128 AddUint16Saturated (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号なし整数値を飽和加算します。 [詳解]
 
static i128 Sub8 (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの整数値を減算します。 [詳解]
 
static i128 Sub16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの整数値を減算します。 [詳解]
 
static i128 Sub32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの整数値を減算します。 [詳解]
 
static i128 Sub64 (i128arg a, i128arg b) noexcept
 ab の64bitの各レーンの整数値を減算します。 [詳解]
 
static i128 SubInt8Saturated (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号付き整数値を飽和減算します。 [詳解]
 
static i128 SubInt16Saturated (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号付き整数値を飽和減算します。 [詳解]
 
static i128 SubUint8Saturated (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号なし整数値を飽和減算します。 [詳解]
 
static i128 SubUint16Saturated (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号なし整数値を飽和減算します。 [詳解]
 
static i128 PairwiseAdd8 (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの整数値を水平加算します。 [詳解]
 
static i128 PairwiseAdd16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの整数値を水平加算します。 [詳解]
 
static i128 PairwiseAdd32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの整数値を水平加算します。 [詳解]
 
static i128 Mult16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの整数値を乗算します。 [詳解]
 
static i128 MultAdd16 (i128arg a, i128arg b, i128arg c) noexcept
 ab の16bitの各レーンの整数値を乗算し、その結果にc の16bitの各レーンの整数値を加算します。 [詳解]
 
static i128 MultSub16 (i128arg a, i128arg b, i128arg c) noexcept
 ab の16bitの各レーンの整数値を乗算し、その結果をc の16bitの各レーンの整数値から減算します。 [詳解]
 
static i128 Mult32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの整数値を乗算します。 [詳解]
 
static i128 MultAdd32 (i128arg a, i128arg b, i128arg c) noexcept
 ab の32bitの各レーンの整数値を乗算し、その結果にc の32bitの各レーンの整数値を加算します。 [詳解]
 
static i128 MultSub32 (i128arg a, i128arg b, i128arg c) noexcept
 ab の32bitの各レーンの整数値を乗算し、その結果をc の32bitの各レーンの整数値から減算します。 [詳解]
 
static i128 NegateInt8 (i128arg value) noexcept
 value の8bitの各レーンの符号付き整数値の符号を反転した値を計算します。
 
static i128 NegateInt16 (i128arg value) noexcept
 value の16bitの各レーンの符号付き整数値の符号を反転した値を計算します。
 
static i128 NegateInt32 (i128arg value) noexcept
 value の32bitの各レーンの符号付き整数値の符号を反転した値を計算します。
 
最大及び最小
static i128 MaxInt8 (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号付き整数値で大きい方の値を設定します。 [詳解]
 
static i128 MaxInt16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号付き整数値で大きい方の値を設定します。 [詳解]
 
static i128 MaxInt32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの符号付き整数値で大きい方の値を設定します。 [詳解]
 
static i128 MaxUint8 (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号なし整数値で大きい方の値を設定します。 [詳解]
 
static i128 MaxUint16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号なし整数値で大きい方の値を設定します。 [詳解]
 
static i128 MaxUint32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの符号なし整数値で大きい方の値を設定します。 [詳解]
 
static i128 MinInt8 (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号付き整数値で小さい方の値を設定します。 [詳解]
 
static i128 MinInt16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号付き整数値で小さい方の値を設定します。 [詳解]
 
static i128 MinInt32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの符号付き整数値で小さい方の値を設定します。 [詳解]
 
static i128 MinUint8 (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号なし整数値で小さい方の値を設定します。 [詳解]
 
static i128 MinUint16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号なし整数値で小さい方の値を設定します。 [詳解]
 
static i128 MinUint32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの符号なし整数値で小さい方の値を設定します。 [詳解]
 
絶対値
static i128 AbsInt8 (i128arg value) noexcept
 value の8bitの各レーンの符号付き整数値の絶対値を計算します。
 
static i128 AbsInt16 (i128arg value) noexcept
 value の16bitの各レーンの符号付き整数値の絶対値を計算します。
 
static i128 AbsInt32 (i128arg value) noexcept
 value の32bitの各レーンの符号付き整数値の絶対値を計算します。
 
static i128 AbsDiffInt8 (i128arg a, i128arg b) noexcept
 ab の8bitの各レーンの符号付き整数値の差分の絶対値を計算します。
 
static i128 AbsDiffInt16 (i128arg a, i128arg b) noexcept
 ab の16bitの各レーンの符号付き整数値の差分の絶対値を計算します。
 
static i128 AbsDiffInt32 (i128arg a, i128arg b) noexcept
 ab の32bitの各レーンの符号付き整数値の差分の絶対値を計算します。
 
論理演算
static i128 And (i128arg a, i128arg b) noexcept
 ab のビット単位での論理積を計算します。
 
static i128 Or (i128arg a, i128arg b) noexcept
 ab のビット単位での論理和を計算します。
 
static i128 Xor (i128arg a, i128arg b) noexcept
 ab のビット単位での排他的論理和を計算します。
 
static i128 Not (i128arg a) noexcept
 a のビット単位での否定を計算します。
 
static i128 AndNot (i128arg a, i128arg b) noexcept
 a のビット単位での否定と、b のビット単位での論理積を計算します。 [詳解]
 
static i128 OrNot (i128arg a, i128arg b) noexcept
 a のビット単位での否定と、b のビット単位での論理和を計算します。 [詳解]
 
比較
static i128 CmpEq8 (i128arg a, i128arg b) noexcept
 ab を8bitのレーン単位で比較を行います。 [詳解]
 
static i128 CmpEq16 (i128arg a, i128arg b) noexcept
 ab を16bitのレーン単位で比較を行います。 [詳解]
 
static i128 CmpEq32 (i128arg a, i128arg b) noexcept
 ab を32bitのレーン単位で比較を行います。 [詳解]
 
static i128 CmpLtInt8 (i128arg a, i128arg b) noexcept
 ab を8bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpLtInt16 (i128arg a, i128arg b) noexcept
 ab を16bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpLtInt32 (i128arg a, i128arg b) noexcept
 ab を32bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpGtInt8 (i128arg a, i128arg b) noexcept
 ab を8bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpGtInt16 (i128arg a, i128arg b) noexcept
 ab を16bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpGtInt32 (i128arg a, i128arg b) noexcept
 ab を32bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpLtUint8 (i128arg a, i128arg b) noexcept
 ab を8bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpLtUint16 (i128arg a, i128arg b) noexcept
 ab を16bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpLtUint32 (i128arg a, i128arg b) noexcept
 ab を32bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpGtUint8 (i128arg a, i128arg b) noexcept
 ab を8bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpGtUint16 (i128arg a, i128arg b) noexcept
 ab を16bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpGtUint32 (i128arg a, i128arg b) noexcept
 ab を32bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpLeInt8 (i128arg a, i128arg b) noexcept
 ab を8bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpLeInt16 (i128arg a, i128arg b) noexcept
 ab を16bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpLeInt32 (i128arg a, i128arg b) noexcept
 ab を32bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpGeInt8 (i128arg a, i128arg b) noexcept
 ab を8bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpGeInt16 (i128arg a, i128arg b) noexcept
 ab を16bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpGeInt32 (i128arg a, i128arg b) noexcept
 ab を32bitの符号付き整数として比較を行います。 [詳解]
 
static i128 CmpLeUint8 (i128arg a, i128arg b) noexcept
 ab を8bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpLeUint16 (i128arg a, i128arg b) noexcept
 ab を16bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpLeUint32 (i128arg a, i128arg b) noexcept
 ab を32bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpGeUint8 (i128arg a, i128arg b) noexcept
 ab を8bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpGeUint16 (i128arg a, i128arg b) noexcept
 ab を16bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpGeUint32 (i128arg a, i128arg b) noexcept
 ab を32bitの符号なし整数として比較を行います。 [詳解]
 
全てのレーンに対するビットシフト
static i128 ShiftLeftLogical8 (i128arg value, int count) noexcept
 8bitの各レーンをcount だけ左シフトします。
 
static i128 ShiftRightLogical8 (i128arg value, int count) noexcept
 8bitの各レーンをcount だけ右論理シフトします。
 
static i128 ShiftLeftLogical16 (i128arg value, int count) noexcept
 16bitの各レーンをcount だけ左シフトします。
 
static i128 ShiftRightLogical16 (i128arg value, int count) noexcept
 16bitの各レーンをcount だけ右論理シフトします。
 
static i128 ShiftRightArithmetic16 (i128arg value, int count) noexcept
 16bitの各レーンをcount だけ右算術シフトします。
 
static i128 ShiftLeftLogical32 (i128arg value, int count) noexcept
 32bitの各レーンをcount だけ左シフトします。
 
static i128 ShiftRightLogical32 (i128arg value, int count) noexcept
 32bitの各レーンをcount だけ右論理シフトします。
 
static i128 ShiftRightArithmetic32 (i128arg value, int count) noexcept
 32bitの各レーンをcount だけ右算術シフトします。
 
static i128 ShiftLeftLogical64 (i128arg value, int count) noexcept
 64bitの各レーンをcount だけ左シフトします。
 
static i128 ShiftRightLogical64 (i128arg value, int count) noexcept
 64bitの各レーンをcount だけ右論理シフトします。
 
128ビット幅でのシフトとローテート
template<size_t N>
static i128 ByteShiftLeft (i128arg value) noexcept
 valueN バイト分左シフトします。空いたレーンには0が設定されます。 [詳解]
 
template<size_t N>
static i128 ByteShiftRight (i128arg value) noexcept
 valueN バイト分右シフトします。空いたレーンには0が設定されます。 [詳解]
 
template<size_t N>
static i128 ByteRotateRight (i128arg value) noexcept
 valueN バイト分右ローテートします。 [詳解]
 
template<size_t N>
static i128 AlignR (i128arg a, i128arg b) noexcept
 a,b を256bit値に見立てて右に N バイトシフトした後の下位128bit値を返します。 [詳解]
 
レーン幅の変更
static i128 NarrowFrom16To8 (i128arg lo, i128arg hi) noexcept
 16bit幅のレーンの上位8bitをカットして16個を1つの128bit値にして返します。 [詳解]
 
static i128 NarrowFrom32To16 (i128arg lo, i128arg hi) noexcept
 32bit幅のレーンの上位16bitをカットして8個を1つの128bit値にして返します。 [詳解]
 
static i128 NarrowFrom64To32 (i128arg lo, i128arg hi) noexcept
 64bit幅のレーンの上位32bitをカットして4個を1つの128bit値にして返します。 [詳解]
 
static i128 ConvertFromUint16ToUint8Saturated (i128arg lo, i128arg hi) noexcept
 16bitの符号なし整数16個を8bitの符号なし整数16個に変換します。範囲外の値はクランプされます。 [詳解]
 
static i128 ConvertFromInt16ToInt8Saturated (i128arg lo, i128arg hi) noexcept
 16bitの符号付き整数16個を8bitの符号付き整数16個に変換します。範囲外の値はクランプされます。 [詳解]
 
static i128 ConvertFromUint32ToUint16Saturated (i128arg lo, i128arg hi) noexcept
 32bitの符号なし整数8個を16bitの符号なし整数8個に変換します。範囲外の値はクランプされます。 [詳解]
 
static i128 ConvertFromInt32ToInt16Saturated (i128arg lo, i128arg hi) noexcept
 32bitの符号付き整数8個を16bitの符号付き整数8個に変換します。範囲外の値はクランプされます。 [詳解]
 
static i128 ConvertFromInt8ToInt16 (i64arg value) noexcept
 8bitの符号付き整数8個を16bitの符号付き整数8個に変換します。 [詳解]
 
static i128 ConvertFromInt16ToInt32 (i64arg value) noexcept
 16bitの符号付き整数4個を32bitの符号付き整数4個に変換します。 [詳解]
 
static i128 ConvertFromInt32ToInt64 (i64arg value) noexcept
 32bitの符号付き整数2個を64bitの符号付き整数2個に変換します。 [詳解]
 
static i128 ConvertFromUint8ToUint16 (i64arg value) noexcept
 8bitの符号なし整数8個を16bitの符号なし整数8個に変換します。 [詳解]
 
static i128 ConvertFromUint16ToUint32 (i64arg value) noexcept
 16bitの符号なし整数4個を32bitの符号なし整数4個に変換します。 [詳解]
 
static i128 ConvertFromUint32ToUint64 (i64arg value) noexcept
 32bitの符号なし整数2個を64bitの符号なし整数2個に変換します。 [詳解]
 
ZipとUnzip
static i128 Zip8 (i64arg a, i64arg b) noexcept
 ab の8bitの値をインターリーブします。 [詳解]
 
static i128 Unzip8 (i64arg a, i64arg b) noexcept
 ab の8bitの値をインターリーブ解除します。 [詳解]
 
static i128 Zip16 (i64arg a, i64arg b) noexcept
 ab の16bitの値をインターリーブします。 [詳解]
 
static i128 Unzip16 (i64arg a, i64arg b) noexcept
 ab の16bitの値をインターリーブ解除します。 [詳解]
 
static i128 Zip32 (i64arg a, i64arg b) noexcept
 ab の32bitの値をインターリーブします。 [詳解]
 
static i128 Unzip32 (i64arg a, i64arg b) noexcept
 ab の32bitの値をインターリーブ解除します。実際にはZip32()と同じ動作をします。 [詳解]
 
エンディアンの反転
static i128 Reverse16 (i128arg value) noexcept
 8個の16bit値のエンディアンを反転します。
 
static i128 Reverse32 (i128arg value) noexcept
 4個の32bit値のエンディアンを反転します。
 
static i128 Reverse64 (i128arg value) noexcept
 2個の64bit値のエンディアンを反転します。
 
その他
static int MoveMask8 (i128arg value) noexcept
 各8bitレーンを1bitの値に集約して整数として返します。 [詳解]
 
static int MoveMask16 (i128arg value) noexcept
 各16bitレーンを1bitの値に集約して整数として返します。 [詳解]
 
static int MoveMask32 (i128arg value) noexcept
 各32bitレーンを1bitの値に集約して整数として返します。 [詳解]
 
static bool IsZero (i128arg value) noexcept
 全てのbitが0かどうかを検査します。 [詳解]
 
static bool IsFull (i128arg value) noexcept
 全てのbitが1かどうかを検査します。 [詳解]
 
static i128 Select (i128arg mask, i128arg a, i128arg b) noexcept
 mask の値に従ってab を合成します。 [詳解]
 
static i128 Shuffle8 (i128arg value, i128arg shuffle) noexcept
 16個の8bit値を重複も含めて任意の並びに並べ替えます。 [詳解]
 

詳解

128bitレジスタ(SSEではXMM0-XMM15, NEONではQ0-Q15)を用いた整数SIMD演算を行うためのクラスです。

説明
このクラスのメンバは全て静的関数で、クラスをインスタンス化することはできません。

SimdInt.h1564 行目に定義があります。

関数詳解

nn::nlib::simd::I128::Add16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの整数値を加算します。

引数
[in]a8個の16bit値
[in]b8個の16bit値
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = a16[0] + b16[0]
r16[1] = a16[1] + b16[0]
....
r16[7] = a16[7] + b16[7]
nn::nlib::simd::I128::Add32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の32bitの各レーンの整数値を加算します。

引数
[in]a4個の32bit値
[in]b4個の32bit値
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = a32[0] + b32[0]
r32[1] = a32[1] + b32[0]
....
r32[3] = a32[3] + b32[3]
nn::nlib::simd::I128::Add64 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の64bitの各レーンの整数値を加算します。

引数
[in]a2個の64bit値
[in]b2個の64bit値
戻り値
以下のような擬似コードで示される計算結果を返します。
r64[0] = a64[0] + b64[0]
r64[1] = a64[1] + b64[0]
nn::nlib::simd::I128::Add8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの整数値を加算します。

引数
[in]a16個の8bit値
[in]b16個の8bit値
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = a8[0] + b8[0]
r8[1] = a8[1] + b8[0]
....
r8[15] = a8[15] + b8[15]
nn::nlib::simd::I128::AddInt16Saturated ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの符号付き整数値を飽和加算します。

引数
[in]a8個の16bit符号付き整数
[in]b8個の16bit符号付き整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = clamp(a16[0] + b16[0], INT16_MIN, INT16_MAX)
r16[1] = clamp(a16[1] + b16[1], INT16_MIN, INT16_MAX)
....
r16[7] = clamp(a16[7] + b16[7], INT16_MIN, INT16_MAX)
nn::nlib::simd::I128::AddInt8Saturated ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの符号付き整数値を飽和加算します。

引数
[in]a16個の8bit符号付き整数
[in]b16個の8bit符号付き整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = clamp(a8[0] + b8[0], INT8_MIN, INT8_MAX)
r8[1] = clamp(a8[1] + b8[1], INT8_MIN, INT8_MAX)
....
r8[15] = clamp(a8[15] + b8[15], INT8_MIN, INT8_MAX)
nn::nlib::simd::I128::AddUint16Saturated ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの符号なし整数値を飽和加算します。

引数
[in]a8個の16bit符号なし整数
[in]b8個の16bit符号なし整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = clamp(a16[0] + b16[0], UINT16_MAX)
r16[1] = clamp(a16[1] + b16[1], UINT16_MAX)
....
r16[7] = clamp(a16[7] + b16[7], UINT16_MAX)
nn::nlib::simd::I128::AddUint8Saturated ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの符号なし整数値を飽和加算します。

引数
[in]a16個の8bit符号なし整数
[in]b16個の8bit符号なし整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = clamp(a8[0] + b8[0], UINT8_MAX)
r8[1] = clamp(a8[1] + b8[1], UINT8_MAX)
....
r8[15] = clamp(a8[15] + b8[15], UINT8_MAX)
template<size_t N>
nn::nlib::simd::I128::AlignR ( i128arg  a,
i128arg  b 
)
staticnoexcept

a,b を256bit値に見立てて右に N バイトシフトした後の下位128bit値を返します。

テンプレート引数
N右シフトするバイト数
引数
[in]a右シフトされる256bit値の上位128bitの値
[in]b右シフトされる256bit値の下位128bitの値
戻り値
右シフトされた下位128bitの値
nn::nlib::simd::I128::AndNot ( i128arg  a,
i128arg  b 
)
staticnoexcept

a のビット単位での否定と、b のビット単位での論理積を計算します。

引数
[in]a128bitの値
[in]b128bitの値
戻り値
~a & bを返します。
template<size_t N>
nn::nlib::simd::I128::ByteRotateRight ( i128arg  value)
staticnoexcept

valueN バイト分右ローテートします。

テンプレート引数
Nローテートするバイト数
引数
[in]valueローテートされる128bitの値
戻り値
ローテート後の128bitの値
template<size_t N>
nn::nlib::simd::I128::ByteShiftLeft ( i128arg  value)
staticnoexcept

valueN バイト分左シフトします。空いたレーンには0が設定されます。

テンプレート引数
Nシフトするバイト数
引数
[in]valueシフトされる128bitの値
戻り値
シフト後の128bitの値
template<size_t N>
nn::nlib::simd::I128::ByteShiftRight ( i128arg  value)
staticnoexcept

valueN バイト分右シフトします。空いたレーンには0が設定されます。

テンプレート引数
Nシフトするバイト数
引数
[in]valueシフトされる128bitの値
戻り値
シフト後の128bitの値
nn::nlib::simd::I128::CmpEq16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitのレーン単位で比較を行います。

引数
[in]a8個の16bit値
[in]b8個の16bit値
戻り値
8個の16bit値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] == b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] == b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] == b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpEq32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitのレーン単位で比較を行います。

引数
[in]a4個の32bit値
[in]b4個の32bit値
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] == b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] == b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] == b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpEq8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitのレーン単位で比較を行います。

引数
[in]a16個の8bit値
[in]b16個の8bit値
戻り値
16個の8bit値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] == b8[0] ? 0xFF : 0x00
r8[1] = a8[1] == b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] == b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::CmpGeInt16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitの符号付き整数として比較を行います。

引数
[in]a8個の16bit符号付き整数
[in]b8個の16bit符号付き整数
戻り値
8個の16ビット値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] >= b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] >= b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] >= b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpGeInt32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitの符号付き整数として比較を行います。

引数
[in]a4個の32bit符号付き整数
[in]b4個の32bit符号付き整数
戻り値
4個の32ビット値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] >= b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] >= b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] >= b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpGeInt8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitの符号付き整数として比較を行います。

引数
[in]a16個の8bit符号付き整数
[in]b16個の8bit符号付き整数
戻り値
16個の8ビット値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] >= b8[0] ? 0xFF : 0x00
r8[1] = a8[1] >= b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] >= b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::CmpGeUint16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitの符号なし整数として比較を行います。

引数
[in]a8個の16bit符号なし整数
[in]b8個の16bit符号なし整数
戻り値
8個の16ビット値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] >= b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] >= b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] >= b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpGeUint32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitの符号なし整数として比較を行います。

引数
[in]a4個の32bit符号なし整数
[in]b4個の32bit符号なし整数
戻り値
4個の32ビット値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] >= b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] >= b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] >= b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpGeUint8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitの符号なし整数として比較を行います。

引数
[in]a16個の8bit符号なし整数
[in]b16個の8bit符号なし整数
戻り値
16個の8ビット値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] >= b8[0] ? 0xFF : 0x00
r8[1] = a8[1] >= b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] >= b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::CmpGtInt16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitの符号付き整数として比較を行います。

引数
[in]a8個の16bit符号付き整数
[in]b8個の16bit符号付き整数
戻り値
8個の16ビット値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] > b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] > b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] > b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpGtInt32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitの符号付き整数として比較を行います。

引数
[in]a4個の32bit符号付き整数
[in]b4個の32bit符号付き整数
戻り値
4個の32ビット値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] > b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] > b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] > b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpGtInt8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitの符号付き整数として比較を行います。

引数
[in]a16個の8bit符号付き整数
[in]b16個の8bit符号付き整数
戻り値
16個の8ビット値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] > b8[0] ? 0xFF : 0x00
r8[1] = a8[1] > b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] > b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::CmpGtUint16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitの符号なし整数として比較を行います。

引数
[in]a8個の16bit符号なし整数
[in]b8個の16bit符号なし整数
戻り値
8個の16ビット値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] > b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] > b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] > b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpGtUint32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitの符号なし整数として比較を行います。

引数
[in]a4個の32bit符号なし整数
[in]b4個の32bit符号なし整数
戻り値
4個の32ビット値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] > b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] > b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] > b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpGtUint8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitの符号なし整数として比較を行います。

引数
[in]a16個の8bit符号なし整数
[in]b16個の8bit符号なし整数
戻り値
16個の8ビット値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] > b8[0] ? 0xFF : 0x00
r8[1] = a8[1] > b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] > b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::CmpLeInt16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitの符号付き整数として比較を行います。

引数
[in]a8個の16bit符号付き整数
[in]b8個の16bit符号付き整数
戻り値
8個の16ビット値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] <= b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] <= b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] <= b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpLeInt32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitの符号付き整数として比較を行います。

引数
[in]a4個の32bit符号付き整数
[in]b4個の32bit符号付き整数
戻り値
4個の32ビット値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] <= b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] <= b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] <= b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpLeInt8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitの符号付き整数として比較を行います。

引数
[in]a16個の8bit符号付き整数
[in]b16個の8bit符号付き整数
戻り値
16個の8ビット値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] <= b8[0] ? 0xFF : 0x00
r8[1] = a8[1] <= b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] <= b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::CmpLeUint16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitの符号なし整数として比較を行います。

引数
[in]a8個の16bit符号なし整数
[in]b8個の16bit符号なし整数
戻り値
8個の16ビット値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] <= b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] <= b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] <= b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpLeUint32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitの符号なし整数として比較を行います。

引数
[in]a4個の32bit符号なし整数
[in]b4個の32bit符号なし整数
戻り値
4個の32ビット値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] <= b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] <= b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] <= b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpLeUint8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitの符号なし整数として比較を行います。

引数
[in]a16個の8bit符号なし整数
[in]b16個の8bit符号なし整数
戻り値
16個の8ビット値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] <= b8[0] ? 0xFF : 0x00
r8[1] = a8[1] <= b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] <= b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::CmpLtInt16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitの符号付き整数として比較を行います。

引数
[in]a8個の16bit符号付き整数
[in]b8個の16bit符号付き整数
戻り値
8個の16ビット値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] < b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] < b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] < b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpLtInt32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitの符号付き整数として比較を行います。

引数
[in]a4個の32bit符号付き整数
[in]b4個の32bit符号付き整数
戻り値
4個の32ビット値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] < b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] < b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] < b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpLtInt8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitの符号付き整数として比較を行います。

引数
[in]a16個の8bit符号付き整数
[in]b16個の8bit符号付き整数
戻り値
16個の8ビット値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] < b8[0] ? 0xFF : 0x00
r8[1] = a8[1] < b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] < b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::CmpLtUint16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を16bitの符号なし整数として比較を行います。

引数
[in]a8個の16bit符号なし整数
[in]b8個の16bit符号なし整数
戻り値
8個の16ビット値(マスク)で、擬似コードでは以下のような値を返します。
r16[0] = a16[0] < b16[0] ? 0xFFFF : 0x0000
r16[1] = a16[1] < b16[1] ? 0xFFFF : 0x0000
.....
r16[7] = a16[7] < b16[7] ? 0xFFFF : 0x0000
nn::nlib::simd::I128::CmpLtUint32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を32bitの符号なし整数として比較を行います。

引数
[in]a4個の32bit符号なし整数
[in]b4個の32bit符号なし整数
戻り値
4個の32ビット値(マスク)で、擬似コードでは以下のような値を返します。
r32[0] = a32[0] < b32[0] ? 0xFFFFFFFF : 0x0000
r32[1] = a32[1] < b32[1] ? 0xFFFFFFFF : 0x0000
.....
r32[3] = a32[3] < b32[3] ? 0xFFFFFFFF : 0x0000
nn::nlib::simd::I128::CmpLtUint8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab を8bitの符号なし整数として比較を行います。

引数
[in]a16個の8bit符号なし整数
[in]b16個の8bit符号なし整数
戻り値
16個の8ビット値(マスク)で、擬似コードでは以下のような値を返します。
r8[0] = a8[0] < b8[0] ? 0xFF : 0x00
r8[1] = a8[1] < b8[1] ? 0xFF : 0x00
.....
r8[15] = a8[15] < b8[15] ? 0xFF : 0x00
nn::nlib::simd::I128::ConvertFromInt16ToInt32 ( i64arg  value)
staticnoexcept

16bitの符号付き整数4個を32bitの符号付き整数4個に変換します。

引数
[in]value4個の16bit符号付き整数
戻り値
4個の32bit値で、擬似コードでは以下のような値を返します。
r16[0] = value16[0]
r16[1] = value16[0] < 0 ? 0xFFFF : 0x00
....
r16[6] = value16[4]
r16[7] = value16[4] < 0 ? 0xFFFF : 0x00
nn::nlib::simd::I128::ConvertFromInt16ToInt8Saturated ( i128arg  lo,
i128arg  hi 
)
staticnoexcept

16bitの符号付き整数16個を8bitの符号付き整数16個に変換します。範囲外の値はクランプされます。

引数
[in]lo8個の16bit符号付き整数
[in]hi8個の16bit符号付き整数
戻り値
16個の8bit値で、擬似コードでは以下のような値を返します。
r8[0] = clamp(lo16[0])
r8[1] = clamp(lo16[1])
....
r8[7] = clamp(lo16[7])
r8[8] = clamp(hi16[0])
....
r8[15] = clamp(hi16[7])
nn::nlib::simd::I128::ConvertFromInt32ToInt16Saturated ( i128arg  lo,
i128arg  hi 
)
staticnoexcept

32bitの符号付き整数8個を16bitの符号付き整数8個に変換します。範囲外の値はクランプされます。

引数
[in]lo4個の32bit符号付き整数
[in]hi4個の32bit符号付き整数
戻り値
8個の16bit値で、擬似コードでは以下のような値を返します。
r16[0] = clamp(lo32[0])
r16[1] = clamp(lo32[1])
....
r16[3] = clamp(lo32[3])
r16[4] = clamp(hi32[0])
....
r16[7] = clamp(hi32[3])
nn::nlib::simd::I128::ConvertFromInt32ToInt64 ( i64arg  value)
staticnoexcept

32bitの符号付き整数2個を64bitの符号付き整数2個に変換します。

引数
[in]value2個の32bit符号付き整数
戻り値
2個の64bit値で、擬似コードでは以下のような値を返します。
r32[0] = value32[0]
r32[1] = value32[0] < 0 ? 0xFFFFFFFF : 0x00
r32[2] = value32[1]
r32[3] = value32[1] < 0 ? 0xFFFFFFFF : 0x00
nn::nlib::simd::I128::ConvertFromInt8ToInt16 ( i64arg  value)
staticnoexcept

8bitの符号付き整数8個を16bitの符号付き整数8個に変換します。

引数
[in]value8個の8bit符号付き整数
戻り値
8個の16bit値で、擬似コードでは以下のような値を返します。
r8[0] = value8[0]
r8[1] = value8[0] < 0 ? 0xFF : 0x00
....
r8[14] = value8[7]
r8[15] = value8[7] < 0 ? 0xFF : 0x00
nn::nlib::simd::I128::ConvertFromUint16ToUint32 ( i64arg  value)
staticnoexcept

16bitの符号なし整数4個を32bitの符号なし整数4個に変換します。

引数
[in]value4個の16bit符号なし整数
戻り値
4個の32bit値で、擬似コードでは以下のような値を返します。
r16[0] = value16[0]
r16[1] = 0
....
r16[6] = value16[4]
r16[7] = 0
nn::nlib::simd::I128::ConvertFromUint16ToUint8Saturated ( i128arg  lo,
i128arg  hi 
)
staticnoexcept

16bitの符号なし整数16個を8bitの符号なし整数16個に変換します。範囲外の値はクランプされます。

引数
[in]lo8個の16bit符号なし整数
[in]hi8個の16bit符号なし整数
戻り値
16個の8bit値で、擬似コードでは以下のような値を返します。
r8[0] = clamp(lo16[0])
r8[1] = clamp(lo16[1])
....
r8[7] = clamp(lo16[7])
r8[8] = clamp(hi16[0])
....
r8[15] = clamp(hi16[7])
nn::nlib::simd::I128::ConvertFromUint32ToUint16Saturated ( i128arg  lo,
i128arg  hi 
)
staticnoexcept

32bitの符号なし整数8個を16bitの符号なし整数8個に変換します。範囲外の値はクランプされます。

引数
[in]lo4個の32bit符号なし整数
[in]hi4個の32bit符号なし整数
戻り値
8個の16bit値で、擬似コードでは以下のような値を返します。
r16[0] = clamp(lo32[0])
r16[1] = clamp(lo32[1])
....
r16[3] = clamp(lo32[3])
r16[4] = clamp(hi32[0])
....
r16[7] = clamp(hi32[3])
nn::nlib::simd::I128::ConvertFromUint32ToUint64 ( i64arg  value)
staticnoexcept

32bitの符号なし整数2個を64bitの符号なし整数2個に変換します。

引数
[in]value2個の32bit符号なし整数
戻り値
2個の64bit値で、擬似コードでは以下のような値を返します。
r32[0] = value32[0]
r32[1] = 0
r32[2] = value32[1]
r32[3] = 0
nn::nlib::simd::I128::ConvertFromUint8ToUint16 ( i64arg  value)
staticnoexcept

8bitの符号なし整数8個を16bitの符号なし整数8個に変換します。

引数
[in]value8個の8bit符号なし整数
戻り値
8個の16bit値で、擬似コードでは以下のような値を返します。
r8[0] = value8[0]
r8[1] = 0
....
r8[14] = value8[7]
r8[15] = 0
template<size_t N>
nn::nlib::simd::I128::GetUint16FromLane ( i128arg  value)
staticnoexcept

value のレーン N の16bitの符号なし整数を取得します。

テンプレート引数
Tレーンの値です。0以上7以下の整数を指定します。
引数
[in]value8個の16bitの符号なし整数
戻り値
16bitの符号なし整数
template<size_t N>
nn::nlib::simd::I128::GetUint32FromLane ( i128arg  value)
staticnoexcept

value のレーン N の32bitの符号なし整数を取得します。

テンプレート引数
Tレーンの値です。0以上3以下の整数を指定します。
引数
[in]value4個の32bitの符号なし整数
戻り値
32bitの符号なし整数
template<size_t N>
nn::nlib::simd::I128::GetUint64FromLane ( i128arg  value)
staticnoexcept

value のレーン N の64bitの符号なし整数を取得します。

テンプレート引数
Tレーンの値です。0以上1以下の整数を指定します。
引数
[in]value2個の64bitの符号なし整数
戻り値
64bitの符号なし整数
template<size_t N>
nn::nlib::simd::I128::GetUint8FromLane ( i128arg  value)
staticnoexcept

value のレーン N の8bitの符号なし整数を取得します。

テンプレート引数
Tレーンの値です。0以上15以下の整数を指定します。
引数
[in]value16個の8bitの符号なし整数
戻り値
8bitの符号なし整数
nn::nlib::simd::I128::IsFull ( i128arg  value)
staticnoexcept

全てのbitが1かどうかを検査します。

引数
[in]value128bitの値
戻り値
全てのbitが1の場合はtrue, そうでなければfalse
nn::nlib::simd::I128::IsZero ( i128arg  value)
staticnoexcept

全てのbitが0かどうかを検査します。

引数
[in]value128bitの値
戻り値
全てのbitが0の場合はtrue, そうでなければfalse
説明
この関数は相対的にMoveMask8()等よりは軽量なため、以下のように事前にマスクを検査するために利用することができます。
if (!I128::IsZero(value)) {
int mask = I128::MoveMask8(value);
// count trailing zero等のmaskに対する処理
....
}
nn::nlib::simd::I128::MaxInt16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの符号付き整数値で大きい方の値を設定します。

引数
[in]a8個の16bit符号付き整数値
[in]b8個の16bit符号付き整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = a16[0] > b16[0] ? a16[0] : b16[0]
r16[1] = a16[1] > a16[1] ? a16[1] : b16[1]
....
r16[7] = a16[7] > b16[7] ? a16[7] : b16[7]
nn::nlib::simd::I128::MaxInt32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の32bitの各レーンの符号付き整数値で大きい方の値を設定します。

引数
[in]a4個の32bit符号付き整数値
[in]b4個の32bit符号付き整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = a32[0] > b32[0] ? a32[0] : b32[0]
r32[1] = a32[1] > a32[1] ? a32[1] : b32[1]
....
r32[3] = a32[3] > b32[3] ? a32[3] : b32[7]
nn::nlib::simd::I128::MaxInt8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの符号付き整数値で大きい方の値を設定します。

引数
[in]a16個の8bit符号付き整数値
[in]b16個の8bit符号付き整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = a8[0] > b8[0] ? a8[0] : b8[0]
r8[1] = a8[1] > a8[1] ? a8[1] : b8[1]
....
r8[15] = a8[15] > b8[15] ? a8[15] : b8[15]
nn::nlib::simd::I128::MaxUint16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの符号なし整数値で大きい方の値を設定します。

引数
[in]a8個の16bit符号なし整数値
[in]b8個の16bit符号なし整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = a16[0] > b16[0] ? a16[0] : b16[0]
r16[1] = a16[1] > a16[1] ? a16[1] : b16[1]
....
r16[7] = a16[7] > b16[7] ? a16[7] : b16[7]
nn::nlib::simd::I128::MaxUint32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の32bitの各レーンの符号なし整数値で大きい方の値を設定します。

引数
[in]a4個の32bit符号なし整数値
[in]b4個の32bit符号なし整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = a32[0] > b32[0] ? a32[0] : b32[0]
r32[1] = a32[1] > a32[1] ? a32[1] : b32[1]
....
r32[3] = a32[3] > b32[3] ? a32[3] : b32[3]
nn::nlib::simd::I128::MaxUint8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの符号なし整数値で大きい方の値を設定します。

引数
[in]a16個の8bit符号なし整数値
[in]b16個の8bit符号なし整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = a8[0] > b8[0] ? a8[0] : b8[0]
r8[1] = a8[1] > a8[1] ? a8[1] : b8[1]
....
r8[15] = a8[15] > b8[15] ? a8[15] : b8[15]
nn::nlib::simd::I128::MinInt16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの符号付き整数値で小さい方の値を設定します。

引数
[in]a8個の16bit符号付き整数値
[in]b8個の16bit符号付き整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = a16[0] < b16[0] ? a16[0] : b16[0]
r16[1] = a16[1] < a16[1] ? a16[1] : b16[1]
....
r16[7] = a16[7] < b16[7] ? a16[7] : b16[7]
nn::nlib::simd::I128::MinInt32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の32bitの各レーンの符号付き整数値で小さい方の値を設定します。

引数
[in]a4個の32bit符号付き整数値
[in]b4個の32bit符号付き整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = a32[0] < b32[0] ? a32[0] : b32[0]
r32[1] = a32[1] < a32[1] ? a32[1] : b32[1]
....
r32[3] = a32[3] < b32[3] ? a32[3] : b32[3]
nn::nlib::simd::I128::MinInt8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの符号付き整数値で小さい方の値を設定します。

引数
[in]a16個の8bit符号付き整数値
[in]b16個の8bit符号付き整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = a8[0] < b8[0] ? a8[0] : b8[0]
r8[1] = a8[1] < a8[1] ? a8[1] : b8[1]
....
r8[15] = a8[15] < b8[15] ? a8[15] : b8[15]
nn::nlib::simd::I128::MinUint16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの符号なし整数値で小さい方の値を設定します。

引数
[in]a8個の16bit符号なし整数値
[in]b8個の16bit符号なし整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = a16[0] < b16[0] ? a16[0] : b16[0]
r16[1] = a16[1] < a16[1] ? a16[1] : b16[1]
....
r16[7] = a16[7] < b16[7] ? a16[7] : b16[7]
nn::nlib::simd::I128::MinUint32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の32bitの各レーンの符号なし整数値で小さい方の値を設定します。

引数
[in]a4個の32bit符号なし整数値
[in]b4個の32bit符号なし整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = a32[0] < b32[0] ? a32[0] : b32[0]
r32[1] = a32[1] < a32[1] ? a32[1] : b32[1]
....
r32[3] = a32[3] < b32[3] ? a32[3] : b32[3]
nn::nlib::simd::I128::MinUint8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの符号なし整数値で小さい方の値を設定します。

引数
[in]a16個の8bit符号なし整数値
[in]b16個の8bit符号なし整数値
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = a8[0] < b8[0] ? a8[0] : b8[0]
r8[1] = a8[1] < a8[1] ? a8[1] : b8[1]
....
r8[15] = a8[15] < b8[15] ? a8[15] : b8[15]
nn::nlib::simd::I128::MoveMask16 ( i128arg  value)
staticnoexcept

各16bitレーンを1bitの値に集約して整数として返します。

引数
[in]value8個の16bitマスク
戻り値
擬似コードでは以下のような値を返します。
int rval = 0
rval |= value16[0] == 0xFFFFU ? 0x01 : 0x00
rval |= value16[1] == 0xFFFFU ? 0x02 : 0x00
.....
rval |= value16[7] == 0xFFFFU ? 0x80 : 0x00
return rval
説明
アーキテクチャによってどのビットが結果に反映されるかどうかが異なります。
  • SSE4.1(_mm_movemask_epi8, PMOVMSKB)では最上位ビットの値が結果に反映されます。
  • NEONではレーンによって異なるビットがサンプリングされて結果に反映されます。
いずれの場合でも、比較演算の結果を入力とした場合には意図した通りの動作をします。
nn::nlib::simd::I128::MoveMask32 ( i128arg  value)
staticnoexcept

各32bitレーンを1bitの値に集約して整数として返します。

引数
[in]value4個の32bitマスク
戻り値
擬似コードでは以下のような値を返します。
int rval = 0
rval |= value32[0] == 0xFFFFFFFFU ? 0x01 : 0x00
rval |= value32[1] == 0xFFFFFFFFU ? 0x02 : 0x00
.....
rval |= value32[3] == 0xFFFFFFFFU ? 0x08 : 0x00
return rval
説明
アーキテクチャによってどのビットが結果に反映されるかどうかが異なります。
  • SSE4.1(_mm_movemask_epi8, PMOVMSKB)では最上位ビットの値が結果に反映されます。
  • NEONではレーンによって異なるビットがサンプリングされて結果に反映されます。
いずれの場合でも、比較演算の結果を入力とした場合には意図した通りの動作をします。
nn::nlib::simd::I128::MoveMask8 ( i128arg  value)
staticnoexcept

各8bitレーンを1bitの値に集約して整数として返します。

引数
[in]value16個の8bitマスク
戻り値
擬似コードでは以下のような値を返します。
int rval = 0
rval |= value8[0] == 0xFFU ? 0x0001 : 0x0000
rval |= value8[1] == 0xFFU ? 0x0002 : 0x0000
.....
rval |= value8[15] == 0xFFU ? 0x8000 : 0x0000
return rval
説明
アーキテクチャによってどのビットが結果に反映されるかどうかが異なります。
  • SSE4.1(_mm_movemask_epi8, PMOVMSKB)では最上位ビットの値が結果に反映されます。
  • NEONではレーンによって異なるビットがサンプリングされて結果に反映されます。
いずれの場合でも、比較演算の結果を入力とした場合には意図した通りの動作をします。
nn::nlib::simd::I128::Mult16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの整数値を乗算します。

引数
[in]a8個の16bit整数
[in]b8個の16bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = a16[0] * b16[0]
r16[1] = a16[1] * a16[1]
....
r16[7] = a16[7] + b16[7]
nn::nlib::simd::I128::Mult32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の32bitの各レーンの整数値を乗算します。

引数
[in]a4個の32bit整数
[in]b4個の32bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = a32[0] * b32[0]
r32[1] = a32[1] * a32[1]
....
r32[3] = a32[3] + b32[3]
nn::nlib::simd::I128::MultAdd16 ( i128arg  a,
i128arg  b,
i128arg  c 
)
staticnoexcept

ab の16bitの各レーンの整数値を乗算し、その結果にc の16bitの各レーンの整数値を加算します。

引数
[in]a8個の16bit整数
[in]b8個の16bit整数
[in]c8個の16bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = c16[0] + a16[0] * b16[0]
r16[1] = c16[1] + a16[1] * a16[1]
....
r16[7] = c16[7] + a16[7] * b16[7]
nn::nlib::simd::I128::MultAdd32 ( i128arg  a,
i128arg  b,
i128arg  c 
)
staticnoexcept

ab の32bitの各レーンの整数値を乗算し、その結果にc の32bitの各レーンの整数値を加算します。

引数
[in]a4個の32bit整数
[in]b4個の32bit整数
[in]c4個の32bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = c32[0] + a32[0] * b32[0]
r32[1] = c32[1] + a32[1] * a32[1]
....
r32[3] = c32[3] + a32[3] * b32[3]
nn::nlib::simd::I128::MultSub16 ( i128arg  a,
i128arg  b,
i128arg  c 
)
staticnoexcept

ab の16bitの各レーンの整数値を乗算し、その結果をc の16bitの各レーンの整数値から減算します。

引数
[in]a8個の16bit整数
[in]b8個の16bit整数
[in]c8個の16bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = c16[0] - a16[0] * b16[0]
r16[1] = c16[1] - a16[1] * a16[1]
....
r16[7] = c16[7] - a16[7] * b16[7]
nn::nlib::simd::I128::MultSub32 ( i128arg  a,
i128arg  b,
i128arg  c 
)
staticnoexcept

ab の32bitの各レーンの整数値を乗算し、その結果をc の32bitの各レーンの整数値から減算します。

引数
[in]a4個の32bit整数
[in]b4個の32bit整数
[in]c4個の32bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = c32[0] - a32[0] * b32[0]
r32[1] = c32[1] - a32[1] * a32[1]
....
r32[3] = c32[3] - a32[3] * b32[3]
nn::nlib::simd::I128::NarrowFrom16To8 ( i128arg  lo,
i128arg  hi 
)
staticnoexcept

16bit幅のレーンの上位8bitをカットして16個を1つの128bit値にして返します。

引数
[in]lo8個の16bitレーン
[in]hi8個の16bitレーン
戻り値
16個の8bit値で、擬似コードでは以下のような値を返します。
r8[0] = lo8[0]
r8[1] = lo8[2]
r8[2] = lo8[4]
....
r8[7] = lo8[14]
r8[8] = hi8[0]
....
r8[15] = hi8[14]
nn::nlib::simd::I128::NarrowFrom32To16 ( i128arg  lo,
i128arg  hi 
)
staticnoexcept

32bit幅のレーンの上位16bitをカットして8個を1つの128bit値にして返します。

引数
[in]lo4個の32bitレーン
[in]hi4個の32bitレーン
戻り値
8個の16bit値で、擬似コードでは以下のような値を返します。
r16[0] = lo16[0]
r16[1] = lo16[2]
....
r16[3] = lo16[3]
r16[4] = hi16[0]
....
r16[7] = hi16[3]
nn::nlib::simd::I128::NarrowFrom64To32 ( i128arg  lo,
i128arg  hi 
)
staticnoexcept

64bit幅のレーンの上位32bitをカットして4個を1つの128bit値にして返します。

引数
[in]lo2個の64bitレーン
[in]hi2個の64bitレーン
戻り値
4個の32bit値で、擬似コードでは以下のような値を返します。
r32[0] = lo32[0]
r32[1] = lo32[2]
r32[2] = hi32[0]
r32[3] = hi32[2]
nn::nlib::simd::I128::OrNot ( i128arg  a,
i128arg  b 
)
staticnoexcept

a のビット単位での否定と、b のビット単位での論理和を計算します。

引数
[in]a128bitの値
[in]b128bitの値
戻り値
~a | bを返します。
nn::nlib::simd::I128::PairwiseAdd16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの整数値を水平加算します。

引数
[in]a8個の16bit整数
[in]b8個の16bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = a16[0] + a16[1]
r16[1] = a16[2] + a16[3]
....
r16[4] = b16[0] + b16[1]
r16[5] = b16[2] + b16[3]
....
r16[7] = b16[6] + b16[7]
nn::nlib::simd::I128::PairwiseAdd32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の32bitの各レーンの整数値を水平加算します。

引数
[in]a4個の32bit整数
[in]b4個の32bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = a32[0] + a32[1]
r32[1] = a32[2] + a32[3]
r32[2] = b32[0] + b32[1]
r32[3] = b32[2] + b32[3]
nn::nlib::simd::I128::PairwiseAdd8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの整数値を水平加算します。

引数
[in]a16個の8bit整数
[in]b16個の8bit整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = a8[0] + a8[1]
r8[1] = a8[2] + a8[3]
r8[2] = a8[4] + a8[5]
r8[3] = a8[6] + a8[7]
....
r8[8] = b8[0] + b8[1]
r8[9] = b8[2] + b8[3]
....
r8[15] = b8[14] + b8[15]
nn::nlib::simd::I128::Select ( i128arg  mask,
i128arg  a,
i128arg  b 
)
staticnoexcept

mask の値に従ってab を合成します。

引数
[in]mask16個の8bit幅のマスク
[in]a16個の8bit値
[in]b16個の8bit値
戻り値
ab が合成された値で、擬似コードでは以下のような値を返します。
r8[0] = mask8[0] == 0xFFU ? a[0] : b[0]
r8[1] = mask8[1] == 0xFFU ? a[1] : b[1]
....
r8[15] = mask8[15] == 0xFFU ? a[15] : b[15]
説明
各マスクが0xFF又は0でない場合、動作結果は不定です。SIMDコード内でのif文の代わりとして利用されます。
template<size_t N>
nn::nlib::simd::I128::SetUint16ToLane ( i128arg  value,
uint16_t  v 
)
staticnoexcept

value のレーン N の16bit符号なし整数をv に設定します。

テンプレート引数
Tレーンの値です。0以上7以下の整数を指定します。
引数
[in]value8個の16bitの符号なし整数
[in]v16bitの符号なし整数
戻り値
変更された128bit値
template<size_t N>
nn::nlib::simd::I128::SetUint32ToLane ( i128arg  value,
uint32_t  v 
)
staticnoexcept

value のレーン N の32bit符号なし整数をv に設定します。

テンプレート引数
Tレーンの値です。0以上3以下の整数を指定します。
引数
[in]value4個の32bitの符号なし整数
[in]v32bitの符号なし整数
戻り値
変更された128bit値
template<size_t N>
nn::nlib::simd::I128::SetUint64ToLane ( i128arg  value,
uint64_t  v 
)
staticnoexcept

value のレーン N の64bit符号なし整数をv に設定します。

テンプレート引数
Tレーンの値です。0以上1以下の整数を指定します。
引数
[in]value2個の64bitの符号なし整数
[in]v64bitの符号なし整数
戻り値
変更された128bit値
template<size_t N>
nn::nlib::simd::I128::SetUint8ToLane ( i128arg  value,
uint8_t  v 
)
staticnoexcept

value のレーン N の8bit符号なし整数をv に設定します。

テンプレート引数
Tレーンの値です。0以上15以下の整数を指定します。
引数
[in]value16個の8bitの符号なし整数
[in]v8bitの符号なし整数
戻り値
変更された128bit値
template<size_t N>
nn::nlib::simd::I128::SetValue ( i128  value,
each_select32_tag   
)
staticnoexcept

value のレーンN の32bit値を全てのレーンに設定します。

テンプレート引数
Nレーン
引数
[in]value128bit値
戻り値
設定された128bit値
template<size_t N>
nn::nlib::simd::I128::SetValue ( i128  value,
each_select16_tag   
)
staticnoexcept

value のレーンN の16bit値を全てのレーンに設定します。

テンプレート引数
Nレーン
引数
[in]value128bit値
戻り値
設定された128bit値
template<size_t N>
nn::nlib::simd::I128::SetValue ( i128  value,
each_select8_tag   
)
staticnoexcept

value のレーンN の8bit値を全てのレーンに設定します。

テンプレート引数
Nレーン
引数
[in]value128bit値
戻り値
設定された128bit値
nn::nlib::simd::I128::Shuffle8 ( i128arg  value,
i128arg  shuffle 
)
staticnoexcept

16個の8bit値を重複も含めて任意の並びに並べ替えます。

引数
[in]value並べ替えられる16個の8bit値
[in]shuffle16個の8bitインデックス(0以上15以下の値か0x80)
戻り値
擬似コードでは以下のような値を返します。
r8[0] = shuffle8[0] == 0x80 ? 0 : value8[shuffle8[0]]
....
r8[15] = shuffle8[15] == 0x80 ? 0 : value8[shuffle8[15]]
説明
shuffle の8bit値が0以上15以下又は0x80でない場合の動作は不定です。
nn::nlib::simd::I128::Sub16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの整数値を減算します。

引数
[in]a8個の16bit値
[in]b8個の16bit値
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = a16[0] - b16[0]
r16[1] = a16[1] - b16[0]
....
r16[7] = a16[7] - b16[7]
nn::nlib::simd::I128::Sub32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の32bitの各レーンの整数値を減算します。

引数
[in]a4個の32bit値
[in]b4個の32bit値
戻り値
以下のような擬似コードで示される計算結果を返します。
r32[0] = a32[0] - b32[0]
r32[1] = a32[1] - b32[0]
...
r32[3] = a32[3] - b32[3]
nn::nlib::simd::I128::Sub64 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の64bitの各レーンの整数値を減算します。

引数
[in]a2個の64bit値
[in]b2個の64bit値
戻り値
以下のような擬似コードで示される計算結果を返します。
r64[0] = a64[0] - b64[0]
r64[1] = a64[1] - b64[0]
nn::nlib::simd::I128::Sub8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの整数値を減算します。

引数
[in]a16個の8bit値
[in]b16個の8bit値
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = a8[0] - b8[0]
r8[1] = a8[1] - b8[0]
....
r8[15] = a8[15] - b8[15]
nn::nlib::simd::I128::SubInt16Saturated ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの符号付き整数値を飽和減算します。

引数
[in]a8個の16bit符号付き整数
[in]b8個の16bit符号付き整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = clamp(a16[0] - b16[0], INT16_MIN, INT16_MAX)
r16[1] = clamp(a16[1] - b16[1], INT16_MIN, INT16_MAX)
....
r16[7] = clamp(a16[7] - b16[7], INT16_MIN, INT16_MAX)
nn::nlib::simd::I128::SubInt8Saturated ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの符号付き整数値を飽和減算します。

引数
[in]a16個の8bit符号付き整数
[in]b16個の8bit符号付き整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = clamp(a8[0] - b8[0], INT8_MIN, INT8_MAX)
r8[1] = clamp(a8[1] - b8[1], INT8_MIN, INT8_MAX)
....
r8[15] = clamp(a8[15] - b8[15], INT8_MIN, INT8_MAX)
nn::nlib::simd::I128::SubUint16Saturated ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の16bitの各レーンの符号なし整数値を飽和減算します。

引数
[in]a8個の16bit符号なし整数
[in]b8個の16bit符号なし整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r16[0] = clamp(a16[0] - b16[0], 0)
r16[1] = clamp(a16[1] - b16[1], 0)
....
r16[7] = clamp(a16[7] - b16[7], 0)
nn::nlib::simd::I128::SubUint8Saturated ( i128arg  a,
i128arg  b 
)
staticnoexcept

ab の8bitの各レーンの符号なし整数値を飽和減算します。

引数
[in]a16個の8bit符号なし整数
[in]b16個の8bit符号なし整数
戻り値
以下のような擬似コードで示される計算結果を返します。
r8[0] = clamp(a8[0] - b8[0], 0)
r8[1] = clamp(a8[1] - b8[1], 0)
....
r8[15] = clamp(a8[15] - b8[15], 0)
nn::nlib::simd::I128::Unzip16 ( i64arg  a,
i64arg  b 
)
staticnoexcept

ab の16bitの値をインターリーブ解除します。

引数
[in]a4個の16bit値
[in]b4個の16bit値
戻り値
8個の16bit値で、擬似コードでは以下のような値を返します。
r16[0] = a16[0]
r16[1] = a16[2]
....
r16[3] = b16[2]
r16[4] = a16[1]
....
r16[6] = b16[1]
r16[7] = b16[3]
nn::nlib::simd::I128::Unzip32 ( i64arg  a,
i64arg  b 
)
staticnoexcept

ab の32bitの値をインターリーブ解除します。実際にはZip32()と同じ動作をします。

引数
[in]a2個の32bit値
[in]b2個の32bit値
戻り値
4個の32bit値で、擬似コードでは以下のような値を返します。
r32[0] = a32[0]
r32[1] = b32[0]
r32[2] = a32[1]
r32[3] = b32[1]
nn::nlib::simd::I128::Unzip8 ( i64arg  a,
i64arg  b 
)
staticnoexcept

ab の8bitの値をインターリーブ解除します。

引数
[in]a8個の8bit値
[in]b8個の8bit値
戻り値
16個の8bit値で、擬似コードでは以下のような値を返します。
r8[0] = a8[0]
r8[1] = a8[2]
r8[2] = a8[4]
r8[3] = a8[6]
....
r8[7] = b8[6]
r8[8] = a8[1]
....
r8[14] = b8[5]
r8[15] = b8[7]
nn::nlib::simd::I128::Zip16 ( i64arg  a,
i64arg  b 
)
staticnoexcept

ab の16bitの値をインターリーブします。

引数
[in]a4個の16bit値
[in]b4個の16bit値
戻り値
8個の16bit値で、擬似コードでは以下のような値を返します。
r16[0] = a16[0]
r16[1] = b16[0]
r16[2] = a16[1]
r16[3] = b16[1]
....
r16[6] = a16[3]
r16[7] = b16[3]
nn::nlib::simd::I128::Zip32 ( i64arg  a,
i64arg  b 
)
staticnoexcept

ab の32bitの値をインターリーブします。

引数
[in]a2個の32bit値
[in]b2個の32bit値
戻り値
4個の32bit値で、擬似コードでは以下のような値を返します。
r32[0] = a32[0]
r32[1] = b32[0]
r32[2] = a32[1]
r32[3] = b32[1]
nn::nlib::simd::I128::Zip8 ( i64arg  a,
i64arg  b 
)
staticnoexcept

ab の8bitの値をインターリーブします。

引数
[in]a8個の8bit値
[in]b8個の8bit値
戻り値
16個の8bit値で、擬似コードでは以下のような値を返します。
r8[0] = a8[0]
r8[1] = b8[0]
r8[2] = a8[1]
r8[3] = b8[1]
....
r8[14] = a8[7]
r8[15] = b8[7]

このクラス詳解は次のファイルから抽出されました: