from __future__ import division
from math import log

def dx(a, b, n):
    return (b - a) / n

def rectangle(f, a, b, n=1):
    x = lambda k: a + (k + 0.5) * dx(a, b, n)
    return dx(a, b, n) * sum(f(x(k)) for k in xrange(n))

def trapezoid(f, a, b, n=1):
    x = lambda k: a + k * dx(a, b, n)
    return dx(a, b, n) * (f(a) + f(b) + sum(0.5 * (f(x(k)) + f(x(k + 1))) for k
        in xrange(1, n)))

def simpson(f, a, b, n=1):
    x = lambda k: a + k * dx(a, b, 2 * n)
    return dx(a, b, 2 * n) / 3 * (f(a) + f(b) + 2 * sum(f(x(k)) for k in
        xrange(2, 2 * n, 2)) + 4 * sum(f(x(k)) for k in xrange(1, 2 * n, 2)))

def adaptive_quad(f, a, b, quad=simpson, eps=1e-7):
    int_with5 = quad(f, a, b, 5)
    int_with10 = quad(f, a, b, 10)
    m = (a + b) / 2
    if abs(int_with5 - int_with10) < eps:
        return int_with10
    else:
        return (adaptive_quad(f, a, m, quad, eps) +
                adaptive_quad(f, m, b, quad, eps))

def approx_pi(b):
    return adaptive_quad(lambda x: 1 / log(x), 2, b)

if __name__ == "__main__":
    cube = lambda x: pow(x, 3)
    print rectangle(cube, 0, 1, 10000)
    print trapezoid(cube, 0, 1, 10000)
    print simpson(cube, 0, 1, 10000)
    print approx_pi(1e21)

def rectangular(f, lo, hi, nsteps=1):
    area = 0
    spread = float(hi-lo)
    for n in range(nsteps):
        x = lo + spread*(2*n+1)/(2*nsteps)
        area += f(x)

    return area*spread/nsteps

def trapezoidal(f, lo, hi, nsteps=1):
    area = -(f(lo) + f(hi))
    spread = float(hi-lo)
    for n in range(nsteps+1):
        x = lo + n*spread/nsteps
        area += 2*f(x)

    return area*float(hi-lo)/(2*nsteps)

def simpson(f, lo, hi, nsteps=1):
    area = -(f(lo) + f(hi))
    spread = float(hi-lo)
    for n in range(2*nsteps+1):
        x = lo + n*spread/(2*nsteps)
        area += 4*f(x) if n&1 else 2*f(x)

    return area*spread/(6*nsteps)

def adaptive(f, lo, hi, integrator=simpson, eps=1e-3):
    lo,hi = float(lo),float(hi)
    area = 0
    todo = [(lo, hi,integrator(f, lo, hi))]

    while todo:
        a,b,slice_area = todo.pop()
        mid = (a+b)/2
        lohalf = integrator(f, a, mid)
        hihalf = integrator(f, mid, b)
        if abs(slice_area - (lohalf + hihalf)) > eps:
            todo.append((a,mid,lohalf))
            todo.append((mid,b,hihalf))
        else:
            area += lohalf + hihalf

    return area

# tests
def cube(x):
    return x*x*x

def invlog(x):
    from math import log

    return 1/log(x)

print rectangular(cube, 0, 1, 10000)
print trapezoidal(cube, 0, 1, 10000)
print simpson(cube, 0, 1, 10000)
print adaptive(invlog, 2, 1e21, eps=1e-7)

output:
0.24999999875
0.2500000025
0.25
2.11272694866e+19

int combine f a b n = sum $ map g [0..n - 1] where
    w    = (b - a) / n
    lo i = a + w * i
    g i  = w * combine (f $ lo i) (f $ lo i + w/2) (f $ lo i + w)

intRect = int (\_ m _ -> m)

intTrap = int (\l _ h -> (l + h) / 2)

intSimp = int (\l m h -> (l + 4 * m + h) / 6)

intAdapt m f a b epsilon = if abs (g10 - g5) < e then g10 else
    intAdapt m f a mid (Just e) + intAdapt m f mid b (Just e)
    where g5  = m f a b 5
          g10 = m f a b 10
          mid = (a + b) / 2
          e   = maybe 1e-7 id epsilon

approxPi n = round $ intAdapt intSimp (recip . log) 2 n Nothing