Example #1
0
def test_pdsolve_variable_coeff():
    f, F = map(Function, ['f', 'F'])
    u = f(x, y)
    eq = x * (u.diff(x)) - y * (u.diff(y)) + y**2 * u - y**2
    sol = pdsolve(eq, hint="1st_linear_variable_coeff")
    assert sol == Eq(u, F(x * y) * exp(y**2 / 2) + 1)
    assert checkpdesol(eq, sol)[0]

    eq = x**2 * u + x * u.diff(x) + x * y * u.diff(y)
    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
    assert sol == Eq(u, F(y * exp(-x)) * exp(-x**2 / 2))
    assert checkpdesol(eq, sol)[0]

    eq = y * x**2 * u + y * u.diff(x) + u.diff(y)
    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
    assert sol == Eq(u, F(-2 * x + y**2) * exp(-x**3 / 3))
    assert checkpdesol(eq, sol)[0]

    eq = exp(x)**2 * (u.diff(x)) + y
    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
    assert sol == Eq(u, y * exp(-2 * x) / 2 + F(y))
    assert checkpdesol(eq, sol)[0]

    eq = exp(2 * x) * (u.diff(y)) + y * u - u
    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
    assert sol == Eq(u, F(x) * exp(-y * (y - 2) * exp(-2 * x) / 2))
Example #2
0
def test_pde_1st_linear_constant_coeff():
    f, F = map(Function, ["f", "F"])
    u = f(x, y)
    eq = -2 * u.diff(x) + 4 * u.diff(y) + 5 * u - exp(x + 3 * y)
    sol = pdsolve(eq)
    assert sol == Eq(f(x, y), (F(4 * x + 2 * y) + exp(x / S(2) + 4 * y) / S(15)) * exp(x / S(2) - y))
    assert classify_pde(eq) == ("1st_linear_constant_coeff", "1st_linear_constant_coeff_Integral")
    assert checkpdesol(eq, sol)[0]

    eq = (u.diff(x) / u) + (u.diff(y) / u) + 1 - (exp(x + y) / u)
    sol = pdsolve(eq)
    assert sol == Eq(f(x, y), F(x - y) * exp(-x / 2 - y / 2) + exp(x + y) / S(3))
    assert classify_pde(eq) == ("1st_linear_constant_coeff", "1st_linear_constant_coeff_Integral")
    assert checkpdesol(eq, sol)[0]

    eq = 2 * u + -u.diff(x) + 3 * u.diff(y) + sin(x)
    sol = pdsolve(eq)
    assert sol == Eq(f(x, y), F(3 * x + y) * exp(x / S(5) - 3 * y / S(5)) - 2 * sin(x) / S(5) - cos(x) / S(5))
    assert classify_pde(eq) == ("1st_linear_constant_coeff", "1st_linear_constant_coeff_Integral")
    assert checkpdesol(eq, sol)[0]

    eq = u + u.diff(x) + u.diff(y) + x * y
    sol = pdsolve(eq)
    assert sol == Eq(f(x, y), -x * y + x + y + F(x - y) * exp(-x / S(2) - y / S(2)) - 2)
    assert classify_pde(eq) == ("1st_linear_constant_coeff", "1st_linear_constant_coeff_Integral")
    assert checkpdesol(eq, sol)[0]

    eq = u + u.diff(x) + u.diff(y) + log(x)
    assert classify_pde(eq) == ("1st_linear_constant_coeff", "1st_linear_constant_coeff_Integral")
Example #3
0
def test_pdsolve_variable_coeff():
    f, F = map(Function, ['f', 'F'])
    u = f(x, y)
    eq = x*(u.diff(x)) - y*(u.diff(y)) + y**2*u - y**2
    sol = pdsolve(eq, hint="1st_linear_variable_coeff")
    assert sol == Eq(u, F(x*y)*exp(y**2/2) + 1)
    assert checkpdesol(eq, sol)[0]

    eq = x**2*u + x*u.diff(x) + x*y*u.diff(y)
    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
    assert sol == Eq(u, F(y*exp(-x))*exp(-x**2/2))
    assert checkpdesol(eq, sol)[0]

    eq = y*x**2*u + y*u.diff(x) + u.diff(y)
    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
    assert sol == Eq(u, F(-2*x + y**2)*exp(-x**3/3))
    assert checkpdesol(eq, sol)[0]

    eq = exp(x)**2*(u.diff(x)) + y
    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
    assert sol == Eq(u, y*exp(-2*x)/2 + F(y))
    assert checkpdesol(eq, sol)[0]

    eq = exp(2*x)*(u.diff(y)) + y*u - u
    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
    assert sol == Eq(u, exp((-y**2 + 2*y + 2*F(x))*exp(-2*x)/2))
