macroshock 0.1.0__py3-none-any.whl

macroshock/__init__.py

@@ -0,0 +1 @@
+from .macroshock import SVAR

macroshock/bootstrap.py

@@ -0,0 +1,259 @@
+# bootstrap.py
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy.linalg import solve_triangular
+from .var import estimate_var
+from .fc import compute_forecast
+
+
+def bootstrap_svar(model, typ: str, shock: int = 1):
+    """
+    Replica la lógica original de SVAR.Bootstrap, pero fuera de la clase.
+
+    Parameters
+    ----------
+    model : objeto tipo SVAR
+        Debe tener los mismos atributos que usaba el método Bootstrap original.
+    typ : {'IR', 'FC'}
+        Tipo de bootstrap: IRFs o Forecasts.
+    shock : int
+        Índice (1-based) del shock para IRFs.
+
+    Returns
+    -------
+    draws : dict[str, np.ndarray]
+        Diccionario {variable: draws} con shape:
+        - IR: (reps, steps)
+        - FC: (reps, past + horizon)
+    """
+    # BEGIN BOOTSTRAP
+    b = 0
+
+    if typ == "IR":
+        draws = {var: np.zeros((model.reps, model.steps)) for var in model.variables}
+    elif typ == "FC":
+        draws = {
+            var: np.zeros((model.reps, model.past + model.horizon))
+            for var in model.variables
+        }
+    else:
+        raise ValueError("typ must be 'IR' or 'FC'.")
+
+    while True:
+        # progreso
+        if b in list(
+            range(int(model.reps / 10) - 1, model.reps, int(model.reps / 10))
+        ):
+            print(str(b + 1) + "/" + str(model.reps))
+
+        # ---------- tipo de remuestreo ----------
+        if model.resampling == 1:  # normal
+            resampled_resid = model.resid.copy()
+            for i in range(model.n_obs):
+                rnd = np.random.randint(0, model.n_obs)
+                resampled_resid[i] = model.resid[rnd]
+        elif model.resampling == 2:  # wild
+            rsigns = np.random.choice([-1, 1], size=model.resid.shape[0])
+            # Nota: igual que el código original, esto modifica model.resid en sitio
+            resampled_resid = model.resid
+            for i in range(model.resid.shape[0]):
+                resampled_resid[i, :] = model.resid[i, :] * rsigns[i]
+        else:
+            raise ValueError("resampling must be 1 (normal) or 2 (wild).")
+
+        # ---------- condición inicial para recursión hacia adelante ----------
+        Y_sim = model.Y.copy()
+        Y_0 = np.zeros((model.n_vars * model.lags,))
+
+        for i in range(model.lags):
+            Y_0[i * model.n_vars : (i + 1) * model.n_vars] = model.data[
+                model.lags - i - 1, :
+            ]
+
+        # ---------- generar datos simulados ----------
+        for i in range(model.n_obs):
+            u = np.zeros((model.n_vars * model.lags,))
+            u[0 : model.n_vars] = resampled_resid[i]
+
+            if model.const == 0:
+                FY_0 = model.F @ Y_0
+                Y_0 = FY_0 + u
+            elif model.const == 1:
+                beta_const = np.zeros((model.n_vars * model.lags,))
+                beta_const[0 : model.n_vars] = model.beta[:, 0]
+                FY_0 = model.F @ Y_0
+                Y_0 = beta_const + FY_0 + u
+            elif model.const == 2:
+                beta_const = np.zeros((model.n_vars * model.lags,))
+                beta_const[0 : model.n_vars] = model.beta[:, 0]
+                beta_trend = np.zeros((model.n_vars * model.lags,))
+                beta_trend[0 : model.n_vars] = model.beta[:, 1]
+                FY_0 = model.F @ Y_0
+                Y_0 = beta_const + ((i + model.lags) * beta_trend) + FY_0 + u
+            elif model.const == 3:
+                beta_const = np.zeros((model.n_vars * model.lags,))
+                beta_const[0 : model.n_vars] = model.beta[:, 0]
+                beta_trend = np.zeros((model.n_vars * model.lags,))
+                beta_trend[0 : model.n_vars] = model.beta[:, 1]
+                beta_sqrd = np.zeros((model.n_vars * model.lags,))
+                beta_sqrd[0 : model.n_vars] = model.beta[:, 2]
+                FY_0 = model.F @ Y_0
+                Y_0 = (
+                    beta_const
+                    + (i * beta_trend)
+                    + ((i**2) * beta_sqrd)
+                    + FY_0
+                    + u
+                )
+
+            if model.DUM is not None:
+                Y_0[0 : model.n_vars] = Y_0[0 : model.n_vars] + model.beta[
+                    :,
+                    model.const
+                    + (model.n_vars * model.lags)
+                    + model.n_ex : model.const
+                    + (model.n_vars * model.lags)
+                    + model.n_ex
+                    + model.n_dum,
+                ] @ model.D[i, :]
+
+            Y_sim[i] = Y_0[0 : model.n_vars]
+
+        Y_sim = np.vstack([model.data[0 : model.lags, :], Y_sim])
+
+        # ---------- remuestreo del instrumento (método IV) ----------
+        if model.method == "IV":
+            iv = model.z
+            if model.resampling == 2 and model.iv is not None:
+                for i in range(model.n_iv):
+                    for j in range(len(iv[i])):
+                        iv[i][j] = iv[i][j] * rsigns[-len(iv[i]) :][j]
+
+        # ---------- construir Ysim y Xsim ----------
+        Ysim = Y_sim[model.lags :]
+        Xsim_list = []
+
+        for i in range(model.lags):
+            Xsim_list.append(
+                Y_sim[(model.lags - i - 1) : model.n_obs + model.lags - i - 1]
+            )
+        Xsim = np.hstack(Xsim_list)
+
+        if model.const == 1:
+            Xsim = np.hstack([np.ones((model.n_obs, 1)), Xsim])
+        elif model.const == 2:
+            trend = np.arange(1, model.n_obs + 1).reshape(-1, 1)
+            Xsim = np.hstack([np.ones((model.n_obs - model.lags, 1)), trend, Xsim])
+        elif model.const == 3:
+            trend = np.arange(1, model.n_obs + 1).reshape(-1, 1)
+            Xsim = np.hstack(
+                [np.ones((model.n_obs, 1)), trend, trend**2, Xsim]
+            )
+
+        if model.EXOGdata is not None:
+            if len(model.EXOG) == model.n_obs:
+                Xsim_exog = model.EXOGdata
+            else:
+                Xsim_exog = model.EXOGdata[-model.n_obs :]
+                if len(Xsim_exog) != model.n_obs:
+                    print("Exogenous variables in different domain")
+            Xsim = np.hstack([Xsim, Xsim_exog])
+
+        if model.DUM is not None:
+            Xsim = np.hstack([Xsim, model.D[: model.n_obs, :]])
+
+        # ---------- asegurar shapes ----------
+        if isinstance(Ysim, pd.Series):
+            Ysim = Ysim.values.reshape(-1, 1)
+        if isinstance(Xsim, pd.Series):
+            Xsim = Xsim.values.reshape(-1, 1)
+
+        Ysim = Ysim.reshape(-1, 1) if Ysim.ndim == 1 else Ysim
+        Xsim = Xsim.reshape(-1, 1) if Xsim.ndim == 1 else Xsim
+
+        Xsim = np.array(Xsim, dtype=float)
+        Ysim = np.array(Ysim, dtype=float)
+
+        # ---------- estimar VAR simulado ----------
+        simres=estimate_var(Ysim, Xsim, model.R)
+        
+        XXsim = Xsim.T @ Xsim
+        XXsim_inv = np.linalg.inv(XXsim)
+        betasim = simres.beta
+        sigma_usim = simres.sigma_u
+        residsim = simres.resid
+    
+        beta_stdsim = np.zeros((model.n_vars, model.n_cols))
+        for i in range(model.n_vars):
+            beta_stdsim[i, :] = np.sqrt(
+                np.diagonal(sigma_usim[i, i] * XXsim_inv)
+            )
+
+        # ---------- construir Fsim ----------
+        topsim = betasim[:, -(model.n_vars * model.lags) :]
+        bottomsim = np.zeros(
+            ((model.lags - 1) * model.n_vars, model.lags * model.n_vars)
+        )
+        for i in range((model.lags - 1) * model.n_vars):
+            bottomsim[i, i] = 1
+        Fsim = np.vstack([topsim, bottomsim])
+
+        # ---------- identificar Bsim ----------
+        if model.method == "short":
+            Bsim = np.linalg.cholesky(sigma_usim)
+
+        elif model.method == "long":
+            M1 = np.eye(model.n_vars)
+            for k in range(model.lags):
+                M1 = M1 - Fsim[
+                    0 : model.n_vars, k * model.n_vars : (k + 1) * model.n_vars
+                ]
+            M1 = np.linalg.inv(M1)
+            D = np.linalg.cholesky(M1 @ sigma_usim @ M1.T)
+            Bsim = np.linalg.solve(M1, D)
+
+        elif model.method == "IV":
+            usim = residsim
+            for j in range(model.n_iv):
+                XX_invfssim = (np.var(iv[j])) ** (-1)
+                betafssim = XX_invfssim * (iv[j].T @ usim[-len(iv[j]) :, j])
+                ujhatsim = iv[j] * betafssim
+                Bsim = np.zeros((model.n_vars, model.n_vars))
+                Bsim[j, j] = 1
+                for i in range(model.n_vars):
+                    XX_invsssim = (np.var(ujhatsim)) ** (-1)
+                    if i != j:
+                        betasssim = XX_invsssim * (
+                            ujhatsim.T.T @ usim[-len(iv[j]) :, i]
+                        )
+                        Bsim[i, j] = betasssim
+                Csim = np.linalg.cholesky(sigma_usim)
+                q = solve_triangular(Csim, Bsim[:, j], lower=True)
+                vsim = np.linalg.norm(q)
+                # vsim = np.linalg.norm(Csim[:,j])
+                Bsim[:, j] = Bsim[:, j] / vsim
+
+        # ---------- almacenar draws ----------
+        if typ == "IR":
+            ir_b = model.IR(Bsim, Fsim, shock)
+
+            if np.any(Bsim != 0):
+                if model.method in ("short", "long", "IV"):
+                    for k in range(model.n_vars):
+                        draws[model.variables[k]][b, :] = ir_b[:, k]
+                    b += 1
+
+        if typ == "FC":
+            fc_b = compute_forecast(model, Fsim)
+            if np.any(Bsim != 0):
+                if model.method in ("short", "long", "IV"):
+                    for k in range(model.n_vars):
+                        draws[model.variables[k]][b, :] = fc_b[:, k]
+                    b += 1
+
+        if b >= model.reps:
+            break
+
+    return draws

