macroshock 0.2.0__tar.gz → 0.2.2__tar.gz

{macroshock-0.2.0/src/macroshock.egg-info → macroshock-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: macroshock
-Version: 0.2.0
+Version: 0.2.2
 Summary: Powerful time series econometrics for Structural Vector Autoregressions (SVAR)
 Author-email: Patricio Arias <patoariaslopez2@gmail.com>
 License: MIT License
@@ -41,13 +41,13 @@ Dynamic: license-file
 
 ## Main Features
 
-* **Restricted VAR estimation** (Lütkepohl-style GLS), with support for:
+* - **Restricted VAR estimation** (Lütkepohl-style GLS), with support for:
 
   - Constant, trend and quadratic trend.
   - Exogenous variables.
   - Seasonal dummies (quarterly or monthly).
   - Linear restrictions on the coefficients (`restrictions='zeros'` or `'custom zeros'`).
-* **Four structural identification methods**:
+* - **Four structural identification methods**:
 
 |Method|Description|
 |-|-|
@@ -56,12 +56,12 @@ Dynamic: license-file
 |`signs`|Sign restrictions (orthogonal rotation sampling with acceptance/rejection)|
 |`IV`|Instrumental variable identification (proxy-SVAR)|
 
-* **Impulse-response functions (IRF)** with confidence bands.
-* **Forecast error variance decomposition (FEVD)**.
-* **Conditional forecasts** with confidence bands.
-* **Bootstrap** (normal or *wild* resampling) for inference.
-* **Built-in plots** for IRF, forecasts and FEVD, publication-ready.
-* **Stability test** of the system (characteristic polynomial roots).
+* - **Impulse-response functions (IRF)** with confidence bands.
+* - **Forecast error variance decomposition (FEVD)**.
+* - **Conditional forecasts** with confidence bands.
+* - **Bootstrap** (normal or *wild* resampling) for inference.
+* - **Built-in plots** for IRF, forecasts and FEVD, publication-ready.
+* - **Stability test** of the system (characteristic polynomial roots).
 
 ## Installation
 
@@ -96,7 +96,7 @@ model = SVAR(
     horizon=8,         # forecast horizon
     past=12,           # past periods to show in the forecast
     alpha=32,          # confidence interval level (32 -> 68% central band)
-    reps\_default=1000, # bootstrap replications
+    reps=1000, # bootstrap replications
 )
 
 # Runs the complete pipeline: Y/X construction, VAR estimation,
@@ -116,13 +116,13 @@ model.S()                # identifies the structural system (matrix B)
 model.summary()          # prints the estimation summary
 
 # Impulse response to shock 1, with "pair" bands (low/high percentile)
-ir = model.ImpulseResponse(shock=1, show=True, bands="pair")
+ir = model.ImpulseResponse(1, show=True, bands="pair")
 
 # Forecast with "many" bands (multiple stacked confidence levels)
 fc = model.Forecast(show=True, bands="many")
 
-# Forecast error variance decomposition for shock 1
-vd = model.VarianceDecomp(shock=1, show=True)
+# Forecast error variance decomposition for variable 1
+vd = model.VarianceDecomp(1, show=True)
 ```
 
 Each of these methods returns a dictionary with the point estimate and confidence bands at different levels (`'point'`, `'low'`, `'high'`, `2.5`, `5`, `95`, `97.5`, `0.5`, `99.5`), indexed by variable name.
@@ -143,7 +143,7 @@ By default it uses the Cholesky decomposition. If `matrix\_short` is passed (a b
 model = SVAR(data=df, variables=variables, lags=4, method="long")
 ```
 
-By default it uses the Cholesky decomposition. If `matrix\_short` is passed (a binary matrix of 1s and 0s), the `B` matrix satisfying the indicated zero restrictions is solved numerically.
+By default it uses the Cholesky decomposition. If `matrix\_long` is passed (a binary matrix of 1s and 0s), the `B` matrix satisfying the indicated zero restrictions is solved numerically.
 
 ### 3\. Sign restrictions
 
@@ -157,7 +157,7 @@ model = SVAR(
     method="signs",
     matrix\_signs=matrix\_signs,
     steps\_signs=4,       # horizons over which signs are checked
-    reps\_default=1000,   # number of accepted B matrices
+    reps=1000,   # number of accepted B matrices
 )
 ```
 

{macroshock-0.2.0 → macroshock-0.2.2}/README.md

@@ -4,13 +4,13 @@
 
 ## Main Features
 
-* **Restricted VAR estimation** (Lütkepohl-style GLS), with support for:
+* - **Restricted VAR estimation** (Lütkepohl-style GLS), with support for:
 
   - Constant, trend and quadratic trend.
   - Exogenous variables.
   - Seasonal dummies (quarterly or monthly).
   - Linear restrictions on the coefficients (`restrictions='zeros'` or `'custom zeros'`).
-* **Four structural identification methods**:
+* - **Four structural identification methods**:
 
 |Method|Description|
 |-|-|
@@ -19,12 +19,12 @@
 |`signs`|Sign restrictions (orthogonal rotation sampling with acceptance/rejection)|
 |`IV`|Instrumental variable identification (proxy-SVAR)|
 
-* **Impulse-response functions (IRF)** with confidence bands.
-* **Forecast error variance decomposition (FEVD)**.
-* **Conditional forecasts** with confidence bands.
-* **Bootstrap** (normal or *wild* resampling) for inference.
-* **Built-in plots** for IRF, forecasts and FEVD, publication-ready.
-* **Stability test** of the system (characteristic polynomial roots).
+* - **Impulse-response functions (IRF)** with confidence bands.
+* - **Forecast error variance decomposition (FEVD)**.
+* - **Conditional forecasts** with confidence bands.
+* - **Bootstrap** (normal or *wild* resampling) for inference.
+* - **Built-in plots** for IRF, forecasts and FEVD, publication-ready.
+* - **Stability test** of the system (characteristic polynomial roots).
 
 ## Installation
 
@@ -59,7 +59,7 @@ model = SVAR(
     horizon=8,         # forecast horizon
     past=12,           # past periods to show in the forecast
     alpha=32,          # confidence interval level (32 -> 68% central band)
-    reps\_default=1000, # bootstrap replications
+    reps=1000, # bootstrap replications
 )
 
 # Runs the complete pipeline: Y/X construction, VAR estimation,
@@ -79,13 +79,13 @@ model.S()                # identifies the structural system (matrix B)
 model.summary()          # prints the estimation summary
 
 # Impulse response to shock 1, with "pair" bands (low/high percentile)
-ir = model.ImpulseResponse(shock=1, show=True, bands="pair")
+ir = model.ImpulseResponse(1, show=True, bands="pair")
 
 # Forecast with "many" bands (multiple stacked confidence levels)
 fc = model.Forecast(show=True, bands="many")
 
-# Forecast error variance decomposition for shock 1
-vd = model.VarianceDecomp(shock=1, show=True)
+# Forecast error variance decomposition for variable 1
+vd = model.VarianceDecomp(1, show=True)
 ```
 
 Each of these methods returns a dictionary with the point estimate and confidence bands at different levels (`'point'`, `'low'`, `'high'`, `2.5`, `5`, `95`, `97.5`, `0.5`, `99.5`), indexed by variable name.
@@ -106,7 +106,7 @@ By default it uses the Cholesky decomposition. If `matrix\_short` is passed (a b
 model = SVAR(data=df, variables=variables, lags=4, method="long")
 ```
 
-By default it uses the Cholesky decomposition. If `matrix\_short` is passed (a binary matrix of 1s and 0s), the `B` matrix satisfying the indicated zero restrictions is solved numerically.
+By default it uses the Cholesky decomposition. If `matrix\_long` is passed (a binary matrix of 1s and 0s), the `B` matrix satisfying the indicated zero restrictions is solved numerically.
 
 ### 3\. Sign restrictions
 
@@ -120,7 +120,7 @@ model = SVAR(
     method="signs",
     matrix\_signs=matrix\_signs,
     steps\_signs=4,       # horizons over which signs are checked
-    reps\_default=1000,   # number of accepted B matrices
+    reps=1000,   # number of accepted B matrices
 )
 ```
 

{macroshock-0.2.0 → macroshock-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "macroshock"
-version = "0.2.0"
+version = "0.2.2"
 requires-python = ">=3.10"
 dependencies = [
     "numpy>=1.24.0",

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/bootstrap.py

@@ -10,7 +10,7 @@ from .fc import compute_forecast
 from .fevd import forecast_error_variance_decomposition
 
 
-def bootstrap_svar(model, typ: str, shock: int = 1, reps: int = 0):
+def bootstrap_svar(model, typ: str, shock: int = 1, reps: int = 100, impact: float = 1.0, steps: int = 30, horizon: int = 5, past: int = 24):
     """
     Replica la lógica original de SVAR.Bootstrap, pero fuera de la clase.
 
@@ -30,19 +30,19 @@ def bootstrap_svar(model, typ: str, shock: int = 1, reps: int = 0):
         - IR: (reps, steps)
         - FC: (reps, past + horizon)
     """
+    if model.method == 'signs':
+        raise ValueError("No bootstrap in sign restriction SVAR")
     
-    if reps == 0:
-        reps = model.reps_default
     
     # BEGIN BOOTSTRAP
     b = 0
 
     if typ == "IR":
-        draws = {var: np.zeros((reps, model.steps)) for var in model.variables}
+        draws = {var: np.zeros((reps, steps)) for var in model.variables}
     elif typ == "FC":
-        draws = {var: np.zeros((reps, model.past + model.horizon)) for var in model.variables}
+        draws = {var: np.zeros((reps, past + horizon)) for var in model.variables}
     elif typ == "VD":
-        draws = {var: np.zeros((reps, model.steps)) for var in model.variables}
+        draws = {var: np.zeros((reps, steps)) for var in model.variables}
     else:
         raise ValueError("typ must be 'IR', 'FC' or 'VD'.")
 
@@ -157,11 +157,11 @@ def bootstrap_svar(model, typ: str, shock: int = 1, reps: int = 0):
                 [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
+        if model.data_exogenous is not None:
+            if len(model.variables_exogenous) == model.n_obs:
+                Xsim_exog = model.data_exogenous
             else:
-                Xsim_exog = model.EXOGdata[-model.n_obs :]
+                Xsim_exog = model.data_exogenous[-model.n_obs :]
                 if len(Xsim_exog) != model.n_obs:
                     print("Exogenous variables in different domain")
             Xsim = np.hstack([Xsim, Xsim_exog])
@@ -242,7 +242,7 @@ def bootstrap_svar(model, typ: str, shock: int = 1, reps: int = 0):
 
         # ---------- almacenar draws ----------
         if typ == "IR":
-            ir_b = impulse_response(Bsim, Fsim, shock, steps=model.steps, impact=model.impact)
+            ir_b = impulse_response(Bsim, Fsim, shock, steps=steps, impact=impact)
         
             if np.any(Bsim != 0):
                 if model.method in ("short", "long", "IV"):
@@ -260,7 +260,7 @@ def bootstrap_svar(model, typ: str, shock: int = 1, reps: int = 0):
         
         if typ == "VD":
             vd_dict = forecast_error_variance_decomposition(
-                Bsim, Fsim, steps=model.steps
+                Bsim, Fsim, steps=steps
             )
             if np.any(Bsim != 0):
                 if model.method in ("short", "long", "IV"):

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/data.py

@@ -32,11 +32,11 @@ def YX(model) -> YXR:
     
     model.n_obs, _ = X.shape
     
-    if model.EXOGdata is not None:
+    if model.data_exogenous is not None:
         if model.n_obsex==model.n_obs:
-            X_exog=model.EXOGdata
+            X_exog=model.data_exogenous
         else:
-            X_exog=model.EXOGdata[-model.n_obs:]
+            X_exog=model.data_exogenous[-model.n_obs:]
             if len(X_exog)!=model.n_obs:
                 print('Exogenous variables in different domain')
         X=np.hstack([X,X_exog])
@@ -107,4 +107,5 @@ def YX(model) -> YXR:
                 
         model.R=np.delete(RRR, drop, axis=1)
         
-    return YXR(Y=model.Y, X=model.X, R=model.R)
+    return YXR(Y=model.Y, X=model.X, R=model.R)
+

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/fc.py

@@ -38,7 +38,7 @@ def compute_forecast(modelo, F):
         if modelo.const == 1:
             FYs += beta_const
         elif modelo.const == 2:
-            FYs += beta_const + ((i + modelo.lags) * beta_trend)
+            FYs += beta_const + (i * beta_trend)
         elif modelo.const == 3:
             FYs += beta_const + (i * beta_trend) + ((i**2) * beta_sqrd)
             

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/fevd.py

@@ -34,16 +34,15 @@ def forecast_error_variance_decomposition(
 
     n_vars = B.shape[0]
 
-    # 1. Pre-calculate Orthogonalized Impulse Responses for all horizons
+    # 1. Pre-calculate Orthogonalized Impulse Responses for all horizons.
+    # Accumulate F^h incrementally (F^h = F^(h-1) @ F) instead of calling
+    # np.linalg.matrix_power(F, h) from scratch at every horizon.
     theta = np.zeros((steps, n_vars, n_vars))
+    F_power = np.eye(F.shape[0])  # F^0
     for h in range(steps):
-        if h == 0:
-            F_power = np.eye(F.shape[0])
-        else:
-            F_power = np.linalg.matrix_power(F, h)
-
         Psi_h = F_power[:n_vars, :n_vars]
         theta[h] = Psi_h @ B
+        F_power = F_power @ F  # advance to F^(h+1) for the next iteration
 
     # 2. Calculate Variance Decomposition per variable
     VD = {}

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/identification.py

@@ -250,7 +250,7 @@ def identify_signs(
                     FEVDL[k1 + 1].append(vd_check)
 
                     m_accepted += 1
-                    if m_accepted in list(range(100, reps + 1, 100)):
+                    if m_accepted in list(range(0+reps//10, reps + 1, reps//10)):
                         print(f"{m_accepted}/{reps}")
         else:
             n_rejected += 1
@@ -265,37 +265,75 @@ def identify_signs(
                 "=============================="
             )
             B_zero = np.zeros((n_vars, n_vars))
+
+            # Same key set as the successful path below (ir_* and vd_*,
+            # zero-filled with the right shape) so SVAR.S() can always
+            # unpack 'extra' the same way, whether or not sampling aborted.
+            ir_stats = _zero_stat_dicts(steps, n_vars, extra_percentiles=True)
+            vd_stats = _zero_stat_dicts(steps, n_vars, extra_percentiles=False)
+
+            extra = {
+                "IRL": IRL,
+                "MB": MB,
+                "ir_median": ir_stats["median"],
+                "ir_mean": ir_stats["mean"],
+                "ir_high": ir_stats["high"],
+                "ir_low": ir_stats["low"],
+                "ir_00": ir_stats["00"],
+                "ir_99": ir_stats["99"],
+                "ir_02": ir_stats["02"],
+                "ir_97": ir_stats["97"],
+                "ir_05": ir_stats["05"],
+                "ir_95": ir_stats["95"],
+                "ir_10": ir_stats["10"],
+                "ir_90": ir_stats["90"],
+                "ir_16": ir_stats["16"],
+                "ir_84": ir_stats["84"],
+                "ir_25": ir_stats["25"],
+                "ir_75": ir_stats["75"],
+                "FEVDL": FEVDL,
+                "vd_median": vd_stats["median"],
+                "vd_mean": vd_stats["mean"],
+                "vd_high": vd_stats["high"],
+                "vd_low": vd_stats["low"],
+                "vd_00": vd_stats["00"],
+                "vd_99": vd_stats["99"],
+                "vd_02": vd_stats["02"],
+                "vd_97": vd_stats["97"],
+                "vd_05": vd_stats["05"],
+                "vd_95": vd_stats["95"],
+                "alpha": alpha,
+                "steps_signs": steps_signs,
+            }
+
             return StructuralResults(
                 B=B_zero,
                 method="signs",
                 n_rejected=n_rejected,
                 m_accepted=m_accepted,
                 corr=0,
-                extra={"IRL": IRL, "FEVDL": FEVDL, "MB": MB},
+                extra=extra,
             )
 
-    # Build IR bands across accepted draws
-    ir_median = {}
-    ir_mean = {}
-    ir_high = {}
-    ir_low = {}
-    ir_00 = {}
-    ir_99 = {}
-    ir_02 = {}
-    ir_97 = {}
-    ir_05 = {}
-    ir_95 = {}
-    ir_10 = {}
-    ir_90 = {}
-    ir_16 = {}
-    ir_84 = {}
-    ir_25 = {}
-    ir_75 = {}
+    # Build IR bands across accepted draws, starting from a zero baseline so
+    # that a shock with zero accepted draws (edge case) degrades to zeros
+    # instead of crashing np.stack([]) with a ValueError.
+    ir_stats = _zero_stat_dicts(steps, n_vars, extra_percentiles=True)
+    ir_median, ir_mean = ir_stats["median"], ir_stats["mean"]
+    ir_high, ir_low = ir_stats["high"], ir_stats["low"]
+    ir_00, ir_99 = ir_stats["00"], ir_stats["99"]
+    ir_02, ir_97 = ir_stats["02"], ir_stats["97"]
+    ir_05, ir_95 = ir_stats["05"], ir_stats["95"]
+    ir_10, ir_90 = ir_stats["10"], ir_stats["90"]
+    ir_16, ir_84 = ir_stats["16"], ir_stats["84"]
+    ir_25, ir_75 = ir_stats["25"], ir_stats["75"]
 
     alpha_low = alpha / 2.0
     alpha_high = 100.0 - alpha_low
 
     for key, lst in IRL.items():
+        if len(lst) == 0:
+            continue  # leave the zero baseline for this shock
         stack = np.stack(lst, axis=0)  # (n_accept, steps, n_vars)
         ir_median[key] = np.median(stack, axis=0)
         ir_mean[key] = np.mean(stack, axis=0)
@@ -318,20 +356,16 @@ def identify_signs(
     # above: 'high' uses the lower percentile and 'low' the upper one,
     # since that is the swap SVAR.ImpulseResponse() already compensates
     # for on read -- SVAR.VarianceDecomp() will do the same for FEVD).
-    vd_median = {}
-    vd_mean = {}
-    vd_high = {}
-    vd_low = {}
-    vd_00 = {}
-    vd_99 = {}
-    vd_02 = {}
-    vd_97 = {}
-    vd_05 = {}
-    vd_95 = {}
+    vd_stats = _zero_stat_dicts(steps, n_vars, extra_percentiles=False)
+    vd_median, vd_mean = vd_stats["median"], vd_stats["mean"]
+    vd_high, vd_low = vd_stats["high"], vd_stats["low"]
+    vd_00, vd_99 = vd_stats["00"], vd_stats["99"]
+    vd_02, vd_97 = vd_stats["02"], vd_stats["97"]
+    vd_05, vd_95 = vd_stats["05"], vd_stats["95"]
 
     for key, lst in FEVDL.items():
         if len(lst) == 0:
-            continue
+            continue  # leave the zero baseline for this shock
         stack = np.stack(lst, axis=0)  # (n_accept, steps, n_vars)
         vd_median[key] = np.median(stack, axis=0)
         vd_mean[key] = np.mean(stack, axis=0)
@@ -345,8 +379,8 @@ def identify_signs(
         vd_95[key] = np.percentile(stack, 95.0, axis=0)
 
     B_median = np.median(np.stack(MB, axis=0), axis=0)
-    B_mean = np.mean(np.stack(MB, axis=0), axis=0)
-    
+    #B_mean = np.mean(np.stack(MB, axis=0), axis=0)
+
     extra = {
         "IRL": IRL,
         "MB": MB,
@@ -382,7 +416,7 @@ def identify_signs(
     }
 
     return StructuralResults(
-        B=B_mean,
+        B=B_median,
         method="signs",
         n_rejected=n_rejected,
         m_accepted=m_accepted,
@@ -467,7 +501,7 @@ def identify_iv(
         C = np.linalg.cholesky(sigma_u)
         q = solve_triangular(C, B[:, j], lower=True)
         v = np.linalg.norm(q)
-        B[:, j] = B[:, j] * v
+        B[:, j] = B[:, j] / v
 
     extra = {
         "z": z_list,
@@ -482,4 +516,16 @@ def identify_iv(
         m_accepted=None,
         corr=corr_list,
         extra=extra,
-    )
+    )
+
+def _zero_stat_dicts(steps: int, n_vars: int, extra_percentiles: bool = False) -> dict:
+
+    def _zero_per_shock():
+        return {k: np.zeros((steps, n_vars)) for k in range(1, n_vars + 1)}
+
+    names = ["median", "mean", "high", "low", "00", "99", "02", "97", "05", "95"]
+    if extra_percentiles:
+        names += ["10", "90", "16", "84", "25", "75"]
+
+    return {name: _zero_per_shock() for name in names}
+

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/irf.py

@@ -27,14 +27,14 @@ def impulse_response(
     impulse = np.zeros((n_vars, 1))
     impulse[shock - 1, 0] = impact
 
+    # Accumulate F^h incrementally (F^h = F^(h-1) @ F) instead of calling
+    # np.linalg.matrix_power(F, h) from scratch at every horizon.
+    F_power = np.eye(n_vars * lags)  # F^0
     for h in range(steps):
-        if h == 0:
-            F_power = np.eye(n_vars * lags)
-        else:
-            F_power = np.linalg.matrix_power(F, h)
         Psi_h = F_power[:n_vars, :n_vars]
         response = Psi_h @ B @ impulse
         ir[h, :] = response[:, 0]
+        F_power = F_power @ F  # advance to F^(h+1) for the next iteration
 
     return ir
 
@@ -101,4 +101,4 @@ def compute_bands_from_draws(
         stats["q99_5"][var] = np.percentile(arr, 99.5, axis=0)
         
 
-    return stats
+    return stats

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/macroshock.py

@@ -13,7 +13,6 @@ from .identification import (
     identify_iv,
 )
 from .bootstrap import bootstrap_svar
-
 from .fc import compute_forecast
 from .irf import compute_bands_from_draws
 from .fevd import forecast_error_variance_decomposition
@@ -28,30 +27,30 @@ class SVAR:
     def __init__(self, 
                  data, 
                  variables, 
-                 lags, 
-                 transformation=None, 
-                 const=1, 
-                 rescaling=None, 
-                 restrictions=None,
-                 R=None,
-                 method='short',
-                 matrix_long=None,
-                 matrix_short=None,
-                 matrix_signs=None, 
-                 iv=None, 
-                 shocks=None, 
-                 EXOGdata=None,
-                 EXOG=None, 
-                 DUM=None,
-                 impact=1,
-                 steps=60, 
-                 steps_signs=1, 
-                 resampling=1, 
-                 alpha=32,
-                 reps_default=1000,
-                 titles=None,
-                 horizon=6, 
-                 past=12
+                 lags: int, 
+                 transformation = None, 
+                 const: int = 1, 
+                 rescaling = None, 
+                 restrictions = None,
+                 R = None,
+                 method: str = 'short',
+                 matrix_long = None,
+                 matrix_short = None,
+                 matrix_signs = None, 
+                 iv = None, 
+                 shocks = None, 
+                 data_exogenous = None,
+                 variables_exogenous = None, 
+                 DUM = None,
+                 impact: float = 1.0,
+                 steps: int = 60, 
+                 steps_signs: int = 1, 
+                 resampling: int = 1, 
+                 alpha: float = 32,
+                 reps:int = 1000,
+                 titles = None,
+                 horizon: int = 6, 
+                 past: int = 12
                  ):
         
         
@@ -72,15 +71,15 @@ class SVAR:
         self.matrix_signs=matrix_signs
         self.iv=iv
         self.shocks=shocks
-        self.EXOGdata=EXOGdata
-        self.EXOG=EXOG
+        self.data_exogenous=data_exogenous
+        self.variables_exogenous=variables_exogenous
         self.DUM=DUM
         self.impact=impact
         self.steps=steps
         self.steps_signs=steps_signs
         self.resampling=resampling
         self.alpha=alpha
-        self.reps_default=reps_default
+        self.reps=reps
         self.titles=titles
         self.horizon=horizon
         self.past=past
@@ -96,17 +95,17 @@ class SVAR:
             if self.method=='IV':
                 self.iv=self.data[self.iv].values
             self.data=self.data[self.variables].values
-        if EXOGdata is not None:
-            if isinstance(EXOGdata, pd.DataFrame):
-                self.EXOGdata=self.EXOGdata[self.EXOG].values
-                self.n_obsex,self.n_ex=self.EXOGdata.shape
+        if data_exogenous is not None:
+            if isinstance(data_exogenous, pd.DataFrame):
+                self.data_exogenous=self.data_exogenous[self.variables_exogenous].values
+                self.n_obsex,self.n_ex=self.data_exogenous.shape
         else:
             self.n_ex=0
-            if self.EXOG is None:
-                self.EXOG=['Exog'+f"{i+1}" for i in range(self.n_ex)]
+            if self.variables_exogenous is None:
+                self.variables_exogenous=['Exog'+f"{i+1}" for i in range(self.n_ex)]
         for i in range(len(self.transformation)):
             if self.transformation[i]=="diff":
-                self.data[1:,i]=np.diff(self.data[:, i])
+                self.data[1:,i]=np.diff(self.data[:, i])*self.rescaling[i]
             elif self.transformation[i]=="logdiff":
                 self.data[1:,i]=np.diff(np.log(self.data[:,i]))*self.rescaling[i]
             elif self.transformation[i]=="log":
@@ -151,6 +150,7 @@ class SVAR:
         self.n_obs = res.n_obs
         self.n_vars = res.n_vars
         self.n_cols = res.n_cols
+        self.n_params = res.n_params
 
         # Build companion matrix F exactly as before
         top = self.beta[:, self.const : self.const + (self.lags * self.n_vars)]
@@ -187,7 +187,7 @@ class SVAR:
                 matrix_signs=self.matrix_signs,
                 steps_signs=self.steps_signs,
                 steps=self.steps,
-                reps=self.reps_default,
+                reps=self.reps,
                 alpha=self.alpha,
             )
             self.B = struct.B
@@ -256,7 +256,7 @@ class SVAR:
             for j in range(self.n_vars):
                 lagged.append("Lag"+f"{i+1}"+"."+self.variables[j])
     
-        summary0="Summary\n=====================================\nModel: SVARX\nMethod: OLS\nDate/Time: "+datetime.now().strftime("%Y-%m-%d %H:%M:%S %Z")+"\n-------------------------------------\nNo. of Equations: "+f"{self.n_vars:>18.2f}"+"\nNo. of Observations: "+f"{self.n_obs:>15.2f}"+"\nLog Likelihood: "+f"{self.ll:>20.6f}"+"\nAIC: "+f"{self.aic:>31.6f}"+"\nBIC: "+f"{self.bic:>31.6f}"+"\nHQIC: "+f"{self.hqic:>30.6f}"+"\nFPE: "+f"{self.fpe:>31.6f}"+"\nDet: "+f"{self.det:>31.6f}"+"\n-------------------------------------\n"
+        summary0="\nSummary\n=====================================\nModel: SVARX\nMethod: OLS\nDate/Time: "+datetime.now().strftime("%Y-%m-%d %H:%M:%S %Z")+"\n-------------------------------------\nNo. of Equations: "+f"{self.n_vars:>18.2f}"+"\nNo. of Observations: "+f"{self.n_obs:>15.2f}"+"\nFree Parameters: "+f"{self.n_params:>19.2f}"+"\nLog Likelihood: "+f"{self.ll:>20.6f}"+"\nAIC: "+f"{self.aic:>31.6f}"+"\nBIC: "+f"{self.bic:>31.6f}"+"\nHQIC: "+f"{self.hqic:>30.6f}"+"\nFPE: "+f"{self.fpe:>31.6f}"+"\nDet: "+f"{self.det:>31.6f}"+"\n-------------------------------------\n"
         for i in range(self.n_vars):
             summary1="Results for equation "+self.variables[i]+"\n=====================================================================\n                coefficient      std. error     t-stat      p-value\n---------------------------------------------------------------------\n"
             if self.const==1:
@@ -274,7 +274,7 @@ class SVAR:
                     summary2 = (lagged[j-self.const]+f"{self.beta[i,j]:>{26-len(lagged[j-self.const])}.6f}"f"{self.beta_std[i,j]:>16.6f}"f"{self.tstat[i,j]:>12.3f}"f"{self.pvalue[i,j]:>12.3f}\n")
                     summary1=summary1+summary2
                 elif j in range(self.const+(self.lags*self.n_vars),self.const+(self.lags*self.n_vars)+self.n_ex):
-                    summary2 = (self.EXOG[j-self.const-(self.lags*self.n_vars)]+f"{self.beta[i,j]:>{26-len(self.EXOG[j-self.const-(self.lags*self.n_vars)])}.6f}"f"{self.beta_std[i,j]:>16.6f}"f"{self.tstat[i,j]:>12.3f}"f"{self.pvalue[i,j]:>12.3f}\n")
+                    summary2 = (self.variables_exogenous[j-self.const-(self.lags*self.n_vars)]+f"{self.beta[i,j]:>{26-len(self.variables_exogenous[j-self.const-(self.lags*self.n_vars)])}.6f}"f"{self.beta_std[i,j]:>16.6f}"f"{self.tstat[i,j]:>12.3f}"f"{self.pvalue[i,j]:>12.3f}\n")
                     summary1=summary1+summary2
                 elif j in range(self.const+(self.lags*self.n_vars)+self.n_ex,self.const+(self.lags*self.n_vars)+self.n_ex+self.n_dum):
                     summary2 = (self.dummies[j-self.const-(self.lags*self.n_vars)-self.n_ex]+f"{self.beta[i,j]:>{26-len(self.dummies[j-self.const-(self.lags*self.n_vars)-self.n_ex])}.6f}"f"{self.beta_std[i,j]:>16.6f}"f"{self.tstat[i,j]:>12.3f}"f"{self.pvalue[i,j]:>12.3f}\n")
@@ -315,29 +315,27 @@ class SVAR:
     #--------------------------------------------------------------------------
         
     # impulse response calculation and plotting function
-    def ImpulseResponse(self, shock, show=True, bands='pair', steps=None, impact=None):
+    def ImpulseResponse(self, shock: int, show: bool = True, bands: str = 'pair', reps: int = None, steps: int = None, impact: float = None):
+        if reps is None:
+            reps = self.reps
         if steps is None:
             steps = self.steps
-        else:
-            self.steps = steps
         if impact is None:
             impact = self.impact
-        else:
-            self.impact = impact
         """
         Calcula IRFs (punto y bandas) y, opcionalmente, grafica.
         Mantiene la API y el output de la versión original.
         """
-        print("\nshock: " + str(shock) + "\n")
-
         # tipo de bandas
         self.bands = bands
 
         # Métodos distintos a 'signs': bootstrap estándar
         if self.method != 'signs':
+            
+            print("\nCalculating responses to shock " + str(shock) + ":\n")
 
             # Bootstrap de IRFs para este shock
-            self.drawsIR=bootstrap_svar(self, typ='IR', shock=shock)
+            self.drawsIR=bootstrap_svar(self, typ='IR', shock=shock, reps=reps, steps=steps)
             
             # Calcular medias y cuantiles a partir de self.drawsIR
             stats = compute_bands_from_draws(self.drawsIR, self.alpha)
@@ -356,6 +354,9 @@ class SVAR:
 
         # Método 'signs': ya tenemos el conjunto de identificaciones
         else:
+            
+            print("\nResponses to shock " + str(shock) + "\n")
+            
             # self.ir_median, self.ir_mean, etc. vienen de identify_signs (identification.py),
             # indexados por número de shock.
             
@@ -426,84 +427,15 @@ class SVAR:
             }
 
         return output
-
-        
-        print("\nshock: "+str(shock)+"\n")
-        # type of bands
-        self.bands=bands
-        
-        # for signs IMF are already estimated from the set identification process, thus this bootstrap is only for the other methods
-        if self.method!='signs':
-    
-            self.Bootstrap('IR',shock=shock)
-            
-            # alpha levels
-            lower_q = self.alpha / 2
-            upper_q = 100 - self.alpha / 2
-            #--------------------------------------------------------------
-            
-            # storage for IRF
-            self.ir_point = {}
-            self.ir_mean = {}
-            self.ir_low = {}
-            self.ir_high = {}
-            self.ir_95 = {}
-            self.ir_05 = {}
-            self.ir_00 = {}
-            self.ir_99 = {}
-            self.ir_02 = {}
-            self.ir_97 = {}
-        
-            for var in self.variables:
-                x=np.zeros((self.reps_default,self.steps))
-                for j in range(self.reps_default):
-                    x[j,:]=self.drawsIR[var][j]
-                self.drawsIR[var]=x
-        
-            for var in self.variables:
-                self.ir_point[var] = np.mean(self.drawsIR[var], axis=0)
-                self.ir_mean[var] = np.mean(self.drawsIR[var], axis=0)
-                self.ir_low[var]  = np.percentile(self.drawsIR[var], lower_q, axis=0)
-                self.ir_high[var] = np.percentile(self.drawsIR[var], upper_q, axis=0)
-                self.ir_95[var]   = np.percentile(self.drawsIR[var], 95, axis=0)
-                self.ir_05[var]   = np.percentile(self.drawsIR[var], 5, axis=0)
-                self.ir_00[var]   = np.percentile(self.drawsIR[var], 0.5, axis=0)
-                self.ir_99[var]   = np.percentile(self.drawsIR[var], 99.5, axis=0)
-                self.ir_02[var]   = np.percentile(self.drawsIR[var], 2.5, axis=0)
-                self.ir_97[var]   = np.percentile(self.drawsIR[var], 97.5, axis=0)
-            #--------------------------------------------------------------
-        
-        # if method is signs we already have the identification set for B matrices thus no bootstrap
-        elif self.method=='signs':
-            
-            self.ir_point = self.ir_median[shock]
-            self.ir_low = self.ir_low[shock]
-            self.ir_high = self.ir_high[shock]
-            self.ir_02 = self.ir_02[shock]
-            self.ir_97 = self.ir_97[shock]
-            self.ir_05 = self.ir_05[shock]
-            self.ir_95 = self.ir_95[shock]
-            self.ir_00 = self.ir_00[shock]
-            self.ir_99 = self.ir_99[shock]
-            self.ir_mean = self.ir_mean[shock]
-        #--------------------------------------------------------------
-        
-        # show the plots if indicated
-        if show==True:
-            plot_irf_svar(shock)
-            
-            #--------------------------------------------------------------
-            
-       # output set up 
-        if self.method!='signs':
-            output={'point':self.ir_mean, 'low':self.ir_low, 'high':self.ir_high, 2.5:self.ir_02, 5:self.ir_05, 0.5:self.ir_00, 99.5:self.ir_99,97.5:self.ir_97,95:self.ir_95}
-        else:
-            output={'point':self.ir_point, 'low':self.ir_low, 'high':self.ir_high, 2.5:self.ir_02, 5:self.ir_05, 0.5:self.ir_00, 99.5:self.ir_99,97.5:self.ir_97,95:self.ir_95}
-
-        return output
       
     # forecast calculation and plotting (THIS FUNCTION MIMICS THE IMPULSE RESPONSE ONE FOR BOOTSTAP AND BANDS LOGIC)
-    def Forecast(self, show=True, bands='many'):
+    def Forecast(self, show: bool = True, bands: str = 'many', horizon: int = None, past: int = None, reps: int = None):
+        if reps is None:
+            reps = self.reps
+        if horizon is None:
+            horizon = self.horizon
+        if past is None:
+            past = self.past
         """
         Calcula pronósticos (punto y bandas) y, opcionalmente, grafica.
         Mantiene la API y estructura de salida de la función original.
@@ -511,13 +443,13 @@ class SVAR:
         # Para métodos distintos de 'signs', hacemos bootstrap
         if self.method != 'signs':
 
-            print("Forecast:\n")
+            print("\nCalculating forecast:\n")
 
             # Pronóstico determinista (no lo usabas mucho, pero lo mantenemos)
             self.fc_point = compute_forecast(self, self.F)
 
             # Bootstrap de pronósticos
-            self.drawsFC=bootstrap_svar(self, typ='FC')
+            self.drawsFC=bootstrap_svar(self, typ='FC', horizon=horizon, past=past, reps=reps)
 
             # Calcular bandas a partir de self.drawsFC
             stats = compute_bands_from_draws(self.drawsFC, self.alpha)
@@ -535,7 +467,7 @@ class SVAR:
         # Para 'signs', no había bootstrap en tu código: solo trayectoria determinista
         elif self.method == 'signs':
 
-            print('No bands Forecast:\n')
+            print('\nNo bands Forecast\n')
 
             fc_det = compute_forecast(self, self.F)  # (past + horizon, n_vars)
 
@@ -582,92 +514,33 @@ class SVAR:
         }
 
         return output
-
-        
-        if self.method!='signs':
-            
-            print("\nreps_default:\n")
-            
-            self.fc_point = self.FC(self.F)
-            
-            self.Bootstrap('FC')
-        
-            lower_q = self.alpha / 2
-            upper_q = 100 - self.alpha / 2
-            
-            self.fc_mean = {}
-            self.fc_low = {}
-            self.fc_high = {}
-            self.fc_95 = {}
-            self.fc_50 = {}
-            self.fc_05 = {}
-            self.fc_02 = {}
-            self.fc_97 = {}
-            self.fc_00 = {}
-            self.fc_99 = {}
-        
-            for var in self.variables:
-                x=np.zeros((self.reps_default,self.past+self.horizon))
-                for j in range(self.reps_default):
-                    x[j,:]=self.drawsFC[var][j]
-                self.drawsFC[var]=x
-        
-            for var in self.variables:
-                self.fc_mean[var] = np.mean(self.drawsFC[var], axis=0)
-                self.fc_low[var]  = np.percentile(self.drawsFC[var], lower_q, axis=0)
-                self.fc_high[var] = np.percentile(self.drawsFC[var], upper_q, axis=0)
-                self.fc_95[var]   = np.percentile(self.drawsFC[var], 95, axis=0)
-                self.fc_99[var]   = np.percentile(self.drawsFC[var], 99.5, axis=0)
-                self.fc_00[var]   = np.percentile(self.drawsFC[var], 0.5, axis=0)
-                self.fc_05[var]   = np.percentile(self.drawsFC[var], 5, axis=0)
-                self.fc_02[var]   = np.percentile(self.drawsFC[var], 2.5, axis=0)
-                self.fc_97[var]   = np.percentile(self.drawsFC[var], 97.5, axis=0)
-            
-        elif self.method=='signs':
-            
-            print('no bands Forecast:')
-            self.fc_mean = {self.variables[i]:self.FC(self.F)[:,i] for i in range(self.n_vars)}
-            self.fc_low = self.fc_mean
-            self.fc_high = self.fc_mean
-            self.fc_95 = self.fc_mean
-            self.fc_99 = self.fc_mean
-            self.fc_00 = self.fc_mean
-            self.fc_05 = self.fc_mean
-            self.fc_02 = self.fc_mean
-            self.fc_97 = self.fc_mean
-            
-        if show==True:
-            
-            self.bands=bands
-            
-            plot_forecast_svar(self)
-           
-        output={'point':self.fc_mean, 'low':self.fc_low, 'high':self.fc_high, 2.5:self.fc_02, 5:self.fc_05,97.5:self.fc_97,95:self.fc_95,0.5:self.fc_00,99.5:self.fc_99}
-        
-        return output
     
     
-    def VarianceDecomp(self, shock: int = 1, show: bool = True, bands: str = 'pair', steps: int = None):
+    def VarianceDecomp(self, shock: int, show: bool = True, bands: str = 'pair', steps: int = None, reps: int = None):
         """
         Calcula la Descomposición de Varianza (punto y bandas) y, opcionalmente, grafica.
         Mantiene la API y estructura de salida de ImpulseResponse y Forecast.
         """
         if steps is None:
             steps = self.steps
-        else:
-            self.steps = steps
-
-        print("Calculating Variance Decomposition:\n")
+        if reps is None:
+            reps = self.reps
 
         self.bands = bands
 
         if self.method != 'signs':
+            
+            print(f"\nCalculating FEVD for {self.variables[shock-1]}:\n")
+            
             self.vd_det = forecast_error_variance_decomposition(self.B, self.F, steps=self.steps)
 
-            self.drawsVD = bootstrap_svar(self, typ='VD', shock=shock)
-
+            self.drawsVD = bootstrap_svar(self, typ='VD', shock=shock, reps=reps, steps=steps)
+            
+            #self.vd_point
+            
             stats = compute_bands_from_draws(self.drawsVD, self.alpha)
-
+            
+            self.vd_point = stats["point"]
             self.vd_mean = stats["mean"]
             self.vd_low  = stats["low"]
             self.vd_high = stats["high"]
@@ -679,6 +552,8 @@ class SVAR:
             self.vd_99   = stats["q99_5"]
 
         elif self.method == 'signs':
+            
+            print(f"\nFEVD for {self.variables[shock-1]}\n")
 
             # Deterministic FEVD for the median B matrix (self.B is already
             # the median of the accepted set for 'signs'). This is what
@@ -727,11 +602,11 @@ class SVAR:
         if show is True:
             # Uses self.vd_det in both branches -- plot_variance_decomp_svar()
             # doesn't need to know about self.method at all.
-            plot_variance_decomp_svar(self)
+            plot_variance_decomp_svar(self, shock)
 
         if self.method != 'signs':
             output = {
-                'point': self.vd_mean,
+                'point': self.vd_point,
                 'low':   self.vd_low,
                 'high':  self.vd_high,
                 2.5:     self.vd_02,
@@ -801,8 +676,8 @@ class SVAR:
             self.Forecast(bands=FCbands)
                 
         if showVD==True:
-            self.VarianceDecomp()
-    
+            for k in range(self.n_vars):
+                self.VarianceDecomp(k+1,show=show,bands=IRbands)
     
 class SVEC:
     

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/plotting.py

@@ -1,4 +1,3 @@
-# plotting.py
 from __future__ import annotations
 
 import numpy as np
@@ -231,73 +230,68 @@ def plot_forecast_svar(model):
 
     plt.tight_layout(rect=[0, 0, 1, 0.95])
 
-def plot_variance_decomp_svar(model):
+def plot_variance_decomp_svar(model, shock: int):
     """
-    Grafica la Descomposición de Varianza (FEVD) para un modelo SVAR.
-    Crea un gráfico de áreas apiladas (stackplot) por cada variable, donde 
-    las áreas suman 100% y muestran la proporción de la varianza explicada.
+    Grafica la Descomposición de Varianza (FEVD) para una sola variable de
+    un modelo SVAR: un stackplot con la contribución de cada shock
+    estructural a la varianza del error de pronóstico de esa variable, en
+    cada horizonte.
+
+    Parameters
+    ----------
+    model : objeto SVAR
+        Debe tener .variables, .shocks, .steps y .vd_det poblados (p.ej.
+        tras llamar model.VarianceDecomp()).
+    shock : int
+        Índice 1-based de la variable a graficar. Coincide directamente con
+        las llaves de model.vd_det (indexado 1..n_vars por variable).
     """
-    n_vars = len(model.variables)
-    
-    # Adjust layout dynamically based on the number of variables
-    cols = 1
-    rows = n_vars
-    
-    fig, axes = plt.subplots(rows, cols, figsize=(8, 2+ 2 * rows), squeeze=False)
-    axes = axes.flatten()
-    
+    var_name = model.variables[shock - 1]
+
     horizon = np.arange(model.steps)
 
     # Check for assigned shocks
     if model.shocks is None:
         model.shocks = model.variables
-        
+
+    fig, ax = plt.subplots(figsize=(7, 4))
+
     fig.suptitle(
-        "Forecast Error Variance Decomposition",
-        fontsize=16,
+        f"Forecast Error Variance Decomposition: {var_name}",
+        fontsize=13,
         fontname="Times New Roman",
         color="black"
     )
-    
+
     # Generate a distinct color palette for the structural shocks
     colors = plt.cm.tab10(np.linspace(0, 1, len(model.shocks)))
-    
-    for i, var in enumerate(model.variables):
-        ax = axes[i]
-        
-        # Extract the deterministic FEVD matrix for variable i+1
-        # model.vd_det[i+1] is shape (steps, n_shocks)
-        # We multiply by 100 and transpose (.T) so stackplot can read shape (n_shocks, steps)
-        y_data = (model.vd_det[i + 1] * 100).T 
-        
-        # Generate the continuous stacked area plot
-        ax.stackplot(
-            horizon, 
-            y_data, 
-            labels=model.shocks if i == 0 else (), # Only attach labels to the first subplot
-            colors=colors,
-            alpha=0.9 # Adds a slight transparency
-        )
-            
-        ax.set_title(f"{var}", fontsize=12, fontweight='bold')
-        ax.set_ylim([0, 100])
-        ax.set_xlim([0, model.steps - 1]) # Flush limits for a continuous line
-        ax.set_xlabel("Horizonte")
-        ax.set_ylabel("Varianza Explicada (%)")
-        ax.grid(True, axis='y', alpha=0.3)
-
-    # Add a single, centralized legend for the entire figure
-    fig.legend(
-        loc='lower center', 
-        ncol=len(model.shocks), 
-        bbox_to_anchor=(0.5, -0.05),
+
+    # Extract the deterministic FEVD matrix for the target variable.
+    # model.vd_det[shock] is shape (steps, n_shocks); multiply by 100 and
+    # transpose (.T) so stackplot can read shape (n_shocks, steps).
+    y_data = (model.vd_det[shock] * 100).T
+
+    ax.stackplot(
+        horizon,
+        y_data,
+        labels=model.shocks,
+        colors=colors,
+        alpha=0.9
+    )
+
+    ax.set_ylim([0, 100])
+    ax.set_xlim([0, model.steps - 1])
+    ax.set_xlabel("Horizonte")
+    ax.set_ylabel("Varianza Explicada (%)")
+    ax.grid(True, axis='y', alpha=0.3)
+
+    ax.legend(
+        loc='lower center',
+        ncol=len(model.shocks),
+        bbox_to_anchor=(0.5, -0.45),
         frameon=False,
         fontsize=11
     )
 
-    # Hide any empty subplots if n_vars doesn't perfectly fill the grid
-    for k in range(i + 1, len(axes)):
-        axes[k].set_visible(False)
-        
-    fig.tight_layout(rect=[0, 0.05, 1, 0.95])
+    fig.tight_layout()
     plt.show()

{macroshock-0.2.0 → macroshock-0.2.2}/src/macroshock/var.py

@@ -26,10 +26,10 @@ class VARResults:
     beta_std: np.ndarray
     tstat: np.ndarray
     pvalue: np.ndarray
-    F: np.ndarray
     n_obs: int
     n_vars: int
     n_cols: int
+    n_params: int
 
 def estimate_var(Y: np.ndarray, X: np.ndarray, R: np.ndarray) -> VARResults:
     # 1. Basic Setup
@@ -98,10 +98,11 @@ def estimate_var(Y: np.ndarray, X: np.ndarray, R: np.ndarray) -> VARResults:
     aic = 2.0 * n_params - 2.0 * ll
     bic = n_params * np.log(n_obs) - 2.0 * ll
     hqic = 2.0 * n_params * np.log(np.log(n_obs)) - 2.0 * ll
-
+    fpe = np.linalg.det(sigma_u) * ((n_obs + n_cols) / (n_obs - n_cols)) ** n_vars
+    
     return VARResults(
         beta=beta, sigma_u=sigma_u, resid=resid, Y_hat=Y_hat,
         ll=ll, aic=aic, bic=bic, hqic=hqic, det=np.linalg.det(sigma_u),
-        fpe=0.0, beta_std=beta_std, tstat=tstat, pvalue=pvalue,
-        F=None, n_obs=n_obs, n_vars=n_vars, n_cols=n_cols
+        fpe=fpe, beta_std=beta_std, tstat=tstat, pvalue=pvalue,
+        n_obs=n_obs, n_vars=n_vars, n_cols=n_cols, n_params=n_params
     )

{macroshock-0.2.0 → macroshock-0.2.2/src/macroshock.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: macroshock
-Version: 0.2.0
+Version: 0.2.2
 Summary: Powerful time series econometrics for Structural Vector Autoregressions (SVAR)
 Author-email: Patricio Arias <patoariaslopez2@gmail.com>
 License: MIT License
@@ -41,13 +41,13 @@ Dynamic: license-file
 
 ## Main Features
 
-* **Restricted VAR estimation** (Lütkepohl-style GLS), with support for:
+* - **Restricted VAR estimation** (Lütkepohl-style GLS), with support for:
 
   - Constant, trend and quadratic trend.
   - Exogenous variables.
   - Seasonal dummies (quarterly or monthly).
   - Linear restrictions on the coefficients (`restrictions='zeros'` or `'custom zeros'`).
-* **Four structural identification methods**:
+* - **Four structural identification methods**:
 
 |Method|Description|
 |-|-|
@@ -56,12 +56,12 @@ Dynamic: license-file
 |`signs`|Sign restrictions (orthogonal rotation sampling with acceptance/rejection)|
 |`IV`|Instrumental variable identification (proxy-SVAR)|
 
-* **Impulse-response functions (IRF)** with confidence bands.
-* **Forecast error variance decomposition (FEVD)**.
-* **Conditional forecasts** with confidence bands.
-* **Bootstrap** (normal or *wild* resampling) for inference.
-* **Built-in plots** for IRF, forecasts and FEVD, publication-ready.
-* **Stability test** of the system (characteristic polynomial roots).
+* - **Impulse-response functions (IRF)** with confidence bands.
+* - **Forecast error variance decomposition (FEVD)**.
+* - **Conditional forecasts** with confidence bands.
+* - **Bootstrap** (normal or *wild* resampling) for inference.
+* - **Built-in plots** for IRF, forecasts and FEVD, publication-ready.
+* - **Stability test** of the system (characteristic polynomial roots).
 
 ## Installation
 
@@ -96,7 +96,7 @@ model = SVAR(
     horizon=8,         # forecast horizon
     past=12,           # past periods to show in the forecast
     alpha=32,          # confidence interval level (32 -> 68% central band)
-    reps\_default=1000, # bootstrap replications
+    reps=1000, # bootstrap replications
 )
 
 # Runs the complete pipeline: Y/X construction, VAR estimation,
@@ -116,13 +116,13 @@ model.S()                # identifies the structural system (matrix B)
 model.summary()          # prints the estimation summary
 
 # Impulse response to shock 1, with "pair" bands (low/high percentile)
-ir = model.ImpulseResponse(shock=1, show=True, bands="pair")
+ir = model.ImpulseResponse(1, show=True, bands="pair")
 
 # Forecast with "many" bands (multiple stacked confidence levels)
 fc = model.Forecast(show=True, bands="many")
 
-# Forecast error variance decomposition for shock 1
-vd = model.VarianceDecomp(shock=1, show=True)
+# Forecast error variance decomposition for variable 1
+vd = model.VarianceDecomp(1, show=True)
 ```
 
 Each of these methods returns a dictionary with the point estimate and confidence bands at different levels (`'point'`, `'low'`, `'high'`, `2.5`, `5`, `95`, `97.5`, `0.5`, `99.5`), indexed by variable name.
@@ -143,7 +143,7 @@ By default it uses the Cholesky decomposition. If `matrix\_short` is passed (a b
 model = SVAR(data=df, variables=variables, lags=4, method="long")
 ```
 
-By default it uses the Cholesky decomposition. If `matrix\_short` is passed (a binary matrix of 1s and 0s), the `B` matrix satisfying the indicated zero restrictions is solved numerically.
+By default it uses the Cholesky decomposition. If `matrix\_long` is passed (a binary matrix of 1s and 0s), the `B` matrix satisfying the indicated zero restrictions is solved numerically.
 
 ### 3\. Sign restrictions
 
@@ -157,7 +157,7 @@ model = SVAR(
     method="signs",
     matrix\_signs=matrix\_signs,
     steps\_signs=4,       # horizons over which signs are checked
-    reps\_default=1000,   # number of accepted B matrices
+    reps=1000,   # number of accepted B matrices
 )
 ```