Merge branch 'main' of github.com:JonasTurnwald/fredipy

Author: JonasTurnwald

examples/basic_breit_wigner.ipynb

@@ -83,7 +83,7 @@
     "data = {\n",
     "    'x': p,\n",
     "    'y': G_err,\n",
-    "    'dy': err**2}"
+    "    'cov_y': err**2}"
    ]
   },
   {
@@ -327,7 +327,7 @@
     "obs_direct = {\n",
     "    'x': w_direct,\n",
     "    'y': rho_direct,\n",
-    "    'dy': 0.1**2}"
+    "    'cov_y': 0.1**2}"
    ]
   },
   {
@@ -420,7 +420,7 @@
     "obs_deriv = {\n",
     "    'x': w_deriv,\n",
     "    'y': rho_deriv,\n",
-    "    'dy': 0.1**2}"
+    "    'cov_y': 0.1**2}"
    ]
   },
   {
@@ -622,7 +622,7 @@
     "data2d = {\n",
     "    'x': p_data,\n",
     "    'y': G + err * np.random.randn(len(G)),\n",
-    "    'dy': err**2}"
+    "    'cov_y': err**2}"
    ]
   },
   {

examples/gaussian_mixture_model.ipynb

@@ -114,7 +114,7 @@
     "data = {\n",
     "    'x': matsubara_mesh,\n",
     "    'y': noised_eucl,\n",
-    "    'dy': noise_amplitude**2 }"
+    "    'cov_y': noise_amplitude**2 }"
    ]
   },
   {

fredipy/__init__.py

@@ -8,4 +8,4 @@
 
 __all__ = ["models", "constraints", "operators", "integrators", "util", "kernels"]
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

fredipy/constraints.py

@@ -29,35 +29,35 @@ def __init__(
         ----------
         op      : operator that acts on the GP, see Operator module.
         data    : data dictionary or List or np.ndarray. \
-                  If input is List Dictionary needs position 'x' and value 'y' entries and optionally some error 'dy'. \
-                  If input is List or np.ndarray needs [**x**, **y**, **dy**] entries, where dy is optional.
+                  If input is List Dictionary, needs position 'x' and value 'y' entries and optionally some error 'cov_y'. \
+                  If input is List or np.ndarray, needs [**x**, **y**, **cov_y**] entries, where cov_y is optional.
         x       : position of the data, List or np.ndarray or number.
         y       : value of the data, List or np.ndarray or number, must have the same length as x.
-        dy      : error of the data, List or np.ndarray or number or None.
+        cov_y   : covariance of the data, List or np.ndarray or number or None.
         """
         self.op = op
 
         if isinstance(data, dict):
             x, y = make_column_vector(data['x']), make_column_vector(data['y'])
-            dy = np.array(data['dy'] if 'dy' in data else 0.)
+            cov_y = np.array(data['cov_y'] if 'cov_y' in data else 0.)
 
         if isinstance(data, list) or isinstance(data, np.ndarray):
             x, y = make_column_vector(data[0]), make_column_vector(data[1])
-            dy = np.array(data[2] if len(data) > 2 else 0.)
+            cov_y = np.array(data[2] if len(data) > 2 else 0.)
 
         len_y = y.shape[0]
         assert x.shape[0] == len_y, \
             f'Length of x/y must match, have {x.shape[0], len(y)}.'
 
-        assert (dy.shape == (len_y, len_y) or dy.shape == (len_y,) or dy.shape == (len_y, 1) or
-                dy.shape == (1, len_y) or dy.shape == (1,) or dy.shape == ()), \
-            f'Error matrix must be a matrix of shape (len(y), len(y)), a vector with len(y) or a number, \
-            have {dy.shape} with y having length {len_y}.'
+        assert (cov_y.shape == (len_y, len_y) or cov_y.shape == (len_y,) or cov_y.shape == (len_y, 1) or
+                cov_y.shape == (1, len_y) or cov_y.shape == (1,) or cov_y.shape == ()), \
+            f'Covariance must be a matrix of shape (len(y), len(y)), a vector with len(y) or a number, \
+            have {cov_y.shape} with y having length {len_y}.'
 
-        if not dy.shape == (len(y), len(y)):
-            dy = dy * np.eye(len(y))
+        if not cov_y.shape == (len(y), len(y)):
+            cov_y = cov_y * np.eye(len(y))
 
-        self.x, self.y, self.dy = x, y, dy
+        self.x, self.y, self.cov_y = x, y, cov_y
         self._op = None
         self._args: Tuple = tuple()
         self._x = None

fredipy/integrators.py

@@ -97,7 +97,7 @@ def __init__(
             ) -> None:
 
         self.w = make_column_vector(np.linspace(w_min, w_max, int_n+1))
-        self.dw = self.w[1] - self.w[0]
+        self.dw = (self.w[1] - self.w[0]).item()
         self.w = self.w[:-1] + 0.5 * self.dw  # midpoint rule
 
     def doubleIntegrationSymmetric(
@@ -116,7 +116,7 @@ def doubleIntegrationSymmetric(
                     constraint(make_row_vector(self.w), x=make_column_vector(np.array([p[i, 0]])))
                     @ kernel(np.c_[self.w, p[i, 1:] * ones_w], np.c_[self.w, p[j, 1:] * ones_w])
                     @ constraint(make_column_vector(self.w), x=make_row_vector(np.array([p[j, 0]])))
-                )
+                ).item()
 
         return tmp + tmp.T - np.diag(tmp.diagonal())
 
@@ -258,7 +258,7 @@ def __init__(
         if int_n % 2 == 0:
             int_n = int_n + 1
         self.w = make_column_vector(np.linspace(w_min, w_max, int_n))
-        self.dw = self.w[1] - self.w[0]
+        self.dw = (self.w[1] - self.w[0]).item()
         # construct array of alternating prefactors
         self.prefactors = np.empty_like(self.w)
         self.prefactors[::2] = 2
@@ -286,7 +286,7 @@ def doubleIntegrationSymmetric(
                     @ kernel(np.c_[self.w, p[i, 1:] * ones_w], np.c_[self.w, p[j, 1:] * ones_w])
                     @ (self.prefactors
                        * constraint(make_row_vector(self.w), x=make_column_vector(np.array([p[j, 0]])))).T
-                )
+                ).item()
 
         return tmp + tmp.T - np.diag(tmp.diagonal())
 

fredipy/models.py

@@ -53,7 +53,7 @@ def __init__(
         self.OpKer = OpKer
 
         self.y = np.concatenate([c.y for c in self.constraints])
-        self.dy = sp.linalg.block_diag(*[c.dy for c in self.constraints])
+        self.cov_y = sp.linalg.block_diag(*[c.cov_y for c in self.constraints])
 
         # for caching intermediate results
         self._posterior_cache: Dict[str, np.ndarray] = {}
@@ -203,7 +203,7 @@ def _maybe_prepare_posterior(self) -> None:
             OpKerOp = self.OpKerOp(
                 self.kernel, self.constraints)
             OpKerOp_cholesky = np.linalg.cholesky(
-                OpKerOp + self.dy)
+                OpKerOp + self.cov_y)
             alpha = sp.linalg.solve_triangular(
                 OpKerOp_cholesky.T,
                 sp.linalg.solve_triangular(

pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "fredipy"
 authors = [
     {name = "Jonas Turnwald", email = "jonas.turnwald@tu-darmstadt.de"},
-    {name = "Julian M. Urban", email = "tbd@tbd.com"},  # DO EMAILS!
+    {name = "Julian M. Urban", email = "jurban@mit.edu"},  # DO EMAILS!
     {name = "Nicolas Wink", email = "tbd@tbd.com"}
 ]
 classifiers = [
@@ -41,4 +41,4 @@ include = ["fredipy"]
 exclude = ["tests*", "docs", "examples", "archive"]
 
 [tool.setuptools.dynamic]
-version = {attr = "fredipy.__version__"}
+version = {attr = "fredipy.__version__"}

tests/test_data_input.py

@@ -51,7 +51,7 @@ def test_single_datapoint_integrator(x: Any) -> None:
     data = {
         'x': x,
         'y': x,
-        'dy': 0.1}
+        'cov_y': 0.1}
 
     kernel = fp.kernels.RadialBasisFunction(0.5, 0.3)
 
@@ -83,7 +83,7 @@ def test_single_datapoint_identity(x: Any) -> None:
     data = {
         'x': x,
         'y': x,
-        'dy': 0.1}
+        'cov_y': 0.1}
 
     kernel = fp.kernels.RadialBasisFunction(0.5, 0.3)
     constraints = [fp.constraints.LinearEquality(fp.operators.Identity(), data)]
@@ -96,21 +96,21 @@ def test_single_datapoint_identity(x: Any) -> None:
         assert len(_rho) == 1
 
 
-@pytest.mark.parametrize("dy", [
-    rng.rand(3, 3),
+@pytest.mark.parametrize("cov_y", [
+    rng.rand(3, 3) + 0.1 * np.eye(3),
     [0.1, 0.2, 0.3],
     0.1,
     np.array([0.1, 0.2, 0.3]),
     np.array([0.1, 0.2, 0.3]).reshape(-1, 1),
     np.array([0.1, 0.2, 0.3]).reshape(1, -1)
 ])
-def test_multiple_dy_inputs(dy: Any) -> None:
+def test_multiple_cov_y_inputs(cov_y: Any) -> None:
     x = np.array([1, 2, 3])
     y = np.array([1, 2, 3])
     data = {
         'x': x,
         'y': y,
-        'dy': dy
+        'cov_y': cov_y
     }
 
     kernel = fp.kernels.RadialBasisFunction(0.5, 0.3)
@@ -122,7 +122,7 @@ def test_multiple_dy_inputs(dy: Any) -> None:
 
 
 @pytest.mark.parametrize("data_input", [
-    {'x': [1, 2, 3], 'y': [1, 2, 3], 'dy': [0.1, 0.2, 0.3]},
+    {'x': [1, 2, 3], 'y': [1, 2, 3], 'cov_y': [0.1, 0.2, 0.3]},
     [[1, 2, 3], [1, 2, 3], [0.1, 0.2, 0.3]],
     np.array([[1, 2, 3], [1, 2, 3], [0.1, 0.2, 0.3]])
 ])

tests/test_reconstruction.py

@@ -52,7 +52,7 @@ def test_reconstruction_BW_1d() -> None:
     data = {
         'x': p,
         'y': G + err * rng.randn(len(G)),
-        'dy': err * np.ones_like(p)}
+        'cov_y': err**2 * np.ones_like(p)}
 
     # setting up the model
     kernel = fp.kernels.RadialBasisFunction(0.5, 0.3)
@@ -88,7 +88,7 @@ def test_reconstruction_BW_1d_uv_asymptotics() -> None:
     data = {
         'x': p,
         'y': G + err * rng.randn(len(G)),
-        'dy': err * np.ones_like(p)}
+        'cov_y': err**2 * np.ones_like(p)}
 
     def uv_asymptotics(x): return 1 / x**3
 
@@ -125,7 +125,7 @@ def test_standard_interpolation_1D() -> None:
     data = {
         'x': p,
         'y': G_data,
-        'dy': err}
+        'cov_y': err**2}
 
     kernel = fp.kernels.RadialBasisFunction(3., 0.4)
     identity_op = fp.operators.Identity()
@@ -152,7 +152,7 @@ def test_dressing_1D() -> None:
     data = {
         'x': p,
         'y': G_data,
-        'dy': err * np.ones_like(p)}
+        'cov_y': err**2 * np.ones_like(p)}
 
     # setting up the model
     kernel = fp.kernels.RadialBasisFunction(0.3, 0.5)