def _calculate_volatility(self):
self.annualised_vol = get_volatility(self.returns_tms, self.frequency, annualise=True)
positive_returns_tms = self.returns_tms[self.returns_tms > 0]
negative_returns_tms = self.returns_tms[self.returns_tms < 0]
self.annualised_upside_vol = get_volatility(positive_returns_tms, self.frequency, annualise=True)
self.annualised_downside_vol = get_volatility(negative_returns_tms, self.frequency, annualise=True)
def sorino_ratio(qf_series: QFSeries,
frequency: Frequency,
risk_free: float = 0) -> float:
"""
Calculates the Sorino ratio for a given timeseries of returns.
sorino_ratio = (CAGR - risk free) / annualised downside volatility
Parameters
----------
qf_series: QFSeries
financial series
frequency: Frequency
frequency of the qf_series
risk_free: float
risk free rate
Returns
-------
float
"""
annualised_growth_rate = cagr(qf_series, frequency)
negative_returns = qf_series[qf_series < 0]
annualised_downside_vol = get_volatility(negative_returns,
frequency,
annualise=True)
ratio = (annualised_growth_rate - risk_free) / annualised_downside_vol
return ratio
def sharpe_ratio(qf_series: QFSeries,
frequency: Frequency,
risk_free: float = 0) -> float:
"""
Calculates the Sharpe Ratio for a given timeseries of returns and given frequency.
Parameters
----------
qf_series: QFSeries
financial series
frequency: Frequency
frequency of the series
risk_free: float
risk free rate
Returns
-------
float
Sharpe Ratio for given series and frequency
"""
annual_simple_return = cagr(qf_series, frequency)
annual_log_return = np.log(annual_simple_return + 1)
annual_vol = get_volatility(qf_series, frequency, annualise=True)
return (annual_log_return - risk_free) / annual_vol
def _compute_volatility(self, prices_tms) -> float:
"""Compute the annualised volatility of the last self._number_of_samples days"""
prices_tms = prices_tms.dropna().iloc[-self._number_of_samples:]
prices_tms = PricesSeries(prices_tms)
try:
volatility = get_volatility(prices_tms,
frequency=Frequency.DAILY,
annualise=True)
except (AssertionError, AttributeError):
volatility = float('nan')
return volatility
def _calculate_single_values(data_provider):
ticker = QuandlTicker('AAPL', 'WIKI')
fields = [
PriceField.Open, PriceField.High, PriceField.Low, PriceField.Close
]
prices_df = data_provider.get_price(ticker, fields, start_date, end_date)
di_vol = DriftIndependentVolatility.get_volatility(prices_df,
Frequency.DAILY)
print("drift_independent_vol = {}".format(di_vol))
close_price_tms = prices_df[PriceField.Close]
simple_vol = get_volatility(close_price_tms, Frequency.DAILY)
print("simple_vol = {}".format(simple_vol))
def rolling_volatility(qf_series: QFSeries,
frequency: Frequency = None,
annualise: bool = True,
window_size: int = None) -> QFSeries:
"""
Calculates the rolling volatility for the given series of returns. If the annualise parameter is set to be True,
then it is obligatory to specify frequency.
Parameters
----------
qf_series: QFSeries
series of returns or prices
frequency: Frequency
the frequency of samples in the returns series; it is only obligatory to specify frequency if the annualise
parameter is set to True, which is a default value
annualise: bool
True if the volatility values should be annualised; False otherwise. If it is set to True, then it is obligatory
to specify a frequency of the returns series.
window_size: int
number of samples from which the rolling volatility will be calculated. If it is not set, then only overall
volatility (of the whole series) will be calculated
Returns
-------
QFSeries
Series of volatility values for each day concerning last window_size days.
"""
returns_tms = qf_series.to_log_returns()
if annualise:
assert frequency is not None
volatility_values = []
for i in range(window_size - 1, len(returns_tms)):
start_index = i - window_size + 1
end_index = i + 1
returns_from_window = returns_tms[start_index:end_index]
volatility = get_volatility(returns_from_window, frequency, annualise)
volatility_values.append(volatility)
first_date_idx = window_size - 1
dates = returns_tms.index[first_date_idx::]
volatility_tms = QFSeries(data=volatility_values, index=dates)
return volatility_tms
def volatility_fun(window):
return get_volatility(SimpleReturnsSeries(window), self.frequency)
def volatility(window):
return get_volatility(PricesSeries(window), freq)
def volatility(window):
return get_volatility(PricesSeries(window), Frequency.DAILY)
def test_get_volatility(self):
expected_volatility = 9.513791146776931
actual_volatility = get_volatility(self.log_returns_tms, frequency=Frequency.DAILY)
self.assertAlmostEqual(expected_volatility, actual_volatility)
def volatility(window):
return get_volatility(PricesSeries(window),
Frequency.DAILY,
annualise=True)
def volatility(window):
return get_volatility(PricesSeries(window),
self.frequency,
annualise=True)
def simple_vol(close_tms):
return get_volatility(close_tms, Frequency.DAILY)