nlib
nn::nlib::simd::F128 クラス

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

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

静的公開メンバ関数

template<size_t N>
static f128 SetZeroToLane (f128arg value) noexcept
 value のレーンN に0.fを設定します。 [詳解]
 
全てのレーンに値を設定
static f128 SetValue (float v, each_float_tag) noexcept
 4個の32bitのレーンに単精度浮動小数点数を設定します。
 
static f128 SetValue (uint32_t v, each_uint32_tag) noexcept
 4個の32bitのレーンに32bit符号なし整数をビットをそのままに設定します。
 
static f128 SetValue (float a, float b, float c, float d) noexcept
 4個の32bitのレーンにそれぞれ単精度浮動小数点数を設定します。
 
template<size_t N>
static f128 SetValue (f128arg value, each_select32_tag) noexcept
 value のレーンN の単精度浮動小数点数を全てのレーンに設定します。 [詳解]
 
static f128 SetZero () noexcept
 全てのレーンに0.fを設定します。
 
static f128 SetOne () noexcept
 全てのレーンに1.fを設定します。
 
static f128 SetNegativeOne () noexcept
 全てのレーンに-1.fを設定します。
 
static f128 SetEpsilon () noexcept
 全てのレーンにepsilon(1.0e-7f)を設定します。
 
static f128 SetInfinity () noexcept
 全てのレーンに正の無限大(0x7F800000U)を設定します。
 
static f128 SetNaN () noexcept
 全てのレーンにNaN(0x7FC00000U)を設定します。
 
static f128 SetSignMask () noexcept
 全てのレーンに-0.f(0x80000000U)を設定します。
 
メモリからのロード
static f128 LoadA16 (const float *p) noexcept
 16バイトアライメントのアドレスp から16バイトのデータを読み込み値を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static f128 LoadA8 (const float *p) noexcept
 8バイトアライメントのアドレスp から16バイトのデータを読み込み値を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static f128 LoadA4 (const float *p) noexcept
 4バイトアライメントのアドレスp から16バイトのデータを読み込み値を設定します。引数型はuintptr_t又はintptr_tでも可。
 
static f128 LoadA16 (uintptr_t p) noexcept
 LoadA16(const float* p) をラップします。
 
static f128 LoadA8 (uintptr_t p) noexcept
 LoadA8(const float* p) をラップします。
 
static f128 LoadA4 (uintptr_t p) noexcept
 LoadA4(const float* p) をラップします。
 
static f128 LoadA16 (intptr_t p) noexcept
 LoadA16(const float* p) をラップします。
 
static f128 LoadA8 (intptr_t p) noexcept
 LoadA8(const float* p) をラップします。
 
static f128 LoadA4 (intptr_t p) noexcept
 LoadA4(const float* p) をラップします。
 
メモリへのストア
static void StoreA16 (float *p, f128arg value) noexcept
 16バイトアライメントのアドレスpvalue の16バイトのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreA8 (float *p, f128arg value) noexcept
 8バイトアライメントのアドレスpvalue の16バイトのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreA4 (float *p, f128arg value) noexcept
 4バイトアライメントのアドレスpvalue の16バイトのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreA16 (uintptr_t p, f128arg value) noexcept
 StoreA16(float* p, f128arg value) をラップします。
 
static void StoreA8 (uintptr_t p, f128arg value) noexcept
 StoreA8(float* p, f128arg value) をラップします。
 
static void StoreA4 (uintptr_t p, f128arg value) noexcept
 StoreA4(float* p, f128arg value) をラップします。
 
static void StoreA16 (intptr_t p, f128arg value) noexcept
 StoreA16(float* p, f128arg value) をラップします。
 
static void StoreA8 (intptr_t p, f128arg value) noexcept
 StoreA8(float* p, f128arg value) をラップします。
 
static void StoreA4 (intptr_t p, f128arg value) noexcept
 StoreA4(float* p, f128arg value) をラップします。
 
static void StoreLoA8 (float *p, f128arg value) noexcept
 8バイトアライメントのアドレスpvalue の下位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreLoA4 (float *p, f128arg value) noexcept
 4バイトアライメントのアドレスpvalue の下位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreLoA8 (uintptr_t p, f128arg value) noexcept
 StoreLoA8(float* p, f128arg value) をラップします。
 
static void StoreLoA4 (uintptr_t p, f128arg value) noexcept
 StoreLoA4(float* p, f128arg value) をラップします。
 
static void StoreLoA8 (intptr_t p, f128arg value) noexcept
 StoreLoA8(float* p, f128arg value) をラップします。
 
static void StoreLoA4 (intptr_t p, f128arg value) noexcept
 StoreLoA4(float* p, f128arg value) をラップします。
 
static void StoreHiA8 (float *p, f128arg value) noexcept
 8バイトアライメントのアドレスpvalue の上位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreHiA4 (float *p, f128arg value) noexcept
 4バイトアライメントのアドレスpvalue の上位64bitのデータを書き込みます。引数型はuintptr_t又はintptr_tでも可。
 
static void StoreHiA8 (uintptr_t p, f128arg value) noexcept
 StoreHiA8(float* p, f128arg value) をラップします。
 
static void StoreHiA4 (uintptr_t p, f128arg value) noexcept
 StoreHiA4(float* p, f128arg value) をラップします。
 
static void StoreHiA8 (intptr_t p, f128arg value) noexcept
 StoreHiA8(float* p, f128arg value) をラップします。
 
static void StoreHiA4 (intptr_t p, f128arg value) noexcept
 StoreHiA4(float* p, f128arg value) をラップします。
 
整数型との変換
static f128 ConvertFromI128 (i128 value) noexcept
 value から32bitの符号付き整数をそれぞれ単精度浮動小数点数に変換して返します。 [詳解]
 
static i128 ConvertToI128Round (f128 value) noexcept
 value を4つの32bitの符号付き整数に変換して返します。小数点以下は0の方向に丸められます。 [詳解]
 
static i128 ConvertToI128Truncate (f128 value) noexcept
 value を4つの32bitの符号付き整数に変換して返します。小数点以下は0の方向に切り捨てられます。 [詳解]
 
static f128 CastFromI128 (i128 value) noexcept
 value の全てのビットをそのままに f128 に変換して返します。 [詳解]
 
static i128 CastToI128 (f128 value) noexcept
 value の全てのビットをそのままに i128 に変換して返します。 [詳解]
 
template<int N>
static f128 ConvertFromFixedPoint (i128arg value) noexcept
 4個の固定小数点数を4個の単精度浮動小数点数に変換します。 [詳解]
 
template<int N>
static i128 ConvertToFixedPoint (f128arg value) noexcept
 4個の単精度浮動小数点数を4個の固定小数点数に変換します。 [詳解]
 
加減乗除と絶対値
static f128 Add (f128arg a, f128arg b) noexcept
 a, b の同一レーンの浮動小数点数を加算した値を返します。
 