Example #4
0
def test_pde_1st_linear_constant_coeff_homogeneous():
    f, F = map(Function, ['f', 'F'])
    u = f(x, y)
    eq = 2 * u + u.diff(x) + u.diff(y)
    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous', )
    sol = pdsolve(eq)
    assert sol == Eq(u, F(x - y) * exp(-x - y))
    assert checkpdesol(eq, sol)[0]

    eq = 4 + (3 * u.diff(x) / u) + (2 * u.diff(y) / u)
    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous', )
    sol = pdsolve(eq)
    assert sol == Eq(u,
                     F(2 * x - 3 * y) * exp(-S(12) * x / 13 - S(8) * y / 13))
    assert checkpdesol(eq, sol)[0]

    eq = u + (6 * u.diff(x)) + (7 * u.diff(y))
    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous', )
    sol = pdsolve(eq)
    assert sol == Eq(u, F(7 * x - 6 * y) * exp(-6 * x / S(85) - 7 * y / S(85)))
    assert checkpdesol(eq, sol)[0]

    eq = a * u + b * u.diff(x) + c * u.diff(y)
    sol = pdsolve(eq)
    assert checkpdesol(eq, sol)[0]
Example #5
0
def test_solvefun():
    f, F, G, H = map(Function, ['f', 'F', 'G', 'H'])
    eq1 = f(x, y) + f(x, y).diff(x) + f(x, y).diff(y)
    assert pdsolve(eq1) == Eq(f(x, y), F(x - y) * exp(-x / 2 - y / 2))
    assert pdsolve(eq1, solvefun=G) == Eq(f(x, y),
                                          G(x - y) * exp(-x / 2 - y / 2))
    assert pdsolve(eq1, solvefun=H) == Eq(f(x, y),
                                          H(x - y) * exp(-x / 2 - y / 2))
Example #6
0
def test_pde_1st_linear_constant_coeff():
    f, F = map(Function, ["f", "F"])
    u = f(x, y)
    eq = -2 * u.diff(x) + 4 * u.diff(y) + 5 * u - exp(x + 3 * y)
    sol = pdsolve(eq)
    assert sol == Eq(f(x,
                       y), (F(4 * x + 2 * y) + exp(x / S(2) + 4 * y) / S(15)) *
                     exp(x / S(2) - y))
    assert classify_pde(eq) == (
        "1st_linear_constant_coeff",
        "1st_linear_constant_coeff_Integral",
    )
    assert checkpdesol(eq, sol)[0]

    eq = (u.diff(x) / u) + (u.diff(y) / u) + 1 - (exp(x + y) / u)
    sol = pdsolve(eq)
    assert sol == Eq(f(x, y),
                     F(x - y) * exp(-x / 2 - y / 2) + exp(x + y) / S(3))
    assert classify_pde(eq) == (
        "1st_linear_constant_coeff",
        "1st_linear_constant_coeff_Integral",
    )
    assert checkpdesol(eq, sol)[0]

    eq = 2 * u + -u.diff(x) + 3 * u.diff(y) + sin(x)
    sol = pdsolve(eq)
    assert sol == Eq(
        f(x, y),
        F(3 * x + y) * exp(x / S(5) - 3 * y / S(5)) - 2 * sin(x) / S(5) -
        cos(x) / S(5),
    )
    assert classify_pde(eq) == (
        "1st_linear_constant_coeff",
        "1st_linear_constant_coeff_Integral",
    )
    assert checkpdesol(eq, sol)[0]

    eq = u + u.diff(x) + u.diff(y) + x * y
    sol = pdsolve(eq)
    assert sol == Eq(f(x, y),
                     -x * y + x + y + F(x - y) * exp(-x / S(2) - y / S(2)) - 2)
    assert classify_pde(eq) == (
        "1st_linear_constant_coeff",
        "1st_linear_constant_coeff_Integral",
    )
    assert checkpdesol(eq, sol)[0]

    eq = u + u.diff(x) + u.diff(y) + log(x)
    assert classify_pde(eq) == (
        "1st_linear_constant_coeff",
        "1st_linear_constant_coeff_Integral",
    )
