pygeoinf 1.2.9__py3-none-any.whl → 1.3.1__py3-none-any.whl

pygeoinf/__init__.py

@@ -85,3 +85,70 @@ from .backus_gilbert import HyperEllipsoid
 from .nonlinear_optimisation import (
     ScipyUnconstrainedOptimiser,
 )
+
+
+__all__ = [
+    # random_matrix
+    "fixed_rank_random_range",
+    "variable_rank_random_range",
+    "random_range",
+    "random_svd",
+    "random_eig",
+    "random_cholesky",
+    "random_diagonal",
+    # hilbert_space
+    "HilbertSpace",
+    "DualHilbertSpace",
+    "EuclideanSpace",
+    "HilbertModule",
+    "MassWeightedHilbertSpace",
+    "MassWeightedHilbertModule",
+    # nonlinear_forms
+    "NonLinearForm",
+    # linear_forms
+    "LinearForm",
+    # nonlinear_operators
+    "NonLinearOperator",
+    # linear_operators
+    "LinearOperator",
+    "MatrixLinearOperator",
+    "DenseMatrixLinearOperator",
+    "SparseMatrixLinearOperator",
+    "DiagonalSparseMatrixLinearOperator",
+    "NormalSumOperator",
+    # gaussian_measure
+    "GaussianMeasure",
+    # direct_sum
+    "HilbertSpaceDirectSum",
+    "BlockStructure",
+    "BlockLinearOperator",
+    "ColumnLinearOperator",
+    "RowLinearOperator",
+    "BlockDiagonalLinearOperator",
+    # linear_solvers
+    "LinearSolver",
+    "DirectLinearSolver",
+    "LUSolver",
+    "CholeskySolver",
+    "EigenSolver",
+    "IterativeLinearSolver",
+    "ScipyIterativeSolver",
+    "CGMatrixSolver",
+    "BICGMatrixSolver",
+    "BICGStabMatrixSolver",
+    "GMRESMatrixSolver",
+    "CGSolver",
+    # forward_problem
+    "ForwardProblem",
+    "LinearForwardProblem",
+    # linear_optimisation
+    "LinearLeastSquaresInversion",
+    "LinearMinimumNormInversion",
+    # linear_bayesian
+    "LinearBayesianInversion",
+    "LinearBayesianInference",
+    # backus_gilbert
+    "HyperEllipsoid",
+    # nonlinear_optimisation
+    "ScipyUnconstrainedOptimiser",
+]

pygeoinf/backus_gilbert.py

@@ -8,8 +8,6 @@ from .hilbert_space import HilbertSpace, Vector
 from .linear_operators import LinearOperator
 from .nonlinear_forms import NonLinearForm
 
-from .forward_problem import LinearForwardProblem
-from .inversion import LinearInference
 
 
 class HyperEllipsoid:

pygeoinf/checks/hilbert_space.py

@@ -46,6 +46,23 @@ class HilbertSpaceAxiomChecks:
         if not norm_sum <= self.norm(x) + self.norm(y):
             raise AssertionError("Axiom failed: Triangle inequality")
 
+    def _check_riesz_representation(self, x, y):
+        """
+        Checks that the inner product is consistent with the Riesz map (to_dual).
+        This ensures that <x, y> == (R(x))(y).
+        """
+        # Value from the (potentially optimized) direct inner product method
+        direct_inner_product = self.inner_product(x, y)
+
+        # Value from the Riesz map definition
+        dual_x = self.to_dual(x)
+        riesz_inner_product = self.duality_product(dual_x, y)
+
+        if not np.isclose(direct_inner_product, riesz_inner_product):
+            raise AssertionError(
+                "Axiom failed: Inner product is not consistent with the Riesz map."
+            )
+
     def _check_mapping_identities(self, x):
         """Checks that component and dual mappings are self-consistent."""
         # from_components(to_components(x)) == x
@@ -176,6 +193,7 @@ class HilbertSpaceAxiomChecks:
             # Run all checks
             self._check_vector_space_axioms(x, y, a)
             self._check_inner_product_axioms(x, y, z, a, b)
+            # self._check_riesz_representation(x, y)
             self._check_mapping_identities(x)
             self._check_inplace_operations(x, y, a)
             self._check_copy(x)

pygeoinf/checks/nonlinear_operators.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 import numpy as np
 
 if TYPE_CHECKING:
-    from ..linear_operators import LinearOperator
+    pass
 
 
 class NonLinearOperatorAxiomChecks:

pygeoinf/direct_sum.py

@@ -26,12 +26,10 @@ 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 .linear_operators import LinearOperator
 from .linear_forms import LinearForm
-from .parallel import parallel_compute_dense_matrix_from_scipy_op
 
 
 class HilbertSpaceDirectSum(HilbertSpace):

pygeoinf/gaussian_measure.py

@@ -20,7 +20,8 @@ Key Features
 """
 
 from __future__ import annotations
-from typing import Callable, Optional, Any, List, TypeVar, TYPE_CHECKING
+from typing import Callable, Optional, Any, List, TYPE_CHECKING
+import warnings
 
 import numpy as np
 from scipy.linalg import eigh
@@ -40,6 +41,12 @@ from .direct_sum import (
 )
 
 
+# This block is only processed by type checkers, not at runtime.
+if TYPE_CHECKING:
+    from .hilbert_space import HilbertSpace
+    from .typing import Vector
+
+
 class GaussianMeasure:
     """
     Represents a Gaussian measure on a Hilbert space.
@@ -191,6 +198,7 @@ class GaussianMeasure:
         /,
         *,
         expectation: Vector = None,