static f128 Sub (f128arg a, f128arg b) noexcept
 a, b の同一レーンの浮動小数点数を減算した値を返します。
 
static f128 Mult (f128arg a, f128arg b) noexcept
 a, b の同一レーンの浮動小数点数を乗算した値を返します。
 
static f128 Mult (float a, f128arg b) noexcept
 b の各レーンに対して、a を乗算した値を返します。
 
template<size_t N>
static f128 Mult (f128arg a, f128arg b, each_select32_tag) noexcept
 a[N] * b に相当する乗算を行います。
 
static f128 Div (f128arg a, f128arg b) noexcept
 a, b の同一レーンの浮動小数点数を除算した値を返します。ゼロ除算の場合は正か負の無限大を返します。
 
static f128 Negate (f128arg value) noexcept
 value の各レーンの浮動小数点数の符号を反転させます。
 
template<bool NegateLane0, bool NegateLane1, bool NegateLane2, bool NegateLane3>
static f128 NegateEx (f128arg value) noexcept
 value の各レーンの符号を反転します。レーン毎に符号を反転するかどうかを設定できます。 [詳解]
 
static f128 MultAdd (f128arg a, f128arg b, f128arg c) noexcept
 c + a * b に相当する積和演算を行います。
 
static f128 MultAdd (float a, f128arg b, f128arg c) noexcept
 c + a * b に相当する積和演算を行います。
 
template<size_t N>
static f128 MultAdd (f128arg a, f128arg b, f128arg c, each_select32_tag) noexcept
 c + a[N] * b に相当する積和演算を行います。
 
static f128 MultSub (f128arg a, f128arg b, f128arg c) noexcept
 c - a * b に相当する積和演算を行います。
 
static f128 MultSub (float a, f128arg b, f128arg c) noexcept
 c - a * b に相当する積和演算を行います。
 
template<size_t N>
static f128 MultSub (f128arg a, f128arg b, f128arg c, each_select32_tag) noexcept
 c - a[N] * b に相当する積和演算を行います。
 
static f128 PairwiseAdd (f128arg a, f128arg b) noexcept
 a, b に対して水平加算を行い、結果を1つの128bit値にまとめます。 [詳解]
 
static f128 Abs (f128arg value) noexcept
 value の各レーンの絶対値を計算して返します。
 
static f128 AbsDiff (f128arg a, f128arg b) noexcept
 ab の各レーンの差分の絶対値を計算して返します。
 
最大・最小
static f128 Max (f128arg a, f128arg b) noexcept
 a, b の同一レーンの値を比較して、大きい方の値を選択した値を返します。 [詳解]
 
static f128 Min (f128arg a, f128arg b) noexcept
 a, b の同一レーンの値を比較して、小さい方の値を選択した値を返します。 [詳解]
 
static f128 PairwiseMax (f128arg a, f128arg b) noexcept
 a, b の隣り合うレーンの値を比較して、大きい方の値を選択した値を返します。 [詳解]
 
static f128 PairwiseMin (f128arg a, f128arg b) noexcept
 a, b の隣り合うレーンの値を比較して、小さい方の値を選択した値を返します。 [詳解]
 
static f128 Clamp (f128arg value, f128arg min, f128arg max) noexcept
 value の各レーンの値が、 min の同一レーンの値未満の場合はmin に、max の同一レーンの値より大きい場合はmax にクランプした値を返します。 [詳解]
 
static f128 Saturate (f128arg value) noexcept
 value の各レーンの値を、 0.0と1.0でクランプします。
 
逆数・平方根
static f128 Recp (f128arg value) noexcept
 value の各レーンの値の逆数を計算します。ゼロ除算の場合は正の無限大を返します。 [詳解]
 
static f128 RecpEst (f128arg value) noexcept
 value の各レーンの値の逆数を相対的に高速・低精度で計算します。ゼロ除算の場合は正の無限大を返します。 [詳解]
 
static f128 Sqrt (f128arg value) noexcept
 value の各レーンの平方根を計算します。 [詳解]
 
static f128 SqrtEst (f128arg value) noexcept
 value の各レーンの平方根を相対的に高速・低精度で計算します。 [詳解]
 
static f128 RecpSqrt (f128arg value) noexcept
 value の各レーンの逆数の平方根を計算します。ゼロ除算の場合は正の無限大を返します。 [詳解]
 
static f128 RecpSqrtEst (f128arg value) noexcept
 value の各レーンの逆数の平方根を相対的に高速・低精度で計算します。ゼロ除算の場合は正の無限大を返します。 [詳解]
 
値の丸め
static f128 Round (f128arg value) noexcept
 value の各レーンの単精度浮動小数点数の小数点以下を四捨五入した値を計算します。 [詳解]
 
static f128 Truncate (f128arg value) noexcept
 value の各レーンの単精度浮動小数点数の小数点以下を0の方向に切り捨てた値を計算します。 [詳解]
 
static f128 Floor (f128arg value) noexcept
 value の各レーンの単精度浮動小数点数以下となる最大の整数値を計算します。 [詳解]
 
static f128 Ceil (f128arg value) noexcept
 value の各レーンの単精度浮動小数点数以上となる最小の整数値を計算します。 [詳解]
 
論理演算
static f128 And (f128arg a, f128arg b) noexcept
 ab のビット単位での論理積を計算します。
 
static f128 Or (f128arg a, f128arg b) noexcept
 ab のビット単位での論理和を計算します。
 
static f128 Xor (f128arg a, f128arg b) noexcept
 ab のビット単位での排他的論理和を計算します。
 
static f128 Not (f128arg a) noexcept
 a のビット単位での否定を計算します。
 
static f128 AndNot (f128arg a, f128arg b) noexcept
 a のビット単位での否定と、b のビット単位での論理積を計算します。 [詳解]
 
static f128 OrNot (f128arg a, f128arg b) noexcept
 a のビット単位での否定と、b のビット単位での論理和を計算します。 [詳解]
 
比較
static f128 CmpEq (f128arg a, f128arg b) noexcept
 ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。 [詳解]
 
static f128 CmpLt (f128arg a, f128arg b) noexcept
 ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。 [詳解]
 
static f128 CmpLe (f128arg a, f128arg b) noexcept
 ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。 [詳解]
 
static f128 CmpGt (f128arg a, f128arg b) noexcept
 ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。 [詳解]
 
static f128 CmpGe (f128arg a, f128arg b) noexcept
 ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。 [詳解]
 
static f128 CmpNe (f128arg a, f128arg b) noexcept
 ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。 [詳解]
 
static f128 CmpNearEq (f128arg a, f128arg b, f128arg eps) noexcept
 ab の差がeps 以内かどうかを調べ、比較結果に応じてビットが設定されます。 [詳解]
 
static f128 InBound (f128arg value, f128arg bounds) noexcept
 value の絶対値が bounds 以下にそれぞれ収まるかどうかを調べ、比較結果に応じてビットが設定されます。 [詳解]
 
