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

pygeoinf/nonlinear_optimisation.py

@@ -0,0 +1,211 @@
+"""
+Module for solution of non-linear inverse and inference problems based on optimisation methods.
+"""
+
+from typing import Any, Callable
+
+import numpy as np
+from scipy.optimize import minimize
+from scipy.optimize import line_search as scipy_line_search
+from scipy.sparse.linalg import LinearOperator as ScipyLinOp
+
+
+from .hilbert_space import Vector
+from .nonlinear_forms import NonLinearForm
+
+
+class ScipyUnconstrainedOptimiser:
+    """
+    A wrapper for scipy.optimize.minimize that adapts a NonLinearForm.
+    """
+
+    _HESSIAN_METHODS = {
+        "Newton-CG",
+        "trust-ncg",
+        "trust-krylov",
+        "trust-exact",
+        "dogleg",
+    }
+
+    _GRADIENT_METHODS = {"BFGS", "L-BFGS-B", "CG"}
+
+    _DERIVATIVE_FREE_METHODS = {"Nelder-Mead", "Powell"}
+
+    def __init__(self, method: str, /, **kwargs: Any) -> None:
+        """
+        Args:
+            method (str): The optimization method to use (e.g., 'Newton-CG', 'BFGS').
+            **kwargs: Options to be passed to scipy.optimize.minimize (e.g., tol, maxiter).
+        """
+        self.method = method
+        self.solver_kwargs = kwargs
+
+    def minimize(self, form: NonLinearForm, x0: Vector) -> Vector:
+        """
+        Finds the minimum of a NonLinearForm starting from an initial guess.
+
+        Args:
+            form (NonLinearForm): The non-linear functional to minimize.
+            x0 (Vector): The initial guess in the Hilbert space.
+
+        Returns:
+            Vector: The vector that minimizes the form.
+        """
+        domain = form.domain
+
+        def fun(cx: np.ndarray) -> float:
+            x = domain.from_components(cx)
+            return form(x)
+
+        jac_wrapper = None
+        if form.has_gradient:
+
+            def jac_func(cx: np.ndarray) -> np.ndarray:
+                x = domain.from_components(cx)
+                grad_x = form.gradient(x)
+                return domain.to_components(grad_x)
+
+            jac_wrapper = jac_func
+
+        hess_wrapper = None
+        if form.has_hessian:
+
+            def hess_func(cx: np.ndarray) -> ScipyLinOp:
+                x = domain.from_components(cx)
+                hessian_op = form.hessian(x)
+                return hessian_op.matrix(galerkin=True)
+
+            hess_wrapper = hess_func
+
+        final_jac = (
+            jac_wrapper if self.method not in self._DERIVATIVE_FREE_METHODS else None
+        )
+        final_hess = hess_wrapper if self.method in self._HESSIAN_METHODS else None
+
+        options = self.solver_kwargs.copy()
+        tol = options.pop("tol", None)
+
+        if self.method in self._GRADIENT_METHODS:
+            if tol is not None and "gtol" not in options:
+                options["gtol"] = tol
+
+        cx0 = domain.to_components(x0)
+
+        result = minimize(
+            fun=fun,
+            x0=cx0,
+            method=self.method,
+            jac=final_jac,
+            hess=final_hess,
+            tol=tol,
+            options=options,
+        )
+
+        c_final = result.x
+        return domain.from_components(c_final)
+
+
+def line_search(
+    form: NonLinearForm,
+    xk: Vector,
+    pk: Vector,
+    gfk: Vector = None,
+    old_fval: float = None,
+    old_old_fval: float = None,
+    c1: float = 0.0001,
+    c2: float = 0.9,
+    amax: float = None,
+    extra_condition: Callable[[float, Vector, float, Vector], bool] = None,
+    maxiter: int = 10,
+):
+    """
+    Wrapper for the scipy line_search method for application to a non-linear form.
+
+    Args:
+        form (NonLinearForm): The non-linear functional to minimize.
+        xk (Vector): The current point.
+        pk (Vector): The search direction.
+        gfk (Vector, optional): The gradient at x=xk. If not provided will be recalculated.
+        old_fval (float, optional): The function value at x=xk. If not provided will be recalculated.
+        old_old_fval (float, optional): The valur at the point proceeding x=xk.
+        c1 (float, optional): Parameter for Armijo condition rule.
+        c2 (float, optional): Parameter for curvature condition rule.
+        amax (float, optional): Maximum step size.
+        extra_condition (callable, optional): A callable of the form extra_condition(alpha, x, f, g) returning
+             a boolean. Arguments are the proposed step alpha and the corresponding x, f and g values. The line
+             search accepts the value of alpha only if this callable returns True. If the callable returns False
+             for the step length, the algorithm will continue with new iterates. The callable is only called for
+             iterates satisfying the strong Wolfe conditions.
+        maxiter (int, optional): Maximum number of iterations to perform.
+
+    Returns:
+        alpha (float | None): Alpha for which x_new = x0 + alpha * pk, or None if the
+             line search algorithm did not converge.
+        fc (int): Number of function evaluations made.
+        gc (int): Numner of gradient evaluations mades.
+        new_fval (float | None): New function value f(x_new)=f(x0+alpha*pk), or
+            None if the line search algorithm did not converge.
+        old_fval (float): Old function value f(x0).
+        new_slope (float | None): The local slope along the search direction at
+             the new value <myfprime(x_new), pk>, or None if the line search algorithm
+             did not converge.
+
+    Raises:
+        ValueError: If the non-linear form does not have a gradient set.
+    """
+
+    if not form.has_gradient:
+        raise ValueError("NonLinearForm must provide its gradient")
+
+    domain = form.domain
+
+    # Wrap the function.
+    def f(xc: np.ndarray) -> float:
+        x = domain.from_components(xc)
+        return form(x)
+
+    # Wrap the derivative. Note that this is given in
+    # terms of the components of the derivative (i.e., an element
+    # of the dual space) and not the gradient, this meaning that
+    # the standard Euclidean pairing with the components on the
+    #  descent direction will yield the correct slope.
+    def myfprime(c: np.ndarray) -> np.ndarray:
+        x = domain.from_components(c)
+        g = form.derivative(x)
+        return domain.dual.to_components(g)
+
+    # Convert the initial vector to components.
+    xkc = domain.to_components(xk)
+
+    # Convert descent direction to components
+    pkc = domain.to_components(pk)
+
+    # If gradient provided, convert to its dual components.
+    gfkc = domain.to_dual(gfk).components if gfk is not None else None
+
+    # Wrap the extra condition, if provided.
+
+    if extra_condition is not None:
+
+        def _extra_condition(
+            alpha: float, xc: np.ndarray, f: float, gc: np.ndarray
+        ) -> bool:
+            x = domain.from_components(xc)
+            df = domain.dual.from_components(gc)
+            g = domain.from_dual(df)
+            return extra_condition(alpha, x, f, g)
+
+    return scipy_line_search(
+        f,
+        myfprime,
+        xkc,
+        pkc,
+        gfk=gfkc,
+        old_fval=old_fval,
+        old_old_fval=old_old_fval,
+        c1=c1,
+        c2=c2,
+        amax=amax,
+        extra_condition=_extra_condition,
+        maxiter=maxiter,
+    )

