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

pygeoinf/direct_sum.py

@@ -25,10 +25,13 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import List, Any
 import numpy as np
+from scipy.linalg import block_diag
+from joblib import Parallel, delayed
 
 from .hilbert_space import HilbertSpace
 from .operators import LinearOperator
 from .linear_forms import LinearForm
+from .parallel import parallel_compute_dense_matrix_from_scipy_op
 
 
 class HilbertSpaceDirectSum(HilbertSpace):
@@ -300,6 +303,40 @@ class BlockLinearOperator(LinearOperator, BlockStructure):
         self._check_block_indices(i, j)
         return self._blocks[i][j]
 
+    def _compute_dense_matrix(
+        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)
+                for j in range(self.col_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)
+
     def __mapping(self, xs: List[Any]) -> List[Any]:
 
         ys = []
@@ -379,6 +416,28 @@ class ColumnLinearOperator(LinearOperator, BlockStructure):
             raise IndexError("Column index out of range for ColumnLinearOperator.")
         return self._operators[i]
 
+    def _compute_dense_matrix(
+        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)
+
 
 class RowLinearOperator(LinearOperator, BlockStructure):
     """
@@ -433,6 +492,28 @@ class RowLinearOperator(LinearOperator, BlockStructure):
             raise IndexError("Row index out of range for RowLinearOperator.")
         return self._operators[j]
 
+    def _compute_dense_matrix(
+        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)
+
 
 class BlockDiagonalLinearOperator(LinearOperator, BlockStructure):
     """
@@ -473,3 +554,25 @@ class BlockDiagonalLinearOperator(LinearOperator, BlockStructure):
             domain = self._operators[j].domain
             codomain = self._operators[i].codomain
             return domain.zero_operator(codomain)
+
+    def _compute_dense_matrix(
+        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)

pygeoinf/gaussian_measure.py

@@ -484,7 +484,9 @@ class GaussianMeasure:
             )
 
         return multivariate_normal(
-            mean=self.expectation, cov=self.covariance.matrix(dense=True)
+            mean=self.expectation,
+            cov=self.covariance.matrix(dense=True),
+            allow_singular=True,
         )
 
     def low_rank_approximation(

pygeoinf/linear_optimisation.py

@@ -51,7 +51,7 @@ class LinearLeastSquaresInversion(Inversion):
         if self.forward_problem.data_error_measure_set:
             self.assert_inverse_data_covariance()
 
-    def normal_operator(self, damping: float) -> "LinearOperator":
+    def normal_operator(self, damping: float) -> LinearOperator:
         """
         Returns the Tikhonov-regularized normal operator.
 
@@ -88,8 +88,8 @@ class LinearLeastSquaresInversion(Inversion):
         solver: "LinearSolver",
         /,
         *,
-        preconditioner: Optional["LinearOperator"] = None,
-    ) -> Union[Operator, "LinearOperator"]:
+        preconditioner: Optional[LinearOperator] = None,
+    ) -> Union[Operator, LinearOperator]:
         """
         Returns an operator that maps data to the least-squares solution.
 
@@ -121,7 +121,7 @@ class LinearLeastSquaresInversion(Inversion):
             )
 
             # This mapping is affine, not linear, if the error measure has a non-zero mean.
-            def mapping(data: "Vector") -> "Vector":
+            def mapping(data: Vector) -> Vector:
                 shifted_data = self.forward_problem.data_space.subtract(
                     data, self.forward_problem.data_error_measure.expectation
                 )
@@ -162,13 +162,13 @@ class LinearMinimumNormInversion(Inversion):
         solver: "LinearSolver",
         /,
         *,
-        preconditioner: Optional["LinearOperator"] = None,
+        preconditioner: Optional[LinearOperator] = None,
         significance_level: float = 0.95,
         minimum_damping: float = 0.0,
         maxiter: int = 100,
         rtol: float = 1.0e-6,
         atol: float = 0.0,
