Пример #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
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]))