pygeoinf 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

pygeoinf/subspaces.py

@@ -3,29 +3,25 @@ Defines classes for representing affine and linear subspaces.
 
 The primary abstraction is the `AffineSubspace`, which represents a subset of
 a Hilbert space defined by a translation and a closed linear tangent space.
-`LinearSubspace` is a specialization where the translation is zero.
 """
 
 from __future__ import annotations
 from typing import List, Optional, Any, Callable, TYPE_CHECKING
 import numpy as np
+import warnings
 
 from .linear_operators import LinearOperator
 from .hilbert_space import HilbertSpace, Vector, EuclideanSpace
 from .linear_solvers import LinearSolver, CholeskySolver, IterativeLinearSolver
 
 if TYPE_CHECKING:
-    # Avoid circular imports for type checking
-    pass
+    from .gaussian_measure import GaussianMeasure
 
 
 class OrthogonalProjector(LinearOperator):
     """
     Internal engine for subspace projections.
-
     Represents an orthogonal projection operator P = P* = P^2.
-    While this class can be used directly, it is generally recommended to use
-    `AffineSubspace` or `LinearSubspace` for high-level problem definitions.
     """
 
     def __init__(
@@ -52,9 +48,8 @@ class OrthogonalProjector(LinearOperator):
         basis_vectors: List[Vector],
         orthonormalize: bool = True,
     ) -> OrthogonalProjector:
-        """Constructs P from a basis spanning the range."""
+        """Constructs a projector P onto the span of the provided basis vectors."""
         if not basis_vectors:
-            # Return zero operator if basis is empty
             return domain.zero_operator(domain)
 
         if orthonormalize:
@@ -78,7 +73,12 @@ class AffineSubspace:
         translation: Optional[Vector] = None,
         constraint_operator: Optional[LinearOperator] = None,
         constraint_value: Optional[Vector] = None,
+        solver: Optional[LinearSolver] = None,
+        preconditioner: Optional[LinearOperator] = None,
     ) -> None:
+        """
+        Initializes the AffineSubspace.
+        """
         self._projector = projector
 
         if translation is None:
@@ -91,6 +91,15 @@ class AffineSubspace:
         self._constraint_operator = constraint_operator
         self._constraint_value = constraint_value
 
+        # Logic: If explicit equation exists, default to Cholesky.
+        # If implicit, leave None (requires robust solver from user).
+        if self._constraint_operator is not None and solver is None:
+            self._solver = CholeskySolver(galerkin=True)
+        else:
+            self._solver = solver
+
+        self._preconditioner = preconditioner
+
     @property
     def domain(self) -> HilbertSpace:
         return self._projector.domain
@@ -108,27 +117,39 @@ class AffineSubspace:
         return LinearSubspace(self._projector)
 
     @property
-    def has_constraint_equation(self) -> bool:
+    def has_explicit_equation(self) -> bool:
+        """True if defined by B(u)=w, False if defined only by geometry."""
         return self._constraint_operator is not None
 
     @property
     def constraint_operator(self) -> LinearOperator:
+        """
+        Returns B for {u | B(u)=w}.
+        Falls back to (I - P) if no explicit operator exists.
+        """
         if self._constraint_operator is None:
-            raise AttributeError("This subspace is not defined by a linear equation.")
+            return self._projector.complement
         return self._constraint_operator
 
     @property
     def constraint_value(self) -> Vector:
+        """
+        Returns w for {u | B(u)=w}.
+        Falls back to (I - P)x0 if no explicit operator exists.
+        """
         if self._constraint_value is None:
-            raise AttributeError("This subspace is not defined by a linear equation.")
+            complement = self._projector.complement
+            return complement(self._translation)
         return self._constraint_value
 
     def project(self, x: Vector) -> Vector:
+        """Orthogonally projects x onto the affine subspace."""
         diff = self.domain.subtract(x, self.translation)
         proj_diff = self.projector(diff)
         return self.domain.add(self.translation, proj_diff)
 
     def is_element(self, x: Vector, rtol: float = 1e-6) -> bool:
+        """Returns True if x lies in the subspace."""
         proj = self.project(x)
         diff = self.domain.subtract(x, proj)
         norm_diff = self.domain.norm(diff)
@@ -136,6 +157,46 @@ class AffineSubspace:
         scale = norm_x if norm_x > 1e-12 else 1.0
         return norm_diff <= rtol * scale
 
+    def condition_gaussian_measure(
+        self, prior: GaussianMeasure, geometric: bool = False
+    ) -> GaussianMeasure:
+        """
+        Conditions a Gaussian measure on this subspace.
+        """
+        if geometric:
+            # Geometric Projection: u -> P(u - x0) + x0
+            # Affine Map: u -> P(u) + (I-P)x0
+            shift = self.domain.subtract(
+                self.translation, self.projector(self.translation)
+            )
+            return prior.affine_mapping(operator=self.projector, translation=shift)
+
+        else:
+            # Bayesian Conditioning: u | B(u)=w
+
+            # Check for singular implicit operator usage
+            if not self.has_explicit_equation and self._solver is None:
+                raise ValueError(
+                    "This subspace defines the constraint implicitly as (I-P)u = (I-P)x0. "
+                    "The operator (I-P) is singular. You must provide a solver "
+                    "capable of handling singular systems (e.g. MinRes) to the "
+                    "AffineSubspace constructor."
+                )
+
+            # Local imports
+            from .forward_problem import LinearForwardProblem
+            from .linear_bayesian import LinearBayesianInversion
+
+            solver = self._solver
+            preconditioner = self._preconditioner
+
+            constraint_problem = LinearForwardProblem(self.constraint_operator)
+            constraint_inversion = LinearBayesianInversion(constraint_problem, prior)
+
+            return constraint_inversion.model_posterior_measure(
+                self.constraint_value, solver, preconditioner=preconditioner
+            )
+
     @classmethod
     def from_linear_equation(
         cls,
@@ -144,7 +205,7 @@ class AffineSubspace:
         solver: Optional[LinearSolver] = None,
         preconditioner: Optional[LinearOperator] = None,
     ) -> AffineSubspace:
-        """Constructs the subspace {u | B(u) = w}."""
+        """Constructs subspace from B(u)=w."""
         domain = operator.domain
         G = operator @ operator.adjoint
 
@@ -166,7 +227,12 @@ class AffineSubspace:
         projector = OrthogonalProjector(domain, mapping, complement_projector=P_perp_op)
 
         return cls(
-            projector, translation, constraint_operator=operator, constraint_value=value
+            projector,
+            translation,
+            constraint_operator=operator,
+            constraint_value=value,
+            solver=solver,
+            preconditioner=preconditioner,
         )
 
     @classmethod
@@ -176,18 +242,38 @@ class AffineSubspace:
         basis_vectors: List[Vector],
         translation: Optional[Vector] = None,
         orthonormalize: bool = True,
+        solver: Optional[LinearSolver] = None,
+        preconditioner: Optional[LinearOperator] = None,
     ) -> AffineSubspace:
         """