-    ) -> Union[Operator, "LinearOperator"]:
+    ) -> Union[Operator, LinearOperator]:
         """
         Returns an operator that maps data to the minimum-norm solution.
 
@@ -196,8 +196,8 @@ class LinearMinimumNormInversion(Inversion):
             lsq_inversion = LinearLeastSquaresInversion(self.forward_problem)
 
             def get_model_for_damping(
-                damping: float, data: "Vector", model0: Optional["Vector"] = None
-            ) -> tuple["Vector", float]:
+                damping: float, data: Vector, model0: Optional[Vector] = None
+            ) -> tuple[Vector, float]:
                 """Computes the LS model and its chi-squared for a given damping."""
                 op = lsq_inversion.least_squares_operator(
                     damping, solver, preconditioner=preconditioner
@@ -206,7 +206,7 @@ class LinearMinimumNormInversion(Inversion):
                 chi_squared = self.forward_problem.chi_squared(model, data)
                 return model, chi_squared
 
-            def mapping(data: "Vector") -> "Vector":
+            def mapping(data: Vector) -> Vector:
                 """The non-linear mapping from data to the minimum-norm model."""
                 model = self.model_space.zero
                 chi_squared = self.forward_problem.chi_squared(model, data)

pygeoinf/linear_solvers.py

@@ -48,6 +48,19 @@ class DirectLinearSolver(LinearSolver):
     factorization.
     """
 
+    def __init__(
+        self, /, *, galerkin: bool = False, parallel: bool = False, n_jobs: int = -1
+    ):
+        """
+        Args:
+            galerkin (bool): If True, the Galerkin matrix representation is used.
+            parallel (bool): If True, parallel computation is used.
+            n_jobs (int): Number of parallel jobs.
+        """
+        self._galerkin: bool = galerkin
+        self._parallel: bool = parallel
+        self._n_jobs: int = n_jobs
+
 
 class LUSolver(DirectLinearSolver):
     """
@@ -55,12 +68,16 @@ class LUSolver(DirectLinearSolver):
     dense matrix representation.
     """
 
-    def __init__(self, /, *, galerkin: bool = False) -> None:
+    def __init__(
+        self, /, *, galerkin: bool = False, parallel: bool = False, n_jobs: int = -1
+    ) -> None:
         """
         Args:
             galerkin (bool): If True, the Galerkin matrix representation is used.
+            parallel (bool): If True, parallel computation is used.
+            n_jobs (int): Number of parallel jobs.
         """
-        self._galerkin: bool = galerkin
+        super().__init__(galerkin=galerkin, parallel=parallel, n_jobs=n_jobs)
 
     def __call__(self, operator: LinearOperator) -> LinearOperator:
         """
@@ -74,7 +91,12 @@ class LUSolver(DirectLinearSolver):
         """
         assert operator.is_square
 
-        matrix = operator.matrix(dense=True, galerkin=self._galerkin)
+        matrix = operator.matrix(
+            dense=True,
+            galerkin=self._galerkin,
+            parallel=self._parallel,
+            n_jobs=self._n_jobs,
+        )
         factor = lu_factor(matrix, overwrite_a=True)
 
         def matvec(cy: np.ndarray) -> np.ndarray:
@@ -102,12 +124,16 @@ class CholeskySolver(DirectLinearSolver):
     representation is positive-definite.
     """
 
-    def __init__(self, /, *, galerkin: bool = False) -> None:
+    def __init__(
+        self, /, *, galerkin: bool = False, parallel: bool = False, n_jobs: int = -1
+    ) -> None:
         """
         Args:
             galerkin (bool): If True, the Galerkin matrix representation is used.
+            parallel (bool): If True, parallel computation is used.
+            n_jobs (int): Number of parallel jobs.
         """
-        self._galerkin: bool = galerkin
+        super().__init__(galerkin=galerkin, parallel=parallel, n_jobs=n_jobs)
 
     def __call__(self, operator: LinearOperator) -> LinearOperator:
         """
