pygeoinf 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

pygeoinf/auxiliary.py

@@ -0,0 +1,29 @@
+from .gaussian_measure import GaussianMeasure
+
+def empirical_data_error_measure(model_measure, forward_operator, n_samples=10, scale_factor=1.0):
+    """
+    Generate an empirical data error measure based on samples from a measure on the model space. Useful for when you need
+    to define a reasonable data error measure for synthetic testing, and need the covariance matrix to be easily accessible.
+    
+    Args:
+        model_measure: The measure on the model space used as a basis for the error measure (e.g., the model prior measure)
+        forward_operator: Linear operator mapping from model space to data space (e.g., operator B)
+        n_samples: Number of samples to generate for computing statistics (default: 10)
+        scale_factor: Scaling factor for the standard deviations (default: 1.0)
+
+    Returns:
+        inf.GaussianMeasure: Data error measure with empirically determined covariance
+    """
+    # Generate samples in data space by pushing forward model samples
+    data_samples = model_measure.affine_mapping(operator=forward_operator).samples(n_samples)
+    data_space = forward_operator.codomain
+    
+    # Remove the mean from each sample
+    total = data_space.zero
+    for sample in data_samples:
+        total = data_space.add(total, sample)
+    mean = data_space.multiply(1.0 / n_samples, total)
+    zeroed_samples = [data_space.multiply(scale_factor, data_space.subtract(data_sample, mean)) for data_sample in data_samples]
+
+    # Create and return the Gaussian measure from the zeroed samples
+    return GaussianMeasure.from_samples(forward_operator.codomain, zeroed_samples)

pygeoinf/checks/hilbert_space.py

@@ -46,6 +46,23 @@ class HilbertSpaceAxiomChecks:
         if not norm_sum <= self.norm(x) + self.norm(y):
             raise AssertionError("Axiom failed: Triangle inequality")
 
+    def _check_riesz_representation(self, x, y):
+        """
+        Checks that the inner product is consistent with the Riesz map (to_dual).
+        This ensures that <x, y> == (R(x))(y).
+        """
+        # Value from the (potentially optimized) direct inner product method
+        direct_inner_product = self.inner_product(x, y)
+
+        # Value from the Riesz map definition
+        dual_x = self.to_dual(x)
+        riesz_inner_product = self.duality_product(dual_x, y)
+
+        if not np.isclose(direct_inner_product, riesz_inner_product):
+            raise AssertionError(
+                "Axiom failed: Inner product is not consistent with the Riesz map."
+            )
+
     def _check_mapping_identities(self, x):
         """Checks that component and dual mappings are self-consistent."""
         # from_components(to_components(x)) == x
@@ -176,6 +193,7 @@ class HilbertSpaceAxiomChecks:
             # Run all checks
             self._check_vector_space_axioms(x, y, a)
             self._check_inner_product_axioms(x, y, z, a, b)
+            # self._check_riesz_representation(x, y)
             self._check_mapping_identities(x)
             self._check_inplace_operations(x, y, a)
             self._check_copy(x)

pygeoinf/checks/linear_operators.py

@@ -12,6 +12,7 @@ from .nonlinear_operators import NonLinearOperatorAxiomChecks
 
 if TYPE_CHECKING:
     from ..hilbert_space import Vector
+    from ..linear_forms import LinearForm
 
 
 class LinearOperatorAxiomChecks(NonLinearOperatorAxiomChecks):
