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 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 LoadLoA8 (const void *p) noexcept
 8バイトアライメントのアドレスp から8バイトのデータを読み込み下位64bitに値を設定し、上位64bitに0を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadLoA4 (const void *p) noexcept
 4バイトアライメントのアドレスp から8バイトのデータを読み込み下位64bitに値を設定し、上位64bitに0を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadLoA2 (const void *p) noexcept
 2バイトアライメントのアドレスp から8バイトのデータを読み込み下位64bitに値を設定し、上位64bitに0を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadLoA1 (const void *p) noexcept
 アライメントされていないアドレスp から8バイトのデータを読み込み下位64bitに値を設定し、上位64bitに0を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadHiA8 (const void *p) noexcept
 8バイトアライメントのアドレスp から8バイトのデータを読み込み上位64bitに値を設定し、下位64bitに0を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadHiA4 (const void *p) noexcept
 4バイトアライメントのアドレスp から8バイトのデータを読み込み上位64bitに値を設定し、下位64bitに0を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadHiA2 (const void *p) noexcept
 2バイトアライメントのアドレスp から8バイトのデータを読み込み上位64bitに値を設定し、下位64bitに0を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static i128 LoadHiA1 (const void *p) noexcept
 アライメントされていないアドレスp から8バイトのデータを読み込み上位64bitに値を設定し、下位64bitに0を設定します。引数型はuintptr_t又はintptr_tでも可。
 
メモリへのストア
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 StoreLoA8 (void *p, i128arg value) noexcept
 8バイトアライメントのアドレスpvalue の下位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreLoA4 (void *p, i128arg value) noexcept
 4バイトアライメントのアドレスpvalue の下位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreLoA2 (void *p, i128arg value) noexcept
 2バイトアライメントのアドレスpvalue の下位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreLoA1 (void *p, i128arg value) noexcept
 アライメントされていないアドレスpvalue の下位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreHiA8 (void *p, i128arg value) noexcept
 8バイトアライメントのアドレスpvalue の上位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreHiA4 (void *p, i128arg value) noexcept
 4バイトアライメントのアドレスpvalue の上位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreHiA2 (void *p, i128arg value) noexcept
 2バイトアライメントのアドレスpvalue の上位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreHiA1 (void *p, i128arg value) noexcept
 アライメントされていないアドレスpvalue の上位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
特定のレーンの値の取得と設定
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 Test8 (i128arg a, i128arg b) noexcept
 I128::Not(I128::CmpEqZero8(I128::And(a, b)))と同義です。
 
static i128 Test16 (i128arg a, i128arg b) noexcept
 I128::Not(I128::CmpEqZero16(I128::And(a, b)))と同義です。
 
