inference-tools 0.13.3__py3-none-any.whl → 0.13.4__py3-none-any.whl

inference/priors.py

@@ -2,14 +2,113 @@
 .. moduleauthor:: Chris Bowman <chris.bowman.physics@gmail.com>
 """
 
+from abc import ABC, abstractmethod
 from typing import Union, Iterable
-
-from numpy import array, log, pi, zeros, concatenate, float64, where
+from numpy import atleast_1d, log, pi, zeros, concatenate, where, ndarray, isfinite
 from numpy.random import normal, exponential, uniform
 from itertools import chain
 
 
-class JointPrior:
+class BasePrior(ABC):
+    variables: list[int]
+
+    @staticmethod
+    def validate_variable_indices(
+        variable_inds: Union[int, Iterable[int]],
+        n_parameters: int,
+        class_name="BasePrior",
+    ) -> list[int]:
+        indices_type_error = TypeError(
+            f"""\n
+            \r[ {class_name} error ]
+            \r>> 'variable_inds' argument of {class_name} must be
+            \r>> given as an integer or list of integers
+            """
+        )
+
+        if not isinstance(variable_inds, (int, Iterable)):
+            raise indices_type_error
+
+        if isinstance(variable_inds, int):
+            variable_inds = [variable_inds]
+
+        if not all(isinstance(p, int) for p in variable_inds):
+            raise indices_type_error
+
+        if not isinstance(variable_inds, list):
+            variable_inds = list(variable_inds)
+
+        if n_parameters != len(variable_inds):
+            raise ValueError(
+                f"""\n
+                \r[ {class_name} error ]
+                \r>> The total number of variables specified via the 'variable_indices' argument
+                \r>> is inconsistent with the number specified by the other arguments.
+                """
+            )
+
+        if len(variable_inds) != len(set(variable_inds)):
+            raise ValueError(
+                f"""\n
+                \r[ {class_name} error ]
+                \r>> All integers given via the 'variable_indices' must be unique.
+                \r>> Two or more of the given integers are duplicates.
+                """
+            )
+
+        return variable_inds
+
+    @abstractmethod
+    def __call__(self, theta: ndarray) -> float:
+        pass
+
+    @abstractmethod
+    def gradient(self, theta: ndarray) -> ndarray:
+        pass
+
+    def cost(self, theta: ndarray) -> float:
+        """
+        Returns the 'cost', equal to the negative prior log-probability, for the
+        provided set of model parameters.
+
+        :param theta: \
+            The model parameters as a 1D ``numpy.ndarray``.
+
+        :returns: \
+            The negative prior log-probability value.
+        """
+        return -self(theta)
+
+    def cost_gradient(self, theta: ndarray) -> ndarray:
+        """
+        Returns the gradient of the 'cost', equal to the negative prior log-probability,
+        with respect to the model parameters.
+
+        :param theta: \
+            The model parameters as a 1D ``numpy.ndarray``.
+
+        :returns: \
+            The gradient of the negative prior log-probability value.
+        """
+        return -self.gradient(theta)
+
+    def sample(self) -> ndarray:
+        """
+        Draws a sample from the prior.
+
+        :returns: \
+            A single sample from the prior distribution as a 1D ``numpy.ndarray``.
+        """
+        raise NotImplementedError(
+            f"""\n
+            \r[ {self.__class__.__name__} error ]
+            \r>> 'sample' is an optional method for classes inheriting from
+            \r>> 'BasePrior', and has not been implemented for '{self.__class__.__name__}'.
+            """
+        )
+
+
+class JointPrior(BasePrior):
     """
     A class which combines multiple prior distribution objects into a single
     joint-prior distribution object.
