Implementing component GARCH process

.gitignore

@@ -7,4 +7,18 @@ build/
 dist
 .benchmarks/
 .cache/
-README.rst
+README.rst
+*.suo
+
+/totestimports.py
+*.user
+/.vs/config/applicationhost.config
+/local_cythonrecursion.py
+/.vs/arch/v14/.suo
+*.pyproj
+*.sln
+
+/.vs/config/applicationhost.config
+.vscode/settings.json
+**/*.ipynb_checkpoints/
+

arch/tests/univariate/test_recursions.py

@@ -339,6 +339,26 @@ def test_egarch(self):
             sigma2[t] = np.exp(lnsigma2[t])
         assert_almost_equal(sigma2_python, sigma2)
 
+    def test_cgarch(self):
+        T, resids, = self.T, self.resids
+        sigma2, backcast = self.sigma2, self.backcast
+
+        parameters = np.array([0.1, 0.4, 0.75, 0.8, 0.2])
+        fresids = resids ** 2.0
+        q2 = np.ndarray(T)
+        g2 = np.ndarray(T)
+        recpy.cgarch_recursion(parameters, fresids, sigma2, backcast,
+                               self.var_bounds, g2, q2)
+        sigma2_numba = sigma2.copy()
+        recpy.cgarch_recursion_python(parameters, fresids, sigma2,
+                                      backcast, self.var_bounds, g2, q2)
+        sigma2_python = sigma2.copy()
+        rec.cgarch_recursion(parameters, fresids, sigma2, backcast,
+                             self.var_bounds, g2, q2)
+
+        assert_almost_equal(sigma2_numba, sigma2)
+        assert_almost_equal(sigma2_python, sigma2)
+
     @pytest.mark.skipif(missing_numba or missing_extension, reason='numba not installed')
     def test_garch_performance(self):
         garch_setup = """

arch/tests/univariate/test_volatility.py

@@ -10,7 +10,7 @@
 except ImportError:
     from arch.univariate import recursions_python as rec
 from arch.univariate.volatility import GARCH, ARCH, HARCH, ConstantVariance, \
-    EWMAVariance, RiskMetrics2006, EGARCH, FixedVariance
+    EWMAVariance, RiskMetrics2006, EGARCH, FixedVariance, CGARCH
 from arch.univariate.distribution import Normal, StudentsT, SkewStudent
 from arch.compat.python import range
 
@@ -91,6 +91,85 @@ def test_garch(self):
         assert_equal(garch.o, 0)
         assert_equal(garch.q, 1)
 
+    def test_cgarch(self):
+        cgarch = CGARCH()
+        sv = cgarch.starting_values(self.resids)
+        assert_equal(sv.shape[0], cgarch.num_params)
+        parameters = np.array([0.1, 0.4, 0.06, 0.8, 0.2])
+        bounds = cgarch.bounds(self.resids)
+        assert_equal(bounds[0], (0, 1))
+        assert_equal(bounds[1], (0, 1))
+        assert_equal(bounds[2], (0, 1))
+        assert_equal(bounds[3], (0.79, 1))
+        assert_equal(bounds[4], (0, 1))
+        backcast = cgarch.backcast(self.resids)
+        w = 0.94 ** np.arange(75)
+        assert_almost_equal(backcast,
+                            np.sum((self.resids[:75] ** 2) * (w / w.sum())))
+        var_bounds = cgarch.variance_bounds(self.resids)
+        cgarch.compute_variance(parameters, self.resids, self.sigma2,
+                                backcast, var_bounds)
+        cond_var_direct = np.zeros_like(self.sigma2)
+        g2 = np.ndarray(self.T)
+        q2 = g2.copy()
+        rec.cgarch_recursion(parameters,
+                             self.resids ** 2.0,
+                             cond_var_direct,
+                             backcast,
+                             var_bounds, g2, q2)
+        assert_allclose(self.sigma2, cond_var_direct)
+
+        a, b = cgarch.constraints()
+        a_target = np.array([[0, 1, 0, 0, -1], [-1, -1, 0, 1, 0], [0, 0, 0, -1, 0]])
+        b_target = np.array([0, 0, -1])
+        assert_array_equal(a, a_target)
+        assert_array_equal(b, b_target)
+        # test simulated data
+        state = np.random.get_state()
+        rng = Normal()
+        sim_data = cgarch.simulate(parameters, self.T, rng.simulate([]))
+        np.random.set_state(state)
+        e = np.random.standard_normal(self.T + 500)
+        alpha, beta, omega, rho, phi = parameters
+        converted_params = cgarch._covertparams(parameters)
+        fromgarch = converted_params[0]/(1-(np.sum(converted_params[1:])))
+        fromcg = omega/(1-rho)
+        aver = (fromcg + fromgarch)/2
+        if (aver > 0.0) and (aver < 0.2):
+            initial_value = aver
+        else:
+            initial_value = 0.1
+        sigma2 = np.zeros(self.T + 500)
+        sigma2[0] = initial_value
+        g2 = np.ndarray(self.T + 500)
+        q2 = g2.copy()
+        q2[0] = initial_value * 0.65
+        g2[0] = initial_value - q2[0]
+        data = np.zeros(self.T + 500)
+        data[0] = e[0] * np.sqrt(sigma2[0])
+
+        for i in range(1, self.T + 500):
+            g2[i] = alpha * (data[i - 1]**2 - q2[i - 1]) + beta * g2[i - 1]
+            q2[i] = omega + rho * q2[i - 1] + phi * (data[i - 1]**2 - sigma2[i - 1])
+            sigma2[i] = g2[i] + q2[i]
+            data[i] = e[i] * (np.sqrt(sigma2[i]))
+
+        data = data[500:]
+        sigma2 = sigma2[500:]
+        assert_almost_equal(data / sim_data[0], np.ones_like(data))
+        assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
+
+        names = cgarch.parameter_names()
+        names_target = ["alpha", "beta", "omega", "rho", "phi"]
+        assert_equal(names, names_target)
+
+        assert isinstance(cgarch.__str__(), str)
+
+        assert_equal(cgarch.name, 'ComponentGARCH')
+        assert_equal(cgarch.num_params, 5)
+        assert_equal(cgarch.p, 2)
+        assert_equal(cgarch.q, 2)
+
     def test_garch_power(self):
         garch = GARCH(power=1.0)
         assert_equal(garch.num_params, 3)

arch/univariate/__init__.py

@@ -1,12 +1,12 @@
 from __future__ import absolute_import
 
 from arch.univariate.mean import HARX, ConstantMean, ZeroMean, ARX, arch_model, LS
-from arch.univariate.volatility import (GARCH, ARCH, HARCH, ConstantVariance, EWMAVariance,
+from arch.univariate.volatility import (GARCH, ARCH, HARCH, CGARCH, ConstantVariance, EWMAVariance,
                                         RiskMetrics2006, EGARCH, FixedVariance)
 from arch.univariate.distribution import Distribution, Normal, StudentsT, SkewStudent
 
 __all__ = ['HARX', 'ConstantMean', 'ZeroMean', 'ARX', 'arch_model', 'LS',
-           'GARCH', 'ARCH', 'HARCH', 'ConstantVariance',
+           'GARCH', 'ARCH', 'HARCH', 'ConstantVariance', 'CGARCH',
            'EWMAVariance', 'RiskMetrics2006', 'EGARCH',
            'Distribution', 'Normal', 'StudentsT', 'SkewStudent',
            'FixedVariance']