-        Constructs the subspace passing through 'translation' with the given
-        tangent basis.
-
-        Note: This does not define a constraint equation B(u)=w, so it cannot
-        be used directly with ConstrainedLinearBayesianInversion.
+        Constructs an affine subspace from a translation and a basis for the tangent space.
+
+        This method defines the subspace geometrically. The constraint is implicit:
+        (I - P)u = (I - P)x0.
+
+        Args:
+            domain: The Hilbert space.
+            basis_vectors: Basis vectors for the tangent space V.
+            translation: A point x0 in the subspace.
+            orthonormalize: If True, orthonormalizes the basis.
+            solver: A linear solver capable of handling the singular operator (I-P).
+                    Required if you intend to use this subspace for Bayesian conditioning.
+            preconditioner: Optional preconditioner for the solver.
         """
+        if solver is None:
+            warnings.warn(
+                "Constructing a subspace from a tangent basis without a solver. "
+                "This defines an implicit constraint with a singular operator. "
+                "Bayesian conditioning will fail; geometric projection remains available.",
+                UserWarning,
+                stacklevel=2,
+            )
+
         projector = OrthogonalProjector.from_basis(
             domain, basis_vectors, orthonormalize=orthonormalize
         )
-        return cls(projector, translation)
+
+        return cls(projector, translation, solver=solver, preconditioner=preconditioner)
 
     @classmethod
     def from_complement_basis(
@@ -198,24 +284,18 @@ class AffineSubspace:
         orthonormalize: bool = True,
     ) -> AffineSubspace:
         """