static i128 Test32 (i128arg a, i128arg b) noexcept
 I128::Not(I128::CmpEqZero32(I128::And(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 CmpEq64 (i128arg a, i128arg b) noexcept
 ab を64bitのレーン単位で比較を行います。 [詳解]
 
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 CmpLtInt64 (i128arg a, i128arg b) noexcept
 ab を64bitの符号付き整数として比較を行います。 [詳解]
 
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 CmpGtInt64 (i128arg a, i128arg b) noexcept
 ab を64bitの符号付き整数として比較を行います。 [詳解]
 
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 CmpLtUint64 (i128arg a, i128arg b) noexcept
 ab を64bitの符号なし整数として比較を行います。 [詳解]
 
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 CmpGtUint64 (i128arg a, i128arg b) noexcept
 ab を64bitの符号なし整数として比較を行います。 [詳解]
 
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 CmpLeInt64 (i128arg a, i128arg b) noexcept
 ab を64bitの符号付き整数として比較を行います。 [詳解]
 
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 CmpGeInt64 (i128arg a, i128arg b) noexcept
 ab を64bitの符号付き整数として比較を行います。 [詳解]
 
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 CmpLeUint64 (i128arg a, i128arg b) noexcept
 ab を64bitの符号なし整数として比較を行います。 [詳解]
 
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 CmpGeUint64 (i128arg a, i128arg b) noexcept
 ab を64bitの符号なし整数として比較を行います。 [詳解]
 
static i128 CmpEqZero8 (i128arg value) noexcept
 I128::CmpEq8(value, I128::SetZero())と同義です。
 
static i128 CmpEqZero16 (i128arg value) noexcept
 I128::CmpEq16(value, I128::SetZero())と同義です。
 
static i128 CmpEqZero32 (i128arg value) noexcept
 I128::CmpEq32(value, I128::SetZero())と同義です。
 
static i128 CmpEqZero64 (i128arg value) noexcept
 I128::CmpEq64(value, I128::SetZero())と同義です。
 
全てのレーンに対するビットシフト
static i128 ShiftLeftLogical8 (i128arg value, int count) noexcept
 8bitの各レーンをcount だけ左シフトします。
 
static i128 ShiftRightLogical8 (i128arg value, int count) noexcept
 8bitの各レーンをcount だけ右論理シフトします。
 
static i128 ShiftRightArithmetic8 (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 だけ右論理シフトします。
 
全てのレーンに対するビットシフト(定数シフト)
template<size_t N>
static i128 ShiftLeftLogical8 (i128arg value) noexcept
 8bitの各レーンをN だけ左シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftRightLogical8 (i128arg value) noexcept
 8bitの各レーンをN だけ右シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftRightArithmetic8 (i128arg value) noexcept
 8bitの各レーンをN だけ算術右シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftLeftLogical16 (i128arg value) noexcept
 16bitの各レーンをN だけ左シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftRightLogical16 (i128arg value) noexcept
 16bitの各レーンをN だけ右シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftRightArithmetic16 (i128arg value) noexcept
 16bitの各レーンをN だけ算術右シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftLeftLogical32 (i128arg value) noexcept
 32bitの各レーンをN だけ左シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftRightLogical32 (i128arg value) noexcept
 32bitの各レーンをN だけ右シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftRightArithmetic32 (i128arg value) noexcept
 32bitの各レーンをN だけ算術右シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftLeftLogical64 (i128arg value) noexcept
 64bitの各レーンをN だけ左シフトします。 [詳解]
 
template<size_t N>
static i128 ShiftRightLogical64 (i128arg value) noexcept
 64bitの各レーンをN だけ右シフトします。 [詳解]
 
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 ConvertFromInt8ToInt16Lo (i128arg value) noexcept
 引数の下位64bitの8bit符号付き整数8個を16bitの符号付き整数8個に符号拡張します。 [詳解]
 
static i128 ConvertFromInt8ToInt16Hi (i128arg value) noexcept
 引数の上位64bitの8bit符号付き整数8個を16bitの符号付き整数8個に符号拡張します。 [詳解]
 
static i128 ConvertFromInt16ToInt32Lo (i128arg value) noexcept
 引数の下位64bitの16bit符号付き整数4個を32bitの符号付き整数4個に符号拡張します。 [詳解]
 
static i128 ConvertFromInt16ToInt32Hi (i128arg value) noexcept
 引数の上位64bitの16bit符号付き整数4個を32bitの符号付き整数4個に符号拡張します。 [詳解]
 
static i128 ConvertFromInt32ToInt64Lo (i128arg value) noexcept
 引数の下位64bitの32bit符号付き整数2個を64bitの符号付き整数2個に符号拡張します。 [詳解]
 
static i128 ConvertFromInt32ToInt64Hi (i128arg value) noexcept
 引数の上位64bitの32bit符号付き整数2個を64bitの符号付き整数2個に符号拡張します。 [詳解]
 
static i128 ConvertFromUint8ToUint16Lo (i128arg value) noexcept
 引数の下位64bitの8bit符号なし整数8個を16bitの符号なし整数8個に拡張します。 [詳解]
 
static i128 ConvertFromUint8ToUint16Hi (i128arg value) noexcept
 引数の上位64bitの8bit符号なし整数8個を16bitの符号なし整数8個に拡張します。 [詳解]
 
static i128 ConvertFromUint16ToUint32Lo (i128arg value) noexcept
 引数の下位64bitの16bit符号なし整数4個を32bitの符号なし整数4個に変換します。 [詳解]
 
static i128 ConvertFromUint16ToUint32Hi (i128arg value) noexcept
 引数の上位64bitの16bit符号なし整数4個を32bitの符号なし整数4個に変換します。 [詳解]
 
static i128 ConvertFromUint32ToUint64Lo (i128arg value) noexcept
 引数の下位64bitの32bit符号なし整数2個を64bitの符号なし整数2個に変換します。 [詳解]
 
static i128 ConvertFromUint32ToUint64Hi (i128arg value) noexcept
 引数の上位64bitの32bit符号なし整数2個を64bitの符号なし整数2個に変換します。 [詳解]
 
ZipとUnzip
static i128 Zip8Lo (i128arg a, i128arg b) noexcept
 I128::Permute8<0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23>(a, b)と同じ結果を返します。
 
static i128 Zip8Hi (i128arg a, i128arg b) noexcept
 I128::Permute8<8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31>(a, b)と同じ結果を返します。
 
static i128 Unzip8Lo (i128arg a, i128arg b) noexcept
 I128::Permute8<0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30>(a, b)と同じ結果を返します。
 
static i128 Unzip8Hi (i128arg a, i128arg b) noexcept
 I128::Permute8<1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31>(a, b)と同じ結果を返します。
 
static i128 Zip16Lo (i128arg a, i128arg b) noexcept
 I128::Permute16<0, 8, 1, 9, 2, 10, 3, 11>(a, b)と同じ結果を返します。
 
static i128 Zip16Hi (i128arg a, i128arg b) noexcept
 I128::Permute16<4, 12, 5, 13, 6, 14, 7, 15>(a, b)と同じ結果を返します。
 
static i128 Unzip16Lo (i128arg a, i128arg b) noexcept
 I128::Permute16<0, 2, 4, 6, 8, 10, 12, 14>(a, b)と同じ結果を返します。
 
static i128 Unzip16Hi (i128arg a, i128arg b) noexcept
 I128::Permute16<1, 3, 5, 7, 9, 11, 13, 15>(a, b)と同じ結果を返します。
 
static i128 Zip32Lo (i128arg a, i128arg b) noexcept
 I128::Permute32<0, 4, 1, 5>(a, b)と同じ結果を返します。
 
static i128 Zip32Hi (i128arg a, i128arg b) noexcept
 I128::Permute32<2, 6, 3, 7>(a, b)と同じ結果を返します。
 
static i128 Unzip32Lo (i128arg a, i128arg b) noexcept
 I128::Permute32<0, 2, 4, 6>(a, b)と同じ結果を返します。
 
static i128 Unzip32Hi (i128arg a, i128arg b) noexcept
 I128::Permute32<1, 3, 5, 7>(a, b)と同じ結果を返します。
 
template<int V0, int V1, int V2, int V3, int V4, int V5, int V6, int V7, int V8, int V9, int V10, int V11, int V12, int V13, int V14, int V15>
static i128 Permute8 (i128arg a, i128arg b) noexcept
 32個の8bit値を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。 [詳解]
 
template<int V0, int V1, int V2, int V3, int V4, int V5, int V6, int V7>
static i128 Permute16 (i128arg a, i128arg b) noexcept
 16個の16bit値を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。 [詳解]
 
template<int V0, int V1, int V2, int V3>
static i128 Permute32 (i128arg a, i128arg b) noexcept
 8個の32bit値を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。 [詳解]
 
エンディアンの反転
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 i128 SetMask8 (int mask) noexcept
 I128::MoveMask8()の逆の計算を行います。
 
static i128 SetMask16 (int mask) noexcept
 I128::MoveMask16()の逆の計算を行います。
 
static i128 SetMask32 (int mask) noexcept
 I128::MoveMask32()の逆の計算を行います。
 
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値を重複も含めて任意の並びに並べ替えます。 [詳解]
 
static int PopCntMask8 (i128arg value) noexcept
 16個の8bit幅のマスクのうち0xFFであるものの個数を返します。 [詳解]
 
static int ClzMask8 (i128arg value) noexcept
 16個の8bit幅のマスクのうち、MSB(最も後ろのバイト)から連続する0であるバイトの数を返します。 [詳解]
 
static int CtzMask8 (i128arg value) noexcept
 16個の8bit幅のマスクのうち、LSB(最も前のバイト)から連続する0であるバイトの数を返します。 [詳解]
 

詳解

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

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

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

関数詳解

§ Add16()

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]

§ Add32()

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]

§ Add64()

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]

§ Add8()

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]

