Add LogUniform distribution

Add an explicit LogUniform distribution class.

The interpretation of the distribution parameter is different from the existing `Uniform(a, b, log=True)`.

In PEtab v2, X ~ LogUniform(a, b) <=> ln(X) ~ Uniform(ln(a), ln(b)).

However, in PEtab v1, a `parameterScaleUniform` prior for a parameterScale=log parameter is interpreted as ln(X) ~ Uniform(a, b).

Author: dweindl

petab/v1/distributions.py

@@ -36,6 +36,7 @@
     "Normal",
     "Rayleigh",
     "Uniform",
+    "LogUniform",
 ]
 
 
@@ -382,6 +383,10 @@ class Uniform(Distribution):
         If ``False``, no transformation is applied.
         If a transformation is applied, the lower and upper bounds are the
         lower and upper bounds of the underlying uniform distribution.
+        Note that this differs from the usual definition of a log-uniform
+        distribution, where the logarithm of the variable is uniformly
+        distributed between the logarithms of the bounds (see also
+        :class:`LogUniform`).
     """
 
     def __init__(
@@ -411,6 +416,43 @@ def _ppf_untransformed_untruncated(self, q) -> np.ndarray | float:
         return uniform.ppf(q, loc=self._low, scale=self._high - self._low)
 
 
+class LogUniform(Distribution):
+    """A log-uniform or reciprocal distribution.
+
+    A random variable is log-uniformly distributed between ``low`` and ``high``
+    if its logarithm is uniformly distributed between ``log(low)`` and
+    ``log(high)``.
+
+    :param low: The lower bound of the distribution.
+    :param high: The upper bound of the distribution.
+    """
+
+    def __init__(
+        self,
+        low: float,
+        high: float,
+    ):
+        self._logbase = np.exp(1)
+        self._low = self._log(low)
+        self._high = self._log(high)
+        super().__init__(log=self._logbase)
+
+    def __repr__(self):
+        return self._repr({"low": self._low, "high": self._high})
+
+    def _sample(self, shape=None) -> np.ndarray | float:
+        return np.random.uniform(low=self._low, high=self._high, size=shape)
+
+    def _pdf_untransformed_untruncated(self, x) -> np.ndarray | float:
+        return uniform.pdf(x, loc=self._low, scale=self._high - self._low)
+
+    def _cdf_untransformed_untruncated(self, x) -> np.ndarray | float:
+        return uniform.cdf(x, loc=self._low, scale=self._high - self._low)
+
+    def _ppf_untransformed_untruncated(self, q) -> np.ndarray | float:
+        return uniform.ppf(q, loc=self._low, scale=self._high - self._low)
+
+
 class Laplace(Distribution):
     """A (log-)Laplace distribution.
 

petab/v2/core.py

@@ -201,7 +201,7 @@ class PriorDistribution(str, Enum):
     PriorDistribution.LAPLACE: Laplace,
     PriorDistribution.LOG_LAPLACE: Laplace,
     PriorDistribution.LOG_NORMAL: Normal,
-    PriorDistribution.LOG_UNIFORM: Uniform,
+    PriorDistribution.LOG_UNIFORM: LogUniform,
     PriorDistribution.NORMAL: Normal,
     PriorDistribution.RAYLEIGH: Rayleigh,
     PriorDistribution.UNIFORM: Uniform,
@@ -1060,7 +1060,15 @@ def prior_dist(self) -> Distribution:
             # `Uniform.__init__` does not accept the `trunc` parameter
             low = max(self.prior_parameters[0], self.lb)
             high = min(self.prior_parameters[1], self.ub)
-            return cls(low, high, log=log)
+            return cls(low, high)
+
+        if cls == LogUniform:
+            # Mind the different interpretation of distribution parameters for
+            #  Uniform(..., log=True) and LogUniform!!
+            # `LogUniform.__init__` does not accept the `trunc` parameter
+            low = max(self.prior_parameters[0], self.lb)
+            high = min(self.prior_parameters[1], self.ub)
+            return cls(low, high)
 
         return cls(*self.prior_parameters, log=log, trunc=[self.lb, self.ub])