diff --git a/.gitignore b/.gitignore
index 162bb2a86f..c6fb760b07 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,4 @@ dist/
 doc/build/
 doc/source/**/generated/
 arch/univariate/recursions.c
+**/.DS_Store
diff --git a/arch/covariance/kernel.py b/arch/covariance/kernel.py
index 368c7fc06d..ef39f98f8c 100644
--- a/arch/covariance/kernel.py
+++ b/arch/covariance/kernel.py
@@ -4,10 +4,10 @@
 from functools import cached_property
 from typing import SupportsInt, cast
 
-import numpy as np
 from pandas import DataFrame, Index
 from pandas.util._decorators import Substitution
 
+from arch.experimental import numpy as np
 from arch.typing import ArrayLike, Float64Array
 from arch.utility.array import AbstractDocStringInheritor, ensure1d, ensure2d
 
@@ -398,6 +398,7 @@ def cov(self) -> CovarianceEstimate:
         sr = x.T @ x / df
         w = self.kernel_weights
         num_weights = w.shape[0]
+        x = np.asarray(self._x)
         oss = np.zeros((k, k))
         for i in range(1, num_weights):
             oss += w[i] * (x[i:].T @ x[:-i]) / df
diff --git a/arch/experimental/__init__.py b/arch/experimental/__init__.py
new file mode 100644
index 0000000000..8a9c4189db
--- /dev/null
+++ b/arch/experimental/__init__.py
@@ -0,0 +1,19 @@
+from .engine import (
+    LinAlgEngine,
+    NumpyEngine,
+    backend,
+    linalg,
+    numpy,
+    set_backend,
+    use_backend,
+)
+
+__all__ = [
+    "LinAlgEngine",
+    "NumpyEngine",
+    "backend",
+    "linalg",
+    "numpy",
+    "set_backend",
+    "use_backend",
+]
diff --git a/arch/experimental/engine.py b/arch/experimental/engine.py
new file mode 100644
index 0000000000..107ae2be6c
--- /dev/null
+++ b/arch/experimental/engine.py
@@ -0,0 +1,139 @@
+from contextlib import contextmanager
+from typing import Any
+
+_BACKEND_ENGINE = "numpy"
+_SUPPORTED_ENGINES = ["numpy", "tensorflow", "cupy", "jax"]
+
+
+def backend():
+    return _BACKEND_ENGINE
+
+
+def set_backend(library_name):
+    """
+    Set backend engine.
+
+    The function sets the backend engine in global level.
+
+    Parameters
+    ----------
+    library_name : str
+        Library name. Default is `numpy`. Options are `numpy`, `tensorflow`,
+        `cupy` and `jax`.
+    """
+    library_name = library_name.lower()
+    assert library_name in _SUPPORTED_ENGINES, (
+        "Only `numpy`, `tensorflow`, `cupy` and `jax` are supported, but not "
+        f"{library_name}"
+    )
+    global _BACKEND_ENGINE
+    _BACKEND_ENGINE = library_name
+    return _BACKEND_ENGINE
+
+
+@contextmanager
+def use_backend(library_name="numpy"):
+    """
+    NumPy engine selection.
+
+    The function is a context manager to enable users to switch to a
+    specific library as a replacement of NumPy in CPU.
+
+    Parameters
+    ----------
+    library_name : str
+        Library name. Default is `numpy`. Options are `numpy`, `tensorflow`,
+        `cupy` and `jax`.
+    """
+    library_name = library_name.lower()
+    assert library_name.lower() in _SUPPORTED_ENGINES, (
+        "Only `numpy`, `tensorflow`, `cupy` and `jax` are supported, but not "
+        f"{library_name}"
+    )
+    global _BACKEND_ENGINE
+    _original = _BACKEND_ENGINE
+    try:
+        _BACKEND_ENGINE = library_name
+        if _BACKEND_ENGINE == "tensorflow":
+            import tensorflow.experimental.numpy as np
+
+            np.experimental_enable_numpy_behavior()
+        yield
+    finally:
+        _BACKEND_ENGINE = _original
+
+
+class NumpyEngine:
+    """
+    NumPy engine.
+    """
+
+    def __getattribute__(self, __name: str) -> Any:
+        if __name == "name":
+            return _BACKEND_ENGINE
+
+        try:
+            if _BACKEND_ENGINE == "numpy":
+                import numpy as anp
+            elif _BACKEND_ENGINE == "tensorflow":
+                import tensorflow.experimental.numpy as anp
+            elif _BACKEND_ENGINE == "cupy":
+                import cupy as anp
+            elif _BACKEND_ENGINE == "jax":
+                import jax.numpy as anp
+            else:
+                raise ValueError(f"Cannot recognize backend {_BACKEND_ENGINE}")
+        except ImportError:
+            raise ImportError(
+                "Library `numpy` cannot be imported from backend engine "
+                f"{_BACKEND_ENGINE}. Please make sure to install the library "
+                f"via `pip install {_BACKEND_ENGINE}`."
+            )
+
+        try:
+            return getattr(anp, __name)
+        except AttributeError:
+            raise AttributeError(
+                f"Cannot get attribute / function ({__name}) from numpy library in "
+                f"backend engine {_BACKEND_ENGINE}"
+            )
+
+
+class LinAlgEngine:
+    """
+    Linear algebra engine.
+    """
+
+    def __getattribute__(self, __name: str) -> Any:
+        if __name == "name":
+            return _BACKEND_ENGINE
+
+        try:
+            if _BACKEND_ENGINE == "numpy":
+                import numpy.linalg as alinalg
+            elif _BACKEND_ENGINE == "tensorflow":
+                import tensorflow.linalg as alinalg
+            elif _BACKEND_ENGINE == "cupy":
+                import cupy.linalg as alinalg
+            elif _BACKEND_ENGINE == "jax":
+                import jax.numpy.linalg as alinalg
+            else:
+                raise ValueError(f"Cannot recognize backend {_BACKEND_ENGINE}")
+        except ImportError:
+            raise ImportError(
+                "Library `linalg` cannot be imported from backend engine "
+                f"{_BACKEND_ENGINE}. Please make sure to install the library "
+                f"via `pip install {_BACKEND_ENGINE}`."
+            )
+
+        try:
+            return getattr(alinalg, __name)
+        except AttributeError:
+            raise AttributeError(
+                f"Cannot get attribute / function ({__name}) from linalg library in "
+                f"backend engine {_BACKEND_ENGINE}"
+            )
+
+
+numpy = NumpyEngine()
+linalg = LinAlgEngine()
diff --git a/arch/tests/experimental/test_engine.py b/arch/tests/experimental/test_engine.py
new file mode 100644
index 0000000000..430b2a2c49
--- /dev/null
+++ b/arch/tests/experimental/test_engine.py
@@ -0,0 +1,94 @@
+import pytest
+
+from arch.experimental.engine import (
+    _SUPPORTED_ENGINES,
+    backend,
+    linalg,
+    numpy,
+    set_backend,
+    use_backend,
+)
+
+
+def test_numpy_name():
+    for engine_name in _SUPPORTED_ENGINES:
+        if engine_name == "tensorflow":
+            continue
+
+        with use_backend(engine_name):
+            assert engine_name == numpy.name
+
+
+def test_linalg_name():
+    for engine_name in _SUPPORTED_ENGINES:
+        if engine_name == "tensorflow":
+            continue
+
+        with use_backend(engine_name):
+            assert engine_name == linalg.name
+
+
+def test_set_backend_eq():
+    assert set_backend(backend()) == backend()
+
+
+def test_numpy_getattribute():
+    import numpy as np
+
+    with use_backend("numpy"):
+        array = numpy.array
+        assert array == np.array
+
+
+def test_linalg_getattribute():
+    import numpy.linalg
+
+    with use_backend("numpy"):
+        inv = linalg.inv
+        assert inv == numpy.linalg.inv
+
+
+def test_numpy_getattribute_failed_attr():
+    with use_backend("numpy"):
+        with pytest.raises(AttributeError) as exc:
+            numpy.xyz  # noqa
+
+    assert str(exc.value) == (
+        "Cannot get attribute / function (xyz) from numpy library in "
+        "backend engine numpy"
+    )
+
+
+def test_linalg_getattribute_failed_attr():
+    with use_backend("numpy"):
+        with pytest.raises(AttributeError) as exc:
+            linalg.xyz  # noqa
+
+    assert str(exc.value) == (
+        "Cannot get attribute / function (xyz) from linalg library in "
+        "backend engine numpy"
+    )
+
+
+def test_numpy_getattribute_failed_import():
+    with use_backend("jax"):
+        with pytest.raises(ImportError) as exc:
+            numpy.array  # noqa
+
+    assert str(exc.value) == (
+        "Library `numpy` cannot be imported from backend engine "
+        "jax. Please make sure to install the library "
+        "via `pip install jax`."
+    )
+
+
+def test_linalg_getattribute_failed_import():
+    with use_backend("jax"):
+        with pytest.raises(ImportError) as exc:
+            linalg.inv  # noqa
+
+    assert str(exc.value) == (
+        "Library `linalg` cannot be imported from backend engine "
+        "jax. Please make sure to install the library "
+        "via `pip install jax`."
+    )
diff --git a/arch/tests/test_examples.py b/arch/tests/test_examples.py
index 1638916402..4f81ec2055 100644
--- a/arch/tests/test_examples.py
+++ b/arch/tests/test_examples.py
@@ -37,7 +37,10 @@
 except ImportError:  # pragma: no cover
     pytestmark = pytest.mark.skip(reason=REASON)
 
