pygeoinf 1.1.6__tar.gz → 1.1.8__tar.gz

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

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

{pygeoinf-1.1.6 → pygeoinf-1.1.8}/pygeoinf/hilbert_space.py

@@ -223,6 +223,8 @@ class HilbertSpace(ABC):
     #                      Final (Non-Overridable) Methods                #
     # ------------------------------------------------------------------- #
 
+    
+
     @final
     @property
     def coordinate_inclusion(self) -> LinearOperator:

{pygeoinf-1.1.6 → pygeoinf-1.1.8}/pygeoinf/linear_solvers.py

@@ -172,7 +172,12 @@ class IterativeLinearSolver(LinearSolver):
         """
         Solves the adjoint linear system A*y = x for y.
         """
-        return self.solve_linear_system(operator.adjoint, preconditioner.adjoint, x, y0)
+        adjoint_preconditioner = (
+            None
+            if preconditioner is None
+            else preconditioner.adjoint
+        )
+        return self.solve_linear_system(operator.adjoint, adjoint_preconditioner, x, y0)
 
     def __call__(
         self,

{pygeoinf-1.1.6 → pygeoinf-1.1.8}/pygeoinf/symmetric_space/circle.py

@@ -336,18 +336,21 @@ class Lebesgue(CircleHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
         return self.kmax == other.kmax and self.radius == other.radius
 
-    def invariant_automorphism(self, f: Callable[[float], float]):
+    def invariant_automorphism_from_index_function(self, g: Callable[[int], float]):
         """
         Implements an invariant automorphism of the form f(Δ) using Fourier
         expansions on a circle.
 
+        For this method, the function f is given implicitly in terms of a
+        function, g, of the eigenvalue indices for the space. Letting k(λ) be
+        the index for eigenvalue λ, we then have f(λ) = g(k(λ)).
+
         Args:
-            f: A real-valued function that is well-defined on the spectrum
-               of the Laplacian, Δ.
+            g: A real-valued function of the eigenvalue index.
         """
 
         values = np.fromiter(
-            (f(self.laplacian_eigenvalue(k)) for k in range(self.kmax + 1)),
+            (g(k) for k in range(self.kmax + 1)),
             dtype=float,
         )
         matrix = diags([values], [0])

{pygeoinf-1.1.6 → pygeoinf-1.1.8}/pygeoinf/symmetric_space/sphere.py

@@ -160,6 +160,17 @@ class SphereHelper:
         l = k[0]
         return l * (l + 1) / self.radius**2
 
+    def degree_from_laplacian_eigenvalue(self, eig: float) -> float:
+        """
+        Returns the degree corresponding to a given eigenvalue.
+
+        Note that the value is returned as a float
+
+        Args:
+            eig: The eigenvalue.
+        """
+        return np.sqrt(self.radius**2 * eig + 0.25)
+
     def trace_of_invariant_automorphism(self, f: Callable[[float], float]) -> float:
         """
         Returns the trace of the automorphism of the form f(Δ) with f a function
@@ -444,10 +455,10 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
             dtype=float,
         )
 
-    def invariant_automorphism(self, f: Callable[[float], float]) -> LinearOperator:
-        values = self._degree_dependent_scaling_values(
-            lambda l: f(self.laplacian_eigenvalue((l, 0)))
-        )
+    def invariant_automorphism_from_index_function(
+        self, g: Callable[[(int, int)], float]
+    ) -> LinearOperator:
+        values = self._degree_dependent_scaling_values(lambda l: g((l, 0)))
         matrix = diags([values], [0])
 
         def mapping(u):

{pygeoinf-1.1.6 → pygeoinf-1.1.8}/pygeoinf/symmetric_space/symmetric_space.py

@@ -30,6 +30,8 @@ AbstractInvariantSobolevSpace
 from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import Callable, Any, List
+
+
 import numpy as np
 from scipy.sparse import diags
 
@@ -98,6 +100,26 @@ class AbstractInvariantLebesgueSpace(ABC):
         """Returns a list of the norms of the eigenfunctions."""
 
     @abstractmethod
+    def invariant_automorphism_from_index_function(
+        self, g: Callable[[int | tuple[int, ...]], float]
+    ) -> LinearOperator:
+        """
+        Returns an automorphism of the form f(Δ) with f a function
+        that is well-defined on the spectrum of the Laplacian, Δ.
+
+        In order to be well-defined, the function must have appropriate
+        growth properties. For example, in an L² space we need f to be bounded.
+        In Sobolev spaces Hˢ a more complex condition holds depending on the
+        Sobolev order. These conditions on the function are not checked.
+
+        For this method, the function f is given implicitly in terms of a
+        function, g, of the eigenvalue indices for the space. Letting k(λ) be
+        the index for eigenvalue λ, we then have f(λ) = g(k(λ)).
+
+        Args:
+            g: A function that takes an eigenvalue index and returns a real value.
+        """
+
     def invariant_automorphism(self, f: Callable[[float], float]) -> LinearOperator:
         """
         Returns an automorphism of the form f(Δ) with f a function
@@ -111,7 +133,15 @@ class AbstractInvariantLebesgueSpace(ABC):
         Args:
             f: A real-valued function that is well-defined on the spectrum
                of the Laplacian.
+
+        Notes:
+            This method is a convenience wrapper for the more general
+            `invariant_automorphism_from_index_function`. It could be
+            overriden if computationally advantageous.
         """
+        return self.invariant_automorphism_from_index_function(
+            lambda k: f(self.laplacian_eigenvalue(k))
+        )
 
     @abstractmethod
     def trace_of_invariant_automorphism(self, f: Callable[[float], float]) -> float:
@@ -351,16 +381,26 @@ class AbstractInvariantSobolevSpace(AbstractInvariantLebesgueSpace):
             self, EuclideanSpace(dim), matrix, galerkin=True
         )
 
-    def invariant_automorphism(self, f: Callable[[float], float]):
+    def invariant_automorphism_from_index_function(
+        self, g: Callable[[int | tuple[int, ...]], float]
+    ):
         """
-        Returns an invariant automorphism of the form f(Δ) making use of the equivalent
-        operator on the underlying Lebesgue space.
+        Returns an automorphism of the form f(Δ) with f a function
+        that is well-defined on the spectrum of the Laplacian, Δ.
+
+        In order to be well-defined, the function must have appropriate
+        growth properties. For example, in an L² space we need f to be bounded.
+        In Sobolev spaces Hˢ a more complex condition holds depending on the
+        Sobolev order. These conditions on the function are not checked.
+
+        For this method, the function f is given implicitly in terms of a
+        function, g, of the eigenvalue indices for the space. Letting k(λ) be
+        the index for eigenvalue λ, we then have f(λ) = g(k(λ)).
 
         Args:
-            f: A real-valued function that is well-defined on the spectrum
-               of the Laplacian, Δ.
+            g: A function that takes an eigenvalue index and returns a real value.
         """
-        A = self.underlying_space.invariant_automorphism(f)
+        A = self.underlying_space.invariant_automorphism_from_index_function(g)
         return LinearOperator.from_formally_self_adjoint(self, A)
 
     def point_value_scaled_invariant_gaussian_measure(

{pygeoinf-1.1.6 → pygeoinf-1.1.8}/pyproject.toml

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