+        rtol: float = 1e-10,
     ) -> GaussianMeasure:
         """
         Creates a Gaussian measure from a dense covariance matrix.
@@ -199,15 +207,36 @@ class GaussianMeasure:
         the covariance operator. This method computes a Cholesky-like
         decomposition of the matrix to create a `covariance_factor`.
 
+        It includes a check to handle numerical precision issues, allowing for
+        eigenvalues that are slightly negative within a relative tolerance.
+
         Args:
             domain: The Hilbert space the measure is defined on.
             covariance_matrix: The dense covariance matrix.
             expectation: The expectation (mean) of the measure.
+            rtol: The relative tolerance used to check for negative eigenvalues.
         """
 
         eigenvalues, U = eigh(covariance_matrix)
-        if any(val < 0 for val in eigenvalues):
-            raise ValueError("Covariance matrix is not non-negative")
+
+        if np.any(eigenvalues < 0):
+            max_eig = np.max(np.abs(eigenvalues))
+            min_eig = np.min(eigenvalues)
+
+            # Check if the most negative eigenvalue is outside the tolerance
+            if min_eig < -rtol * max_eig:
+                raise ValueError(
+                    "Covariance matrix has significantly negative eigenvalues, "
+                    "indicating it is not positive semi-definite."
+                )
+            else:
+                # If negative eigenvalues are within tolerance, warn and correct
+                warnings.warn(
+                    "Covariance matrix has small negative eigenvalues due to "
+                    "numerical error. Clipping them to zero.",
+                    UserWarning,
+                )
+                eigenvalues[eigenvalues < 0] = 0
 
         values = np.sqrt(eigenvalues)
         D = diags([values], [0])
@@ -460,24 +489,57 @@ class GaussianMeasure:
                 sample=new_sample if self.sample_set else None,
             )
 
-    def as_multivariate_normal(self) -> multivariate_normal:
+    def as_multivariate_normal(
+        self, /, *, parallel: bool = False, n_jobs: int = -1
+    ) -> multivariate_normal:
         """
         Returns the measure as a `scipy.stats.multivariate_normal` object.
 
         This is only possible if the measure is defined on a EuclideanSpace.
-        """
 
+        If the covariance matrix has small negative eigenvalues due to numerical
+        precision issues, this method attempts to correct them by setting them
+        to zero.
+
+        Args:
+            parallel (bool, optional): If `True`, computes the dense covariance
+                matrix in parallel. Defaults to `False`.
+            n_jobs (int, optional): The number of parallel jobs to use. `-1`
+                uses all available cores. Defaults to -1.
+        """
         if not isinstance(self.domain, EuclideanSpace):
             raise NotImplementedError(
                 "Method only defined for measures on Euclidean space."
             )
 
-        return multivariate_normal(
-            mean=self.expectation,
-            cov=self.covariance.matrix(dense=True),
-            allow_singular=True,
+        mean_vector = self.expectation
+
+        # Pass the parallelization arguments directly to the matrix creation method
+        cov_matrix = self.covariance.matrix(
+            dense=True, parallel=parallel, n_jobs=n_jobs
         )
 
+        try:
+            # First, try to create the distribution directly.
+            return multivariate_normal(
+                mean=mean_vector, cov=cov_matrix, allow_singular=True
+            )
+        except ValueError:
+            # If it fails, clean the covariance matrix and try again.
+            warnings.warn(
+                "Covariance matrix is not positive semi-definite due to "
+                "numerical errors. Setting negative eigenvalues to zero.",
+                UserWarning,
+            )
+
+            eigenvalues, eigenvectors = eigh(cov_matrix)
+            eigenvalues[eigenvalues < 0] = 0
+            cleaned_cov = eigenvectors @ diags(eigenvalues) @ eigenvectors.T
+
+            return multivariate_normal(
+                mean=mean_vector, cov=cleaned_cov, allow_singular=True
+            )
+
     def low_rank_approximation(
         self,
         size_estimate: int,

pygeoinf/hilbert_space.py

@@ -166,6 +166,22 @@ class HilbertSpace(ABC, HilbertSpaceAxiomChecks):
         """
         return isinstance(x, type(self.zero))
 
+    def inner_product(self, x1: Vector, x2: Vector) -> float:
+        """
+        Computes the inner product of two vectors, `(x1, x2)`.
+
+        This is defined via the duality product as `<R(x1), x2>`, where `R` is
+        the Riesz map (`to_dual`).
+
+        Args:
+            x1: The first vector.
+            x2: The second vector.
+
+        Returns:
+            The inner product as a float.
+        """
+        return self.duality_product(self.to_dual(x1), x2)
+
     def duality_product(self, xp: LinearForm, x: Vector) -> float:
         """
         Computes the duality product <xp, x>.
@@ -293,23 +309,6 @@ class HilbertSpace(ABC, HilbertSpaceAxiomChecks):
 
         return LinearOperator.self_dual(self, self.to_dual)
 
-    @final
-    def inner_product(self, x1: Vector, x2: Vector) -> float:
-        """
-        Computes the inner product of two vectors, `(x1, x2)`.
-
-        This is defined via the duality product as `<R(x1), x2>`, where `R` is
-        the Riesz map (`to_dual`).
-
-        Args:
-            x1: The first vector.
-            x2: The second vector.
-
-        Returns:
-            The inner product as a float.
-        """
-        return self.duality_product(self.to_dual(x1), x2)
-
     @final
     def squared_norm(self, x: Vector) -> float:
         """
@@ -588,6 +587,15 @@ class EuclideanSpace(HilbertSpace):
         """Maps a `LinearForm` back to a vector via its components."""
         return self.dual.to_components(xp)
 
+    def inner_product(self, x1: np.ndarray, x2: np.ndarray) -> float:
+        """
+        Computes the inner product of two vectors.
+
+        Notes:
+            Default implementation overrident for efficiency.
+        """
+        return np.dot(x1, x2)
+
     def __eq__(self, other: object):
         if not isinstance(other, EuclideanSpace):
             return NotImplemented