macroshock/data.py

@@ -0,0 +1,111 @@
+#data.py
+
+import numpy as np
+import pandas as pd
+from dataclasses import dataclass
+
+@dataclass
+class YXR:
+    Y: np.ndarray
+    X: np.ndarray
+    R: np.ndarray
+
+def YX(model) -> YXR:
+    
+    model.n_obs, _ = model.data.shape
+
+    Y = model.data[model.lags:,:]
+    X = []
+
+    for i in range(model.lags):
+        X.append(model.data[(model.lags-i-1) : model.n_obs - model.lags + (model.lags-i-1),:])
+    X = np.hstack(X)
+    
+    if model.const == 1:
+        X = np.hstack([np.ones((model.n_obs - model.lags, 1)), X])
+    elif model.const == 2:
+        trend = np.arange(1, model.n_obs - model.lags + 1).reshape(-1, 1)
+        X = np.hstack([np.ones((model.n_obs - model.lags, 1)), trend, X])
+    elif model.const == 3:
+        trend = np.arange(1, model.n_obs - model.lags + 1).reshape(-1, 1)
+        X = np.hstack([np.ones((model.n_obs - model.lags, 1)), trend, trend**2, X])
+    
+    model.n_obs, _ = X.shape
+    
+    if model.EXOGdata is not None:
+        if model.n_obsex==model.n_obs:
+            X_exog=model.EXOGdata
+        else:
+            X_exog=model.EXOGdata[-model.n_obs:]
+            if len(X_exog)!=model.n_obs:
+                print('Exogenous variables in different domain')
+        X=np.hstack([X,X_exog])
+        
+    if model.DUM is not None:
+        if model.DUM=='Q':
+            model.dummies=['Q'+f"{i+1}" for i in range(4)]
+            model.n_dum=3
+            model.D=np.zeros((model.n_obs+model.horizon,4))
+            for j in range(model.n_obs+model.horizon):
+                for x in range(4):
+                    if j in range(x,model.n_obs+model.horizon,4):
+                        model.D[j,x]=1
+        if model.DUM=='M':
+            model.dummies=['M'+f"{i+1}" for i in range(12)]
+            model.n_dum=11
+            model.D=np.zeros((model.n_obs+model.horizon,12))
+            for j in range(model.n_obs+model.horizon):
+                for x in range(12):
+                    if j in range(x,model.n_obs+model.horizon,12):
+                        model.D[j,x]=1
+        model.D=model.D[:,:model.n_dum]
+        model.Dhorizon=model.D[model.n_obs:model.n_obs+model.horizon,:]
+        X=np.hstack([X,model.D[0:model.n_obs,:]])
+    else:
+        model.n_dum=0
+
+    model.Y=Y
+    model.X=X
+    
+    if isinstance(model.Y, pd.Series):
+        model.Y=model.Y.values.reshape(-1, 1)
+    if isinstance(model.X, pd.Series):
+        model.X=model.X.values.reshape(-1, 1)
+        
+    model.Y = model.Y.reshape(-1, 1) if model.Y.ndim == 1 else model.Y
+    model.X = model.X.reshape(-1, 1) if model.X.ndim == 1 else model.X
+    
+    _ , model.n_vars=model.Y.shape
+    model.n_obs, model.n_cols= model.X.shape
+    
+    model.X = np.array(model.X, dtype=float)
+    model.Y = np.array(model.Y, dtype=float)
+    
+    if model.restrictions is None:
+        model.R=np.eye(model.n_cols*model.n_vars)
+        
+    elif model.restrictions=='zeros':
+        RR=np.eye(model.n_cols*model.n_vars)
+        drop=[]
+        
+        for i in range(model.n_vars):
+            for j in range(model.n_vars):
+                if model.R[i][j]==0:
+                    for k in range(model.lags):
+                        drop.append(model.const*model.n_vars+i+(model.n_vars*j)+(k*model.n_vars*model.n_vars))
+        
+        model.R=np.delete(RR, drop, axis=1)
+                    
+    elif model.restrictions=='custom zeros':
+        RR=model.R.ravel(order='F')
+        RRR=np.eye(len(RR))
+        drop=[]
+        
+        for i in range(len(RR)):
+            if RR[i]==0:
+                drop.append(i)
+                
+        model.R=np.delete(RRR, drop, axis=1)
+        
+    return YXR(Y=model.Y, X=model.X, R=model.R)
+