-        Constructs the subspace orthogonal to the given basis, passing through
-        'translation'.
-
-        This automatically constructs the constraint operator B such that
-        the subspace is {u | B(u) = B(translation)}.
+        Constructs subspace from complement basis.
+        Constraint is explicit: <u, e_i> = <x0, e_i>.
         """
-        # 1. Orthonormalize basis for stability
         if orthonormalize:
             e_vectors = domain.gram_schmidt(basis_vectors)
         else:
             e_vectors = basis_vectors
 
-        # 2. Construct Projector P_perp
         complement_projector = OrthogonalProjector.from_basis(
-            domain, e_vectors, orthonormalize=False  # Already done
+            domain, e_vectors, orthonormalize=False
         )
 
-        # 3. Construct Projector P = I - P_perp
         def mapping(x: Any) -> Any:
             return domain.subtract(x, complement_projector(x))
 
@@ -223,16 +303,12 @@ class AffineSubspace:
             domain, mapping, complement_projector=complement_projector
         )
 
-        # 4. Construct Constraint Operator B implicitly defined by the basis
-        # B: E -> R^k, u -> [<e_1, u>, ..., <e_k, u>]
-        # Since e_i are orthonormal, BB* = I, which is perfect for solvers.
         codomain = EuclideanSpace(len(e_vectors))
 
         def constraint_mapping(u: Vector) -> np.ndarray:
             return np.array([domain.inner_product(e, u) for e in e_vectors])
 
         def constraint_adjoint(c: np.ndarray) -> Vector:
-            # sum c_i e_i
             res = domain.zero
             for i, e in enumerate(e_vectors):
                 domain.axpy(c[i], e, res)
@@ -242,8 +318,6 @@ class AffineSubspace:
             domain, codomain, constraint_mapping, adjoint_mapping=constraint_adjoint
         )
 
-        # 5. Determine Constraint Value w = B(translation)
-        # If translation is None (zero), w is zero.
         if translation is None:
             _translation = domain.zero
             w = codomain.zero
@@ -251,12 +325,20 @@ class AffineSubspace:
             _translation = translation
             w = B(_translation)
 
-        return cls(projector, _translation, constraint_operator=B, constraint_value=w)
+        solver = CholeskySolver(galerkin=True)
+
+        return cls(
+            projector,
+            _translation,
+            constraint_operator=B,
+            constraint_value=w,
+            solver=solver,
+        )
 
 
 class LinearSubspace(AffineSubspace):
     """