§ AddInt16Saturated()

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)

§ AddInt8Saturated()

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)

§ AddUint16Saturated()

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)

§ AddUint8Saturated()

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)

§ AlignR()

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の値
説明
下図はN = 4の場合の動作を図解したものです。
dot_inline_dotgraph_22.png

§ AndNot()

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

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

引数
[in]a128bitの値
[in]b128bitの値
戻り値
~a & bを返します。

§ ByteRotateRight()

template<size_t N>
nn::nlib::simd::I128::ByteRotateRight ( i128arg  value)
staticnoexcept

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

テンプレート引数
Nローテートするバイト数
引数
[in]valueローテートされる128bitの値
戻り値
ローテート後の128bitの値
説明
下図はN = 4の場合の動作を図解したものです。
dot_inline_dotgraph_23.png

§ ByteShiftLeft()

template<size_t N>
nn::nlib::simd::I128::ByteShiftLeft ( i128arg  value)
staticnoexcept

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

テンプレート引数
Nシフトするバイト数
引数
[in]valueシフトされる128bitの値
戻り値
シフト後の128bitの値
説明
下図はN = 4の場合の動作を図解したものです。
dot_inline_dotgraph_24.png

§ ByteShiftRight()

template<size_t N>
nn::nlib::simd::I128::ByteShiftRight ( i128arg  value)
staticnoexcept

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

テンプレート引数
Nシフトするバイト数
引数
[in]valueシフトされる128bitの値
戻り値
シフト後の128bitの値
説明
下図はN = 4の場合の動作を図解したものです。
dot_inline_dotgraph_25.png

§ ClzMask8()

nn::nlib::simd::I128::ClzMask8 ( i128arg  value)
staticnoexcept

16個の8bit幅のマスクのうち、MSB(最も後ろのバイト)から連続する0であるバイトの数を返します。

引数
[in]value16個の8bit幅のマスク
戻り値
MSB(最も後ろのバイト)から連続する0であるバイトの数
説明
nlib_clz(I128::MoveMask8(value)) - 16と同じ結果になります。

§ CmpEq16()

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

§ CmpEq32()

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 : 0x00000000
r32[1] = a32[1] == b32[1] ? 0xFFFFFFFF : 0x00000000
.....
r32[3] = a32[3] == b32[3] ? 0xFFFFFFFF : 0x00000000