@@ -597,7 +605,7 @@ class EuclideanSpace(HilbertSpace):
         """
         Checks if an object is a valid element of the space.
         """
-        return isinstance(x, np.ndarray) and len(x) == self.dim
+        return isinstance(x, np.ndarray) and x.shape == (self.dim,)
 
 
 class MassWeightedHilbertSpace(HilbertSpace):
@@ -678,6 +686,15 @@ class MassWeightedHilbertSpace(HilbertSpace):
         x = self.underlying_space.from_dual(xp)
         return self._inverse_mass_operator(x)
 
+    def inner_product(self, x1: Vector, x2: Vector) -> float:
+        """
+        Computes the inner product of two vectors.
+
+        Notes:
+            Default implementation overrident for efficiency.
+        """
+        return self._underlying_space.inner_product(self._mass_operator(x1), x2)
+
     def __eq__(self, other: object) -> bool:
         """
         Checks for equality with another MassWeightedHilbertSpace.

pygeoinf/linear_forms.py

@@ -18,7 +18,7 @@ from .nonlinear_forms import NonLinearForm
 
 # This block only runs for type checkers, not at runtime
 if TYPE_CHECKING:
-    from .hilbert_space import HilbertSpace, EuclideanSpace, Vector
+    from .hilbert_space import HilbertSpace, Vector
     from .linear_operators import LinearOperator
 
 

pygeoinf/linear_operators.py

@@ -25,7 +25,6 @@ from collections import defaultdict
 import numpy as np
 import scipy.sparse as sp
 from scipy.sparse.linalg import LinearOperator as ScipyLinOp
-from scipy.sparse import diags
 
 
 from joblib import Parallel, delayed
@@ -46,7 +45,7 @@ from .checks.linear_operators import LinearOperatorAxiomChecks
 
 # This block only runs for type checkers, not at runtime
 if TYPE_CHECKING:
-    from .hilbert_space import HilbertSpace, EuclideanSpace
+    from .hilbert_space import HilbertSpace
     from .linear_forms import LinearForm
 
 

pygeoinf/nonlinear_forms.py

@@ -16,7 +16,6 @@ if TYPE_CHECKING:
     from .hilbert_space import HilbertSpace, Vector
     from .linear_forms import LinearForm
     from .linear_operators import LinearOperator
-    from .nonlinear_operators import NonLinearOperator
 
 
 class NonLinearForm:

pygeoinf/nonlinear_operators.py

@@ -8,7 +8,7 @@ algebraic operations and an interface for the Frécher derivative.
 """
 
 from __future__ import annotations
-from typing import Callable, Optional, Any, TYPE_CHECKING
+from typing import Callable, Any, TYPE_CHECKING
 
 
 from .checks.nonlinear_operators import NonLinearOperatorAxiomChecks
@@ -16,7 +16,7 @@ from .checks.nonlinear_operators import NonLinearOperatorAxiomChecks
 
 # This block only runs for type checkers, not at runtime
 if TYPE_CHECKING:
-    from .hilbert_space import HilbertSpace, EuclideanSpace, Vector
+    from .hilbert_space import HilbertSpace, Vector
     from .linear_operators import LinearOperator
 
 

pygeoinf/plot.py

