math.log

All Samples(4895) | Call(4340) | Derive(0) | Import(555)

log(x[, base])

Return the logarithm of x to the given base.
If the base not specified, returns the natural logarithm (base e) of x.

src/p/y/pycppad-HEAD/example/std_math.py pycppad(Download)

  assert abs( cos(a_x)    - math.cos(x) )   < delta
  assert abs( cosh(a_x)   - math.cosh(x) )  < delta
  assert abs( exp(a_x)    - math.exp(x) )   < delta
  assert abs( log(a_x)    - math.log(x) )   < delta
  assert abs( log10(a_x)  - math.log10(x) ) < delta
  assert abs( sin(a_x)    - math.sin(x) )   < delta
  assert abs( sinh(a_x)   - math.sinh(x) )  < delta

  assert abs( cos(a2x)    - math.cos(x) )   < delta
  assert abs( cosh(a2x)   - math.cosh(x) )  < delta
  assert abs( exp(a2x)    - math.exp(x) )   < delta
  assert abs( log(a2x)    - math.log(x) )   < delta
  assert abs( log10(a2x)  - math.log10(x) ) < delta
  assert abs( sin(a2x)    - math.sin(x) )   < delta
  assert abs( sinh(a2x)   - math.sinh(x) )  < delta

src/l/a/LabJackPython-HEAD/Examples/u6Noise.py LabJackPython(Download)

    p2pn = max(readings) - min(readings)
 
    # Noise-Free resolution in bits follows the formula:
    nfrbits = 24 - math.log(p2pn, 2)
 
    # Noise-Free Resolution (uV) = 
    #                            <range> / 2 ^ < Noise-Free resolution (bits) >

    rms = math.sqrt(rms)
 
    # Effective Resolution is uses a similar formulas as Noise-Free.
    erbits = 24 - math.log(rms, 2)
 
    erres = ( ranges[voltageRange] / (2**erbits) ) * (10 ** 6)

src/t/w/twitstream-HEAD/examples/stats.py twitstream(Download)

def log_spacing(integer):
    m = math.sqrt(10)
    if integer == 0:
        return 0
    return m ** math.floor(math.log(integer, m))
 
def linear_chunk(interval):

src/p/y/python-ply-HEAD/example/BASIC/basinterp.py python-ply(Download)

             'ATN' : lambda z: math.atan(self.eval(z)),
             'EXP' : lambda z: math.exp(self.eval(z)),
             'ABS' : lambda z: abs(self.eval(z)),
             'LOG' : lambda z: math.log(self.eval(z)),
             'SQR' : lambda z: math.sqrt(self.eval(z)),
             'INT' : lambda z: int(self.eval(z)),
             'RND' : lambda z: random.random()

src/c/b/cbflib-HEAD/trunk/CBFlib_bleeding_edge/ply-3.2/example/BASIC/basinterp.py cbflib(Download)

             'ATN' : lambda z: math.atan(self.eval(z)),
             'EXP' : lambda z: math.exp(self.eval(z)),
             'ABS' : lambda z: abs(self.eval(z)),
             'LOG' : lambda z: math.log(self.eval(z)),
             'SQR' : lambda z: math.sqrt(self.eval(z)),
             'INT' : lambda z: int(self.eval(z)),
             'RND' : lambda z: random.random()

src/c/b/cbflib-HEAD/CBFlib_bleeding_edge/ply-3.2/example/BASIC/basinterp.py cbflib(Download)

             'ATN' : lambda z: math.atan(self.eval(z)),
             'EXP' : lambda z: math.exp(self.eval(z)),
             'ABS' : lambda z: abs(self.eval(z)),
             'LOG' : lambda z: math.log(self.eval(z)),
             'SQR' : lambda z: math.sqrt(self.eval(z)),
             'INT' : lambda z: int(self.eval(z)),
             'RND' : lambda z: random.random()

src/s/y/sympy-old-HEAD/examples/advanced/pidigits.py sympy-old(Download)

    else:
        skip = len(intpart)
    print "Step 1 of 2: calculating binary value..."
    prec = int(n*math.log(base,2))+10
    t = clock()
    a = func(prec)
    step1_time = clock() - t

src/s/y/sympy-tensor-HEAD/examples/advanced/pidigits.py sympy-tensor(Download)

    else:
        skip = len(intpart)
    print "Step 1 of 2: calculating binary value..."
    prec = int(n*math.log(base,2))+10
    t = clock()
    a = func(prec)
    step1_time = clock() - t

src/s/y/sympy-HEAD/examples/advanced/pidigits.py sympy(Download)

    else:
        skip = len(intpart)
    print "Step 1 of 2: calculating binary value..."
    prec = int(n*math.log(base,2))+10
    t = clock()
    a = func(prec)
    step1_time = clock() - t

src/s/h/shedskin-HEAD/examples/mastermind2.py shedskin(Download)

# Recipe 496907: Mastermind-style code-breaking, by Raymond Hettinger
# http://code.activestate.com/recipes/496907/
# Version speed up and adapted to Psyco D by leonardo maffi, V.1.0, Apr 4 2009
 
import random
from math import log
from collections import defaultdict

    s = float(len(possibles))
    for i in b.itervalues():
        p = i / s
        bits -= p * log(p, 2)
    return bits
 
def nodup(play):

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 Next