static f128 CmpEqZero (f128arg value) noexcept
 F128::CmpEq(value, F128::SetZero())と同義です。
 
static f128 CmpLtZero (f128arg value) noexcept
 F128::CmpLt(value, F128::SetZero())と同義です。
 
static f128 CmpLeZero (f128arg value) noexcept
 F128::CmpLe(value, F128::SetZero())と同義です。
 
static f128 CmpGtZero (f128arg value) noexcept
 F128::CmpGt(value, F128::SetZero())と同義です。
 
static f128 CmpGeZero (f128arg value) noexcept
 F128::CmpGe(value, F128::SetZero())と同義です。
 
static f128 CmpNeZero (f128arg value) noexcept
 F128::CmpNe(value, F128::SetZero())と同義です。
 
static f128 CmpNearEqZero (f128arg value, f128arg eps) noexcept
 F128::CmpNearEq(value, F128::SetZero(), eps)と同義です。
 
三角関数
static f128 AddAngle (f128arg angle1, f128arg angle2) noexcept
 それぞれのレーンに格納された4つのラジアンを加算します。 結果は-π 以上 π 未満に正規化されます。 [詳解]
 
static f128 SubAngle (f128arg angle1, f128arg angle2) noexcept
 それぞれのレーンに格納された4つのラジアンを減算します。 結果は-π 以上 π 未満に正規化されます。 [詳解]
 
static f128 ModAngle (f128arg value) noexcept
 それぞれのレーンに格納された4つのラジアンを-π 以上 π 未満に正規化します。
 
static f128 Sin (f128arg value) noexcept
 それぞれのレーンに格納されたラジアンに対応するサインを計算します。
 
static f128 Cos (f128arg value) noexcept
 それぞれのレーンに格納されたラジアンに対応するコサインを計算します。
 
static f128x2 SinCos (f128arg value) noexcept
 サインとコサインを計算して返します。戻り値のval[0] にサインが、val[1]にコサインが格納されます。
 
static f128 Tan (f128arg value) noexcept
 それぞれのレーンに格納されたラジアンに対応するタンジェントを計算します。
 
static f128 SinH (f128arg value) noexcept
 それぞれのレーンの値のハイパボリックサインを計算します。
 
static f128 CosH (f128arg value) noexcept
 それぞれのレーンの値のハイパボリックコサインを計算します。
 
static f128 TanH (f128arg value) noexcept
 それぞれのレーンの値のハイパボリックタンジェントを計算します。
 
static f128 ArcSin (f128arg value) noexcept
 それぞれのレーンのアークサインを計算します。
 
static f128 ArcCos (f128arg value) noexcept
 それぞれのレーンのアークコサインを計算します。
 
static f128 ArcTan (f128arg value) noexcept
 それぞれのレーンのアークタンジェントを計算します。
 
static f128 ArcTan2 (f128arg y, f128arg x) noexcept
 y / x のアークタンジェントを計算します。 [詳解]
 
static f128 Exp2 (f128arg value) noexcept
 2^value乗の計算をそれぞれのレーンに対して行い、結果をそれぞれのレーンに格納します。 [詳解]
 
static f128 ExpE (f128arg value) noexcept
 e^value乗の計算をそれぞれのレーンに対して行い、結果をそれぞれのレーンに格納します。 [詳解]
 
static f128 Log2 (f128arg value) noexcept
 それぞれのレーンに対して2を底とする対数を計算します。
 
static f128 LogE (f128arg value) noexcept
 それぞれのレーンについてe(自然対数の底)を底とする対数を計算します。
 
補間
static f128 Lerp (f128arg a, f128arg b, f128arg t) noexcept
 a, b の各レーンの値ごとに線形補間を行います。 [詳解]
 
static f128 Hermite (f128arg p0, f128arg v0, f128arg p1, f128arg_ex v1, f128arg_ex t) noexcept
 与えられた引数を用いてHermite補間を行います。 [詳解]
 
static f128 CatmullRom (f128arg p0, f128arg p1, f128arg p2, f128arg_ex p3, f128arg_ex t) noexcept
 与えられた引数を用いてCatmull-Rom補間を行います。 [詳解]
 
static f128 BaryCentric (f128arg p0, f128arg p1, f128arg p2, f128arg_ex f, f128arg_ex g) noexcept
 与えられた引数を用いてBaryCentric補間を行います。 [詳解]
 
その他
static int MoveMask (f128arg value) noexcept
 各32bitレーンを1bitの値に集約して整数として返します。 [詳解]
 
static bool IsAllMaskFalse (f128arg value) noexcept
 論理演算の結果が全て偽であるかどうかを検査します。 [詳解]
 
static bool IsAllMaskTrue (f128arg value) noexcept
 論理演算の結果が全て真であるかどうかを検査します。 [詳解]
 
static f128 Select (f128arg mask, f128arg a, f128arg b) noexcept
 mask の値に従ってab を合成します。この関数を使うことにより条件分岐の実行を避けることができます。 [詳解]
 
static f128 IsNaN (f128arg value) noexcept
 value のレーンの単精度浮動小数点数が非数であった場合、そのレーンのbitが全て1になります。 [詳解]
 
static f128 IsInfinite (f128arg value) noexcept
 value のレーンの単精度浮動小数点数が正の無限か負の無限であった場合、そのレーンのbitが全て1になります。 [詳解]
 
特定のレーンの値の取得と設定
template<size_t N>
static float GetFloatFromLane (f128arg value) noexcept
 value のレーン N の単精度浮動小数点数を取得します。 [詳解]
 
template<size_t N>
static uint32_t GetUint32FromLane (f128arg value) noexcept
 value のレーン N の単精度浮動小数点数のビットパターンを32bit符号なし整数として取得します。 [詳解]
 
static float GetFloatByIndex (f128arg value, size_t idx) noexcept
 value のレーン idx の単精度浮動小数点数を習得します。 [詳解]
 
static uint32_t GetUint32ByIndex (f128arg value, size_t idx) noexcept
 value のレーン idx を符号なし32bit整数として取得します。 [詳解]
 
template<size_t N>
static f128 SetFloatToLane (f128arg value, float v) noexcept
 value のレーン N の単精度浮動小数点数をv に設定したものを返します。 [詳解]
 
static f128 SetFloatByIndex (f128arg value, float v, size_t i) noexcept
 value のレーン i の単精度浮動小数点数をv に設定したものを返します。 [詳解]
 
要素の並べ替え
template<int V0, int V1, int V2, int V3>
static f128 Swizzle (f128arg value) noexcept
 4個の単精度浮動小数点数を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。 [詳解]
 
template<int V0, int V1, int V2, int V3>
static f128 Permute (f128arg a, f128arg b) noexcept
 8個の単精度浮動小数点数を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。 [詳解]
 
template<bool SplatLane0, bool SplatLane1, bool SplatLane2, bool SplatLane3>
static f128 Splat (f128arg value, f128arg splat) noexcept
 value の各レーンの値をテンプレート引数の設定によってsplat の値に置き換えます。splat の値は全てのレーンで同じである必要があります。 [詳解]
 