macroshock/fc.py

@@ -0,0 +1,68 @@
+#fc.py
+import numpy as np
+
+def compute_forecast(modelo, F):
+    
+    # 1. Initialize State Vector (start)
+    start = np.zeros((modelo.n_vars * modelo.lags, 1))
+    for i in range(modelo.lags):
+        # Stacking lags: y_t, y_{t-1}, ...
+        start[i*modelo.n_vars : (i+1)*modelo.n_vars, :] = \
+            modelo.Y[modelo.n_obs - i - 1, :].reshape(-1, 1)
+    
+    # 2. Initialize Forecast Array
+    Yfc = np.zeros((modelo.horizon + modelo.past, modelo.n_vars))
+    Yfc[0:modelo.past, :] = modelo.Y[-modelo.past:, :]
+    
+    # 3. Pre-compute Deterministic Vectors (Optimization)
+    # Moving this outside the loop prevents creating new arrays 120 times
+    beta_const = np.zeros((modelo.n_vars * modelo.lags, 1))
+    beta_trend = np.zeros((modelo.n_vars * modelo.lags, 1))
+    beta_sqrd  = np.zeros((modelo.n_vars * modelo.lags, 1))
+    
+    if modelo.const >= 1:
+        beta_const[0:modelo.n_vars, 0] = modelo.beta[:, 0]
+    if modelo.const >= 2:
+        beta_trend[0:modelo.n_vars, 0] = modelo.beta[:, 1]
+    if modelo.const == 3:
+        beta_sqrd[0:modelo.n_vars, 0]  = modelo.beta[:, 2]
+
+    # 4. Forecast Loop
+    for i in range(modelo.horizon):
+        
+        # A. Transition Step
+        FYs = F @ start
+        
+        # B. Add Deterministic Terms (Const, Trend, etc)
+        # Note: Ensure your trend logic (i + lags) matches your estimation definition
+        if modelo.const == 1:
+            FYs += beta_const
+        elif modelo.const == 2:
+            FYs += beta_const + ((i + modelo.lags) * beta_trend)
+        elif modelo.const == 3:
+            FYs += beta_const + (i * beta_trend) + ((i**2) * beta_sqrd)
+            
+        # C. Add Dummies (if present)
+        if modelo.DUM is not None:
+            # Calculate dummy index offset for readability
+            idx_start = modelo.const + (modelo.lags * modelo.n_vars) + modelo.n_ex
+            
+            if modelo.DUM == 'Q':
+                dummy_coefs = modelo.beta[:, idx_start : idx_start+3]
+                dummy_vals  = modelo.Dhorizon[i, :].reshape(-1, 1)
+                FYs[0:modelo.n_vars, :] += dummy_coefs @ dummy_vals
+                
+            elif modelo.DUM == 'M':
+                dummy_coefs = modelo.beta[:, idx_start : idx_start+11]
+                dummy_vals  = modelo.Dhorizon[i, :].reshape(-1, 1)
+                FYs[0:modelo.n_vars, :] += dummy_coefs @ dummy_vals
+
+        # D. Store Forecast (THE FIX)
+        # We take the first 'n_vars' rows from the 'FYs' column vector
+        # and flatten them to fit into the Yfc row.
+        Yfc[modelo.past + i, :] = FYs[0:modelo.n_vars, 0]
+        
+        # E. Update state for next iteration
+        start = FYs
+
+    return Yfc