-SLOW_NOTEBOOKS = ["multiple-comparison_examples.ipynb"]
+SLOW_NOTEBOOKS = [
+    "multiple-comparison_examples.ipynb",
+    "experimental_accelerated_numpy.ipynb",
+]
 if bool(os.environ.get("ARCH_TEST_SLOW_NOTEBOOKS", False)):  # pragma: no cover
     SLOW_NOTEBOOKS = []
 kernel_name = "python%s" % sys.version_info.major
diff --git a/arch/unitroot/unitroot.py b/arch/unitroot/unitroot.py
index 6d1b4e33e1..a7d0d0925b 100644
--- a/arch/unitroot/unitroot.py
+++ b/arch/unitroot/unitroot.py
@@ -37,7 +37,7 @@
     squeeze,
     sum as npsum,
 )
-from numpy.linalg import LinAlgError, inv, lstsq, matrix_rank, pinv, qr, solve
+from numpy.linalg import LinAlgError, inv, lstsq, matrix_rank, pinv, solve
 from pandas import DataFrame
 from scipy.stats import norm
 from statsmodels.iolib.summary import Summary
@@ -45,6 +45,7 @@
 from statsmodels.regression.linear_model import OLS, RegressionResults
 from statsmodels.tsa.tsatools import lagmat
 