template<size_t N>
static f128 RotateLeft (f128arg value) noexcept
 4個の単精度浮動小数点数を左にN 個分回転させます。 [詳解]
 
template<size_t N>
static f128 RotateRight (f128arg value) noexcept
 4個の単精度浮動小数点数を右にN 個分回転させます。 [詳解]
 
template<size_t N>
static f128 ShiftRight (f128arg a, f128arg b) noexcept
 a を右にシフトして空いた部分にb の要素を順にシフトする形で設定します。 [詳解]
 

詳解

128bitレジスタ(SSEではXMM0-XMM15, NEONではQ0-Q15)を用いて単精度浮動小数点数のSIMD演算を行うためのクラスです。

説明
原則としてパックされているそれぞれの浮動小数点数が独立に計算される関数が実装されています。
SSEやNEONがサポートされていない環境でも利用することができますが、パフォーマンスは最適なものではありません。
このクラスのメンバは全て静的関数で、クラスをインスタンス化することはできません。

SimdFloat.h80 行目に定義があります。

関数詳解

§ AddAngle()

nn::nlib::simd::F128::AddAngle ( f128arg  angle1,
f128arg  angle2 
)
staticnoexcept

それぞれのレーンに格納された4つのラジアンを加算します。 結果は-π 以上 π 未満に正規化されます。

引数
[in]angle14個の単精度浮動小数点数(ラジアン)
[in]angle24個の単精度浮動小数点数(ラジアン)
戻り値
4個の単精度浮動小数点数(ラジアン)
説明
angle1, angle2 のそれぞれのレーンに格納されたラジアンは -π 以上π 未満である必要があります。

§ AndNot()

nn::nlib::simd::F128::AndNot ( f128arg  a,
f128arg  b 
)
staticnoexcept

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

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

§ ArcTan2()

nn::nlib::simd::F128::ArcTan2 ( f128arg  y,
f128arg  x 
)
staticnoexcept

y / x のアークタンジェントを計算します。

引数
[in]y4個の単精度浮動小数点数
[in]x4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数(アークタンジェント)
説明
境界値に関しては以下のような値を返します。ここで"sign(y)"はy の符号です。
y x
0 - sign(y) * π
0 + sign(y) * 0
y sign(y) * 0
y -∞ sign(y) * π
y ≠ 0 0 sign(y) * π/2
y ≠ 0 - sign(y) * (atan(y/x) + π)
±∞ x sign(y) * π/2
±∞ sign(y) * (π / 4)
±∞ -∞ sign(y) * (π * 3 / 4)
otherwise otherwise atan(y/x)

§ BaryCentric()

nn::nlib::simd::F128::BaryCentric ( f128arg  p0,
f128arg  p1,
f128arg  p2,
f128arg_ex  f,
f128arg_ex  g 
)
staticnoexcept

与えられた引数を用いてBaryCentric補間を行います。

引数
[in]p04個の単精度浮動小数点数(位置0)
[in]p14個の単精度浮動小数点数(位置1)
[in]p24個の単精度浮動小数点数(位置2)
[in]f4個の単精度浮動小数点数(補間係数)
[in]g4個の単精度浮動小数点数(補間係数)
戻り値
BaryCentric補間された4個の単精度浮動小数点数を返します。擬似コードは以下のようになります。
rval[0] = p0[0] + f[0] * (p1[0] - p0[0]) + g[0] * (p2[0] - p0[0])
.....

§ CastFromI128()

nn::nlib::simd::F128::CastFromI128 ( i128  value)
staticnoexcept

value の全てのビットをそのままに f128 に変換して返します。

引数
[in]value128bitの値
戻り値
4個の単精度浮動小数点数

§ CastToI128()

nn::nlib::simd::F128::CastToI128 ( f128  value)
staticnoexcept

value の全てのビットをそのままに i128 に変換して返します。

引数
[in]value4個の単精度浮動小数点数
戻り値
128bitの値

§ CatmullRom()

nn::nlib::simd::F128::CatmullRom ( f128arg  p0,
f128arg  p1,
f128arg  p2,
f128arg_ex  p3,
f128arg_ex  t 
)
staticnoexcept

与えられた引数を用いてCatmull-Rom補間を行います。

引数
[in]p04個の単精度浮動小数点数(位置0)
[in]p14個の単精度浮動小数点数(位置1)
[in]p24個の単精度浮動小数点数(位置2)
[in]p34個の単精度浮動小数点数(位置3)
[in]t4個の単精度浮動小数点数(補間係数)
戻り値
Catmull-Rom補間された4個の単精度浮動小数点数を返します。擬似コードは以下のようになります。
rval[0] = (-t[0]^3 + 2 * t[0]^2 - t[0]) * p0[0] +
(3 * t[0]^3 - 5 * t[0]^2 + 2) * p1[0] +
(-3 * t[0]^3 + 4 * t[0]^2 + t) * p2[0] +
(t[0]^3 - t[0]^2)
rval[0] *= 0.5
......

§ Ceil()

nn::nlib::simd::F128::Ceil ( f128arg  value)
staticnoexcept

value の各レーンの単精度浮動小数点数以上となる最小の整数値を計算します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。
説明
例えば、6.54321は7.0に、-6.54321は-6.0になります。

§ Clamp()

nn::nlib::simd::F128::Clamp ( f128arg  value,
f128arg  min,
f128arg  max 
)
staticnoexcept

value の各レーンの値が、 min の同一レーンの値未満の場合はmin に、max の同一レーンの値より大きい場合はmax にクランプした値を返します。

引数
[in]value4個の単精度浮動小数点数
[in]min4個の単精度浮動小数点数
[in]max4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。以下のような擬似コードになります。
if (value[0] < min[0]) rval[0] = min[0]
else if (value[0] > max[0]) rval[0] = max[0]
else rval[0] = value[0]
.....

§ CmpEq()

nn::nlib::simd::F128::CmpEq ( f128arg  a,
f128arg  b 
)
staticnoexcept

ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r[0] = a[0] == b[0] ? 0xFFFFFFFF : 0x00000000
r[1] = a[1] == b[1] ? 0xFFFFFFFF : 0x00000000
r[2] = a[2] == b[2] ? 0xFFFFFFFF : 0x00000000
r[3] = a[3] == b[3] ? 0xFFFFFFFF : 0x00000000

§ CmpGe()

nn::nlib::simd::F128::CmpGe ( f128arg  a,
f128arg  b 
)
staticnoexcept

ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r[0] = a[0] >= b[0] ? 0xFFFFFFFF : 0x00000000
r[1] = a[1] >= b[1] ? 0xFFFFFFFF : 0x00000000
r[2] = a[2] >= b[2] ? 0xFFFFFFFF : 0x00000000
r[3] = a[3] >= b[3] ? 0xFFFFFFFF : 0x00000000

