अजगर में आधार 2 में प्रवेश करें

Question

मुझे अजगर में आधार दो के लिए लॉग की गणना कैसे करनी चाहिए। उदाहरण के लिए। मेरे पास यह समीकरण है जहां मैं लॉग बेस 2 का उपयोग कर रहा हूं

import math
e = -(t/T)* math.log((t/T)[, 2])

Comments

यदि आपको math.log()कॉल में ", 2" के चारों ओर चौकोर कोष्ठक लेते हैं तो आपके पास क्या काम होना चाहिए । या तुमने कोशिश की?

— मार्टिउ

अच्छी एन्ट्रापी गणना

— मुहम्मद अल्करौरी

math.log (मान, आधार)

— वैलेंटाइन हेनिट्ज

Answer 1

यह जानकर अच्छा लगा

लेकिन यह भी जानते हैं कि math.logएक वैकल्पिक दूसरा तर्क है जो आपको आधार निर्दिष्ट करने की अनुमति देता है:

In [22]: import math

In [23]: math.log?
Type:       builtin_function_or_method
Base Class: <type 'builtin_function_or_method'>
String Form:    <built-in function log>
Namespace:  Interactive
Docstring:
    log(x[, base]) -> the logarithm of x to the given base.
    If the base not specified, returns the natural logarithm (base e) of x.


In [25]: math.log(8,2)
Out[25]: 3.0

Comments

baseतर्क 2.3 संस्करण में जोड़ा गया, btw।

— जो क्रैबग

यह क्या है '?' वाक्य - विन्यास ? मुझे इसके लिए संदर्भ नहीं मिल रहा है।

— wap26

@ wap26: ऊपर, मैं IPython इंटरैक्टिव दुभाषिया का उपयोग कर रहा हूँ । इसकी सुविधाओं में से एक (के साथ पहुँचा ?) गतिशील वस्तु आत्मनिरीक्षण है ।

— unutbu

Answer 2

फ्लोट → फ्लोट math.log2(x)

import math

log2 = math.log(x, 2.0)
log2 = math.log2(x)   # python 3.4 or later

• धन्यवाद @akashchandrakar और @unutbu ।

---

फ्लोट → इंट math.frexp(x)

यदि आप सभी की जरूरत है एक अस्थायी बिंदु संख्या के लॉग आधार 2 का पूर्णांक हिस्सा है, घातांक निकालने बहुत कुशल है:

log2int_slow = int(math.floor(math.log(x, 2.0)))
log2int_fast = math.frexp(x)[1] - 1

• पायथन फ्रीएक्सपी () सी फ़ंक्शन फ्रीक्सपी () को कॉल करता है जो बस पकड़ लेता है और घातांक को घुमाता है ।

• पाइथन फ्रीक्सपी () एक ट्यूपल (मैन्टिसा, घातांक) लौटाता है। तो [1]एक्सपोनेंट पार्ट मिलता है।

• 2 की अभिन्न शक्तियों के लिए प्रतिपादक एक से अधिक आप अपेक्षा कर सकते हैं। उदाहरण के लिए 32 को 0.5x2⁶ के रूप में संग्रहीत किया जाता है। यह - 1ऊपर बताता है। 1/32 के लिए भी काम करता है जिसे 0.5x2 which के रूप में संग्रहीत किया जाता है।

• नकारात्मक अनंत की ओर फर्श, इसलिए log₂31 4 नहीं 5. log 1/ (1/17) -5 है -4 नहीं।

---

int → इंट x.bit_length()

यदि इनपुट और आउटपुट दोनों पूर्णांक हैं, तो यह मूल पूर्णांक विधि बहुत कुशल हो सकती है:

log2int_faster = x.bit_length() - 1

• - 1क्योंकि 2 because को n + 1 बिट्स की आवश्यकता होती है। बहुत बड़े पूर्णांक के लिए काम करता है, उदाहरण के लिए 2**10000।

• नकारात्मक अनंत की ओर फर्श, इसलिए log₂31 4 नहीं 5. log 1/ (1/17) -5 है -4 नहीं।

Comments

