PythonTsa 1.5.3__tar.gz

pythontsa-1.5.3/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: PythonTsa
+Version: 1.5.3
+Summary: Package for Applied Time Series Analysis and Forecasting with Python, Springer 2022
+Home-page: https://github.com/QuantLet/pyTSA
+Author: Changquan Huang
+Author-email: h.changquan@icloud.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+This package is a companion to the book  Applied Time Series Analysis and Forecasting with Python, Springer 2022. 
+
+It contains several  key Python functions for analyzing time series and most data sets analyzed in the book. Naturally, these functions can also be used to analyze other time series data.
+

pythontsa-1.5.3/README.md

@@ -0,0 +1,4 @@
+This package is a companion to the book  Applied Time Series Analysis and Forecasting with Python, Springer 2022. 
+
+It contains several  key Python functions for analyzing time series and most data sets analyzed in the book. Naturally, these functions can also be used to analyze other time series data.
+

pythontsa-1.5.3/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = [ "setuptools>=42",  "wheel"]
+build-backend = "setuptools.build_meta"

pythontsa-1.5.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pythontsa-1.5.3/setup.py

@@ -0,0 +1,24 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name ="PythonTsa",
+    version ="1.5.3",
+    author ="Changquan Huang",
+    author_email="h.changquan@icloud.com",
+    description ="Package for Applied Time Series Analysis and Forecasting with Python, Springer 2022",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url = "https://github.com/QuantLet/pyTSA", 
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    python_requires=">=3.6",
+    package_data={'PythonTsa': ['Ptsadata/*.csv', 'Ptsadata/*.txt', 'Ptsadata/*.xlsx',  'Ptsadata/*.dat']}
+)

pythontsa-1.5.3/src/PythonTsa/CheckStationarynInvertible.py

@@ -0,0 +1,38 @@
+import numpy as np
+
+def isstationary(armaProcess):
+        """
+        Arma process is stationary if AR roots are outside unit circle.
+
+        Returns
+        -------
+        bool
+             True if AR roots all are outside unit circle.
+        """
+        narroots=armaProcess.arroots.shape[0]
+        arrts=armaProcess.arroots
+        for t in range(narroots):
+            arrts[t]=float("%.6f" % abs(arrts[t]))
+        if np.all(arrts > 1.0):
+            return True
+        else:
+            return False
+
+
+def isinvertible(armaProcess):
+        """
+        Arma process is invertible if MA roots are outside unit circle.
+
+        Returns
+        -------
+        bool
+             True if MA roots all are outside unit circle.
+        """
+        nmaroots=armaProcess.maroots.shape[0]
+        marts=armaProcess.maroots
+        for t in range(nmaroots):
+            marts[t]=float("%.6f" % abs(marts[t]))
+        if np.all(marts > 1.0):
+            return True
+        else:
+            return False

pythontsa-1.5.3/src/PythonTsa/CointegrationTest.py

