pygeoinf 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

pygeoinf/__init__.py

@@ -1,6 +1,7 @@
 from .random_matrix import (
     fixed_rank_random_range,
     variable_rank_random_range,
+    random_range,
     random_svd,
     random_eig,
     random_cholesky,
@@ -16,16 +17,22 @@ from .hilbert_space import (
 )
 
 
-from .operators import (
-    Operator,
-    LinearOperator,
-    DiagonalLinearOperator,
+from .nonlinear_forms import (
+    NonLinearForm,
 )
 
+
 from .linear_forms import (
     LinearForm,
 )
 
+from .nonlinear_operators import NonLinearOperator
+
+from .linear_operators import (
+    LinearOperator,
+    DiagonalLinearOperator,
+)
+
 
 from .gaussian_measure import (
     GaussianMeasure,
@@ -45,7 +52,9 @@ from .linear_solvers import (
     DirectLinearSolver,
     LUSolver,
     CholeskySolver,
+    EigenSolver,
     IterativeLinearSolver,
+    ScipyIterativeSolver,
     CGMatrixSolver,
     BICGMatrixSolver,
     BICGStabMatrixSolver,
@@ -61,3 +70,7 @@ from .linear_optimisation import (
 )
 
 from .linear_bayesian import LinearBayesianInversion, LinearBayesianInference
+
+from .nonlinear_optimisation import (
+    ScipyUnconstrainedOptimiser,
+)

pygeoinf/backus_gilbert.py

@@ -0,0 +1,120 @@
+"""
+Module for Backus-Gilbert like methods for solving inference problems. To be done...
+"""
+
+from .hilbert_space import HilbertSpace, Vector
+from .linear_operators import LinearOperator
+from .nonlinear_forms import NonLinearForm
+
+
+class HyperEllipsoid:
+    """
+    A class for hyper-ellipsoids in a Hilbert Space. Such sets occur within
+    the context of Backus-Gilbert methods, both in terms of prior constraints
+    and posterior bounds on the property space.
+
+    The hyper-ellipsoid is defined through the inequality
+
+    (A(x-x_0), x-x_0)_{X} <= r**2,
+
+    where A is a self-adjoint linear operator on the space, X, x is an arbitrary vector, x_0 is the
+    centre, and r the radius.
+    """
+
+    def __init__(
+        self,
+        space: HilbertSpace,
+        radius: float,
+        /,
+        *,
+        centre: Vector = None,
+        operator: LinearOperator = None,
+    ) -> None:
+        """
+        Args:
+            space (HilbertSpace): The Hilbert space in which the hyper-ellipsoid is defined.
+            radius (float): The radius of the hyper-ellipsoid.
+            centre (Vector); The centre of the hyper-ellipsoid. The default is None which corresponds to
+                the zero-vector.
+            operator (LinearOperator): A self-adjoint operator on the space defining the hyper-ellipsoid.
+                The default is None which corresponds to the identity operator.
+        """
+
+        if not isinstance(space, HilbertSpace):
+            raise ValueError("Input space must be a HilbertSpace")
+        self._space = space
+
+        if not radius > 0:
+            raise ValueError("Input radius must be positive.")
+        self._radius = radius
+
+        if operator is None:
+            self._operator = space.identity_operator()
+        else:
+            if not (operator.domain == space and operator.is_automorphism):
+                raise ValueError("Operator is not of the appropriate form.")
+            self._operator = operator
+
+        if centre is None:
+            self._centre = space.zero
+        else:
+            if not space.is_element(centre):
+                raise ValueError("The input centre does not lie in the space.")
+            self._centre = centre
+
+    @property
+    def space(self) -> HilbertSpace:
+        """
+        Returns the HilbertSpace the hyper-ellipsoid is defined on.
+        """
+        return self._space
+
+    @property
+    def radius(self) -> float:
+        """
+        Returns the radius of the hyper-ellipsoid.
+        """
+        return self._radius
+
+    @property
+    def operator(self) -> LinearOperator:
+        """
+        Returns the operator for the hyper-ellipsoid.
+        """
+        return self._operator
+
+    @property
+    def centre(self) -> Vector:
+        """
+        Returns the centre of the hyper-ellipsoid.
+        """
+        return self._centre
+
+    @property
+    def quadratic_form(self) -> NonLinearForm:
+        """
+        Returns the mapping x -> (A(x-x_0), x-x_0)_{X} as a NonLinearForm.
+        """
+
+        space = self.space
+        x0 = self.centre
+        A = self.operator
+
+        def mapping(x: Vector) -> float:
+            d = space.subtract(x, x0)
+            return space.inner_product(A(d), d)
+
+        def gradient(x: Vector) -> Vector:
+            d = space.subtract(x, x0)
+            return space.multiply(2, A(d))
+
+        def hessian(_: Vector) -> LinearOperator:
+            return A
+
+        return NonLinearForm(space, mapping, gradient=gradient, hessian=hessian)
+
+    def is_point(self, x: Vector) -> bool:
+        """
+        True if x lies in the hyper-ellipsoid.
+        """
+        return self.quadratic_form(x) <= self.radius**2

pygeoinf/direct_sum.py

@@ -29,7 +29,7 @@ from scipy.linalg import block_diag
 from joblib import Parallel, delayed
 
 from .hilbert_space import HilbertSpace
-from .operators import LinearOperator
+from .linear_operators import LinearOperator
 from .linear_forms import LinearForm
 from .parallel import parallel_compute_dense_matrix_from_scipy_op
 
@@ -116,6 +116,16 @@ class HilbertSpaceDirectSum(HilbertSpace):
 
         return self.subspaces == other.subspaces
 
+    def is_element(self, xs: Any) -> bool:
+        """
+        Checks if a list of vectors is a valid element of the direct sum space.
+        """
+        if not isinstance(xs, list):
+            return False
+        if len(xs) != self.number_of_subspaces:
+            return False
+        return all(space.is_element(x) for space, x in zip(self._spaces, xs))
+
     @property
     def subspaces(self) -> List[HilbertSpace]:
         """Returns the list of subspaces that form the direct sum."""
@@ -307,35 +317,18 @@ class BlockLinearOperator(LinearOperator, BlockStructure):
         self, galerkin: bool, parallel: bool, n_jobs: int
     ) -> np.ndarray:
         """Overloaded method to efficiently compute the dense matrix for a block operator."""
-        if not parallel:
-            block_matrices = [
-                [
-                    self.block(i, j).matrix(
-                        dense=True, galerkin=galerkin, parallel=False
-                    )
-                    for j in range(self.col_dim)
-                ]
-                for i in range(self.row_dim)
-            ]
-            return np.block(block_matrices)
 
-        else:
-            block_scipy_ops = [
-                self.block(i, j).matrix(galerkin=galerkin)
-                for i in range(self.row_dim)
+        block_matrices = [
+            [
+                self.block(i, j).matrix(
+                    dense=True, galerkin=galerkin, parallel=parallel, n_jobs=n_jobs
+                )
                 for j in range(self.col_dim)
             ]
+            for i in range(self.row_dim)
+        ]
 
-            computed_blocks = Parallel(n_jobs=n_jobs)(
-                delayed(parallel_compute_dense_matrix_from_scipy_op)(op, n_jobs=1)
-                for op in block_scipy_ops
-            )
-
-            block_matrices = [
-                computed_blocks[i * self.col_dim : (i + 1) * self.col_dim]
-                for i in range(self.row_dim)
-            ]
-            return np.block(block_matrices)
+        return np.block(block_matrices)
 
     def __mapping(self, xs: List[Any]) -> List[Any]:
 
@@ -402,6 +395,7 @@ class ColumnLinearOperator(LinearOperator, BlockStructure):
             x = domain.zero
             for op, y in zip(self._operators, ys):
                 domain.axpy(1.0, op.adjoint(y), x)
+                print(op.adjoint(y).data)
             return x
 
         LinearOperator.__init__(
@@ -420,23 +414,11 @@ class ColumnLinearOperator(LinearOperator, BlockStructure):
         self, galerkin: bool, parallel: bool, n_jobs: int
     ) -> np.ndarray:
         """Overloaded method to efficiently compute the dense matrix for a column operator."""
-        if not parallel:
-            block_matrices = [
-                op.matrix(dense=True, galerkin=galerkin, parallel=False)
-                for op in self._operators
-            ]
-            return np.vstack(block_matrices)
-        else:
-            block_scipy_ops = [
-                op.matrix(galerkin=galerkin, parallel=False) for op in self._operators
-            ]
-
-            computed_blocks = Parallel(n_jobs=n_jobs)(
-                delayed(parallel_compute_dense_matrix_from_scipy_op)(op, n_jobs=1)
-                for op in block_scipy_ops
-            )
-
-            return np.vstack(computed_blocks)
+        block_matrices = [
+            op.matrix(dense=True, galerkin=galerkin, parallel=parallel, n_jobs=n_jobs)
+            for op in self._operators
+        ]
+        return np.vstack(block_matrices)
 
 
 class RowLinearOperator(LinearOperator, BlockStructure):
@@ -496,23 +478,11 @@ class RowLinearOperator(LinearOperator, BlockStructure):
         self, galerkin: bool, parallel: bool, n_jobs: int
     ) -> np.ndarray:
         """Overloaded method to efficiently compute the dense matrix for a row operator."""
-        if not parallel:
-            block_matrices = [
-                op.matrix(dense=True, galerkin=galerkin, parallel=False)
-                for op in self._operators
-            ]
-            return np.hstack(block_matrices)
-        else:
-            block_scipy_ops = [
-                op.matrix(galerkin=galerkin, parallel=False) for op in self._operators
-            ]
-
-            computed_blocks = Parallel(n_jobs=n_jobs)(
-                delayed(parallel_compute_dense_matrix_from_scipy_op)(op, n_jobs=1)
-                for op in block_scipy_ops
-            )
-
-            return np.hstack(computed_blocks)
+        block_matrices = [
+            op.matrix(dense=True, galerkin=galerkin, parallel=parallel, n_jobs=n_jobs)
+            for op in self._operators
+        ]
+        return np.hstack(block_matrices)
 
 
 class BlockDiagonalLinearOperator(LinearOperator, BlockStructure):
@@ -559,20 +529,8 @@ class BlockDiagonalLinearOperator(LinearOperator, BlockStructure):
         self, galerkin: bool, parallel: bool, n_jobs: int
     ) -> np.ndarray:
         """Overloaded method to efficiently compute the dense matrix for a block-diagonal operator."""
-        if not parallel:
-            block_matrices = [
-                op.matrix(dense=True, galerkin=galerkin, parallel=False)
-                for op in self._operators
-            ]
-            return block_diag(*block_matrices)
-        else:
-            block_scipy_ops = [
-                op.matrix(galerkin=galerkin, parallel=False) for op in self._operators
-            ]
-
-            computed_blocks = Parallel(n_jobs=n_jobs)(
-                delayed(parallel_compute_dense_matrix_from_scipy_op)(op, n_jobs=1)
-                for op in block_scipy_ops
-            )
-
-            return block_diag(*computed_blocks)
+        block_matrices = [
+            op.matrix(dense=True, galerkin=galerkin, parallel=parallel, n_jobs=n_jobs)
+            for op in self._operators
+        ]
+        return block_diag(*block_matrices)

pygeoinf/forward_problem.py

@@ -24,12 +24,14 @@ from scipy.stats import chi2
 
 from .gaussian_measure import GaussianMeasure
 from .direct_sum import ColumnLinearOperator
+from .linear_operators import LinearOperator
+
 
 # This block only runs for type checkers, not at runtime, to prevent
 # circular import errors while still allowing type hints.
 if TYPE_CHECKING:
     from .hilbert_space import HilbertSpace, Vector
-    from .operators import LinearOperator
+    from .nonlinear_operators import NonLinearOperator
 
 
 class ForwardProblem:
@@ -43,10 +45,10 @@ class ForwardProblem:
 
     def __init__(
         self,
-        forward_operator: LinearOperator,
+        forward_operator: NonLinearOperator,
         /,
         *,
-        data_error_measure: Optional["GaussianMeasure"] = None,
+        data_error_measure: Optional[GaussianMeasure] = None,
     ) -> None:
         """Initializes the ForwardProblem.
 
@@ -57,8 +59,8 @@ class ForwardProblem:
                 from which data errors are assumed to be drawn. If None, the
                 data is considered to be error-free.
         """
-        self._forward_operator: LinearOperator = forward_operator
-        self._data_error_measure: Optional["GaussianMeasure"] = data_error_measure
+        self._forward_operator: NonLinearOperator = forward_operator
+        self._data_error_measure: Optional[GaussianMeasure] = data_error_measure
         if self.data_error_measure_set:
             if self.data_space != data_error_measure.domain:
                 raise ValueError(
@@ -76,7 +78,7 @@ class ForwardProblem:
         return self._data_error_measure is not None
 
     @property
-    def data_error_measure(self) -> "GaussianMeasure":
+    def data_error_measure(self) -> GaussianMeasure:
         """The measure from which data errors are drawn."""
         if not self.data_error_measure_set:
             raise AttributeError("Data error measure has not been set.")
@@ -101,10 +103,31 @@ class LinearForwardProblem(ForwardProblem):
     and `e` is a random error drawn from a Gaussian distribution.
     """
 
+    def __init__(
+        self,
+        forward_operator: LinearOperator,
+        /,
+        *,
+        data_error_measure: Optional[GaussianMeasure] = None,
+    ) -> None:
+        """
+        Args:
+            forward_operator: The operator that maps from the model space to the
+                data space.
+            data_error_measure: A Gaussian measure representing the distribution
+                from which data errors are assumed to be drawn. If None, the
+                data is considered to be error-free.
+        """
+
+        if not isinstance(forward_operator, LinearOperator):
+            raise ValueError("Forward operator must be a linear operator.")
+
+        super().__init__(forward_operator, data_error_measure=data_error_measure)
+
     @staticmethod
     def from_direct_sum(
-        forward_problems: List["LinearForwardProblem"],
-    ) -> "LinearForwardProblem":
+        forward_problems: List[LinearForwardProblem],
+    ) -> LinearForwardProblem:
         """
         Forms a joint forward problem from a list of separate problems.
 
@@ -144,7 +167,7 @@ class LinearForwardProblem(ForwardProblem):
             joint_forward_operator, data_error_measure=data_error_measure
         )
 
-    def data_measure(self, model: "Vector") -> "GaussianMeasure":
+    def data_measure(self, model: Vector) -> GaussianMeasure:
         """
         Returns the Gaussian measure for the data, given a specific model.
 
@@ -165,7 +188,7 @@ class LinearForwardProblem(ForwardProblem):
             translation=self.forward_operator(model)
         )
 
-    def synthetic_data(self, model: "Vector") -> "Vector":
+    def synthetic_data(self, model: Vector) -> Vector:
         """
         Generates a synthetic data vector for a given model.
 
@@ -180,9 +203,7 @@ class LinearForwardProblem(ForwardProblem):
         """
         return self.data_measure(model).sample()
 
-    def synthetic_model_and_data(
-        self, prior: "GaussianMeasure"
-    ) -> Tuple["Vector", "Vector"]:
+    def synthetic_model_and_data(self, prior: GaussianMeasure) -> Tuple[Vector, Vector]:
         """
         Generates a random model and corresponding synthetic data.
 
@@ -216,14 +237,16 @@ class LinearForwardProblem(ForwardProblem):
         """
         return chi2.ppf(significance_level, self.data_space.dim)
 
-    def chi_squared(self, model: "Vector", data: "Vector") -> float:
+    def chi_squared(self, model: Vector, data: Vector) -> float:
         """
         Calculates the chi-squared statistic for a given model and data.
 
         This measures the misfit between the predicted and observed data.
+
         - If a data error measure with an inverse covariance `C_e^-1` is defined,
           this is the weighted misfit: `(d - A(u))^T * C_e^-1 * (d - A(u))`.
         - Otherwise, it is the squared L2 norm of the data residual: `||d - A(u)||^2`.
+
         Args:
             model: A vector from the model space.
             data: An observed data vector from the data space.
@@ -231,6 +254,7 @@ class LinearForwardProblem(ForwardProblem):
         Returns:
             The chi-squared statistic.
         """
+
         residual = self.data_space.subtract(data, self.forward_operator(model))
 
         if self.data_error_measure_set:
@@ -247,7 +271,7 @@ class LinearForwardProblem(ForwardProblem):
             return self.data_space.squared_norm(residual)
 
     def chi_squared_test(
-        self, significance_level: float, model: "Vector", data: "Vector"
+        self, significance_level: float, model: Vector, data: Vector
     ) -> bool:
         """
         Performs a chi-squared test for goodness of fit.

pygeoinf/gaussian_measure.py

@@ -30,7 +30,7 @@ from scipy.stats import multivariate_normal
 
 from .hilbert_space import EuclideanSpace, HilbertModule
 
-from .operators import (
+from .linear_operators import (
     LinearOperator,
     DiagonalLinearOperator,
 )
@@ -491,12 +491,16 @@ class GaussianMeasure:
 
     def low_rank_approximation(
         self,
-        rank: int,
+        size_estimate: int,
         /,
         *,
-        power: int = 0,
-        method: str = "fixed",
-        rtol: float = 1e-2,
+        method: str = "variable",
+        max_rank: int = None,
+        power: int = 2,
+        rtol: float = 1e-4,
+        block_size: int = 10,
+        parallel: bool = False,
+        n_jobs: int = -1,
     ) -> GaussianMeasure:
         """
         Constructs a low-rank approximation of the measure.
@@ -505,16 +509,37 @@ class GaussianMeasure:
         can be much more efficient for sampling and storage.
 
         Args:
-            rank (int): The target rank for the approximation.
-            power (int, optional): Power iterations for the randomized algorithm.
-            method (str, optional): 'fixed' or 'variable' rank method.
-            rtol (float, optional): Relative tolerance for variable rank method.
+            size_estimate: For 'fixed' method, the exact target rank. For 'variable'
+                       method, this is the initial rank to sample.
+            method ({'variable', 'fixed'}): The algorithm to use.
+            - 'variable': (Default) Progressively samples to find the rank needed
+                          to meet tolerance `rtol`, stopping at `max_rank`.
+            - 'fixed': Returns a basis with exactly `size_estimate` columns.
+            max_rank: For 'variable' method, a hard limit on the rank. Ignored if
+                    method='fixed'. Defaults to min(m, n).
+            power: Number of power iterations to improve accuracy.
+            rtol: Relative tolerance for the 'variable' method. Ignored if
+                method='fixed'.
+            block_size: Number of new vectors to sample per iteration in 'variable'
+                        method. Ignored if method='fixed'.
+            parallel: Whether to use parallel matrix multiplication.
+            n_jobs: Number of jobs for parallelism.
 
         Returns:
             GaussianMeasure: The new, low-rank Gaussian measure.
+
+        Notes:
+            Parallel implemention only currently possible with fixed-rank decompositions.
         """
         covariance_factor = self.covariance.random_cholesky(
-            rank, power=power, method=method, rtol=rtol
+            size_estimate,
+            method=method,
+            max_rank=max_rank,
+            power=power,
+            rtol=rtol,
+            block_size=block_size,
+            parallel=parallel,
+            n_jobs=n_jobs,
         )
 
         return GaussianMeasure(

pygeoinf/hilbert_space.py

@@ -38,7 +38,7 @@ import numpy as np
 
 # This block only runs for type checkers, not at runtime
 if TYPE_CHECKING:
-    from .operators import LinearOperator
+    from .linear_operators import LinearOperator
     from .linear_forms import LinearForm
 
 # Define a generic type for vectors in a Hilbert space
@@ -223,15 +223,13 @@ class HilbertSpace(ABC):
     #                      Final (Non-Overridable) Methods                #
     # ------------------------------------------------------------------- #
 
-    
-
     @final
     @property
     def coordinate_inclusion(self) -> LinearOperator:
         """
         The linear operator mapping R^n component vectors into this space.
         """
-        from .operators import LinearOperator
+        from .linear_operators import LinearOperator
 
         domain = EuclideanSpace(self.dim)
 
@@ -257,7 +255,7 @@ class HilbertSpace(ABC):
         """
         The linear operator projecting vectors from this space to R^n.
         """
-        from .operators import LinearOperator
+        from .linear_operators import LinearOperator
 
         codomain = EuclideanSpace(self.dim)
 
@@ -281,7 +279,7 @@ class HilbertSpace(ABC):
     @property
     def riesz(self) -> LinearOperator:
         """The Riesz map (dual to primal) as a `LinearOperator`."""
-        from .operators import LinearOperator
+        from .linear_operators import LinearOperator
 
         return LinearOperator.self_dual(self.dual, self.from_dual)
 
@@ -289,7 +287,7 @@ class HilbertSpace(ABC):
     @property
     def inverse_riesz(self) -> LinearOperator:
         """The inverse Riesz map (primal to dual) as a `LinearOperator`."""
-        from .operators import LinearOperator
+        from .linear_operators import LinearOperator
 
         return LinearOperator.self_dual(self, self.to_dual)
 
@@ -412,7 +410,7 @@ class HilbertSpace(ABC):
     @final
     def identity_operator(self) -> LinearOperator:
         """Returns the identity operator `I` on the space."""
-        from .operators import LinearOperator
+        from .linear_operators import LinearOperator
 
         return LinearOperator(
             self,
@@ -433,7 +431,7 @@ class HilbertSpace(ABC):
         Returns:
             The zero linear operator.
         """
-        from .operators import LinearOperator
+        from .linear_operators import LinearOperator
 
         codomain = self if codomain is None else codomain
         return LinearOperator(
@@ -506,6 +504,14 @@ class DualHilbertSpace(HilbertSpace):
             return NotImplemented
         return self.underlying_space == other.underlying_space
 
+    def is_element(self, x: Any) -> bool:
+        """
+        Checks if an object is a valid element of the dual space.
+        """
+        from .linear_forms import LinearForm
+
+        return isinstance(x, LinearForm) and x.domain == self.underlying_space
+
     @final
     def duality_product(self, xp: LinearForm, x: Vector) -> float:
         """
@@ -585,6 +591,12 @@ class EuclideanSpace(HilbertSpace):
             return NotImplemented
         return self.dim == other.dim
 
+    def is_element(self, x: Any) -> bool:
+        """
+        Checks if an object is a valid element of the space.
+        """
+        return isinstance(x, np.ndarray) and len(x) == self.dim
+
 
 class MassWeightedHilbertSpace(HilbertSpace):
     """
@@ -680,6 +692,40 @@ class MassWeightedHilbertSpace(HilbertSpace):
             and (self.inverse_mass_operator == other.inverse_mass_operator)
         )
 
+    def is_element(self, x: Any) -> bool:
+        """
+        Checks if an object is a valid element of the space.
+        """
+        return self.underlying_space.is_element(x)
+
+    def add(self, x: Vector, y: Vector) -> Vector:
+        """Computes the sum of two vectors. Defaults to `x + y`."""
+        return self.underlying_space.add(x, y)
+
+    def subtract(self, x: Vector, y: Vector) -> Vector:
+        """Computes the difference of two vectors. Defaults to `x - y`."""
+        return self.underlying_space.subtract(x, y)
+
+    def multiply(self, a: float, x: Vector) -> Vector:
+        """Computes scalar multiplication. Defaults to `a * x`."""
+        return self.underlying_space.multiply(a, x)
+
+    def negative(self, x: Vector) -> Vector:
+        """Computes the additive inverse of a vector. Defaults to `-1 * x`."""
+        return self.underlying_space.negative(x)
+
+    def ax(self, a: float, x: Vector) -> None:
+        """Performs in-place scaling `x := a*x`. Defaults to `x *= a`."""
+        self.underlying_space.ax(a, x)
+
+    def axpy(self, a: float, x: Vector, y: Vector) -> None:
+        """Performs in-place operation `y := y + a*x`. Defaults to `y += a*x`."""
+        self.underlying_space.axpy(a, x, y)
+
+    def copy(self, x: Vector) -> Vector:
+        """Returns a deep copy of a vector. Defaults to `x.copy()`."""
+        return self.underlying_space.copy(x)
+
 
 class MassWeightedHilbertModule(MassWeightedHilbertSpace, HilbertModule):
     """