§ CmpEq64()

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

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

引数
[in]a2個の64bit値
[in]b2個の64bit値
戻り値
2個の64bit値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] == b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] == b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpEq8()

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

§ CmpGeInt16()

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

§ CmpGeInt32()

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

§ CmpGeInt64()

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

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

引数
[in]a2個の64bit符号付き整数
[in]b2個の64bit符号付き整数
戻り値
2個の64ビット値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] >= b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] >= b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpGeInt8()

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

§ CmpGeUint16()

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

§ CmpGeUint32()

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

§ CmpGeUint64()

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

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

引数
[in]a2個の64bit符号なし整数
[in]b2個の64bit符号なし整数
戻り値
2個の64ビット値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] >= b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] >= b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpGeUint8()

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

§ CmpGtInt16()

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

§ CmpGtInt32()

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

§ CmpGtInt64()

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

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

引数
[in]a2個の64bit符号付き整数
[in]b2個の64bit符号付き整数
戻り値
2個の64ビット値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] > b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] > b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpGtInt8()

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

§ CmpGtUint16()

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

§ CmpGtUint32()

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

§ CmpGtUint64()

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

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

引数
[in]a2個の64bit符号なし整数
[in]b2個の64bit符号なし整数
戻り値
2個の64ビット値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] > b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] > b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpGtUint8()

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

§ CmpLeInt16()

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

§ CmpLeInt32()

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

§ CmpLeInt64()

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

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

引数
[in]a2個の64bit符号付き整数
[in]b2個の64bit符号付き整数
戻り値
2個の64ビット値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] <= b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] <= b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpLeInt8()

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

§ CmpLeUint16()

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

§ CmpLeUint32()

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

§ CmpLeUint64()

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

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

引数
[in]a2個の64bit符号なし整数
[in]b2個の64bit符号なし整数
戻り値
2個の64ビット値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] <= b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] <= b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpLeUint8()

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

§ CmpLtInt16()

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

§ CmpLtInt32()

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 : 0x00000000
r32[1] = a32[1] < b32[1] ? 0xFFFFFFFF : 0x00000000
.....
r32[3] = a32[3] < b32[3] ? 0xFFFFFFFF : 0x00000000

§ CmpLtInt64()

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

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

引数
[in]a2個の64bit符号付き整数
[in]b2個の64bit符号付き整数
戻り値
2個の64ビット値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] < b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] < b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpLtInt8()

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

§ CmpLtUint16()

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

§ CmpLtUint32()

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

§ CmpLtUint64()

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

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

引数
[in]a2個の64bit符号なし整数
[in]b2個の64bit符号なし整数
戻り値
2個の64ビット値(マスク)で、擬似コードでは以下のような値を返します。
r64[0] = a64[0] < b64[0] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000
r64[1] = a64[1] < b64[1] ? 0xFFFFFFFFFFFFFFFF : 0x0000000000000000

§ CmpLtUint8()

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

§ ConvertFromInt16ToInt32Hi()

nn::nlib::simd::I128::ConvertFromInt16ToInt32Hi ( i128arg  value)
staticnoexcept

引数の上位64bitの16bit符号付き整数4個を32bitの符号付き整数4個に符号拡張します。

引数
[in]value8個の16bit符号付き整数
戻り値
4個の32bit符号つき整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r16[0] = value16[4]
r16[1] = value16[4] < 0 ? 0xFFFF : 0x00
....
r16[6] = value16[7]
r16[7] = value16[7] < 0 ? 0xFFFF : 0x00

§ ConvertFromInt16ToInt32Lo()

nn::nlib::simd::I128::ConvertFromInt16ToInt32Lo ( i128arg  value)
staticnoexcept

引数の下位64bitの16bit符号付き整数4個を32bitの符号付き整数4個に符号拡張します。

引数
[in]value8個の16bit符号付き整数
戻り値
4個の32bit符号つき整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r16[0] = value16[0]
r16[1] = value16[0] < 0 ? 0xFFFF : 0x00
....
r16[6] = value16[3]
r16[7] = value16[3] < 0 ? 0xFFFF : 0x00

§ ConvertFromInt16ToInt8Saturated()

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])

§ ConvertFromInt32ToInt16Saturated()

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])

§ ConvertFromInt32ToInt64Hi()

nn::nlib::simd::I128::ConvertFromInt32ToInt64Hi ( i128arg  value)
staticnoexcept

引数の上位64bitの32bit符号付き整数2個を64bitの符号付き整数2個に符号拡張します。

引数
[in]value4個の32bit符号付き整数
戻り値
2個の64bit符号つき整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r32[0] = value32[2]
r32[1] = value32[2] < 0 ? 0xFFFFFFFF : 0x00
r32[2] = value32[3]
r32[3] = value32[3] < 0 ? 0xFFFFFFFF : 0x00

§ ConvertFromInt32ToInt64Lo()

nn::nlib::simd::I128::ConvertFromInt32ToInt64Lo ( i128arg  value)
staticnoexcept