@@ -0,0 +1,533 @@
+"""
+Cointegration test for time series 
+"""
+from statsmodels.compat.numpy import lstsq
+from statsmodels.compat.pandas import deprecate_kwarg
+from statsmodels.compat.python import lrange, lzip
+from statsmodels.compat.scipy import _next_regular
+
+import warnings
+
+import numpy as np
+from numpy.linalg import LinAlgError
+import pandas as pd
+from scipy import stats
+#import matplotlib.pyplot as plt
+
+from statsmodels.regression.linear_model import OLS, yule_walker
+from statsmodels.tools.sm_exceptions import (
+    CollinearityWarning,
+    InfeasibleTestError,
+    InterpolationWarning,
+    MissingDataError,
+)
+from statsmodels.tools.tools import Bunch, add_constant
+from statsmodels.tools.validation import (
+    array_like,
+    bool_like,
+    dict_like,
+    float_like,
+    int_like,
+    string_like,
+)
+#from statsmodels.tsa._bds import bds
+#from statsmodels.tsa._innovations import innovations_algo, innovations_filter
+from statsmodels.tsa.adfvalues import mackinnoncrit, mackinnonp
+#from statsmodels.tsa.arima_model import ARMA
+from statsmodels.tsa.tsatools import add_trend, lagmat, lagmat2ds
+
+__all__ = [
+    "acovf",
+    "acf",
+    "pacf",
+    "pacf_yw",
+    "pacf_ols",
+    "ccovf",
+    "ccf",
+    "q_stat",
+    "coint",
+    "arma_order_select_ic",
+    "adfuller",
+    "kpss",
+    "bds",
+    "pacf_burg",
+    "innovations_algo",
+    "innovations_filter",
+    "levinson_durbin_pacf",
+    "levinson_durbin",
+    "zivot_andrews",
+]
+
+SQRTEPS = np.sqrt(np.finfo(np.double).eps)
+
+
+def _autolag(
+    mod,
+    endog,
+    exog,
+    startlag,
+    maxlag,
+    method,
+    modargs=(),
+    fitargs=(),
+    regresults=False,
+):
+    """
+    Returns the results for the lag length that maximizes the info criterion.
+
+    Parameters
+    ----------
+    mod : Model class
+        Model estimator class
+    endog : array_like
+        nobs array containing endogenous variable
+    exog : array_like
+        nobs by (startlag + maxlag) array containing lags and possibly other
+        variables
+    startlag : int
+        The first zero-indexed column to hold a lag.  See Notes.
+    maxlag : int
+        The highest lag order for lag length selection.
+    method : {"aic", "bic", "t-stat"}
+        aic - Akaike Information Criterion
+        bic - Bayes Information Criterion
+        t-stat - Based on last lag
+    modargs : tuple, optional
+        args to pass to model.  See notes.
+    fitargs : tuple, optional
+        args to pass to fit.  See notes.
+    regresults : bool, optional
+        Flag indicating to return optional return results
+
+    Returns
+    -------
+    icbest : float
+        Best information criteria.
+    bestlag : int
+        The lag length that maximizes the information criterion.
+    results : dict, optional
+        Dictionary containing all estimation results
+
+    Notes
+    -----
+    Does estimation like mod(endog, exog[:,:i], *modargs).fit(*fitargs)
+    where i goes from lagstart to lagstart+maxlag+1.  Therefore, lags are
+    assumed to be in contiguous columns from low to high lag length with
+    the highest lag in the last column.
+    """
+    # TODO: can tcol be replaced by maxlag + 2?
+    # TODO: This could be changed to laggedRHS and exog keyword arguments if
+    #    this will be more general.
+
+    results = {}
+    method = method.lower()
+    for lag in range(startlag, startlag + maxlag + 1):
+        mod_instance = mod(endog, exog[:, :lag], *modargs)
+        results[lag] = mod_instance.fit()
+
+    if method == "aic":
+        icbest, bestlag = min((v.aic, k) for k, v in results.items())
+    elif method == "bic":
+        icbest, bestlag = min((v.bic, k) for k, v in results.items())
+    elif method == "t-stat":
+        # stop = stats.norm.ppf(.95)
+        stop = 1.6448536269514722
+        # Default values to ensure that always set
+        bestlag = startlag + maxlag
+        icbest = 0.0
+        for lag in range(startlag + maxlag, startlag - 1, -1):
+            icbest = np.abs(results[lag].tvalues[-1])
+            bestlag = lag
+            if np.abs(icbest) >= stop:
+                # Break for first lag with a significant t-stat
+                break
+    else:
+        raise ValueError(f"Information Criterion {method} not understood.")
+
+    if not regresults:
+        return icbest, bestlag
+    else:
+        return icbest, bestlag, results
+
+
+# this needs to be converted to a class like HetGoldfeldQuandt,
+# 3 different returns are a mess
+# See:
+# Ng and Perron(2001), Lag length selection and the construction of unit root
+# tests with good size and power, Econometrica, Vol 69 (6) pp 1519-1554
+# TODO: include drift keyword, only valid with regression == "c"
+# just changes the distribution of the test statistic to a t distribution
+# TODO: autolag is untested
+def adfuller(
+    x,
+    maxlag=None,
+    regression="c",
+    autolag="AIC",
+    store=False,
+    regresults=False,
+):
+    """
+    Augmented Dickey-Fuller unit root test.
+
+    The Augmented Dickey-Fuller test can be used to test for a unit root in a
+    univariate process in the presence of serial correlation.
+
+    Parameters
+    ----------
+    x : array_like, 1d
+        The data series to test.
+    maxlag : int
+        Maximum lag which is included in test, default 12*(nobs/100)^{1/4}.
+    regression : {"c","ct","ctt","nc"}
+        Constant and trend order to include in regression.
+
+        * "c" : constant only (default).
+        * "ct" : constant and trend.
+        * "ctt" : constant, and linear and quadratic trend.
+        * "nc" : no constant, no trend.
+
+    autolag : {"AIC", "BIC", "t-stat", None}
+        Method to use when automatically determining the lag length among the
+        values 0, 1, ..., maxlag.
+
+        * If "AIC" (default) or "BIC", then the number of lags is chosen
+          to minimize the corresponding information criterion.
+        * "t-stat" based choice of maxlag.  Starts with maxlag and drops a
+          lag until the t-statistic on the last lag length is significant
+          using a 5%-sized test.
+        * If None, then the number of included lags is set to maxlag.
+    store : bool
+        If True, then a result instance is returned additionally to
+        the adf statistic. Default is False.
+    regresults : bool, optional
+        If True, the full regression results are returned. Default is False.
+
+    Returns
+    -------
+    adf : float
+        The test statistic.
+    pvalue : float
+        MacKinnon"s approximate p-value based on MacKinnon (1994, 2010).
+    usedlag : int
+        The number of lags used.
+    nobs : int
+        The number of observations used for the ADF regression and calculation
+        of the critical values.
+    critical values : dict
+        Critical values for the test statistic at the 1 %, 5 %, and 10 %
+        levels. Based on MacKinnon (2010).
+    icbest : float
+        The maximized information criterion if autolag is not None.
+    resstore : ResultStore, optional
+        A dummy class with results attached as attributes.
+
+    Notes
+    -----
+    The null hypothesis of the Augmented Dickey-Fuller is that there is a unit
+    root, with the alternative that there is no unit root. If the pvalue is
+    above a critical size, then we cannot reject that there is a unit root.
+
+    The p-values are obtained through regression surface approximation from
+    MacKinnon 1994, but using the updated 2010 tables. If the p-value is close
+    to significant, then the critical values should be used to judge whether
+    to reject the null.
+
+    The autolag option and maxlag for it are described in Greene.
+
+    References
+    ----------
+    .. [1] W. Green.  "Econometric Analysis," 5th ed., Pearson, 2003.
+
+    .. [2] Hamilton, J.D.  "Time Series Analysis".  Princeton, 1994.
+
+    .. [3] MacKinnon, J.G. 1994.  "Approximate asymptotic distribution functions for
+        unit-root and cointegration tests.  `Journal of Business and Economic
+        Statistics` 12, 167-76.
+
+    .. [4] MacKinnon, J.G. 2010. "Critical Values for Cointegration Tests."  Queen"s
+        University, Dept of Economics, Working Papers.  Available at
+        http://ideas.repec.org/p/qed/wpaper/1227.html
+
+    Examples
+    --------
+    See example notebook
+    """
+    x = array_like(x, "x")
+    maxlag = int_like(maxlag, "maxlag", optional=True)
+    regression = string_like(
+        regression, "regression", options=("c", "ct", "ctt", "nc")
+    )
+    autolag = string_like(
+        autolag, "autolag", optional=True, options=("aic", "bic", "t-stat")
+    )
+    store = bool_like(store, "store")
+    regresults = bool_like(regresults, "regresults")
+
+    if regresults:
+        store = True
+
+    trenddict = {None: "nc", 0: "c", 1: "ct", 2: "ctt"}
+    if regression is None or isinstance(regression, int):
+        regression = trenddict[regression]
+    regression = regression.lower()
+    nobs = x.shape[0]
+
+    ntrend = len(regression) if regression != "nc" else 0
+    if maxlag is None:
+        # from Greene referencing Schwert 1989
+        maxlag = int(np.ceil(12.0 * np.power(nobs / 100.0, 1 / 4.0)))
+        # -1 for the diff
+        maxlag = min(nobs // 2 - ntrend - 1, maxlag)
+        if maxlag < 0:
+            raise ValueError(
+                "sample size is too short to use selected "
+                "regression component"
+            )
+    elif maxlag > nobs // 2 - ntrend - 1:
+        raise ValueError(
+            "maxlag must be less than (nobs/2 - 1 - ntrend) "
+            "where n trend is the number of included "
+            "deterministic regressors"
+        )
+    xdiff = np.diff(x)
+    xdall = lagmat(xdiff[:, None], maxlag, trim="both", original="in")
+    nobs = xdall.shape[0]
+
+    xdall[:, 0] = x[-nobs - 1 : -1]  # replace 0 xdiff with level of x
+    xdshort = xdiff[-nobs:]
+
+    if store:
+        from statsmodels.stats.diagnostic import ResultsStore
+
+        resstore = ResultsStore()
+    if autolag:
+        if regression != "nc":
+            fullRHS = add_trend(xdall, regression, prepend=True)
+        else:
+            fullRHS = xdall
+        startlag = fullRHS.shape[1] - xdall.shape[1] + 1
+        # 1 for level
+        # search for lag length with smallest information criteria
+        # Note: use the same number of observations to have comparable IC
+        # aic and bic: smaller is better
+
+        if not regresults:
+            icbest, bestlag = _autolag(
+                OLS, xdshort, fullRHS, startlag, maxlag, autolag
+            )
+        else:
+            icbest, bestlag, alres = _autolag(
+                OLS,
+                xdshort,
+                fullRHS,
+                startlag,
+                maxlag,
+                autolag,
+                regresults=regresults,
+            )
+            resstore.autolag_results = alres
+
+        bestlag -= startlag  # convert to lag not column index
+
+        # rerun ols with best autolag
+        xdall = lagmat(xdiff[:, None], bestlag, trim="both", original="in")
+        nobs = xdall.shape[0]
+        xdall[:, 0] = x[-nobs - 1 : -1]  # replace 0 xdiff with level of x
+        xdshort = xdiff[-nobs:]
+        usedlag = bestlag
+    else:
+        usedlag = maxlag
+        icbest = None
+    if regression != "nc":
+        resols = OLS(
+            xdshort, add_trend(xdall[:, : usedlag + 1], regression)
+        ).fit()
+    else:
+        resols = OLS(xdshort, xdall[:, : usedlag + 1]).fit()
+
+    adfstat = resols.tvalues[0]
+    #    adfstat = (resols.params[0]-1.0)/resols.bse[0]
+    # the "asymptotically correct" z statistic is obtained as
+    # nobs/(1-np.sum(resols.params[1:-(trendorder+1)])) (resols.params[0] - 1)
+    # I think this is the statistic that is used for series that are integrated
+    # for orders higher than I(1), ie., not ADF but cointegration tests.
+
+    # Get approx p-value and critical values
+    pvalue = mackinnonp(adfstat, regression=regression, N=1)
+    critvalues = mackinnoncrit(N=1, regression=regression, nobs=nobs)
+    critvalues = {
+        "1%": critvalues[0],
+        "5%": critvalues[1],
+        "10%": critvalues[2],
+    }
+    if store:
+        resstore.resols = resols
+        resstore.maxlag = maxlag
+        resstore.usedlag = usedlag
+        resstore.adfstat = adfstat
+        resstore.critvalues = critvalues
+        resstore.nobs = nobs
+        resstore.H0 = (
+            "The coefficient on the lagged level equals 1 - " "unit root"
+        )
+        resstore.HA = "The coefficient on the lagged level < 1 - stationary"
+        resstore.icbest = icbest
+        resstore._str = "Augmented Dickey-Fuller Test Results"
+        return adfstat, pvalue, critvalues, resstore
+    else:
+        if not autolag:
+            return adfstat, pvalue, usedlag, nobs, critvalues
+        else:
+            return adfstat, pvalue, usedlag, nobs, critvalues, icbest
+
+
+def cointest(
+    y0,
+    y1,
+    trend="c",
+    method="aeg",
+    maxlag=None,
+    autolag="aic",
+    return_results=None
+):
+    """
+    Test for no-cointegration of a univariate equation.
+
+    The null hypothesis is no cointegration. Variables in y0 and y1 are
+    assumed to be integrated of order 1, I(1).
+
+    This uses the augmented Engle-Granger two-step cointegration test.
+    Constant or trend is included in 1st stage regression, i.e. in
+    cointegrating equation.
+
+    **Warning:** The autolag default has changed compared to statsmodels 0.8.
+    In 0.8 autolag was always None, no the keyword is used and defaults to
+    "aic". Use `autolag=None` to avoid the lag search.
+
+    Parameters
+    ----------
+    y0 : array_like
+        The first element in cointegrated system. Must be 1-d.
+    y1 : array_like
+        The remaining elements in cointegrated system.
+    trend : str {"c", "ct"}
+        The trend term included in regression for cointegrating equation.
+
+        * "c" : constant.
+        * "ct" : constant and linear trend.
+        * also available quadratic trend "ctt", and no constant "nc".
+
+    method : {"aeg"}
+        Only "aeg" (augmented Engle-Granger) is available.
+    maxlag : None or int
+        Argument for `adfuller`, largest or given number of lags.
+    autolag : str
+        Argument for `adfuller`, lag selection criterion.
+
+        * If None, then maxlag lags are used without lag search.
+        * If "AIC" (default) or "BIC", then the number of lags is chosen
+          to minimize the corresponding information criterion.
+        * "t-stat" based choice of maxlag.  Starts with maxlag and drops a
+          lag until the t-statistic on the last lag length is significant
+          using a 5%-sized test.
+    return_results : bool
+        For future compatibility, currently only tuple available.
+        If True, then a results instance is returned. Otherwise, a tuple
+        with the test outcome is returned. Set `return_results=False` to
+        avoid future changes in return.
+    fig : bool
+       If 'True', plot the regression residuals 
+
+    Returns
+    -------
+    coint_t : float
+        The t-statistic of unit-root test on residuals.
+    pvalue : float
+        MacKinnon"s approximate, asymptotic p-value based on MacKinnon (1994).
+    crit_value : dict
+        Critical values for the test statistic at the 1 %, 5 %, and 10 %
+        levels based on regression curve. This depends on the number of
+        observations.
+
+    Notes
+    -----
+    The Null hypothesis is that there is no cointegration, the alternative
+    hypothesis is that there is cointegrating relationship. If the pvalue is
+    small, below a critical size, then we can reject the hypothesis that there
+    is no cointegrating relationship.
+
+    P-values and critical values are obtained through regression surface
+    approximation from MacKinnon 1994 and 2010.
+
+    If the two series are almost perfectly collinear, then computing the
+    test is numerically unstable. However, the two series will be cointegrated
+    under the maintained assumption that they are integrated. In this case
+    the t-statistic will be set to -inf and the pvalue to zero.
+
+    TODO: We could handle gaps in data by dropping rows with nans in the
+    Auxiliary regressions. Not implemented yet, currently assumes no nans
+    and no gaps in time series.
+
+    References
+    ----------
+    .. [1] MacKinnon, J.G. 1994  "Approximate Asymptotic Distribution Functions
+       for Unit-Root and Cointegration Tests." Journal of Business & Economics
+       Statistics, 12.2, 167-76.
+    .. [2] MacKinnon, J.G. 2010.  "Critical Values for Cointegration Tests."
+       Queen"s University, Dept of Economics Working Papers 1227.
+       http://ideas.repec.org/p/qed/wpaper/1227.html
+    """
+    y0 = array_like(y0, "y0")
+    y1 = array_like(y1, "y1", ndim=2)
+    trend = string_like(trend, "trend", options=("c", "nc", "ct", "ctt"))
+    method = string_like(method, "method", options=("aeg",))
+    maxlag = int_like(maxlag, "maxlag", optional=True)
+    autolag = string_like(
+        autolag, "autolag", optional=True, options=("aic", "bic", "t-stat")
+    )
+    return_results = bool_like(return_results, "return_results", optional=True)
+
+    nobs, k_vars = y1.shape
+    k_vars += 1  # add 1 for y0
+
+    if trend == "nc":
+        xx = y1
+    else:
+        xx = add_trend(y1, trend=trend, prepend=False)
+
+    res_co = OLS(y0, xx).fit()
+
+    if res_co.rsquared < 1 - 100 * SQRTEPS:
+        res_adf = adfuller(
+            res_co.resid, maxlag=maxlag, autolag=autolag, regression="nc"
+        )
+    else:
+        warnings.warn(
+            "y0 and y1 are (almost) perfectly colinear."
+            "Cointegration test is not reliable in this case.",
+            CollinearityWarning,
+        )
+        # Edge case where series are too similar
+        res_adf = (-np.inf,)
+
+    # no constant or trend, see egranger in Stata and MacKinnon
+    if trend == "nc":
+        crit = [np.nan] * 3  # 2010 critical values not available
+    else:
+        crit = mackinnoncrit(N=k_vars, regression=trend, nobs=nobs - 1)
+        #  nobs - 1, the -1 is to match egranger in Stata, I do not know why.
+        #  TODO: check nobs or df = nobs - k
+        
+    pval_asy = mackinnonp(res_adf[0], regression=trend, N=k_vars)
+
+    print ('Results of Augmented Engle-Granger Two-step Cointegration Test:')
+    print('Test Statistic   ', res_adf[0])
+    print('P-value  ', pval_asy)
+    a1='%6f'%crit[0]
+    b1='%6f'%crit[1]
+    c1='%6f'%crit[2]
+    print('Critical values: ', a1, '(1%) ' , b1,  '(5%) ', c1, '(10%)')
+    residts=pd.Series(res_co.resid)
+    return  residts
+
+