pygeoinf 1.1.5__tar.gz → 1.1.6__tar.gz

{pygeoinf-1.1.5 → pygeoinf-1.1.6}/PKG-INFO

@@ -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 → pygeoinf-1.1.6}/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-1.1.5 → pygeoinf-1.1.6}/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-1.1.5 → pygeoinf-1.1.6}/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 → pygeoinf-1.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pygeoinf"
-version = "1.1.5"
+version = "1.1.6"
 description = "A package for solving geophysical inference and inverse problems"
 authors = ["David Al-Attar and Dan Heathcote"]
 readme = "README.md"