pygeoinf/parallel.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     MatrixLike = Union[np.ndarray, ScipyLinOp]
 
 
-def parallel_mat_mat(A: "MatrixLike", B: np.ndarray, n_jobs: int = -1) -> np.ndarray:
+def parallel_mat_mat(A: MatrixLike, B: np.ndarray, n_jobs: int = -1) -> np.ndarray:
     """
     Computes the matrix product A @ B in parallel by applying A to each column of B.
 

pygeoinf/random_matrix.py

@@ -15,14 +15,10 @@ constructing approximate matrix decompositions" (2011).
 
 from typing import Tuple, Union
 
+import warnings
+
 import numpy as np
-from scipy.linalg import (
-    cho_factor,
-    solve_triangular,
-    eigh,
-    svd,
-    qr,
-)
+from scipy.linalg import cho_factor, solve_triangular, eigh, svd, qr
 from scipy.sparse.linalg import LinearOperator as ScipyLinOp
 
 from .parallel import parallel_mat_mat
@@ -50,6 +46,8 @@ def fixed_rank_random_range(
         power: The number of power iterations to perform. Power iterations
             (multiplying by `A*A`) improves the accuracy of the approximation by
             amplifying the dominant singular values, but adds to the computational cost.
+        parallel: Whether to use parallel matrix multiplication.
+        n_jobs: Number of jobs for parallelism.
 
     Returns:
         An (m, rank) matrix with orthonormal columns whose span approximates
@@ -87,76 +85,180 @@ def fixed_rank_random_range(
 
 
 def variable_rank_random_range(
-    matrix: MatrixLike, rank: int, /, *, power: int = 0, rtol: float = 1e-6
+    matrix: MatrixLike,
+    initial_rank: int,
+    /,
+    *,
+    max_rank: int = None,
+    power: int = 0,
+    block_size: int = 10,
+    rtol: float = 1e-4,
+    parallel: bool = False,
+    n_jobs: int = -1,
 ) -> np.ndarray:
     """