@@ -0,0 +1,350 @@
+import matplotlib.pyplot as plt
+import matplotlib.colors as colors
+import numpy as np
+import scipy.stats as stats
+from typing import Union, List, Optional
+
+def plot_1d_distributions(
+    posterior_measures: Union[object, List[object]],
+    prior_measures: Optional[Union[object, List[object]]] = None,
+    true_value: Optional[float] = None,
+    xlabel: str = "Property Value",
+    title: str = "Prior and Posterior Probability Distributions",
+    figsize: tuple = (12, 7),
+    show_plot: bool = True
+):
+    """
+    Plot 1D probability distributions for prior and posterior measures using dual y-axes.
+    
+    Args:
+        posterior_measures: Single measure or list of measures for posterior distributions
+        prior_measures: Single measure or list of measures for prior distributions (optional)
+        true_value: True value to mark with a vertical line (optional)
+        xlabel: Label for x-axis
+        title: Title for the plot
+        figsize: Figure size tuple
+        show_plot: Whether to display the plot
+        
+    Returns:
+        fig, (ax1, ax2): Figure and axes objects
+    """
+    
+    # Convert single measures to lists for uniform handling
+    if not isinstance(posterior_measures, list):
+        posterior_measures = [posterior_measures]
+    
+    if prior_measures is not None and not isinstance(prior_measures, list):
+        prior_measures = [prior_measures]
+    
+    # Define color sequences
+    prior_colors = ['green', 'orange', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan']
+    posterior_colors = ['blue', 'red', 'darkgreen', 'orange', 'purple', 'brown', 'pink', 'gray']
+    
+    # Calculate statistics for all distributions
+    posterior_stats = []
+    for measure in posterior_measures:
+        if hasattr(measure, 'expectation') and hasattr(measure, 'covariance'):
+            # For pygeoinf measures
+            mean = measure.expectation[0]
+            var = measure.covariance.matrix(dense=True)[0, 0]
+            std = np.sqrt(var)
+        else:
+            # For scipy distributions
+            mean = measure.mean[0]
+            std = np.sqrt(measure.cov[0, 0])
+        posterior_stats.append((mean, std))
+    
+    prior_stats = []
+    if prior_measures is not None:
+        for measure in prior_measures:
+            if hasattr(measure, 'expectation') and hasattr(measure, 'covariance'):
+                # For pygeoinf measures
+                mean = measure.expectation[0]
+                var = measure.covariance.matrix(dense=True)[0, 0]
+                std = np.sqrt(var)
+            else:
+                # For scipy distributions
+                mean = measure.mean[0]
+                std = np.sqrt(measure.cov[0, 0])
+            prior_stats.append((mean, std))
+    
+    # Determine plot range to include all distributions
+    all_means = [stat[0] for stat in posterior_stats]
+    all_stds = [stat[1] for stat in posterior_stats]
+    
+    if prior_measures is not None:
+        all_means.extend([stat[0] for stat in prior_stats])
+        all_stds.extend([stat[1] for stat in prior_stats])
+    
+    if true_value is not None:
+        all_means.append(true_value)
+        all_stds.append(0)  # No std for true value
+    
+    # Calculate x-axis range (6 sigma coverage)
+    x_min = min([mean - 6 * std for mean, std in zip(all_means, all_stds) if std > 0])
+    x_max = max([mean + 6 * std for mean, std in zip(all_means, all_stds) if std > 0])
+    
+    # Add some padding around true value if needed
+    if true_value is not None:
+        range_size = x_max - x_min
+        x_min = min(x_min, true_value - 0.1 * range_size)
+        x_max = max(x_max, true_value + 0.1 * range_size)
+    
+    x_axis = np.linspace(x_min, x_max, 1000)
+    
+    # Create the plot with two y-axes
+    fig, ax1 = plt.subplots(figsize=figsize)
+    
+    # Plot priors on the first axis (left y-axis) if provided
+    if prior_measures is not None:
+        color1 = prior_colors[0] if len(prior_measures) > 0 else 'green'
+        ax1.set_xlabel(xlabel)
+        ax1.set_ylabel('Prior Probability Density', color=color1)
+        
+        for i, (measure, (mean, std)) in enumerate(zip(prior_measures, prior_stats)):
+            color = prior_colors[i % len(prior_colors)]
+            
+            # Calculate PDF values using scipy.stats
+            pdf_values = stats.norm.pdf(x_axis, loc=mean, scale=std)
+            
+            # Determine label
+            if len(prior_measures) == 1:
+                label = f'Prior PDF (Mean: {mean:.5f})'
+            else:
+                label = f'Prior {i+1} (Mean: {mean:.5f})'
+            
+            ax1.plot(x_axis, pdf_values, color=color, lw=2, linestyle=':', label=label)
+            ax1.fill_between(x_axis, pdf_values, color=color, alpha=0.15)
+        
+        ax1.tick_params(axis='y', labelcolor=color1)
+        ax1.grid(True, linestyle='--')
+    else:
+        # If no priors, use the left axis for posteriors
+        ax1.set_xlabel(xlabel)
+        ax1.set_ylabel('Probability Density')
+        ax1.grid(True, linestyle='--')
+    
+    # Create second y-axis for posteriors (or use first if no priors)
+    if prior_measures is not None:
+        ax2 = ax1.twinx()
+        color2 = posterior_colors[0] if len(posterior_measures) > 0 else 'blue'
+        ax2.set_ylabel('Posterior Probability Density', color=color2)
+        ax2.tick_params(axis='y', labelcolor=color2)
+        ax2.grid(False)
+        plot_ax = ax2
+    else:
+        plot_ax = ax1
+        color2 = posterior_colors[0] if len(posterior_measures) > 0 else 'blue'
+    
+    # Plot posteriors
+    for i, (measure, (mean, std)) in enumerate(zip(posterior_measures, posterior_stats)):
+        color = posterior_colors[i % len(posterior_colors)]
+        
+        # Calculate PDF values using scipy.stats
+        pdf_values = stats.norm.pdf(x_axis, loc=mean, scale=std)
+        
+        # Determine label
+        if len(posterior_measures) == 1:
+            label = f'Posterior PDF (Mean: {mean:.5f})'
+        else:
+            label = f'Posterior {i+1} (Mean: {mean:.5f})'
+        
+        plot_ax.plot(x_axis, pdf_values, color=color, lw=2, label=label)
+        plot_ax.fill_between(x_axis, pdf_values, color=color, alpha=0.2)
+    
+    # Plot true value if provided
+    if true_value is not None:
+        ax1.axvline(true_value, color='black', linestyle='-', lw=2, 
+                   label=f'True Value: {true_value:.5f}')
+    
+    # Create combined legend
+    handles1, labels1 = ax1.get_legend_handles_labels()
+    
+    if prior_measures is not None:
+        handles2, labels2 = ax2.get_legend_handles_labels()
+        all_handles = handles1 + handles2
+        all_labels = [h.get_label() for h in all_handles]
+    else:
+        all_handles = handles1
+        all_labels = [h.get_label() for h in all_handles]
+    
+    fig.legend(all_handles, all_labels, loc='upper right', bbox_to_anchor=(0.9, 0.9))
+    fig.suptitle(title, fontsize=16)
+    fig.tight_layout(rect=[0, 0, 1, 0.96])
+    
+    if show_plot:
+        plt.show()
+    
+    if prior_measures is not None:
+        return fig, (ax1, ax2)
+    else:
+        return fig, ax1
+
+
+def plot_corner_distributions(
+    posterior_measure: object,
+    true_values: Optional[Union[List[float], np.ndarray]] = None,
+    labels: Optional[List[str]] = None,
+    title: str = "Joint Posterior Distribution",
+    figsize: Optional[tuple] = None,
+    show_plot: bool = True,
+    include_sigma_contours: bool = True,
+    colormap: str = "Blues"
+):
+    """
+    Create a corner plot for multi-dimensional posterior distributions.
+    
+    Args:
+        posterior_measure: Multi-dimensional posterior measure (pygeoinf object)
+        true_values: True values for each dimension (optional)
+        labels: Labels for each dimension (optional)
+        title: Title for the plot
+        figsize: Figure size tuple (if None, calculated based on dimensions)
+        show_plot: Whether to display the plot
+        include_sigma_contours: Whether to include 1-sigma contour lines
+        colormap: Colormap for 2D plots
+        
+    Returns:
+        fig, axes: Figure and axes array
+    """
+    
+    # Extract statistics from the measure
+    if hasattr(posterior_measure, 'expectation') and hasattr(posterior_measure, 'covariance'):
+        mean_posterior = posterior_measure.expectation
+        cov_posterior = posterior_measure.covariance.matrix(dense=True, parallel=True)
+    else:
+        raise ValueError("posterior_measure must have 'expectation' and 'covariance' attributes")
+    
+    n_dims = len(mean_posterior)
+    
+    # Set default labels if not provided
+    if labels is None:
+        labels = [f"Dimension {i+1}" for i in range(n_dims)]
+    
+    # Set figure size based on dimensions if not provided
+    if figsize is None:
+        figsize = (3 * n_dims, 3 * n_dims)
+    
+    # Create subplots
+    fig, axes = plt.subplots(n_dims, n_dims, figsize=figsize)
+    fig.suptitle(title, fontsize=16)
+    
+    # Ensure axes is always 2D array
+    if n_dims == 1:
+        axes = np.array([[axes]])
+    elif n_dims == 2:
+        axes = axes.reshape(2, 2)
+    
+    # Initialize pcm variable for colorbar
+    pcm = None
+    
+    for i in range(n_dims):
+        for j in range(n_dims):
+            ax = axes[i, j]
+            
+            if i == j:  # Diagonal plots (1D marginal distributions)
+                mu = mean_posterior[i]
+                sigma = np.sqrt(cov_posterior[i, i])
+                
+                # Create x-axis range
+                x = np.linspace(mu - 4 * sigma, mu + 4 * sigma, 200)
+                pdf = stats.norm.pdf(x, mu, sigma)
+                
+                # Plot the PDF
+                ax.plot(x, pdf, "darkblue", label="Posterior PDF")
+                ax.fill_between(x, pdf, color="lightblue", alpha=0.6)
+                
+                # Add true value if provided
+                if true_values is not None:
+                    true_val = true_values[i]
+                    ax.axvline(true_val, color="black", linestyle="-", 
+                              label=f"True: {true_val:.2f}")
+                
+                ax.set_xlabel(labels[i])
+                ax.set_ylabel("Density" if i == 0 else "")
+                ax.set_yticklabels([])
+            
+            elif i > j:  # Lower triangle: 2D joint distributions
+                # Extract 2D mean and covariance
+                mean_2d = np.array([mean_posterior[j], mean_posterior[i]])
+                cov_2d = np.array([
+                    [cov_posterior[j, j], cov_posterior[j, i]],
+                    [cov_posterior[i, j], cov_posterior[i, i]]
+                ])
+                
+                # Create 2D grid
+                sigma_j = np.sqrt(cov_posterior[j, j])
+                sigma_i = np.sqrt(cov_posterior[i, i])
+                
+                x_range = np.linspace(mean_2d[0] - 3.5 * sigma_j, 
+                                    mean_2d[0] + 3.5 * sigma_j, 100)
+                y_range = np.linspace(mean_2d[1] - 3.5 * sigma_i, 
+                                    mean_2d[1] + 3.5 * sigma_i, 100)
+                
+                X, Y = np.meshgrid(x_range, y_range)
+                pos = np.dstack((X, Y))
+                
+                # Calculate PDF values
+                rv = stats.multivariate_normal(mean_2d, cov_2d)
+                Z = rv.pdf(pos)
+                
+                # Create filled contour plot using pcolormesh like the original
+                pcm = ax.pcolormesh(
+                    X, Y, Z, shading="auto", cmap=colormap,
+                    norm=colors.LogNorm(vmin=Z.min(), vmax=Z.max())
+                )
+                
+                # Add contour lines
+                ax.contour(X, Y, Z, colors="black", linewidths=0.5, alpha=0.6)
+                
+                # Add 1-sigma contour if requested
+                if include_sigma_contours:
+                    # Calculate 1-sigma level (approximately 39% of peak for 2D Gaussian)
+                    sigma_level = rv.pdf(mean_2d) * np.exp(-0.5)
+                    ax.contour(X, Y, Z, levels=[sigma_level], colors="red", 
+                              linewidths=1, linestyles="--", alpha=0.8)
+                
+                # Plot mean point
+                ax.plot(mean_posterior[j], mean_posterior[i], "r+", 
+                       markersize=10, mew=2, label="Posterior Mean")
+                
+                # Plot true value if provided
+                if true_values is not None:
+                    ax.plot(true_values[j], true_values[i], "kx", 
+                           markersize=10, mew=2, label="True Value")
+                
+                ax.set_xlabel(labels[j])
+                ax.set_ylabel(labels[i])
+            
+            else:  # Upper triangle: hide these plots
+                ax.axis("off")
+    
+    # Create legend similar to the original
+    handles, labels_leg = axes[0, 0].get_legend_handles_labels()
+    if n_dims > 1:
+        handles2, labels2 = axes[1, 0].get_legend_handles_labels()
+        handles.extend(handles2)
+        labels_leg.extend(labels2)
+    
+    # Clean up labels by removing values after colons
+    cleaned_labels = [label.split(":")[0] for label in labels_leg]
+    
+    fig.legend(
+        handles, cleaned_labels,
+        loc="upper right", 
+        bbox_to_anchor=(0.9, 0.95)
+    )
+    
+    # Adjust main plot layout to make room on the right for the colorbar
+    plt.tight_layout(rect=[0, 0, 0.88, 0.96])
+    
+    # Add a colorbar if we have 2D plots
+    if n_dims > 1 and pcm is not None:
+        cbar_ax = fig.add_axes([0.9, 0.15, 0.03, 0.7])
+        cbar = fig.colorbar(pcm, cax=cbar_ax)
+        cbar.set_label("Probability Density", size=12)
+    
+    if show_plot:
+        plt.show()
+    
+    return fig, axes

pygeoinf/symmetric_space/circle.py

@@ -158,11 +158,11 @@ class CircleHelper:
         """
         return np.fromiter((f(theta) for theta in self.angles()), float)
 
-    def to_coefficient(self, u: np.ndarray) -> np.ndarray:
+    def to_coefficients(self, u: np.ndarray) -> np.ndarray:
         """Maps a function vector to its complex Fourier coefficients."""
         return rfft(u) * self.fft_factor
 
-    def from_coefficient(self, coeff: np.ndarray) -> np.ndarray:
+    def from_coefficients(self, coeff: np.ndarray) -> np.ndarray:
         """Maps complex Fourier coefficients to a function vector."""
         return irfft(coeff, n=2 * self.kmax) * self._inverse_fft_factor
 
@@ -235,7 +235,7 @@ class CircleHelper:
         # a minimal, non-redundant representation.
         return np.concatenate((coeff.real, coeff.imag[1 : self.kmax]))
 
-    def _component_to_coefficient(self, c: np.ndarray) -> np.ndarray:
+    def _component_to_coefficients(self, c: np.ndarray) -> np.ndarray:
         """Unpacks a real component vector into complex Fourier coefficients."""
         # This is the inverse of `_coefficient_to_component`. It reconstructs
         # the full complex coefficient array that irfft expects. We re-insert
@@ -290,26 +290,26 @@ class Lebesgue(CircleHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
     def to_components(self, u: np.ndarray) -> np.ndarray:
         """Converts a function vector to its real component representation."""
-        coeff = self.to_coefficient(u)
+        coeff = self.to_coefficients(u)
         return self._coefficient_to_component(coeff)
 
     def from_components(self, c: np.ndarray) -> np.ndarray:
         """Converts a real component vector back to a function vector."""
-        coeff = self._component_to_coefficient(c)
-        return self.from_coefficient(coeff)
+        coeff = self._component_to_coefficients(c)
+        return self.from_coefficients(coeff)
 
     def to_dual(self, u: np.ndarray) -> "LinearForm":
         """Maps a vector `u` to its dual representation `u*`."""
-        coeff = self.to_coefficient(u)
+        coeff = self.to_coefficients(u)
         cp = self._coefficient_to_component(self._metric @ coeff)
         return self.dual.from_components(cp)
 
     def from_dual(self, up: "LinearForm") -> np.ndarray:
         """Maps a dual vector `u*` back to its primal representation `u`."""
         cp = self.dual.to_components(up)
-        dual_coeff = self._component_to_coefficient(cp)
+        dual_coeff = self._component_to_coefficients(cp)
         primal_coeff = self._inverse_metric @ dual_coeff
-        return self.from_coefficient(primal_coeff)
+        return self.from_coefficients(primal_coeff)
 
     def vector_multiply(self, x1: np.ndarray, x2: np.ndarray) -> np.ndarray:
         """
@@ -366,9 +366,9 @@ class Lebesgue(CircleHelper, HilbertModule, AbstractInvariantLebesgueSpace):
         matrix = diags([values], [0])
 
         def mapping(u):
-            coeff = self.to_coefficient(u)
+            coeff = self.to_coefficients(u)
             coeff = matrix @ coeff
-            return self.from_coefficient(coeff)
+            return self.from_coefficients(coeff)
 
         return LinearOperator.self_adjoint(self, mapping)
 
@@ -468,6 +468,31 @@ class Sobolev(
 
         return Sobolev(k, order, scale, radius=radius)
 
+    @property
+    def derivative_operator(self) -> LinearOperator:
+        """
+        Returns the derivative operator from the space to one with a lower order.
+        """
+
+        codomain = Sobolev(self.kmax, self.order - 1, self.scale, radius=self.radius)
+
+        lebesgue_space = self.underlying_space
+        k = np.arange(self.kmax + 1)
+
+        def mapping(u):
+            coeff = lebesgue_space.to_coefficients(u)
+            diff_coeff = 1j * k * coeff
+            return lebesgue_space.from_coefficients(diff_coeff)
+
+        op_L2 = LinearOperator(
+            lebesgue_space,
+            lebesgue_space,
+            mapping,
+            adjoint_mapping=lambda u: -1 * mapping(u),
+        )
+
+        return LinearOperator.from_formal_adjoint(self, codomain, op_L2)
+
     def __eq__(self, other: object) -> bool:
         """
         Checks for mathematical equality with another Sobolev space on a circle.

pygeoinf/symmetric_space/sphere.py

@@ -208,11 +208,11 @@ class SphereHelper:
 
         return u
 
-    def to_coefficient(self, u: sh.SHGrid) -> sh.SHCoeffs:
+    def to_coefficients(self, u: sh.SHGrid) -> sh.SHCoeffs:
         """Maps a function vector to its spherical harmonic coefficients."""
         return u.expand(normalization=self.normalization, csphase=self.csphase)
 
-    def from_coefficient(self, ulm: sh.SHCoeffs) -> sh.SHGrid:
+    def from_coefficients(self, ulm: sh.SHCoeffs) -> sh.SHGrid:
         """Maps spherical harmonic coefficients to a function vector."""
         grid = self.grid if self._sampling == 1 else "DH2"
         return ulm.expand(grid=grid, extend=self.extend)
@@ -393,7 +393,7 @@ class SphereHelper:
         flat_coeffs = ulm.coeffs.flatten(order="C")
         return self._sparse_coeffs_to_component @ flat_coeffs
 
-    def _component_to_coefficient(self, c: np.ndarray) -> sh.SHCoeffs:
+    def _component_to_coefficients(self, c: np.ndarray) -> sh.SHCoeffs:
         """Maps a component vector to spherical harmonic coefficients."""
         flat_coeffs = self._sparse_coeffs_to_component.T @ c
         coeffs = flat_coeffs.reshape((2, self.lmax + 1, self.lmax + 1))
@@ -435,22 +435,22 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
         return self._dim
 
     def to_components(self, u: sh.SHGrid) -> np.ndarray:
-        coeff = self.to_coefficient(u)
+        coeff = self.to_coefficients(u)
         return self._coefficient_to_component(coeff)
 
     def from_components(self, c: np.ndarray) -> sh.SHGrid:
-        coeff = self._component_to_coefficient(c)
-        return self.from_coefficient(coeff)
+        coeff = self._component_to_coefficients(c)
+        return self.from_coefficients(coeff)
 
     def to_dual(self, u: sh.SHGrid) -> LinearForm:
-        coeff = self.to_coefficient(u)
+        coeff = self.to_coefficients(u)
         cp = self._coefficient_to_component(coeff) * self.radius**2
         return self.dual.from_components(cp)
 
     def from_dual(self, up: LinearForm) -> sh.SHGrid:
         cp = self.dual.to_components(up) / self.radius**2
-        coeff = self._component_to_coefficient(cp)
-        return self.from_coefficient(coeff)
+        coeff = self._component_to_coefficients(cp)
+        return self.from_coefficients(coeff)
 
     def ax(self, a: float, x: sh.SHGrid) -> None:
         """
@@ -513,8 +513,8 @@ class Lebesgue(SphereHelper, HilbertModule, AbstractInvariantLebesgueSpace):
 
         def mapping(u):
             c = matrix @ (self.to_components(u))
-            coeff = self._component_to_coefficient(c)
-            return self.from_coefficient(coeff)
+            coeff = self._component_to_coefficients(c)
+            return self.from_coefficients(coeff)
 
         return LinearOperator.self_adjoint(self, mapping)
 
@@ -605,7 +605,9 @@ class Sobolev(SphereHelper, MassWeightedHilbertModule, AbstractInvariantSobolevS
         summation = 1.0
         l = 0
         err = 1.0
-        sobolev_func = lambda deg: (1.0 + scale**2 * deg * (deg + 1)) ** order
+
+        def sobolev_func(deg):
+            return (1.0 + scale**2 * deg * (deg + 1)) ** order
 
         while err > rtol:
             l += 1

pygeoinf/symmetric_space/symmetric_space.py

@@ -35,7 +35,7 @@ from typing import Callable, Any, List
 import numpy as np
 from scipy.sparse import diags
 
-from pygeoinf.hilbert_space import EuclideanSpace, HilbertSpace
+from pygeoinf.hilbert_space import EuclideanSpace
 from pygeoinf.linear_operators import LinearOperator
 from pygeoinf.linear_forms import LinearForm
 from pygeoinf.gaussian_measure import GaussianMeasure

{pygeoinf-1.2.9.dist-info → pygeoinf-1.3.1.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pygeoinf
-Version: 1.2.9
+Version: 1.3.1
 Summary: A package for solving geophysical inference and inverse problems
 License: BSD-3-Clause
+License-File: LICENSE
 Author: David Al-Attar and Dan Heathcote
 Requires-Python: >=3.11
 Classifier: License :: OSI Approved :: BSD License
@@ -10,6 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: sphere
 Requires-Dist: joblib (>=1.5.2,<2.0.0)
 Requires-Dist: matplotlib (>=3.0.0)

pygeoinf-1.3.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+pygeoinf/__init__.py,sha256=vAoI6Kw2EL5koHn0EP0kbLvhtWV9gxA439PowiqkQHU,3246
+pygeoinf/backus_gilbert.py,sha256=eFi4blSwOCsg_NuH6WD4gcgjvzvu5g5WpWahGobSBdM,3694
+pygeoinf/checks/hilbert_space.py,sha256=07AZ6fx44PgSPjo_bjRJlVWTta1k1hhIX0TTTwMRdm8,8665
+pygeoinf/checks/linear_operators.py,sha256=RkmtAW6e5Zr6EuhX6GAt_pI0IWu2WZ-CrfjSBN_7dsU,4664
+pygeoinf/checks/nonlinear_operators.py,sha256=vB12HDX9YHJ8nNSVxG9BWzsVYTg12L5rrYbW98lPYxE,5560
+pygeoinf/direct_sum.py,sha256=7V0qrwFGj0GN-p_zzffefPrIB0dPu5dshLTxem1mQGE,19274
+pygeoinf/forward_problem.py,sha256=NnqWp7iMfkhHa9d-jBHzYHClaAfhKmO5D058AcJLLYg,10724
+pygeoinf/gaussian_measure.py,sha256=bBh64xHgmLFl27krn9hkf8qDQjop_39x69cyhJgUHN8,26219
+pygeoinf/hilbert_space.py,sha256=rKF8upjHw7uw3qBKS-bsEo1J9-So0urTcmVsmJJQeog,25875
+pygeoinf/inversion.py,sha256=RV0hG2bGnciWdja0oOPKPxnFhYzufqdj-mKYNr4JJ_o,6447
+pygeoinf/linear_bayesian.py,sha256=L1cJkeHtba4fPXZ8CmiLRBtuG2fmzG228M_iEar-iP8,9643
+pygeoinf/linear_forms.py,sha256=mgZeDRegNKo8kviE68KrxkHR4gG9bf1RgsJz1MtDMCk,9181
+pygeoinf/linear_operators.py,sha256=Bn-uzwUXi2kkWZ7wc9Uhj3vBHtocN17hnzc_r7DAzTk,64530
+pygeoinf/linear_optimisation.py,sha256=UbSr6AOPpR2sRYoN1Pvv24-Zu7_XlJk1zE1IhQu83hg,12428
+pygeoinf/linear_solvers.py,sha256=v-7yjKsa67Ts5EcyJzCdpj-aF0qBrA-akq0kLe59DS4,16843
+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=zXY0o5MvgJUiwy3uEwTOwVdKT_5XRBKx_-9qmyalB3A,13654
+pygeoinf/random_matrix.py,sha256=71l6eAXQ2pRMleaz1lXud6O1F78ugKyp3vHcRBXhdwM,17661
+pygeoinf/symmetric_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygeoinf/symmetric_space/circle.py,sha256=GuwVmLdHGTMxMrZfyXIPP3pz_y971ntlD5pl42lKJZ0,18796
+pygeoinf/symmetric_space/sphere.py,sha256=SYeGa70fKzasXxwPoVk3tNBtlP0QwLQe5jwW7o3AmcU,23376
+pygeoinf/symmetric_space/symmetric_space.py,sha256=pEIZZYWsdegrYCwUs3bo86JTz3d2LsXFWdRYFa0syFs,17963
+pygeoinf-1.3.1.dist-info/METADATA,sha256=vCwJqf6JupB0xp7MdR26DAjHpuBbTG37lbBGgZjz9W0,16365
+pygeoinf-1.3.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+pygeoinf-1.3.1.dist-info/licenses/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
+pygeoinf-1.3.1.dist-info/RECORD,,

{pygeoinf-1.2.9.dist-info → pygeoinf-1.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any

pygeoinf-1.2.9.dist-info/RECORD

@@ -1,28 +0,0 @@
-pygeoinf/__init__.py,sha256=pV9UXNrRXAIagU4eTmHf2Qi0CtVgOp0sqLnltgBFoKc,1650
-pygeoinf/backus_gilbert.py,sha256=vpIWvryUIy6pHWhT9A4bVB3A9MuTll1MyN9U8zmVI5c,3783
-pygeoinf/checks/hilbert_space.py,sha256=Kr7PcOGrNIISezty0FBj5uXavIHC91yjCp2FVGNlHeE,7931
-pygeoinf/checks/linear_operators.py,sha256=RkmtAW6e5Zr6EuhX6GAt_pI0IWu2WZ-CrfjSBN_7dsU,4664
-pygeoinf/checks/nonlinear_operators.py,sha256=Rn9LTftyw5eGU3akx6xYNUJVGvX9J6gyTEXVFgLfYqs,5601
-pygeoinf/direct_sum.py,sha256=1RHPJI_PoEvSRH9AmjX-v88IkSW4uT2rPSt5pmZQEZY,19377
-pygeoinf/forward_problem.py,sha256=NnqWp7iMfkhHa9d-jBHzYHClaAfhKmO5D058AcJLLYg,10724
-pygeoinf/gaussian_measure.py,sha256=zYpvQ29jBpWE2tDTF1rXZQiSICDuoxizVP4ZJr1k6Fk,23665
-pygeoinf/hilbert_space.py,sha256=0NCCG-OOHysdXYEFUs1wtJhGgOnuKvjZCZg8NJZO-DA,25331
-pygeoinf/inversion.py,sha256=RV0hG2bGnciWdja0oOPKPxnFhYzufqdj-mKYNr4JJ_o,6447
-pygeoinf/linear_bayesian.py,sha256=L1cJkeHtba4fPXZ8CmiLRBtuG2fmzG228M_iEar-iP8,9643
-pygeoinf/linear_forms.py,sha256=sgynBvlQ35CaH12PKU2vWPHh9ikrmQbD5IASCUQtlbw,9197
-pygeoinf/linear_operators.py,sha256=HToie5nllV0PQFa-QzETtIPKveWnt2dkWiaWTJa6fTw,64577
-pygeoinf/linear_optimisation.py,sha256=UbSr6AOPpR2sRYoN1Pvv24-Zu7_XlJk1zE1IhQu83hg,12428
-pygeoinf/linear_solvers.py,sha256=v-7yjKsa67Ts5EcyJzCdpj-aF0qBrA-akq0kLe59DS4,16843
-pygeoinf/nonlinear_forms.py,sha256=eQudA-HfedbURvRmzVvU8HfNCxHTuWUpdDoWe_KlA4Y,7067
-pygeoinf/nonlinear_operators.py,sha256=X4_UMV1Rn4MqorjfN4P_UTckzCb4Gy1XceR3Ix8G4F8,7170
-pygeoinf/nonlinear_optimisation.py,sha256=skK1ikn9GrVYherD64Qt9WrEYHA2NAJ48msOu_J8Oig,7431
-pygeoinf/parallel.py,sha256=VVFvNHszy4wSa9LuErIsch4NAkLaZezhdN9YpRROBJo,2267
-pygeoinf/random_matrix.py,sha256=71l6eAXQ2pRMleaz1lXud6O1F78ugKyp3vHcRBXhdwM,17661
-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=8mIny_KNP2MCpVxqIFKEgXc1_EIDesVz65OhUtRVsuQ,23349
-pygeoinf/symmetric_space/symmetric_space.py,sha256=Q3KtfCtHO0_8LjsdKtH-5WVhRQurt5Bdk4yx1D2F5YY,17977
-pygeoinf-1.2.9.dist-info/LICENSE,sha256=GrTQnKJemVi69FSbHprq60KN0OJGsOSR-joQoTq-oD8,1501
-pygeoinf-1.2.9.dist-info/METADATA,sha256=dBoRWZKHNcr7PIhPki7pU9oIFLy0FQtJOvI6dIp39no,16292
-pygeoinf-1.2.9.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pygeoinf-1.2.9.dist-info/RECORD,,