pygeoinf 1.3.1__tar.gz → 1.3.3__tar.gz

{pygeoinf-1.3.1 → pygeoinf-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeoinf
-Version: 1.3.1
+Version: 1.3.3
 Summary: A package for solving geophysical inference and inverse problems
 License: BSD-3-Clause
 License-File: LICENSE
@@ -13,10 +13,12 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: sphere
+Requires-Dist: Cartopy (>=0.23.0,<0.24.0) ; extra == "sphere"
 Requires-Dist: joblib (>=1.5.2,<2.0.0)
 Requires-Dist: matplotlib (>=3.0.0)
 Requires-Dist: numpy (>=1.26.0)
 Requires-Dist: pyqt6 (>=6.0.0)
+Requires-Dist: pyshtools (>=4.0.0) ; extra == "sphere"
 Requires-Dist: scipy (>=1.16.1)
 Description-Content-Type: text/markdown
 

pygeoinf-1.3.3/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-1.3.3/pygeoinf/checks/linear_operators.py

@@ -0,0 +1,197 @@
+"""
+Provides a self-checking mechanism for LinearOperator implementations.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+
+# Import the base checks from the sibling module
+from .nonlinear_operators import NonLinearOperatorAxiomChecks
+
+
+if TYPE_CHECKING:
+    from ..hilbert_space import Vector
+    from ..linear_forms import LinearForm
+
+
+class LinearOperatorAxiomChecks(NonLinearOperatorAxiomChecks):
+    """
+    A mixin for checking the properties of a LinearOperator.
+
+    Inherits the derivative check from NonLinearOperatorAxiomChecks and adds
+    checks for linearity and the adjoint identity.
+    """
+
+    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)
+        )
+        lhs = self(ax_plus_by)
+
+        aLx = self.codomain.multiply(a, self(x))
+        bLy = self.codomain.multiply(b, self(y))
+        rhs = self.codomain.add(aLx, bLy)
+
+        # Compare the results in the codomain
+        diff_norm = self.codomain.norm(self.codomain.subtract(lhs, rhs))
+        rhs_norm = self.codomain.norm(rhs)
+        relative_error = diff_norm / (rhs_norm + 1e-12)
+
+        if relative_error > check_rtol and diff_norm > check_atol:
+            raise AssertionError(
+                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,
+        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, rtol=check_rtol, atol=check_atol):
+            raise AssertionError(
+                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,
+        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*
+        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*
+        res1 = (a * op1).adjoint(y)
+        res2 = (a * op1.adjoint)(y)
+        _check_norm_based(res1, res2, op1.domain, "(a*A)* != a*A*")
+
+        # (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:
+            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
+        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, check_rtol=check_rtol, check_atol=check_atol)
+
+        # Now, run the linear-specific checks
+        print(
+            f"Running {n_checks} additional randomized checks for linearity and adjoints..."
+        )
+        for _ in range(n_checks):
+            x1 = self.domain.random()
+            x2 = self.domain.random()
+            y = self.codomain.random()
+            a, b = np.random.randn(), np.random.randn()
+
+            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, check_rtol=check_rtol, check_atol=check_atol
+                )
+
+        print(f"✅ All {n_checks} linear operator checks passed successfully.")

{pygeoinf-1.3.1 → pygeoinf-1.3.3}/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-1.3.1 → pygeoinf-1.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pygeoinf"
-version = "1.3.1"
+version = "1.3.3"
 description = "A package for solving geophysical inference and inverse problems"
 authors = ["David Al-Attar and Dan Heathcote"]
 readme = "README.md"
@@ -14,6 +14,10 @@ matplotlib = ">=3.0.0"
 pyqt6 = ">=6.0.0"
 joblib = "^1.5.2"
 
+# Define optional dependencies WITH versions
+pyshtools = { version = ">=4.0.0", optional = true }
+Cartopy = { version = "^0.23.0", optional = true }
+
 [tool.poetry.extras]
 sphere = ["pyshtools", "Cartopy"]
 

pygeoinf-1.3.1/pygeoinf/checks/linear_operators.py

@@ -1,124 +0,0 @@
-"""
-Provides a self-checking mechanism for LinearOperator implementations.
-"""
-
-from __future__ import annotations
-from typing import TYPE_CHECKING
-import numpy as np
-
-# Import the base checks from the sibling module
-from .nonlinear_operators import NonLinearOperatorAxiomChecks
-
-
-if TYPE_CHECKING:
-    from ..hilbert_space import Vector
-
-
-class LinearOperatorAxiomChecks(NonLinearOperatorAxiomChecks):
-    """
-    A mixin for checking the properties of a LinearOperator.
-
-    Inherits the derivative check from NonLinearOperatorAxiomChecks and adds
-    checks for linearity and the adjoint identity.
-    """
-
-    def _check_linearity(self, x: Vector, y: Vector, a: float, b: float):
-        """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)
-        )
-        lhs = self(ax_plus_by)
-
-        aLx = self.codomain.multiply(a, self(x))
-        bLy = self.codomain.multiply(b, self(y))
-        rhs = self.codomain.add(aLx, bLy)
-
-        # Compare the results in the codomain
-        diff_norm = self.codomain.norm(self.codomain.subtract(lhs, rhs))
-        rhs_norm = self.codomain.norm(rhs)
-        relative_error = diff_norm / (rhs_norm + 1e-12)
-
-        if relative_error > 1e-9:
-            raise AssertionError(
-                f"Linearity check failed: L(ax+by) != aL(x)+bL(y). Relative error: {relative_error:.2e}"
-            )
-
-    def _check_adjoint_definition(self, x: Vector, y: Vector):
-        """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):
-            raise AssertionError(
-                f"Adjoint definition failed: <L(x),y> = {lhs:.4e}, but <x,L*(y)> = {rhs:.4e}"
-            )
-
-    def _check_algebraic_identities(self, op1, op2, x, y, a):
-        """
-        Verifies the algebraic properties of the adjoint and dual operators.
-        Requires a second compatible operator (op2).
-        """
-        # --- 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*")
-
-        # (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*")
-
-        # (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")
-
-        # (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*")
-
-        # --- 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:
-        """
-        Runs all checks for the LinearOperator, including non-linear checks
-        and algebraic identities.
-        """
-        # First, run the parent (non-linear) checks from the base class
-        super().check(n_checks, op2=op2)
-
-        # Now, run the linear-specific checks
-        print(
-            f"Running {n_checks} additional randomized checks for linearity and adjoints..."
-        )
-        for _ in range(n_checks):
-            x1 = self.domain.random()
-            x2 = self.domain.random()
-            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)
-
-            if op2:
-                self._check_algebraic_identities(self, op2, x1, y, a)
-
-        print(f"✅ All {n_checks} linear operator checks passed successfully.")