-    Represents a linear subspace (an affine subspace passing through zero).
+    Represents a linear subspace (an affine subspace passing through the origin).
     """
 
     def __init__(self, projector: OrthogonalProjector) -> None:
@@ -272,14 +354,19 @@ class LinearSubspace(AffineSubspace):
 
     @classmethod
     def from_kernel(
-        cls, operator: LinearOperator, solver: Optional[LinearSolver] = None
+        cls,
+        operator: LinearOperator,
+        solver: Optional[LinearSolver] = None,
+        preconditioner: Optional[LinearOperator] = None,
     ) -> LinearSubspace:
         affine = AffineSubspace.from_linear_equation(
-            operator, operator.codomain.zero, solver
+            operator, operator.codomain.zero, solver, preconditioner
         )
         instance = cls(affine.projector)
         instance._constraint_operator = operator
         instance._constraint_value = operator.codomain.zero
+        instance._solver = affine._solver
+        instance._preconditioner = preconditioner
         return instance
 
     @classmethod
@@ -288,11 +375,16 @@ class LinearSubspace(AffineSubspace):
         domain: HilbertSpace,
         basis_vectors: List[Vector],
         orthonormalize: bool = True,
+        solver: Optional[LinearSolver] = None,
+        preconditioner: Optional[LinearOperator] = None,
     ) -> LinearSubspace:
         projector = OrthogonalProjector.from_basis(
             domain, basis_vectors, orthonormalize=orthonormalize
         )
-        return cls(projector)
+        instance = cls(projector)
+        instance._solver = solver
+        instance._preconditioner = preconditioner
+        return instance
 
     @classmethod
     def from_complement_basis(
@@ -304,8 +396,8 @@ class LinearSubspace(AffineSubspace):
         affine = AffineSubspace.from_complement_basis(
             domain, basis_vectors, translation=None, orthonormalize=orthonormalize
         )
-        # Copy constraint info from the affine instance
         instance = cls(affine.projector)
         instance._constraint_operator = affine.constraint_operator
         instance._constraint_value = affine.constraint_value
+        instance._solver = affine._solver
         return instance

pygeoinf/symmetric_space/sh_tools.py

@@ -8,19 +8,31 @@ import numpy as np
 
 
 class SHVectorConverter:
-    """
+    r"""
     Handles conversion between pyshtools 3D coefficient arrays and 1D vectors.
 
-    This class provides a bridge between the pyshtools data structure for
-    spherical harmonic coefficients, a 3D array of shape (2, lmax+1, lmax+1),
-    and the 1D vector format often used in linear algebra and inverse problems.
+    This class bridges the gap between the `pyshtools` 3D array format
+    (shape `[2, lmax+1, lmax+1]`) and the flat 1D vector format used in
+    linear algebra.
+
+    **Vector Layout:**
+    The output vector is ordered first by degree $l$ (ascending from `lmin` to `lmax`),
+    and then by order $m$ (ascending from $-l$ to $+l$).
+
+    The sequence of coefficients is:
+
+    .. math::
+        [u_{l_{min}, -l_{min}}, \dots, u_{l_{min}, l_{min}}, \quad
+         u_{l_{min}+1, -(l_{min}+1)}, \dots, u_{l_{min}+1, l_{min}+1}, \quad \dots]
+
+    **Example (lmin=0):**
 
-    The vector is ordered by degree l, and within each degree, by order m,
-    from -l to +l.
+    .. math::
+        [u_{0,0}, \quad u_{1,-1}, u_{1,0}, u_{1,1}, \quad u_{2,-2}, u_{2,-1}, u_{2,0}, u_{2,1}, u_{2,2}, \dots]
 
     Args:
         lmax (int): The maximum spherical harmonic degree to include.
-        lmin (int): The minimum spherical harmonic degree to include. Defaults to 2.
+        lmin (int): The minimum spherical harmonic degree to include. Defaults to 0.
     """
 
     def __init__(self, lmax: int, lmin: int = 0):

pygeoinf/symmetric_space/sphere.py

@@ -532,30 +532,26 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
         )
 
     def to_coefficient_operator(self, lmax: int, lmin: int = 0):
-        """
-        Returns a LinearOperator that maps an element of the space to
-        a vector of its spherical harmonic coefficients within the
-        specified range of degrees.
+        r"""
+        Returns a LinearOperator mapping a function to its spherical harmonic coefficients.
 
-        The output coefficients are ordered in the following manner:
+        The operator maps an element of the Hilbert space to a vector in $\mathbb{R}^k$.
+        The coefficients in the output vector are ordered by degree $l$ (major)
+        and order $m$ (minor), from $-l$ to $+l$.
 
-        u_{00}, u_{1-1}, u_{10}, u_{11}, u_{2-2}, u_{2-1}, u_{20}, u_{21}, u_{22}, ...
+        **Ordering:**
 
-        in this case assuming lmin = 0.
+        .. math::
+            u = [u_{0,0}, \quad u_{1,-1}, u_{1,0}, u_{1,1}, \quad u_{2,-2}, \dots, u_{2,2}, \quad \dots]
 
-        If lmax is larger than the field's lmax, the output will be padded by zeros.
+        (assuming `lmin=0`).
 
         Args:
             lmax: The maximum spherical harmonic degree to include in the output.
-            lmin: The minimum spherical harmonic degree to include in the output.
-                Defaults to 0.
+            lmin: The minimum spherical harmonic degree to include. Defaults to 0.
 
         Returns:
-            A LinearOperator that maps an SHGrid to a NumPy vector of coefficients.
-
-        Notes:
-            This is a left inverse of the from_coefficient_operator so long a the
-            values for lmin and lmax are equal.
+            A LinearOperator mapping `SHGrid` -> `numpy.ndarray`.
         """
 
         converter = SHVectorConverter(lmax, lmin)
@@ -577,27 +573,25 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
         return LinearOperator(self, codomain, mapping, adjoint_mapping=adjoint_mapping)
 
     def from_coefficient_operator(self, lmax: int, lmin: int = 0):
-        """
-        Returns a LinearOperator that maps a vector of spherical harmonic coefficients
-        to an element of the space.
+        r"""
+        Returns a LinearOperator mapping a vector of coefficients to a function.
 
-        The input coefficients are ordered in the following manner:
+        The operator maps a vector in $\mathbb{R}^k$ to an element of the Hilbert space.
+        The input vector must follow the standard $l$-major, $m$-minor ordering.
 
-        u_{00}, u_{1-1}, u_{10}, u_{11}, u_{2-2}, u_{2-1}, u_{20}, u_{21}, u_{22}, ...
+        **Ordering:**
 
-        in this case assuming lmin = 0.
+        .. math::
+            v = [u_{0,0}, \quad u_{1,-1}, u_{1,0}, u_{1,1}, \quad u_{2,-2}, \dots, u_{2,2}, \quad \dots]
+
+        (assuming `lmin=0`).
 
         Args:
-            lmax: The maximum spherical harmonic degree to include in the output.
-            lmin: The minimum spherical harmonic degree to include in the output.
-                Defaults to 0.
+            lmax: The maximum spherical harmonic degree expected in the input.
+            lmin: The minimum spherical harmonic degree expected. Defaults to 0.
 
         Returns:
-            A LinearOperator that maps a NumPy vector of coefficients to an SHGrid.
-
-        Notes:
-            This is a right inverse of the to_coefficient_operator so long a the
-            values for lmin and lmax are equal.
+            A LinearOperator mapping `numpy.ndarray` -> `SHGrid`.
         """
 
         converter = SHVectorConverter(lmax, lmin)
@@ -783,30 +777,26 @@ class Sobolev(SphereHelper, MassWeightedHilbertModule, AbstractInvariantSobolevS
         )
 
     def to_coefficient_operator(self, lmax: int, lmin: int = 0):
-        """
-        Returns a LinearOperator that maps an element of the space to
-        a vector of its spherical harmonic coefficients within the
-        specified range of degrees.
+        r"""
+        Returns a LinearOperator mapping a function to its spherical harmonic coefficients.
 
-        The output coefficients are ordered in the following manner:
+        The operator maps an element of the Hilbert space to a vector in $\mathbb{R}^k$.
+        The coefficients in the output vector are ordered by degree $l$ (major)
+        and order $m$ (minor), from $-l$ to $+l$.
 
-        u_{00}, u_{1-1}, u_{10}, u_{11}, u_{2-2}, u_{2-1}, u_{20}, u_{21}, u_{22}, ...
+        **Ordering:**
 
-        in this case assuming lmin = 0.
+        .. math::
+            u = [u_{0,0}, \quad u_{1,-1}, u_{1,0}, u_{1,1}, \quad u_{2,-2}, \dots, u_{2,2}, \quad \dots]
 
-        If lmax is larger than the field's lmax, the output will be padded by zeros.
+        (assuming `lmin=0`).
 
         Args:
             lmax: The maximum spherical harmonic degree to include in the output.
-            lmin: The minimum spherical harmonic degree to include in the output.
-                Defaults to 0.
+            lmin: The minimum spherical harmonic degree to include. Defaults to 0.
 
         Returns:
