फास्ट लॉग 2 (फ्लोट एक्स) कार्यान्वयन सी ++

Question

मुझे सी ++ में लॉग 2 (फ्लोट एक्स) फ़ंक्शन का एक बहुत तेज़ कार्यान्वयन चाहिए।

मैं एक बहुत ही दिलचस्प कार्यान्वयन पाया (और बहुत तेज!)

#include <intrin.h> 

inline unsigned long log2(int x) 
{ 
    unsigned long y; 
    _BitScanReverse(&y, x); 
    return y; 
} 

लेकिन इस समारोह केवल इनपुट में पूर्णांक मूल्यों के लिए अच्छा है।

प्रश्न: वहाँ किसी भी तरह से डबल प्रकार इनपुट चर को यह समारोह कन्वर्ट करने के लिए है?

युपीडी:

मैं इस कार्यान्वयन पाया:

typedef unsigned long uint32; 
typedef long int32; 
static inline int32 ilog2(float x) 
{ 
    uint32 ix = (uint32&)x; 
    uint32 exp = (ix >> 23) & 0xFF; 
    int32 log2 = int32(exp) - 127; 

    return log2; 
} 

जो पिछले उदाहरण की तुलना में बहुत तेजी से होता है, लेकिन उत्पादन अहस्ताक्षरित प्रकार है।

क्या यह फ़ंक्शन डबल प्रकार वापस करना संभव है?

अग्रिम धन्यवाद!

Answer 1

यह फ़ंक्शन सी ++ नहीं है, यह एमएसवीसी ++ विशिष्ट है। इसके अलावा, मुझे बहुत संदेह है कि इस तरह के किसी भी अंतर्निहित मौजूद हैं। और यदि उन्होंने किया, तो मानक फ़ंक्शन को बस इसका उपयोग करने के लिए कॉन्फ़िगर किया जाएगा। तो बस मानक-प्रदान की गई लाइब्रेरी को कॉल करें।

Answer 2

नहीं, लेकिन अगर आपको केवल परिणाम के पूर्णांक हिस्से की आवश्यकता है और पोर्टेबिलिटी पर जोर नहीं देते हैं, तो यहां तक ​​कि तेज भी है। क्योंकि आपको फ्लोट के एक्सपोनेंट हिस्से को निकालने की ज़रूरत है!

Answer 3

यदि आपको केवल लॉगरिदम के पूर्णांक भाग की आवश्यकता है, तो आप इसे सीधे फ़्लोटिंग पॉइंट नंबर से निकाल सकते हैं।

portably:

#include <cmath> 

int log2_fast(double d) { 
    int result; 
    std::frexp(d, &result); 
    return result-1; 
} 

संभवतः तेजी से है, लेकिन अनिर्दिष्ट और अपरिभाषित व्यवहार पर निर्भर:

int log2_evil(double d) { 
    return ((reinterpret_cast<unsigned long long&>(d) >> 52) & 0x7ff) - 1023; 
} 

Answer 4

आप this implementation में एक बार देख ले सकते हैं, लेकिन:

• यह नहीं हो सकता कुछ प्लेटफॉर्म पर काम
• शायद OT हरा std :: लॉग इन करें

Answer 5

Fast log() function (5 तेजी से लगभग ×)

आप के लिए ब्याज की हो सकता है कि

। कोड यहां काम करता है; हालांकि यह असीम सटीक नहीं है। के रूप में कोड वेब पेज (> हटा दिया गया है) पर टूट गया है मैं इसे यहाँ पोस्ट करेंगे:

inline float fast_log2 (float val) 
{ 
    int * const exp_ptr = reinterpret_cast <int *> (&val); 
    int   x = *exp_ptr; 
    const int  log_2 = ((x >> 23) & 255) - 128; 
    x &= ~(255 << 23); 
    x += 127 << 23; 
    *exp_ptr = x; 

    val = ((-1.0f/3) * val + 2) * val - 2.0f/3; // (1) 

    return (val + log_2); 
} 

inline float fast_log (const float &val) 
{ 
    return (fast_log2 (val) * 0.69314718f); 
} 

Answer 6

MSVC + जीसीसी संगत संस्करण है कि XX.XXXXXXX + -0,0054545

float mFast_Log2(float val) { 
    union { float val; int32_t x; } u = { val }; 
    register float log_2 = (float)(((u.x >> 23) & 255) - 128);    
    u.x &= ~(255 << 23); 
    u.x += 127 << 23; 
    log_2 += ((-0.3358287811f) * u.val + 2.0f) * u.val -0.65871759316667f; 
    return (log_2); 
} 

Answer 7

देना सी ++ 11 std::log2<cmath> में जोड़ा गया।

Answer 8

यह पहला जवाब है जो आईईईई कार्यान्वयन पर भरोसा नहीं करता है, हालांकि मुझे लगता है कि यह आईईईई मशीनों पर केवल तेज़ है जहां frexp() मूल रूप से एक लागतहीन कार्य है।

frexp रिटर्न को छोड़ने के बजाय, कोई इसे रैखिक रूप से इंटरपोलेट करने के लिए उपयोग कर सकता है। यदि यह सकारात्मक है तो अंश मान 0.5 और 1.0 के बीच है, इसलिए हम 0.0 और 1.0 के बीच फैलाते हैं और इसे एक्सपोनेंट में जोड़ते हैं।

प्रैक्टिस में, ऐसा लगता है कि यह तेजी से मूल्यांकन 5-10% के लिए अच्छा है, हमेशा एक मूल्य कम लौटा रहा है। मुझे यकीन है कि 2* स्केलिंग कारक को ट्वीव करके इसे बेहतर बनाया जा सकता है।

#include <cmath> 

double log2_fast(double d) { 
    int exponent; 
    double fraction = std::frexp(d, &exponent); 
    return (result-1) + 2* (fraction - 0.5); 
} 

आप सत्यापित कर सकते हैं कि इस इस के साथ उचित तेजी से अनुमान होता है:

#include <cmath> 

int main() 
{ 
    for(double x=0.001;x<1000;x+=0.1) 
    { 
     std::cout << x << " " << std::log2(x) << " " << log2_fast(x) << "\n"; 
    } 
}