@@ -22,7 +23,15 @@ class LinearOperatorAxiomChecks(NonLinearOperatorAxiomChecks):
     checks for linearity and the adjoint identity.
     """
 
-    def _check_linearity(self, x: Vector, y: Vector, a: float, b: float):
+    def _check_linearity(
+        self,
+        x: Vector,
+        y: Vector,
+        a: float,
+        b: float,
+        check_rtol: float = 1e-5,
+        check_atol: float = 1e-8,
+    ):
         """Verifies the linearity property: L(ax + by) = a*L(x) + b*L(y)"""
         ax_plus_by = self.domain.add(
             self.domain.multiply(a, x), self.domain.multiply(b, y)
@@ -38,72 +47,130 @@ class LinearOperatorAxiomChecks(NonLinearOperatorAxiomChecks):
         rhs_norm = self.codomain.norm(rhs)
         relative_error = diff_norm / (rhs_norm + 1e-12)
 
-        if relative_error > 1e-9:
+        if relative_error > check_rtol and diff_norm > check_atol:
             raise AssertionError(
-                f"Linearity check failed: L(ax+by) != aL(x)+bL(y). Relative error: {relative_error:.2e}"
+                f"Linearity check failed: L(ax+by) != aL(x)+bL(y). "
+                f"Relative error: {relative_error:.2e} (Tol: {check_rtol:.2e}), "
+                f"Absolute error: {diff_norm:.2e} (Tol: {check_atol:.2e})"
             )
 
-    def _check_adjoint_definition(self, x: Vector, y: Vector):
+    def _check_adjoint_definition(
+        self,
+        x: Vector,
+        y: Vector,
+        check_rtol: float = 1e-5,
+        check_atol: float = 1e-8,
+    ):
         """Verifies the adjoint identity: <L(x), y> = <x, L*(y)>"""
         lhs = self.codomain.inner_product(self(x), y)
         rhs = self.domain.inner_product(x, self.adjoint(y))
 
-        if not np.isclose(lhs, rhs):
+        if not np.isclose(lhs, rhs, rtol=check_rtol, atol=check_atol):
             raise AssertionError(
-                f"Adjoint definition failed: <L(x),y> = {lhs:.4e}, but <x,L*(y)> = {rhs:.4e}"
+                f"Adjoint definition failed: <L(x),y> = {lhs:.4e}, "
+                f"but <x,L*(y)> = {rhs:.4e} (RelTol: {check_rtol:.2e}, AbsTol: {check_atol:.2e})"
             )
 
-    def _check_algebraic_identities(self, op1, op2, x, y, a):
+    def _check_algebraic_identities(
+        self,
+        op1,
+        op2,
+        x,
+        y,
+        a,
+        check_rtol: float = 1e-5,
+        check_atol: float = 1e-8,
+    ):
         """
         Verifies the algebraic properties of the adjoint and dual operators.
         Requires a second compatible operator (op2).
         """
+
+        def _check_norm_based(res1, res2, space, axiom_name):
+            """Helper to perform norm-based comparison."""
+            diff_norm = space.norm(space.subtract(res1, res2))
+            norm_res2 = space.norm(res2)
+            if diff_norm > check_atol and diff_norm > check_rtol * (norm_res2 + 1e-12):
+                raise AssertionError(
+                    f"Axiom failed: {axiom_name}. "
+                    f"Absolute error: {diff_norm:.2e}, Relative error: {diff_norm / (norm_res2 + 1e-12):.2e}"
+                )
+
         # --- Adjoint Identities ---
         # (A+B)* = A* + B*
-        op_sum_adj = (op1 + op2).adjoint
-        adj_sum = op1.adjoint + op2.adjoint
-        diff = op1.domain.subtract(op_sum_adj(y), adj_sum(y))
-        if op1.domain.norm(diff) > 1e-9:
-            raise AssertionError("Axiom failed: (A+B)* != A* + B*")
+        res1 = (op1 + op2).adjoint(y)
+        res2 = (op1.adjoint + op2.adjoint)(y)
+        _check_norm_based(res1, res2, op1.domain, "(A+B)* != A* + B*")
 
         # (a*A)* = a*A*
-        op_scaled_adj = (a * op1).adjoint
-        adj_scaled = a * op1.adjoint
-        diff = op1.domain.subtract(op_scaled_adj(y), adj_scaled(y))
-        if op1.domain.norm(diff) > 1e-9:
-            raise AssertionError("Axiom failed: (a*A)* != a*A*")
+        res1 = (a * op1).adjoint(y)
+        res2 = (a * op1.adjoint)(y)
+        _check_norm_based(res1, res2, op1.domain, "(a*A)* != a*A*")
 
         # (A*)* = A
-        op_adj_adj = op1.adjoint.adjoint
-        diff = op1.codomain.subtract(op_adj_adj(x), op1(x))
-        if op1.codomain.norm(diff) > 1e-9:
-            raise AssertionError("Axiom failed: (A*)* != A")
+        res1 = op1.adjoint.adjoint(x)
+        res2 = op1(x)
+        _check_norm_based(res1, res2, op1.codomain, "(A*)* != A")
 
         # (A@B)* = B*@A*
         if op1.domain == op2.codomain:
-            op_comp_adj = (op1 @ op2).adjoint
-            adj_comp = op2.adjoint @ op1.adjoint
-            diff = op2.domain.subtract(op_comp_adj(y), adj_comp(y))
-            if op2.domain.norm(diff) > 1e-9:
-                raise AssertionError("Axiom failed: (A@B)* != B*@A*")
+            res1 = (op1 @ op2).adjoint(y)
+            res2 = (op2.adjoint @ op1.adjoint)(y)
+            _check_norm_based(res1, res2, op2.domain, "(A@B)* != B*@A*")
 
         # --- Dual Identities ---
         # (A+B)' = A' + B'
         op_sum_dual = (op1 + op2).dual
         dual_sum = op1.dual + op2.dual
         y_dual = op1.codomain.to_dual(y)
-        # The result of applying a dual operator is a LinearForm, which supports subtraction
-        diff_dual = op_sum_dual(y_dual) - dual_sum(y_dual)
-        if op1.domain.dual.norm(diff_dual) > 1e-9:
-            raise AssertionError("Axiom failed: (A+B)' != A' + B'")
 
-    def check(self, n_checks: int = 5, op2=None) -> None:
+        # The result of applying a dual operator is a LinearForm
+        res1_form: LinearForm = op_sum_dual(y_dual)
+        res2_form: LinearForm = dual_sum(y_dual)
+
+        # CORRECTED: Use LinearForm subtraction and dual space norm
+        # (This assumes LinearForm overloads __sub__)
+        try:
+            diff_form = res1_form - res2_form
+            diff_norm = op1.domain.dual.norm(diff_form)
+            norm_res2 = op1.domain.dual.norm(res2_form)
+
+            if diff_norm > check_atol and diff_norm > check_rtol * (norm_res2 + 1e-12):
+                raise AssertionError(
+                    f"Axiom failed: (A+B)' != A' + B'. "
+                    f"Absolute error: {diff_norm:.2e}, Relative error: {diff_norm / (norm_res2 + 1e-12):.2e}"
+                )
+        except (AttributeError, TypeError):
+            # Fallback if LinearForm doesn't support subtraction or norm
+            if not np.allclose(
+                res1_form.components,
+                res2_form.components,
+                rtol=check_rtol,
+                atol=check_atol,
+            ):
+                raise AssertionError(
+                    "Axiom failed: (A+B)' != A' + B' (component check)."
+                )
+
+    def check(
+        self,
+        n_checks: int = 5,
+        op2=None,
+        check_rtol: float = 1e-5,
+        check_atol: float = 1e-8,
+    ) -> None:
         """
         Runs all checks for the LinearOperator, including non-linear checks
         and algebraic identities.
+
+        Args:
+            n_checks: The number of randomized trials to perform.
+            op2: An optional second operator for testing algebraic rules.
+            check_rtol: The relative tolerance for numerical checks.
+            check_atol: The absolute tolerance for numerical checks.
         """
         # First, run the parent (non-linear) checks from the base class
-        super().check(n_checks, op2=op2)
+        super().check(n_checks, op2=op2, check_rtol=check_rtol, check_atol=check_atol)
 
         # Now, run the linear-specific checks
         print(
@@ -115,10 +182,16 @@ class LinearOperatorAxiomChecks(NonLinearOperatorAxiomChecks):
             y = self.codomain.random()
             a, b = np.random.randn(), np.random.randn()
 
-            self._check_linearity(x1, x2, a, b)
-            self._check_adjoint_definition(x1, y)
+            self._check_linearity(
+                x1, x2, a, b, check_rtol=check_rtol, check_atol=check_atol
+            )
+            self._check_adjoint_definition(
+                x1, y, check_rtol=check_rtol, check_atol=check_atol
+            )
 
             if op2:
-                self._check_algebraic_identities(self, op2, x1, y, a)
+                self._check_algebraic_identities(
+                    self, op2, x1, y, a, check_rtol=check_rtol, check_atol=check_atol
+                )
 
         print(f"✅ All {n_checks} linear operator checks passed successfully.")

pygeoinf/checks/nonlinear_operators.py

@@ -13,7 +13,9 @@ if TYPE_CHECKING:
 class NonLinearOperatorAxiomChecks:
     """A mixin for checking the properties of a NonLinearOperator."""
 
-    def _check_derivative_finite_difference(self, x, v, h=1e-7):
+    def _check_derivative_finite_difference(
+        self, x, v, h=1e-7, check_rtol: float = 1e-5, check_atol: float = 1e-8
+    ):
         """
         Verifies the derivative using the finite difference formula:
         D[F](x) @ v  ≈  (F(x + h*v) - F(x)) / h
@@ -49,12 +51,20 @@ class NonLinearOperatorAxiomChecks:
         analytic_norm = self.codomain.norm(analytic_result)
         relative_error = diff_norm / (analytic_norm + 1e-12)
 