Example #7
0
def test_checkpdesol():
    f, F = map(Function, ['f', 'F'])
    eq1 = a*f(x,y) + b*f(x,y).diff(x) + c*f(x,y).diff(y)
    eq2 = 3*f(x,y) + 2*f(x,y).diff(x) + f(x,y).diff(y)
    eq3 = a*f(x,y) + b*f(x,y).diff(x) + 2*f(x,y).diff(y)
    for eq in [eq1, eq2, eq3]:
        assert checkpdesol(eq, pdsolve(eq))[0]
    eq4 = x*f(x,y) + f(x,y).diff(x) + 3*f(x,y).diff(y)
    eq5 = 2*f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
    eq6 = f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
    assert checkpdesol(eq4, [pdsolve(eq5), pdsolve(eq6)]) == [
        (False, (x - 2)*F(3*x - y)*exp(-x/S(5) - 3*y/S(5))),
         (False, (x - 1)*F(3*x - y)*exp(-x/S(10) - 3*y/S(10)))]
Example #8
0
def test_checkpdesol():
    f, F = map(Function, ['f', 'F'])
    eq1 = a * f(x, y) + b * f(x, y).diff(x) + c * f(x, y).diff(y)
    eq2 = 3 * f(x, y) + 2 * f(x, y).diff(x) + f(x, y).diff(y)
    eq3 = a * f(x, y) + b * f(x, y).diff(x) + 2 * f(x, y).diff(y)
    for eq in [eq1, eq2, eq3]:
        assert checkpdesol(eq, pdsolve(eq))[0]
    eq4 = x * f(x, y) + f(x, y).diff(x) + 3 * f(x, y).diff(y)
    eq5 = 2 * f(x, y) + 1 * f(x, y).diff(x) + 3 * f(x, y).diff(y)
    eq6 = f(x, y) + 1 * f(x, y).diff(x) + 3 * f(x, y).diff(y)
    assert checkpdesol(eq4, [pdsolve(eq5), pdsolve(eq6)]) == [
        (False, (x - 2) * F(3 * x - y) * exp(-x / S(5) - 3 * y / S(5))),
        (False, (x - 1) * F(3 * x - y) * exp(-x / S(10) - 3 * y / S(10)))
    ]
Example #9
0
def test_checkpdesol():
    f, F = map(Function, ['f', 'F'])
    eq1 = a*f(x,y) + b*f(x,y).diff(x) + c*f(x,y).diff(y)
    eq2 = 3*f(x,y) + 2*f(x,y).diff(x) + f(x,y).diff(y)
    eq3 = a*f(x,y) + b*f(x,y).diff(x) + 2*f(x,y).diff(y)
    for eq in [eq1, eq2, eq3]:
        assert checkpdesol(eq, pdsolve(eq))[0]
    eq4 = x*f(x,y) + f(x,y).diff(x) + 3*f(x,y).diff(y)
    eq5 = 2*f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
    eq6 = f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
    assert checkpdesol(eq4, [pdsolve(eq5), pdsolve(eq6)]) == [
        (False, (x - 2)*F(3*x - y)*exp(-x/S(5) - 3*y/S(5))),
         (False, (x - 1)*F(3*x - y)*exp(-x/S(10) - 3*y/S(10)))]
    for eq in [eq4, eq5, eq6]:
        assert checkpdesol(eq, pdsolve(eq))[0]
    sol = pdsolve(eq4)
    sol4 = Eq(sol.lhs - sol.rhs, 0)
    raises(NotImplementedError, lambda:
        checkpdesol(eq4, sol4, solve_for_func=False))
