Merge pull request #8 from ousema-bouaneni/main

CI test failure fix and replacement of poetry and mkapi by pixi and mkdocstrings

Author: albop

.github/workflows/ci.yaml

@@ -1,6 +1,6 @@
 name: CI
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
 

.gitignore

@@ -9,3 +9,4 @@ poetry.lock
 **/__pycache__/*
 temp*.yml
 .mypy*
+*ipynb*

docs/index.md

@@ -1,5 +1,8 @@
-# Welcome to MkDocs
+# Reference
 
-For full documentation visit [mkdocs.org](https://www.mkdocs.org).
-
-The solution to all the problems is hidden in the source code of this page.
+::: dyno
+    options:
+        docstring_style: numpy
+        separate_signature: false
+        show_signature_annotations: false
+        docstring_section_style: table

dyno/language.py

@@ -2,7 +2,7 @@
 
 # copied from dolo
 
-from .types import Vector, Matrix
+from .typedefs import TVector, TMatrix
 
 from dolang.language import greek_tolerance, language_element  # type: ignore
 
@@ -15,6 +15,20 @@ class NotPositiveSemidefinite(np.linalg.LinAlgError):
     pass
 
 
+@language_element
+def Matrix(*lines):
+    mat = np.array(lines, np.float64)
+    assert mat.ndim == 2
+    return mat
+
+
+@language_element
+def Vector(*elements):
+    mat = np.array(elements, np.float64)
+    assert mat.ndim == 1
+    return mat
+
+
 @language_element
 class Normal:
     """Multivariate normal process class, can be used to model white noise.
@@ -40,13 +54,15 @@ class Normal:
         dimension
     """
 
-    Μ: Vector  # this is capital case μ, not M... 😭
-    Σ: Matrix
+    Μ: TVector  # this is capital case μ, not M... 😭
+    Σ: TMatrix
+
+    signature = {"Σ": "Matrix", "Μ": "Optional[Vector]"}
 
     @greek_tolerance
     def __init__(self, Σ, Μ=None):
 
-        Sigma = Σ
+        Sigma = np.array(Σ)
         mu = Μ
 
         self.Σ = np.atleast_2d(np.array(Sigma, dtype=float))
@@ -103,7 +119,7 @@ def Σ(self):
 
         Returns
         -------
-        Matrix
+        TMatrix
             Covariance matrix of the process
         """
         assert len(self.processes) == 1

dyno/misc.py

@@ -1,11 +1,11 @@
 import numpy as np
-from .types import Vector, Matrix
+from .typedefs import TVector, TMatrix
 from typing import Callable
 
 
 def jacobian(
-    func: Callable[[Vector], Vector], initial: Vector, delta: float = 1e-3
-) -> Matrix:
+    func: Callable[[TVector], TVector], initial: TVector, delta: float = 1e-3
+) -> TMatrix:
     """Jacobian calculation with finite differences
 
     Parameters

dyno/model.py

@@ -8,8 +8,9 @@
 
 from abc import ABC, abstractmethod
 
-from typing import Callable, Self, overload, Literal
-from .types import Vector, Matrix, IRFType, Solver, SymbolType, DynamicFunction
+from typing import Callable, overload, Literal, Any
+from typing_extensions import Self
+from .typedefs import TVector, TMatrix, IRFType, Solver, SymbolType, DynamicFunction
 from pandas import DataFrame
 from .language import Normal
 
@@ -19,7 +20,7 @@ class RecursiveSolution:
 
     Attributes
     ----------
-    X, Y, Σ: (N,N) matrix
+    X, Y, Σ: (N,N) Matrix
         parameters of the stationary VAR process $y_t = Xy_{t-1} + Yε_t$, where Σ is the covariance matrix of $ε_t$
 
     symbols: dict[SymbolType, list[str]]
@@ -35,12 +36,12 @@ class RecursiveSolution:
 
     def __init__(
         self: Self,
-        X: Matrix,
-        Y: Matrix,
-        Σ: Matrix,
+        X: TMatrix,
+        Y: TMatrix,
+        Σ: TMatrix,
         symbols: dict[SymbolType, list[str]],
-        x0: Vector | None = None,
-        evs: Vector | None = None,
+        x0: TVector | None = None,
+        evs: TVector | None = None,
     ) -> None:
 
         self.x0 = x0
@@ -73,25 +74,31 @@ def describe(self: Self) -> str:
 
     @overload
     def dynamic(
-        self: Self, y0: Vector, y1: Vector, y2: Vector, e: Vector, p: Vector
-    ) -> Vector:
+        self: Self, y0: TVector, y1: TVector, y2: TVector, e: TVector, p: TVector
+    ) -> TVector:
         pass
 
     @overload
     def dynamic(
-        self: Self, y0: Vector, y1: Vector, y2: Vector, e: Vector, p: Vector, diff: bool
-    ) -> tuple[Vector, Matrix, Matrix, Matrix, Matrix]:
+        self: Self,
+        y0: TVector,
+        y1: TVector,
+        y2: TVector,
+        e: TVector,
+        p: TVector,
+        diff: bool,
+    ) -> tuple[TVector, TMatrix, TMatrix, TMatrix, TMatrix]:
         pass
 
     def dynamic(
         self: Self,
-        y0: Vector,
-        y1: Vector,
-        y2: Vector,
-        e: Vector,
-        p: Vector,
+        y0: TVector,
+        y1: TVector,
+        y2: TVector,
+        e: TVector,
+        p: TVector,
         diff: bool = False,
-    ) -> Vector | tuple[Vector, Matrix, Matrix, Matrix, Matrix]:
+    ) -> TVector | tuple[TVector, TMatrix, TMatrix, TMatrix, TMatrix]:
         """function f describing the behavior of the dynamic system $f(y_{t+1}, y_t, y_{t-1}, ε_t, p) = 0$
 
         Parameters
@@ -125,18 +132,18 @@ def dynamic(
         return r
 
     @overload
-    def compute(self: Self, calibration: dict[str, float] = {}) -> Vector:
+    def compute(self: Self, calibration: dict[str, float] = {}) -> TVector:
         pass
 
     @overload
     def compute(
         self: Self, calibration: dict[str, float] = {}, diff: bool = False
-    ) -> tuple[Vector, Matrix, Matrix, Matrix, Matrix]:
+    ) -> tuple[TVector, TMatrix, TMatrix, TMatrix, TMatrix]:
         pass
 
     def compute(
         self: Self, calibration: dict[str, float] = {}, diff: bool = False
-    ) -> Vector | tuple[Vector, Matrix, Matrix, Matrix, Matrix]:
+    ) -> TVector | tuple[TVector, TMatrix, TMatrix, TMatrix, TMatrix]:
         """Computes the dynamic function's value based on calibration state and parameters
 
         Parameters
@@ -148,7 +155,7 @@ def compute(
 
         Returns
         -------
-        Vector|tuple[Vector, Matrix, Matrix, Matrix, Matrix]
+        TVector|tuple[TVector, TMatrix, TMatrix, TMatrix, TMatrix]
             value of the dynamic function at the state described by calibration, as well as its partial derivatives if diff is set to True
         """
         c = self.get_calibration(**calibration)

dyno/simul.py

@@ -2,7 +2,7 @@
 import pandas as pd
 from .model import RecursiveSolution
 
-from .types import IRFType
+from .typedefs import IRFType
 
 
 def irf(

dyno/solver.py

@@ -1,12 +1,12 @@
 import numpy as np
 from numpy.linalg import solve as linsolve
 from scipy.linalg import ordqz
-from .types import Vector, Matrix, Solver
+from .typedefs import TVector, TMatrix, Solver
 
 
 def solve(
-    A: Matrix, B: Matrix, C: Matrix, method: Solver = "qz", options={}
-) -> tuple[Matrix, Vector | None]:
+    A: TMatrix, B: TMatrix, C: TMatrix, method: Solver = "qz", options={}
+) -> tuple[TMatrix, TVector | None]:
     """Solves AX² + BX + C = 0 for X using the chosen method
 
     Parameters
@@ -52,8 +52,8 @@ class NoConvergence(Exception):
 
 
 def solve_ti(
-    A: Matrix, B: Matrix, C: Matrix, T: int = 10000, tol: float = 1e-10
-) -> tuple[Matrix, None]:
+    A: TMatrix, B: TMatrix, C: TMatrix, T: int = 10000, tol: float = 1e-10
+) -> tuple[TMatrix, None]:
     """Solves AX² + BX + C = 0 for X using fixed-point iteration.
 
     Parameters
@@ -102,8 +102,8 @@ def solve_ti(
 
 
 def solve_qz(
-    A: Matrix, B: Matrix, C: Matrix, tol: float = 1e-15
-) -> tuple[Matrix, Vector]:
+    A: TMatrix, B: TMatrix, C: TMatrix, tol: float = 1e-15
+) -> tuple[TMatrix, TVector]:
     """Solves AX² + BX + C = 0 for X using QZ decomposition.
 
     Parameters
@@ -142,7 +142,7 @@ def solve_qz(
     return X, np.sort(λ_all).reshape(2 * n)
 
 
-def decompose_blocks(Z: Matrix) -> tuple[Matrix, Matrix, Matrix, Matrix]:
+def decompose_blocks(Z: TMatrix) -> tuple[TMatrix, TMatrix, TMatrix, TMatrix]:
     """Decomposes square matrix Z into four square blocks Z11, Z12, Z21, Z22 such that Z can be written as:
     ```
     [Z11, Z12]
@@ -189,7 +189,7 @@ def genev(α: float, β: float, tol: float = 1e-9) -> float:
             return np.inf
 
 
-def vgenev(α: Vector, β: Vector, tol: float = 1e-9) -> Vector:
+def vgenev(α: TVector, β: TVector, tol: float = 1e-9) -> TVector:
     """
     Computes the generalized eigenvalues λ = α/β, vectorized version of `genev`
 
@@ -207,7 +207,7 @@ def vgenev(α: Vector, β: Vector, tol: float = 1e-9) -> Vector:
     return (np.array([genev(a, b) for a, b in zip(α, β)])).reshape(len(α))
 
 
-def moments(X: Matrix, Y: Matrix, Σ: Matrix) -> tuple[Matrix, Matrix]:
+def moments(X: TMatrix, Y: TMatrix, Σ: TMatrix) -> tuple[TMatrix, TMatrix]:
     """
     Computes conditional and unconditional moments of stationary process $y_t = X y_{t-1} + Y e_t$
 
@@ -230,19 +230,19 @@ def moments(X: Matrix, Y: Matrix, Σ: Matrix) -> tuple[Matrix, Matrix]:
 
     Applying the linear covariance operator to both sides of the equation $y_t = X y_{t-1} + Y e_t$ yields
     $$
-    \mathrm{Cov}(y_t) = X ⋅ \mathrm{Cov}(y_{t-1}) ⋅ X^* + Y ⋅ \mathrm{Cov}(e_t) ⋅ Y^*
+    \\mathrm{Cov}(y_t) = X ⋅ \\mathrm{Cov}(y_{t-1}) ⋅ X^* + Y ⋅ \\mathrm{Cov}(e_t) ⋅ Y^*
     $$
-    By stationarity of $y_t$, $\mathrm{Cov}(y_t) = \mathrm{Cov}(y_{t-1}) := \Gamma$, so
+    By stationarity of $y_t$, $\\mathrm{Cov}(y_t) = \\mathrm{Cov}(y_{t-1}) := Γ$, so
     $$
     Γ = X Γ X^* + Γ₀
     $$
     By applying the [Vec-operator](https://en.wikipedia.org/wiki/Vectorization_(mathematics)#Compatibility_with_Kronecker_products), we get the following equation:
     $$
-    \mathrm{Vec}(Γ) = (X ⊗ X) \mathrm{Vec}(Γ)  + \mathrm{Vec}(Γ₀)
+    \\mathrm{Vec}(Γ) = (X ⊗ X) \\mathrm{Vec}(Γ)  + \\mathrm{Vec}(Γ₀)
     $$
     Which gives the following solution
     $$
-    \mathrm{Vec}(Γ) = (I_{N^2} - X ⊗ X)^{-1} \mathrm{Vec}(Γ₀)
+    \\mathrm{Vec}(Γ) = (I_{N^2} - X ⊗ X)^{-1} \\mathrm{Vec}(Γ₀)
     $$
     """
 

dyno/types.py dyno/typedefs.pydyno/types.py renamed to dyno/typedefs.py

@@ -2,14 +2,11 @@
 from typing import Literal, TypeVar, Callable
 
 DType = TypeVar("DType", bound=np.generic)
-Vector = np.ndarray[tuple[int], DType]
-Matrix = np.ndarray[tuple[int, int], DType]
+TVector = np.ndarray[tuple[int], DType]
+TMatrix = np.ndarray[tuple[int, int], DType]
 
 Solver = Literal["ti", "qz"]
 SymbolType = Literal["endogenous", "exogenous", "parameters"]
 IRFType = Literal["level", "log-deviation", "deviation"]
 
-DynamicFunction = Callable[
-    [Vector, Vector, Vector, Vector, Vector, Vector],
-    Vector | tuple[Vector, Matrix, Matrix, Matrix, Matrix],
-]
+DynamicFunction = Callable[[TVector, TVector, TVector, TVector, TVector, TVector], None]

mkdocs.yml

@@ -2,7 +2,7 @@ site_name: Dyno 🦖
 
 plugins:
   - search # necessary for search to work
-  - mkapi
+  - mkdocstrings
 
 markdown_extensions:
   - mdx_math
@@ -33,6 +33,4 @@ extra_javascript:
   - https://cdn.jsdelivr.net/npm/vega-embed@5
 
 nav:
-  - index.md
-  - Reference:
-    - $api/dyno.***
+  - index.md