@@ -121,7 +147,12 @@ class CholeskySolver(DirectLinearSolver):
         """
         assert operator.is_automorphism
 
-        matrix = operator.matrix(dense=True, galerkin=self._galerkin)
+        matrix = operator.matrix(
+            dense=True,
+            galerkin=self._galerkin,
+            parallel=self._parallel,
+            n_jobs=self._n_jobs,
+        )
         factor = cho_factor(matrix, overwrite_a=False)
 
         def matvec(cy: np.ndarray) -> np.ndarray:
@@ -173,9 +204,7 @@ class IterativeLinearSolver(LinearSolver):
         Solves the adjoint linear system A*y = x for y.
         """
         adjoint_preconditioner = (
-            None
-            if preconditioner is None
-            else preconditioner.adjoint
+            None if preconditioner is None else preconditioner.adjoint
         )
         return self.solve_linear_system(operator.adjoint, adjoint_preconditioner, x, y0)
 

pygeoinf/operators.py

@@ -35,12 +35,36 @@ from .random_matrix import (
     random_eig as rm_eig,
 )
 
+from .parallel import parallel_compute_dense_matrix_from_scipy_op
+
 # This block only runs for type checkers, not at runtime
 if TYPE_CHECKING:
     from .hilbert_space import HilbertSpace, EuclideanSpace
     from .linear_forms import LinearForm
 
 
+def _parallel_scipy_op_col(scipy_op: ScipyLinOp, j: int, domain_dim: int) -> np.ndarray:
+    """
+    A top-level helper that applies a scipy.LinearOperator to a basis vector.
+
+    This function is simple and serializable ("picklable").
+
+    Args:
+        scipy_op: The SciPy LinearOperator wrapper for the matrix action.
+        j: The index of the basis vector (column) to compute.
+        domain_dim: The dimension of the domain space.
+
+    Returns:
+        The j-th column of the dense matrix as a NumPy array.
+    """
+    # Create the j-th component basis vector
+    cx = np.zeros(domain_dim)
+    cx[j] = 1.0
+
+    # Apply the SciPy wrapper, which handles all necessary conversions
+    return scipy_op @ cx
+
+
 class Operator:
     """
     A general, potentially non-linear operator between two Hilbert spaces.
@@ -489,7 +513,13 @@ class LinearOperator(Operator):
         return self._thread_safe
 
     def matrix(
-        self, /, *, dense: bool = False, galerkin: bool = False
+        self,
+        /,
+        *,
+        dense: bool = False,
+        galerkin: bool = False,
+        parallel: bool = False,
+        n_jobs: int = -1,
     ) -> Union[ScipyLinOp, np.ndarray]:
         """
         Returns a matrix representation of the operator.
@@ -529,12 +559,17 @@ class LinearOperator(Operator):
                     self-adjoint, its Galerkin matrix will be **symmetric**, which is a
                     prerequisite for algorithms like the Conjugate Gradient method.
 
+            parallel (bool): If True, use parallel computing. Defaults to False.
+                This is only relevant for dense matrices.
+            n_jobs (int): Number of parallel jobs. Defaults to -1.
+                This is only relevant for dense matrices.
+
         Returns:
             Union[ScipyLinOp, np.ndarray]: The matrix representation of the
                 operator, either as a dense array or a matrix-free object.
         """
         if dense:
-            return self._compute_dense_matrix(galerkin)
+            return self._compute_dense_matrix(galerkin, parallel, n_jobs)
         else:
             if galerkin:
 
@@ -597,9 +632,35 @@ class LinearOperator(Operator):
         galerkin: bool = False,
         rtol: float = 1e-3,
         method: str = "fixed",
+        parallel: bool = False,
+        n_jobs: int = -1,
     ) -> Tuple[LinearOperator, "DiagonalLinearOperator", LinearOperator]:
         """
         Computes an approximate SVD using a randomized algorithm.
