コード例 #1
0
def trapezodial(expr, interval, N):
    func = function(expr)
    dx, fs = getIntervalPoints(N, func, interval)

    integral = 0.0
    for i in range(N):
        integral += fs[i] + fs[i + 1]
    integral *= dx / 2

    return integral, maxErr(func, dx, interval)
コード例 #2
0
def rectangular(expr, interval, N):
    func = function(expr)
    dx, fs = getIntervalPoints(N, func, interval)

    # Integral computation
    integral = 0.0
    for i in range(N):
        integral += fs[i]
    integral *= dx

    return integral, maxErr(func, dx, interval)
コード例 #3
0
def simpson(expr, interval, N):
    func = function(expr)
    # Simpson rule requires that interval is separated in 2*n equal intervals
    dx, fs = getIntervalPoints(2 * N, func, interval)
    dx *= 2  # dx must be (b-a)/6 not (b-a)/12

    integral = 0.0
    for i in range(N):
        integral += fs[2 * i] + 4 * fs[2 * i + 1] + fs[2 * i + 2]
    integral *= dx / 6

    return integral, maxErr(func, dx, interval)
コード例 #4
0
def newton_raphson(expr, point=0, tolerance=0.001):
    """Uses newton raphson method to solve the equation: expr = 0"""
    f = function(expr)
    derivative = f.diff()

    k = 0
    while True:
        k += 1
        newPoint = point - f(point) / derivative(point)

        if abs(newPoint - point) < tolerance:
            break
        else:
            point = newPoint

    return point, k  # (solution, iterations)
コード例 #5
0
ファイル: bisection.py プロジェクト: toliz/numerical-methods
def bisection(expr, lo, hi, tolerance=0.001):
    """Uses bisection method to solve the equation: expr = 0"""
    f = function(expr)

    k = 1
    while abs(hi - lo) >= tolerance:
        medium = (hi + lo) / 2

        if f(lo) * f(medium) <= 0:
            hi = medium
        else:
            lo = medium

        k += 1

    return lo, hi, k  # (lower bound, higher bound, iterations)
コード例 #6
0
def false_position(expr, lo, hi, tolerance=0.001):
    """Uses false position method to solve the equation: expr = 0"""
    f = function(expr)

    c, k = 1, 1
    while abs(f(c)) >= tolerance:
        c = (lo * f(hi) - hi * f(lo)) / (f(hi) - f(lo))

        if (f(lo) * f(c) <= 0):
            hi = c
        else:
            lo = c

        k += 1

    return c, k  # (solution, iterations)
コード例 #7
0
def fixed_point(expr, point=0, tolerance=0.001):
    """Uses fixed point method to solve the equation: expr = 0"""

    # TODO: implement Aitken acceleration
    f = function(expr + "+x")

    k, maxiter = 0, 1000
    while True:
        k += 1
        newPoint = f(point)

        if abs(newPoint - point) < tolerance:
            break
        elif k > maxiter:
            return Exception("Failed to convert in %d iterations" % maxiter)
        else:
            point = newPoint

    return point, k  # (solution, iterations)
コード例 #8
0
        # Func is a first degree polynomial and its derivative is constant
        # Sympy can't handle devitives of a constant function. If func has
        # a positive slope then we should return func(b), else we should
        # return func(a)
        return max(func(a), func(b))
    secondder = func.diff(2)
    """
    To find the global maximum of func in interval we first solve df/dx = 0
    Then we check if the second derivative is negative on these points, which
    is the condition for checking for local maximum. Of these local maxima
    and the values of func at a and b we want the one that is bigger
    """
    solutionsExpr = solve(firstder)
    solutions = list(map(lambda x: x.evalf(), solutionsExpr))

    maxOfFunc = max(func(a), func(b))
    for point in solutions:
        if secondder(point) < 0:
            # we have a local maximum
            maxOfFunc = max(func(point), maxOfFunc)

    return maxOfFunc


if __name__ == "__main__":
    expr = input("Enter a function: ")
    f = function(expr)

    print(funcMax(f, [-10, 10]))
    print(getIntervalPoints(10, function('x'), [0, 1]))