trendfollowing 1.0.4__py3-none-any.whl

trendfollowing/__init__.py

@@ -0,0 +1,37 @@
+"""
+trendfollowing: replication package for The Science and Practice of Trend-Following Systems
+reference: Sepp, A. and Lucic, V., The Science and Practice of Trend-Following Systems,
+https://ssrn.com/abstract=3167787
+"""
+__version__ = "1.0.0"
+
+from trendfollowing.analytics.filters import (span_to_nu,
+                                              compute_ewm_long_short_weights)
+from trendfollowing.analytics.autocorrelation import (population_acf,
+                                                      compute_psi_nu,
+                                                      power_autocorr)
+from trendfollowing.analytics.expected_return import (expected_pnl_white_noise,
+                                                      expected_pnl_ar1,
+                                                      expected_pnl_ma1,
+                                                      expected_pnl_arfima,
+                                                      expected_turnover)
+from trendfollowing.analytics.sharpe import (SignalMoments,
+                                             compute_signal_moments,
+                                             compute_daily_moments,
+                                             compute_annualised_sharpe,
+                                             compute_realized_sharpe,
+                                             sharpe_white_noise,
+                                             sharpe_white_noise_approx,
+                                             sharpe_ar1,
+                                             sharpe_ar1_approx,
+                                             sharpe_arfima,
+                                             expected_annual_return)
+from trendfollowing.analytics.skewness import (aggregated_third_moment_white_noise,
+                                                skewness_white_noise,
+                                                skewness_master_curve,
+                                                skewness_peak_horizon)
+
+from trendfollowing.conventions import (AF_DAILY,
+                                        PPY_QUARTERLY,
+                                        PPY_MONTHLY,
+                                        compute_daily_annualised_vol)

trendfollowing/analysis/__init__.py

@@ -0,0 +1,3 @@
+"""
+exploratory research scripts, not part of the paper exhibits
+"""

trendfollowing/analysis/autocorr_analysis.py