Example #10
0
def test_checkpdesol():
    f, F = map(Function, ['f', 'F'])
    eq1 = a*f(x,y) + b*f(x,y).diff(x) + c*f(x,y).diff(y)
    eq2 = 3*f(x,y) + 2*f(x,y).diff(x) + f(x,y).diff(y)
    eq3 = a*f(x,y) + b*f(x,y).diff(x) + 2*f(x,y).diff(y)
    for eq in [eq1, eq2, eq3]:
        assert checkpdesol(eq, pdsolve(eq))[0]
    eq4 = x*f(x,y) + f(x,y).diff(x) + 3*f(x,y).diff(y)
    eq5 = 2*f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
    eq6 = f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
    assert checkpdesol(eq4, [pdsolve(eq5), pdsolve(eq6)]) == [
        (False, (x - 2)*F(3*x - y)*exp(-x/S(5) - 3*y/S(5))),
         (False, (x - 1)*F(3*x - y)*exp(-x/S(10) - 3*y/S(10)))]
    for eq in [eq4, eq5, eq6]:
        assert checkpdesol(eq, pdsolve(eq))[0]
    sol = pdsolve(eq4)
    sol4 = Eq(sol.lhs - sol.rhs, 0)
    raises(NotImplementedError, lambda:
        checkpdesol(eq4, sol4, solve_for_func=False))
Example #11
0
def ForwardKolmogorovEquation(drift, diffusion):
    p = Function('p')
    u = p(x, t)
    ut = u.diff(t)
    tdrift = u * drift
    tdiffusion = u * (1/2*diffusion**2)
    tdt = tdrift.diff(x)
    tdifft = tdiffusion.diff(x)
    tdifftt = tdifft.diff(x)
    eq = Eq(ut + tdt - tdifftt)
    return pdsolve(eq)
Example #12
0
def ForwardKolmogorovEquation(drift, diffusion):
    p = Function('p')
    u = p(x, t)
    ut = u.diff(t)
    tdrift = u * drift
    tdiffusion = u * (1 / 2 * diffusion**2)
    tdt = tdrift.diff(x)
    tdifft = tdiffusion.diff(x)
    tdifftt = tdifft.diff(x)
    eq = Eq(ut + tdt - tdifftt)
    return pdsolve(eq)
Example #13
0
def test_pdsolve_all():
    f, F = map(Function, ["f", "F"])
    u = f(x, y)
    eq = u + u.diff(x) + u.diff(y) + x ** 2 * y
    sol = pdsolve(eq, hint="all")
    keys = ["1st_linear_constant_coeff", "1st_linear_constant_coeff_Integral", "default", "order"]
    assert sorted(sol.keys()) == keys
    assert sol["order"] == 1
    assert sol["default"] == "1st_linear_constant_coeff"
    assert sol["1st_linear_constant_coeff"] == Eq(
        f(x, y), -x ** 2 * y + x ** 2 + 2 * x * y - 4 * x - 2 * y + F(x - y) * exp(-x / S(2) - y / S(2)) + 6
    )
Example #14
0
def test_pdsolve_all():
    f, F = map(Function, ['f', 'F'])
    u = f(x,y)
    eq = u + u.diff(x) + u.diff(y) + x**2*y
    sol = pdsolve(eq, hint = 'all')
    keys = ['1st_linear_constant_coeff',
        '1st_linear_constant_coeff_Integral', 'default', 'order']
    assert sorted(sol.keys()) == keys
    assert sol['order'] == 1
    assert sol['default'] == '1st_linear_constant_coeff'
    assert sol['1st_linear_constant_coeff'] == Eq(f(x, y),
        -x**2*y + x**2 + 2*x*y - 4*x - 2*y + F(x - y)*exp(-x/S(2) - y/S(2)) + 6)
Example #15
0
def test_pdsolve_all():
    f, F = map(Function, ['f', 'F'])
    u = f(x,y)
    eq = u + u.diff(x) + u.diff(y) + x**2*y
    sol = pdsolve(eq, hint = 'all')
    keys = ['1st_linear_constant_coeff',
        '1st_linear_constant_coeff_Integral', 'default', 'order']
    assert sorted(sol.keys()) == keys
    assert sol['order'] == 1
    assert sol['default'] == '1st_linear_constant_coeff'
    assert sol['1st_linear_constant_coeff'] == Eq(f(x, y),
        -x**2*y + x**2 + 2*x*y - 4*x - 2*y + F(x - y)*exp(-x/S(2) - y/S(2)) + 6)
