pygeoinf 1.3.1__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/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-1.3.1.dist-info → pygeoinf-1.3.2.dist-info}/METADATA

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

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

@@ -1,8 +1,9 @@
 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=07AZ6fx44PgSPjo_bjRJlVWTta1k1hhIX0TTTwMRdm8,8665
-pygeoinf/checks/linear_operators.py,sha256=RkmtAW6e5Zr6EuhX6GAt_pI0IWu2WZ-CrfjSBN_7dsU,4664
-pygeoinf/checks/nonlinear_operators.py,sha256=vB12HDX9YHJ8nNSVxG9BWzsVYTg12L5rrYbW98lPYxE,5560
+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=bBh64xHgmLFl27krn9hkf8qDQjop_39x69cyhJgUHN8,26219
@@ -23,7 +24,7 @@ pygeoinf/symmetric_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 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.1.dist-info/METADATA,sha256=vCwJqf6JupB0xp7MdR26DAjHpuBbTG37lbBGgZjz9W0,16365
-pygeoinf-1.3.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-pygeoinf-1.3.1.dist-info/licenses/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
-pygeoinf-1.3.1.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,,