引数の下位64bitの32bit符号付き整数2個を64bitの符号付き整数2個に符号拡張します。

引数
[in]value4個の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

§ ConvertFromInt8ToInt16Hi()

nn::nlib::simd::I128::ConvertFromInt8ToInt16Hi ( i128arg  value)
staticnoexcept

引数の上位64bitの8bit符号付き整数8個を16bitの符号付き整数8個に符号拡張します。

引数
[in]value16個の8bit符号付き整数
戻り値
8個の16bit符号つき整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r8[0] = value8[8]
r8[1] = value8[8] < 0 ? 0xFF : 0x00
....
r8[14] = value8[15]
r8[15] = value8[15] < 0 ? 0xFF : 0x00

§ ConvertFromInt8ToInt16Lo()

nn::nlib::simd::I128::ConvertFromInt8ToInt16Lo ( i128arg  value)
staticnoexcept

引数の下位64bitの8bit符号付き整数8個を16bitの符号付き整数8個に符号拡張します。

引数
[in]value16個の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

§ ConvertFromUint16ToUint32Hi()

nn::nlib::simd::I128::ConvertFromUint16ToUint32Hi ( i128arg  value)
staticnoexcept

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

引数
[in]value8個の16bit符号なし整数
戻り値
4個の32bit符号なし整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r16[0] = value16[4]
r16[1] = 0
....
r16[6] = value16[7]
r16[7] = 0

§ ConvertFromUint16ToUint32Lo()

nn::nlib::simd::I128::ConvertFromUint16ToUint32Lo ( i128arg  value)
staticnoexcept

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

引数
[in]value8個の16bit符号なし整数
戻り値
4個の32bit符号なし整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r16[0] = value16[0]
r16[1] = 0
....
r16[6] = value16[3]
r16[7] = 0

§ ConvertFromUint16ToUint8Saturated()

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])

§ ConvertFromUint32ToUint16Saturated()

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])

§ ConvertFromUint32ToUint64Hi()

nn::nlib::simd::I128::ConvertFromUint32ToUint64Hi ( i128arg  value)
staticnoexcept

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

引数
[in]value4個の32bit符号なし整数
戻り値
2個の64bit符号なし整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r32[0] = value32[2]
r32[1] = 0
r32[2] = value32[3]
r32[3] = 0

§ ConvertFromUint32ToUint64Lo()

nn::nlib::simd::I128::ConvertFromUint32ToUint64Lo ( i128arg  value)
staticnoexcept

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

引数
[in]value4個の32bit符号なし整数
戻り値
2個の64bit符号なし整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r32[0] = value32[0]
r32[1] = 0
r32[2] = value32[1]
r32[3] = 0

§ ConvertFromUint8ToUint16Hi()

nn::nlib::simd::I128::ConvertFromUint8ToUint16Hi ( i128arg  value)
staticnoexcept

引数の上位64bitの8bit符号なし整数8個を16bitの符号なし整数8個に拡張します。

引数
[in]value16個の8bit符号なし整数
戻り値
8個の16bit符号なし整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r8[0] = value8[8]
r8[1] = 0
....
r8[14] = value8[15]
r8[15] = 0

§ ConvertFromUint8ToUint16Lo()

nn::nlib::simd::I128::ConvertFromUint8ToUint16Lo ( i128arg  value)
staticnoexcept

引数の下位64bitの8bit符号なし整数8個を16bitの符号なし整数8個に拡張します。

引数
[in]value16個の8bit符号なし整数
戻り値
8個の16bit符号なし整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r8[0] = value8[0]
r8[1] = 0
....
r8[14] = value8[7]
r8[15] = 0

§ CtzMask8()

nn::nlib::simd::I128::CtzMask8 ( i128arg  value)
staticnoexcept

16個の8bit幅のマスクのうち、LSB(最も前のバイト)から連続する0であるバイトの数を返します。

引数
[in]value16個の8bit幅のマスク
戻り値
LSB(最も前のバイト)から連続する0であるバイトの数
説明
nlib_ctz(I128::MoveMask8(value))と同じ結果になります。

§ GetUint16FromLane()

template<size_t N>
nn::nlib::simd::I128::GetUint16FromLane ( i128arg  value)
staticnoexcept

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

テンプレート引数
Tレーンの値です。0以上7以下の整数を指定します。
引数
[in]value8個の16bitの符号なし整数
戻り値
16bitの符号なし整数

§ GetUint32FromLane()

template<size_t N>
nn::nlib::simd::I128::GetUint32FromLane ( i128arg  value)
staticnoexcept

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

テンプレート引数
Tレーンの値です。0以上3以下の整数を指定します。
引数
[in]value4個の32bitの符号なし整数
戻り値
32bitの符号なし整数

§ GetUint64FromLane()

template<size_t N>
nn::nlib::simd::I128::GetUint64FromLane ( i128arg  value)
staticnoexcept

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

テンプレート引数
Tレーンの値です。0以上1以下の整数を指定します。
引数
[in]value2個の64bitの符号なし整数
戻り値
64bitの符号なし整数