दिलचस्प। तो आप 1 को घटा रहे हैं क्योंकि मंटिसा रेंज [0.5, 1.0) में है? अगर मैं ऐसा कर पाता तो मैं इसे कुछ और बढ़ा देता।

— लार्श

बिल्कुल सही @LarsH। 32 को 0.5x2⁶ के रूप में संग्रहीत किया जाता है इसलिए यदि आप log₂32 = 5 चाहते हैं तो आपको 1 घटाना होगा । 1/32 के लिए भी सही है जो 0.5x2 which के रूप में संग्रहीत है।

— बॉब स्टीन

Answer 3

यदि आप अजगर 3.4 या इसके बाद के संस्करण पर हैं, तो इसमें पहले से ही लॉग 2 के लिए अंतर्निहित फ़ंक्शन (x) है

import math
'finds log base2 of x'
answer = math.log2(x)

यदि आप अजगर के पुराने संस्करण पर हैं तो आप इस तरह कर सकते हैं

import math
'finds log base2 of x'
answer = math.log(x)/math.log(2)

Comments

डॉक्स का उल्लेख log2 3.3 में पेश किया गया था। क्या आप इसकी पुष्टि कर सकते हैं कि यह केवल 3.4 में है? docs.python.org/3.3/library/math.html

— ZaydH

Answer 4

सुन्न का उपयोग करना:

In [1]: import numpy as np

In [2]: np.log2?
Type:           function
Base Class:     <type 'function'>
String Form:    <function log2 at 0x03049030>
Namespace:      Interactive
File:           c:\python26\lib\site-packages\numpy\lib\ufunclike.py
Definition:     np.log2(x, y=None)
Docstring:
    Return the base 2 logarithm of the input array, element-wise.

Parameters
----------
x : array_like
  Input array.
y : array_like
  Optional output array with the same shape as `x`.

Returns
-------
y : ndarray
  The logarithm to the base 2 of `x` element-wise.
  NaNs are returned where `x` is negative.

See Also
--------
log, log1p, log10

Examples
--------
>>> np.log2([-1, 2, 4])
array([ NaN,   1.,   2.])

In [3]: np.log2(8)
Out[3]: 3.0

Answer 5

http://en.wikipedia.org/wiki/Binary_logarithm

def lg(x, tol=1e-13):
  res = 0.0

  # Integer part
  while x<1:
    res -= 1
    x *= 2
  while x>=2:
    res += 1
    x /= 2

  # Fractional part
  fp = 1.0
  while fp>=tol:
    fp /= 2
    x *= x
    if x >= 2:
        x /= 2
        res += fp

  return res

Comments

एक एल्गोरिथ्म के लिए अतिरिक्त बिंदु जो कि हमेशा सही पूर्णांक भाग देने के लिए अनुकूलित किया जा सकता है, int (math.log (x, 2)) के विपरीत

— user12861

Answer 6

>>> def log2( x ):
...     return math.log( x ) / math.log( 2 )
... 
>>> log2( 2 )
1.0
>>> log2( 4 )
2.0
>>> log2( 8 )
3.0
>>> log2( 2.4 )
1.2630344058337937
>>> 

Comments

यह math.logफ़ंक्शन के लिए बनाया गया है। देखिए अब्बू का जवाब।

— tgray

Answer 7

इसे इस्तेमाल करे ,

import math
print(math.log(8,2))  # math.log(number,base) 

Answer 8

logbase2 (x) = log (x) / लॉग (2)

Answer 9

अजगर 3 या इसके बाद के संस्करण में, गणित वर्ग में गिरने वाले कार्य होते हैं

import math

math.log2(x)
math.log10(x)
math.log1p(x)

या आप आम तौर पर अपने math.log(x, base)इच्छित किसी भी आधार के लिए उपयोग कर सकते हैं।

Answer 10

log_base_2 (x) = लॉग (x) / लॉग (2)

Answer 11

उस लॉग को मत भूलना [आधार A] x = लॉग [आधार B] x / लॉग [आधार B] A ।

इसलिए यदि आपके पास केवल log(प्राकृतिक लॉग के लिए) और log10(बेस -10 लॉग के लिए) है, तो आप उपयोग कर सकते हैं

myLog2Answer = log10(myInput) / log10(2)