pygeoinf 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

pygeoinf/direct_sum.py

@@ -119,12 +119,10 @@ class HilbertSpaceDirectSum(HilbertSpace):
         """
         if len(xps) != self.number_of_subspaces:
             raise ValueError("Incorrect number of dual vectors provided.")
-        return LinearForm(
-            self,
-            mapping=lambda x: sum(
-                xp(self.subspace_projection(i)(x)) for i, xp in enumerate(xps)
-            ),
-        )
+
+        cps = [space.dual.to_components(xp) for space, xp in zip(self._spaces, xps)]
+        cp = np.concatenate(cps, 0)
+        return LinearForm(self, components=cp)
 
     def canonical_dual_inverse_isomorphism(self, xp: LinearForm) -> List[LinearForm]:
         """
@@ -136,12 +134,17 @@ class HilbertSpaceDirectSum(HilbertSpace):
         Args:
             xp (LinearForm): A dual vector on the direct sum space.
         """
-        return [
-            LinearForm(space, mapping=lambda x, j=i: xp(self.subspace_inclusion(j)(x)))
-            for i, space in enumerate(self.subspaces)
-        ]
 
-    # ... (Private methods remain the same) ...
+        cp = self.dual.to_components(xp)
+        xps = []
+        i = 0
+        for space in self._spaces:
+            j = i + space.dim
+            xp = space.dual.from_components(cp[i:j])
+            xps.append(xp)
+            i = j
+        return xps
+
     def __to_components(self, xs: List[Any]) -> np.ndarray:
         cs = [space.to_components(x) for space, x in zip(self._spaces, xs)]
         return np.concatenate(cs, 0)
@@ -204,7 +207,6 @@ class BlockStructure(ABC):
     An abstract base class for operators with a block structure.
     """
 
-    # ... (class content is the same) ...
     def __init__(self, row_dim: int, col_dim: int) -> None:
         self._row_dim: int = row_dim
         self._col_dim: int = col_dim
@@ -245,7 +247,7 @@ class BlockLinearOperator(LinearOperator, BlockStructure):
         """
         if not blocks or not blocks[0]:
             raise ValueError("Block structure cannot be empty.")
-        # ... (rest of the method is the same) ...
+
         domains = [operator.domain for operator in blocks[0]]
         codomains = []
         for row in blocks:
@@ -281,7 +283,7 @@ class BlockLinearOperator(LinearOperator, BlockStructure):
         return self._blocks[i][j]
 
     def __mapping(self, xs: List[Any]) -> List[Any]:
-        # ... (method content is the same) ...
+
         ys = []
         for i in range(self.row_dim):
             codomain = self._codomains[i]
@@ -293,7 +295,7 @@ class BlockLinearOperator(LinearOperator, BlockStructure):
         return ys
 
     def __adjoint_mapping(self, ys: List[Any]) -> List[Any]:
-        # ... (method content is the same) ...
+
         xs = []
         for j in range(self.col_dim):
             domain = self._domains[j]

pygeoinf/forms.py

@@ -17,6 +17,9 @@ class LinearForm:
     """
     Represents a linear form, which is a linear functional that maps
     vectors from a Hilbert space to a scalar value (a real number).
+
+    Internally, the form is represented by its components relative to the basis for
+    its domain, with these components stored as in a numpy vector.
     """
 
     def __init__(
@@ -40,19 +43,19 @@ class LinearForm:
         """
 
         self._domain: "HilbertSpace" = domain
-        self._components: Optional[np.ndarray] = components
-        self._mapping: Callable[[Any], float]
 
         if components is None:
             if mapping is None:
                 raise AssertionError("Neither mapping nor components specified.")
-            else:
-                self._mapping = mapping
+            self._components = np.zeros(self.domain.dim)
+            cx = np.zeros(self.domain.dim)
+            for i in range(self.domain.dim):
+                cx[i] = 1
+                x = self.domain.from_components(cx)
+                self._components[i] = mapping(x)
+                cx[i] = 0
         else:
-            if mapping is None:
-                self._mapping = self._mapping_from_components
-            else:
-                self._mapping = mapping
+            self._components: np.ndarray = components
 
     @staticmethod
     def from_linear_operator(operator: "LinearOperator") -> "LinearForm":
@@ -69,35 +72,12 @@ class LinearForm:
         """The Hilbert space on which the form is defined."""
         return self._domain
 
-    @property
-    def components_stored(self) -> bool:
-        """True if the form's component vector is cached."""
-        return self._components is not None
-
     @property
     def components(self) -> np.ndarray:
         """
         The component vector of the form.
-
-        The components are computed and cached on first access if not
-        provided during initialization.
         """
-        if self.components_stored:
-            return self._components
-        else:
-            self.store_components()
-            return self.components
-
-    def store_components(self) -> None:
-        """Computes and caches the component vector of the form."""
-        if not self.components_stored:
-            self._components = np.zeros(self.domain.dim)
-            cx = np.zeros(self.domain.dim)
-            for i in range(self.domain.dim):
-                cx[i] = 1
-                x = self.domain.from_components(cx)
-                self._components[i] = self(x)
-                cx[i] = 0
+        return self._components
 
     @property
     def as_linear_operator(self) -> "LinearOperator":
@@ -117,21 +97,15 @@ class LinearForm:
 
     def __call__(self, x: Any) -> float:
         """Applies the linear form to a vector."""
-        return self._mapping(x)
+        return np.dot(self._components, self.domain.to_components(x))
 
     def __neg__(self) -> "LinearForm":
         """Returns the additive inverse of the form."""
-        if self.components_stored:
-            return LinearForm(self.domain, components=-self._components)
-        else:
-            return LinearForm(self.domain, mapping=lambda x: -self(x))
+        return LinearForm(self.domain, components=-self._components)
 
     def __mul__(self, a: float) -> "LinearForm":
         """Returns the product of the form and a scalar."""
-        if self.components_stored:
-            return LinearForm(self.domain, components=a * self._components)
-        else:
-            return LinearForm(self.domain, mapping=lambda x: a * self(x))
+        return LinearForm(self.domain, components=a * self._components)
 
     def __rmul__(self, a: float) -> "LinearForm":
         """Returns the product of the form and a scalar."""
@@ -143,26 +117,12 @@ class LinearForm:
 
     def __add__(self, other: "LinearForm") -> "LinearForm":
         """Returns the sum of this form and another."""
-        if self.components_stored and other.components_stored:
-            return LinearForm(
-                self.domain, components=self.components + other.components
-            )
-        else:
-            return LinearForm(self.domain, mapping=lambda x: self(x) + other(x))
+        return LinearForm(self.domain, components=self.components + other.components)
 
     def __sub__(self, other: "LinearForm") -> "LinearForm":
         """Returns the difference between this form and another."""
-        if self.components_stored and other.components_stored:
-            return LinearForm(
-                self.domain, components=self.components - other.components
-            )
-        else:
-            return LinearForm(self.domain, mapping=lambda x: self(x) - other(x))
+        return LinearForm(self.domain, components=self.components - other.components)
 
     def __str__(self) -> str:
         """Returns the string representation of the form's components."""
         return self.components.__str__()
-
-    def _mapping_from_components(self, x: Any) -> float:
-        """Implements the action of the form using its cached components."""
-        return np.dot(self._components, self.domain.to_components(x))

pygeoinf/symmetric_space/sphere.py

@@ -221,6 +221,19 @@ class Sobolev(SymmetricSpaceSobolev):
     #                 Public methods                #
     # ==============================================#
 
+    def project_function(self, f: Callable[[(float, float)], float]) -> np.ndarray:
+        """
+        Returns an element of the space by projecting a given function.
+
+        Args:
+            f: A function that takes a point `(lat, lon)` and returns a value.
+        """
+        u = self.zero
+        for j, lon in enumerate(u.lons()):
+            for i, lat in enumerate(u.lats()):
+                u.data[i, j] = f((lat, lon))
+        return u
+
     def random_point(self) -> List[float]:
         """Returns a random point as `[latitude, longitude]`."""
         latitude = np.random.uniform(-90.0, 90.0)