§ GetUint8FromLane()

template<size_t N>
nn::nlib::simd::I128::GetUint8FromLane ( i128arg  value)
staticnoexcept

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

テンプレート引数
Tレーンの値です。0以上15以下の整数を指定します。
引数
[in]value16個の8bitの符号なし整数
戻り値
8bitの符号なし整数

§ IsFull()

nn::nlib::simd::I128::IsFull ( i128arg  value)
staticnoexcept

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

引数
[in]value128bitの値
戻り値
全てのbitが1の場合はtrue, そうでなければfalse

§ IsZero()

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に対する処理
....
}

§ MaxInt16()

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]

§ MaxInt32()

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]

§ MaxInt8()

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]

§ MaxUint16()

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]

§ MaxUint32()

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]

§ MaxUint8()

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]

§ MinInt16()

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]

§ MinInt32()

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]

§ MinInt8()

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]

§ MinUint16()

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]

§ MinUint32()

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]

§ MinUint8()

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]

§ MoveMask16()

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ではレーンによって異なるビットがサンプリングされて結果に反映されます。
いずれの場合でも、比較演算の結果を入力とした場合には意図した通りの動作をします。

§ MoveMask32()

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ではレーンによって異なるビットがサンプリングされて結果に反映されます。
いずれの場合でも、比較演算の結果を入力とした場合には意図した通りの動作をします。

§ MoveMask8()

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ではレーンによって異なるビットがサンプリングされて結果に反映されます。
いずれの場合でも、比較演算の結果を入力とした場合には意図した通りの動作をします。 この関数には、典型的には以下のような応用が存在します。
  • 戻り値にnlib_ctz()を用いて何らかの条件を満たす最初のレーンのインデックスを得る。
  • 戻り値にnlib_popcnt16()を用いて何らかの条件を満たすレーンの数を得る。

§ Mult16()

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]

§ Mult32()

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]

§ MultAdd16()

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]

§ MultAdd32()

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]

§ MultSub16()

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]

§ MultSub32()

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]

§ NarrowFrom16To8()

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]
説明
この関数の動作は下図のよう図示することができます。
dot_inline_dotgraph_26.png

§ NarrowFrom32To16()

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]
説明
この関数の動作は下図のよう図示することができます。
dot_inline_dotgraph_27.png

§ NarrowFrom64To32()

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]
説明
この関数の動作は下図のよう図示することができます。
dot_inline_dotgraph_28.png

§ OrNot()

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

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

引数
[in]a128bitの値
[in]b128bitの値
戻り値
~a | bを返します。

§ PairwiseAdd16()

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]

§ PairwiseAdd32()

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]

§ PairwiseAdd8()

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]

§ Permute16()

template<int V0, int V1, int V2, int V3, int V4, int V5, int V6, int V7>
nn::nlib::simd::I128::Permute16 ( i128arg  a,
i128arg  b 
)
staticnoexcept

16個の16bit値を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。

テンプレート引数
V0新たな128bit値のレーン0にコピーするレーン番号(0-15)又は-1
V1新たな128bit値のレーン1にコピーするレーン番号(0-15)又は-1
V2新たな128bit値のレーン2にコピーするレーン番号(0-15)又は-1
V3新たな128bit値のレーン3にコピーするレーン番号(0-15)又は-1
V4新たな128bit値のレーン4にコピーするレーン番号(0-15)又は-1
V5新たな128bit値のレーン5にコピーするレーン番号(0-15)又は-1
V6新たな128bit値のレーン6にコピーするレーン番号(0-15)又は-1
V7新たな128bit値のレーン7にコピーするレーン番号(0-15)又は-1
引数
[in]a8個の16bit値
[in]b8個の16bit値
戻り値
8個の16bit値
説明
a からコピーする場合はレーン番号に0-7を、b からコピーする場合はレーン番号に8-15を指定します。
以下のような擬似コードで示される計算結果を返します。
# a[-1] and b[-1] have undefined values.
r[0] = V0 < 8 ? a[V0] : b[V0 - 8];
r[1] = V1 < 8 ? a[V1] : b[V1 - 8];
.....
r[7] = V7 < 8 ? a[V7] : b[V7 - 8];

§ Permute32()

template<int V0, int V1, int V2, int V3>
nn::nlib::simd::I128::Permute32 ( i128arg  a,
i128arg  b 
)
staticnoexcept

8個の32bit値を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。

テンプレート引数
V0新たな128bit値のレーン0にコピーするレーン番号(0-7)又は-1
V1新たな128bit値のレーン1にコピーするレーン番号(0-7)又は-1
V2新たな128bit値のレーン2にコピーするレーン番号(0-7)又は-1
V3新たな128bit値のレーン3にコピーするレーン番号(0-7)又は-1
引数
[in]a4個の32bit値
[in]b4個の32bit値
戻り値
4個の32bit値
説明
a からコピーする場合はレーン番号に0-3を、b からコピーする場合はレーン番号に4-7を指定します。
以下のような擬似コードで示される計算結果を返します。
# a[-1] and b[-1] have undefined values.
r[0] = V0 < 4 ? a[V0] : b[V0 - 4];
r[1] = V1 < 4 ? a[V1] : b[V1 - 4];
.....
r[3] = V3 < 4 ? a[V3] : b[V3 - 4];