@@ -22,12 +121,13 @@ class JointPrior:
         The total number of model variables.
     """
 
-    def __init__(self, components, n_variables):
+    def __init__(self, components: list[BasePrior], n_variables: int):
         if not all(isinstance(c, BasePrior) for c in components):
             raise TypeError(
-                """
-                All objects contained in the 'components' argument must be instances
-                of a subclass of BasePrior (e.g. GaussianPrior, UniformPrior)
+                """\n
+                \r[ JointPrior error ]
+                \r>> The sequence of prior objects passed to the 'components' argument 
+                \r>> of 'JointPrior' must be instances of a subclass of 'BasePrior'.
                 """
             )
 
@@ -45,24 +145,31 @@ class JointPrior:
         for var in chain(*[c.variables for c in self.components]):
             if var in self.prior_variables:
                 raise ValueError(
-                    f"Variable index '{var}' appears more than once in prior components"
+                    f"""\n
+                    \r[ JointPrior error ]
+                    \r>> Variable index '{var}' appears more than once in the prior
+                    \r>> objects passed to the 'components' argument of 'JointPrior'.
+                    """
                 )
             self.prior_variables.append(var)
 
         if len(self.prior_variables) != n_variables:
             raise ValueError(
-                f"""
-                The total number of variables specified across the various prior
-                components ({len(self.prior_variables)}) does not match the number specified in
-                the 'n_variables' argument ({n_variables}).
+                f"""\n
+                \r[ JointPrior error ]
+                \r>> The total number of variables specified across the various prior
+                \r>> components ({len(self.prior_variables)}) does not match the number
+                \r>> specified in the 'n_variables' argument ({n_variables}).
                 """
             )
 
         if not all(0 <= i < n_variables for i in self.prior_variables):
             raise ValueError(
-                """
-                All variable indices given to the prior components must have values
-                in the range [0, n_variables-1].
+                """\n
+                \r[ JointPrior error ]
+                \r>> All variable indices specified across the various prior
+                \r>> objects passed to the 'components' argument of 'JointPrior'
+                \r>> must have values in the range [0, n_variables - 1].
                 """
             )
 
@@ -75,7 +182,7 @@ class JointPrior:
         )
         self.bounds = [v[0] for v in both]
 
-    def __call__(self, theta):
+    def __call__(self, theta: ndarray) -> float:
         """
         Returns the joint-prior log-probability value, calculated as the sum
         of the log-probabilities from each prior component for the provided
@@ -89,7 +196,7 @@ class JointPrior:
         """
         return sum(c(theta) for c in self.components)
 
-    def gradient(self, theta):
+    def gradient(self, theta: ndarray) -> ndarray:
         """
         Returns the gradient of the prior log-probability with respect to the model
         parameters.
@@ -105,7 +212,7 @@ class JointPrior:
             grad[c.variables] = c.gradient(theta)
         return grad
 
-    def sample(self):
+    def sample(self) -> ndarray:
         """
         Draws a sample from the prior.
 
@@ -118,77 +225,35 @@ class JointPrior:
         return sample
 
 
-class BasePrior:
-    @staticmethod
-    def check_variables(variable_inds: Union[int, Iterable[int]], n_vars: int):
-        if not isinstance(variable_inds, (int, Iterable)):
-            raise TypeError("'variable_inds' must be an integer or list of integers")
-
-        if isinstance(variable_inds, int):
-            variable_inds = [variable_inds]
-
-        if not all(isinstance(p, int) for p in variable_inds):
-            raise TypeError("'variable_inds' must be an integer or list of integers")
-
-        if n_vars != len(variable_inds):
-            raise ValueError(
-                """
-                The total number of variables specified via the 'variable_indices' argument is
-                inconsistent with the number specified by the other arguments.
-                """
-            )
-
-        if len(variable_inds) != len(set(variable_inds)):
-            raise ValueError(
-                """
-                All integers given via the 'variable_indices' must be unique.
-                Two or more of the given integers are duplicates.
-                """
-            )
-
-        return variable_inds
-
-
 class GaussianPrior(BasePrior):
     """
     A class for generating a Gaussian prior for one or more of the model variables.
 
     :param mean: \
-        A list specifying the means of the Gaussian priors on each of the variables specified
-        in the ``variable_indices`` argument.
+        The means of the Gaussian priors on each of the variables specified
+        in the ``variable_indices`` argument as a 1D ``numpy.ndarray``.
 
     :param sigma: \
-        A list specifying the standard deviations of the Gaussian priors on each of the
-        variables specified in the ``variable_indices`` argument.
+        The standard deviations of the Gaussian priors on each of the variables
+        specified in the ``variable_indices`` argument as a 1D ``numpy.ndarray``.
 
     :param variable_indices: \
         A list of integers specifying the indices of the variables to which the prior will apply.
     """
 
