def test_vega(self):
     call_vega = BSPrice_Analytical(*self.input, True)['derivatives'][1]
     put_vega = BSPrice_Analytical(*self.input, False)['derivatives'][1]
     self.assertAlmostEqual(call_vega,
                            differentiate(BSPrice, *self.input, True)[1],
                            places=3)
     self.assertAlmostEqual(put_vega,
                            differentiate(BSPrice, *self.input, False)[1],
                            places=3)
     self.assertAlmostEqual(call_vega,
                            BSPrice_SAD(*self.input,
                                        True)['derivatives'][1],
                            places=8)
     self.assertAlmostEqual(put_vega,
                            BSPrice_SAD(*self.input,
                                        False)['derivatives'][1],
                            places=8)
     self.assertAlmostEqual(call_vega,
                            BSPrice_AAD(*self.input,
                                        True)['derivatives'][1],
                            places=8)
     self.assertAlmostEqual(put_vega,
                            BSPrice_AAD(*self.input,
                                        False)['derivatives'][1],
                            places=8)
 def test_rho(self):
     call_rho = BSPrice_Analytical(*self.input, True)['derivatives'][4]
     put_rho = BSPrice_Analytical(*self.input, False)['derivatives'][4]
     self.assertAlmostEqual(call_rho,
                            differentiate(BSPrice, *self.input, True)[4],
                            places=3)
     self.assertAlmostEqual(put_rho,
                            differentiate(BSPrice, *self.input, False)[4],
                            places=3)
     self.assertAlmostEqual(call_rho,
                            BSPrice_SAD(*self.input,
                                        True)['derivatives'][4],
                            places=8)
     self.assertAlmostEqual(put_rho,
                            BSPrice_SAD(*self.input,
                                        False)['derivatives'][4],
                            places=8)
     self.assertAlmostEqual(call_rho,
                            BSPrice_AAD(*self.input,
                                        True)['derivatives'][4],
                            places=8)
     self.assertAlmostEqual(put_rho,
                            BSPrice_AAD(*self.input,
                                        False)['derivatives'][4],
                            places=8)
 def test_theta(self):
     call_theta = -1 * BSPrice_Analytical(*self.input,
                                          True)['derivatives'][3]
     put_theta = -1 * BSPrice_Analytical(*self.input,
                                         False)['derivatives'][3]
     self.assertAlmostEqual(call_theta,
                            differentiate(BSPrice, *self.input, True)[3],
                            places=3)
     self.assertAlmostEqual(put_theta,
                            differentiate(BSPrice, *self.input, False)[3],
                            places=3)
     self.assertAlmostEqual(call_theta,
                            BSPrice_SAD(*self.input,
                                        True)['derivatives'][3],
                            places=8)
     self.assertAlmostEqual(put_theta,
                            BSPrice_SAD(*self.input,
                                        False)['derivatives'][3],
                            places=8)
     self.assertAlmostEqual(call_theta,
                            BSPrice_AAD(*self.input,
                                        True)['derivatives'][3],
                            places=8)
     self.assertAlmostEqual(put_theta,
                            BSPrice_AAD(*self.input,
                                        False)['derivatives'][3],
                            places=8)
Ejemplo n.º 4
0
    def test(self):
        def t_fun(x, y):
            return x**4 + y**3

        derivatives = differentiate(t_fun, self.x, self.y, epsilon=self.eps)
        self.assertAlmostEqual(4 * self.x**3, derivatives[0], places=1)
        self.assertAlmostEqual(3 * self.y**2, derivatives[1], places=1)
 def test_Kpoint(self):
     call_KPoint = differentiate(BSPrice, *self.input, True)[2]
     self.assertAlmostEqual(call_KPoint,
                            BSPrice_SAD(*self.input,
                                        True)['derivatives'][2],
                            places=4)
     self.assertAlmostEqual(call_KPoint,
                            BSPrice_AAD(*self.input,
                                        True)['derivatives'][2],
                            places=4)
def forward_bump_derivatives():
    for i in range(0, option.__len__()):
        price = differentiate(BSPrice, *option[i])