§ Permute8()

template<int V0, int V1, int V2, int V3, int V4, int V5, int V6, int V7, int V8, int V9, int V10, int V11, int V12, int V13, int V14, int V15>
nn::nlib::simd::I128::Permute8 ( i128arg  a,
i128arg  b 
)
staticnoexcept

32個の8bit値を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。

テンプレート引数
V0新たな128bit値のレーン0にコピーするレーン番号(0-31)又は-1
V1新たな128bit値のレーン1にコピーするレーン番号(0-31)又は-1
V2新たな128bit値のレーン2にコピーするレーン番号(0-31)又は-1
V3新たな128bit値のレーン3にコピーするレーン番号(0-31)又は-1
V4新たな128bit値のレーン4にコピーするレーン番号(0-31)又は-1
V5新たな128bit値のレーン5にコピーするレーン番号(0-31)又は-1
V6新たな128bit値のレーン6にコピーするレーン番号(0-31)又は-1
V7新たな128bit値のレーン7にコピーするレーン番号(0-31)又は-1
V8新たな128bit値のレーン8にコピーするレーン番号(0-31)又は-1
V9新たな128bit値のレーン9にコピーするレーン番号(0-31)又は-1
V10新たな128bit値のレーン10にコピーするレーン番号(0-31)又は-1
V11新たな128bit値のレーン11にコピーするレーン番号(0-31)又は-1
V12新たな128bit値のレーン12にコピーするレーン番号(0-31)又は-1
V13新たな128bit値のレーン13にコピーするレーン番号(0-31)又は-1
V14新たな128bit値のレーン14にコピーするレーン番号(0-31)又は-1
V15新たな128bit値のレーン15にコピーするレーン番号(0-31)又は-1
引数
[in]a16個の8bit値
[in]b16個の8bit値
戻り値
16個の8bit値
説明
a からコピーする場合はレーン番号に0-15を、b からコピーする場合はレーン番号に16-31を指定します。
以下のような擬似コードで示される計算結果を返します。
# a[-1] and b[-1] have undefined values.
r[0] = V0 < 16 ? a[V0] : b[V0 - 16];
r[1] = V1 < 16 ? a[V1] : b[V1 - 16];
.....
r[15] = V15 < 16 ? a[V15] : b[V15 - 16];

§ PopCntMask8()

nn::nlib::simd::I128::PopCntMask8 ( i128arg  value)
staticnoexcept

16個の8bit幅のマスクのうち0xFFであるものの個数を返します。

引数
[in]value16個の8bit幅のマスク
戻り値
マスクされているバイト数
説明
nlib_popcnt16(I128::MoveMask8(value))と同じ結果になります。

§ Reverse16()

nn::nlib::simd::I128::Reverse16 ( i128arg  value)
staticnoexcept

8個の16bit値のエンディアンを反転します。

引数
[in]value8個の16bit整数
戻り値
エンディアンが反転された8個の16bit整数
説明
この関数の動作は下図のよう図示することができます。
dot_inline_dotgraph_29.png

§ Reverse32()

nn::nlib::simd::I128::Reverse32 ( i128arg  value)
staticnoexcept

4個の32bit値のエンディアンを反転します。

引数
[in]value4個の32bit整数
戻り値
エンディアンが反転された4個の32bit整数
説明
この関数の動作は下図のよう図示することができます。
dot_inline_dotgraph_30.png

§ Reverse64()

nn::nlib::simd::I128::Reverse64 ( i128arg  value)
staticnoexcept

2個の64bit値のエンディアンを反転します。

引数
[in]value2個の64bit整数
戻り値
エンディアンが反転された2個の64bit整数
説明
この関数の動作は下図のよう図示することができます。
dot_inline_dotgraph_31.png

§ Select()

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文の代わりとして利用されます。 例えば、0未満のレーンを0に設定したい場合は、以下のようなコードを書くことで条件分岐を避けることができます。
// result[i] = a[i] < 0 ? 0 : a[i];
zero = I128::SetZero();
mask = I128::CmpLtInt8(a, zero);
result = I128::Select(mask, zero, a);
// same to I128::MaxInt8(a, zero);

§ SetUint16ToLane()

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値

§ SetUint32ToLane()

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値

§ SetUint64ToLane()

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値

§ SetUint8ToLane()

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値

§ SetValue() [1/3]

template<size_t N>
nn::nlib::simd::I128::SetValue ( i128  value,
each_select32_tag   
)
staticnoexcept

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

テンプレート引数
Nレーン
引数
[in]value128bit値
戻り値
設定された128bit値

§ SetValue() [2/3]

template<size_t N>
nn::nlib::simd::I128::SetValue ( i128  value,
each_select16_tag   
)
staticnoexcept

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

テンプレート引数
Nレーン
引数
[in]value128bit値
戻り値
設定された128bit値