-    Computes an orthonormal basis for a variable-rank approximation to the
-    range of a matrix using a randomized method.
+    Computes a variable-rank orthonormal basis using a progressive sampling algorithm.
 
-    The algorithm adaptively determines the rank required to meet a given
-    error tolerance.
+    The algorithm starts with `initial_rank` samples, checks for convergence,
+    and then progressively draws new blocks of random samples until the desired
+    tolerance `rtol` is met or `max_rank` is reached.
 
     Args:
-        matrix (matrix-like): An (m, n) matrix or LinearOperator whose range
-            is to be approximated.
-        rank (int): The maximum rank for the approximation. The algorithm
-            may return a basis with a smaller rank.
-        power (int): Exponent for power iterations. Note: This parameter is
-            reserved for future functionality and is currently unused.
-        rtol (float): The relative tolerance for the approximation error, used
-            to determine the output rank.
+        matrix: The (m, n) matrix or LinearOperator.
+        initial_rank: The number of vectors to sample initially.
+        max_rank: A hard limit on the number of basis vectors. Defaults to min(m, n).
+        power: Number of power iterations to improve accuracy on the initial sample.
+        rtol: Relative tolerance for determining the output rank.
+        block_size: The number of new vectors to sample in each iteration.
+        parallel: Whether to use parallel matrix multiplication.
+        n_jobs: Number of jobs for parallelism.
 
     Returns:
-        numpy.ndarray: An (m, k) matrix with orthonormal columns, where k <= rank.
-            Its span approximates the range of the input matrix.
+        An (m, k) matrix with orthonormal columns that approximates the matrix's
+        range to the given tolerance.
+    """
+    m, n = matrix.shape
+    if max_rank is None:
+        max_rank = min(m, n)
 
-    Notes:
-        If the input matrix is a scipy LinearOperator, it must have the
-        `matvec` method implemented.
+    # Initial Sample
+    random_matrix = np.random.randn(n, initial_rank)
+    if parallel:
+        ys = parallel_mat_mat(matrix, random_matrix, n_jobs)
+    else:
+        ys = matrix @ random_matrix
 
-        This method is based on Algorithm 4.5 in Halko et al. 2011.
-    """
+    # Power Iterations on initial sample for a better starting point
+    for _ in range(power):
+        ys, _ = qr(ys, mode="economic")
+        if parallel:
+            ys_tilde = parallel_mat_mat(matrix.T, ys, n_jobs)
+            ys = parallel_mat_mat(matrix, ys_tilde, n_jobs)
+        else:
+            ys_tilde = matrix.T @ ys
+            ys = matrix @ ys_tilde
 
-    m, n = matrix.shape
+    # Form the initial basis
+    basis_vectors, _ = qr(ys, mode="economic")
+
+    # Progressively sample and check for convergence
+    converged = False
 
-    random_vectors = [np.random.randn(n) for _ in range(rank)]
-    ys = [matrix @ x for x in random_vectors]
-    basis_vectors = []
+    # Dynamically estimate norm for tolerance calculation
+    tol = None
 
-    def projection(xs: list, y: np.ndarray) -> np.ndarray:
-        ps = [np.dot(x, y) for x in xs]
-        for p, x in zip(ps, xs):
-            y -= p * x
-        return y
+    while basis_vectors.shape[1] < max_rank:
+        # Generate a NEW block of random vectors for error checking
+        test_vectors = np.random.randn(n, block_size)
+        if parallel:
+            y_test = parallel_mat_mat(matrix, test_vectors, n_jobs)
+        else:
+            y_test = matrix @ test_vectors
 
-    norm = max(np.linalg.norm(y) for y in ys)
+        # Estimate norm for tolerance on the first pass
+        if tol is None:
+            # Estimate spectral norm from the first block of test vectors.
+            # A more stable estimate than from a single vector.
+            norm_estimate = np.linalg.norm(y_test) / np.sqrt(block_size)
+            tol = rtol * norm_estimate
 
