const非整数指数を使用したpow（）の最適化？
私のコードには、実行時間の約10〜20％を占めるpow()を実行しているホットスポットがあります。
pow(x,y)への私の入力は非常に具体的であるため、より高いパフォーマンスで2つのpow()近似（各指数に1つ）をロールバックする方法があるかどうか疑問に思っています。
- 2つの定数指数、2.4と1/2.4があります。
- 指数が2.4の場合、xは（0.090473935、1.0]の範囲になります。
- 指数が1/2.4の場合、xは（0.0031308、1.0]の範囲になります。
- SSE/AVX
floatベクトルを使用しています。プラットフォームの詳細を利用できる場合は、すぐに！
完全精度（floatの場合）アルゴリズムにも関心がありますが、最大エラー率は0.01％前後が理想的です。
私はすでに高速pow()approximation を使用していますが、これらの制約は考慮されていません。より良いことは可能ですか？
IEEE 754ハッキングの流れで、高速で「魔法」の少ない別のソリューションを次に示します。約12クロックサイクルで0.08％のエラーマージンを達成します（Intel Merom CPUでp = 2.4の場合）。
浮動小数点数はもともと対数の近似値として発明されたので、整数値を_log2_の近似値として使用できます。これは、convert-from-integer命令を浮動小数点値に適用して、別の浮動小数点値を取得することで、多少移植性の高い方法で実現できます。
powの計算を完了するには、定数係数を掛けて、整数に変換する命令で対数を変換します。 SSEでは、関連する命令は_cvtdq2ps_および_cvtps2dq_です。
ただし、それほど単純ではありません。 IEEE 754の指数フィールドは符号付きで、バイアス値127はゼロの指数を表します。このバイアスは、対数を乗算する前に削除し、べき乗する前に再度追加する必要があります。さらに、減算によるバイアス調整はゼロでは機能しません。幸いなことに、両方の調整は、事前に定数係数を掛けることによって達成できます。
_x^p
= exp2( p * log2( x ) )
= exp2( p * ( log2( x ) + 127 - 127 ) - 127 + 127 )
= cvtps2dq( p * ( log2( x ) + 127 - 127 - 127 / p ) )
= cvtps2dq( p * ( log2( x ) + 127 - log2( exp2( 127 - 127 / p ) ) )
= cvtps2dq( p * ( log2( x * exp2( 127 / p - 127 ) ) + 127 ) )
= cvtps2dq( p * ( cvtdq2ps( x * exp2( 127 / p - 127 ) ) ) )
_exp2( 127 / p - 127 )は定数係数です。この関数はかなり特殊化されています。定数係数は指数の逆数で指数関数的に増加し、オーバーフローするため、小さな小数指数では機能しません。負の指数では機能しません。仮数ビットは乗算によって指数ビットと混合されるため、指数が大きいとエラーが大きくなります。
しかし、それは長い4つの高速命令です。事前乗算、「整数」から（対数に）変換、電力乗算、「整数」（対数から）に変換。このSSEの実装では、変換が非常に高速です。追加の定数係数を最初の乗算に詰め込むこともできます。
_template< unsigned expnum, unsigned expden, unsigned coeffnum, unsigned coeffden >
__m128 fastpow( __m128 arg ) {
__m128 ret = arg;
// std::printf( "arg = %,vg\n", ret );
// Apply a constant pre-correction factor.
ret = _mm_mul_ps( ret, _mm_set1_ps( exp2( 127. * expden / expnum - 127. )
* pow( 1. * coeffnum / coeffden, 1. * expden / expnum ) ) );
// std::printf( "scaled = %,vg\n", ret );
// Reinterpret arg as integer to obtain logarithm.
asm ( "cvtdq2ps %1, %0" : "=x" (ret) : "x" (ret) );
// std::printf( "log = %,vg\n", ret );
// Multiply logarithm by power.
ret = _mm_mul_ps( ret, _mm_set1_ps( 1. * expnum / expden ) );
// std::printf( "powered = %,vg\n", ret );
// Convert back to "integer" to exponentiate.
asm ( "cvtps2dq %1, %0" : "=x" (ret) : "x" (ret) );
// std::printf( "result = %,vg\n", ret );
return ret;
}
_指数= 2.4のいくつかの試行は、これが常に約5％過大評価していることを示しています。 （ルーチンは常に過大評価されることが保証されています。）単純に0.95を乗算することもできますが、さらにいくつかの命令で約10進数の精度が得られ、グラフィックスにはこれで十分です。
重要なのは、過大評価と過小評価を一致させ、平均を取ることです。
- X ^ 0.8の計算：4つの命令、エラー〜+ 3％。
- X ^ -0.4を計算：1つの
rsqrtps。 （これは非常に正確ですが、ゼロで機能する能力を犠牲にします。） - X ^ 0.4を計算：1つの
mulps。 - X ^ -0.2を計算：1つの
rsqrtps。 - X ^ 2を計算：1つの
mulps。 - X ^ 3を計算：1つの
mulps。 - x ^ 2.4 = x ^ 2 * x ^ 0.4：
mulps1つ。これは過大評価です。 - x ^ 2.4 = x ^ 3 * x ^ -0.4 * x ^ -0.2：2つの
mulps。これは過小評価です。 - 上記の平均：
addps1つ、mulps1つ。
命令の集計：14、レイテンシ= 5の2つの変換とスループット= 4の2つの逆平方根推定。
適切に平均を取るために、予想される誤差で推定に重みを付けます。過小評価により、エラーが0.6対0.4の累乗に引き上げられるため、エラーは1.5倍になると予想されます。重み付けは命令を追加しません。プレファクターで実行できます。係数aを呼び出す：a ^ 0.5 = 1.5 a ^ -0.75、およびa = 1.38316186。
最終的な誤差は、約.015％、つまり最初のfastpow結果より2桁優れています。ランタイムは、volatileソース変数とデスティネーション変数を使用したビジーループの約12サイクルです…反復と重複していますが、実際の使用では命令レベルの並列処理も行われます。 SIMDを考えると、これは3サイクルあたり1つのスカラー結果のスループットです。
_int main() {
__m128 const x0 = _mm_set_ps( 0.01, 1, 5, 1234.567 );
std::printf( "Input: %,vg\n", x0 );
// Approx 5% accuracy from one call. Always an overestimate.
__m128 x1 = fastpow< 24, 10, 1, 1 >( x0 );
std::printf( "Direct x^2.4: %,vg\n", x1 );
// Lower exponents provide lower initial error, but too low causes overflow.
__m128 xf = fastpow< 8, 10, int( 1.38316186 * 1e9 ), int( 1e9 ) >( x0 );
std::printf( "1.38 x^0.8: %,vg\n", xf );
// Imprecise 4-cycle sqrt is still far better than fastpow, good enough.
__m128 xfm4 = _mm_rsqrt_ps( xf );
__m128 xf4 = _mm_mul_ps( xf, xfm4 );
// Precisely calculate x^2 and x^3
__m128 x2 = _mm_mul_ps( x0, x0 );
__m128 x3 = _mm_mul_ps( x2, x0 );
// Overestimate of x^2 * x^0.4
x2 = _mm_mul_ps( x2, xf4 );
// Get x^-0.2 from x^0.4. Combine with x^-0.4 into x^-0.6 and x^2.4.
__m128 xfm2 = _mm_rsqrt_ps( xf4 );
x3 = _mm_mul_ps( x3, xfm4 );
x3 = _mm_mul_ps( x3, xfm2 );
std::printf( "x^2 * x^0.4: %,vg\n", x2 );
std::printf( "x^3 / x^0.6: %,vg\n", x3 );
x2 = _mm_mul_ps( _mm_add_ps( x2, x3 ), _mm_set1_ps( 1/ 1.960131704207789 ) );
// Final accuracy about 0.015%, 200x better than x^0.8 calculation.
std::printf( "average = %,vg\n", x2 );
}
_うーん...申し訳ありませんが、これより早く投稿することができませんでした。そして、それをx ^ 1/2.4に拡張することは、演習として残します; v）.
統計で更新
小さなテストハーネスと2つのxを実装しました（5/12） 上記に該当する場合。
_#include <cstdio>
#include <xmmintrin.h>
#include <cmath>
#include <cfloat>
#include <algorithm>
using namespace std;
template< unsigned expnum, unsigned expden, unsigned coeffnum, unsigned coeffden >
__m128 fastpow( __m128 arg ) {
__m128 ret = arg;
// std::printf( "arg = %,vg\n", ret );
// Apply a constant pre-correction factor.
ret = _mm_mul_ps( ret, _mm_set1_ps( exp2( 127. * expden / expnum - 127. )
* pow( 1. * coeffnum / coeffden, 1. * expden / expnum ) ) );
// std::printf( "scaled = %,vg\n", ret );
// Reinterpret arg as integer to obtain logarithm.
asm ( "cvtdq2ps %1, %0" : "=x" (ret) : "x" (ret) );
// std::printf( "log = %,vg\n", ret );
// Multiply logarithm by power.
ret = _mm_mul_ps( ret, _mm_set1_ps( 1. * expnum / expden ) );
// std::printf( "powered = %,vg\n", ret );
// Convert back to "integer" to exponentiate.
asm ( "cvtps2dq %1, %0" : "=x" (ret) : "x" (ret) );
// std::printf( "result = %,vg\n", ret );
return ret;
}
__m128 pow125_4( __m128 arg ) {
// Lower exponents provide lower initial error, but too low causes overflow.
__m128 xf = fastpow< 4, 5, int( 1.38316186 * 1e9 ), int( 1e9 ) >( arg );
// Imprecise 4-cycle sqrt is still far better than fastpow, good enough.
__m128 xfm4 = _mm_rsqrt_ps( xf );
__m128 xf4 = _mm_mul_ps( xf, xfm4 );
// Precisely calculate x^2 and x^3
__m128 x2 = _mm_mul_ps( arg, arg );
__m128 x3 = _mm_mul_ps( x2, arg );
// Overestimate of x^2 * x^0.4
x2 = _mm_mul_ps( x2, xf4 );
// Get x^-0.2 from x^0.4, and square it for x^-0.4. Combine into x^-0.6.
__m128 xfm2 = _mm_rsqrt_ps( xf4 );
x3 = _mm_mul_ps( x3, xfm4 );
x3 = _mm_mul_ps( x3, xfm2 );
return _mm_mul_ps( _mm_add_ps( x2, x3 ), _mm_set1_ps( 1/ 1.960131704207789 * 0.9999 ) );
}
__m128 pow512_2( __m128 arg ) {
// 5/12 is too small, so compute the sqrt of 10/12 instead.
__m128 x = fastpow< 5, 6, int( 0.992245 * 1e9 ), int( 1e9 ) >( arg );
return _mm_mul_ps( _mm_rsqrt_ps( x ), x );
}
__m128 pow512_4( __m128 arg ) {
// 5/12 is too small, so compute the 4th root of 20/12 instead.
// 20/12 = 5/3 = 1 + 2/3 = 2 - 1/3. 2/3 is a suitable argument for fastpow.
// weighting coefficient: a^-1/2 = 2 a; a = 2^-2/3
__m128 xf = fastpow< 2, 3, int( 0.629960524947437 * 1e9 ), int( 1e9 ) >( arg );
__m128 xover = _mm_mul_ps( arg, xf );
__m128 xfm1 = _mm_rsqrt_ps( xf );
__m128 x2 = _mm_mul_ps( arg, arg );
__m128 xunder = _mm_mul_ps( x2, xfm1 );
// sqrt2 * over + 2 * sqrt2 * under
__m128 xavg = _mm_mul_ps( _mm_set1_ps( 1/( 3 * 0.629960524947437 ) * 0.999852 ),
_mm_add_ps( xover, xunder ) );
xavg = _mm_mul_ps( xavg, _mm_rsqrt_ps( xavg ) );
xavg = _mm_mul_ps( xavg, _mm_rsqrt_ps( xavg ) );
return xavg;
}
__m128 mm_succ_ps( __m128 arg ) {
return (__m128) _mm_add_epi32( (__m128i) arg, _mm_set1_epi32( 4 ) );
}
void test_pow( double p, __m128 (*f)( __m128 ) ) {
__m128 arg;
for ( arg = _mm_set1_ps( FLT_MIN / FLT_EPSILON );
! isfinite( _mm_cvtss_f32( f( arg ) ) );
arg = mm_succ_ps( arg ) ) ;
for ( ; _mm_cvtss_f32( f( arg ) ) == 0;
arg = mm_succ_ps( arg ) ) ;
std::printf( "Domain from %g\n", _mm_cvtss_f32( arg ) );
int n;
int const bucket_size = 1 << 25;
do {
float max_error = 0;
double total_error = 0, cum_error = 0;
for ( n = 0; n != bucket_size; ++ n ) {
float result = _mm_cvtss_f32( f( arg ) );
if ( ! isfinite( result ) ) break;
float actual = ::powf( _mm_cvtss_f32( arg ), p );
float error = ( result - actual ) / actual;
cum_error += error;
error = std::abs( error );
max_error = std::max( max_error, error );
total_error += error;
arg = mm_succ_ps( arg );
}
std::printf( "error max = %8g\t" "avg = %8g\t" "|avg| = %8g\t" "to %8g\n",
max_error, cum_error / n, total_error / n, _mm_cvtss_f32( arg ) );
} while ( n == bucket_size );
}
int main() {
std::printf( "4 insn x^12/5:\n" );
test_pow( 12./5, & fastpow< 12, 5, 1059, 1000 > );
std::printf( "14 insn x^12/5:\n" );
test_pow( 12./5, & pow125_4 );
std::printf( "6 insn x^5/12:\n" );
test_pow( 5./12, & pow512_2 );
std::printf( "14 insn x^5/12:\n" );
test_pow( 5./12, & pow512_4 );
}
_出力：
_4 insn x^12/5:
Domain from 1.36909e-23
error max = inf avg = inf |avg| = inf to 8.97249e-19
error max = 2267.14 avg = 139.175 |avg| = 139.193 to 5.88021e-14
error max = 0.123606 avg = -0.000102963 |avg| = 0.0371122 to 3.85365e-09
error max = 0.123607 avg = -0.000108978 |avg| = 0.0368548 to 0.000252553
error max = 0.12361 avg = 7.28909e-05 |avg| = 0.037507 to 16.5513
error max = 0.123612 avg = -0.000258619 |avg| = 0.0365618 to 1.08471e+06
error max = 0.123611 avg = 8.70966e-05 |avg| = 0.0374369 to 7.10874e+10
error max = 0.12361 avg = -0.000103047 |avg| = 0.0371122 to 4.65878e+15
error max = 0.123609 avg = nan |avg| = nan to 1.16469e+16
14 insn x^12/5:
Domain from 1.42795e-19
error max = inf avg = nan |avg| = nan to 9.35823e-15
error max = 0.000936462 avg = 2.0202e-05 |avg| = 0.000133764 to 6.13301e-10
error max = 0.000792752 avg = 1.45717e-05 |avg| = 0.000129936 to 4.01933e-05
error max = 0.000791785 avg = 7.0132e-06 |avg| = 0.000129923 to 2.63411
error max = 0.000787589 avg = 1.20745e-05 |avg| = 0.000129347 to 172629
error max = 0.000786553 avg = 1.62351e-05 |avg| = 0.000132397 to 1.13134e+10
error max = 0.000785586 avg = 8.25205e-06 |avg| = 0.00013037 to 6.98147e+12
6 insn x^5/12:
Domain from 9.86076e-32
error max = 0.0284339 avg = 0.000441158 |avg| = 0.00967327 to 6.46235e-27
error max = 0.0284342 avg = -5.79938e-06 |avg| = 0.00897913 to 4.23516e-22
error max = 0.0284341 avg = -0.000140706 |avg| = 0.00897084 to 2.77556e-17
error max = 0.028434 avg = 0.000440504 |avg| = 0.00967325 to 1.81899e-12
error max = 0.0284339 avg = -6.11153e-06 |avg| = 0.00897915 to 1.19209e-07
error max = 0.0284298 avg = -0.000140597 |avg| = 0.00897084 to 0.0078125
error max = 0.0284371 avg = 0.000439748 |avg| = 0.00967319 to 512
error max = 0.028437 avg = -7.74294e-06 |avg| = 0.00897924 to 3.35544e+07
error max = 0.0284369 avg = -0.000142036 |avg| = 0.00897089 to 2.19902e+12
error max = 0.0284368 avg = 0.000439183 |avg| = 0.0096732 to 1.44115e+17
error max = 0.0284367 avg = -7.41244e-06 |avg| = 0.00897923 to 9.44473e+21
error max = 0.0284366 avg = -0.000141706 |avg| = 0.00897088 to 6.1897e+26
error max = 0.485129 avg = -0.0401671 |avg| = 0.048422 to 4.05648e+31
error max = 0.994932 avg = -0.891494 |avg| = 0.891494 to 2.65846e+36
error max = 0.999329 avg = nan |avg| = nan to -0
14 insn x^5/12:
Domain from 2.64698e-23
error max = 0.13556 avg = 0.00125936 |avg| = 0.00354677 to 1.73472e-18
error max = 0.000564988 avg = 2.51458e-06 |avg| = 0.000113709 to 1.13687e-13
error max = 0.000565065 avg = -1.49258e-06 |avg| = 0.000112553 to 7.45058e-09
error max = 0.000565143 avg = 1.5293e-06 |avg| = 0.000112864 to 0.000488281
error max = 0.000565298 avg = 2.76457e-06 |avg| = 0.000113713 to 32
error max = 0.000565453 avg = -1.61276e-06 |avg| = 0.000112561 to 2.09715e+06
error max = 0.000565531 avg = 1.42628e-06 |avg| = 0.000112866 to 1.37439e+11
error max = 0.000565686 avg = 2.71505e-06 |avg| = 0.000113715 to 9.0072e+15
error max = 0.000565763 avg = -1.56586e-06 |avg| = 0.000112415 to 1.84467e+19
_より正確な5/12の精度はrsqrt操作によって制限されているのではないかと思います。
Ian Stephensonは このコード を書いており、pow()よりも優れていると主張しています。彼 は次のように考え を説明します。
Powは基本的にログを使用して実装されます：
pow(a,b)=x(logx(a)*b)。したがって、高速な対数と高速な指数が必要です。xが何であるかは問題ではないため、2を使用します。トリックは、浮動小数点数が既に対数形式の形式になっていることです。a=M*2E両側のログを取ると、次のようになります。
log2(a)=log2(M)+Eまたはもっと簡単に：
log2(a)~=Eつまり、数値の浮動小数点表現を取り、指数を抽出すると、対数として出発点として適切なものが得られます。ビットパターンをマッサージしてこれを行うと、仮数はエラーを適切に近似し、かなりうまく機能することがわかります。
これは単純な照明の計算には十分ですが、より良いものが必要な場合は、仮数を抽出し、それを使用してかなり正確な2次補正係数を計算できます。
まず、フロートを使用しても、最近のほとんどのマシンではそれほど多くは購入されません。実際、ダブルスの方が速い場合があります。あなたのパワー1.0/2.4は5/12または1/3 *（1 + 1/4）です。これはcbrt（1回）とsqrt（2回！）を呼び出していますが、それでもpow（）を使用する場合より2倍高速です。 （最適化：-O3、コンパイラ：i686-Apple-darwin10-g ++-4.2.1）。
#include <math.h> // cmath does not provide cbrt; C99 does.
double xpow512 (double x) {
double cbrtx = cbrt(x);
return cbrtx*sqrt(sqrt(cbrtx));
}
これはあなたの質問に答えないかもしれません。
2.4fおよび1/2.4fは、sRGBと線形RGBカラースペース間の変換に使用されるパワーとまったく同じなので、非常に疑わしくなります。つまり、具体的にthat、を最適化しようとしているのかもしれません。わからない。これがあなたの質問に答えないかもしれない理由です。
この場合は、ルックアップテーブルを使用してみてください。何かのようなもの：
__attribute__((aligned(64))
static const unsigned short SRGB_TO_LINEAR[256] = { ... };
__attribute__((aligned(64))
static const unsigned short LINEAR_TO_SRGB[256] = { ... };
void apply_lut(const unsigned short lut[256], unsigned char *src, ...
16ビットデータを使用している場合は、必要に応じて変更します。とにかくテーブルを16ビットにして、8ビットデータを処理するときに必要に応じて結果をディザリングできるようにします。データが最初は浮動小数点の場合、これは明らかにうまく機能しません-しかし、sRGBデータを浮動小数点に格納することは実際には意味がないため、最初に16ビット/ 8ビットに変換することもできます。リニアからsRGBへの変換を行います。
（sRGBが浮動小数点として意味をなさない理由は、HDRは線形であるべきであり、sRGBはディスクへの保存または画面への表示にのみ便利ですが、操作には便利ではありません。）
Binomial series は定数指数を考慮しますが、すべての入力を範囲[1,2）に正規化できる場合にのみ使用できます。 （（1 + x）^ aを計算することに注意してください）。必要な精度を得るために必要な用語の数を決定するには、いくつかの分析を行う必要があります。
私はあなたに質問します本当に質問したかった、それはどのように高速sRGB <->線形RGB変換を行うかです。これを正確かつ効率的に行うには、多項式近似を使用できます。以下の多項式近似はsollyaで生成されており、最悪の場合の相対誤差は0.0144％です。
inline double poly7(double x, double a, double b, double c, double d,
double e, double f, double g, double h) {
double ab, cd, ef, gh, abcd, efgh, x2, x4;
x2 = x*x; x4 = x2*x2;
ab = a*x + b; cd = c*x + d;
ef = e*x + f; gh = g*x + h;
abcd = ab*x2 + cd; efgh = ef*x2 + gh;
return abcd*x4 + efgh;
}
inline double srgb_to_linear(double x) {
if (x <= 0.04045) return x / 12.92;
// Polynomial approximation of ((x+0.055)/1.055)^2.4.
return poly7(x, 0.15237971711927983387,
-0.57235993072870072762,
0.92097986411523535821,
-0.90208229831912012386,
0.88348956209696805075,
0.48110797889132134175,
0.03563925285274562038,
0.00084585397227064120);
}
inline double linear_to_srgb(double x) {
if (x <= 0.0031308) return x * 12.92;
// Piecewise polynomial approximation (divided by x^3)
// of 1.055 * x^(1/2.4) - 0.055.
if (x <= 0.0523) return poly7(x, -6681.49576364495442248881,
1224.97114922729451791383,
-100.23413743425112443219,
6.60361150127077944916,
0.06114808961060447245,
-0.00022244138470139442,
0.00000041231840827815,
-0.00000000035133685895) / (x*x*x);
return poly7(x, -0.18730034115395793881,
0.64677431008037400417,
-0.99032868647877825286,
1.20939072663263713636,
0.33433459165487383613,
-0.01345095746411287783,
0.00044351684288719036,
-0.00000664263587520855) / (x*x*x);
}
そして、多項式を生成するために使用されるソリア入力：
suppressmessage(174);
f = ((x+0.055)/1.055)^2.4;
p0 = fpminimax(f, 7, [|D...|], [0.04045;1], relative);
p = fpminimax(f/(p0(1)+1e-18), 7, [|D...|], [0.04045;1], relative);
print("relative:", dirtyinfnorm((f-p)/f, [s;1]));
print("absolute:", dirtyinfnorm((f-p), [s;1]));
print(canonical(p));
s = 0.0523;
z = 3;
f = 1.055 * x^(1/2.4) - 0.055;
p = fpminimax(1.055 * (x^(z+1/2.4) - 0.055*x^z/1.055), 7, [|D...|], [0.0031308;s], relative)/x^z;
print("relative:", dirtyinfnorm((f-p)/f, [0.0031308;s]));
print("absolute:", dirtyinfnorm((f-p), [0.0031308;s]));
print(canonical(p));
p = fpminimax(1.055 * (x^(z+1/2.4) - 0.055*x^z/1.055), 7, [|D...|], [s;1], relative)/x^z;
print("relative:", dirtyinfnorm((f-p)/f, [s;1]));
print("absolute:", dirtyinfnorm((f-p), [s;1]));
print(canonical(p));
以下は、任意の高速計算方法で使用できるアイデアです。処理が速くなるかどうかは、データの到着方法によって異なります。 xとpow(x, n)がわかっている場合は、累乗の変化率を使用して、単一の乗算で小さなdeltaのpow(x + delta, n)の合理的な近似を計算できます。 （多かれ少なかれ）追加します。パワー関数に入力する連続する値が十分に近い場合、これにより、複数の関数呼び出しでの正確な計算の全コストが償却されます。導関数を取得するために追加のpow計算は必要ないことに注意してください。これを拡張して2次導関数を使用することで、2次関数を使用できます。これにより、使用できるdeltaが増加し、同じ精度が得られます。
2.4の指数の場合、すべての2.4値とlirpのルックアップテーブルを作成するか、テーブルが十分に正確でなかった場合（基本的には巨大なログテーブル）に、より高い次数の関数を入力値に入力することができます。
または、値の2乗*値を2/5にすると、関数の前半から最初の2乗値を取得し、次に5乗根を求めることができます。 5番目のルートについては、ニュートンまたは他の高速近似を行うことができますが、正直に言うと、この時点に到達したら、exp関数とlog関数を適切な省略された系列関数で実行する方が良いでしょう。
したがって、伝統的にpowf(x, p) = x^pはxをx=2^(log2(x))と書き直してpowf(x,p) = 2^(p*log2(x))にすることで解決され、問題が2つの近似に変換されますexp2()＆log2()。これには、より大きな累乗pで作業できるという利点がありますが、欠点は、これが一定の累乗pおよび指定された入力範囲0 ≤ x ≤ 1に対する最適なソリューションではないことです。
ベキp > 1の場合、答えは範囲0 ≤ x ≤ 1のささいなミニマックス多項式です。これは、以下に示すようにp = 12/5 = 2.4の場合です。
float pow12_5(float x){
float mp;
// Minimax horner polynomials for x^(5/12), Note: choose the accurarcy required then implement with fma() [Fused Multiply Accumulates]
// mp = 0x4.a84a38p-12 + x * (-0xd.e5648p-8 + x * (0xa.d82fep-4 + x * 0x6.062668p-4)); // 1.13705697e-3
mp = 0x1.117542p-12 + x * (-0x5.91e6ap-8 + x * (0x8.0f50ep-4 + x * (0xa.aa231p-4 + x * (-0x2.62787p-4)))); // 2.6079002e-4
// mp = 0x5.a522ap-16 + x * (-0x2.d997fcp-8 + x * (0x6.8f6d1p-4 + x * (0xf.21285p-4 + x * (-0x7.b5b248p-4 + x * 0x2.32b668p-4)))); // 8.61377e-5
// mp = 0x2.4f5538p-16 + x * (-0x1.abcdecp-8 + x * (0x5.97464p-4 + x * (0x1.399edap0 + x * (-0x1.0d363ap0 + x * (0xa.a54a3p-4 + x * (-0x2.e8a77cp-4)))))); // 3.524655e-5
return(mp);
}
ただし、p < 1の場合、範囲0 ≤ x ≤ 1のミニマックス近似は、目的の精度に適切に収束しません。 1つのオプション[実際にはありません]は、問題y=x^p=x^(p+m)/x^mを書き直すことです。ここで、m=1,2,3は正の整数であり、新しいべき乗近似p > 1を作成しますが、これにより、本質的に遅い除算が導入されます。
ただし、入力xを浮動小数点の指数と仮数の形式として分解する別のオプションがあります。
x = mx* 2^(ex) where 1 ≤ mx < 2
y = x^(5/12) = mx^(5/12) * 2^((5/12)*ex), let ey = floor(5*ex/12), k = (5*ex) % 12
= mx^(5/12) * 2^(k/12) * 2^(ey)
1 ≤ mx < 2でのmx^(5/12)のミニマックス近似は、除算なしで以前よりもはるかに速く収束しますが、2^(k/12)には12ポイントのLUTが必要です。コードは以下のとおりです。
float powk_12LUT[] = {0x1.0p0, 0x1.0f38fap0, 0x1.1f59acp0, 0x1.306fep0, 0x1.428a3p0, 0x1.55b81p0, 0x1.6a09e6p0, 0x1.7f910ep0, 0x1.965feap0, 0x1.ae89fap0, 0x1.c823ep0, 0x1.e3437ep0};
float pow5_12(float x){
union{float f; uint32_t u;} v, e2;
float poff, m, e, ei;
int xe;
v.f = x;
xe = ((v.u >> 23) - 127);
if(xe < -127) return(0.0f);
// Calculate remainder k in 2^(k/12) to find LUT
e = xe * (5.0f/12.0f);
ei = floorf(e);
poff = powk_12LUT[(int)(12.0f * (e - ei))];
e2.u = ((int)ei + 127) << 23; // Calculate the exponent
v.u = (v.u & ~(0xFFuL << 23)) | (0x7FuL << 23); // Normalize exponent to zero
// Approximate mx^(5/12) on [1,2), with appropriate degree minimax
// m = 0x8.87592p-4 + v.f * (0x8.8f056p-4 + v.f * (-0x1.134044p-4)); // 7.6125e-4
// m = 0x7.582138p-4 + v.f * (0xb.1666bp-4 + v.f * (-0x2.d21954p-4 + v.f * 0x6.3ea0cp-8)); // 8.4522726e-5
m = 0x6.9465cp-4 + v.f * (0xd.43015p-4 + v.f * (-0x5.17b2a8p-4 + v.f * (0x1.6cb1f8p-4 + v.f * (-0x2.c5b76p-8)))); // 1.04091259e-5
// m = 0x6.08242p-4 + v.f * (0xf.352bdp-4 + v.f * (-0x7.d0c1bp-4 + v.f * (0x3.4d153p-4 + v.f * (-0xc.f7a42p-8 + v.f * 0x1.5d840cp-8)))); // 1.367401e-6
return(m * poff * e2.f);
}