pygeoinf 1.2.0__py3-none-any.whl → 1.2.1__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,3 @@
+"""
+Module for Backus-Gilbert like methods for solving inference problems. To be done...
+"""

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
 
@@ -307,35 +307,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]:
 
@@ -420,23 +403,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 +467,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 +518,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

@@ -29,7 +29,7 @@ from .direct_sum import ColumnLinearOperator
 # circular import errors while still allowing type hints.
 if TYPE_CHECKING:
     from .hilbert_space import HilbertSpace, Vector
-    from .operators import LinearOperator
+    from .linear_operators import LinearOperator
 
 
 class ForwardProblem:
@@ -221,9 +221,11 @@ class LinearForwardProblem(ForwardProblem):
         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 +233,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:

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(

pygeoinf/linear_bayesian.py

@@ -28,7 +28,7 @@ from .gaussian_measure import GaussianMeasure
 
 
 from .forward_problem import LinearForwardProblem
-from .operators import LinearOperator
+from .linear_operators import LinearOperator
 from .linear_solvers import LinearSolver, IterativeLinearSolver
 from .hilbert_space import HilbertSpace, Vector
 

pygeoinf/linear_forms.py

@@ -1,33 +1,36 @@
 """
-Provides the `LinearForm` class to represent linear functionals.
+Provides the `LinearForm` class for representing linear functionals.
 
 A linear form is a linear mapping from a vector in a Hilbert space to a
-scalar (a real number). This class provides a concrete representation for
-elements of the dual space of a `HilbertSpace`.
-
-A `LinearForm` can be thought of as a dual vector and is a fundamental component
-for defining inner products and adjoint operators within the library.
+scalar. This class provides a concrete, component-based representation for
+elements of the dual space of a `HilbertSpace`. It inherits from `NonLinearForm`,
+specializing it for the linear case.
 """
 
 from __future__ import annotations
 from typing import Callable, Optional, Any, TYPE_CHECKING
 
+from joblib import Parallel, delayed
+
 import numpy as np
 
+from .nonlinear_forms import NonLinearForm
+
 # This block only runs for type checkers, not at runtime
 if TYPE_CHECKING:
-    from .hilbert_space import HilbertSpace, EuclideanSpace
-    from .operators import LinearOperator
+    from .hilbert_space import HilbertSpace, EuclideanSpace, Vector
+    from .linear_operators import LinearOperator
 
 
-class LinearForm:
+class LinearForm(NonLinearForm):
     """
-    Represents a linear form, a functional that maps vectors to scalars.
+    Represents a linear form as an efficient, component-based functional.
 
-    A `LinearForm` is an element of a dual `HilbertSpace`. It is defined by its
-    action on vectors from its `domain` space. Internally, this action is
-    represented by a component vector, which when dotted with the component
-    vector of a primal space element, produces the scalar result.
+    A `LinearForm` is an element of a dual `HilbertSpace` and is defined by its
+    action on vectors from its `domain`. Internally, this action is represented
+    by a component vector. This class provides optimized arithmetic operations
+    and correctly defines the gradient (a constant vector) and the Hessian
+    (the zero operator) for any linear functional.
     """
 
     def __init__(
@@ -35,29 +38,49 @@ class LinearForm:
         domain: HilbertSpace,
         /,
         *,
-        mapping: Optional[Callable[[Any], float]] = None,
         components: Optional[np.ndarray] = None,
+        mapping: Optional[Callable[[Vector], float]] = None,
+        parallel: bool = False,
+        n_jobs: int = -1,
     ) -> None:
         """
-        Initializes the LinearForm.
+        Initializes the LinearForm from a mapping or component vector.
+
+        A form must be defined by exactly one of two methods:
+        1.  **components**: The explicit component vector representing the form.
+        2.  **mapping**: A function `f(x)` that defines the form's action.
+            The components will be automatically computed from this mapping.
 
-        A form can be defined either by its functional mapping or directly
-        by its component vector. If a mapping is provided without components,
-        the components will be computed by evaluating the mapping on the
-        basis vectors of the domain.
 
         Args:
             domain: The Hilbert space on which the form is defined.
-            mapping: A function `f(x)` defining the action of the form.
             components: The component representation of the form.
+            mapping: The functional mapping `f(x)`. Used if `components` is None.
+            parallel: Whether to use parallel computing components from the mapping.
+            n_jobs: The number of jobs to use for parallel computing.
+
+        Raises:
+            AssertionError: If neither or both `mapping` and `components`
+                are specified.
+
+        Notes:
+            Parallel options only relevant if the form is defined by a mapping.
+
+            If both `components` and `mapping` are specified, `components`
+            will take precedence.
         """
 
-        self._domain: HilbertSpace = domain
+        super().__init__(
+            domain,
+            self._mapping_impl,
+            gradient=self._gradient_impl,
+            hessian=self._hessian_impl,
+        )
 
         if components is None:
             if mapping is None:
                 raise AssertionError("Neither mapping nor components specified.")
-            self._compute_components(mapping)
+            self._compute_components(mapping, parallel, n_jobs)
         else:
             self._components: np.ndarray = components
 
@@ -93,7 +116,7 @@ class LinearForm:
         is the scalar result of the form's action.
         """
         from .hilbert_space import EuclideanSpace
-        from .operators import LinearOperator
+        from .linear_operators import LinearOperator
 
         return LinearOperator(
             self.domain,
@@ -108,10 +131,6 @@ class LinearForm:
         """
         return LinearForm(self.domain, components=self.components.copy())
 
-    def __call__(self, x: Any) -> float:
-        """Applies the linear form to a vector."""
-        return np.dot(self._components, self.domain.to_components(x))
-
     def __neg__(self) -> LinearForm:
         """Returns the additive inverse of the form."""
         return LinearForm(self.domain, components=-self._components)
@@ -128,13 +147,47 @@ class LinearForm:
         """Returns the division of the form by a scalar."""
         return self * (1.0 / a)
 
-    def __add__(self, other: LinearForm) -> LinearForm:
-        """Returns the sum of this form and another."""
-        return LinearForm(self.domain, components=self.components + other.components)
+    def __add__(self, other: NonLinearForm | LinearForm) -> NonLinearForm | LinearForm:
+        """
+        Returns the sum of this form and another.
+
+        If `other` is also a `LinearForm`, this performs an optimized,
+        component-wise addition. Otherwise, it delegates to the general
+        implementation in the `NonLinearForm` base class.
+
+        Args:
+            other: The form to add to this one.
+
+        Returns:
+            A `LinearForm` if adding two `LinearForm`s, otherwise a `NonLinearForm`.
+        """
+        if isinstance(other, LinearForm):
+            return LinearForm(
+                self.domain, components=self.components + other.components
+            )
+        else:
+            return super().__add__(other)
+
+    def __sub__(self, other: NonLinearForm | LinearForm) -> NonLinearForm | LinearForm:
+        """
+        Returns the difference of this form and another.
+
+        If `other` is also a `LinearForm`, this performs an optimized,
+        component-wise subtraction. Otherwise, it delegates to the general
+        implementation in the `NonLinearForm` base class.
+
+        Args:
+            other: The form to subtract from this one.
 
-    def __sub__(self, other: LinearForm) -> LinearForm:
-        """Returns the difference between this form and another."""
-        return LinearForm(self.domain, components=self.components - other.components)
+        Returns:
+            A `LinearForm` if subtracting two `LinearForm`s, otherwise a `NonLinearForm`.
+        """
+        if isinstance(other, LinearForm):
+            return LinearForm(
+                self.domain, components=self.components - other.components
+            )
+        else:
+            return super().__sub__(other)
 
     def __imul__(self, a: float) -> "LinearForm":
         """
@@ -156,14 +209,55 @@ class LinearForm:
         """Returns the string representation of the form's components."""
         return self.components.__str__()
 
-    def _compute_components(self, mapping: Callable[[Any], float]):
+    def _compute_components(
+        self,
+        mapping: Callable[[Any], float],
+        parallel: bool,
+        n_jobs: Optional[int],
+    ):
+        """Computes the component vector of the form, with an optional parallel backend."""
+        if not parallel:
+            self._components = np.zeros(self.domain.dim)
+            cx = np.zeros(self.domain.dim)
+            for i in range(self.domain.dim):
+                cx[i] = 1.0
+                x = self.domain.from_components(cx)
+                self._components[i] = mapping(x)
+                cx[i] = 0.0
+        else:
+
+            def compute_one_component(i: int) -> float:
+                """
+                Computes a single component for a given basis vector index.
+                This function is sent to each parallel worker.
+                """
+
+                # cx = np.zeros(self.domain.dim)
+                # cx[i] = 1.0
+                # x = self.domain.from_components(cx)
+                x = self.domain.basis_vector(i)
+                return mapping(x)
+
+            # Run the helper function in parallel for each dimension
+            results = Parallel(n_jobs=n_jobs)(
+                delayed(compute_one_component)(i) for i in range(self.domain.dim)
+            )
+            self._components = np.array(results)
+
+    def _mapping_impl(self, x: Vector) -> float:
+        """
+        Maps a vector to its scalar value.
+        """
+        return np.dot(self.components, self.domain.to_components(x))
+
+    def _gradient_impl(self, _: Vector) -> Vector:
+        """
+        Computes the gradient of the form at a point.
+        """
+        return self.domain.from_dual(self)
+
+    def _hessian_impl(self, _: Vector) -> LinearOperator:
         """
-        Computes the component vector of the form.
+        Computes the Hessian of the form at a point.
         """
-        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
+        return self.domain.zero_operator()