-    def __init__(self, mean, sigma, variable_indices):
-        self.mean = array(mean, dtype=float64).squeeze()
-        self.sigma = array(sigma, dtype=float64).squeeze()
-
-        # if parameters were passed as floats, convert from 0D to 1D arrays
-        if self.mean.ndim == 0:
-            self.mean = self.mean.reshape([1])
-        if self.sigma.ndim == 0:
-            self.sigma = self.sigma.reshape([1])
+    def __init__(self, mean: ndarray, sigma: ndarray, variable_indices: list[int]):
+        self.mean, self.sigma = validate_prior_parameters(
+            class_name="GaussianPrior",
+            params=[("mean", mean), ("sigma", sigma)],
+            require_positive={"sigma"},
+        )
 
         self.n_params = self.mean.size
-
-        if self.mean.size != self.sigma.size:
-            raise ValueError(
-                "mean and sigma arguments must have the same number of elements"
-            )
-
-        if self.mean.ndim > 1 or self.sigma.ndim > 1:
-            raise ValueError("mean and sigma arguments must be 1D arrays")
-
-        if not (self.sigma > 0.0).all():
-            raise ValueError('All values of "sigma" must be greater than zero')
-
-        self.variables = self.check_variables(variable_indices, self.n_params)
+        self.variables = self.validate_variable_indices(
+            variable_inds=variable_indices,
+            n_parameters=self.n_params,
+            class_name="GaussianPrior",
+        )
 
         # pre-calculate some quantities as an optimisation
         self.inv_sigma = 1.0 / self.sigma
@@ -196,7 +261,7 @@ class GaussianPrior(BasePrior):
         self.normalisation = -log(self.sigma).sum() - 0.5 * log(2 * pi) * self.n_params
         self.bounds = [(None, None)] * self.n_params
 
-    def __call__(self, theta):
+    def __call__(self, theta: ndarray) -> float:
         """
         Returns the prior log-probability value for the provided set of model parameters.
 
@@ -209,7 +274,7 @@ class GaussianPrior(BasePrior):
         z = (self.mean - theta[self.variables]) * self.inv_sigma
         return -0.5 * (z**2).sum() + self.normalisation
 
-    def gradient(self, theta):
+    def gradient(self, theta: ndarray) -> ndarray:
         """
         Returns the gradient of the prior log-probability with respect to the model
         parameters.
@@ -222,7 +287,7 @@ class GaussianPrior(BasePrior):
         """
         return (self.mean - theta[self.variables]) * self.inv_sigma_sqr
 
-    def sample(self):
+    def sample(self) -> ndarray:
         """
         Draws a sample from the prior.
 
@@ -251,26 +316,26 @@ class ExponentialPrior(BasePrior):
     A class for generating an exponential prior for one or more of the model variables.
 
     :param beta: \