@@ -0,0 +1,288 @@
+"""
+empirical autocorrelation analysis of futures returns: per-instrument and
+per-group acf estimates and plots behind the autocorrelation exhibits of the paper
+reference: Sepp, A. and Lucic, V., The Science and Practice of Trend-Following Systems,
+https://ssrn.com/abstract=3167787
+"""
+# packages
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import qis as qis
+from typing import Tuple, Dict, List, Union
+from enum import Enum
+
+import qis.utils.df_groups as dfg
+import qis.utils.dates as da
+import qis.models.linear.ra_returns as tra
+import qis.plots.boxplot as box
+import qis.perfstats.returns as ret
+from qis.models.linear.auto_corr import estimate_acf_from_paths
+
+from futures_strats.data.universes.futures.bbg_futures import Universes
+from futures_strats.local_path import LOCAL_PATH
+
+
+def compute_returns_autocorrelation(prices: Union[pd.DataFrame, pd.Series],
+                                    freq: str = 'B',
+                                    span: int = 31,
+                                    autocorr_span: int = 31,
+                                    is_ra_returns: bool = False
+                                    ) -> Union[pd.DataFrame, pd.Series]:
+
+    """
+    sample acf of log returns per instrument at the given lags
+    """
+    if isinstance(prices, pd.Series):
+        prices = prices.to_frame()
+    returns_1 = qis.to_returns(prices=prices, is_log_returns=True, freq=None, drop_first=True)
+    autocorr_df = qis.ewm_xy_convolution(returns=returns_1,
+                                         freq=freq,
+                                         convolution_type=qis.ConvolutionType.AUTO_CORR,
+                                         is_ra_returns=is_ra_returns)
+    return autocorr_df
+
+
+def compute_returns_autocorrelation0(prices: Union[pd.DataFrame, pd.Series],
+                                    freq: str = 'B',
+                                    span: int = 31,
+                                    autocorr_span: int = 31,
+                                    is_ra_returns: bool = False
+                                    ) -> Union[pd.DataFrame, pd.Series]:
+    """
+    sample acf of log returns per instrument, legacy variant kept for comparison
+    """
+    if is_ra_returns:
+        returns_1 = qis.to_returns(prices=prices, is_log_returns=True, freq=None, drop_first=True)
+        returns = qis.compute_sum_freq_ra_returns(returns=returns_1, freq=freq, span=span,
+                                                  is_log_returns_to_arithmetic=False,
+                                                  is_norm=False,
+                                                  warmup_period=100)
+    else:
+        returns = qis.to_returns(prices=prices, is_log_returns=True, freq=freq, drop_first=True)
+
+    autocorr_df = qis.compute_ewm_vector_autocorr_df(data=returns,
+                                                     span=autocorr_span,
+                                                     lag=1,
+                                                     is_normalize=True)
+    return autocorr_df
+
+
+def get_prices(time_period: da.TimePeriod = None) -> Tuple[Dict, pd.Series]:
+    """
+    load the asset-class price dictionary and group metadata for the acf exhibits
+    """
+    universe_data = Universes.BBG_FUTURES.load_universe_data(local_path=LOCAL_PATH)
+    prices = universe_data.get_prices(time_period=time_period)
+    prices = prices.dropna(axis=1, how='all')
+    ac_data = universe_data.get_ac_data()[prices.columns]
+    ac_data = ac_data.apply(lambda x: x.value)
+    ac_prices = dfg.split_df_by_groups(df=prices, group_data=ac_data, total_column='Universe')
+
+    return ac_prices, ac_data
+
+
+def plot_instrument_acf(price: pd.Series,
+                        freqs: List[str] = ('B', 'W-MON', 'ME', 'QE'),
+                        ra_spans: List[int] = (2.5, 5, 21, 63),
+                        nlags: int = 20,
+                        is_ra_returns: bool = False
+                        ):
+
+    """
+    plot the sample acf and pacf bars of one instrument's returns
+    """
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(2, 2, figsize=(12, 8), tight_layout=True)
+        axs = qis.to_flat_list(axs)
+
+        for idx, freq in enumerate(freqs):
+            returns_1 = qis.to_returns(prices=price, is_log_returns=True, freq=None, drop_first=True)
+            if is_ra_returns:
+                returns = qis.compute_sum_freq_ra_returns(returns=returns_1, freq=freq, span=ra_spans[idx],
+                                                          is_log_returns_to_arithmetic=False,
+                                                          is_norm=False)
+            else:
+                returns = qis.to_returns(prices=price, is_log_returns=True, freq=freq, drop_first=True)
+
+            acfs, pacfs = qis.estimate_acf_from_path(path=returns, nlags=nlags)
+            qis.plot_bars(df=acfs,
+                          title=f"Returns frequency={freq}",
+                          legend_loc=None,
+                          x_rotation=0,
+                          xlabel='lag',
+                          ax=axs[idx])
+            ax = axs[idx]
+            n_error = 1.0 / np.sqrt(len(returns.index))
+            ax.axhline(n_error, color='red', linestyle='dashed', linewidth=1)
+            ax.axhline(-n_error, color='red', linestyle='dashed', linewidth=1)
+            qis.set_suptitle(fig, title=f"Autocorrelation of {price.name}: {qis.get_time_period(df=price).to_str()}")
+
+
+def plot_instrument_acf_ewm(prices: Union[pd.Series, pd.DataFrame],
+                            freqs: List[str] = ('B', 'W-MON', 'ME', 'QE'),
+                            ra_span: int = 31,
+                            autocorr_spans: List[int] = (10*260, 10*52, 10*12, 10*4),
+                            is_ra_returns: bool = False
+                            ):
+
+    """
+    plot the ewm-smoothed acf of instrument returns across lags
+    """
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(2, 2, figsize=(12, 8), tight_layout=True)
+        axs = qis.to_flat_list(axs)
+
+        for idx, freq in enumerate(freqs):
+            autocorr_df = compute_returns_autocorrelation(prices=prices,
+                                                          freq=freq,
+                                                          span=ra_span,
+                                                          autocorr_span=autocorr_spans[idx],
+                                                          is_ra_returns=is_ra_returns)
+            if isinstance(prices, pd.DataFrame) and len(prices.columns) > 10:
+                legend_loc = None
+            else:
+                legend_loc = 'upper left'
+            qis.plot_time_series(df=autocorr_df,
+                                 title=f"Returns frequency={freq}",
+                                 x_date_freq='YE',
+                                 date_format='%d-%b-%y',
+                                 legend_loc=legend_loc,
+                                 ax=axs[idx])
+            ax = axs[idx]
+            n_error = 1.0 / np.sqrt(autocorr_spans[idx])
+            ax.axhline(n_error, color='red', linestyle='dashed', linewidth=1)
+            ax.axhline(-n_error, color='red', linestyle='dashed', linewidth=1)
+
+
+
+def plot_group_acf_ewm(prices: pd.DataFrame,
+                       freqs: List[str] = ('B', 'W-MON', 'ME', 'QE'),
+                       ra_span: int = 31,
+                       autocorr_spans: List[int] = (10*260, 10*52, 10*12, 10*4),
+                       is_ra_returns: bool = False
+                       ) -> plt.Figure:
+
+    """
+    plot the ewm-smoothed acf aggregated by asset group
+    """
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(2, 2, figsize=(12, 8), tight_layout=True)
+        axs = qis.to_flat_list(axs)
+
+        for idx, freq in enumerate(freqs):
+            autocorr_df = compute_returns_autocorrelation(prices=prices,
+                                                          freq=freq,
+                                                          span=ra_span,
+                                                          autocorr_span=autocorr_spans[idx],
+                                                          is_ra_returns=is_ra_returns)
+            autocorr_df = autocorr_df.replace({0.0: np.nan})
+            df = pd.concat([autocorr_df.quantile(q=0.25, axis=1).rename('25% Quantile'),
+                            autocorr_df.median(axis=1).rename('Median'),
+                            autocorr_df.quantile(q=0.75, axis=1).rename('75% Quantile')], axis=1)
+
+            qis.plot_time_series(df=df,
+                                 title=f"Returns frequency={freq}",
+                                 x_date_freq='YE',
+                                 date_format='%d-%b-%y',
+                                 framealpha=0.9,
+                                 trend_line=qis.TrendLine.ZERO_SHADOWS,
+                                 ax=axs[idx])
+            ax = axs[idx]
+            n_error = 1.0 / np.sqrt(autocorr_spans[idx])
+            ax.axhline(n_error, color='red', linestyle='dashed', linewidth=1)
+            ax.axhline(-n_error, color='red', linestyle='dashed', linewidth=1)
+
+    return fig
+
+
+def plot_acf(time_period: da.TimePeriod = None):
+    ac_prices, ac_data = get_prices(time_period=time_period)
+
+    freq = 'QE'
+    ac_acfs = []
+    for ac, prices in ac_prices.items():
+        returns = ret.to_returns(prices=prices, freq=freq)
+        acfs, m_acf, std_acf = estimate_acf_from_paths(paths=returns, is_pacf=True)
+        ac_acfs.append(acfs)
+    ac_acfs = pd.concat(ac_acfs, axis=1)
+
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(1, 1, figsize=(18, 10), tight_layout=True)
+        box.df_boxplot_by_index(df=ac_acfs, ax=axs)
+
+    returns = ret.to_returns(prices=ac_prices['Universe'], freq=freq)
+    returns, weights, _ = tra.compute_ra_returns(returns=ret.to_returns(prices=ac_prices['Universe'],is_first_zero=True), ewm_lambda=0.94)
+    # returns = returns.resample('QE').sum().iloc[1:, :]
+    print(returns)
+
+    acfs, m_acf, std_acf = estimate_acf_from_paths(paths=returns, is_pacf=True, nlags=100)
+    acfs = acfs.drop(0, axis=0)
+    ac_acfs = acfs.T.dropna(axis=0, how='all')
+    ac_acfs.columns = [f"lag-{n}" for n in range(len(ac_acfs.columns))]
+    ac_acfs['ac'] = ac_data
+    ac_acfs = ac_acfs.set_index('ac')
+    print(ac_acfs)
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(1, 1, figsize=(18, 10), tight_layout=True)
+        box.df_boxplot_by_hue_var(df=ac_acfs, x_index_var_name='ac', hue_var_name='lags', ax=axs)
+
+
+class LocalTests(Enum):
+    DATA = 1
+    ACF = 2
+    INSTRUMENT_ACF = 3
+    TIME_SERIES_AUTOCORR = 4
+    GROUP_TIME_SERIES_AUTOCORR = 5
+
+
+def run_local_test(local_test: LocalTests):
+    """Run local tests for development and debugging purposes.
+
+    These are integration tests that download real data and generate reports.
+    Use for quick verification during development.
+    """
+
+    from futures_strats.local_path import LOCAL_PATH
+    universe_data = Universes.BBG_FUTURES.load_universe_data(local_path=LOCAL_PATH)
+    prices = universe_data.get_prices(freq='B').ffill()
+    time_period = da.TimePeriod('31Dec1990', None)
+    prices = time_period.locate(prices)
+
+    if local_test == LocalTests.DATA:
+        get_prices()
+
+    elif local_test == LocalTests.ACF:
+        plot_acf(time_period=time_period)
+
+    elif local_test == LocalTests.INSTRUMENT_ACF:
+        # price = prices['NI1 Index'].dropna()
+        price = prices['ES1 Index'].dropna()
+        plot_instrument_acf(price=price, is_ra_returns=False)
+
+    elif local_test == LocalTests.TIME_SERIES_AUTOCORR:
+        # price = prices['NI1 Index'].dropna()
+        # price = prices['ES1 Index'].dropna()
+        price = prices['GC1 Comdty'].dropna()
+        plot_instrument_acf_ewm(prices=price, is_ra_returns=True)
+
+    elif local_test == LocalTests.GROUP_TIME_SERIES_AUTOCORR:
+        group_data = universe_data.get_ac_data()
+        dfs = qis.split_df_by_groups(df=prices, group_data=group_data)
+        # plot_instrument_acf_ewm(prices=dfs['AcCom.EQ'], is_ra_returns=False)
+        figs = []
+        for key, df in dfs.items():
+            fig = plot_group_acf_ewm(prices=df, is_ra_returns=True)
+            qis.set_suptitle(fig, title=f"{key}")
+            figs.append(fig)
+        qis.save_figs_to_pdf(figs, file_name='group_acf', local_path=qis.get_output_path())
+
+    plt.show()
+
+
+if __name__ == '__main__':
+
+    local_test = LocalTests.TIME_SERIES_AUTOCORR
+
+run_local_test(local_test=local_test)