+
+        Args:
+            rank (int): The desired rank of the SVD.
+            power (int): The power of the random matrix.
+            galerkin (bool): If True, use the Galerkin representation.
+            rtol (float): The relative tolerance for the SVD.
+            method (str): The method to use for the SVD.
+                - "fixed": Use a fixed rank SVD.
+                - "variable": Use a variable rank SVD.
+            parallel (bool): If True, use parallel computing. Defaults to False.
+                Only used with fixed rank method.
+            n_jobs (int): Number of parallel jobs. Defaults to -1.
+                Only used with fixed rank method.
+
+        Returns:
+            left (LinearOperator): The left singular vector matrix.
+            singular_values (DiagonalLinearOperator): The singular values.
+            right (LinearOperator): The right singular vector matrix.
+
+        Notes:
+            The right factor is in transposed form. This means the original
+            operator can be approximated as:
+                A = left @ singular_values @ right
+
         """
         from .hilbert_space import EuclideanSpace
 
@@ -610,7 +671,9 @@ class LinearOperator(Operator):
 
         qr_factor: np.ndarray
         if method == "fixed":
-            qr_factor = fixed_rank_random_range(matrix, rank, power=power)
+            qr_factor = fixed_rank_random_range(
+                matrix, rank, power=power, parallel=parallel, n_jobs=n_jobs
+            )
         elif method == "variable":
             qr_factor = variable_rank_random_range(matrix, rank, power=power, rtol=rtol)
         else:
@@ -648,10 +711,34 @@ class LinearOperator(Operator):
         power: int = 0,
         rtol: float = 1e-3,
         method: str = "fixed",
+        parallel: bool = False,
+        n_jobs: int = -1,
     ) -> Tuple[LinearOperator, "DiagonalLinearOperator"]:
         """
         Computes an approximate eigendecomposition for a self-adjoint
         operator using a randomized algorithm.
+
+        Args:
+            rank (int): The desired rank of the eigendecomposition.
+            power (int): The power of the random matrix.
+            rtol (float): The relative tolerance for the eigendecomposition.
+            method (str): The method to use for the eigendecomposition.
+                - "fixed": Use a fixed rank eigendecomposition.
+                - "variable": Use a variable rank eigendecomposition.
+            parallel (bool): If True, use parallel computing. Defaults to False.
+                Only used with fixed rank method.
+            n_jobs (int): Number of parallel jobs. Defaults to -1.
+                Only used with fixed rank method.
+
+        Returns:
+            expansion (LinearOperator): A linear operator that maps coefficients
+                in the eigen-basis to the resulting vector.
+            eigenvalues (DiagonalLinearOperator): The eigenvalues.
+
+        Notes:
+            The original operator can be approximated as:
+                A = expansion @ eigenvalues @ expansion.adjoint
+
         """
         from .hilbert_space import EuclideanSpace
 
@@ -663,7 +750,9 @@ class LinearOperator(Operator):
 
         qr_factor: np.ndarray
         if method == "fixed":
-            qr_factor = fixed_rank_random_range(matrix, rank, power=power)
+            qr_factor = fixed_rank_random_range(
+                matrix, rank, power=power, parallel=parallel, n_jobs=n_jobs
+            )
         elif method == "variable":
             qr_factor = variable_rank_random_range(matrix, rank, power=power, rtol=rtol)
         else:
@@ -687,11 +776,34 @@ class LinearOperator(Operator):
         power: int = 0,
         rtol: float = 1e-3,
         method: str = "fixed",
+        parallel: bool = False,
+        n_jobs: int = -1,
     ) -> LinearOperator:
         """
         Computes an approximate Cholesky decomposition for a positive-definite
         self-adjoint operator using a randomized algorithm.