-        A list specifying the 'beta' parameter value of the exponential priors on each of the
-        variables specified in the ``variable_indices`` argument.
+        The 'beta' parameter values of the exponential priors on each of the variables
+        specified in the ``variable_indices`` argument as a 1D ``numpy.ndarray``.
 
     :param variable_indices: \
         A list of integers specifying the indices of the variables to which the prior will apply.
     """
 
-    def __init__(self, beta, variable_indices):
-        self.beta = array(beta, dtype=float64).squeeze()
-        if self.beta.ndim == 0:
-            self.beta = self.beta.reshape([1])
-        self.n_params = self.beta.size
-
-        if self.beta.ndim > 1:
-            raise ValueError("beta argument must be a 1D array")
-
-        if not (self.beta > 0.0).all():
-            raise ValueError('All values of "beta" must be greater than zero')
+    def __init__(self, beta: ndarray, variable_indices: list[int]):
+        (self.beta,) = validate_prior_parameters(
+            class_name="ExponentialPrior",
+            params=[("beta", beta)],
+            require_positive={"beta"},
+        )
 
-        self.variables = self.check_variables(variable_indices, self.n_params)
+        self.n_params = self.beta.size
+        self.variables = self.validate_variable_indices(
+            variable_inds=variable_indices,
+            n_parameters=self.n_params,
+            class_name="ExponentialPrior",
+        )
 
         # pre-calculate some quantities as an optimisation
         self.lam = 1.0 / self.beta
@@ -278,7 +343,7 @@ class ExponentialPrior(BasePrior):
         self.zeros = zeros(self.n_params)
         self.bounds = [(0.0, None)] * self.n_params
 
-    def __call__(self, theta):
+    def __call__(self, theta: ndarray) -> float:
         """
         Returns the prior log-probability value for the provided set of model parameters.
 
@@ -292,7 +357,7 @@ class ExponentialPrior(BasePrior):
             return -1e100
         return -(self.lam * theta[self.variables]).sum() + self.normalisation
 
-    def gradient(self, theta):
+    def gradient(self, theta: ndarray) -> ndarray:
         """
         Returns the gradient of the prior log-probability with respect to the model
         parameters.
@@ -305,7 +370,7 @@ class ExponentialPrior(BasePrior):
         """
         return where(theta[self.variables] >= 0.0, -self.lam, self.zeros)
 
-    def sample(self):
+    def sample(self) -> ndarray:
         """
         Draws a sample from the prior.
 
@@ -315,7 +380,7 @@ class ExponentialPrior(BasePrior):
         return exponential(scale=self.beta)
 
     @classmethod
-    def combine(cls, priors):
+    def combine(cls, priors: list[BasePrior]):
         if not all(isinstance(p, cls) for p in priors):
             raise ValueError(f"All prior objects being combined must be of type {cls}")
 
@@ -332,48 +397,44 @@ class UniformPrior(BasePrior):
     A class for generating a uniform prior for one or more of the model variables.
 
     :param lower: \
-        A list specifying the lower bound of the uniform priors on each of the variables
-        specified in the ``variable_indices`` argument.
+        The lower bound of the uniform priors on each of the variables
+        specified in the ``variable_indices`` argument as a 1D ``numpy.ndarray``.
 
     :param upper: \
-        A list specifying the upper bound of the uniform priors on each of the variables
-        specified in the ``variable_indices`` argument.
+        The upper bound of the uniform priors on each of the variables
+        specified in the ``variable_indices`` argument as a 1D ``numpy.ndarray``.
 
     :param variable_indices: \
         A list of integers specifying the indices of the variables to which the prior will apply.
     """
 
-    def __init__(self, lower, upper, variable_indices):
-        self.lower = array(lower).squeeze()
-        self.upper = array(upper).squeeze()
-
-        # if parameters were passed as floats, convert from 0D to 1D arrays
-        self.lower = self.lower.reshape([1]) if self.lower.ndim == 0 else self.lower
-        self.upper = self.upper.reshape([1]) if self.upper.ndim == 0 else self.upper
+    def __init__(self, lower: ndarray, upper: ndarray, variable_indices: list[int]):
+        self.lower, self.upper = validate_prior_parameters(
+            class_name="UniformPrior", params=[("lower", lower), ("upper", upper)]
+        )
 
         self.n_params = self.lower.size
         self.grad = zeros(self.n_params)
 
-        if self.lower.size != self.upper.size:
-            raise ValueError(
-                """'lower' and 'upper' arguments must have the same number of elements"""
-            )
-
-        if self.lower.ndim > 1 or self.upper.ndim > 1:
-            raise ValueError("'lower' and 'upper' arguments must be 1D arrays")
-
         if (self.upper <= self.lower).any():
             raise ValueError(
-                "All values in 'lower' must be less than the corresponding values in 'upper'"
+                """\n
+                \r[ UniformPrior error ]
+                \r>> All values in 'lower' must be less than the corresponding values in 'upper'
+                """
             )
 
-        self.variables = self.check_variables(variable_indices, self.n_params)
+        self.variables = self.validate_variable_indices(
+            variable_inds=variable_indices,
+            n_parameters=self.n_params,
+            class_name="UniformPrior",
+        )
 
         # pre-calculate some quantities as an optimisation
         self.normalisation = -log(self.upper - self.lower).sum()
         self.bounds = [(lo, up) for lo, up in zip(self.lower, self.upper)]
 
-    def __call__(self, theta):
+    def __call__(self, theta: ndarray) -> float:
         """
         Returns the prior log-probability value for the provided set of model parameters.
 
@@ -389,7 +450,7 @@ class UniformPrior(BasePrior):
             return self.normalisation
         return -1e100
 
-    def gradient(self, theta):
+    def gradient(self, theta: ndarray) -> ndarray:
         """
         Returns the gradient of the prior log-probability with respect to the model
         parameters.
@@ -402,7 +463,7 @@ class UniformPrior(BasePrior):
         """
         return self.grad
 
-    def sample(self):
+    def sample(self) -> ndarray:
         """
         Draws a sample from the prior.
 
@@ -424,3 +485,77 @@ class UniformPrior(BasePrior):
         upper = concatenate([p.upper for p in priors])
 
         return cls(lower=lower, upper=upper, variable_indices=variables)
+
+
+def validate_prior_parameters(
+    class_name: str, params: list[tuple], require_positive: set[str] = frozenset()
+) -> list[ndarray]:
+    validated_params = []
+    for param_name, param in params:
+        if attempt_array_conversion(param):
+            param = atleast_1d(param).astype(float)
+
+        if not isinstance(param, ndarray):
+            raise TypeError(
+                f"""\n
+                \r[ {class_name} error ]
+                \r>> Argument '{param_name}' should be an instance of a numpy.ndarray,
+                \r>> but instead has type:
+                \r>> {type(param)}
+                """
+            )
+
+        if param.ndim != 1:
+            raise ValueError(
+                f"""\n
+                \r[ {class_name} error ]
+                \r>> Argument '{param_name}' should be a 1D numpy.ndarray, 
+                \r>> but has {param.ndim} dimensions and shape {param.shape}.
+                """
+            )
+
+        if not isfinite(param).all():
+            raise ValueError(
+                f"""\n
+                \r[ {class_name} error ]
+                \r>> Argument '{param_name}' contains non-finite values.
+                """
+            )
+
+        if param_name in require_positive:
+            if not (param > 0.0).all():
+                raise ValueError(
+                    f"""\n
+                    \r[ {class_name} error ]
+                    \r>> All values given in '{param_name}' must be greater than zero.
+                    """
+                )
+
+        validated_params.append(param)
+
+    # check all inputs are the same size by collecting their sizes in a set
+    if len({param.size for param in validated_params}) != 1:
+        raise ValueError(
+            f"""\n
+            \r[ {class_name} error ]
+            \r>> Arguments
+            \r>> {[param_name for param_name, _ in params]}
+            \r>> must all be arrays of equal size, but instead have sizes
+            \r>> {[param.size for param in validated_params]}
+            \r>> respectively.
+            """
+        )
+
+    return validated_params
+
+
+def attempt_array_conversion(param) -> bool:
+    # if input is a zero-dimensional array, we need to convert to 1D
+    zero_dim_array = isinstance(param, ndarray) and param.ndim == 0
+    # if the input is a float or an int, also convert to a 1D array
+    valid_number = isinstance(param, (int, float))
+    # if the input is a list or tuple containing only floats and ints, also convert
+    valid_sequence = isinstance(param, (list, tuple)) and all(
+        isinstance(v, (int, float)) for v in param
+    )
+    return zero_dim_array or valid_sequence or valid_number

{inference_tools-0.13.3.dist-info → inference_tools-0.13.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: inference-tools
-Version: 0.13.3
+Version: 0.13.4
 Summary: A collection of python tools for Bayesian data analysis
 Author-email: Chris Bowman <chris.bowman.physics@gmail.com>
 License: MIT License
@@ -33,15 +33,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy >=1.20
-Requires-Dist: scipy >=1.6.3
-Requires-Dist: matplotlib >=3.4.2
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.6.3
+Requires-Dist: matplotlib>=3.4.2
 Provides-Extra: tests
-Requires-Dist: pytest >=3.3.0 ; extra == 'tests'
-Requires-Dist: pytest-cov >=3.0.0 ; extra == 'tests'
-Requires-Dist: pyqt5 >=5.15 ; extra == 'tests'
-Requires-Dist: hypothesis >=6.24 ; extra == 'tests'
-Requires-Dist: freezegun >=1.1.0 ; extra == 'tests'
+Requires-Dist: pytest>=3.3.0; extra == "tests"
+Requires-Dist: pytest-cov>=3.0.0; extra == "tests"
+Requires-Dist: pyqt5>=5.15; extra == "tests"
+Requires-Dist: hypothesis>=6.24; extra == "tests"
+Requires-Dist: freezegun>=1.1.0; extra == "tests"
 
 # inference-tools
 

inference_tools-0.13.4.dist-info/RECORD

@@ -0,0 +1,33 @@
+inference/__init__.py,sha256=Wheq9bSUF5Y_jAc_w_Avi4WW2kphDK0qHGM6FsIKSxY,275
+inference/_version.py,sha256=dhPsd2j9Al5Z6JN-zXmB6-Uti2Ily2tvtEtKPTNHaCQ,413
+inference/likelihoods.py,sha256=fS_k3mRr7bv6kgDt29u_OB6emU-ARVZktf7j-eXA-2U,10008
+inference/plotting.py,sha256=U1M_F5I-UMtfHiaN1YihcxYq5gg_2MNyPm7MxF1LecY,19747
+inference/posterior.py,sha256=ptPZgzT--ehbpu57nW9GmFuyovFOSmw56HWfuC-8GGA,3584
+inference/priors.py,sha256=67cgKw7jDurda9UByFJ7jOoEJH1FyZDOHC9-nvr0nWY,19352
+inference/approx/__init__.py,sha256=b8xCdshVeGHyao6-P0038QB71WOMLrcYXCOYiYjK7Tk,132
+inference/approx/conditional.py,sha256=IeUismbo25qa1BUIqsZ2noum9_mLXNaORsg57abxBec,9515
+inference/gp/__init__.py,sha256=R4iPgf8TdunkOv_VLwue7Fz3AjGWDTBop58nCmbmMQ0,801
+inference/gp/acquisition.py,sha256=Yr1dshTYwkMIrKYPSwDZDusXXNsOpobrxaympJc5q3g,8158
+inference/gp/covariance.py,sha256=DVN8lAtDjCWXYSsQwhQZxV6RJ8KZeo72unOCjHhTGg0,25919
+inference/gp/inversion.py,sha256=AP5dprY8hibWgtCyQytJdErE1iVp_i7e6y9FxyGtKHo,9917
+inference/gp/mean.py,sha256=6EJ_OxBi98netl9Rp2Ij7eXdWndGVS-X_g5VWnWMVkk,4084
+inference/gp/optimisation.py,sha256=sPhakklWIgg1yEUhUzA-m5vl0kVPvHdcgnQ0OAGT8qs,11763
+inference/gp/regression.py,sha256=10TzqVeUzUkuw8-Cbe4LbxevByTi5iE5QDdRClN7Nhk,25677
+inference/mcmc/__init__.py,sha256=IsEhVSIpZCDNIqgSq_21M6DH6x8F1jJbYWM0e3S3QG4,445
+inference/mcmc/base.py,sha256=cEh1LPmKd6JMop8EcuH3dvAeJYei88pcPTw1xe7tGKY,10496
+inference/mcmc/ensemble.py,sha256=s9Xspq5r360_XmpRHCplN5cscD60UoYXlYqx3yVEhsM,15528
+inference/mcmc/gibbs.py,sha256=9US0VqLEI_f70vrHg0sFZQneJMyjm8BF_l_0bD-ZqKI,24190
+inference/mcmc/hmc.py,sha256=rfTqvD3aZqqHXcM17_Yj8U_2mt2eTQ_BI6hOeFqycoo,19420
+inference/mcmc/parallel.py,sha256=HRK1Ka02iO5Q6m3282lqZeAlCZPXHIglC8RAlDE6Xd4,14082
+inference/mcmc/pca.py,sha256=-XVs25hH8FRA6XY4xWEK1cUZ8oDDllW7t_vlK6FU7Gs,10739
+inference/mcmc/utilities.py,sha256=YjpK3FvV0Q98jLusrZrvGck-bjm6uZZ1U7HHH3aly8g,6048
+inference/pdf/__init__.py,sha256=gVmQ1HLTab6_oWMQN26A1r7PkqbApaJmBK-c7TIFxjY,270
+inference/pdf/base.py,sha256=Zj5mfFmDqTe5cFz0biBxcvEaxdOUC-SsOUjebUEX7HM,5442
+inference/pdf/hdi.py,sha256=j_W4kv70weXR7C2ltTHR6OUNkAK-kLQhnrnpPrjiLxQ,4282
+inference/pdf/kde.py,sha256=KSl8y---602MlxoSVH8VknNQYZ2KAOTky50QU3jRw28,12999
+inference/pdf/unimodal.py,sha256=9S05c0hq_rF-MLoDJgUmaJKRdcP8F9_Idj7Ncb6m9q0,6218
+inference_tools-0.13.4.dist-info/LICENSE,sha256=Y0-EfO5pdxf6d0J6Er13ZSWiPZ2o6kHvM37eRgnJdww,1069
+inference_tools-0.13.4.dist-info/METADATA,sha256=l2x2GqQSfSrgrLeZLLqQ-LX00bxB1CKjj3AxHvTJ7F8,5378
+inference_tools-0.13.4.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+inference_tools-0.13.4.dist-info/top_level.txt,sha256=I7bsb71rLtH3yvVH_HSLXUosY2AwCxEG3vctNsEhbEM,10
+inference_tools-0.13.4.dist-info/RECORD,,

{inference_tools-0.13.3.dist-info → inference_tools-0.13.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.1.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

inference_tools-0.13.3.dist-info/RECORD

@@ -1,33 +0,0 @@
-inference/__init__.py,sha256=Wheq9bSUF5Y_jAc_w_Avi4WW2kphDK0qHGM6FsIKSxY,275
-inference/_version.py,sha256=VXQPyzbmOGe0nuuEEus9EQY40THABR5BB9WWse8Z8LI,413
-inference/likelihoods.py,sha256=WELpZ6kHcm8ygmuTo4bUpOxhcbs4dxEhX94aShbDgxA,9688
-inference/plotting.py,sha256=U1M_F5I-UMtfHiaN1YihcxYq5gg_2MNyPm7MxF1LecY,19747
-inference/posterior.py,sha256=ueyfmfmHjSh26iR58kf07IdbOiC5tSEUe0VlOWSN9bo,3481
-inference/priors.py,sha256=RcGkY1e04tA_CkzSzD1ixe-OfPJlrJ4-6QOg4agfDls,14753
-inference/approx/__init__.py,sha256=b8xCdshVeGHyao6-P0038QB71WOMLrcYXCOYiYjK7Tk,132
-inference/approx/conditional.py,sha256=d9NfUCa8X6O0UP840LWzKdW6ms4yk1Li1hN_ptSQ4-k,9448
-inference/gp/__init__.py,sha256=R4iPgf8TdunkOv_VLwue7Fz3AjGWDTBop58nCmbmMQ0,801
-inference/gp/acquisition.py,sha256=Yr1dshTYwkMIrKYPSwDZDusXXNsOpobrxaympJc5q3g,8158
-inference/gp/covariance.py,sha256=myHUAeWF-2-S1b8itABSkbDBoTrhdG9xDDjmKLEVGJg,25472
-inference/gp/inversion.py,sha256=AP5dprY8hibWgtCyQytJdErE1iVp_i7e6y9FxyGtKHo,9917
-inference/gp/mean.py,sha256=ZL9-U6mgkuDhigmGFazJylSEivyu9prP6d4hY6j3ayU,4039
-inference/gp/optimisation.py,sha256=DwSZTargltFEG_rubtcwAp7XzR-58wCxHaqbPEI4O-8,11490
-inference/gp/regression.py,sha256=QilRzPd1JHZKTZsWJoTifIq8E-ZrOtMGMvsTogLyV_U,25563
-inference/mcmc/__init__.py,sha256=IsEhVSIpZCDNIqgSq_21M6DH6x8F1jJbYWM0e3S3QG4,445
-inference/mcmc/base.py,sha256=qEgNKQ3uL8icH9GRgvGjglpBezLIzs1kHC5z27cwdCc,10399
-inference/mcmc/ensemble.py,sha256=s9Xspq5r360_XmpRHCplN5cscD60UoYXlYqx3yVEhsM,15528
-inference/mcmc/gibbs.py,sha256=7v9OoFY5SBAE2RXc_3Gq-riFd-7jq2vZULuewt5p83c,24159
-inference/mcmc/hmc.py,sha256=uvTgpUBucqDNUgwuzKs_leRmBSvFtMLzfLmZS9K4lD4,19334
-inference/mcmc/parallel.py,sha256=HRK1Ka02iO5Q6m3282lqZeAlCZPXHIglC8RAlDE6Xd4,14082
-inference/mcmc/pca.py,sha256=5KtNtMyoVLnsZmbu-n6T80_gbEWuhBg_JK-KUs5Qktk,10699
-inference/mcmc/utilities.py,sha256=guRahwzregpKt1cP0Pw9WWDBpMEalhAabQ8Tjo3G68M,6005
-inference/pdf/__init__.py,sha256=gVmQ1HLTab6_oWMQN26A1r7PkqbApaJmBK-c7TIFxjY,270
-inference/pdf/base.py,sha256=Zj5mfFmDqTe5cFz0biBxcvEaxdOUC-SsOUjebUEX7HM,5442
-inference/pdf/hdi.py,sha256=j_W4kv70weXR7C2ltTHR6OUNkAK-kLQhnrnpPrjiLxQ,4282
-inference/pdf/kde.py,sha256=EWOBuBpt3mkZ-hzEEBmutNQBy5vc9ipBZ0KEjqpf-AE,12966
-inference/pdf/unimodal.py,sha256=Fza18CRpAqcuHgwJFsnvOuXoymbah_Rcmo4jdcMe_xo,5504
-inference_tools-0.13.3.dist-info/LICENSE,sha256=Y0-EfO5pdxf6d0J6Er13ZSWiPZ2o6kHvM37eRgnJdww,1069
-inference_tools-0.13.3.dist-info/METADATA,sha256=4YgiAy5YnqKdAfRmMQXYNLf4rNYHjsNz-jOh_4rMMYE,5391
-inference_tools-0.13.3.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
-inference_tools-0.13.3.dist-info/top_level.txt,sha256=I7bsb71rLtH3yvVH_HSLXUosY2AwCxEG3vctNsEhbEM,10
-inference_tools-0.13.3.dist-info/RECORD,,