trendfollowing/analysis/check_vol_target.py

@@ -0,0 +1,30 @@
+"""
+numerical check of the inverse-volatility moments under gaussian returns: compares
+the monte carlo mean and variance of the reciprocal realized volatility with the
+closed-form inverse-chi moments, which quantifies the attenuation from volatility
+normalization
+reference: Sepp, A. and Lucic, V., The Science and Practice of Trend-Following Systems,
+https://ssrn.com/abstract=3167787
+"""
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import qis as qis
+from scipy.special import gamma
+
+
+if __name__ == '__main__':
+    n = 240
+    n_path = 100000
+    x = np.random.normal(0.0, 1.0, size=(n, n_path))
+    x2 = np.square(x)
+    vol_bar = 0.15
+    scale = vol_bar / np.sqrt(n)
+    vol = scale*np.sqrt(np.sum(x2, axis=0))
+    inv_vol = 1.0 / vol
+    qis.plot_histogram(df=pd.Series(inv_vol))
+    print(f"e_mc={np.mean(inv_vol)}, var_mc={np.var(inv_vol)}")
+    e_an = (1.0/scale)*np.sqrt(0.5)*gamma(n/2.0-0.5)/gamma(n/2)
+    var_an = (1.0/scale)**2/(n-2.0) - e_an**2
+    print(f"e_an={e_an}, var_an={var_an}, e_an_limit={1.0/vol_bar}")
+    plt.show()