§ CmpGt()

nn::nlib::simd::F128::CmpGt ( f128arg  a,
f128arg  b 
)
staticnoexcept

ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r[0] = a[0] > b[0] ? 0xFFFFFFFF : 0x00000000
r[1] = a[1] > b[1] ? 0xFFFFFFFF : 0x00000000
r[2] = a[2] > b[2] ? 0xFFFFFFFF : 0x00000000
r[3] = a[3] > b[3] ? 0xFFFFFFFF : 0x00000000

§ CmpLe()

nn::nlib::simd::F128::CmpLe ( f128arg  a,
f128arg  b 
)
staticnoexcept

ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r[0] = a[0] <= b[0] ? 0xFFFFFFFF : 0x00000000
r[1] = a[1] <= b[1] ? 0xFFFFFFFF : 0x00000000
r[2] = a[2] <= b[2] ? 0xFFFFFFFF : 0x00000000
r[3] = a[3] <= b[3] ? 0xFFFFFFFF : 0x00000000

§ CmpLt()

nn::nlib::simd::F128::CmpLt ( f128arg  a,
f128arg  b 
)
staticnoexcept

ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r[0] = a[0] < b[0] ? 0xFFFFFFFF : 0x00000000
r[1] = a[1] < b[1] ? 0xFFFFFFFF : 0x00000000
r[2] = a[2] < b[2] ? 0xFFFFFFFF : 0x00000000
r[3] = a[3] < b[3] ? 0xFFFFFFFF : 0x00000000

§ CmpNe()

nn::nlib::simd::F128::CmpNe ( f128arg  a,
f128arg  b 
)
staticnoexcept

ab を単精度浮動小数点数の単位で比較を行い、比較結果に応じてビットが設定されます。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r[0] = a[0] != b[0] ? 0xFFFFFFFF : 0x00000000
r[1] = a[1] != b[1] ? 0xFFFFFFFF : 0x00000000
r[2] = a[2] != b[2] ? 0xFFFFFFFF : 0x00000000
r[3] = a[3] != b[3] ? 0xFFFFFFFF : 0x00000000

§ CmpNearEq()

nn::nlib::simd::F128::CmpNearEq ( f128arg  a,
f128arg  b,
f128arg  eps 
)
staticnoexcept

ab の差がeps 以内かどうかを調べ、比較結果に応じてビットが設定されます。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
[in]eps4個の単精度浮動小数点数
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r[0] = abs(a[0] - b[0]) < eps[0] ? 0xFFFFFFFF : 0x00000000
r[1] = abs(a[1] - b[1]) < eps[1] ? 0xFFFFFFFF : 0x00000000
r[2] = abs(a[2] - b[2]) < eps[2] ? 0xFFFFFFFF : 0x00000000
r[3] = abs(a[3] - b[3]) < eps[3] ? 0xFFFFFFFF : 0x00000000

§ ConvertFromFixedPoint()

template<int N>
nn::nlib::simd::F128::ConvertFromFixedPoint ( i128arg  value)
staticnoexcept

4個の固定小数点数を4個の単精度浮動小数点数に変換します。

テンプレート引数
N固定小数の小数点の位置
引数
[in]value4個の32bitの符号付き整数
戻り値
4個の単精度浮動小数点数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r[0] = static_cast<float>(value32[0]) * powf(0.5, N);
r[1] = static_cast<float>(value32[1]) * powf(0.5, N);
r[2] = static_cast<float>(value32[2]) * powf(0.5, N);
r[3] = static_cast<float>(value32[3]) * powf(0.5, N);

§ ConvertFromI128()

nn::nlib::simd::F128::ConvertFromI128 ( i128  value)
staticnoexcept

value から32bitの符号付き整数をそれぞれ単精度浮動小数点数に変換して返します。

引数
[in]value4個の32bit符号付き整数
戻り値
4個の単精度浮動小数点数

§ ConvertToFixedPoint()

template<int N>
nn::nlib::simd::F128::ConvertToFixedPoint ( f128arg  value)
staticnoexcept

4個の単精度浮動小数点数を4個の固定小数点数に変換します。

テンプレート引数
N固定小数の小数点の位置
引数
[in]value4個の単精度浮動小数点数
戻り値
4個の32bitの符号付き整数
説明
この関数の動作を擬似コードで示すと以下のようになります。
r32[0] = static_cast<int>(value[0] * powf(2.f, N));
r32[1] = static_cast<int>(value[1] * powf(2.f, N));
r32[2] = static_cast<int>(value[2] * powf(2.f, N));
r32[3] = static_cast<int>(value[3] * powf(2.f, N));

§ ConvertToI128Round()

nn::nlib::simd::F128::ConvertToI128Round ( f128  value)
staticnoexcept

value を4つの32bitの符号付き整数に変換して返します。小数点以下は0の方向に丸められます。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の32bit符号付き整数

§ ConvertToI128Truncate()

nn::nlib::simd::F128::ConvertToI128Truncate ( f128  value)
staticnoexcept

value を4つの32bitの符号付き整数に変換して返します。小数点以下は0の方向に切り捨てられます。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の32bit符号付き整数

§ Exp2()

nn::nlib::simd::F128::Exp2 ( f128arg  value)
staticnoexcept

2^value乗の計算をそれぞれのレーンに対して行い、結果をそれぞれのレーンに格納します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数
説明
この関数は入力引数のチェックやオーバーフローへの対策を行っていません。

§ ExpE()

nn::nlib::simd::F128::ExpE ( f128arg  value)
staticnoexcept

e^value乗の計算をそれぞれのレーンに対して行い、結果をそれぞれのレーンに格納します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数
説明
この関数は入力引数のチェックやオーバーフローへの対策を行っていません。

§ Floor()

nn::nlib::simd::F128::Floor ( f128arg  value)
staticnoexcept

value の各レーンの単精度浮動小数点数以下となる最大の整数値を計算します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。
説明
例えば、6.54321は6.0に、-6.54321は-7.0になります。

§ GetFloatByIndex()

nn::nlib::simd::F128::GetFloatByIndex ( f128arg  value,
size_t  idx 
)
staticnoexcept

value のレーン idx の単精度浮動小数点数を習得します。

引数
[in]value4個の単精度浮動小数点数
[in]idx取得するレーンを指定する0以上3以下の整数
戻り値
指定されたレーンに格納されている単精度浮動小数点数

§ GetFloatFromLane()

template<size_t N>
nn::nlib::simd::F128::GetFloatFromLane ( f128arg  value)
staticnoexcept

value のレーン N の単精度浮動小数点数を取得します。

テンプレート引数
Tレーンの値です。0以上3以下の整数を指定します。
引数
[in]value4個の単精度浮動小数点数
戻り値
指定されたレーンに格納されている単精度浮動小数点数

§ GetUint32ByIndex()

nn::nlib::simd::F128::GetUint32ByIndex ( f128arg  value,
size_t  idx 
)
staticnoexcept

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