+
+        Args:
+            rank (int): The desired rank of the Cholesky decomposition.
+            power (int): The power of the random matrix.
+            rtol (float): The relative tolerance for the Cholesky decomposition.
+            method (str): The method to use for the Cholesky decomposition.
+                - "fixed": Use a fixed rank Cholesky decomposition.
+                - "variable": Use a variable rank Cholesky decomposition.
+        parallel (bool): If True, use parallel computing. Defaults to False.
+            Only used with fixed rank method.
+        n_jobs (int): Number of parallel jobs. Defaults to -1.
+                Only used with fixed rank method.
+
+        Returns:
+            factor (LinearOperator): A linear operator from a Euclidean space
+                into the domain of the operator.
+
+        Notes:
+            The original operator can be approximated as:
+                A = factor @ factor.adjoint
         """
+
         from .hilbert_space import EuclideanSpace
 
         assert self.is_automorphism
@@ -702,7 +814,9 @@ class LinearOperator(Operator):
 
         qr_factor: np.ndarray
         if method == "fixed":
-            qr_factor = fixed_rank_random_range(matrix, rank, power=power)
+            qr_factor = fixed_rank_random_range(
+                matrix, rank, power=power, parallel=parallel, n_jobs=n_jobs
+            )
         elif method == "variable":
             qr_factor = variable_rank_random_range(matrix, rank, power=power, rtol=rtol)
         else:
@@ -732,15 +846,24 @@ class LinearOperator(Operator):
         xp = self.__dual_mapping(yp)
         return self.domain.from_dual(xp)
 
-    def _compute_dense_matrix(self, galerkin: bool = False) -> np.ndarray:
-        matrix = np.zeros((self.codomain.dim, self.domain.dim))
-        a = self.matrix(galerkin=galerkin)
-        cx = np.zeros(self.domain.dim)
-        for i in range(self.domain.dim):
-            cx[i] = 1.0
-            matrix[:, i] = (a @ cx)[:]
-            cx[i] = 0.0
-        return matrix
+    def _compute_dense_matrix(
+        self, galerkin: bool, parallel: bool, n_jobs: int
+    ) -> np.ndarray:
+
+        scipy_op_wrapper = self.matrix(galerkin=galerkin)
+
+        if not parallel:
+            matrix = np.zeros((self.codomain.dim, self.domain.dim))
+            cx = np.zeros(self.domain.dim)
+            for i in range(self.domain.dim):
+                cx[i] = 1.0
+                matrix[:, i] = (scipy_op_wrapper @ cx)[:]
+                cx[i] = 0.0
+            return matrix
+        else:
+            return parallel_compute_dense_matrix_from_scipy_op(
+                scipy_op_wrapper, n_jobs=n_jobs
+            )
 
     def __neg__(self) -> LinearOperator:
         domain = self.domain

pygeoinf/parallel.py

@@ -0,0 +1,73 @@
+"""
+A collection of helper functions for parallel computation using Joblib.
+
+These functions are designed to be top-level to ensure they can be
+"pickled" (serialized) and sent to worker processes by libraries like
+multiprocessing or its wrapper, Joblib.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Union
+import numpy as np
+from joblib import Parallel, delayed
+
+if TYPE_CHECKING:
+    from scipy.sparse.linalg import LinearOperator as ScipyLinOp
+
+    MatrixLike = Union[np.ndarray, ScipyLinOp]
+
+
+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.
+
+    This is particularly useful when A is a LinearOperator whose action is
+    computationally expensive.
+
+    Args:
+        A: The matrix or LinearOperator to apply.
+        B: The matrix whose columns will be operated on.
+        n_jobs: The number of CPU cores to use. -1 means all available.
+
+    Returns:
+        The result of the matrix product A @ B as a dense NumPy array.
+    """
+    columns = Parallel(n_jobs=n_jobs)(
+        delayed(A.__matmul__)(B[:, i]) for i in range(B.shape[1])
+    )
+    return np.column_stack(columns)
+
+
+def parallel_compute_dense_matrix_from_scipy_op(
+    scipy_op: "ScipyLinOp", n_jobs: int = -1
+) -> np.ndarray:
+    """
+    Computes the dense matrix representation of a scipy.LinearOperator in parallel.
+
+    It builds the matrix column by column by applying the operator to each
+    basis vector.
+
+    Args:
+        scipy_op: The SciPy LinearOperator wrapper for the matrix action.
+        n_jobs: The number of CPU cores to use. -1 means all available.
+
+    Returns:
+        The dense matrix as a NumPy array.
+    """
+    codomain_dim, domain_dim = scipy_op.shape
+    columns = Parallel(n_jobs=n_jobs)(
+        delayed(_worker_compute_scipy_op_col)(scipy_op, j, domain_dim)
+        for j in range(domain_dim)
+    )
+    return np.column_stack(columns)
+
+
+def _worker_compute_scipy_op_col(
+    scipy_op: "ScipyLinOp", j: int, domain_dim: int
+) -> np.ndarray:
+    """
+    (Internal worker) Computes a single column of a SciPy LinearOperator's matrix.
+    """
+    cx = np.zeros(domain_dim)
+    cx[j] = 1.0
+    return scipy_op @ cx

pygeoinf/random_matrix.py

@@ -25,13 +25,18 @@ from scipy.linalg import (
 )
 from scipy.sparse.linalg import LinearOperator as ScipyLinOp
 
+from .parallel import parallel_mat_mat
 
 # A type for objects that act like matrices (numpy arrays or SciPy LinearOperators)
 MatrixLike = Union[np.ndarray, ScipyLinOp]
 
 
 def fixed_rank_random_range(
-    matrix: MatrixLike, rank: int, power: int = 0
+    matrix: MatrixLike,
+    rank: int,
+    power: int = 0,
+    parallel: bool = False,
+    n_jobs: int = -1,
 ) -> np.ndarray:
     """
     Computes an orthonormal basis for a fixed-rank approximation of a matrix's range.
