pygeoinf 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

pygeoinf/operators.py

@@ -48,8 +48,8 @@ class Operator:
 
     def __init__(
         self,
-        domain: "HilbertSpace",
-        codomain: "HilbertSpace",
+        domain: HilbertSpace,
+        codomain: HilbertSpace,
         mapping: Callable[[Any], Any],
     ) -> None:
         """
@@ -61,17 +61,17 @@ class Operator:
             mapping (callable): The function defining the mapping from the
                 domain to the codomain.
         """
-        self._domain: "HilbertSpace" = domain
-        self._codomain: "HilbertSpace" = codomain
+        self._domain: HilbertSpace = domain
+        self._codomain: HilbertSpace = codomain
         self.__mapping: Callable[[Any], Any] = mapping
 
     @property
-    def domain(self) -> "HilbertSpace":
+    def domain(self) -> HilbertSpace:
         """The domain of the operator."""
         return self._domain
 
     @property
-    def codomain(self) -> "HilbertSpace":
+    def codomain(self) -> HilbertSpace:
         """The codomain of the operator."""
         return self._codomain
 
@@ -111,8 +111,8 @@ class LinearOperator(Operator):
 
     def __init__(
         self,
-        domain: "HilbertSpace",
-        codomain: "HilbertSpace",
+        domain: HilbertSpace,
+        codomain: HilbertSpace,
         mapping: Callable[[Any], Any],
         /,
         *,
@@ -158,21 +158,21 @@ class LinearOperator(Operator):
 
     @staticmethod
     def self_dual(
-        domain: "HilbertSpace", mapping: Callable[[Any], Any]
+        domain: HilbertSpace, mapping: Callable[[Any], Any]
     ) -> LinearOperator:
         """Creates a self-dual operator."""
         return LinearOperator(domain, domain.dual, mapping, dual_mapping=mapping)
 
     @staticmethod
     def self_adjoint(
-        domain: "HilbertSpace", mapping: Callable[[Any], Any]
+        domain: HilbertSpace, mapping: Callable[[Any], Any]
     ) -> LinearOperator:
         """Creates a self-adjoint operator."""
         return LinearOperator(domain, domain, mapping, adjoint_mapping=mapping)
 
     @staticmethod
     def from_formal_adjoint(
-        domain: "HilbertSpace", codomain: "HilbertSpace", operator: LinearOperator
+        domain: HilbertSpace, codomain: HilbertSpace, operator: LinearOperator
     ) -> LinearOperator:
         """
         Constructs an operator on weighted spaces from one on the underlying spaces.
@@ -183,6 +183,10 @@ class LinearOperator(Operator):
         correctly defines the new operator's adjoint with respect to the
         weighted inner products.
 
+        This method automatically handles cases where the domain and/or codomain
+        are a `HilbertSpaceDirectSum`, recursively building the necessary
+        block-structured mass operators.
+
         Args:
             domain: The (potentially) mass-weighted domain of the new operator.
             codomain: The (potentially) mass-weighted codomain of the new operator.
@@ -193,23 +197,40 @@ class LinearOperator(Operator):
             A new `LinearOperator` that acts between the mass-weighted spaces.
         """
         from .hilbert_space import MassWeightedHilbertSpace
+        from .direct_sum import HilbertSpaceDirectSum, BlockDiagonalLinearOperator
+
+        def get_properties(space: HilbertSpace):
+            if isinstance(space, MassWeightedHilbertSpace):
+                return (
+                    space.underlying_space,
+                    space.mass_operator,
+                    space.inverse_mass_operator,
+                )
+            elif isinstance(space, HilbertSpaceDirectSum):
+                properties = [get_properties(subspace) for subspace in space.subspaces]
+                underlying_space = HilbertSpaceDirectSum(
+                    [property[0] for property in properties]
+                )
+                mass_operator = BlockDiagonalLinearOperator(
+                    [property[1] for property in properties]
+                )
+                inverse_mass_operator = BlockDiagonalLinearOperator(
+                    [property[2] for property in properties]
+                )
+                return (
+                    underlying_space,
+                    mass_operator,
+                    inverse_mass_operator,
+                )
+            else:
+                return space, space.identity_operator(), space.identity_operator()
 
-        if isinstance(domain, MassWeightedHilbertSpace):
-            domain_base = domain.underlying_space
-            domain_inverse_mass_operator = domain.inverse_mass_operator
-        else:
-            domain_base = domain
-            domain_inverse_mass_operator = domain.identity_operator()
-
-        if isinstance(codomain, MassWeightedHilbertSpace):
-            codomain_base = codomain.underlying_space
-            codomain_mass_operator = codomain.mass_operator
-        else:
-            codomain_base = codomain
-            codomain_mass_operator = codomain.identity_operator()
+        domain_base, _, domain_inverse_mass_operator = get_properties(domain)
+        codomain_base, codomain_mass_operator, _ = get_properties(codomain)
 
         if domain_base != operator.domain:
             raise ValueError("Domain mismatch")
+
         if codomain_base != operator.codomain:
             raise ValueError("Codomain mismatch")
 
@@ -224,26 +245,25 @@ class LinearOperator(Operator):
 
     @staticmethod
     def from_formally_self_adjoint(
-        domain: "HilbertSpace", operator: LinearOperator
+        domain: HilbertSpace, operator: LinearOperator
     ) -> LinearOperator:
         """
-        Method to construct LinearOperators on MassWeightedHilbertSpaces
-        that are self-adjoint on the underlying space.
+        Constructs a self-adjoint operator on a weighted space.
+
+        This method takes an operator that is formally self-adjoint on an
+        underlying (unweighted) space and promotes it to a truly self-adjoint
+        operator on the `MassWeightedHilbertSpace`. It automatically handles
+        `HilbertSpaceDirectSum` domains.
 
         Args:
-            domain (MassWeightedHilbertSpace): The domain of the operator.
-            operator (LinearOperator): The operator to be converted
-
-        Notes:
-            If the domain is not a MassWeightedHilbertSpace, the underlying
-            domain is taken to be the domain, and the mass operator the identity.
-            In such cases the method is well-defined but pointless as the output
-            operator is identical to the input operator.
+            domain (HilbertSpace): The domain of the operator, which can be a
+                `MassWeightedHilbertSpace` or a `HilbertSpaceDirectSum`.
+            operator (LinearOperator): The operator to be converted.
         """
         return LinearOperator.from_formal_adjoint(domain, domain, operator)
 
     @staticmethod
-    def from_linear_forms(forms: List["LinearForm"]) -> LinearOperator:
+    def from_linear_forms(forms: List[LinearForm]) -> LinearOperator:
         """
         Creates an operator from a list of linear forms.
 
@@ -275,8 +295,8 @@ class LinearOperator(Operator):
 
     @staticmethod
     def from_matrix(
-        domain: "HilbertSpace",
-        codomain: "HilbertSpace",
+        domain: HilbertSpace,
+        codomain: HilbertSpace,
         matrix: Union[np.ndarray, ScipyLinOp],
         /,
         *,
@@ -365,7 +385,7 @@ class LinearOperator(Operator):
 
     @staticmethod
     def self_adjoint_from_matrix(
-        domain: "HilbertSpace", matrix: Union[np.ndarray, ScipyLinOp]
+        domain: HilbertSpace, matrix: Union[np.ndarray, ScipyLinOp]
     ) -> LinearOperator:
         """Forms a self-adjoint operator from its Galerkin matrix."""
 
@@ -379,8 +399,8 @@ class LinearOperator(Operator):
 
     @staticmethod
     def from_tensor_product(
-        domain: "HilbertSpace",
-        codomain: "HilbertSpace",
+        domain: HilbertSpace,
+        codomain: HilbertSpace,
         vector_pairs: List[Tuple[Any, Any]],
         /,
         *,
@@ -414,7 +434,7 @@ class LinearOperator(Operator):
 
     @staticmethod
     def self_adjoint_from_tensor_product(
-        domain: "HilbertSpace",
+        domain: HilbertSpace,
         vectors: List[Any],
         /,
         *,
@@ -697,7 +717,7 @@ class LinearOperator(Operator):
             galerkin=True,
         )
 
-    def _dual_mapping_default(self, yp: Any) -> "LinearForm":
+    def _dual_mapping_default(self, yp: Any) -> LinearForm:
         from .linear_forms import LinearForm
 
         return LinearForm(self.domain, mapping=lambda x: yp(self(x)))
@@ -809,8 +829,8 @@ class DiagonalLinearOperator(LinearOperator):
 
     def __init__(
         self,
-        domain: "HilbertSpace",
-        codomain: "HilbertSpace",
+        domain: HilbertSpace,
+        codomain: HilbertSpace,
         diagonal_values: np.ndarray,
         /,
         *,

pygeoinf/symmetric_space/sphere.py

@@ -425,6 +425,18 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
         """
         return x1 * x2
 
+    def __eq__(self, other: object) -> bool:
+        """
+        Checks for mathematical equality with another Sobolev space on a sphere.
+
+        Two spaces are considered equal if they are of the same type and have
+        the same defining parameters (kmax, order, scale, and radius).
+        """
+        if not isinstance(other, Lebesgue):
+            return NotImplemented
+
+        return self.lmax == other.lmax and self.radius == other.radius
+
     def eigenfunction_norms(self) -> np.ndarray:
         """Returns a list of the norms of the eigenfunctions."""
         return np.fromiter(
@@ -445,10 +457,6 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
         return LinearOperator.self_adjoint(self, mapping)
 
-    # ================================================================ #
-    #                         Private methods                          #
-    # ================================================================ #
-
 
 class Sobolev(SphereHelper, MassWeightedHilbertModule, AbstractInvariantSobolevSpace):
     """

{pygeoinf-1.1.2.dist-info → pygeoinf-1.1.4.dist-info}/METADATA

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

{pygeoinf-1.1.2.dist-info → pygeoinf-1.1.4.dist-info}/RECORD

@@ -8,13 +8,13 @@ pygeoinf/linear_bayesian.py,sha256=aIOzTZbjJtdtwHKh5e01iS8iMiyr8XuwGx91udS3VK4,9
 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=JPDrdLSnM-Y5_CWJ58WDvHBzo3hPoFoUoAOS63QFJmc,32272
+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=vKwvTa-9GMNlN-LBUWaEsZ8vM-dZtQtT71UPDSXZufY,20309
+pygeoinf/symmetric_space/sphere.py,sha256=hg9eAXdwbU9l_QssEcq86FOAQc6mBf416OKVjgsU2Ic,20540
 pygeoinf/symmetric_space/symmetric_space.py,sha256=YkRjHucc2cO7IAoyJS5KMdiRBuytRpUfTUsVMHBPZYs,16146
-pygeoinf-1.1.2.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
-pygeoinf-1.1.2.dist-info/METADATA,sha256=sv7ENSZqZDN3Diivozfbjyzh-OlYrJV3rbBZ-gc076c,15324
-pygeoinf-1.1.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pygeoinf-1.1.2.dist-info/RECORD,,
+pygeoinf-1.1.4.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
+pygeoinf-1.1.4.dist-info/METADATA,sha256=jFoUW2ZH9MrnRw-ZDJvwMJXL0R3yH5KdnLt2chnThUI,15324
+pygeoinf-1.1.4.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pygeoinf-1.1.4.dist-info/RECORD,,