Class qnormal_gen

hyperopt/rdists.py:180–221

Stats for Y = q * round(X / q) where X ~ N(mu, sigma)

class qnormal_gen:
    """Stats for Y = q * round(X / q) where X ~ N(mu, sigma)"""

    def __init__(self, mu, sigma, q):
        self.mu, self.sigma = list(map(float, (mu, sigma)))
        self.q = q
        # -- distfn for using the CDF
        self._norm_logcdf = scipy.stats.norm(loc=mu, scale=sigma).logcdf

    def in_domain(self, x):
        return np.isclose(x, safe_int_cast(np.round(old_div(x, self.q))) * self.q)

    def pmf(self, x):
        return np.exp(self.logpmf(x))

    def logpmf(self, x):
        x1 = np.atleast_1d(x)
        in_domain = self.in_domain(x1)
        rval = np.zeros_like(x1, dtype=float) - np.inf
        x_in_domain = x1[in_domain]

        ubound = x_in_domain + self.q * 0.5
        lbound = x_in_domain - self.q * 0.5
        # -- reflect intervals right of mu to other side
        #    for more accurate calculation
        flip = lbound > self.mu
        tmp = lbound[flip].copy()
        lbound[flip] = self.mu - (ubound[flip] - self.mu)
        ubound[flip] = self.mu - (tmp - self.mu)

        assert np.all(ubound > lbound)
        a = self._norm_logcdf(ubound)
        b = self._norm_logcdf(lbound)
        rval[in_domain] = a + np.log1p(-np.exp(b - a))
        if isinstance(x, np.ndarray):
            return rval
        return float(rval)

    def rvs(self, size=()):
        x = mtrand.normal(loc=self.mu, scale=self.sigma, size=size)
        rval = safe_int_cast(np.round(old_div(x, self.q))) * self.q
        return rval


class qlognormal_gen: