pyrecest 2.2.0__tar.gz → 2.2.2__tar.gz

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

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

{pyrecest-2.2.0 → 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.0"
+version = "2.2.2"
 
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]

pyrecest-2.2.2/src/pyrecest/_backend/_shared_numpy/random.py

@@ -0,0 +1,51 @@
+from ._dispatch import _common
+from ._dispatch import numpy as _np
+
+_modify_func_default_dtype = _common._modify_func_default_dtype
+_allow_complex_dtype = _common._allow_complex_dtype
+
+
+rand = _modify_func_default_dtype(
+    copy=False, kw_only=True, target=_allow_complex_dtype(target=_np.random.rand)
+)
+
+uniform = _modify_func_default_dtype(
+    copy=False, kw_only=True, target=_allow_complex_dtype(target=_np.random.uniform)
+)
+
+
+normal = _modify_func_default_dtype(
+    copy=False, kw_only=True, target=_allow_complex_dtype(target=_np.random.normal)
+)
+
+multivariate_normal = _modify_func_default_dtype(
+    copy=False,
+    kw_only=True,
+    target=_allow_complex_dtype(target=_np.random.multivariate_normal),
+)
+
+
+def choice(a, size=None, replace=True, p=None, axis=0, shuffle=True):
+    """Draw samples using NumPy's seeded global random state.
+
+    ``numpy.random.Generator.choice`` supports sampling rows from a multidimensional
+    array, but it is independent of ``numpy.random.seed`` when a fresh generator is
+    created for every call.  The backend exposes ``random.seed``/``get_state`` from
+    ``numpy.random``, so this wrapper samples indices through the seeded legacy RNG
+    and then gathers along ``axis`` for multidimensional inputs.
+    """
+    del shuffle  # ``numpy.random.choice`` has no equivalent shuffle argument.
+
+    a_array = _np.asarray(a)
+    if a_array.ndim == 0:
+        return _np.random.choice(a, size=size, replace=replace, p=p)
+
+    axis = axis % a_array.ndim
+    if a_array.ndim == 1 and axis == 0:
+        return _np.random.choice(a_array, size=size, replace=replace, p=p)
+
+    if p is not None:
+        p = _np.asarray(p)
+
+    indices = _np.random.choice(a_array.shape[axis], size=size, replace=replace, p=p)
+    return _np.take(a_array, indices, axis=axis)

{pyrecest-2.2.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → pyrecest-2.2.2}/src/pyrecest/distributions/abstract_mixture.py

@@ -7,12 +7,14 @@ import pyrecest.backend
 
 # pylint: disable=redefined-builtin,no-name-in-module,no-member
 from pyrecest.backend import (
-    count_nonzero,
+    array,
+    asarray,
     empty,
     int32,
     int64,
     ones,
     random,
+    reshape,
     sum,
     zeros,
 )
@@ -39,21 +41,29 @@ class AbstractMixture(AbstractDistributionType):
 
         if weights is None:
             weights = ones(num_distributions) / num_distributions
+        else:
+            weights = asarray(weights)
 
         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")
 
-        non_zero_indices = count_nonzero(weights)
+        non_zero_indices = [i for i, weight in enumerate(weights) if bool(weight != 0)]
 
-        if non_zero_indices < len(weights):
+        if len(non_zero_indices) == 0:
+            raise ValueError("At least one mixture weight must be nonzero")
+
+        if len(non_zero_indices) < len(weights):
             warnings.warn(
                 "Elements with zero weights detected. Pruning elements in mixture with weight zero."
             )
             dists = [dists[i] for i in non_zero_indices]
-            weights = weights[non_zero_indices]
+            weights = weights[array(non_zero_indices, dtype=int64)]
 
         self.dists = dists
 
@@ -67,6 +77,17 @@ class AbstractMixture(AbstractDistributionType):
     def input_dim(self) -> int:
         return self.dists[0].input_dim
 
+    def _as_sample_matrix(self, samples, n_samples: int):
+        samples = asarray(samples)
+
+        if self.input_dim == 1 and samples.ndim == 0:
+            return reshape(samples, (1, 1))
+
+        if self.input_dim == 1 and samples.ndim == 1:
+            return reshape(samples, (n_samples, 1))
+
+        return pyrecest.backend.atleast_2d(samples)
+
     def sample(self, n: Union[int, int32, int64]):
         occurrences = random.multinomial(n, self.w)
         if pyrecest.backend.__backend_name__ == "jax":
@@ -78,7 +99,7 @@ class AbstractMixture(AbstractDistributionType):
                         sample_i = self.dists[i].sample(occ_val)
                     except (NotImplementedError, AssertionError, ValueError, TypeError):
                         sample_i = self.dists[i].sample_metropolis_hastings(occ_val)
-                    sample_i = pyrecest.backend.atleast_2d(sample_i)
+                    sample_i = self._as_sample_matrix(sample_i, occ_val)
                     samples.append(sample_i)
             if not samples:
                 return empty((0, self.input_dim))
@@ -89,15 +110,25 @@ class AbstractMixture(AbstractDistributionType):
         for i, occ in enumerate(occurrences):
             occ_val = occ.item() if hasattr(occ, "item") else int(occ)
             if occ_val != 0:
-                s[count : count + occ_val] = self.dists[i].sample(occ_val)  # noqa: E203
+                sample_i = self._as_sample_matrix(
+                    self.dists[i].sample(occ_val), occ_val
+                )
+                s[count : count + occ_val] = sample_i  # noqa: E203
                 count += occ_val
 
         return s
 
     def pdf(self, xs):
-        assert xs.shape[-1] == self.input_dim, "Dimension mismatch"
+        xs = asarray(xs)
 
-        p = zeros(1) if xs.ndim == 1 else zeros(xs.shape[0])
+        if self.input_dim == 1 and xs.ndim <= 1:
+            # For one-dimensional distributions, a flat array represents a batch
+            # of scalar evaluation points. This matches GaussianDistribution.pdf
+            # and avoids rejecting natural inputs such as xs.shape == (n,).
+            p = zeros(xs.shape)
+        else:
+            assert xs.shape[-1] == self.input_dim, "Dimension mismatch"
+            p = zeros(1) if xs.ndim == 1 else zeros(xs.shape[0])
 
         for i, dist in enumerate(self.dists):
             p += self.w[i] * dist.pdf(xs)

{pyrecest-2.2.0 → 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.0 → 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.0 → 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)