引数
[in]value4個の単精度浮動小数点数
[in]idx取得するレーンを指定する0以上3以下の整数
戻り値
指定されたレーンに格納されている単精度浮動小数点数を符号なし32bit整数にキャストしたもの

§ GetUint32FromLane()

template<size_t N>
nn::nlib::simd::F128::GetUint32FromLane ( f128arg  value)
staticnoexcept

value のレーン N の単精度浮動小数点数のビットパターンを32bit符号なし整数として取得します。

テンプレート引数
Tレーンの値です。0以上3以下の整数を指定します。
引数
[in]value4個の単精度浮動小数点数
戻り値
指定されたレーンに格納されている32bit符号なし整数

§ Hermite()

nn::nlib::simd::F128::Hermite ( f128arg  p0,
f128arg  v0,
f128arg  p1,
f128arg_ex  v1,
f128arg_ex  t 
)
staticnoexcept

与えられた引数を用いてHermite補間を行います。

引数
[in]p04個の単精度浮動小数点数(補間の起点)
[in]v04個の単精度浮動小数点数(p0 の接線ベクトル)
[in]p14個の単精度浮動小数点数(補間の終点)
[in]v14個の単精度浮動小数点数(p1 の接線ベクトル)
[in]t4個の単精度浮動小数点数(補間係数)
戻り値
Hermite補間された4個の単精度浮動小数点数を返します。擬似コードは以下のようになります。
rval[0] = (2 * t[0]^3 - 3 * t[0]^2 + 1) * p0[0] +
(t[0]^3 - 2 * t[0]^2 + t[0]) * v0[0] +
(-2 * t[0]^3 + 3 * t[0]^2) * p1[0] +
(t[0]^3 - t[0]^2) * v1[0]
.....

§ InBound()

nn::nlib::simd::F128::InBound ( f128arg  value,
f128arg  bounds 
)
staticnoexcept

value の絶対値が bounds 以下にそれぞれ収まるかどうかを調べ、比較結果に応じてビットが設定されます。

引数
[in]value4個の単精度浮動小数点数
[in]bounds4個の単精度浮動小数点数
戻り値
4個の32bit値(マスク)で、擬似コードでは以下のような値を返します。
r[0] = abs(value[0]) < bounds[0] ? 0xFFFFFFFF : 0x00000000
r[1] = abs(value[1]) < bounds[1] ? 0xFFFFFFFF : 0x00000000
r[2] = abs(value[2]) < bounds[2] ? 0xFFFFFFFF : 0x00000000
r[3] = abs(value[3]) < bounds[3] ? 0xFFFFFFFF : 0x00000000

§ IsAllMaskFalse()

nn::nlib::simd::F128::IsAllMaskFalse ( f128arg  value)
staticnoexcept

論理演算の結果が全て偽であるかどうかを検査します。

引数
[in]value4個の浮動小数点数
戻り値
全てのレーンが偽の場合はtrue, そうでなければfalse
説明
この関数は相対的にMoveMask()よりは軽量なため、以下のように事前に論理演算の結果を検査するために利用することができます。
if (!I128::IsAllMaskFalse(value)) {
int mask = I128::MoveMask(value);
// maskに対する処理
....
}
アーキテクチャにより、実際にどのビットが検査されるかは異なる可能性があります(全てのビットが検査されない可能性があります)。 この関数は比較演算(と論理演算によるその合成)の結果に対して利用するようにしてください。

§ IsAllMaskTrue()

nn::nlib::simd::F128::IsAllMaskTrue ( f128arg  value)
staticnoexcept

論理演算の結果が全て真であるかどうかを検査します。

引数
[in]value4個の浮動小数点数
戻り値
全てのレーンが真の場合はtrue, そうでなければfalse
説明
この関数は相対的にMoveMask()よりは軽量なため、以下のように事前に論理演算の結果を検査するために利用することができます。
if (!I128::IsAllMaskTrue(value)) {
int mask = I128::MoveMask(value);
// maskに対する処理
....
}
アーキテクチャにより、実際にどのビットが検査されるかは異なる可能性があります(全てのビットが検査されない可能性があります)。 この関数は比較演算(と論理演算によるその合成)の結果に対して利用するようにしてください。

§ IsInfinite()

nn::nlib::simd::F128::IsInfinite ( f128arg  value)
staticnoexcept

value のレーンの単精度浮動小数点数が正の無限か負の無限であった場合、そのレーンのbitが全て1になります。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数(マスク)で、擬似コードでは以下のような値を返します。
r[0] = isinf(value[0]) ? 0xFFFFFFFF : 0
r[1] = isinf(value[0]) ? 0xFFFFFFFF : 0
r[2] = isinf(value[0]) ? 0xFFFFFFFF : 0
r[3] = isinf(value[0]) ? 0xFFFFFFFF : 0

§ IsNaN()

nn::nlib::simd::F128::IsNaN ( f128arg  value)
staticnoexcept

value のレーンの単精度浮動小数点数が非数であった場合、そのレーンのbitが全て1になります。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数(マスク)で、擬似コードでは以下のような値を返します。
r[0] = isnan(value[0]) ? 0xFFFFFFFF : 0
r[1] = isnan(value[0]) ? 0xFFFFFFFF : 0
r[2] = isnan(value[0]) ? 0xFFFFFFFF : 0
r[3] = isnan(value[0]) ? 0xFFFFFFFF : 0

§ Lerp()

nn::nlib::simd::F128::Lerp ( f128arg  a,
f128arg  b,
f128arg  t 
)
staticnoexcept

a, b の各レーンの値ごとに線形補間を行います。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
[in]t4個の単精度浮動小数点数
戻り値
線形補間された4個の単精度浮動小数点数を返します。擬似コードは以下のようになります。
rval[0] = a[0] + t[0] * (b[0] - a[0])
rval[1] = a[1] + t[1] * (b[1] - a[1])
rval[2] = a[2] + t[2] * (b[2] - a[2])
rval[3] = a[3] + t[3] * (b[3] - a[3])

§ Max()

nn::nlib::simd::F128::Max ( f128arg  a,
f128arg  b 
)
staticnoexcept

a, b の同一レーンの値を比較して、大きい方の値を選択した値を返します。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。以下のような擬似コードになります。
r[0] = a[0] > b[0] ? a[0] : b[0]
r[1] = a[1] > b[1] ? a[1] : b[1]
r[2] = a[2] > b[2] ? a[2] : b[2]
r[3] = a[3] > b[3] ? a[3] : b[3]

§ Min()

nn::nlib::simd::F128::Min ( f128arg  a,
f128arg  b 
)
staticnoexcept

a, b の同一レーンの値を比較して、小さい方の値を選択した値を返します。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。以下のような擬似コードになります。
r[0] = a[0] < b[0] ? a[0] : b[0]
r[1] = a[1] < b[1] ? a[1] : b[1]
r[2] = a[2] < b[2] ? a[2] : b[2]
r[3] = a[3] < b[3] ? a[3] : b[3]

