Пример #1
0
def impv_bs(spot, strike, r, d, expiry, price, optiontype):
    low = 0.000001
    high = 0.3
    if (optiontype != "EURO_CALL" and optiontype != "EURO_PUT"):
        return "NAN1"
    if (optiontype == "EURO_CALL"):
        ce = bs_call(spot, strike, r, d, high, expiry)
    else:
        ce = bs_put(spot, strike, r, d, high, expiry)

    while (ce < price):
        high *= 2.0
        if (high > 1e10):
            return "NAN2"
        if (optiontype == "EURO_CALL"):
            ce = bs_call(spot, strike, r, d, high, expiry)
        else:
            ce = bs_put(spot, strike, r, d, high, expiry)

    if (optiontype == "EURO_CALL"):
        return brent(low, high, price, bs_call, None, None, spot, strike, r, d,
                     expiry, 0, 0)
    else:
        return brent(low, high, price, bs_put, None, None, spot, strike, r, d,
                     expiry, 0, 0)
Пример #2
0
def impv_bi(spot, strike, r, d, expiry, steps, price, optiontype):
    low = 0.001
    high = 0.3
    if (optiontype != "AMER_CALL" and optiontype != "AMER_PUT"):
        return "optiontype error"
    if (optiontype == "AMER_CALL"):
        ce = bi_amer_call(spot, strike, r, d, high, expiry, steps)
    else:
        ce = bi_amer_put(spot, strike, r, d, high, expiry, steps)

    while (ce < price):
        high *= 2.0
        if (high > 1e10):
            return "can't find a high vol"
        if (optiontype == "AMER_CALL"):
            ce = bi_amer_call(spot, strike, r, d, high, expiry, steps)
        else:
            ce = bi_amer_put(spot, strike, r, d, high, expiry, steps)

    if (optiontype == "AMER_CALL"):
        return brent(low, high, price, None, bi_amer_call, None, spot, strike,
                     r, d, expiry, 0, steps)
    else:
        return brent(low, high, price, None, bi_amer_put, None, spot, strike,
                     r, d, expiry, 0, steps)
Пример #3
0
def eigenvals3(d, c, N):
    def f(x):  # f(x) = |[A] - x[I]|
        p = sturmSeq(d, c, x)
        return p[len(p) - 1]

    lam = zeros((N), type=Float64)
    r = lamRange(d, c, N)  # Bracket eigenvalues
    for i in range(N):  # Solve by Brent's method
        lam[i] = brent(f, r[i], r[i + 1])
    return lam
Пример #4
0
def eigenvals3(d,c,N):

    def f(x):             # f(x) = |[A] - x[I]|
        p = sturmSeq(d,c,x)
        return p[len(p)-1]

    lam = zeros((N),type=Float64)
    r = lamRange(d,c,N)   # Bracket eigenvalues
    for i in range(N):    # Solve by Brent's method
        lam[i] = brent(f,r[i],r[i+1])
    return lam   
Пример #5
0
#!/usr/bin/python
## example4_5
from math import cos
from brent import *


def f(x):
    return x * abs(cos(x)) - 1.0


print "root =", brent(f, 0.0, 4.0)
raw_input("Press return to exit")
Пример #6
0
#!/usr/bin/python
## example4_5
from math import cos
from brent import *

def f(x): return x*abs(cos(x)) - 1.0

print "root =",brent(f,0.0,4.0)
raw_input("Press return to exit")
Пример #7
0
#!/usr/bin/python                                                                                                                  
## example8_1                                                                                                                      
from numarray import zeros,Float64,array                                                                                           
from run_kut4 import *                                                                                                             
from brent import *                                                                                                                
from printSoln import *                                                                                                            
def initCond(u): # Init. values of [y, y’]; use ’u’ if unknown                                                                     
        return array([0.0, u])                                                                                                     