-    tol = rtol * norm / (10 * np.sqrt(2 / np.pi))
-    error = 2 * tol
-    j = -1
-    while error > tol:
-        j += 1
+        # Project test vectors onto current basis to find the residual
+        residual = y_test - basis_vectors @ (basis_vectors.T @ y_test)
+        error = np.linalg.norm(residual, ord=2)
 
-        ys[j] = projection(basis_vectors, ys[j])
-        ys[j] /= np.linalg.norm(ys[j])
-        basis_vectors.append(ys[j])
+        # Check for convergence
+        if error < tol:
+            converged = True
+            break
 
-        y = matrix @ np.random.randn(n)
-        y = projection(basis_vectors, y)
-        ys.append(y)
+        # If not converged, add the new information to the basis
+        new_basis, _ = qr(residual, mode="economic")
 
-        for i in range(j + 1, j + rank):
-            p = np.dot(basis_vectors[j], ys[i])
-            ys[i] -= p * basis_vectors[j]
+        # Append new basis vectors, ensuring we don't exceed max_rank
+        cols_to_add = min(new_basis.shape[1], max_rank - basis_vectors.shape[1])
+        if cols_to_add <= 0:
+            break
 
-        error = max(np.linalg.norm(ys[i]) for i in range(j + 1, j + rank + 1))
+        basis_vectors = np.hstack([basis_vectors, new_basis[:, :cols_to_add]])
 
-        if j > min(n, m):
-            raise RuntimeError("Convergence has failed")
+    if not converged and basis_vectors.shape[1] >= max_rank:
+        warnings.warn(
+            f"Tolerance {rtol} not met before reaching max_rank={max_rank}. "
+            "Result may be inaccurate. Consider increasing `max_rank` or `power`.",
+            UserWarning,
+        )
 
-    qr_factor = np.column_stack(basis_vectors)
+    return basis_vectors
 
