Merge pull request #9 from ousema-bouaneni/main

Refactoring Model class

Author: albop

.gitignore

@@ -9,4 +9,5 @@ poetry.lock
 **/__pycache__/*
 temp*.yml
 .mypy*
-*ipynb*
+*ipynb*
+.github/workflows/.ci_pixi.yaml

dyno/gui/dynare.py

@@ -21,7 +21,7 @@ def sim_to_nsim(irfs):
 
     txt = open(filename).read()
 
-    from dyno.modfile import Modfile
+    from dyno.modfile_preprocessor import Modfile
 
     model = Modfile(txt=txt)
     dr0 = model.solve()
@@ -113,7 +113,7 @@ def import_model(txt):
             else:
                 method = "ti"
 
-            parms = {k: v for k, v in parameters.items()}
+            parms = {k: float(v.value) for k, v in parameters.items()}
 
             dr.value = model.solve(method=method, calibration=parms)
 

dyno/language.py

@@ -8,6 +8,8 @@
 
 import numpy as np
 
+from scipy.stats import multivariate_normal
+
 
 class NotPositiveSemidefinite(np.linalg.LinAlgError):
     """An exception raised when a normal process is created with a covariance matrix that is not positive semidefinite"""
@@ -29,16 +31,48 @@ def Vector(*elements):
     return mat
 
 
+class Exogenous:
+    pass
+
+
+class Deterministic(Exogenous):
+    """Deterministic exogenous variables clas
+
+    Parameters
+    ----------
+    horizon: int
+        time horizon over which the perfect foresight solver will simulate the model
+
+    values_dict: dict[str, list[float]]
+        dictionary containing the values that each exogenous variable takes on at each time period before the horizon,
+        empty fields are assumed to be zero
+    """
+
+    horizon: int
+    """time horizon over which the model will be simulated"""
+
+    values: dict[str, list[float]]
+    """values taken on by each exogenous variable"""
+
+    def __init__(self, horizon: int, values_dict: dict[str, list[float]]):
+        horizon = max(horizon, max([len(periods) for periods in values_dict.values()]))
+        for var, values in values_dict.items():
+            if len(values) < horizon:
+                values_dict[var] = pad_list(values, horizon)
+        self.horizon = horizon
+        self.values = values_dict
+
+
 @language_element
-class Normal:
+class Normal(Exogenous):
     """Multivariate normal process class, can be used to model white noise.
 
     Parameters
     ----------
     Μ: d Vector | None
         Mean vector for the normal process, taken to be equal to zero if not passed
 
-    Σ : (d,d) Matrix
+    Σ: (d,d) Matrix
         Covariance matrix for the normal process, needs to be positive semidefinite
 
     Attributes
@@ -61,39 +95,30 @@ class Normal:
 
     @greek_tolerance
     def __init__(self, Σ, Μ=None):
-
         Sigma = np.array(Σ)
         mu = Μ
-
         self.Σ = np.atleast_2d(np.array(Sigma, dtype=float))
         try:
             assert np.array_equal(Sigma, Sigma.T)
-            np.linalg.cholesky(Sigma)
-        except (AssertionError, np.linalg.LinAlgError):
-            raise (
-                NotPositiveSemidefinite,
+            assert np.all(np.linalg.eigvalsh(Sigma) > -1e-12)
+        except AssertionError:
+            raise NotPositiveSemidefinite(
                 "Σ can't be used as a covariance matrix as it is not positive semidefinite",
             )
-
         self.d = len(self.Σ)
         if mu is None:
             self.Μ = np.array([0.0] * self.d)
         else:
             self.Μ = np.array(mu, dtype=float)
 
         assert self.Σ.shape[0] == self.d
-        assert self.Σ.shape[0] == self.d
-
+        assert self.Σ.shape[1] == self.d
         # this class wraps functionality from scipy
-        import scipy.stats
-
-        self._dist_ = scipy.stats.multivariate_normal(
-            mean=self.Μ, cov=self.Σ, allow_singular=True
-        )
+        self._dist_ = multivariate_normal(mean=self.Μ, cov=self.Σ, allow_singular=True)
 
 
 @language_element
-class ProductNormal:
+class ProductNormal(Exogenous):
     """Product of multivariate normal processes
 
     Parameters
@@ -124,3 +149,7 @@ def Σ(self):
         """
         assert len(self.processes) == 1
         return self.processes[0].Σ
+
+
+def pad_list(l: list, n: int) -> list:
+    return l + [0] * (n - len(l))