-        if relative_error > 1e-4:
+        # The finite difference method itself has an error, so we use
+        # the max of the requested rtol and a default 1e-4.
+        effective_rtol = max(check_rtol, 1e-4)
+
+        if relative_error > effective_rtol and diff_norm > check_atol:
             raise AssertionError(
-                f"Finite difference check failed. Relative error: {relative_error:.2e}"
+                f"Finite difference check failed. Relative error: {relative_error:.2e} "
+                f"(Tolerance: {effective_rtol:.2e}), "
+                f"Absolute error: {diff_norm:.2e} (Tol: {check_atol:.2e})"
             )
 
-    def _check_add_derivative(self, op1, op2, x, v):
+    def _check_add_derivative(
+        self, op1, op2, x, v, check_rtol: float = 1e-5, check_atol: float = 1e-8
+    ):
         """Verifies the sum rule for derivatives: (F+G)' = F' + G'"""
         if not (op1.has_derivative and op2.has_derivative):
             return  # Skip if derivatives aren't defined
@@ -70,11 +80,19 @@ class NonLinearOperatorAxiomChecks:
         res1 = derivative_of_sum(v)
         res2 = sum_of_derivatives(v)
 
-        diff_norm = self.codomain.norm(self.codomain.subtract(res1, res2))
-        if diff_norm > 1e-9:
-            raise AssertionError("Axiom failed: Derivative of sum is incorrect.")
+        # CORRECTED: Use norm-based comparison, not np.allclose
+        diff_norm = op1.codomain.norm(op1.codomain.subtract(res1, res2))
+        norm_res2 = op1.codomain.norm(res2)
+
+        if diff_norm > check_atol and diff_norm > check_rtol * (norm_res2 + 1e-12):
+            raise AssertionError(
+                f"Axiom failed: Derivative of sum is incorrect. "
+                f"Absolute error: {diff_norm:.2e}, Relative error: {diff_norm / (norm_res2 + 1e-12):.2e}"
+            )
 
-    def _check_scalar_mul_derivative(self, op, x, v, a):
+    def _check_scalar_mul_derivative(
+        self, op, x, v, a, check_rtol: float = 1e-5, check_atol: float = 1e-8
+    ):
         """Verifies the scalar multiple rule: (a*F)' = a*F'"""
         if not op.has_derivative:
             return
@@ -90,13 +108,19 @@ class NonLinearOperatorAxiomChecks:
         res1 = derivative_of_scaled(v)
         res2 = scaled_derivative(v)
 
-        diff_norm = self.codomain.norm(self.codomain.subtract(res1, res2))
-        if diff_norm > 1e-9:
+        # CORRECTED: Use norm-based comparison
+        diff_norm = op.codomain.norm(op.codomain.subtract(res1, res2))
+        norm_res2 = op.codomain.norm(res2)
+
+        if diff_norm > check_atol and diff_norm > check_rtol * (norm_res2 + 1e-12):
             raise AssertionError(
-                "Axiom failed: Derivative of scalar multiple is incorrect."
+                f"Axiom failed: Derivative of scalar multiple is incorrect. "
+                f"Absolute error: {diff_norm:.2e}, Relative error: {diff_norm / (norm_res2 + 1e-12):.2e}"
             )
 
-    def _check_matmul_derivative(self, op1, op2, x, v):
+    def _check_matmul_derivative(
+        self, op1, op2, x, v, check_rtol: float = 1e-5, check_atol: float = 1e-8
+    ):
         """Verifies the chain rule for derivatives: (F o G)'(x) = F'(G(x)) @ G'(x)"""
         if not (op1.has_derivative and op2.has_derivative):
             return
@@ -115,13 +139,23 @@ class NonLinearOperatorAxiomChecks:
         res1 = derivative_of_composed(v)
         res2 = chain_rule_derivative(v)
 
+        # CORRECTED: Use norm-based comparison
         diff_norm = op1.codomain.norm(op1.codomain.subtract(res1, res2))
-        if diff_norm > 1e-9:
+        norm_res2 = op1.codomain.norm(res2)
+
+        if diff_norm > check_atol and diff_norm > check_rtol * (norm_res2 + 1e-12):
             raise AssertionError(
-                "Axiom failed: Chain rule for derivatives is incorrect."
+                f"Axiom failed: Chain rule for derivatives is incorrect. "
+                f"Absolute error: {diff_norm:.2e}, Relative error: {diff_norm / (norm_res2 + 1e-12):.2e}"
             )
 
-    def check(self, n_checks: int = 5, op2=None) -> None:
+    def check(
+        self,
+        n_checks: int = 5,
+        op2=None,
+        check_rtol: float = 1e-5,
+        check_atol: float = 1e-8,
+    ) -> None:
         """
         Runs randomized checks to validate the operator's derivative and
         its algebraic properties.
@@ -129,6 +163,8 @@ class NonLinearOperatorAxiomChecks:
         Args:
             n_checks: The number of randomized trials to perform.
             op2: An optional second operator for testing algebraic rules.
+            check_rtol: The relative tolerance for numerical checks.
+            check_atol: The absolute tolerance for numerical checks.
         """
         print(
             f"\nRunning {n_checks} randomized checks for {self.__class__.__name__}..."
@@ -143,12 +179,20 @@ class NonLinearOperatorAxiomChecks:
                 v = self.domain.random()
 
             # Original check
-            self._check_derivative_finite_difference(x, v)
+            self._check_derivative_finite_difference(
+                x, v, check_rtol=check_rtol, check_atol=check_atol
+            )
 
             # New algebraic checks
-            self._check_scalar_mul_derivative(self, x, v, a)
+            self._check_scalar_mul_derivative(
+                self, x, v, a, check_rtol=check_rtol, check_atol=check_atol
+            )
             if op2:
-                self._check_add_derivative(self, op2, x, v)
-                self._check_matmul_derivative(self, op2, x, v)
+                self._check_add_derivative(
+                    self, op2, x, v, check_rtol=check_rtol, check_atol=check_atol
+                )
+                self._check_matmul_derivative(
+                    self, op2, x, v, check_rtol=check_rtol, check_atol=check_atol
+                )
 
         print(f"✅ All {n_checks} non-linear operator checks passed successfully.")

pygeoinf/gaussian_measure.py

@@ -21,6 +21,7 @@ Key Features
 
 from __future__ import annotations
 from typing import Callable, Optional, Any, List, TYPE_CHECKING
+import warnings
 
 import numpy as np
 from scipy.linalg import eigh
@@ -197,6 +198,7 @@ class GaussianMeasure:
         /,
         *,
         expectation: Vector = None,
+        rtol: float = 1e-10,
     ) -> GaussianMeasure:
         """
         Creates a Gaussian measure from a dense covariance matrix.
@@ -205,15 +207,36 @@ class GaussianMeasure:
         the covariance operator. This method computes a Cholesky-like
         decomposition of the matrix to create a `covariance_factor`.
 
+        It includes a check to handle numerical precision issues, allowing for
+        eigenvalues that are slightly negative within a relative tolerance.
+
         Args:
             domain: The Hilbert space the measure is defined on.
             covariance_matrix: The dense covariance matrix.
             expectation: The expectation (mean) of the measure.
+            rtol: The relative tolerance used to check for negative eigenvalues.
         """
 
         eigenvalues, U = eigh(covariance_matrix)