§ MoveMask()

nn::nlib::simd::F128::MoveMask ( f128arg  value)
staticnoexcept

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

引数
[in]value4個の浮動小数点数(マスク)
戻り値
擬似コードでは以下のような値を返します。
int rval = 0;
// ここではvalueは整数として扱われる
rval |= value[0] == 0xFFFFFFFFU ? 1 : 0
rval |= value[1] == 0xFFFFFFFFU ? 2 : 0
rval |= value[2] == 0xFFFFFFFFU ? 4 : 0
rval |= value[3] == 0xFFFFFFFFU ? 8 : 0
説明
アーキテクチャによってどのビットが結果に反映されるかどうかが異なります。
  • SSE4.1(_mm_movemask_ps, MOVMSKPS)では最上位ビットの値が結果に反映されます。
  • NEONではレーンによって異なるビットがサンプリングされて結果に反映されます。
  • 一般的なアーキテクチャでは全てのビットが立っている場合は1、そうでない場合は0が設定されます。
いずれの場合でも、比較演算の結果を入力とした場合には意図した通りの動作をします。

§ NegateEx()

template<bool NegateLane0, bool NegateLane1, bool NegateLane2, bool NegateLane3>
nn::nlib::simd::F128::NegateEx ( f128arg  value)
staticnoexcept

value の各レーンの符号を反転します。レーン毎に符号を反転するかどうかを設定できます。

テンプレート引数
NegateLane0trueならばレーン0の符号を反転します。
NegateLane1trueならばレーン1の符号を反転します。
NegateLane2trueならばレーン2の符号を反転します。
NegateLane3trueならばレーン3の符号を反転します。
引数
[in]value4つの単精度浮動小数点数
戻り値
レーン毎に符号が反転された4つの単精度浮動小数点数
説明
以下のような擬似コードで表される処理を行います。
ret[0] = NagateLane0 ? -value[0] : value[0];
ret[1] = NagateLane1 ? -value[1] : value[1];
ret[2] = NagateLane2 ? -value[2] : value[2];
ret[3] = NagateLane3 ? -value[3] : value[3];
return ret;

§ OrNot()

nn::nlib::simd::F128::OrNot ( f128arg  a,
f128arg  b 
)
staticnoexcept

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

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

§ PairwiseAdd()

nn::nlib::simd::F128::PairwiseAdd ( f128arg  a,
f128arg  b 
)
staticnoexcept

a, b に対して水平加算を行い、結果を1つの128bit値にまとめます。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
擬似コードでは以下のような値を返します。
r[0] = a[0] + a[1]
r[1] = a[2] + a[3]
r[2] = b[0] + b[1]
r[3] = b[2] + b[3]

§ PairwiseMax()

nn::nlib::simd::F128::PairwiseMax ( f128arg  a,
f128arg  b 
)
staticnoexcept

a, b の隣り合うレーンの値を比較して、大きい方の値を選択した値を返します。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。以下のような擬似コードになります。
r[0] = a[0] > a[1] ? a[0] : a[1]
r[1] = a[2] > a[3] ? a[2] : a[3]
r[2] = b[0] > b[1] ? b[0] : b[1]
r[3] = b[2] > b[3] ? b[2] : b[3]

§ PairwiseMin()

nn::nlib::simd::F128::PairwiseMin ( f128arg  a,
f128arg  b 
)
staticnoexcept

a, b の隣り合うレーンの値を比較して、小さい方の値を選択した値を返します。

引数
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。以下のような擬似コードになります。
r[0] = a[0] < a[1] ? a[0] : a[1]
r[1] = a[2] < a[3] ? a[2] : a[3]
r[2] = b[0] < b[1] ? b[0] : b[1]
r[3] = b[2] < b[3] ? b[2] : b[3]

§ Permute()

template<int V0, int V1, int V2, int V3>
nn::nlib::simd::F128::Permute ( f128arg  a,
f128arg  b 
)
staticnoexcept

8個の単精度浮動小数点数を並べ替えて新たな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]a並べ替えられる4個の単精度浮動小数点数
[in]b並べ替えられる4個の単精度浮動小数点数
戻り値
新たな128bit値
説明
a からコピーする場合はレーン番号に0-3を、b からコピーする場合はレーン番号に4-7を指定します。
以下が図解となります。 セレクタV0,V1,V2,V3が任意のレーンを選択し、戻り値のレーンに値を格納します。
dot_inline_dotgraph_17.png

§ Recp()

nn::nlib::simd::F128::Recp ( f128arg  value)
staticnoexcept

value の各レーンの値の逆数を計算します。ゼロ除算の場合は正の無限大を返します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。以下のような擬似コードになります。
rval[0] = 1.0 / value[0]
rval[1] = 1.0 / value[1]
rval[2] = 1.0 / value[2]
rval[3] = 1.0 / value[3]

§ RecpEst()

nn::nlib::simd::F128::RecpEst ( f128arg  value)
staticnoexcept

value の各レーンの値の逆数を相対的に高速・低精度で計算します。ゼロ除算の場合は正の無限大を返します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。

§ RecpSqrt()

nn::nlib::simd::F128::RecpSqrt ( f128arg  value)
staticnoexcept

value の各レーンの逆数の平方根を計算します。ゼロ除算の場合は正の無限大を返します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。以下のような擬似コードになります。
rval[0] = sqrt(1.0 / value[0])
rval[1] = sqrt(1.0 / value[1])
rval[2] = sqrt(1.0 / value[2])
rval[3] = sqrt(1.0 / value[3])

§ RecpSqrtEst()

nn::nlib::simd::F128::RecpSqrtEst ( f128arg  value)
staticnoexcept

value の各レーンの逆数の平方根を相対的に高速・低精度で計算します。ゼロ除算の場合は正の無限大を返します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。

§ RotateLeft()

template<size_t N>
nn::nlib::simd::F128::RotateLeft ( f128arg  value)
inlinestaticnoexcept

4個の単精度浮動小数点数を左にN 個分回転させます。

テンプレート引数
N0, 1, 2, 3のどれか
引数
[in]value回転される4個の単精度浮動小数点数
戻り値
回転された4個の単精度浮動小数点数
説明
右が小さいレーン番号の値であることに注意してください。Swizzle()関数をラップして実装されています。
下図はN = 1の場合の動作を図解したものです。
dot_inline_dotgraph_18.png

SimdFloat.h320 行目に定義があります。

§ RotateRight()

template<size_t N>
nn::nlib::simd::F128::RotateRight ( f128arg  value)
inlinestaticnoexcept

4個の単精度浮動小数点数を右にN 個分回転させます。

テンプレート引数
N0, 1, 2, 3のどれか
引数
[in]value回転される4個の単精度浮動小数点数
戻り値
回転された4個の単精度浮動小数点数
説明
右が小さいレーン番号の値であることに注意してください。Swizzle()関数をラップして実装されています。
下図はN = 1の場合の動作を図解したものです。
dot_inline_dotgraph_19.png