trendfollowing/analysis/signal_plots.py

@@ -0,0 +1,200 @@
+"""
+illustration of signal plots
+"""
+import pandas as pd
+import os
+import numpy as np
+import qis as qis
+import seaborn as sns
+import matplotlib.pyplot as plt
+from typing import Optional, Dict
+from enum import Enum
+
+# my projects
+from trendfollowing.systems.backtest_utils import compute_vol_norm_returns
+from trendfollowing.systems.european import compute_tf_signal_weight, compute_tf_signal, compute_tf_strat_pnl
+
+
+def plot_vol_norm_returns(returns_dict: Dict[str, pd.Series], vol_span: int = 31) -> plt.Figure:
+    """
+    plot the volatility-normalized returns of the given instruments
+    """
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(len(returns_dict.keys()), 2, figsize=(15, 12), tight_layout=True)
+        axs = qis.to_flat_list(axs)
+        for idx, (key, returns) in enumerate(returns_dict.items()):
+            vol_norm_returns = compute_vol_norm_returns(returns=returns.to_numpy(), vol_span=vol_span)
+            vol_norm_returns = pd.Series(vol_norm_returns, index=returns.index, name=key)
+            qis.plot_time_series(df=vol_norm_returns, title=f"{key} vol normalised returns",
+                                 ax=axs[2*idx])
+            qis.plot_histogram(df=vol_norm_returns, title=f"{key} vol normalised returns",
+                               ax=axs[2*idx+1])
+    return fig
+
+
+def plot_signal(returns_dict: Dict[str, pd.Series],
+                long_span: int = 31,
+                short_span: Optional[int] = None,
+                vol_span: int = 31
+                ) -> plt.Figure:
+    """
+    plot the ewma tf signal of the given instruments
+    """
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(len(returns_dict.keys()), 2, figsize=(15, 12), tight_layout=True)
+        axs = qis.to_flat_list(axs)
+        for idx, (key, returns) in enumerate(returns_dict.items()):
+            tf_signal = compute_tf_signal(returns=returns.to_numpy(), long_span=long_span, short_span=short_span, vol_span=vol_span)
+            tf_signal = pd.Series(tf_signal, index=returns.index, name=key)
+            qis.plot_time_series(df=tf_signal, title=f"{key} signal",
+                                 ax=axs[2*idx])
+            qis.plot_histogram(df=tf_signal, title=f"{key} signal",
+                               ax=axs[2*idx+1])
+    return fig
+
+
+def plot_signal_weight(returns_dict: Dict[str, pd.Series],
+                       long_span: int = 31,
+                       short_span: Optional[int] = None,
+                       vol_span: int = 33,
+                       vol_target: float = 0.3
+                       ) -> plt.Figure:
+    """
+    plot the signal and the volatility-target weight of the given instruments
+    """
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(len(returns_dict.keys()), 2, figsize=(15, 12), tight_layout=True)
+        axs = qis.to_flat_list(axs)
+        for idx, (key, returns) in enumerate(returns_dict.items()):
+            tf_signal_weight, signals, vols = compute_tf_signal_weight(returns=returns.to_numpy(), long_span=long_span,
+                                                                       short_span=short_span, vol_span=vol_span,
+                                                                       vol_target=vol_target)
+            tf_signal_weight = pd.Series(tf_signal_weight, index=returns.index, name=key)
+            qis.plot_time_series(df=tf_signal_weight, title=f"{key} signal",
+                                 ax=axs[2*idx])
+            qis.plot_histogram(df=tf_signal_weight, title=f"{key} signal",
+                               ax=axs[2*idx+1])
+    return fig
+
+
+def plot_strat_pnl(returns_dict: Dict[str, pd.Series],
+                   long_span: int = 31,
+                   short_span: Optional[int] = None,
+                   vol_span: int = 33,
+                   vol_target: float = 0.3
+                   ) -> plt.Figure:
+    """
+    plot the strategy pnl of the given instruments under the ewma signal
+    """
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(len(returns_dict.keys()), 2, figsize=(15, 12), tight_layout=True)
+        axs = qis.to_flat_list(axs)
+        for idx, (key, returns) in enumerate(returns_dict.items()):
+            pnl, weights, vols = compute_tf_strat_pnl(returns=returns.to_numpy(), long_span=long_span, short_span=short_span,
+                                          vol_span=vol_span,
+                                          vol_target=vol_target)
+            pnl = pd.Series(pnl, index=returns.index, name=key)
+            qis.plot_time_series(df=pnl, title=f"{key} cum p&l",
+                                 ax=axs[2*idx])
+            qis.plot_histogram(df=pnl.diff(1), title=f"{key} daily p&l",
+                               ax=axs[2*idx+1])
+    return fig
+
+
+def check_filter_span(returns: pd.Series, long_span: int = 100, short_span: int = 10):
+    """
+    visual check of the single and long-short filters at the given spans on one instrument
+    """
+    long_spans = np.linspace(100, 1000, 10)
+    signals = {}
+    for long_span in long_spans:
+        signals[f"span={long_span}"] = qis.compute_ewm_long_short_filter(data=returns, long_span=long_span, short_span=None)
+    signals = pd.DataFrame.from_dict(signals, orient='columns')
+    with sns.axes_style("darkgrid"):
+        fig, ax = plt.subplots(1, 1, figsize=(15, 12), tight_layout=True)
+        qis.plot_histogram(df=signals, title='long', ax=ax)
+
+
+def check_long_short_filters(returns: pd.DataFrame, long_span: int = 100, short_span: int = 10):
+    """
+    visual check of the long-short filter combinations on a return panel
+    """
+    signal_unit = qis.compute_ewm_long_short_filter(data=returns, long_span=long_span, short_span=None)
+    signal_2 = qis.compute_ewm_long_short_filter(data=returns, long_span=long_span, short_span=short_span)
+
+    with sns.axes_style("darkgrid"):
+        fig, axs = plt.subplots(1, 2, figsize=(15, 12), tight_layout=True)
+        qis.plot_histogram(df=signal_unit, title='long', ax=axs[0])
+        qis.plot_histogram(df=signal_2, title='ls', ax=axs[1])
+
+
+class LocalTests(Enum):
+    PLOT_VOL_NORM_RETURNS = 1
+    PLOT_SIGNAL = 2
+    PLOT_SIGNAL_WEIGHT = 3
+    PLOT_PNL = 4
+    CHECK_SIGNAL = 4
+
+
+def run_local_test(local_test: LocalTests):
+    """Run local tests for development and debugging purposes.
+
+    These are integration tests that download real data and generate reports.
+    Use for quick verification during development.
+    """
+    from trendfollowing.local_path import get_universe_data_path
+    local_path = get_universe_data_path()
+
+    prices = qis.load_df_from_csv(file_name='bbg_futures_close', local_path=local_path)
+    time_period = qis.TimePeriod(start='31Dec1999', end=None)
+    prices = time_period.locate(prices)
+    returns = qis.to_returns(prices=prices)
+
+    if local_test == LocalTests.PLOT_VOL_NORM_RETURNS:
+        returns_dict = {'S&P 500': returns['ES1 Index'].dropna(), 'UST10Y': returns['TY1 Comdty'].dropna()}
+        print(returns_dict)
+        plot_vol_norm_returns(returns_dict=returns_dict)
+
+    elif local_test == LocalTests.PLOT_SIGNAL:
+        returns_dict = {'S&P 500': returns['ES1 Index'].dropna(), 'UST10Y': returns['TY1 Comdty'].dropna()}
+        print(returns_dict)
+        plot_signal(returns_dict=returns_dict,
+                    long_span=100,
+                    short_span=None,
+                    vol_span=31)
+
+    elif local_test == LocalTests.PLOT_SIGNAL_WEIGHT:
+        returns_dict = {'S&P 500': returns['ES1 Index'].dropna(), 'UST10Y': returns['TY1 Comdty'].dropna()}
+        print(returns_dict)
+        plot_signal_weight(returns_dict=returns_dict,
+                           long_span=100,
+                           short_span=None,
+                           vol_span=31)
+
+    elif local_test == LocalTests.PLOT_PNL:
+        returns_dict = {'S&P 500': returns['ES1 Index'].dropna(), 'UST10Y': returns['TY1 Comdty'].dropna()}
+        print(returns_dict)
+        plot_strat_pnl(returns_dict=returns_dict,
+                       long_span=250,
+                       short_span=20,
+                       vol_span=31)
+
+    elif local_test == LocalTests.CHECK_SIGNAL:
+
+        # signals = compute_tf_signal(returns=returns.to_numpy(), tf_span=120)
+        #signals = pd.DataFrame(signals, index=returns.index, columns=returns.columns)
+        #qis.plot_histogram(df=signals)
+
+        returns = pd.DataFrame(np.random.normal(loc=0.0, scale=0.2, size=(100000, 30)))
+        ra_returns, _, _ = qis.compute_ra_returns(returns=returns)
+        #check_long_short_filters(returns=ra_returns)
+
+        check_filter_span(returns=ra_returns.iloc[:, 0])
+    plt.show()
+
+
+if __name__ == '__main__':
+
+    local_test = LocalTests.PLOT_PNL
+
+    run_local_test(local_test=local_test)

trendfollowing/analysis/simple_backtest.py

@@ -0,0 +1,26 @@
+"""
+illustration of backtest using QuantInvestStrats (qis) reporting analytics
+"""
+import qis as qis
+from trendfollowing.systems.european import run_european_tf_system
+from trendfollowing.universe import load_data
+
+
+if __name__ == '__main__':
+    # load universe prices and volume costs
+    prices, volume_costs, benchmark_prices, descriptive_df, group_order = load_data()
+    # compute weights of the trend-following strategy
+    backtest_outputs = run_european_tf_system(prices=prices,
+                                              long_span=250,
+                                              short_span=20,
+                                              vol_span=33,
+                                              vol_target=0.0035,
+                                              portfolio_covar_span=250,
+                                              portfolio_target_vol=0.15,
+                                              volume_costs=volume_costs)
+    # compute executions of system portfolio
+    system_portfolio = qis.backtest_model_portfolio(prices=prices,
+                                                   weights=backtest_outputs.weights)
+    # generate report
+    figs = qis.generate_strategy_factsheet(portfolio_data=system_portfolio,
+                                           benchmark_prices=benchmark_prices)