-        if any(val < 0 for val in eigenvalues):
-            raise ValueError("Covariance matrix is not non-negative")
+
+        if np.any(eigenvalues < 0):
+            max_eig = np.max(np.abs(eigenvalues))
+            min_eig = np.min(eigenvalues)
+
+            # Check if the most negative eigenvalue is outside the tolerance
+            if min_eig < -rtol * max_eig:
+                raise ValueError(
+                    "Covariance matrix has significantly negative eigenvalues, "
+                    "indicating it is not positive semi-definite."
+                )
+            else:
+                # If negative eigenvalues are within tolerance, warn and correct
+                warnings.warn(
+                    "Covariance matrix has small negative eigenvalues due to "
+                    "numerical error. Clipping them to zero.",
+                    UserWarning,
+                )
+                eigenvalues[eigenvalues < 0] = 0
 
         values = np.sqrt(eigenvalues)
         D = diags([values], [0])
@@ -466,24 +489,57 @@ class GaussianMeasure:
                 sample=new_sample if self.sample_set else None,
             )
 
-    def as_multivariate_normal(self) -> multivariate_normal:
+    def as_multivariate_normal(
+        self, /, *, parallel: bool = False, n_jobs: int = -1
+    ) -> multivariate_normal:
         """
         Returns the measure as a `scipy.stats.multivariate_normal` object.
 
         This is only possible if the measure is defined on a EuclideanSpace.
-        """
 
+        If the covariance matrix has small negative eigenvalues due to numerical
+        precision issues, this method attempts to correct them by setting them
+        to zero.
+
+        Args:
+            parallel (bool, optional): If `True`, computes the dense covariance
+                matrix in parallel. Defaults to `False`.
+            n_jobs (int, optional): The number of parallel jobs to use. `-1`
+                uses all available cores. Defaults to -1.
+        """
         if not isinstance(self.domain, EuclideanSpace):
             raise NotImplementedError(
                 "Method only defined for measures on Euclidean space."
             )
 
-        return multivariate_normal(
-            mean=self.expectation,
-            cov=self.covariance.matrix(dense=True),
-            allow_singular=True,
+        mean_vector = self.expectation
+
+        # Pass the parallelization arguments directly to the matrix creation method
+        cov_matrix = self.covariance.matrix(
+            dense=True, parallel=parallel, n_jobs=n_jobs
         )
 
+        try:
+            # First, try to create the distribution directly.
+            return multivariate_normal(
+                mean=mean_vector, cov=cov_matrix, allow_singular=True
+            )
+        except ValueError:
+            # If it fails, clean the covariance matrix and try again.
+            warnings.warn(
+                "Covariance matrix is not positive semi-definite due to "
+                "numerical errors. Setting negative eigenvalues to zero.",
+                UserWarning,
+            )
+
+            eigenvalues, eigenvectors = eigh(cov_matrix)
+            eigenvalues[eigenvalues < 0] = 0
+            cleaned_cov = eigenvectors @ diags(eigenvalues) @ eigenvectors.T
+
+            return multivariate_normal(
+                mean=mean_vector, cov=cleaned_cov, allow_singular=True
+            )
+
     def low_rank_approximation(
         self,
         size_estimate: int,

pygeoinf/hilbert_space.py

@@ -166,6 +166,22 @@ class HilbertSpace(ABC, HilbertSpaceAxiomChecks):
         """
         return isinstance(x, type(self.zero))
 
+    def inner_product(self, x1: Vector, x2: Vector) -> float:
+        """
+        Computes the inner product of two vectors, `(x1, x2)`.
+
+        This is defined via the duality product as `<R(x1), x2>`, where `R` is
+        the Riesz map (`to_dual`).
+
+        Args:
+            x1: The first vector.
+            x2: The second vector.
+
+        Returns:
+            The inner product as a float.
+        """
+        return self.duality_product(self.to_dual(x1), x2)
+
     def duality_product(self, xp: LinearForm, x: Vector) -> float:
         """
         Computes the duality product <xp, x>.
@@ -293,23 +309,6 @@ class HilbertSpace(ABC, HilbertSpaceAxiomChecks):
 
         return LinearOperator.self_dual(self, self.to_dual)
 
-    @final
-    def inner_product(self, x1: Vector, x2: Vector) -> float:
-        """
-        Computes the inner product of two vectors, `(x1, x2)`.
-
-        This is defined via the duality product as `<R(x1), x2>`, where `R` is
-        the Riesz map (`to_dual`).
-
-        Args:
-            x1: The first vector.
-            x2: The second vector.
-
-        Returns:
-            The inner product as a float.
-        """
-        return self.duality_product(self.to_dual(x1), x2)
-
     @final
     def squared_norm(self, x: Vector) -> float:
         """
@@ -588,6 +587,15 @@ class EuclideanSpace(HilbertSpace):
         """Maps a `LinearForm` back to a vector via its components."""
         return self.dual.to_components(xp)
 
+    def inner_product(self, x1: np.ndarray, x2: np.ndarray) -> float:
+        """
+        Computes the inner product of two vectors.
+
+        Notes:
+            Default implementation overrident for efficiency.
+        """
+        return np.dot(x1, x2)
+
     def __eq__(self, other: object):
         if not isinstance(other, EuclideanSpace):
             return NotImplemented
@@ -597,7 +605,7 @@ class EuclideanSpace(HilbertSpace):
         """
         Checks if an object is a valid element of the space.
         """
-        return isinstance(x, np.ndarray) and len(x) == self.dim
+        return isinstance(x, np.ndarray) and x.shape == (self.dim,)
 
 
 class MassWeightedHilbertSpace(HilbertSpace):
@@ -678,6 +686,15 @@ class MassWeightedHilbertSpace(HilbertSpace):
         x = self.underlying_space.from_dual(xp)
         return self._inverse_mass_operator(x)
 
