pyrecest 2.2.1__tar.gz → 2.2.2__tar.gz

{pyrecest-2.2.1 → pyrecest-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrecest
-Version: 2.2.1
+Version: 2.2.2
 Summary: Framework for recursive Bayesian estimation in Python.
 License-File: LICENSE
 Author: Florian Pfaff

{pyrecest-2.2.1 → pyrecest-2.2.2}/pyproject.toml

@@ -3,7 +3,7 @@ name = "pyrecest"
 description = "Framework for recursive Bayesian estimation in Python."
 readme = "README.md"
 authors = ["Florian Pfaff <pfaff@ias.uni-stuttgart.de>"]
-version = "2.2.1"
+version = "2.2.2"
 
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/_backend/jax/autodiff.py

@@ -6,10 +6,9 @@ https://github.com/oxcsml/geomstats/blob/master/geomstats/_backend/jax/autodiff.
 
 
 import jax.numpy as anp
-from jax import vmap, grad
-from jax import jacfwd
-from jax import value_and_grad as _value_and_grad
 from autograd.extend import defvjp, primitive  # TODO: replace
+from jax import grad, jacfwd
+from jax import value_and_grad as _value_and_grad
 
 
 def detach(x):
@@ -33,7 +32,14 @@ def elementwise_grad(func):
     func : callable
         Function for which the element-wise grad is computed.
     """
-    return vmap(grad(func))(func)  # NOTE: cf https://github.com/google/jax/issues/564
+
+    def _elementwise_grad(*args, **kwargs):
+        def _summed_func(*inner_args):
+            return anp.sum(func(*inner_args, **kwargs))
+
+        return grad(_summed_func)(*args)
+
+    return _elementwise_grad
 
 
 def custom_gradient(*grad_funcs):
@@ -116,14 +122,20 @@ def value_and_grad(func, to_numpy=False):
 
     return aux_value_and_grad
 
+
 unsupported_functions = [
-    'hessian',
-    'hessian_vec',
-    'jacobian_vec',
-    'jacobian_and_hessian',
-    'value_jacobian_and_hessian',
-    'value_and_jacobian',
+    "hessian",
+    "hessian_vec",
+    "jacobian_vec",
+    "jacobian_and_hessian",
+    "value_jacobian_and_hessian",
+    "value_and_jacobian",
 ]
-for func_name in unsupported_functions:
-    exec(f"{func_name} = lambda *args, **kwargs: NotImplementedError('This function is not supported in this JAX backend.')")
 
+
+def _raise_unsupported(*args, **kwargs):
+    raise NotImplementedError("This function is not supported in this JAX backend.")
+
+
+for func_name in unsupported_functions:
+    globals()[func_name] = _raise_unsupported

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/_backend/jax/random.py

@@ -120,15 +120,31 @@ def choice(a, n, *args, **kwargs):
     return set_state_return(has_state, state, res)
 
 
-def _multivariate_normal(state, size, *args, **kwargs):
-    state, key = jax.random.split(state)
-    return state, jax.random.multivariate_normal(key, shape=size, *args, **kwargs)
+def _shape_from_size(size):
+    """Convert a NumPy-style ``size`` argument to JAX's ``shape`` argument."""
+    if size is None:
+        return None
+    if hasattr(size, "__iter__"):
+        return tuple(int(dim) for dim in size)
+    return (int(size),)
 
 
-def multivariate_normal(size, *args, **kwargs):
-    size = size if hasattr(size, "__iter__") else (size,)
+def _multivariate_normal(state, mean, cov, size=None, *args, **kwargs):
+    state, key = jax.random.split(state)
+    if "shape" in kwargs:
+        if size is not None:
+            raise TypeError("Specify only one of 'size' or 'shape'.")
+        size = kwargs.pop("shape")
+    shape = _shape_from_size(size)
+    return state, jax.random.multivariate_normal(
+        key, mean, cov, shape, *args, **kwargs
+    )
+
+
+def multivariate_normal(mean, cov, size=None, *args, **kwargs):
+    """Draw samples with NumPy-compatible ``multivariate_normal`` arguments."""
     state, has_state, kwargs = _get_state(**kwargs)
-    state, res = _multivariate_normal(state, size, *args, **kwargs)
+    state, res = _multivariate_normal(state, mean, cov, size, *args, **kwargs)
     return set_state_return(has_state, state, res)
 
 

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/_so3_helpers.py

@@ -11,6 +11,7 @@ from pyrecest.backend import (
     concatenate,
     cos,
     linalg,
+    log,
     ndim,
     reshape,
     sin,
@@ -72,6 +73,28 @@ def quaternion_multiply(left, right):
     return normalize_quaternions(product)
 
 
+def so3_exp_map_volume_log_jacobian(tangent_vectors):
+    """Return the SO(3) exponential-map volume log-Jacobian.
+
+    For scalar-last unit quaternions with the canonical ``w >= 0`` sign, the
+    principal rotation-vector chart maps the ball ``||v|| <= pi`` to the upper
+    unit-quaternion half sphere.  With ``theta = ||v||``, its volume element is
+
+        dV = sin(theta / 2)^2 / (2 * theta^2) dv,
+
+    with limiting value ``1 / 8`` at the identity.  The returned value is
+    ``log(dV / dv)`` and preserves all leading dimensions of ``tangent_vectors``.
+    """
+    tangent_vectors = array(tangent_vectors, dtype=float)
+    assert tangent_vectors.shape[-1] == 3, "SO(3) tangent vectors must have length 3."
+
+    angles = linalg.norm(tangent_vectors, axis=-1)
+    safe_angles = where(angles > 1e-8, angles, 1.0)
+    direct = 2.0 * (log(sin(0.5 * safe_angles)) - log(safe_angles)) - log(2.0)
+    small_angle_series = -log(8.0) - angles**2 / 12.0 - angles**4 / 1440.0
+    return where(angles > 1e-8, direct, small_angle_series)
+
+
 def exp_map_identity(tangent_vectors):
     """Map SO(3) tangent vectors at identity to scalar-last quaternions."""
     tangent_vectors = array(tangent_vectors, dtype=float)
@@ -107,10 +130,13 @@ def log_map_identity(rotations):
     angles = 2.0 * arctan2(vector_norm, scalar_part)
     vector_norm_col = reshape(vector_norm, tuple(vector_norm.shape) + (1,))
     safe_norm = where(vector_norm_col > 1e-12, vector_norm_col, 1.0)
-    scale = where(
-        vector_norm_col > 1e-12,
-        reshape(angles, tuple(angles.shape) + (1,)) / safe_norm,
-        2.0,
+    scale = (
+        where(
+            vector_norm_col > 1e-12,
+            reshape(angles, tuple(angles.shape) + (1,)),
+            2.0 * safe_norm,
+        )
+        / safe_norm
     )
     return vector_part * scale
 

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/abstract_dirac_distribution.py

@@ -9,10 +9,12 @@ from beartype import beartype
 from pyrecest.backend import (
     all,
     apply_along_axis,
+    arange,
     argmax,
     int32,
     int64,
     isclose,
+    isfinite,
     log,
     ones,
     random,
@@ -42,13 +44,31 @@ class AbstractDiracDistribution(AbstractDistributionType):
             self.w = copy.copy(w)
         self.normalize_in_place()
 
+    @staticmethod
+    def _validate_weights(w):
+        """
+        Validate Dirac weights and return their total mass.
+        """
+        if not bool(all(isfinite(w))):
+            raise ValueError("Dirac weights must be finite.")
+
+        if not bool(all(w >= 0)):
+            raise ValueError("Dirac weights must be nonnegative.")
+
+        total_weight = sum(w)
+        if not bool(isfinite(total_weight)) or not bool(total_weight > 0):
+            raise ValueError("Dirac weights must have positive finite total mass.")
+
+        return total_weight
+
     def normalize_in_place(self):
         """
         Normalize the weights in-place to ensure they sum to 1.
         """
-        if not isclose(sum(self.w), 1.0, atol=1e-10):
+        total_weight = self._validate_weights(self.w)
+        if not isclose(total_weight, 1.0, atol=1e-10):
             warnings.warn("Weights are not normalized.", RuntimeWarning)
-            self.w = self.w / sum(self.w)
+            self.w = self.w / total_weight
 
     def normalize(self) -> "AbstractDiracDistribution":
         dist = copy.deepcopy(self)
@@ -75,16 +95,17 @@ class AbstractDiracDistribution(AbstractDistributionType):
         w_new = f(dist.d)
 
         assert w_new.shape == dist.w.shape, "Function returned wrong output dimensions."
-        assert all(w_new >= 0), "All weights should be greater than or equal to 0."
-        assert sum(w_new) > 0, "The sum of all weights should be greater than 0."
+        self._validate_weights(w_new)
 
         dist.w = w_new * dist.w
-        dist.w = dist.w / sum(dist.w)
+        total_weight = self._validate_weights(dist.w)
+        dist.w = dist.w / total_weight
 
         return dist
 
     def sample(self, n: Union[int, int32, int64]):
-        samples = random.choice(self.d, n, p=self.w)
+        indices = random.choice(arange(self.d.shape[0]), n, p=self.w)
+        samples = self.d[indices]
         return samples
 
     def entropy(self) -> float:

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/abstract_grid_distribution.py

@@ -74,14 +74,14 @@ class AbstractGridDistribution(AbstractDistributionType):
 
     def normalize_in_place(self, tol=1e-4, warn_unnorm=True):
         int_val = self.integrate()
+        if float(abs(int_val)) < 1e-200:
+            raise ValueError(
+                "Sum of grid values is too close to zero, this usually points to a user error."
+            )
         if any(self.grid_values < 0):
             warnings.warn(
                 "Warning: There are negative values. This usually points to a user error."
             )
-        elif abs(int_val) < 1e-200:
-            raise ValueError(
-                "Sum of grid values is too close to zero, this usually points to a user error."
-            )
         elif abs(int_val - 1) > tol:
             if warn_unnorm:
                 warnings.warn(

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/abstract_manifold_specific_distribution.py

@@ -9,6 +9,16 @@ import pyrecest.backend
 from pyrecest.backend import empty, int32, int64, log, random, squeeze
 
 
+def _to_scalar(value):
+    """Convert a backend scalar or length-one array to a Python float."""
+    try:
+        return float(value.item())
+    except AttributeError:
+        return float(value)
+    except (TypeError, ValueError, RuntimeError):
+        return float(value.reshape(-1)[0])
+
+
 class AbstractManifoldSpecificDistribution(ABC):
     """
     Abstract base class for distributions catering to specific manifolds.
@@ -98,7 +108,7 @@ class AbstractManifoldSpecificDistribution(ABC):
         return self.sample_metropolis_hastings(n)
 
     # jscpd:ignore-start
-    # pylint: disable=too-many-positional-arguments,too-many-locals
+    # pylint: disable=too-many-positional-arguments,too-many-locals,too-many-arguments
     def sample_metropolis_hastings(
         self,
         n: Union[int, int32, int64],
@@ -106,9 +116,19 @@ class AbstractManifoldSpecificDistribution(ABC):
         skipping: Union[int, int32, int64] = 5,
         proposal: Callable | None = None,
         start_point=None,
+        proposal_log_pdf: Callable | None = None,
     ):
         # jscpd:ignore-end
-        """Metropolis Hastings sampling algorithm."""
+        """Metropolis-Hastings sampling algorithm.
+
+        ``proposal`` generates a candidate state from the current state. For
+        non-JAX backends it must be callable as ``proposal(x)``; for JAX it
+        must be callable as ``proposal(key, x)``.
+
+        ``proposal_log_pdf`` is optional and must evaluate
+        ``log q(candidate | current)``. If it is omitted, the proposal is
+        assumed symmetric, recovering the ordinary Metropolis ratio.
+        """
         if pyrecest.backend.__backend_name__ == "jax":
             # Get a key from your global JAX random state *outside* of lax.scan
             import jax as _jax  # pylint: disable=import-error
@@ -132,6 +152,7 @@ class AbstractManifoldSpecificDistribution(ABC):
                 n=int(n),
                 burn_in=int(burn_in),
                 skipping=int(skipping),
+                proposal_log_pdf=proposal_log_pdf,
             )
             # You could optionally stash `key_out` somewhere if you want chain continuation.
             return squeeze(samples)
@@ -146,20 +167,30 @@ class AbstractManifoldSpecificDistribution(ABC):
         s = empty((total_samples, self.input_dim))
         x = start_point
         i = 0
-        pdfx = self.pdf(x)
+        log_pdfx = _to_scalar(self.ln_pdf(x))
 
         while i < total_samples:
             x_new = proposal(x)
             assert (
                 x_new.shape == x.shape
             ), "Proposal must return a vector of same shape as input"
-            pdfx_new = self.pdf(x_new)
-            a = pdfx_new / pdfx
-            if a.item() > 1 or a.item() > random.rand(1):
-                s[i, :] = x_new.squeeze()
+            log_pdfx_new = _to_scalar(self.ln_pdf(x_new))
+            log_acceptance_ratio = log_pdfx_new - log_pdfx
+
+            if proposal_log_pdf is not None:
+                log_acceptance_ratio += _to_scalar(
+                    proposal_log_pdf(x, x_new)
+                ) - _to_scalar(proposal_log_pdf(x_new, x))
+
+            if (
+                log_acceptance_ratio >= 0.0
+                or _to_scalar(log(random.rand(1))) < log_acceptance_ratio
+            ):
                 x = x_new
-                pdfx = pdfx_new
-                i += 1
+                log_pdfx = log_pdfx_new
+            # Record every chain step; rejected proposals keep the current state.
+            s[i, :] = x.squeeze()
+            i += 1
 
         relevant_samples = s[burn_in::skipping, :]
         return squeeze(relevant_samples)
@@ -174,6 +205,8 @@ def sample_metropolis_hastings_jax(
     n: int,
     burn_in: int = 10,
     skipping: int = 5,
+    # function: (candidate, current) -> log q(candidate | current)
+    proposal_log_pdf=None,
 ):
     """
     Metropolis-Hastings sampler in JAX using a plain Python loop.
@@ -186,6 +219,8 @@ def sample_metropolis_hastings_jax(
     proposal:   callable (key, x) -> x_proposed
     start_point: initial state (array)
     n:          number of samples to return (after burn-in and thinning)
+    proposal_log_pdf: optional callable evaluating log q(candidate | current).
+                      If omitted, the proposal is assumed symmetric.
     """
     import jax.numpy as _jnp  # pylint: disable=import-error
     from jax import random as _random  # pylint: disable=import-error
@@ -209,8 +244,14 @@ def sample_metropolis_hastings_jax(
         x_prop = proposal(key_prop, x)
         log_px_prop = _to_scalar(log_pdf(x_prop))
 
-        # Metropolis acceptance
+        # Metropolis-Hastings acceptance. The proposal correction vanishes for
+        # symmetric proposals.
         log_alpha = log_px_prop - log_px
+        if proposal_log_pdf is not None:
+            log_alpha += _to_scalar(proposal_log_pdf(x, x_prop)) - _to_scalar(
+                proposal_log_pdf(x_prop, x)
+            )
+
         log_u = _to_scalar(_jnp.log(_random.uniform(key_u, shape=())))
 
         if log_u < min(0.0, log_alpha):

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/abstract_mixture.py

@@ -47,6 +47,9 @@ class AbstractMixture(AbstractDistributionType):
         if num_distributions != len(weights):
             raise ValueError("Sizes of distributions and weights must be equal")
 
+        if any(bool(weight < 0) for weight in weights):
+            raise ValueError("Mixture weights must be nonnegative")
+
         if not all(dists[0].dim == dist.dim for dist in dists):
             raise ValueError("All distributions must have the same dimension")
 

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/abstract_orthogonal_basis_distribution.py

@@ -4,10 +4,13 @@ from abc import abstractmethod
 
 # pylint: disable=redefined-builtin,no-name-in-module,no-member
 # pylint: disable=no-name-in-module,no-member
+from pyrecest.backend import abs as backend_abs
 from pyrecest.backend import all, exp, imag, real
 
 from .abstract_distribution_type import AbstractDistributionType
 
+_REAL_DENSITY_IMAG_TOL = 1e-10
+
 
 class AbstractOrthogonalBasisDistribution(AbstractDistributionType):
     """
@@ -48,6 +51,23 @@ class AbstractOrthogonalBasisDistribution(AbstractDistributionType):
         result = copy.deepcopy(self)
         return result.normalize_in_place()
 
+    @staticmethod
+    def _discard_negligible_imaginary_part(val):
+        """
+        Return the real part of a numerically real value.
+
+        Non-square-root density representations should evaluate to real-valued
+        densities. Small imaginary parts arise from floating-point roundoff in
+        complex basis evaluations and can be discarded; larger imaginary parts
+        indicate inconsistent coefficients and must not be silently ignored.
+        """
+        if not all(backend_abs(imag(val)) <= _REAL_DENSITY_IMAG_TOL):
+            raise ValueError(
+                "Density evaluation has a non-negligible imaginary part. "
+                "Check that the coefficients define a real-valued density."
+            )
+        return real(val)
+
     def pdf(self, xs):
         """
         Calculates probability density function for the given input.
@@ -57,14 +77,13 @@ class AbstractOrthogonalBasisDistribution(AbstractDistributionType):
         """
         val = self.value(xs)
         if self.transformation == "sqrt":
-            assert all(imag(val) < 0.0001)
-            return real(val) ** 2
+            return backend_abs(val) ** 2
 
         if self.transformation == "identity":
-            return val
+            return self._discard_negligible_imaginary_part(val)
 
         if self.transformation == "log":
             warnings.warn("Density may not be normalized")
-            return exp(val)
+            return exp(self._discard_negligible_imaginary_part(val))
 
         raise ValueError("Transformation not recognized or unsupported")

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/cart_prod/abstract_hypercylindrical_distribution.py

@@ -71,23 +71,30 @@ class AbstractHypercylindricalDistribution(AbstractLinPeriodicCartProdDistributi
 
     def get_reasonable_integration_boundaries(self, scalingFactor=10):
         """
-        Returns reasonable integration boundaries for the specific distribution
-        based on the mode and covariance.
+        Return reasonable integration boundaries for numerical integration.
+
+        The input dimensions are ordered as bounded dimensions first and linear
+        dimensions second.  SciPy's nquad expects one [lower, upper] interval per
+        input dimension, so the periodic dimensions are integrated over a full
+        period and the linear dimensions are truncated around the mode according
+        to their marginal standard deviations.
         """
-        left = empty((self.bound_dim + self.lin_dim, 1))
-        right = empty((self.bound_dim + self.lin_dim, 1))
         P = self.linear_covariance()
         m = self.mode()
 
-        for i in range(self.bound_dim, self.bound_dim + self.lin_dim):
-            left[i] = m[i] - scalingFactor * sqrt(
-                P[i - self.bound_dim, i - self.bound_dim]
-            )
-            right[i] = m[i] + scalingFactor * sqrt(
-                P[i - self.bound_dim, i - self.bound_dim]
+        integration_boundaries = [[0.0, float(2.0 * pi)] for _ in range(self.bound_dim)]
+
+        for linear_idx in range(self.lin_dim):
+            input_idx = self.bound_dim + linear_idx
+            linear_std = sqrt(P[linear_idx, linear_idx])
+            integration_boundaries.append(
+                [
+                    float(m[input_idx] - scalingFactor * linear_std),
+                    float(m[input_idx] + scalingFactor * linear_std),
+                ]
             )
 
-        return vstack((left, right))
+        return integration_boundaries
 
     def mode(self):
         """Find the mode of the distribution by calling mode_numerical."""

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/cart_prod/abstract_lin_bounded_cart_prod_distribution.py

@@ -27,7 +27,7 @@ class AbstractLinBoundedCartProdDistribution(AbstractCartProdDistribution):
         """
         if not bound_dim >= 1:
             raise ValueError("bound_dim must be a positive integer")
-        if not bound_dim >= 1:
+        if not lin_dim >= 1:
             raise ValueError("lin_dim must be a positive integer")
 
         AbstractCartProdDistribution.__init__(self, bound_dim + lin_dim)

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/cart_prod/mardia_sutton_distribution.py

@@ -120,13 +120,35 @@ class MardiaSuttonDistribution(AbstractHypercylindricalDistribution):
         return column_stack([s_vm, s_gauss])
 
     def linear_covariance(self, approximate_mean=None):
-        """Return the intrinsic linear variance as a (1, 1) matrix.
+        """Return the marginal linear variance as a (1, 1) matrix.
 
         Returns:
-            C (1, 1): [[sigma^2]]
+            C (1, 1): marginal variance of the linear variable
         """
         _ = approximate_mean
-        return array([[self.sigma**2]])
+
+        kappa = float(self.kappa)
+        bessel_0 = iv(0, kappa)
+        bessel_ratio_1 = iv(1, kappa) / bessel_0
+        bessel_ratio_2 = iv(2, kappa) / bessel_0
+
+        rho_squared = self.rho1**2 + self.rho2**2
+        conditional_variance = self.sigma**2 * (1.0 - rho_squared)
+
+        # The conditional linear mean depends on the von-Mises-distributed angle.
+        # Hence the marginal linear variance is E[Var[X | theta]] plus
+        # Var(E[X | theta]); returning sigma**2 alone ignores the second term.
+        aligned_rho_cos = self.rho1 * cos(self.mu0) + self.rho2 * sin(self.mu0)
+        aligned_rho_sin = -self.rho1 * sin(self.mu0) + self.rho2 * cos(self.mu0)
+        cos_variance = 0.5 * (1.0 + bessel_ratio_2) - bessel_ratio_1**2
+        sin_variance = 0.5 * (1.0 - bessel_ratio_2)
+        conditional_mean_variance = (
+            self.sigma**2
+            * self.kappa
+            * (aligned_rho_cos**2 * cos_variance + aligned_rho_sin**2 * sin_variance)
+        )
+
+        return array([[conditional_variance + conditional_mean_variance]])
 
     def marginalize_linear(self):
         """Return the marginal circular distribution.

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/circle/circular_fourier_distribution.py

@@ -29,6 +29,16 @@ from .abstract_circular_distribution import AbstractCircularDistribution
 from .circular_dirac_distribution import CircularDiracDistribution
 
 
+def _ensure_odd_n(n) -> None:
+    if n is not None and int(n) % 2 == 0:
+        raise ValueError(
+            "CircularFourierDistribution requires an odd number of "
+            "coefficients/grid values. Even lengths contain a Nyquist "
+            "coefficient that is not represented by the current real "
+            "coefficient convention."
+        )
+
+
 class CircularFourierDistribution(AbstractCircularDistribution):
     """Circular distribution represented by a Fourier series.
 
@@ -67,7 +77,8 @@ class CircularFourierDistribution(AbstractCircularDistribution):
                 )
                 self.n = 2 * c.shape[0] - 1
             else:
-                self.n = n
+                self.n = int(n)
+            _ensure_odd_n(self.n)
         elif a is not None and b is not None:
             assert a.ndim == 1
             assert b.ndim == 1
@@ -76,6 +87,7 @@ class CircularFourierDistribution(AbstractCircularDistribution):
             self.c = None
             self.n = a.shape[0] + b.shape[0]
             assert self.n == n or n is None
+            _ensure_odd_n(self.n)
         else:
             raise ValueError("Need to provide either c or a and b.")
 
@@ -270,7 +282,7 @@ class CircularFourierDistribution(AbstractCircularDistribution):
 
     def get_c(self):
         if self.a is not None:
-            c = (self.a[0] + 1j * hstack((0, self.b))) * 0.5
+            c = hstack((self.a[0:1], self.a[1:] - 1j * self.b)) * 0.5
         elif self.c is not None:
             c = self.c
         else:
@@ -308,6 +320,7 @@ class CircularFourierDistribution(AbstractCircularDistribution):
         transformation: str = "sqrt",
         store_values_multiplied_by_n: bool = True,
     ) -> "CircularFourierDistribution":
+        _ensure_odd_n(n)
         if isinstance(distribution, CircularDiracDistribution):
             if transformation != "identity":
                 warnings.warn(
@@ -355,14 +368,16 @@ class CircularFourierDistribution(AbstractCircularDistribution):
         transformation: str = "sqrt",
         store_values_multiplied_by_n: bool = True,
     ) -> "CircularFourierDistribution":
+        n_values = fvals.shape[0]
+        _ensure_odd_n(n_values)
         c = fft.rfft(fvals)
         if not store_values_multiplied_by_n:
-            c = c * (1.0 / fvals.shape[0])
+            c = c * (1.0 / n_values)
 
         fd = CircularFourierDistribution(
             c=c,
             transformation=transformation,
-            n=fvals.shape[0],
+            n=n_values,
             multiplied_by_n=store_values_multiplied_by_n,
         )
 

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/circle/circular_grid_distribution.py

@@ -81,6 +81,9 @@ class CircularGridDistribution(AbstractCircularDistribution, AbstractGridDistrib
     def get_manifold_size(self):
         return 2 * pi
 
+    def get_grid_point(self, indices):
+        return self.grid[indices]
+
     def trigonometric_moment(self, n):
         weights = self.grid_values / sum(self.grid_values)
         grid = self.get_grid()

{pyrecest-2.2.1 → pyrecest-2.2.2}/src/pyrecest/distributions/circle/sine_skewed_distributions.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 
 # pylint: disable=no-name-in-module,no-member
-from pyrecest.backend import cos, cosh, exp, mod, ndim, pi, sin, sinh
+from pyrecest.backend import array, cos, cosh, exp, mod, ndim, pi, sin, sinh
 from scipy.special import ive  # pylint: disable=no-name-in-module
 
 from .abstract_circular_distribution import AbstractCircularDistribution
@@ -57,7 +57,7 @@ class GeneralizedKSineSkewedVonMisesDistribution(AbstractCircularDistribution):
                 1
                 + self.lambda_**4
                 / 8
-                * (3 - 2 * bessel_ratio(2, self.kappa) + bessel_ratio(4, self.kappa))
+                * (3 - 4 * bessel_ratio(2, self.kappa) + bessel_ratio(4, self.kappa))
                 + 3 * self.lambda_**2 * (1 - bessel_ratio(2, self.kappa))
             )
         else:
@@ -134,7 +134,16 @@ class AbstractSineSkewedDistribution(AbstractCircularDistribution):
         """
         AbstractCircularDistribution.__init__(self)
         self.mu = mu
-        self.lambda_ = lambda_
+        self.lambda_ = array(lambda_)
+        self.validate_parameters()
+
+    def validate_parameters(self):
+        """Validate parameters common to first-order sine-skewed distributions."""
+        if ndim(self.lambda_) != 0:
+            raise ValueError("lambda_ must be a scalar")
+
+        if not (-1.0 <= self.lambda_ <= 1.0):
+            raise ValueError("lambda_ must be between -1 and 1 inclusive")
 
     @abstractmethod
     def base_pdf(self, xs):