SimdFloat.h327 行目に定義があります。

§ Round()

nn::nlib::simd::F128::Round ( f128arg  value)
staticnoexcept

value の各レーンの単精度浮動小数点数の小数点以下を四捨五入した値を計算します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。
説明
例えば、6.54321は7.0に、-6.54321は-7.0になります。

§ Select()

nn::nlib::simd::F128::Select ( f128arg  mask,
f128arg  a,
f128arg  b 
)
staticnoexcept

mask の値に従ってab を合成します。この関数を使うことにより条件分岐の実行を避けることができます。

引数
[in]mask4個の32bit幅のマスク
[in]a4個の単精度浮動小数点数
[in]b4個の単精度浮動小数点数
戻り値
ab が合成された値で、擬似コードでは以下のような値を返します。
r[0] = mask[0] == 0xFFFFFFFFU ? a[0] : b[0]
r[1] = mask[1] == 0xFFFFFFFFU ? a[1] : b[1]
r[1] = mask[2] == 0xFFFFFFFFU ? a[2] : b[2]
r[3] = mask[3] == 0xFFFFFFFFU ? a[3] : b[3]
説明
mask の全ビットが1の場合はa のレーンが格納され、全ビットが0の場合はb のレーンが格納されます。 それ以外の値の場合はアーキテクチャに依存します。
ただし、mask は比較演算(と論理演算によるその合成)の結果であれば意図した通りに動作します。

§ SetFloatByIndex()

nn::nlib::simd::F128::SetFloatByIndex ( f128arg  value,
float  v,
size_t  i 
)
staticnoexcept

value のレーン i の単精度浮動小数点数をv に設定したものを返します。

引数
[in]value4個の単精度浮動小数点数
[in]v単精度浮動小数点数
[in]i取得するレーンを指定する0以上3以下の整数
戻り値
4個の単精度浮動小数点数

§ SetFloatToLane()

template<size_t N>
nn::nlib::simd::F128::SetFloatToLane ( f128arg  value,
float  v 
)
staticnoexcept

value のレーン N の単精度浮動小数点数をv に設定したものを返します。

テンプレート引数
Tレーンの値です。0以上3以下の整数を指定します。
引数
[in]value4個の単精度浮動小数点数
[in]v単精度浮動小数点数
戻り値
4個の単精度浮動小数点数

§ SetValue()

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

value のレーンN の単精度浮動小数点数を全てのレーンに設定します。

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

§ SetZeroToLane()

template<size_t N>
nn::nlib::simd::F128::SetZeroToLane ( f128arg  value)
staticnoexcept

value のレーンN に0.fを設定します。

テンプレート引数
Nレーン
引数
[in]value4つの単精度浮動小数点数
戻り値
value のレーンN に0.fが設定された値

§ ShiftRight()

template<size_t N>
nn::nlib::simd::F128::ShiftRight ( f128arg  a,
f128arg  b 
)
inlinestaticnoexcept

a を右にシフトして空いた部分にb の要素を順にシフトする形で設定します。

テンプレート引数
N0, 1, 2, 3のどれか
引数
[in]aシフトされる4個の単精度浮動小数点数
[in]bシフトされる4個の単精度浮動小数点数
戻り値
シフトされた4個の単精度浮動小数点数
説明
右が小さいレーン番号の値であることに注意してください。Permute()関数をラップして実装されています。
下図はN = 1の場合の動作を図解したものです。
dot_inline_dotgraph_20.png

SimdFloat.h333 行目に定義があります。

§ Splat()

template<bool SplatLane0, bool SplatLane1, bool SplatLane2, bool SplatLane3>
nn::nlib::simd::F128::Splat ( f128arg  value,
f128arg  splat 
)
staticnoexcept

value の各レーンの値をテンプレート引数の設定によってsplat の値に置き換えます。splat の値は全てのレーンで同じである必要があります。

テンプレート引数
SplatLane0trueの場合、value のレーン0をsplat で置き換えます。
SplatLane1trueの場合、value のレーン1をsplat で置き換えます。
SplatLane2trueの場合、value のレーン2をsplat で置き換えます。
SplatLane3trueの場合、value のレーン3をsplat で置き換えます。
引数
[in]value4個の単精度浮動小数点数
[in]splat4個の単精度浮動小数点数(全てのレーンが同じ値)
戻り値
新たな128bit値
説明
同様の処理をF128::Permute()で行うより効率がよい場合があります。

§ Sqrt()

nn::nlib::simd::F128::Sqrt ( f128arg  value)
staticnoexcept

value の各レーンの平方根を計算します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。以下のような擬似コードになります。
rval[0] = sqrt(value[0])
rval[1] = sqrt(value[1])
rval[2] = sqrt(value[2])
rval[3] = sqrt(value[3])

§ SqrtEst()

nn::nlib::simd::F128::SqrtEst ( f128arg  value)
staticnoexcept

value の各レーンの平方根を相対的に高速・低精度で計算します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。

§ SubAngle()

nn::nlib::simd::F128::SubAngle ( f128arg  angle1,
f128arg  angle2 
)
staticnoexcept

それぞれのレーンに格納された4つのラジアンを減算します。 結果は-π 以上 π 未満に正規化されます。

引数
[in]angle14個の単精度浮動小数点数(ラジアン)
[in]angle24個の単精度浮動小数点数(ラジアン)
戻り値
4個の単精度浮動小数点数(ラジアン)
説明
angle1, angle2 のそれぞれのレーンに格納されたラジアンは -π 以上π 未満である必要があります。

§ Swizzle()

template<int V0, int V1, int V2, int V3>
nn::nlib::simd::F128::Swizzle ( f128arg  value)
staticnoexcept

4個の単精度浮動小数点数を並べ替えて新たな128bit値を作成します。どの値になってもよい場合は-1を指定することができます。

テンプレート引数
V0新たな128bit値のレーン0にコピーするレーン番号(0-3)又は-1
V1新たな128bit値のレーン1にコピーするレーン番号(0-3)又は-1
V2新たな128bit値のレーン2にコピーするレーン番号(0-3)又は-1
V3新たな128bit値のレーン3にコピーするレーン番号(0-3)又は-1
引数
[in]value並べ替えられる4個の単精度浮動小数点数
戻り値
新たな128bit値
説明
以下が図解となります。 セレクタV0,V1,V2,V3が任意のレーンを選択し、戻り値のレーンに値を格納します。
dot_inline_dotgraph_21.png

§ Truncate()

nn::nlib::simd::F128::Truncate ( f128arg  value)
staticnoexcept

value の各レーンの単精度浮動小数点数の小数点以下を0の方向に切り捨てた値を計算します。

引数
[in]value4個の単精度浮動小数点数
戻り値
4個の単精度浮動小数点数を返します。
説明
例えば、6.54321は6.0に、-6.54321は-6.0になります。

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