+    def inner_product(self, x1: Vector, x2: Vector) -> float:
+        """
+        Computes the inner product of two vectors.
+
+        Notes:
+            Default implementation overrident for efficiency.
+        """
+        return self._underlying_space.inner_product(self._mass_operator(x1), x2)
+
     def __eq__(self, other: object) -> bool:
         """
         Checks for equality with another MassWeightedHilbertSpace.

pygeoinf/plot.py

@@ -0,0 +1,350 @@
+import matplotlib.pyplot as plt
+import matplotlib.colors as colors
+import numpy as np
+import scipy.stats as stats
+from typing import Union, List, Optional
+
+def plot_1d_distributions(
+    posterior_measures: Union[object, List[object]],
+    prior_measures: Optional[Union[object, List[object]]] = None,
+    true_value: Optional[float] = None,
+    xlabel: str = "Property Value",
+    title: str = "Prior and Posterior Probability Distributions",
+    figsize: tuple = (12, 7),
+    show_plot: bool = True
+):
+    """
+    Plot 1D probability distributions for prior and posterior measures using dual y-axes.
+    
+    Args:
+        posterior_measures: Single measure or list of measures for posterior distributions
+        prior_measures: Single measure or list of measures for prior distributions (optional)
+        true_value: True value to mark with a vertical line (optional)
+        xlabel: Label for x-axis
+        title: Title for the plot
+        figsize: Figure size tuple
+        show_plot: Whether to display the plot
+        
+    Returns:
+        fig, (ax1, ax2): Figure and axes objects
+    """
+    
+    # Convert single measures to lists for uniform handling
+    if not isinstance(posterior_measures, list):
+        posterior_measures = [posterior_measures]
+    
+    if prior_measures is not None and not isinstance(prior_measures, list):
+        prior_measures = [prior_measures]
+    
+    # Define color sequences
+    prior_colors = ['green', 'orange', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan']
+    posterior_colors = ['blue', 'red', 'darkgreen', 'orange', 'purple', 'brown', 'pink', 'gray']
+    
+    # Calculate statistics for all distributions
+    posterior_stats = []
+    for measure in posterior_measures:
+        if hasattr(measure, 'expectation') and hasattr(measure, 'covariance'):
+            # For pygeoinf measures
+            mean = measure.expectation[0]
+            var = measure.covariance.matrix(dense=True)[0, 0]
+            std = np.sqrt(var)
+        else:
+            # For scipy distributions
+            mean = measure.mean[0]
+            std = np.sqrt(measure.cov[0, 0])
+        posterior_stats.append((mean, std))
+    
+    prior_stats = []
+    if prior_measures is not None:
+        for measure in prior_measures:
+            if hasattr(measure, 'expectation') and hasattr(measure, 'covariance'):
+                # For pygeoinf measures
+                mean = measure.expectation[0]
+                var = measure.covariance.matrix(dense=True)[0, 0]
+                std = np.sqrt(var)
+            else:
+                # For scipy distributions
+                mean = measure.mean[0]
+                std = np.sqrt(measure.cov[0, 0])
+            prior_stats.append((mean, std))
+    
+    # Determine plot range to include all distributions
+    all_means = [stat[0] for stat in posterior_stats]
+    all_stds = [stat[1] for stat in posterior_stats]
+    
+    if prior_measures is not None:
+        all_means.extend([stat[0] for stat in prior_stats])
+        all_stds.extend([stat[1] for stat in prior_stats])
+    
+    if true_value is not None:
+        all_means.append(true_value)
+        all_stds.append(0)  # No std for true value
+    
+    # Calculate x-axis range (6 sigma coverage)
+    x_min = min([mean - 6 * std for mean, std in zip(all_means, all_stds) if std > 0])
+    x_max = max([mean + 6 * std for mean, std in zip(all_means, all_stds) if std > 0])
+    
+    # Add some padding around true value if needed
+    if true_value is not None:
+        range_size = x_max - x_min
+        x_min = min(x_min, true_value - 0.1 * range_size)
+        x_max = max(x_max, true_value + 0.1 * range_size)
+    
+    x_axis = np.linspace(x_min, x_max, 1000)
+    
+    # Create the plot with two y-axes
+    fig, ax1 = plt.subplots(figsize=figsize)
+    
+    # Plot priors on the first axis (left y-axis) if provided
+    if prior_measures is not None:
+        color1 = prior_colors[0] if len(prior_measures) > 0 else 'green'
+        ax1.set_xlabel(xlabel)
+        ax1.set_ylabel('Prior Probability Density', color=color1)
+        
+        for i, (measure, (mean, std)) in enumerate(zip(prior_measures, prior_stats)):
+            color = prior_colors[i % len(prior_colors)]
+            
+            # Calculate PDF values using scipy.stats
+            pdf_values = stats.norm.pdf(x_axis, loc=mean, scale=std)
+            
+            # Determine label
+            if len(prior_measures) == 1:
+                label = f'Prior PDF (Mean: {mean:.5f})'
+            else:
+                label = f'Prior {i+1} (Mean: {mean:.5f})'
+            
+            ax1.plot(x_axis, pdf_values, color=color, lw=2, linestyle=':', label=label)
+            ax1.fill_between(x_axis, pdf_values, color=color, alpha=0.15)
+        
+        ax1.tick_params(axis='y', labelcolor=color1)
+        ax1.grid(True, linestyle='--')
+    else:
+        # If no priors, use the left axis for posteriors
+        ax1.set_xlabel(xlabel)
+        ax1.set_ylabel('Probability Density')
+        ax1.grid(True, linestyle='--')
+    
+    # Create second y-axis for posteriors (or use first if no priors)
+    if prior_measures is not None:
+        ax2 = ax1.twinx()
+        color2 = posterior_colors[0] if len(posterior_measures) > 0 else 'blue'
+        ax2.set_ylabel('Posterior Probability Density', color=color2)
+        ax2.tick_params(axis='y', labelcolor=color2)
+        ax2.grid(False)
+        plot_ax = ax2
+    else:
+        plot_ax = ax1
+        color2 = posterior_colors[0] if len(posterior_measures) > 0 else 'blue'
+    
+    # Plot posteriors
+    for i, (measure, (mean, std)) in enumerate(zip(posterior_measures, posterior_stats)):
+        color = posterior_colors[i % len(posterior_colors)]
+        
+        # Calculate PDF values using scipy.stats
+        pdf_values = stats.norm.pdf(x_axis, loc=mean, scale=std)
+        
+        # Determine label
+        if len(posterior_measures) == 1:
+            label = f'Posterior PDF (Mean: {mean:.5f})'
+        else:
+            label = f'Posterior {i+1} (Mean: {mean:.5f})'
+        
+        plot_ax.plot(x_axis, pdf_values, color=color, lw=2, label=label)
+        plot_ax.fill_between(x_axis, pdf_values, color=color, alpha=0.2)
+    
+    # Plot true value if provided
+    if true_value is not None:
+        ax1.axvline(true_value, color='black', linestyle='-', lw=2, 
+                   label=f'True Value: {true_value:.5f}')
+    
+    # Create combined legend
+    handles1, labels1 = ax1.get_legend_handles_labels()
+    
+    if prior_measures is not None:
+        handles2, labels2 = ax2.get_legend_handles_labels()
+        all_handles = handles1 + handles2
+        all_labels = [h.get_label() for h in all_handles]
+    else:
+        all_handles = handles1
+        all_labels = [h.get_label() for h in all_handles]
+    
+    fig.legend(all_handles, all_labels, loc='upper right', bbox_to_anchor=(0.9, 0.9))
+    fig.suptitle(title, fontsize=16)
+    fig.tight_layout(rect=[0, 0, 1, 0.96])
+    
+    if show_plot:
+        plt.show()
+    
+    if prior_measures is not None:
+        return fig, (ax1, ax2)
+    else:
+        return fig, ax1
+
+
+def plot_corner_distributions(
+    posterior_measure: object,
+    true_values: Optional[Union[List[float], np.ndarray]] = None,
+    labels: Optional[List[str]] = None,
+    title: str = "Joint Posterior Distribution",
+    figsize: Optional[tuple] = None,
+    show_plot: bool = True,
+    include_sigma_contours: bool = True,
+    colormap: str = "Blues"
+):
+    """
+    Create a corner plot for multi-dimensional posterior distributions.
+    
+    Args:
+        posterior_measure: Multi-dimensional posterior measure (pygeoinf object)
+        true_values: True values for each dimension (optional)
+        labels: Labels for each dimension (optional)
+        title: Title for the plot
+        figsize: Figure size tuple (if None, calculated based on dimensions)
+        show_plot: Whether to display the plot
+        include_sigma_contours: Whether to include 1-sigma contour lines
+        colormap: Colormap for 2D plots
+        
+    Returns:
+        fig, axes: Figure and axes array
+    """
+    
+    # Extract statistics from the measure
+    if hasattr(posterior_measure, 'expectation') and hasattr(posterior_measure, 'covariance'):
+        mean_posterior = posterior_measure.expectation
+        cov_posterior = posterior_measure.covariance.matrix(dense=True, parallel=True)
+    else:
+        raise ValueError("posterior_measure must have 'expectation' and 'covariance' attributes")
+    
+    n_dims = len(mean_posterior)
+    
+    # Set default labels if not provided
+    if labels is None:
+        labels = [f"Dimension {i+1}" for i in range(n_dims)]
+    
+    # Set figure size based on dimensions if not provided
+    if figsize is None:
+        figsize = (3 * n_dims, 3 * n_dims)
+    
+    # Create subplots
+    fig, axes = plt.subplots(n_dims, n_dims, figsize=figsize)
+    fig.suptitle(title, fontsize=16)
+    
+    # Ensure axes is always 2D array
+    if n_dims == 1:
+        axes = np.array([[axes]])
+    elif n_dims == 2:
+        axes = axes.reshape(2, 2)
+    
+    # Initialize pcm variable for colorbar
+    pcm = None
+    
+    for i in range(n_dims):
+        for j in range(n_dims):
+            ax = axes[i, j]
+            
+            if i == j:  # Diagonal plots (1D marginal distributions)
+                mu = mean_posterior[i]
+                sigma = np.sqrt(cov_posterior[i, i])
+                
+                # Create x-axis range
+                x = np.linspace(mu - 4 * sigma, mu + 4 * sigma, 200)
+                pdf = stats.norm.pdf(x, mu, sigma)
+                
+                # Plot the PDF
+                ax.plot(x, pdf, "darkblue", label="Posterior PDF")
+                ax.fill_between(x, pdf, color="lightblue", alpha=0.6)
+                
+                # Add true value if provided
+                if true_values is not None:
+                    true_val = true_values[i]
+                    ax.axvline(true_val, color="black", linestyle="-", 
+                              label=f"True: {true_val:.2f}")
+                
+                ax.set_xlabel(labels[i])
+                ax.set_ylabel("Density" if i == 0 else "")
+                ax.set_yticklabels([])
+            
+            elif i > j:  # Lower triangle: 2D joint distributions
+                # Extract 2D mean and covariance
+                mean_2d = np.array([mean_posterior[j], mean_posterior[i]])
+                cov_2d = np.array([
+                    [cov_posterior[j, j], cov_posterior[j, i]],
+                    [cov_posterior[i, j], cov_posterior[i, i]]
+                ])
+                
+                # Create 2D grid
+                sigma_j = np.sqrt(cov_posterior[j, j])
+                sigma_i = np.sqrt(cov_posterior[i, i])
+                
+                x_range = np.linspace(mean_2d[0] - 3.5 * sigma_j, 
+                                    mean_2d[0] + 3.5 * sigma_j, 100)
+                y_range = np.linspace(mean_2d[1] - 3.5 * sigma_i, 
+                                    mean_2d[1] + 3.5 * sigma_i, 100)
+                
+                X, Y = np.meshgrid(x_range, y_range)
+                pos = np.dstack((X, Y))
+                
+                # Calculate PDF values
+                rv = stats.multivariate_normal(mean_2d, cov_2d)
+                Z = rv.pdf(pos)
+                
+                # Create filled contour plot using pcolormesh like the original
+                pcm = ax.pcolormesh(
+                    X, Y, Z, shading="auto", cmap=colormap,
+                    norm=colors.LogNorm(vmin=Z.min(), vmax=Z.max())
+                )
+                
+                # Add contour lines
+                ax.contour(X, Y, Z, colors="black", linewidths=0.5, alpha=0.6)
+                
+                # Add 1-sigma contour if requested
+                if include_sigma_contours:
+                    # Calculate 1-sigma level (approximately 39% of peak for 2D Gaussian)
+                    sigma_level = rv.pdf(mean_2d) * np.exp(-0.5)
+                    ax.contour(X, Y, Z, levels=[sigma_level], colors="red", 
+                              linewidths=1, linestyles="--", alpha=0.8)
+                
+                # Plot mean point
+                ax.plot(mean_posterior[j], mean_posterior[i], "r+", 
+                       markersize=10, mew=2, label="Posterior Mean")
+                
+                # Plot true value if provided
+                if true_values is not None:
+                    ax.plot(true_values[j], true_values[i], "kx", 
+                           markersize=10, mew=2, label="True Value")
+                
+                ax.set_xlabel(labels[j])
+                ax.set_ylabel(labels[i])
+            
+            else:  # Upper triangle: hide these plots
+                ax.axis("off")
+    
+    # Create legend similar to the original
+    handles, labels_leg = axes[0, 0].get_legend_handles_labels()
+    if n_dims > 1:
+        handles2, labels2 = axes[1, 0].get_legend_handles_labels()
+        handles.extend(handles2)
+        labels_leg.extend(labels2)
+    
+    # Clean up labels by removing values after colons
+    cleaned_labels = [label.split(":")[0] for label in labels_leg]
+    
+    fig.legend(
+        handles, cleaned_labels,
+        loc="upper right", 
+        bbox_to_anchor=(0.9, 0.95)
+    )
+    
+    # Adjust main plot layout to make room on the right for the colorbar
+    plt.tight_layout(rect=[0, 0, 0.88, 0.96])
+    
+    # Add a colorbar if we have 2D plots
+    if n_dims > 1 and pcm is not None:
+        cbar_ax = fig.add_axes([0.9, 0.15, 0.03, 0.7])
+        cbar = fig.colorbar(pcm, cax=cbar_ax)
+        cbar.set_label("Probability Density", size=12)
+    
+    if show_plot:
+        plt.show()
+    
+    return fig, axes

pygeoinf/symmetric_space/circle.py

@@ -158,11 +158,11 @@ class CircleHelper:
         """
         return np.fromiter((f(theta) for theta in self.angles()), float)
 