§ SetValue() [3/3]

template<size_t N>
nn::nlib::simd::I128::SetValue ( i128  value,
each_select8_tag   
)
staticnoexcept

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

テンプレート引数
Nレーン
引数
[in]value128bit値
戻り値
設定された128bit値

§ ShiftLeftLogical16()

template<size_t N>
nn::nlib::simd::I128::ShiftLeftLogical16 ( i128arg  value)
staticnoexcept

16bitの各レーンをN だけ左シフトします。

テンプレート引数
N左シフトするビット数( \(0 \leq N \leq 16\))
引数
[in]value8個の16bit符号なし整数
戻り値
8個の16bit符号なし整数

§ ShiftLeftLogical32()

template<size_t N>
nn::nlib::simd::I128::ShiftLeftLogical32 ( i128arg  value)
staticnoexcept

32bitの各レーンをN だけ左シフトします。

テンプレート引数
N左シフトするビット数( \(0 \leq N \leq 32\))
引数
[in]value4個の32bit符号なし整数
戻り値
4個の32bit符号なし整数

§ ShiftLeftLogical64()

template<size_t N>
nn::nlib::simd::I128::ShiftLeftLogical64 ( i128arg  value)
staticnoexcept

64bitの各レーンをN だけ左シフトします。

テンプレート引数
N左シフトするビット数( \(0 \leq N \leq 64\))
引数
[in]value2個の64bit符号なし整数
戻り値
2個の64bit符号なし整数

§ ShiftLeftLogical8()

template<size_t N>
nn::nlib::simd::I128::ShiftLeftLogical8 ( i128arg  value)
staticnoexcept

8bitの各レーンをN だけ左シフトします。

テンプレート引数
N左シフトするビット数( \(0 \leq N \leq 8\))
引数
[in]value16個の8bit符号なし整数
戻り値
16個の8bit符号なし整数

§ ShiftRightArithmetic16()

template<size_t N>
nn::nlib::simd::I128::ShiftRightArithmetic16 ( i128arg  value)
staticnoexcept

16bitの各レーンをN だけ算術右シフトします。

テンプレート引数
N右シフトするビット数( \(0 \leq N \leq 16\))
引数
[in]value8個の16bit符号付き整数
戻り値
8個の16bit符号付き整数

§ ShiftRightArithmetic32()

template<size_t N>
nn::nlib::simd::I128::ShiftRightArithmetic32 ( i128arg  value)
staticnoexcept

32bitの各レーンをN だけ算術右シフトします。

テンプレート引数
N右シフトするビット数( \(0 \leq N \leq 32\))
引数
[in]value4個の32bit符号付き整数
戻り値
4個の32bit符号付き整数

§ ShiftRightArithmetic8()

template<size_t N>
nn::nlib::simd::I128::ShiftRightArithmetic8 ( i128arg  value)
staticnoexcept

8bitの各レーンをN だけ算術右シフトします。

テンプレート引数
N右シフトするビット数( \(0 \leq N \leq 8\))
引数
[in]value16個の8bit符号付き整数
戻り値
16個の8bit符号付き整数

§ ShiftRightLogical16()

template<size_t N>
nn::nlib::simd::I128::ShiftRightLogical16 ( i128arg  value)
staticnoexcept

16bitの各レーンをN だけ右シフトします。

テンプレート引数
N右シフトするビット数( \(0 \leq N \leq 16\))
引数
[in]value8個の16bit符号なし整数
戻り値
8個の16bit符号なし整数

§ ShiftRightLogical32()

template<size_t N>
nn::nlib::simd::I128::ShiftRightLogical32 ( i128arg  value)
staticnoexcept

32bitの各レーンをN だけ右シフトします。

テンプレート引数
N右シフトするビット数( \(0 \leq N \leq 32\))
引数
[in]value4個の32bit符号なし整数
戻り値
4個の32bit符号なし整数

§ ShiftRightLogical64()

template<size_t N>
nn::nlib::simd::I128::ShiftRightLogical64 ( i128arg  value)
staticnoexcept

64bitの各レーンをN だけ右シフトします。

テンプレート引数
N右シフトするビット数( \(0 \leq N \leq 64\))
引数
[in]value2個の64bit符号なし整数
戻り値
2個の64bit符号なし整数

§ ShiftRightLogical8()

template<size_t N>
nn::nlib::simd::I128::ShiftRightLogical8 ( i128arg  value)
staticnoexcept

8bitの各レーンをN だけ右シフトします。

テンプレート引数
N右シフトするビット数( \(0 \leq N \leq 8\))
引数
[in]value16個の8bit符号なし整数
戻り値
16個の8bit符号なし整数

§ Shuffle8()

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でない場合の動作は不定です。

§ Sub16()

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]

§ Sub32()

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]

§ Sub64()

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]

§ Sub8()

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]

§ SubInt16Saturated()

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)

§ SubInt8Saturated()

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)

§ SubUint16Saturated()

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)

§ SubUint8Saturated()

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)

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