Example #16
0
def test_pde_1st_linear_constant_coeff():
    f, F = map(Function, ['f', 'F'])
    u = f(x, y)
    eq = -2 * u.diff(x) + 4 * u.diff(y) + 5 * u - exp(x + 3 * y)
    sol = pdsolve(eq)
    assert sol == Eq(f(
        x, y), (F(4 * x + 2 * y) * exp(x / 2) + exp(x + 4 * y) / 15) * exp(-y))
    assert classify_pde(eq) == ('1st_linear_constant_coeff',
                                '1st_linear_constant_coeff_Integral')
    assert checkpdesol(eq, sol)[0]

    eq = (u.diff(x) / u) + (u.diff(y) / u) + 1 - (exp(x + y) / u)
    sol = pdsolve(eq)
    assert sol == Eq(f(x, y), F(x - y) * exp(-x / 2 - y / 2) + exp(x + y) / 3)
    assert classify_pde(eq) == ('1st_linear_constant_coeff',
                                '1st_linear_constant_coeff_Integral')
    assert checkpdesol(eq, sol)[0]

    eq = 2 * u + -u.diff(x) + 3 * u.diff(y) + sin(x)
    sol = pdsolve(eq)
    assert sol == Eq(
        f(x, y),
        F(3 * x + y) * exp(x / 5 - 3 * y / 5) - 2 * sin(x) / 5 - cos(x) / 5)
    assert classify_pde(eq) == ('1st_linear_constant_coeff',
                                '1st_linear_constant_coeff_Integral')
    assert checkpdesol(eq, sol)[0]

    eq = u + u.diff(x) + u.diff(y) + x * y
    sol = pdsolve(eq)
    assert sol.expand() == Eq(
        f(x, y), x + y + (x - y)**2 / 4 - (x + y)**2 / 4 +
        F(x - y) * exp(-x / 2 - y / 2) - 2).expand()
    assert classify_pde(eq) == ('1st_linear_constant_coeff',
                                '1st_linear_constant_coeff_Integral')
    assert checkpdesol(eq, sol)[0]
    eq = u + u.diff(x) + u.diff(y) + log(x)
    assert classify_pde(eq) == ('1st_linear_constant_coeff',
                                '1st_linear_constant_coeff_Integral')
Example #17
0
def test_pde_1st_linear_constant_coeff_homogeneous():
    f, F = map(Function, ["f", "F"])
    u = f(x, y)
    eq = 2 * u + u.diff(x) + u.diff(y)
    assert classify_pde(eq) == ("1st_linear_constant_coeff_homogeneous",)
    sol = pdsolve(eq)
    assert sol == Eq(u, F(x - y) * exp(-x - y))
    assert checkpdesol(eq, sol)[0]

    eq = 4 + (3 * u.diff(x) / u) + (2 * u.diff(y) / u)
    assert classify_pde(eq) == ("1st_linear_constant_coeff_homogeneous",)
    sol = pdsolve(eq)
    assert sol == Eq(u, F(2 * x - 3 * y) * exp(-S(12) * x / 13 - S(8) * y / 13))
    assert checkpdesol(eq, sol)[0]

    eq = u + (6 * u.diff(x)) + (7 * u.diff(y))
    assert classify_pde(eq) == ("1st_linear_constant_coeff_homogeneous",)
    sol = pdsolve(eq)
    assert sol == Eq(u, F(7 * x - 6 * y) * exp(-6 * x / S(85) - 7 * y / S(85)))
    assert checkpdesol(eq, sol)[0]

    eq = a * u + b * u.diff(x) + c * u.diff(y)
    sol = pdsolve(eq)
    assert checkpdesol(eq, sol)[0]
Example #18
0
def test_pdsolve_all():
    f, F = map(Function, ["f", "F"])
    u = f(x, y)
    eq = u + u.diff(x) + u.diff(y) + x**2 * y
    sol = pdsolve(eq, hint="all")
    keys = [
        "1st_linear_constant_coeff",
        "1st_linear_constant_coeff_Integral",
        "default",
        "order",
    ]
    assert sorted(sol.keys()) == keys
    assert sol["order"] == 1
    assert sol["default"] == "1st_linear_constant_coeff"
    assert sol["1st_linear_constant_coeff"] == Eq(
        f(x, y),
        -(x**2) * y + x**2 + 2 * x * y - 4 * x - 2 * y +
        F(x - y) * exp(-x / S(2) - y / S(2)) + 6,
    )
