def test_get_aggregate_returns_with_log_returns(self):
test_returns = [0.01] * 22
dates = DatetimeIndex([
'2000-01-15', '2000-01-17', '2000-01-19', '2000-01-21',
'2000-01-23', '2000-01-25', '2000-01-27', '2000-01-29',
'2000-01-31', '2000-02-02', '2000-02-04', '2000-03-05',
'2000-04-04', '2000-05-04', '2000-06-03', '2000-07-03',
'2001-01-19', '2001-08-07', '2002-02-23', '2002-09-11',
'2003-03-30', '2003-10-16'
])
log_returns_series = LogReturnsSeries(data=test_returns, index=dates)
expected_result = log_returns_series.to_simple_returns()
actual_result = get_aggregate_returns(log_returns_series,
convert_to=Frequency.DAILY)
assert_series_equal(expected_result, actual_result)
expected_cumulative_returns = \
[0.01, 0.04, 0.03, 0.03, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01]
expected_dates = DatetimeIndex([
'2000-01-14', '2000-01-21', '2000-01-28', '2000-02-04',
'2000-03-03', '2000-04-07', '2000-05-05', '2000-06-02',
'2000-07-07', '2001-01-19', '2001-08-10', '2002-02-22',
'2002-09-13', '2003-03-28', '2003-10-17'
])
expected_result = LogReturnsSeries(
data=expected_cumulative_returns,
index=expected_dates).to_simple_returns()
actual_result = get_aggregate_returns(log_returns_series,
convert_to=Frequency.WEEKLY)
assert_series_equal(expected_result, actual_result)
expected_cumulative_returns = \
[0.09, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01]
expected_dates = DatetimeIndex([
'2000-01-31', '2000-02-29', '2000-03-31', '2000-04-30',
'2000-05-31', '2000-06-30', '2000-07-31', '2001-01-31',
'2001-08-31', '2002-02-28', '2002-09-30', '2003-03-31',
'2003-10-31'
])
expected_result = LogReturnsSeries(
data=expected_cumulative_returns,
index=expected_dates).to_simple_returns()
actual_result = get_aggregate_returns(log_returns_series,
convert_to=Frequency.MONTHLY)
assert_series_equal(expected_result, actual_result)
expected_cumulative_returns = [0.16, 0.02, 0.02, 0.02]
expected_dates = DatetimeIndex(
['2000-12-31', '2001-12-31', '2002-12-31', '2003-12-31'])
expected_result = LogReturnsSeries(
data=expected_cumulative_returns,
index=expected_dates).to_simple_returns()
actual_result = get_aggregate_returns(log_returns_series,
convert_to=Frequency.YEARLY)
assert_series_equal(expected_result, actual_result)
class TestSeries(TestCase):
def setUp(self):
return_dates = pd.date_range('2015-01-01', periods=20, freq='D')
test_returns = [0.01, 0.02, 0.03, 0.02, 0.01, 0, -0.01, -0.02, 0.01, 0.03, 0.05, 0.04, 0.03, 0.02,
0.01, 0, 0.01, 0.03, 0.02, 0.04]
self.test_simple_returns_tms = SimpleReturnsSeries(data=test_returns, index=return_dates, dtype=float,
name='Test Name')
prices_values = [100, 101, 103.02, 106.1106, 108.232812, 109.31514012, 109.31514012, 108.2219887188,
106.057548944424, 107.118124433868, 110.331668166884, 115.848251575229, 120.482181638238,
124.096647087385, 126.578580029132, 127.844365829424, 127.844365829424, 129.1228094877180,
132.9964937723500, 135.656423647797, 141.082680593708]
prices_dates = pd.date_range('2014-12-31', periods=1, freq='D').append(return_dates)
self.test_prices_tms = PricesSeries(data=prices_values, index=prices_dates, name='Test Name')
test_log_returns = [0.009950331, 0.019802627, 0.029558802, 0.019802627, 0.009950331, 0, -0.010050336,
-0.020202707, 0.009950331, 0.029558802, 0.048790164, 0.039220713, 0.029558802,
0.019802627, 0.009950331, 0, 0.009950331, 0.029558802, 0.019802627, 0.039220713]
self.test_log_returns_tms = LogReturnsSeries(data=test_log_returns, index=return_dates, dtype=float,
name='Test Name')
def test_prices_to_simple_returns(self):
actual_returns_tms = self.test_prices_tms.to_simple_returns()
expected_returns_tms = self.test_simple_returns_tms
assert_series_equal(expected_returns_tms, actual_returns_tms)
def test_prices_to_log_returns(self):
actual_log_returns_tms = self.test_prices_tms.to_log_returns()
expected_log_returns_tms = self.test_log_returns_tms
assert_series_equal(expected_log_returns_tms, actual_log_returns_tms)
def test_simple_returns_to_prices(self):
expected_tms = self.test_prices_tms
actual_tms = self.test_simple_returns_tms.to_prices(initial_price=100)
assert_series_equal(expected_tms, actual_tms, absolute_tolerance=1e-5)
def test_simple_returns_to_log_returns(self):
expected_tms = self.test_log_returns_tms
actual_tms = self.test_simple_returns_tms.to_log_returns()
assert_series_equal(expected_tms, actual_tms)
def test_log_returns_to_prices(self):
prices_values = array([1, exp(1), exp(2), exp(-1), exp(2)])
prices_dates = pd.date_range('2015-01-01', periods=5)
expected = PricesSeries(data=prices_values, index=prices_dates)
returns_tms = LogReturnsSeries(data=[1, 1, -3, 3], index=expected.index[1::])
actual = returns_tms.to_prices()
assert_series_equal(expected, actual)
def test_log_returns_to_simple_returns(self):
expected_tms = self.test_simple_returns_tms
actual_tms = self.test_log_returns_tms.to_simple_returns()
assert_series_equal(expected_tms, actual_tms)
def test_infer_interval(self):
expected_interval = pd.Timedelta("1 day")
expected_frequency = 1
actual_interval, actual_frequency = self.test_log_returns_tms.infer_interval()
self.assertEqual(expected_interval, actual_interval)
self.assertEqual(expected_frequency, actual_frequency)
expected_interval = pd.Timedelta("1 day")
expected_frequency = 2 / 3
dates = pd.date_range('2016-04-01', periods=4, freq='b')
test_series = QFSeries(data=[0, 0, 0, 0], index=dates)
actual_interval, actual_frequency = test_series.infer_interval()
self.assertEqual(expected_interval, actual_interval)
self.assertEqual(expected_frequency, actual_frequency)
def test_cast_series(self):
actual_casted_series = cast_series(self.test_simple_returns_tms, PricesSeries)
self.assertEqual(PricesSeries, type(actual_casted_series))
self.assertEqual(list(self.test_simple_returns_tms.values), list(actual_casted_series.values))
def test_rolling_window(self):
strategy_dates = pd.date_range('2015-01-01', periods=20, freq='D')
benchmark_dates = pd.date_range('2015-01-10', periods=20, freq='D')
data = [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01,
0.01, 0.01, 0.01, 0.01, 0.01]
strategy = SimpleReturnsSeries(data=data, index=strategy_dates)
benchmark = SimpleReturnsSeries(data=data, index=benchmark_dates)
rolling = strategy.rolling_window_with_benchmark(benchmark, 1, lambda x, y: x.mean() + y.mean())
self.assertEqual(rolling.iloc[0], 0.02)
self.assertEqual(rolling.index[0], benchmark_dates[1])
self.assertEqual(rolling.index[9], benchmark_dates[10])
self.assertEqual(len(rolling), 10)
# Test with missing values in the middle.
strategy_dates = pd.date_range('2015-01-02', periods=3, freq='D')
benchmark_dates = pd.DatetimeIndex(['2015-01-01', '2015-01-02', '2015-01-04'])
strategy = SimpleReturnsSeries(data=[0.01, 0.50, 0.01], index=strategy_dates)
benchmark = SimpleReturnsSeries(data=[0.50, 0.01, 0.01], index=benchmark_dates)
rolling = strategy.rolling_window_with_benchmark(benchmark, 1, lambda x, y: x.mean() + y.mean())
self.assertEqual(rolling.iloc[0], 0.02)