def setUp(self):
        DefaultHeston = HestonBarrierOption(spot=100,
                                            strike=100,
                                            interest_rate=0.06,
                                            volatility=0.2,
                                            tenor=1.0,
                                            mean_reversion=1,
                                            mean_variance=0.12,
                                            vol_of_variance=0.3,
                                            correlation=0.4,
                                            top=(False, 170.0))
        option = DefaultHeston
        # option = HestonOption(tenor=1, strike=99.0, volatility=0.2,
        # mean_reversion=3, mean_variance=0.04,
        # vol_of_variance=0.6, correlation=-0.7)

        self.dt = 1.0 / 150.0
        self.F = HestonFiniteDifferenceEngine(option,
                                              nspots=150,
                                              nvols=80,
                                              force_bandwidth=None,
                                              flip_idx_var=False)

        self.F.init()
        self.F.operators[1].diagonalize()
        self.FG = FDG.HestonFiniteDifferenceEngine(option,
                                                   nspots=self.F.grid.shape[0],
                                                   nvols=self.F.grid.shape[1])
        self.FG.make_operator_templates()
        self.FG.set_zero_derivative()
        self.FG.scale_and_combine_operators()
    def setUp(self):
        DefaultHeston = HestonBarrierOption(spot=100,
                                            strike=100,
                                            interest_rate=0.03125,
                                            volatility=0.2,
                                            tenor=1.0,
                                            mean_reversion=1,
                                            mean_variance=0.12,
                                            vol_of_variance=0.3,
                                            correlation=10.4,
                                            top=(False, 170.0))
        option = DefaultHeston

        # option = HestonOption(tenor=1, strike=99.0, volatility=0.2,
        # mean_reversion=3, mean_variance=0.04,
        # vol_of_variance=0.6, correlation=-0.7)

        self.dt = 1.0 / 2.0
        self.F = HestonFiniteDifferenceEngine(option,
                                              nspots=5,
                                              nvols=5,
                                              force_bandwidth=None,
                                              force_exact=False,
                                              flip_idx_var=False)

        # self.F = HestonFiniteDifferenceEngine(H, nspots=100,
        # nvols=100, spotdensity=10, varexp=4,
        # var_max=12, flip_idx_spot=False,
        # flip_idx_var=False, verbose=False,
        # force_bandwidth=None,
        # force_exact=False)

        self.F.init()

        self.FGG = FDG.HestonFiniteDifferenceEngine(
            option,
            force_exact=False,
            nspots=self.F.grid.shape[0],
            nvols=self.F.grid.shape[1])
        self.FGG.set_zero_derivative()
        self.FGG.make_operator_templates()
示例#3
0
 def setUp(self):
     self.option = HestonBarrierOption()
     self.s = np.array((4.5, 0.2, 5.5, 0, 3, 5.3, 0.001, 24, 1.3, 2.5))
     self.state = np.array((1, 1, 1, 1, 1, 1, 1, 1, 1, 1), dtype=bool)
示例#4
0
class BarrierOption_test(unittest.TestCase):

    def setUp(self):
        self.option = HestonBarrierOption()
        self.s = np.array((4.5, 0.2, 5.5, 0, 3, 5.3, 0.001, 24, 1.3, 2.5))
        self.state = np.array((1, 1, 1, 1, 1, 1, 1, 1, 1, 1), dtype=bool)


    def test_knockout_impossible(self):
        s = self.s.copy()
        state = self.state.copy()
        self.option.top = (False, np.infty)
        self.option.monte_carlo_callback(s, state)
        npt.assert_array_equal(np.ones(state.shape), state)


    def test_knockout_inevitable(self):
        self.option.top = (False, 0)
        self.option.monte_carlo_callback(self.s, self.state)
        npt.assert_array_equal(self.state, np.zeros(self.state.shape))


    def test_knockout_partial(self):
        self.option.top = (False, 3.0)
        self.option.monte_carlo_callback(self.s, self.state)
        res = np.array((0,1,0,1,0,0,1,0,1,1), dtype=bool)
        npt.assert_array_equal(self.state, res)


    def test_knockout_permanent(self):
        self.option.top = (False, 3.0)
        self.option.monte_carlo_callback(self.s, self.state)
        res = np.array((0,1,0,1,0,0,1,0,1,1), dtype=bool)
        self.s *= 0
        self.option.monte_carlo_callback(self.s, self.state)
        npt.assert_array_equal(self.state, res)


    def test_knockout_double(self):
        self.option.top = (False, 3.0)
        self.option.bottom = (False, 1.0)
        res = np.array((0,0,0,0,0,0,0,0,1,1), dtype=bool)
        self.option.monte_carlo_callback(self.s, self.state)
        npt.assert_array_equal(self.state, res)