Example #19
0
def test_PredictorCorrector(input):
    Xs = input[0]
    Ys = input[1]
    exp = input[2]
    technique = input[3]
    xs = input[4]
    approx_error = input[5]
    exp = exp.replace('m', '*')
    exp = exp.replace('p', '**')
    exp = exp[1:len(exp)]
    try:
        f = sympy.sympify(exp)
    except:
        print('sympify error')
        pass
    # print(f)
    # print(exp)
    try:
        ys, errors, finalerror = PredictorCorrector(Xs, Ys, str(f), technique,
                                                    xs, approx_error)
    except:
        pass
    x = sympy.symbols('x')
    y = sympy.symbols('y')
    # try:
    #     # fx = lambdify([x,y] , f)
    #     # print(fx)
    # except:
    #     print('lambdify error')
    # pass
    ux = sympy.diff(f, x)
    uy = sympy.diff(f, y)
    eq = Eq(1 + (2 * (ux / f)) + (3 * (uy / f)), 0)
    try:
        sol = pdsolve(eq)
        print(sol)
    except:
        pass
    # ux = sympy.sympify()
    pass
Example #20
0
from sympy.solvers.pde import pdsolve
from sympy import Function, diff, Eq
from sympy.abc import x, y
f = Function('f')
u = f(x, y)
uxx = u.diff(x).diff(x)
uyy = u.diff(y).diff(y)
eq = Eq(1 - (2*(uxx)) - (3*(uyy)))
print(pdsolve(eq))
Example #21
0
import numpy as np
import sdeint
import matplotlib.pyplot as plt
from sympy.solvers.pde import pdsolve
from sympy import Function, diff, Eq, cos, sin
from sympy.abc import x, t

# Weiner Process Simulation
f = Function('f')
u = f(x, t)
ux = u.diff(x)
ut = u.diff(t)
uxx = ux.diff(x)
eq = Eq(ut + (1 - cos(2 * x) * u + (x + 2 - sin(2 * x)) * ux - 0.5 *
              (sin(x)**2) * uxx))
pdsolve(eq)

# Time steps
n = 1000
T = 1


###############################################################################
def Wiener(mu, sig, n, T):
    Delta = T / n
    #    t = np.arange(1, step=Delta)
    S = np.zeros(n, np.dtype(float))
    x = range(1, len(S))
    for i in x:
        dW = np.random.normal(mu, sig)
        dt = np.sqrt(Delta)
Example #22
0
def test_solvefun():
    f, F, G, H = map(Function, ["f", "F", "G", "H"])
    eq1 = f(x, y) + f(x, y).diff(x) + f(x, y).diff(y)
    assert pdsolve(eq1) == Eq(f(x, y), F(x - y) * exp(-x / 2 - y / 2))
    assert pdsolve(eq1, solvefun=G) == Eq(f(x, y), G(x - y) * exp(-x / 2 - y / 2))
    assert pdsolve(eq1, solvefun=H) == Eq(f(x, y), H(x - y) * exp(-x / 2 - y / 2))
Example #23
0
import numpy as np
import sdeint
import matplotlib.pyplot as plt
from sympy.solvers.pde import pdsolve
from sympy import Function, diff, Eq, cos, sin
from sympy.abc import x, t


# Weiner Process Simulation
f = Function('f')
u = f(x, t)
ux = u.diff(x)
ut = u.diff(t)
uxx = ux.diff(x)
eq = Eq(ut + (1 - cos(2*x)*u + (x + 2 - sin(2*x))*ux - 0.5*(sin(x)**2)*uxx))
pdsolve(eq)


# Time steps
n = 1000 
T = 1  

###############################################################################
def Wiener(mu, sig, n, T):
    Delta = T/n
#    t = np.arange(1, step=Delta)
    S = np.zeros(n, np.dtype(float))
    x = range(1, len(S))
    for i in x:
        dW = np.random.normal(mu, sig)
        dt = np.sqrt(Delta)