-            A LinearOperator that maps an SHGrid to a NumPy vector of coefficients.
-
-        Notes:
-            This is a left inverse of the from_coefficient_operator so long a the
-            values for lmin and lmax are equal.
+            A LinearOperator mapping `SHGrid` -> `numpy.ndarray`.
         """
 
         l2_operator = self.underlying_space.to_coefficient_operator(lmax, lmin)
@@ -816,27 +806,25 @@ class Sobolev(SphereHelper, MassWeightedHilbertModule, AbstractInvariantSobolevS
         )
 
     def from_coefficient_operator(self, lmax: int, lmin: int = 0):
-        """
-        Returns a LinearOperator that maps a vector of spherical harmonic coefficients
-        to an element of the space.
+        r"""
+        Returns a LinearOperator mapping a vector of coefficients to a function.
 
-        The input coefficients are ordered in the following manner:
+        The operator maps a vector in $\mathbb{R}^k$ to an element of the Hilbert space.
+        The input vector must follow the standard $l$-major, $m$-minor ordering.
 
-        u_{00}, u_{1-1}, u_{10}, u_{11}, u_{2-2}, u_{2-1}, u_{20}, u_{21}, u_{22}, ...
+        **Ordering:**
 
-        in this case assuming lmin = 0.
+        .. math::
+            v = [u_{0,0}, \quad u_{1,-1}, u_{1,0}, u_{1,1}, \quad u_{2,-2}, \dots, u_{2,2}, \quad \dots]
+
+        (assuming `lmin=0`).
 
         Args:
-            lmax: The maximum spherical harmonic degree to include in the output.
-            lmin: The minimum spherical harmonic degree to include in the output.
-                Defaults to 0.
+            lmax: The maximum spherical harmonic degree expected in the input.
+            lmin: The minimum spherical harmonic degree expected. Defaults to 0.
 
         Returns:
-            A LinearOperator that maps a NumPy vector of coefficients to an SHGrid.
-
-        Notes:
-            This is a right inverse of the to_coefficient_operator so long a the
-            values for lmin and lmax are equal.
+            A LinearOperator mapping `numpy.ndarray` -> `SHGrid`.
         """
 
         l2_operator = self.underlying_space.from_coefficient_operator(lmax, lmin)

