pygeoinf 1.1.5__py3-none-any.whl → 1.1.6__py3-none-any.whl

pygeoinf/hilbert_space.py

@@ -118,6 +118,16 @@ class HilbertSpace(ABC):
             The corresponding vector in the space.
         """
 
+    @abstractmethod
+    def __eq__(self, other: object) -> bool:
+        """
+        Defines equality between two HilbertSpace instances.
+
+        This is an abstract method, requiring all concrete subclasses to
+        implement a meaningful comparison. This ensures that equality is
+        defined by mathematical equivalence rather than object identity.
+        """
+
     # ------------------------------------------------------------------- #
     #            Default implementations that can be overridden           #
     # ------------------------------------------------------------------- #
@@ -209,21 +219,6 @@ class HilbertSpace(ABC):
         """
         return self.from_components(np.random.randn(self.dim))
 
-    def __eq__(self, other: object) -> bool:
-        """
-        Defines equality between Hilbert spaces.
-
-        For dual spaces, equality is determined by the equality of their
-        underlying primal spaces. For non-dual spaces, this is not implemented,
-        requiring concrete subclasses to define a meaningful comparison.
-        """
-        if isinstance(self, DualHilbertSpace):
-            return (
-                isinstance(other, DualHilbertSpace)
-                and self.underlying_space == other.underlying_space
-            )
-        return NotImplemented
-
     # ------------------------------------------------------------------- #
     #                      Final (Non-Overridable) Methods                #
     # ------------------------------------------------------------------- #
@@ -498,6 +493,17 @@ class DualHilbertSpace(HilbertSpace):
 
         return LinearForm(self._underlying_space, components=c)
 
+    def __eq__(self, other: object) -> bool:
+        """
+        Checks for equality with another dual space.
+
+        Two dual spaces are considered equal if and only if their underlying
+        primal spaces are equal.
+        """
+        if not isinstance(other, DualHilbertSpace):
+            return NotImplemented
+        return self.underlying_space == other.underlying_space
+
     @final
     def duality_product(self, xp: LinearForm, x: Vector) -> float:
         """
@@ -572,6 +578,11 @@ class EuclideanSpace(HilbertSpace):
         """Maps a `LinearForm` back to a vector via its components."""
         return self.dual.to_components(xp)
 
+    def __eq__(self, other: object):
+        if not isinstance(other, EuclideanSpace):
+            return NotImplemented
+        return self.dim == other.dim
+
 
 class MassWeightedHilbertSpace(HilbertSpace):
     """
@@ -651,6 +662,22 @@ class MassWeightedHilbertSpace(HilbertSpace):
         x = self.underlying_space.from_dual(xp)
         return self._inverse_mass_operator(x)
 
+    def __eq__(self, other: object) -> bool:
+        """
+        Checks for equality with another MassWeightedHilbertSpace.
+
+        Two mass-weighted spaces are considered equal if they share an equal
+        underlying space and their mass operators are also equal.
+        """
+        if not isinstance(other, MassWeightedHilbertSpace):
+            return NotImplemented
+
+        return (
+            self.underlying_space == other.underlying_space
+            and (self.mass_operator == other.mass_operator)
+            and (self.inverse_mass_operator == other.inverse_mass_operator)
+        )
+
 
 class MassWeightedHilbertModule(MassWeightedHilbertSpace, HilbertModule):
     """

pygeoinf/operators.py

@@ -232,8 +232,6 @@ class LinearOperator(Operator):
             raise ValueError("Domain mismatch")
 
         if codomain_base != operator.codomain:
-            print(codomain_base)
-            print(operator.codomain)
             raise ValueError("Codomain mismatch")
 
         return LinearOperator(

pygeoinf/symmetric_space/sphere.py

@@ -458,8 +458,14 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
         return LinearOperator.self_adjoint(self, mapping)
 
     def __str__(self) -> str:
-        """Returns the string representation of the form's components."""
-        return f"Lebesgue space on sphere\nlmax={self.lmax}\nradius={self.radius}\ngrid={self.grid}\nextend={self.extend}"
+        """Returns a human-readable string summary of the space."""
+        return (
+            f"Lebesgue space on sphere:\n"
+            f"lmax={self.lmax}\n"
+            f"radius={self.radius}\n"
+            f"grid={self.grid}\n"
+            f"extend={self.extend}"
+        )
 
 
 class Sobolev(SphereHelper, MassWeightedHilbertModule, AbstractInvariantSobolevSpace):