-    return qr_factor
+
+def random_range(
+    matrix: MatrixLike,
+    size_estimate: int,
+    /,
+    *,
+    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,
+) -> np.ndarray:
+    """
+    A unified wrapper for randomized range finding algorithms.
+
+    Args:
+        matrix: The (m, n) matrix or LinearOperator to analyze.
+        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:
+        An (m, k) orthonormal matrix approximating the input matrix's range.
+
+    Raises:
+        ValueError: If an unknown method is specified.
+    """
+    if method == "variable":
+        return variable_rank_random_range(
+            matrix,
+            size_estimate,
+            max_rank=max_rank,
+            power=power,
+            block_size=block_size,
+            rtol=rtol,
+            parallel=parallel,
+            n_jobs=n_jobs,
+        )
+    elif method == "fixed":
+        if any([rtol != 1e-4, block_size != 10, max_rank is not None]):
+            warnings.warn(
+                "'rtol', 'block_size', and 'max_rank' are ignored when method='fixed'.",
+                UserWarning,
+            )
+        return fixed_rank_random_range(
+            matrix,
+            rank=size_estimate,
+            power=power,
+            parallel=parallel,
+            n_jobs=n_jobs,
+        )
+    else:
+        raise ValueError(
+            f"Unknown method '{method}'. Choose from 'fixed' or 'variable'."
+        )
 
 
 def random_svd(
@@ -220,28 +322,66 @@ def random_eig(
     return qr_factor @ eigenvectors, eigenvalues
 
 
-def random_cholesky(matrix: MatrixLike, qr_factor: np.ndarray) -> np.ndarray:
+def random_cholesky(
+    matrix: MatrixLike, qr_factor: np.ndarray, *, rtol: float = 1e-12
+) -> np.ndarray:
     """
-    Computes an approximate Cholesky factorisation for a symmetric positive-
-    definite matrix from a low-rank range approximation.
+    Computes a robust approximate Cholesky factorization using a fallback strategy.
+
+    It first attempts a direct Cholesky factorization. If that fails, it falls
+    back to a method based on eigendecomposition.
 
     Args:
-        matrix (matrix-like): The original symmetric positive-definite (n, n)
-            matrix or LinearOperator.
+        matrix (matrix-like): The original symmetric (n, n) matrix.
         qr_factor (numpy.ndarray): An (n, k) orthonormal basis for the
             approximate range of the matrix.
+        rtol (float, optional): A relative tolerance used in the fallback path.
+            Any eigenvalue `s` such that `s < rtol * max(eigenvalues)` will be
+            treated as zero. Defaults to 1e-12.
 
     Returns:
         numpy.ndarray: The approximate Cholesky factor F, such that A ~= F @ F.T.
-
-    Notes:
-        Based on Algorithm 5.5 of Halko et al. 2011.
     """
-    small_matrix_1 = matrix @ qr_factor
-    small_matrix_2 = qr_factor.T @ small_matrix_1
-    factor, lower = cho_factor(small_matrix_2, overwrite_a=True)
-    identity_operator = np.identity(factor.shape[0])
-    inverse_factor = solve_triangular(
-        factor, identity_operator, overwrite_b=True, lower=lower
-    )
-    return small_matrix_1 @ inverse_factor
+    try:
+        # --- Fast Path: Try direct Cholesky factorization ---
+        small_matrix_1 = matrix @ qr_factor
+        small_matrix_2 = qr_factor.T @ small_matrix_1
+
+        factor, lower = cho_factor(small_matrix_2, overwrite_a=True)
+
+        identity_operator = np.identity(factor.shape[0])
+        inverse_factor = solve_triangular(
+            factor, identity_operator, overwrite_b=True, lower=lower
+        )
+        return small_matrix_1 @ inverse_factor
+
+    except np.linalg.LinAlgError:
+
+        # --- Fallback Path: Eigendecomposition ---
+        small_matrix = qr_factor.T @ (matrix @ qr_factor)
+        eigenvalues, eigenvectors = eigh(small_matrix, overwrite_a=True)
+
+        # Determine the threshold based on the largest eigenvalue.
+        # eigh returns eigenvalues in ascending order.
+        max_eigenvalue = eigenvalues[-1]
+
+        if max_eigenvalue > 0:
+            threshold = rtol * max_eigenvalue
+        else:
+            # If all eigenvalues are non-positive, all will be set to zero.
+            threshold = 0
+
+        # 2. Apply the threshold to create safe eigenvalues.
+        safe_eigenvalues = eigenvalues.copy()
+        safe_eigenvalues[eigenvalues < threshold] = 0.0
+
+        y_matrix = matrix @ qr_factor
+        temp_factor = y_matrix @ eigenvectors
+
+        # Conditionally compute the inverse square root.
+        sqrt_s = np.sqrt(safe_eigenvalues)
+        sqrt_s_inv = np.where(sqrt_s > 0, np.reciprocal(sqrt_s), 0.0)
+
+        cholesky_factor = temp_factor * sqrt_s_inv
+
+        return cholesky_factor

pygeoinf/symmetric_space/circle.py

@@ -24,7 +24,7 @@ Key Classes
 
 from __future__ import annotations
 
-from typing import Callable, Tuple, Optional
+from typing import Callable, Tuple, Optional, Any
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy.fft import rfft, irfft
@@ -38,7 +38,7 @@ from pygeoinf.hilbert_space import (
     HilbertModule,
     MassWeightedHilbertModule,
 )
-from pygeoinf.operators import LinearOperator
+from pygeoinf.linear_operators import LinearOperator
 from pygeoinf.linear_forms import LinearForm
 from .symmetric_space import (
     AbstractInvariantLebesgueSpace,
@@ -336,6 +336,16 @@ class Lebesgue(CircleHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
         return self.kmax == other.kmax and self.radius == other.radius
 
+    def is_element(self, u: Any) -> bool:
+        """
+        Checks if an object is a valid element of the space.
+        """
+        if not isinstance(u, np.ndarray):
+            return False
+        if not u.shape == (self.dim,):
+            return False
+        return True
+
     def invariant_automorphism_from_index_function(self, g: Callable[[int], float]):
         """
         Implements an invariant automorphism of the form f(Δ) using Fourier

pygeoinf/symmetric_space/sphere.py

@@ -38,7 +38,7 @@ from pygeoinf.hilbert_space import (
     HilbertModule,
     MassWeightedHilbertModule,
 )
-from pygeoinf.operators import LinearOperator
+from pygeoinf.linear_operators import LinearOperator
 from pygeoinf.linear_forms import LinearForm
 from .symmetric_space import (
     AbstractInvariantLebesgueSpace,
@@ -448,6 +448,20 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
         return self.lmax == other.lmax and self.radius == other.radius
 
+    def is_element(self, x: Any) -> bool:
+        """
+        Checks if an object is a valid element of the space.
+        """
+        if not isinstance(x, sh.SHGrid):
+            return False
+        if not x.lmax == self.lmax:
+            return False
+        if not x.grid == self._grid_name():
+            return False
+        if not x.extend == self.extend:
+            return False
+        return True
+
     def eigenfunction_norms(self) -> np.ndarray:
         """Returns a list of the norms of the eigenfunctions."""
         return np.fromiter(

pygeoinf/symmetric_space/symmetric_space.py

@@ -36,7 +36,7 @@ import numpy as np
 from scipy.sparse import diags
 
 from pygeoinf.hilbert_space import EuclideanSpace, HilbertSpace
-from pygeoinf.operators import LinearOperator
+from pygeoinf.linear_operators import LinearOperator
 from pygeoinf.linear_forms import LinearForm
 from pygeoinf.gaussian_measure import GaussianMeasure
 

{pygeoinf-1.2.0.dist-info → pygeoinf-1.2.2.dist-info}/METADATA

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

pygeoinf-1.2.2.dist-info/RECORD

@@ -0,0 +1,25 @@
+pygeoinf/__init__.py,sha256=LG49pW8RUK-NxO0KSEHNVG_tBClUK5GFLtjvNLDRnjE,1419
+pygeoinf/backus_gilbert.py,sha256=bXJ0JKh49elNKLm5cGJj_RBh0oXcH3hpR7U-QUFHj8M,3657
+pygeoinf/direct_sum.py,sha256=SuW4OJuMjGme5nNhYTzcrTyo957g0OvNCC3GpQue5Bc,19419
+pygeoinf/forward_problem.py,sha256=iQsTQ4CV4XAqWd48EzhA82NMySGJSQ0_PaEtfG40agw,10529
+pygeoinf/gaussian_measure.py,sha256=EOUyBYT-K9u2ZD_uwPXDv17BJHk-L0RM55jfIR-DmXY,24020
+pygeoinf/hilbert_space.py,sha256=StS2AoTnOFTrh3XRyZ6K9lhQDqJijDaJGMC8RRagoTQ,25247
+pygeoinf/inversion.py,sha256=3FiujTK4PDBPjS0aYdo02nHQjsVFL4GDqv4gvg2YilA,6189
+pygeoinf/linear_bayesian.py,sha256=L1cJkeHtba4fPXZ8CmiLRBtuG2fmzG228M_iEar-iP8,9643
+pygeoinf/linear_forms.py,sha256=sgynBvlQ35CaH12PKU2vWPHh9ikrmQbD5IASCUQtlbw,9197
+pygeoinf/linear_operators.py,sha256=ha6QHKHVBd_MLMNmk8zAoqm_yDM2dClb8C6p13jo7Ik,36333
+pygeoinf/linear_optimisation.py,sha256=sO155SkGg5H1RR-jmULru7R4vlCPjUce--6Z52l3Pks,11147
+pygeoinf/linear_solvers.py,sha256=fPcr4f2mhSK34cHdRXk9LsonQJ_gLhXQYwCYA4O6Jv4,15706
+pygeoinf/nonlinear_forms.py,sha256=eQudA-HfedbURvRmzVvU8HfNCxHTuWUpdDoWe_KlA4Y,7067
+pygeoinf/nonlinear_operators.py,sha256=1FvimPwMxt0h1qOvTTjGabm-2ctDO4bT71LLro-7t68,7069
+pygeoinf/nonlinear_optimisation.py,sha256=xcIJX6Uw6HuJ3OySGXm3cDQ-BVgIVi3jjtOpIHNq8ks,7074
+pygeoinf/parallel.py,sha256=VVFvNHszy4wSa9LuErIsch4NAkLaZezhdN9YpRROBJo,2267
+pygeoinf/random_matrix.py,sha256=afEUFuoVbkFobhC9Jy9SuGb4Yib-fn3pQyiWUqXrA-8,13629
+pygeoinf/symmetric_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygeoinf/symmetric_space/circle.py,sha256=7Bz9BfSkbDnoz5-HFwTsAQE4a09jUapBePwoCK0xYWw,18007
+pygeoinf/symmetric_space/sphere.py,sha256=poasBQEXV5WNSA9LBuCY2lsxv79aV90jKP13FSoQUmU,21950
+pygeoinf/symmetric_space/symmetric_space.py,sha256=Q3KtfCtHO0_8LjsdKtH-5WVhRQurt5Bdk4yx1D2F5YY,17977
+pygeoinf-1.2.2.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
+pygeoinf-1.2.2.dist-info/METADATA,sha256=avOFENnp8CogJepyHc0BfcyN7wq2PHtpXYCrE0KscQ0,15363
+pygeoinf-1.2.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pygeoinf-1.2.2.dist-info/RECORD,,