{pygeoinf-1.0.8.dist-info → pygeoinf-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pygeoinf
-Version: 1.0.8
+Version: 1.0.9
 Summary: A package for solving geophysical inference and inverse problems
 License: BSD-3-Clause
 Author: David Al-Attar and Dan Heathcote
@@ -16,6 +16,7 @@ Requires-Dist: numpy (>=1.26.0)
 Requires-Dist: pyqt6 (>=6.0.0)
 Requires-Dist: pyshtools (>=4.0.0)
 Requires-Dist: scipy (>=1.0.0)
+Requires-Dist: snakeviz (>=2.2.2,<3.0.0)
 Description-Content-Type: text/markdown
 
 # pygeoinf: A Python Library for Geophysical Inference

{pygeoinf-1.0.8.dist-info → pygeoinf-1.0.9.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pygeoinf/__init__.py,sha256=PsUfD2hfc-eoIz6fHSC-Mn3MHflaU07W2mHT6fLYKr0,1076
-pygeoinf/direct_sum.py,sha256=_ZMtK8EQ02nWpU0yYSqeEieR3ZHZgIyN8fgo9jqkm5k,15867
-pygeoinf/forms.py,sha256=X3vftbjkUKb4m21BDg-Z5umlc1ibAl47ml40i1Fv33E,5815
+pygeoinf/direct_sum.py,sha256=jgG1BTDfoU7rg_YYBKWZU08Ugj9Vfo7PaDuF3XXIcOo,15706
+pygeoinf/forms.py,sha256=ddgXrRmM3CCBWjSE2RQUFbIlEiBCAlnVVIRwnQ50TaA,4362
 pygeoinf/forward_problem.py,sha256=4V40qvHN4qAu8CXsxGAuJ5F9oukqXbXbGCARFpBYaD0,9546
 pygeoinf/gaussian_measure.py,sha256=UEFViRtLYU730U4upV33KB_ksg78tpW0dwGVFgt1hOw,21595
 pygeoinf/hilbert_space.py,sha256=m0wbzm2XIITs8KenwrNrgvRKilsf-KrX6SR0ylKyhLg,14342
@@ -13,9 +13,9 @@ pygeoinf/random_matrix.py,sha256=d6apC9Sd5ud-QgLnvvXaURdar3LiYJPwz-CYbDojH54,754
 pygeoinf/symmetric_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeoinf/symmetric_space/circle.py,sha256=TWjQwX42EvZ4-zOIJKATo8lVg0YbXRaQgxVzj6xXYlM,12467
 pygeoinf/symmetric_space/line.py,sha256=FoZL5qVEVWzOkWwhbmwsg3D_0ceX9Nj8L8OJXQevtr4,13203
-pygeoinf/symmetric_space/sphere.py,sha256=YezUyB3TfsY6Bb0M6hVVXSA00HDkcyO8I-FMy_I0lOA,24215
+pygeoinf/symmetric_space/sphere.py,sha256=re-TjugmBABcBpR5LEMhSCxJn0T_h3TRm4tjyGGwTyE,24664
 pygeoinf/symmetric_space/symmetric_space.py,sha256=E-8lXZmW5WWaHgX-YTu--NwV6dXP3M7hIP3J3H6uv3U,9067
-pygeoinf-1.0.8.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
-pygeoinf-1.0.8.dist-info/METADATA,sha256=9kra1ONFxBefYI7LkLzHM2NYkax8RwhHtrGbJT3lZY4,14375
-pygeoinf-1.0.8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pygeoinf-1.0.8.dist-info/RECORD,,
+pygeoinf-1.0.9.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
+pygeoinf-1.0.9.dist-info/METADATA,sha256=HkPhf8yGiBK2x6bjYgATq-6rr8Y7oVxib31fBqcz_Po,14416
+pygeoinf-1.0.9.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pygeoinf-1.0.9.dist-info/RECORD,,