@@ -53,17 +58,29 @@ def fixed_rank_random_range(
     Notes:
         Based on Algorithm 4.4 in Halko et al. 2011.
     """
-
     m, n = matrix.shape
     random_matrix = np.random.randn(n, rank)
 
-    product_matrix = matrix @ random_matrix
+    if parallel:
+        product_matrix = parallel_mat_mat(matrix, random_matrix, n_jobs)
+    else:
+        product_matrix = matrix @ random_matrix
+
     qr_factor, _ = qr(product_matrix, overwrite_a=True, mode="economic")
 
     for _ in range(power):
-        tilde_product_matrix = matrix.T @ qr_factor
+        if parallel:
+            tilde_product_matrix = parallel_mat_mat(matrix.T, qr_factor, n_jobs)
+        else:
+            tilde_product_matrix = matrix.T @ qr_factor
+
         tilde_qr_factor, _ = qr(tilde_product_matrix, overwrite_a=True, mode="economic")
-        product_matrix = matrix @ tilde_qr_factor
+
+        if parallel:
+            product_matrix = parallel_mat_mat(matrix, tilde_qr_factor, n_jobs)
+        else:
+            product_matrix = matrix @ tilde_qr_factor
+
         qr_factor, _ = qr(product_matrix, overwrite_a=True, mode="economic")
 
     return qr_factor

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pygeoinf
-Version: 1.1.8
+Version: 1.2.0
 Summary: A package for solving geophysical inference and inverse problems
 License: BSD-3-Clause
 Author: David Al-Attar and Dan Heathcote
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Cartopy (>=0.23.0,<0.24.0)
+Requires-Dist: joblib (>=1.5.2,<2.0.0)
 Requires-Dist: matplotlib (>=3.0.0)
 Requires-Dist: numpy (>=1.26.0)
 Requires-Dist: pyqt6 (>=6.0.0)

{pygeoinf-1.1.8.dist-info → pygeoinf-1.2.0.dist-info}/RECORD

@@ -1,20 +1,21 @@
 pygeoinf/__init__.py,sha256=uYRwiHKi4nvzUBwQJxNdt8OZodFQ_nj5rUv2YkDXL9Q,1185
-pygeoinf/direct_sum.py,sha256=r0h-3bK6RQiOMoq086oupYaXgUM4pFIV8XNKOB2q9BE,17095
+pygeoinf/direct_sum.py,sha256=ppBWJLjwF1MPF3bL1tJf_ADt_jZw4tnxhiC1DUqPEew,20919
 pygeoinf/forward_problem.py,sha256=RnnVBMg8Ih7TqZylfSkQ7pdHEowEfCkTiXiKFrxBpnM,9754
-pygeoinf/gaussian_measure.py,sha256=SFnHmEjpcrUy09AfO3fXLLB_SaGwA9oc5PU630e3hNM,22826
+pygeoinf/gaussian_measure.py,sha256=X31D-NoBB5f7uagIRsAjTPqAJqcyTOpgUUvBnaWmiAw,22872
 pygeoinf/hilbert_space.py,sha256=90aaUPUBCqsEuXroOwCmvbRFhi1vf6F9bS4pU3DCseI,23369
 pygeoinf/inversion.py,sha256=p9k_iDVgJGLM1cGlT-0rgRwqdYVdsYC_euTXZk3kuOc,3199
 pygeoinf/linear_bayesian.py,sha256=aIOzTZbjJtdtwHKh5e01iS8iMiyr8XuwGx91udS3VK4,9624
 pygeoinf/linear_forms.py,sha256=Uizipi67i1Sd6m0TzsrJd99Xreo_6V8Db0gMy76fG6g,5953
-pygeoinf/linear_optimisation.py,sha256=7lklTRRBGkz8M9WsfvkDl-eoGkc4Ty7BOJq7LWkdxCg,11091
-pygeoinf/linear_solvers.py,sha256=zymKX9oZCkhxWbKxP4ZH8g-GDC5gf_rFhlx7viWZo4Q,12294
-pygeoinf/operators.py,sha256=kbDfHpaWaSnd0zvoAVMBpWWiQRNfW0ImVhtzEEIH6mM,33165
-pygeoinf/random_matrix.py,sha256=_XVwXqM_c0SMpy6JU-8IboXpotug6dDDHKdSPAJpH7c,7788
+pygeoinf/linear_optimisation.py,sha256=zWUMQpuLlEXtA3yJ55sT8809THbU_oQlLUwjroAbZbU,11067
+pygeoinf/linear_solvers.py,sha256=USeUPa0zZ7gXk5OnvEw1LzCxCZoQIKhdwZZn-KNU7jA,13371
+pygeoinf/operators.py,sha256=_t_UqYBIk4rWdRe98hre39sPaoRRbNejOtcvabtf0x8,38010
+pygeoinf/parallel.py,sha256=E148IAKiXojWe6sq3iYtHl1XGAW8w6xaYbI7LOM9oKc,2269
+pygeoinf/random_matrix.py,sha256=Q9jgQVpMOy8jR3s057DzHeKrKLdvwRktF-n_oVZ0xbs,8231
 pygeoinf/symmetric_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeoinf/symmetric_space/circle.py,sha256=eUZPIDwg19RTCK3-bvbARg1g9RQcnV462MTlDaI-l5Y,17716
 pygeoinf/symmetric_space/sphere.py,sha256=yjmES34jWLi4-EhU_RDILYn1y7_YrvgrTyT2qL2mLVg,21534
 pygeoinf/symmetric_space/symmetric_space.py,sha256=lEAshbb55qL0iX84H423Pt35Af89Iy2pfB18JCPheX8,17970
-pygeoinf-1.1.8.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
-pygeoinf-1.1.8.dist-info/METADATA,sha256=uW521FvGxfmGJLmkfLLOIL1XQfIhJVJfKaoJSznEV5I,15324
-pygeoinf-1.1.8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pygeoinf-1.1.8.dist-info/RECORD,,
+pygeoinf-1.2.0.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
+pygeoinf-1.2.0.dist-info/METADATA,sha256=Q9Wo26AZXTTmUy7Fc8AVyhqDlEME7gDQ2udkImPATGo,15363
+pygeoinf-1.2.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pygeoinf-1.2.0.dist-info/RECORD,,