def r(u): # Boundary condition residual--see Eq. (8.3)                                                                             
        X,Y = integrate(F,xStart,initCond(u),xStop,h)                                                                              
        y = Y[len(Y) - 1]                                                                                                          
        r = y[0] - 1.0                                                                                                             
        return r                                                                                                                   
def F(x,y): # First-order differential equations                                                                                   
        F = zeros((2),type=Float64)                                                                                                
        F[0] = y[1]                                                                                                                
        F[1] = -3.0*y[0]*y[1]                                                                                                      
        return F                                                                                                                   
                                                                                                                                   
xStart = 0.0 # Start of integration                                                                                                
xStop = 2.0 # End of integration                                                                                                   
u1 = 1.0 # 1st trial value of unknown init. cond.                                                                                  
u2 = 2.0 # 2nd trial value of unknown init. cond.                                                                                  
h = 0.1 # Step size                                                                                                                
freq = 2 # Printout frequency                                                                                                      
u = brent(r,u1,u2) # Compute the correct initial condition                                                                         
X,Y = integrate(F,xStart,initCond(u),xStop,h)                                                                                      
printSoln(X,Y,freq)                                                                                                                
raw_input(’’\nPress return to exit’’)                                                                                              
                                       
Пример #8
0

def initCond(u):  # Init. values of [y,y']; use 'u' if unknown
    return array([0.0, u])


def r(u):  # Boundary condition residual--see Eq. (8.3)
    X, Y = integrate(F, xStart, initCond(u), xStop, h)
    y = Y[len(Y) - 1]
    r = y[0] - 1.0
    return r


def F(x, y):  # First-order differential equations
    F = zeros((2), type=Float64)
    F[0] = y[1]
    F[1] = -3.0 * y[0] * y[1]
    return F


xStart = 0.0  # Start of integration
xStop = 2.0  # End of integration
u1 = 1.0  # 1st trial value of unknown init. cond.
u2 = 2.0  # 2nd trial value of unknown init. cond.
h = 0.1  # Step size
freq = 2  # Printout frequency
u = brent(r, u1, u2)  # Compute the correct initial condition
X, Y = integrate(F, xStart, initCond(u), xStop, h)
printSoln(X, Y, freq)
raw_input("\nPress return to exit")
Пример #9
0
    return x * x * x - 2 * x - 10


def g(x):
    return (x * 2 + 10) / x / x


# ------------------------------------------------------------
# buscar raices
a, b = rootSearch(f, -10, 10, 0.5, printText=1)
# bisection
print "\nMetodo Bisection"
print bisection(f, a, b, switch=1)
# brent
print "\nMetodo Brent"
print brent(f, a, b, printText=0)
# secant
print "\nMetodo Secant"
print secant(f, a, b, printText=0)
# newton
print "\nMetodo de Newton"
print newton(f, d1f, a, printText=0)
# newton raphson
print "\nMetodo de Newton-Raphson"
print newtonRaphson(f, d1f, a, b, printText=0)
# posicion falsa
print "\nMetodo Posicion Falsa o Falsa Regla"
print falseRule(f, a, b, printText=0)
# punto fijo
print "\nMetodo Punto Fijo"
print fixedPoint(g, a, printText=0)
from bisection import *
from regula_falsi import *
from ridder import *
from brent import *


def f(x):
    return x**3 - 10 * x**2 + 5.0


x1 = 0.0
x2 = 1.0

x, err = bisection(f, x1, x2, TOL=1e-10, verbose=True)
print("Final root = %18.10f" % x)
print("True err   = %18.10e" % abs(f(x)))

x, err = regula_falsi(f, x1, x2, TOL=1e-10, verbose=True)
print("Final root = %18.10f" % x)
print("True err   = %18.10e" % abs(f(x)))

x, err = ridder(f, x1, x2, TOL=1e-10, verbose=True)
print("Final root = %18.10f" % x)
print("True err   = %18.10e" % abs(f(x)))

x, err = brent(f, x1, x2, TOL=1e-10, verbose=True)
print("Final root = %18.10f" % x)
print("True err   = %18.10e" % abs(f(x)))