+from arch.experimental import linalg as alinalg, numpy as anp
 from arch.typing import (
     ArrayLike,
     ArrayLike1D,
@@ -337,7 +338,12 @@ def _autolag_ols(
                 max_lags=maxlag, lag=max(exog_rank - startlag, 0)
             )
         )
-    q, r = qr(exog)
+
+    endog = anp.asarray(endog)
+    exog = anp.asarray(exog)
+    q, r = alinalg.qr(exog)
+    # Convert it to 2-d so as to adapt to linalg.solve input format for all
+    # engines
     qpy = q.T @ endog
     ypy = endog.T @ endog
     xpx = exog.T @ exog
@@ -347,12 +353,12 @@ def _autolag_ols(
     nobs = float(endog.shape[0])
     tstat[0] = inf
     for i in range(startlag, startlag + maxlag + 1):
-        b = solve(r[:i, :i], qpy[:i])
-        sigma2[i - startlag] = squeeze(ypy - b.T @ xpx[:i, :i] @ b) / nobs
+        b = alinalg.solve(r[:i, :i], qpy[:i])
+        sigma2[i - startlag] = anp.squeeze(ypy - b.T @ xpx[:i, :i] @ b) / nobs
         if lower_method == "t-stat" and i > startlag:
-            xpxi = inv(xpx[:i, :i])
-            stderr = sqrt(sigma2[i - startlag] * xpxi[-1, -1])
-            tstat[i - startlag] = squeeze(b[-1]) / stderr
+            xpxi = alinalg.inv(xpx[:i, :i])
+            stderr = anp.sqrt(sigma2[i - startlag] * xpxi[-1, -1])
+            tstat[i - startlag] = anp.squeeze(b[-1]) / stderr
 
     return _select_best_ic(method, nobs, sigma2, tstat)
 
diff --git a/doc/source/experimental/accelerated_numpy.rst b/doc/source/experimental/accelerated_numpy.rst
new file mode 100644
index 0000000000..cd90fd9afd
--- /dev/null
+++ b/doc/source/experimental/accelerated_numpy.rst
@@ -0,0 +1,68 @@
+.. module:: arch.experimental.engine
+   :noindex:
+.. currentmodule:: arch.experimental.engine
+
+Accelerated NumPy
+=================
+
+The feature is to allow users to choose alternative NumPy-like engine
+to run on CPU and GPU. Currently, the following engine are supported in
+CPU and GPU runtime
+
+
+* `JAX <https://jax.readthedocs.io/en/latest/index.html#>`_
+
+* `TensorFlow <https://www.tensorflow.org/guide/tf_numpy>`_
+
+* `CuPy <https://docs.cupy.dev/en/stable/index.html>`_
+
+There are two options users can switch the backend engine.
+
+1. Context Manager
+
+Users can use function ``use_backend`` in a ``with`` statement to temporarily
+switch the NumPy engine.
+
+In the below example, assume that ``data`` object is a timeseries in NumPy array.
+The covariance estimation (NeweyWest) is computed in TensorFlow. Since the
+output is in TensorFlow Tensor type, the last line convert the long term
+covariance from Tensor to NumPy array type.
+
+.. code-block:: python
+
+    import numpy as np
+
+    from arch.experimental import use_backend
+    from arch.covariance.kernel import NeweyWest
+
+    with use_backend("tensorflow"):
+        cov = NeweyWest(data).cov
+
+    long_term_cov = np.asarray(cov.long_term)
+
+2. Global
+
+Users can also configure the backend engine in global level with function
+``set_backend``.
+
+.. code-block:: python
+
+    from arch.experimental import set_backend
+
+    set_backend("tensorflow")
+
+    # Output is already in TensorFlow Tensor type
+    long_term_cov = NeweyWest(data).cov.long_term
+
+For further examples, please refer to the example
+`notebook <experimental_accelerated_numpy.ipynb>`_.
+
+Configure
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+    use_backend
+    set_backend
+
diff --git a/doc/source/index.rst b/doc/source/index.rst
index 88627d7d1c..3e420cca63 100644
--- a/doc/source/index.rst
+++ b/doc/source/index.rst
@@ -35,6 +35,7 @@ routines relevant for the analysis of financial data.
     Multiple Comparison Problems <multiple-comparison/multiple-comparisons>
     Unit Root Tests and Cointegration Analysis <unitroot/unitroot>
     Long-run Covariance Estimation <covariance/covariance>
+    Experimental features <experimental/accelerated_numpy>
     API Reference <api>
     Change Log <changes>
 
diff --git a/examples/experimental_accelerated_numpy.ipynb b/examples/experimental_accelerated_numpy.ipynb
new file mode 100644
index 0000000000..f914122ae7
--- /dev/null
+++ b/examples/experimental_accelerated_numpy.ipynb
@@ -0,0 +1,542 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "H1doh35B3vRA"
+      },
+      "source": [
+        "# Accelerated Numpy\n",
+        "\n",
+        "The notebook demonstrates the performance in switching between various underlying\n",
+        "engine, e.g. JAX / Tensorflow, to run NumPy operations in CPU and GPU.\n",
+        "\n",
+        "In Google Colab, please follow the following steps to change to GPU runtime type\n",
+        "\n",
+        "1. Click \"Runtime\" -> \"Change runtime type\" at the top bar\n",
+        "2. Choose \"GPU\" in \"Hardware accelerator\" and \"T4\" in \"GPU type\"\n",
+        "3. Press \"Save\" button to switch runtime type"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "e2bSb8nb3vRB"
+      },
+      "source": [
+        "(Currently the functionality is only available in the feature branch `feature/tnp`)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import locale\n",
+        "locale.getpreferredencoding = lambda: \"UTF-8\""
+      ],
+      "metadata": {
+        "id": "4__UNucy4od9"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "erbuAiRs3vRC",
+        "outputId": "cd82fe2c-f538-48ca-b7e4-2ef7e1ad3369"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting git+https://github.com/gavincyi/arch.git@feature/tnp\n",
+            "  Cloning https://github.com/gavincyi/arch.git (to revision feature/tnp) to /tmp/pip-req-build-46p2j9ii\n",
+            "  Running command git clone --filter=blob:none --quiet https://github.com/gavincyi/arch.git /tmp/pip-req-build-46p2j9ii\n",
+            "  Running command git checkout -b feature/tnp --track origin/feature/tnp\n",
+            "  Switched to a new branch 'feature/tnp'\n",
+            "  Branch 'feature/tnp' set up to track remote branch 'feature/tnp' from 'origin'.\n",
+            "  Resolved https://github.com/gavincyi/arch.git to commit e57fabd8dfb4f85b53ab3202eb5eff5169f1394e\n",
+            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: numpy>=1.19 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1078+ge57fabd) (1.22.4)\n",
+            "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1078+ge57fabd) (1.10.1)\n",
+            "Requirement already satisfied: pandas>=1.1 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1078+ge57fabd) (1.5.3)\n",
+            "Requirement already satisfied: statsmodels>=0.12 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1078+ge57fabd) (0.13.5)\n",
+            "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.1->arch==0.1.dev1078+ge57fabd) (2.8.2)\n",
+            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.1->arch==0.1.dev1078+ge57fabd) (2022.7.1)\n",
+            "Requirement already satisfied: patsy>=0.5.2 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.12->arch==0.1.dev1078+ge57fabd) (0.5.3)\n",
+            "Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.12->arch==0.1.dev1078+ge57fabd) (23.1)\n",
+            "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from patsy>=0.5.2->statsmodels>=0.12->arch==0.1.dev1078+ge57fabd) (1.16.0)\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install git+https://github.com/gavincyi/arch.git@feature/tnp"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "Rhuk-ebE3vRC"
+      },
+      "outputs": [],
+      "source": [
+        "%load_ext autoreload\n",
+        "%autoreload 2"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "gn_T2Wf_3vRC"
+      },
+      "outputs": [],
+      "source": [
+        "from typing import Tuple\n",
+        "from time import time\n",
+        "import warnings\n",
+        "\n",
+        "import pandas as pd\n",
+        "\n",
+        "from arch.experimental.engine import use_backend\n",
+        "from arch.covariance.kernel import NeweyWest\n",
+        "from arch.typing import ArrayLike\n",
+        "from arch.unitroot import ADF\n",
+        "\n",
+        "warnings.filterwarnings(\"ignore\", category=UserWarning)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "S7pe1H2Ste8O"
+      },
+      "source": [
+        "# Engines\n",
+        "\n",
+        "If the CUDA library is installed with physical GPU, the below cell will return the\n",
+        "following output.\n",
+        "\n",
+        "```\n",
+        "Supported engines: numpy, tensorflow, jax, cupy\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HGRbhqtRte8O",
+        "outputId": "2724269f-5c84-4f8d-f842-020772a12476"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Supported engines: numpy, tensorflow, jax, cupy\n"
+          ]
+        }
+      ],
+      "source": [
+        "ENGINES = [\"numpy\", \"tensorflow\", \"jax\"]\n",
+        "\n",
+        "try:\n",
+        "    import tensorflow.test\n",
+        "    if len(tensorflow.config.list_physical_devices(\"GPU\")):\n",
+        "        ENGINES.append(\"cupy\")\n",
+        "except ImportError:\n",
+        "    raise ImportError(\"Tensorflow should be installed\")\n",
+        "\n",
+        "print(f\"Supported engines: {', '.join(ENGINES)}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "UJORee683vRD"
+      },
+      "source": [
+        "# Covariance\n",
+        "\n",
+        "The following benchmarks measure the average runtime of covariance computation.\n",
+        "\n",
+        "We will measure the runtime performance on 1-d and 2-d arrays.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "AMpUvdsu3vRE"
+      },
+      "outputs": [],
+      "source": [
+        "def cov_get_data(size: Tuple[int, ...], burn: int = 500, use_pandas: bool = False) -> ArrayLike:\n",
+        "    import numpy as np\n",
+        "    rs = np.random.RandomState([3894830, 432841, 323297, 8927821])\n",
+        "    e = rs.standard_normal(size)\n",
+        "    ndim = len(size)\n",
+        "    if ndim == 1:\n",
+        "        phi = rs.uniform(0, 0.9, 1)\n",
+        "        for i in range(1, size[0]):\n",
+        "            e[i] += e[i - 1] * phi\n",
+        "    else:\n",
+        "        phi = np.diag(rs.uniform(0, 0.9, size[1]))\n",
+        "        for i in range(1, size[0]):\n",
+        "            e[i] += e[i - 1] @ phi\n",
+        "    e = e[burn:]\n",
+        "    if use_pandas:\n",
+        "        if ndim == 1:\n",
+        "            return pd.Series(e, name=\"x\")\n",
+        "        else:\n",
+        "            return pd.DataFrame(e, columns=[f\"x{i}\" for i in range(e.shape[1])])\n",
+        "    return e"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "id": "m2GuzwHD3vRE"
+      },
+      "outputs": [],
+      "source": [
+        "def cov_timeit(\n",
+        "    library: str,\n",
+        "    size: Tuple[int, ...] = (5000, ),\n",
+        "    estimator: object = NeweyWest,\n",
+        "    use_pandas: bool = False\n",
+        "):\n",
+        "    import numpy as np\n",
+        "    data = cov_get_data(size, use_pandas=use_pandas)\n",
+        "\n",
+        "    def _func():\n",
+        "        cov = estimator(data).cov.long_run\n",
+        "        if library == \"cupy\":\n",
+        "            cov = cov.get()\n",
+        "        if not use_pandas:\n",
+        "            # Force to convert back to numpy array\n",
+        "            cov = np.asarray(cov)\n",
+        "        return cov\n",
+        "\n",
+        "    with use_backend(library):\n",
+        "        # Warm start (e.g. JAX to compile the function first) and\n",
+        "        # estimate the runtime to determine the total number of runs\n",
+        "        start = time()\n",
+        "        cov = estimator(data).cov\n",
+        "        end = time()\n",
+        "        elapsed = end - start\n",
+        "\n",
+        "        # Generally the total runtime should not be more than 10s\n",
+        "        if elapsed < 0.01:\n",
+        "            n_run = 1000\n",
+        "        elif elapsed < 0.1:\n",
+        "            n_run = 100\n",
+        "        elif elapsed < 1.0:\n",
+        "            n_run = 10\n",
+        "        else:\n",
+        "            n_run = 1\n",
+        "\n",
+        "        # Get total runtime\n",
+        "        runtimes = [0.0] * n_run\n",
+        "        for index in range(n_run):\n",
+        "            start = time()\n",
+        "            ret = _func()\n",
+        "            end = time()\n",
+        "            runtimes[index] = end - start\n",
+        "\n",
+        "    return 1000 * np.percentile(runtimes, 90), n_run, ret\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FXaw2b-cte8Q"
+      },
+      "source": [
+        "First, we measure the runtimes on covariance computation on 1-d array of size\n",
+        "from 1000 to 7500.\n",
+        "\n",
+        "For 1-d array, even with GPU activated, the NumPy still produces the best performance."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 490
+        },
+        "id": "wSPb40Nc3vRE",
+        "outputId": "f19fbc36-4d52-47ac-d078-ace76f2d840b"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Text(0, 0.5, 'Runtime (ms)')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 8
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "runtimes_1d = {}\n",
+        "\n",
+        "for library in ENGINES:\n",
+        "    runtimes_1d[library] = {}\n",
+        "    for dim in [1000, 2000, 3000, 4000, 5000, 7500]:\n",
+        "        runtime = cov_timeit(library=library, size=(dim,))\n",
+        "        runtimes_1d[library][dim] = runtime[0]\n",
+        "\n",
+        "ax = pd.DataFrame(runtimes_1d).plot(title=\"90% percentile runtime for covariance from 1-d array\")\n",
+        "ax.set_xlabel(\"Array size\")\n",
+        "ax.set_ylabel(\"Runtime (ms)\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "SVN1ryaWte8Q"
+      },
+      "source": [
+        "For 2-d array, we measure the runtimes of covariance computation on matrix\n",
+        "with size (5000, N), where N ranges from 100 to 1000.\n",
+        "\n",
+        "With GPU availability, the engines running on GPU runtime perform much better than\n",
+        "NumPy compatible only on CPU runtime."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 490
+        },
+        "id": "nC2W8YtE3vRE",
+        "outputId": "d7c11dec-73d8-4c9c-e2f3-14f980325713"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Text(0, 0.5, 'Runtime (ms)')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 9
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "runtimes_2d = {}\n",
+        "\n",
+        "for library in ENGINES:\n",
+        "    runtimes_2d[library] = {}\n",
+        "    for dim in [100, 200, 300, 400, 500, 750]:\n",
+        "        runtime = cov_timeit(library=library, size=(5000, dim))\n",
+        "        runtimes_2d[library][dim] = runtime[0]\n",
+        "\n",
+        "ax = pd.DataFrame(runtimes_2d).plot(title=\"90% percentile runtime for covariance from 2-d array (5000, N)\")\n",
+        "ax.set_xlabel(\"Size (N)\")\n",
+        "ax.set_ylabel(\"Runtime (ms)\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "SCwiobb7te8Q"
+      },
+      "source": [
+        "# Unitroot"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "id": "ucxcOyMgte8Q"
+      },
+      "outputs": [],
+      "source": [
+        "def unitroot_get_data(size: int):\n",
+        "    import numpy as np\n",
+        "    rnd = np.random.RandomState(12345)\n",
+        "    return np.cumsum(rnd.standard_normal(size))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "id": "DdOesd7Mte8R"
+      },
+      "outputs": [],
+      "source": [
+        "def unitroot_timeit(\n",
+        "    library: str,\n",
+        "    size: int,\n",
+        "    estimator: object = ADF,\n",
+        "):\n",
+        "    import numpy as np\n",
+        "    data = unitroot_get_data(size)\n",
+        "\n",
+        "    def _func():\n",
+        "        return estimator(data).summary()\n",
+        "\n",
+        "    with use_backend(library):\n",
+        "        # Warm start (e.g. JAX to compile the function first) and\n",
+        "        # estimate the runtime to determine the total number of runs\n",
+        "        start = time()\n",
+        "        _func()\n",
+        "        end = time()\n",
+        "        elapsed = end - start\n",
+        "\n",
+        "        # Generally the total runtime should not be more than 10s\n",
+        "        if elapsed < 0.001:\n",
+        "            n_run = 10000\n",
+        "        elif elapsed < 0.01:\n",
+        "            n_run = 1000\n",
+        "        elif elapsed < 0.1:\n",
+        "            n_run = 100\n",
+        "        elif elapsed < 1.0:\n",
+        "            n_run = 10\n",
+        "        else:\n",
+        "            n_run = 1\n",
+        "\n",
+        "        # Get total runtime\n",
+        "        runtimes = [0.0] * n_run\n",
+        "        for index in range(n_run):\n",
+        "            start = time()\n",
+        "            ret = _func()\n",
+        "            end = time()\n",
+        "            runtimes[index] = end - start\n",
+        "\n",
+        "    # Output: time in ms, number of runs and estimation result\n",
+        "    return 1000 * np.percentile(runtimes, 90), n_run, ret\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 490
+        },
+        "id": "XdPgU4Y1te8R",
+        "outputId": "5824a70e-c46c-4d4e-ff72-e35e8705f7bc"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Text(0, 0.5, 'Runtime (ms)')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 12
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "runtimes = {}\n",
+        "\n",
+        "for library in ENGINES:\n",
+        "    if library == \"cupy\":\n",
+        "        continue\n",
+        "\n",
+        "    runtimes[library] = {}\n",
+        "    for dim in [1000, 2000, 3000, 4000, 5000, 7500, 10000]:\n",
+        "        runtime = unitroot_timeit(library=library, size=dim)\n",
+        "        runtimes[library][dim] = runtime[0]\n",
+        "\n",
+        "ax = pd.DataFrame(runtimes).plot(title=\"90% percentile runtime for unitroot\")\n",
+        "ax.set_xlabel(\"Array size\")\n",
+        "ax.set_ylabel(\"Runtime (ms)\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "id": "N25CSEyXte8R"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.9"
+    },
+    "orig_nbformat": 4
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file