@@ -610,3 +616,15 @@ class Sobolev(SphereHelper, MassWeightedHilbertModule, AbstractInvariantSobolevS
 
         c = self._coefficient_to_component(ulm)
         return self.dual.from_components(c)
+
+    def __str__(self) -> str:
+        """Returns a human-readable string summary of the space."""
+        return (
+            f"Lebesgue space on sphere:\n"
+            f"lmax={self.lmax}\n"
+            f"order={self.order}\n"
+            f"scale={self.scale}\n"
+            f"radius={self.radius}\n"
+            f"grid={self.grid}\n"
+            f"extend={self.extend}"
+        )

{pygeoinf-1.1.5.dist-info → pygeoinf-1.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pygeoinf
-Version: 1.1.5
+Version: 1.1.6
 Summary: A package for solving geophysical inference and inverse problems
 License: BSD-3-Clause
 Author: David Al-Attar and Dan Heathcote

{pygeoinf-1.1.5.dist-info → pygeoinf-1.1.6.dist-info}/RECORD

@@ -2,19 +2,19 @@ pygeoinf/__init__.py,sha256=uYRwiHKi4nvzUBwQJxNdt8OZodFQ_nj5rUv2YkDXL9Q,1185
 pygeoinf/direct_sum.py,sha256=r0h-3bK6RQiOMoq086oupYaXgUM4pFIV8XNKOB2q9BE,17095
 pygeoinf/forward_problem.py,sha256=RnnVBMg8Ih7TqZylfSkQ7pdHEowEfCkTiXiKFrxBpnM,9754
 pygeoinf/gaussian_measure.py,sha256=SFnHmEjpcrUy09AfO3fXLLB_SaGwA9oc5PU630e3hNM,22826
-pygeoinf/hilbert_space.py,sha256=42RSYoIPf0hruyysBVoeJGmsmDtTrpaet5YMZnxwgys,22429
+pygeoinf/hilbert_space.py,sha256=GIQMeU5yYDtGUv_nR9TjvJ6DJQKIVSe1JEMZy_qyLjg,23363
 pygeoinf/inversion.py,sha256=p9k_iDVgJGLM1cGlT-0rgRwqdYVdsYC_euTXZk3kuOc,3199
 pygeoinf/linear_bayesian.py,sha256=aIOzTZbjJtdtwHKh5e01iS8iMiyr8XuwGx91udS3VK4,9624
 pygeoinf/linear_forms.py,sha256=Uizipi67i1Sd6m0TzsrJd99Xreo_6V8Db0gMy76fG6g,5953
 pygeoinf/linear_optimisation.py,sha256=7lklTRRBGkz8M9WsfvkDl-eoGkc4Ty7BOJq7LWkdxCg,11091
 pygeoinf/linear_solvers.py,sha256=P9SEjZ1LZdulr2KQrZojbvdCtAm--hMd4EArSu73L34,12154
-pygeoinf/operators.py,sha256=XO2_Y8d8Qo1RqGu3c5AgnAwsPAkial--LH9qdGtVs4M,33235
+pygeoinf/operators.py,sha256=kbDfHpaWaSnd0zvoAVMBpWWiQRNfW0ImVhtzEEIH6mM,33165
 pygeoinf/random_matrix.py,sha256=_XVwXqM_c0SMpy6JU-8IboXpotug6dDDHKdSPAJpH7c,7788
 pygeoinf/symmetric_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeoinf/symmetric_space/circle.py,sha256=0EHPg2FcvWTOvCb8ualCW0uUp8RuUNfQ7oK6NHXtG1Q,17552
-pygeoinf/symmetric_space/sphere.py,sha256=BYh3-Eajdzx4YOd1cMagOG3PfqbgibSq4zSdFRg5Jg8,20768
+pygeoinf/symmetric_space/sphere.py,sha256=edxLWXMqW857hYdN54X76HZyIe0lVVFdzrtCdTHM9Oc,21234
 pygeoinf/symmetric_space/symmetric_space.py,sha256=YkRjHucc2cO7IAoyJS5KMdiRBuytRpUfTUsVMHBPZYs,16146
-pygeoinf-1.1.5.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
-pygeoinf-1.1.5.dist-info/METADATA,sha256=NPePR0GmfcViZ39WixMb1ETS8o6Ld4OjjTTHyl3id7U,15324
-pygeoinf-1.1.5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pygeoinf-1.1.5.dist-info/RECORD,,
+pygeoinf-1.1.6.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
+pygeoinf-1.1.6.dist-info/METADATA,sha256=FzoajwK5kOs47gJmHXkDrd9T1VeyPpxO9ERBFo7iJuc,15324
+pygeoinf-1.1.6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pygeoinf-1.1.6.dist-info/RECORD,,