(define (newton x2)
(let loop ((x 1.0))
(let ((t (- (* x x) x2)))
(if (< (abs t) epsilon) x
(loop (- x (/ t (+ x x))))))))

import math

#Maximum error
DELTA = 0.0001

def cmp_estimation(estimation, true):
    if (true - DELTA) <= estimation <= (true + DELTA):
        return True
    else:
        return False


def newton(number):
    '''
    Returns the square root using Newton formula
    '''

    old_estimation = 0
    estimation = number / 2
            
    #check until next iteration gives us less precission than DELTA
    while not cmp_estimation(old_estimation, estimation):
        old_estimation = estimation
        estimation = estimation \
                    - (float(estimation ** 2 - number) / (2 * estimation))
    
    return estimation

def euler(number, base):
    '''
    Calculate logarithms using Euler formula
    '''
    
    #initialize the numbers getting the closest powers
    upper = 1
    while base ** upper <= number:
        lower = upper
        upper += 1
                
    prev_arith_mean = -1
    arith_mean = 0
    geo_mean = upper
    
    while not cmp_estimation(arith_mean, prev_arith_mean):
        prev_arith_mean = arith_mean
                
        #Calculate geometric and arithmetic mean
        arith_mean = float(lower + upper) / 2
        geo_mean = newton((base ** lower) * (base ** upper))
        
        #Narrow the interval
        if geo_mean < number:
            lower = arith_mean
        else:
            upper = arith_mean
            
    return arith_mean

#Some test to ensure everything is fine
if __name__ == '__main__':
    for i in range(2, 100):
        assert cmp_estimation(newton(i), math.sqrt(i))

    for base in range(2, 11):
        for i in range(base, 100):
            assert cmp_estimation(euler(i, base), math.log(i, base))

eps :: Double
eps = 1e-7

sqrt' :: Double -> Double
sqrt' n = head . filter (\x -> abs (x^2 - n) < eps) $
    iterate (\x -> x - (x^2 - n) / (2*x)) 1

log' :: Double -> Double -> Double
log' b n = f 0 0 where
    f lo hi | b ** hi < n             = f lo (hi + 1)
            | abs (lo / hi - 1) < eps = arit
            | geom < n                = f arit hi
            | otherwise               = f lo arit
            where geom = sqrt' (b ** lo * b ** hi)
                  arit = (lo + hi) / 2