def test_performance(self):
p = performance(ts, 262)
g = read_series("performance_a.csv", parse_dates=False)
for i in p.index[:-2]:
self.assertAlmostEqual(float(p.ix[i]), float(g.ix[i]), places=10)
for i in p.index[-2:]:
self.assertEqual(p.ix[i], pd.Timestamp(g.ix[i]))
def test_volatility(self):
s = read_series("ts.csv", parse_dates=True)
vola = volatility(prices=s, com=32)
vola_adj = volatility_adj_returns(prices=s,
volatility=vola,
winsor=4.2)
osc = oscillator(prices=vola_adj.cumsum(), fast=32, slow=96)
self.assertAlmostEqual(vola["2015-04-22"],
0.0017236025946574798,
places=10)
self.assertAlmostEqual(vola_adj["2015-04-22"],
0.16504637852209397,
places=10)
self.assertAlmostEqual(osc["2015-04-22"],
0.11165322157730379,
places=10)
def test_var(self):
s = read_series("ts.csv", parse_dates=True)
x = 100 * value_at_risk(s, alpha=0.99)
self.assertAlmostEqual(x, 0.47550914363392316, places=10)
def test_cvar(self):
s = read_series("ts.csv", parse_dates=True)
x = 100 * conditional_value_at_risk(s, alpha=0.99)
self.assertAlmostEqual(x, 0.51218385609772821, places=10)
from pyutil.nav.nav import Nav
from unittest import TestCase
import pandas as pd
from test.config import read_series
nav = Nav(read_series("ts.csv", parse_dates=True))
class TestNav(TestCase):
def test_drawdown(self):
self.assertAlmostEqual(100 * nav.drawdown.max(), 5.7000575458488578, places=6)
def test_performance(self):
self.assertAlmostEqual(nav.performance(days=256)["Max Drawdown"], 5.7000575458488578, places=6)
def test_monthly_table(self):
self.assertAlmostEqual(100 * nav.monthlytable["Nov"][2013], 0.23233078558395626, places=5)
def test_summary(self):
self.assertAlmostEqual(nav.summary(days=256)[250]["Max Drawdown"], 3.9885756705666631, places=6)
def test_ewm(self):
self.assertAlmostEqual(100 * nav.ewm_volatility(days=250).values[-1], 2.7706672542422539, places=6)
self.assertAlmostEqual(100 * nav.ewm_ret(days=250).values[-1], 6.0326401733122053, places=6)
self.assertAlmostEqual(nav.ewm_sharpe(days=250).values[-1], 2.177323951144059, places=6)
def test_adjust(self):
x = Nav(pd.Series(data=[50, 60, 55]))
y = x.adjust(100.0)#.series
self.assertAlmostEqual(y[0], 100.0, places=4)
def test_drawdown(self):
pdt.assert_series_equal(drawdown(ts), read_series("drawdown.csv", parse_dates=True), check_names=False)
def test_periods(self):
y = period_returns(ts.pct_change(), offset=periods(ts.index[-1]))
pdt.assert_series_equal(y, read_series("periods.csv", parse_dates=False), check_names=False)
import pandas as pd
from unittest import TestCase
from test.config import read_series, read_frame
from pyutil.web.web import series2array, performance2json, frame2html
nav = read_series("nav.csv")
class TestWeb(TestCase):
def test_series2array(self):
x = series2array(nav)
self.assertEqual(x[4][0], 1418770800000)
self.assertEqual(x[4][1], 1.2875483261929406)
def test_performance2dict(self):
x = pd.read_json(performance2json(nav), orient="split", typ="series")
self.assertEqual(x["Return"], "1.49")
def test_frame2html(self):
x = frame2html(read_frame("price.csv"), name="maffay")
self.assertTrue(x)
def test_drawdown(self):
pdt.assert_series_equal(drawdown(ts),
read_series("drawdown.csv", parse_dates=True),
check_names=False)
import pandas as pd
from pycta.performance.drawdown import drawdown, drawdown_periods
from test.config import read_series
from unittest import TestCase
ts = read_series("ts.csv", parse_dates=True)
import pandas.util.testing as pdt
class TestDrawdown(TestCase):
def test_drawdown(self):
pdt.assert_series_equal(drawdown(ts),
read_series("drawdown.csv", parse_dates=True),
check_names=False)
def test_periods(self):
x = drawdown_periods(ts)
self.assertEquals(x[pd.Timestamp("2014-06-20")], 217)
def test_periods_more(self):
s = read_series("ts.csv", parse_dates=True).pct_change().dropna()
y = period_returns(s, offset=periods(today=s.index[-1]))
pdt.assert_series_equal(y,
read_series("periods.csv", parse_dates=False),
check_names=False)
def test_period_returns(self):
p = periods(today=pd.Timestamp("2015-05-01"))
s = read_series("ts.csv", parse_dates=True).pct_change().dropna()
x = 100 * period_returns(returns=s, offset=p)
self.assertAlmostEqual(x["Three Years"], 1.1645579858904798, places=10)
def test_summary(self):
pdt.assert_series_equal(s.summary().apply(str), read_series("summary.csv").apply(str))
from unittest import TestCase
import pandas as pd
from pycta.performance.nav_series import NavSeries
from test.config import read_series
import pandas.util.testing as pdt
s = NavSeries(read_series("ts.csv", parse_dates=True))
class TestNavSeries(TestCase):
def test_pos_neg(self):
self.assertEqual(s.negative_events, 164)
self.assertEqual(s.positive_events, 176)
self.assertEqual(s.events, 340)
def test_summary(self):
pdt.assert_series_equal(s.summary().apply(str), read_series("summary.csv").apply(str))
def test_autocorrelation(self):
self.assertAlmostEqual(s.autocorrelation, 0.070961153249184269, places=10)
def test_mtd(self):
self.assertAlmostEqual(100*s.mtd, 1.4133604922211385, places=10)
def test_ytd(self):
self.assertAlmostEqual(100*s.ytd, 2.1718996734564122, places=10)
def test_monthly_table(self):
self.assertAlmostEqual(100 * s.monthlytable["Nov"][2014], -0.19540358586001005, places=5)
from unittest import TestCase
import pandas as pd
from pyutil.performance.drawdown import drawdown
from pyutil.performance.periods import period_returns, periods
from pyutil.performance.var import value_at_risk, conditional_value_at_risk
from pyutil.performance.month import monthlytable
from pyutil.performance.performance import performance
from test.config import read_series, read_frame
ts = read_series("ts.csv", parse_dates=True)
import pandas.util.testing as pdt
class TestPerformance(TestCase):
def test_periods(self):
y = period_returns(ts.pct_change(), offset=periods(ts.index[-1]))
pdt.assert_series_equal(y, read_series("periods.csv", parse_dates=False), check_names=False)
def test_drawdown(self):
pdt.assert_series_equal(drawdown(ts), read_series("drawdown.csv", parse_dates=True), check_names=False)
def test_var(self):
var = value_at_risk(ts)
cvar = conditional_value_at_risk(ts)
self.assertAlmostEqual(var, 0.0040086450047240874, places=5)
self.assertAlmostEqual(cvar, 0.0053542831745811131, places=5)
def test_table(self):
s = read_series("ts.csv", parse_dates=True)
pdt.assert_almost_equal(
monthlytable(s), read_frame("monthtable.csv", parse_dates=False))
from unittest import TestCase
from test.config import read_series
nav = read_series("nav.csv", parse_dates=True)
from pyutil.timeseries.timeseries import subsample, adjust, ytd, mtd, consecutive
import pandas as pd
import pandas.util.testing as pdt
class TestTimeseries(TestCase):
def test_subsample_index(self):
b = subsample(nav, day=15, incl=True)
print(b)
self.assertAlmostEqual(b[pd.Timestamp("2015-01-15")], 1.3028672967110184, places=5)
def test_subsample_index2(self):
b = subsample(nav, day=15, incl=True)
self.assertEqual(len(b.index),3)
def test_subsample_quarter(self):
b = subsample(nav, day=15, incl=True).index[0:-1:1]
self.assertEqual(b[1], pd.Timestamp("2015-01-15"))
def test_adjust(self):
x = adjust(nav.truncate(before="2015-01-01"))
self.assertEqual(x.ix[x.index[0]], 1.0)
def test_ytd(self):
a = ytd(nav, today=pd.Timestamp("2014-05-07"))
pdt.assert_series_equal(a, nav.truncate(before=pd.Timestamp("2014-01-01"), after=pd.Timestamp("2014-05-07")))
