pygeoinf 1.3.0__tar.gz → 1.3.1__tar.gz

{pygeoinf-1.3.0 → pygeoinf-1.3.1}/PKG-INFO

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

{pygeoinf-1.3.0 → pygeoinf-1.3.1}/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-1.3.0 → pygeoinf-1.3.1}/pygeoinf/gaussian_measure.py

@@ -21,6 +21,7 @@ Key Features
 
 from __future__ import annotations
 from typing import Callable, Optional, Any, List, TYPE_CHECKING
+import warnings
 
 import numpy as np
 from scipy.linalg import eigh
@@ -197,6 +198,7 @@ class GaussianMeasure:
         /,
         *,
         expectation: Vector = None,
+        rtol: float = 1e-10,
     ) -> GaussianMeasure:
         """
         Creates a Gaussian measure from a dense covariance matrix.
@@ -205,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])
@@ -466,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-1.3.0 → pygeoinf-1.3.1}/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-1.3.1/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-1.3.0 → pygeoinf-1.3.1}/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-1.3.0 → pygeoinf-1.3.1}/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)
 

{pygeoinf-1.3.0 → pygeoinf-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pygeoinf"
-version = "1.3.0"
+version = "1.3.1"
 description = "A package for solving geophysical inference and inverse problems"
 authors = ["David Al-Attar and Dan Heathcote"]
 readme = "README.md"