c++ - सी / सी++में लॉग बेस(2)कैसे लिखें




(11)

यदि आप एक अभिन्न परिणाम की तलाश में हैं, तो आप केवल मूल्य में उच्चतम बिट सेट निर्धारित कर सकते हैं और इसकी स्थिति वापस कर सकते हैं।

क्या लॉग (बेस 2) फ़ंक्शन लिखने का कोई तरीका है?

सी भाषा में 2 फ़ंक्शन में निर्मित है - >>

1. log जो आधार ई है।

2. log10 10 आधार 10;

लेकिन मुझे बेस 2 के लॉग फ़ंक्शन की आवश्यकता है। इसकी गणना कैसे करें।


log2(x) = log10(x) / log10(2)

यदि आप इसे तेज़ी से बनाना चाहते हैं, तो आप लुक ट्विडलिंग हैक्स (केवल पूर्णांक लॉग 2) में लुकअप टेबल का उपयोग कर सकते हैं।

uint32_t v; // find the log base 2 of 32-bit v
int r;      // result goes here

static const int MultiplyDeBruijnBitPosition[32] = 
{
  0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
  8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
};

v |= v >> 1; // first round down to one less than a power of 2 
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;

r = MultiplyDeBruijnBitPosition[(uint32_t)(v * 0x07C4ACDDU) >> 27];

इसके अलावा आपको अपने कंपाइलर्स _BitScanReverse विधियों जैसे _BitScanReverse पर एक नज़र _BitScanReverse चाहिए जो तेजी से हो सकता है क्योंकि यह हार्डवेयर में पूरी तरह से गणना की जा सकती है।

संभावित डुप्लिकेट पर एक नज़र डालें सी ++ में एक पूर्णांक लॉग 2 () कैसे करें?


सरल गणित:

लॉग 2 ( एक्स ) = लॉग वाई ( एक्स ) / लॉग वाई (2)

जहां y कुछ भी हो सकता है, जो मानक लॉग फ़ंक्शंस के लिए या तो 10 या ई है


uint16_t log2(uint32_t n) {//but truncated
     if (n==0) throw ...
     uint16_t logValue = -1;
     while (n) {//
         logValue++;
         n >>= 1;
     }
     return logValue;
 }

मूल रूप से के समान।


जैसा कि http://en.wikipedia.org/wiki/Logarithm पर बताया गया है:

logb(x) = logk(x) / logk(b)

जिसका अर्थ है कि:

log2(x) = log10(x) / log10(2)

सी 99 में log2f (साथ ही log2f और log2l फ्लोट और लम्बी डबल के लिए)।


अपने मूल गणित पाठ्यक्रम से परामर्श लें, log n / log 2 । इससे कोई फर्क नहीं पड़ता कि आप इस मामले में log या log चुनते हैं, नए बेस के log द्वारा विभाजित करने से चाल चलती है।


मुझे अधिक सटीकता की आवश्यकता थी कि केवल सबसे महत्वपूर्ण बिट की स्थिति, और माइक्रोकंट्रोलर जिसका उपयोग मैं कर रहा था, कोई गणित पुस्तकालय नहीं था। मैंने पाया कि सकारात्मक पूर्णांक मान तर्कों के लिए 2 ^ एन मानों के बीच एक रैखिक अनुमान का उपयोग करना अच्छी तरह से काम करता है। यहां कोड है:

uint16_t approx_log_base_2_N_times_256(uint16_t n)
{
    uint16_t msb_only = 0x8000;
    uint16_t exp = 15;

    if (n == 0)
        return (-1);
    while ((n & msb_only) == 0) {
        msb_only >>= 1;
        exp--;
    }

    return (((uint16_t)((((uint32_t) (n ^ msb_only)) << 8) / msb_only)) | (exp << 8));
}

मेरे मुख्य कार्यक्रम में, मुझे एक पूर्णांक परिणाम के साथ एन * लॉग 2 (एन) / 2 की गणना करने की आवश्यकता थी:

temp = (((uint32_t) एन) * approx_log_base_2_N_times_256) / 512;

और सभी 16 बिट मान कभी 2% से अधिक नहीं थे


log2(int n) = 31 - __builtin_clz(n)

bitsetउत्तर पर विस्तार :

#include <iostream>
#include <bitset>
#include <string>

using namespace std;
int main() {
  bitset<8> byte(std::string("10010011");

  // Set Bit
  byte.set(3); // 10010111

  // Clear Bit
  byte.reset(2); // 10010101

  // Toggle Bit
  byte.flip(7); // 00010101

  cout << byte << endl;

  return 0;
}




c++ c