{pygeoinf-1.3.5.dist-info → pygeoinf-1.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeoinf
-Version: 1.3.5
+Version: 1.3.7
 Summary: A package for solving geophysical inference and inverse problems
 License: BSD-3-Clause
 License-File: LICENSE

{pygeoinf-1.3.5.dist-info → pygeoinf-1.3.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pygeoinf/__init__.py,sha256=IrG0WA80NuoXRJvoKNG7lKcht5ICBEQacjtuqBKQ2fU,3622
+pygeoinf/__init__.py,sha256=OdtIgD3aF4LQ4UzponWblw4nQihRntqnni7m1DPdd5I,4076
 pygeoinf/auxiliary.py,sha256=lfoTt9ZH4y8SAV8dKZi5EWx1oF_JtxtBMSmlFYqJYfE,1610
 pygeoinf/backus_gilbert.py,sha256=eFi4blSwOCsg_NuH6WD4gcgjvzvu5g5WpWahGobSBdM,3694
 pygeoinf/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -10,24 +10,25 @@ pygeoinf/forward_problem.py,sha256=NnqWp7iMfkhHa9d-jBHzYHClaAfhKmO5D058AcJLLYg,1
 pygeoinf/gaussian_measure.py,sha256=bBh64xHgmLFl27krn9hkf8qDQjop_39x69cyhJgUHN8,26219
 pygeoinf/hilbert_space.py,sha256=Yc0Jw0A8Jo12Zpgb_9dhcF7CD77S1IDMrSTDFHpTRB8,27340
 pygeoinf/inversion.py,sha256=RV0hG2bGnciWdja0oOPKPxnFhYzufqdj-mKYNr4JJ_o,6447
-pygeoinf/linear_bayesian.py,sha256=o6m0fYESba8rE-rjxfCqXaV6irPthB1aWf8vhM2v8XQ,11324
+pygeoinf/linear_bayesian.py,sha256=qzWEVaNe9AwG5GBmGHgVHswEMFKBWvOOJDlS95ahyxc,8877
 pygeoinf/linear_forms.py,sha256=mgZeDRegNKo8kviE68KrxkHR4gG9bf1RgsJz1MtDMCk,9181
 pygeoinf/linear_operators.py,sha256=Bn-uzwUXi2kkWZ7wc9Uhj3vBHtocN17hnzc_r7DAzTk,64530
-pygeoinf/linear_optimisation.py,sha256=vF1T3HE9rPOnXy3PU82-46dlvGwdAvsqUNXOx0o-KD8,20431
-pygeoinf/linear_solvers.py,sha256=v-7yjKsa67Ts5EcyJzCdpj-aF0qBrA-akq0kLe59DS4,16843
+pygeoinf/linear_optimisation.py,sha256=RhO-1OsEDGnVHBlCtYyqp8jmW4GeGnGWGPRYPSc5GSg,13922
+pygeoinf/linear_solvers.py,sha256=tYBp_ysePnOgqgKhMXhNHxLM8xi3awiwwdnKXHhmlNk,31071
 pygeoinf/nonlinear_forms.py,sha256=t7lk-Bha7Xdk9eiwXMmS0F47oTR6jW6qQ3HkgRGk54A,7012
 pygeoinf/nonlinear_operators.py,sha256=AtkDTQfGDzAnfFDIgiKfdk7uPEI-j_ZA3CNvY5A3U8w,7144
 pygeoinf/nonlinear_optimisation.py,sha256=skK1ikn9GrVYherD64Qt9WrEYHA2NAJ48msOu_J8Oig,7431
 pygeoinf/parallel.py,sha256=VVFvNHszy4wSa9LuErIsch4NAkLaZezhdN9YpRROBJo,2267
 pygeoinf/plot.py,sha256=Uw9PCdxymUiAkFF0BS0kUAZBRWL6sh89FJnSIxtp_2s,13664
-pygeoinf/random_matrix.py,sha256=71l6eAXQ2pRMleaz1lXud6O1F78ugKyp3vHcRBXhdwM,17661
-pygeoinf/subspaces.py,sha256=5Bo1F9if5oEmKJ0YPWMFaajJKec5aGIrYZKvetwWa3c,10454
+pygeoinf/preconditioners.py,sha256=81PnzoQZzsf5mvXBYsHuadf1CdiGFlMbQn_tC2xPQ1k,4503
+pygeoinf/random_matrix.py,sha256=-U_3-yrVos_86EfNy1flULsWY-Y9G9Yy1GKoSS2gn60,17828
+pygeoinf/subspaces.py,sha256=FJobjDRr8JG1zz-TjBsncJ1M5phQYwbttlaGuJz9ycU,13779
 pygeoinf/symmetric_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeoinf/symmetric_space/circle.py,sha256=GuwVmLdHGTMxMrZfyXIPP3pz_y971ntlD5pl42lKJZ0,18796
-pygeoinf/symmetric_space/sh_tools.py,sha256=_A_coPElu8DNYwA5udL92X87wiTyBClTbFtf6ch9nXM,3520
-pygeoinf/symmetric_space/sphere.py,sha256=wZlAVG3kKMuPmRURL4r2ZP3sQ8kWOAWRk1G_Lo_TZmo,28983
+pygeoinf/symmetric_space/sh_tools.py,sha256=EDZm0YRZefvCfDjAKZatZMM3UqeTi-Npiflnc1E5slk,3884
+pygeoinf/symmetric_space/sphere.py,sha256=wYaZ2wqkQAHw9pn4vP_6LR9HAXSpzCncCh24xmSSC5A,28481
 pygeoinf/symmetric_space/symmetric_space.py,sha256=pEIZZYWsdegrYCwUs3bo86JTz3d2LsXFWdRYFa0syFs,17963
-pygeoinf-1.3.5.dist-info/METADATA,sha256=m0YVVuJ1McMBzUG1QYdurV1hB91UGmIiSn-STSq9a0s,16482
-pygeoinf-1.3.5.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-pygeoinf-1.3.5.dist-info/licenses/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
-pygeoinf-1.3.5.dist-info/RECORD,,
+pygeoinf-1.3.7.dist-info/METADATA,sha256=rJugIyw0YNv6ccIFCnXNmISbwUclP-V8Zt1ZDLbqPpw,16482
+pygeoinf-1.3.7.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+pygeoinf-1.3.7.dist-info/licenses/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
+pygeoinf-1.3.7.dist-info/RECORD,,