-    def to_coefficient(self, u: np.ndarray) -> np.ndarray:
+    def to_coefficients(self, u: np.ndarray) -> np.ndarray:
         """Maps a function vector to its complex Fourier coefficients."""
         return rfft(u) * self.fft_factor
 
-    def from_coefficient(self, coeff: np.ndarray) -> np.ndarray:
+    def from_coefficients(self, coeff: np.ndarray) -> np.ndarray:
         """Maps complex Fourier coefficients to a function vector."""
         return irfft(coeff, n=2 * self.kmax) * self._inverse_fft_factor
 
@@ -235,7 +235,7 @@ class CircleHelper:
         # a minimal, non-redundant representation.
         return np.concatenate((coeff.real, coeff.imag[1 : self.kmax]))
 
-    def _component_to_coefficient(self, c: np.ndarray) -> np.ndarray:
+    def _component_to_coefficients(self, c: np.ndarray) -> np.ndarray:
         """Unpacks a real component vector into complex Fourier coefficients."""
         # This is the inverse of `_coefficient_to_component`. It reconstructs
         # the full complex coefficient array that irfft expects. We re-insert
@@ -290,26 +290,26 @@ class Lebesgue(CircleHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
     def to_components(self, u: np.ndarray) -> np.ndarray:
         """Converts a function vector to its real component representation."""
-        coeff = self.to_coefficient(u)
+        coeff = self.to_coefficients(u)
         return self._coefficient_to_component(coeff)
 
     def from_components(self, c: np.ndarray) -> np.ndarray:
         """Converts a real component vector back to a function vector."""
-        coeff = self._component_to_coefficient(c)
-        return self.from_coefficient(coeff)
+        coeff = self._component_to_coefficients(c)
+        return self.from_coefficients(coeff)
 
     def to_dual(self, u: np.ndarray) -> "LinearForm":
         """Maps a vector `u` to its dual representation `u*`."""
-        coeff = self.to_coefficient(u)
+        coeff = self.to_coefficients(u)
         cp = self._coefficient_to_component(self._metric @ coeff)
         return self.dual.from_components(cp)
 
     def from_dual(self, up: "LinearForm") -> np.ndarray:
         """Maps a dual vector `u*` back to its primal representation `u`."""
         cp = self.dual.to_components(up)
-        dual_coeff = self._component_to_coefficient(cp)
+        dual_coeff = self._component_to_coefficients(cp)
         primal_coeff = self._inverse_metric @ dual_coeff
-        return self.from_coefficient(primal_coeff)
+        return self.from_coefficients(primal_coeff)
 
     def vector_multiply(self, x1: np.ndarray, x2: np.ndarray) -> np.ndarray:
         """
@@ -366,9 +366,9 @@ class Lebesgue(CircleHelper, HilbertModule, AbstractInvariantLebesgueSpace):
         matrix = diags([values], [0])
 
         def mapping(u):
-            coeff = self.to_coefficient(u)
+            coeff = self.to_coefficients(u)
             coeff = matrix @ coeff
-            return self.from_coefficient(coeff)
+            return self.from_coefficients(coeff)
 
         return LinearOperator.self_adjoint(self, mapping)
 
@@ -468,6 +468,31 @@ class Sobolev(
 
         return Sobolev(k, order, scale, radius=radius)
 
+    @property
+    def derivative_operator(self) -> LinearOperator:
+        """
+        Returns the derivative operator from the space to one with a lower order.
+        """
+
+        codomain = Sobolev(self.kmax, self.order - 1, self.scale, radius=self.radius)
+
+        lebesgue_space = self.underlying_space
+        k = np.arange(self.kmax + 1)
+
+        def mapping(u):
+            coeff = lebesgue_space.to_coefficients(u)
+            diff_coeff = 1j * k * coeff
+            return lebesgue_space.from_coefficients(diff_coeff)
+
+        op_L2 = LinearOperator(
+            lebesgue_space,
+            lebesgue_space,
+            mapping,
+            adjoint_mapping=lambda u: -1 * mapping(u),
+        )
+
+        return LinearOperator.from_formal_adjoint(self, codomain, op_L2)
+
     def __eq__(self, other: object) -> bool:
         """
         Checks for mathematical equality with another Sobolev space on a circle.

pygeoinf/symmetric_space/sphere.py

@@ -208,11 +208,11 @@ class SphereHelper:
 
         return u
 
-    def to_coefficient(self, u: sh.SHGrid) -> sh.SHCoeffs:
+    def to_coefficients(self, u: sh.SHGrid) -> sh.SHCoeffs:
         """Maps a function vector to its spherical harmonic coefficients."""
         return u.expand(normalization=self.normalization, csphase=self.csphase)
 
-    def from_coefficient(self, ulm: sh.SHCoeffs) -> sh.SHGrid:
+    def from_coefficients(self, ulm: sh.SHCoeffs) -> sh.SHGrid:
         """Maps spherical harmonic coefficients to a function vector."""
         grid = self.grid if self._sampling == 1 else "DH2"
         return ulm.expand(grid=grid, extend=self.extend)
@@ -393,7 +393,7 @@ class SphereHelper:
         flat_coeffs = ulm.coeffs.flatten(order="C")
         return self._sparse_coeffs_to_component @ flat_coeffs
 
-    def _component_to_coefficient(self, c: np.ndarray) -> sh.SHCoeffs:
+    def _component_to_coefficients(self, c: np.ndarray) -> sh.SHCoeffs:
         """Maps a component vector to spherical harmonic coefficients."""
         flat_coeffs = self._sparse_coeffs_to_component.T @ c
         coeffs = flat_coeffs.reshape((2, self.lmax + 1, self.lmax + 1))
@@ -435,22 +435,22 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
         return self._dim
 
     def to_components(self, u: sh.SHGrid) -> np.ndarray:
-        coeff = self.to_coefficient(u)
+        coeff = self.to_coefficients(u)
         return self._coefficient_to_component(coeff)
 
     def from_components(self, c: np.ndarray) -> sh.SHGrid:
-        coeff = self._component_to_coefficient(c)
-        return self.from_coefficient(coeff)
+        coeff = self._component_to_coefficients(c)
+        return self.from_coefficients(coeff)
 
     def to_dual(self, u: sh.SHGrid) -> LinearForm:
-        coeff = self.to_coefficient(u)
+        coeff = self.to_coefficients(u)
         cp = self._coefficient_to_component(coeff) * self.radius**2
         return self.dual.from_components(cp)
 
     def from_dual(self, up: LinearForm) -> sh.SHGrid:
         cp = self.dual.to_components(up) / self.radius**2
-        coeff = self._component_to_coefficient(cp)
-        return self.from_coefficient(coeff)
+        coeff = self._component_to_coefficients(cp)
+        return self.from_coefficients(coeff)
 
     def ax(self, a: float, x: sh.SHGrid) -> None:
         """
@@ -513,8 +513,8 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
         def mapping(u):
             c = matrix @ (self.to_components(u))
-            coeff = self._component_to_coefficient(c)
-            return self.from_coefficient(coeff)
+            coeff = self._component_to_coefficients(c)
+            return self.from_coefficients(coeff)
 
         return LinearOperator.self_adjoint(self, mapping)
 

{pygeoinf-1.3.0.dist-info → pygeoinf-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeoinf
-Version: 1.3.0
+Version: 1.3.2
 Summary: A package for solving geophysical inference and inverse problems
 License: BSD-3-Clause
 License-File: LICENSE

{pygeoinf-1.3.0.dist-info → pygeoinf-1.3.2.dist-info}/RECORD

@@ -1,12 +1,13 @@
 pygeoinf/__init__.py,sha256=vAoI6Kw2EL5koHn0EP0kbLvhtWV9gxA439PowiqkQHU,3246
+pygeoinf/auxiliary.py,sha256=lfoTt9ZH4y8SAV8dKZi5EWx1oF_JtxtBMSmlFYqJYfE,1610
 pygeoinf/backus_gilbert.py,sha256=eFi4blSwOCsg_NuH6WD4gcgjvzvu5g5WpWahGobSBdM,3694
-pygeoinf/checks/hilbert_space.py,sha256=Kr7PcOGrNIISezty0FBj5uXavIHC91yjCp2FVGNlHeE,7931
-pygeoinf/checks/linear_operators.py,sha256=RkmtAW6e5Zr6EuhX6GAt_pI0IWu2WZ-CrfjSBN_7dsU,4664
-pygeoinf/checks/nonlinear_operators.py,sha256=vB12HDX9YHJ8nNSVxG9BWzsVYTg12L5rrYbW98lPYxE,5560
+pygeoinf/checks/hilbert_space.py,sha256=07AZ6fx44PgSPjo_bjRJlVWTta1k1hhIX0TTTwMRdm8,8665
+pygeoinf/checks/linear_operators.py,sha256=LjC7X3RRimsyoLu062RNdhj1KEau3CBhBTZ4m3ZRmjI,7042
+pygeoinf/checks/nonlinear_operators.py,sha256=CoINs_Pm0lzo8nR3H70bo8Osvauiy03CA-b99MnCPjw,7532
 pygeoinf/direct_sum.py,sha256=7V0qrwFGj0GN-p_zzffefPrIB0dPu5dshLTxem1mQGE,19274
 pygeoinf/forward_problem.py,sha256=NnqWp7iMfkhHa9d-jBHzYHClaAfhKmO5D058AcJLLYg,10724
-pygeoinf/gaussian_measure.py,sha256=FezItV3QFHtVvAc_-Butr2lA4PTWjcZeKYb4I3vN7d4,23816
-pygeoinf/hilbert_space.py,sha256=0NCCG-OOHysdXYEFUs1wtJhGgOnuKvjZCZg8NJZO-DA,25331
+pygeoinf/gaussian_measure.py,sha256=bBh64xHgmLFl27krn9hkf8qDQjop_39x69cyhJgUHN8,26219
+pygeoinf/hilbert_space.py,sha256=rKF8upjHw7uw3qBKS-bsEo1J9-So0urTcmVsmJJQeog,25875
 pygeoinf/inversion.py,sha256=RV0hG2bGnciWdja0oOPKPxnFhYzufqdj-mKYNr4JJ_o,6447
 pygeoinf/linear_bayesian.py,sha256=L1cJkeHtba4fPXZ8CmiLRBtuG2fmzG228M_iEar-iP8,9643
 pygeoinf/linear_forms.py,sha256=mgZeDRegNKo8kviE68KrxkHR4gG9bf1RgsJz1MtDMCk,9181
@@ -17,12 +18,13 @@ pygeoinf/nonlinear_forms.py,sha256=t7lk-Bha7Xdk9eiwXMmS0F47oTR6jW6qQ3HkgRGk54A,7
 pygeoinf/nonlinear_operators.py,sha256=AtkDTQfGDzAnfFDIgiKfdk7uPEI-j_ZA3CNvY5A3U8w,7144
 pygeoinf/nonlinear_optimisation.py,sha256=skK1ikn9GrVYherD64Qt9WrEYHA2NAJ48msOu_J8Oig,7431
 pygeoinf/parallel.py,sha256=VVFvNHszy4wSa9LuErIsch4NAkLaZezhdN9YpRROBJo,2267
+pygeoinf/plot.py,sha256=zXY0o5MvgJUiwy3uEwTOwVdKT_5XRBKx_-9qmyalB3A,13654
 pygeoinf/random_matrix.py,sha256=71l6eAXQ2pRMleaz1lXud6O1F78ugKyp3vHcRBXhdwM,17661
 pygeoinf/symmetric_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pygeoinf/symmetric_space/circle.py,sha256=7Bz9BfSkbDnoz5-HFwTsAQE4a09jUapBePwoCK0xYWw,18007
-pygeoinf/symmetric_space/sphere.py,sha256=LN5HJsPtj7thIHAElbbtAS9F4t6HKmXEjwMUXQoGLPQ,23365
+pygeoinf/symmetric_space/circle.py,sha256=GuwVmLdHGTMxMrZfyXIPP3pz_y971ntlD5pl42lKJZ0,18796
+pygeoinf/symmetric_space/sphere.py,sha256=SYeGa70fKzasXxwPoVk3tNBtlP0QwLQe5jwW7o3AmcU,23376
 pygeoinf/symmetric_space/symmetric_space.py,sha256=pEIZZYWsdegrYCwUs3bo86JTz3d2LsXFWdRYFa0syFs,17963
-pygeoinf-1.3.0.dist-info/METADATA,sha256=UFX827ttCmk0fTTiXe4XsKx8xRqeaud3AegP6eBtE9k,16365
-pygeoinf-1.3.0.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
-pygeoinf-1.3.0.dist-info/licenses/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
-pygeoinf-1.3.0.dist-info/RECORD,,
+pygeoinf-1.3.2.dist-info/METADATA,sha256=VCh-zC2vcghWe8Ja34MCFu7xj7qZgsZmpBPqCXQhwOU,16365
+pygeoinf-1.3.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+pygeoinf-1.3.2.dist-info/licenses/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
+pygeoinf-1.3.2.dist-info/RECORD,,

{pygeoinf-1.3.0.dist-info → pygeoinf-1.3.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.0
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any