Fixed typos

Author: fonnesbeck

pymc3/distributions/continuous.py

@@ -227,8 +227,8 @@ def __init__(self, *args, **kwargs):
         self.tau, self.sd = get_tau_sd(tau=tau, sd=sd)
         self.variance = 1. / self.tau
 
-        assert_negative_support_support(sd, 'sd', 'Normal')
-        assert_negative_support_support(tau, 'tau', 'Normal')
+        assert_negative_support(sd, 'sd', 'Normal')
+        assert_negative_support(tau, 'tau', 'Normal')
 
         super(Normal, self).__init__(**kwargs)
 
@@ -277,8 +277,8 @@ def __init__(self, sd=None, tau=None, *args, **kwargs):
         self.mean = tt.sqrt(2 / (np.pi * self.tau))
         self.variance = (1. - 2 / np.pi) / self.tau
 
-        assert_negative_support_support(tau, 'tau', 'HalfNormal')
-        assert_negative_support_support(sd, 'sd', 'HalfNormal')
+        assert_negative_support(tau, 'tau', 'HalfNormal')
+        assert_negative_support(sd, 'sd', 'HalfNormal')
 
     def random(self, point=None, size=None, repeat=None):
         sd = draw_values([self.sd], point=point)
@@ -359,9 +359,9 @@ def __init__(self, mu=None, lam=None, phi=None, alpha=0., *args, **kwargs):
                                - 1.5 * self.mu / self.lam) + alpha
         self.variance = (self.mu**3) / self.lam
 
-        assert_negative_support_support(phi, 'phi', 'Wald')
-        assert_negative_support_support(mu, 'mu', 'Wald')
-        assert_negative_support_support(lam, 'lam', 'Wald')
+        assert_negative_support(phi, 'phi', 'Wald')
+        assert_negative_support(mu, 'mu', 'Wald')
+        assert_negative_support(lam, 'lam', 'Wald')
 
     def get_mu_lam_phi(self, mu, lam, phi):
         if mu is None:
@@ -465,8 +465,8 @@ def __init__(self, alpha=None, beta=None, mu=None, sd=None,
         self.variance = alpha * beta / (
             (alpha + beta)**2 * (alpha + beta + 1))
 
-        assert_negative_support_support(alpha, 'alpha', 'Beta')
-        assert_negative_support_support(beta, 'beta', 'Beta')
+        assert_negative_support(alpha, 'alpha', 'Beta')
+        assert_negative_support(beta, 'beta', 'Beta')
 
     def get_alpha_beta(self, alpha=None, beta=None, mu=None, sd=None):
         if (alpha is not None) and (beta is not None):
@@ -527,7 +527,7 @@ def __init__(self, lam, *args, **kwargs):
 
         self.variance = lam**-2
 
-        assert_negative_support_support(lam, 'lam', 'Exponential')
+        assert_negative_support(lam, 'lam', 'Exponential')
 
     def random(self, point=None, size=None, repeat=None):
         lam = draw_values([self.lam], point=point)
@@ -570,7 +570,7 @@ def __init__(self, mu, b, *args, **kwargs):
 
         self.variance = 2 * b**2
 
-        assert_negative_support_support(b, 'b', 'Laplace')
+        assert_negative_support(b, 'b', 'Laplace')
 
     def random(self, point=None, size=None, repeat=None):
         mu, b = draw_values([self.mu, self.b], point=point)
@@ -625,8 +625,8 @@ def __init__(self, mu=0, sd=None, tau=None, *args, **kwargs):
         self.mode = tt.exp(mu - 1. / self.tau)
         self.variance = (tt.exp(1. / self.tau) - 1) * tt.exp(2 * mu + 1. / self.tau)
 
-        assert_negative_support_support(tau, 'tau', 'Lognormal')
-        assert_negative_support_support(sd, 'sd', 'Lognormal')
+        assert_negative_support(tau, 'tau', 'Lognormal')
+        assert_negative_support(sd, 'sd', 'Lognormal')
 
     def _random(self, mu, tau, size=None):
         samples = np.random.normal(size=size)
@@ -686,8 +686,8 @@ def __init__(self, nu, mu=0, lam=None, sd=None, *args, **kwargs):
                                   (1 / self.lam) * (nu / (nu - 2)),
                                   np.inf)
 
-        assert_negative_support_support(lam, 'lam (sd)', 'StudentT')
-        assert_negative_support_support(nu, 'nu', 'StudentT')
+        assert_negative_support(lam, 'lam (sd)', 'StudentT')
+        assert_negative_support(nu, 'nu', 'StudentT')
 
     def random(self, point=None, size=None, repeat=None):
         nu, mu, lam = draw_values([self.nu, self.mu, self.lam],
@@ -747,8 +747,8 @@ def __init__(self, alpha, m, *args, **kwargs):
             (alpha * m**2) / ((alpha - 2.) * (alpha - 1.)**2),
             np.inf)
 
-        assert_negative_support_support(alpha, 'alpha', 'Pareto')
-        assert_negative_support_support(m, 'm', 'Pareto')
+        assert_negative_support(alpha, 'alpha', 'Pareto')
+        assert_negative_support(m, 'm', 'Pareto')
 
 
     def _random(self, alpha, m, size=None):
@@ -801,7 +801,7 @@ def __init__(self, alpha, beta, *args, **kwargs):
         self.median = self.mode = self.alpha = alpha
         self.beta = beta
 
-        assert_negative_support_support(beta, 'beta', 'Cauchy')
+        assert_negative_support(beta, 'beta', 'Cauchy')
 
     def _random(self, alpha, beta, size=None):
         u = np.random.uniform(size=size)
@@ -849,7 +849,7 @@ def __init__(self, beta, *args, **kwargs):
         self.median = beta
         self.beta = beta
 
-        assert_negative_support_support(beta, 'beta', 'HalfCauchy')
+        assert_negative_support(beta, 'beta', 'HalfCauchy')
 
     def _random(self, beta, size=None):
         u = np.random.uniform(size=size)
@@ -917,8 +917,8 @@ def __init__(self, alpha=None, beta=None, mu=None, sd=None,
         self.mode = tt.maximum((alpha - 1) / beta, 0)
         self.variance = alpha / beta**2
 
-        assert_negative_support_support(alpha, 'alpha', 'Gamma')
-        assert_negative_support_support(beta, 'beta', 'Gamma')
+        assert_negative_support(alpha, 'alpha', 'Gamma')
+        assert_negative_support(beta, 'beta', 'Gamma')
 
     def get_alpha_beta(self, alpha=None, beta=None, mu=None, sd=None):
         if (alpha is not None) and (beta is not None):
@@ -986,8 +986,8 @@ def __init__(self, alpha, beta=1, *args, **kwargs):
         self.variance = tt.switch(tt.gt(alpha, 2),
                                   (beta**2) / (alpha * (alpha - 1.)**2),
                                   np.inf)
-        assert_negative_support_support(alpha, 'alpha', 'InverseGamma')
-        assert_negative_support_support(beta, 'beta', 'InverseGamma')
+        assert_negative_support(alpha, 'alpha', 'InverseGamma')
+        assert_negative_support(beta, 'beta', 'InverseGamma')
 
     def _calculate_mean(self):
         m = self.beta / (self.alpha - 1.)
@@ -1071,8 +1071,8 @@ def __init__(self, alpha, beta, *args, **kwargs):
         self.variance = (beta**2) * \
             tt.exp(gammaln(1 + 2. / alpha - self.mean**2))
 
-        assert_negative_support_support(alpha, 'alpha', 'Weibull')
-        assert_negative_support_support(beta, 'beta', 'Weibull')
+        assert_negative_support(alpha, 'alpha', 'Weibull')
+        assert_negative_support(beta, 'beta', 'Weibull')
 
     def random(self, point=None, size=None, repeat=None):
         alpha, beta = draw_values([self.alpha, self.beta],
@@ -1260,8 +1260,8 @@ def __init__(self, mu, sigma, nu, *args, **kwargs):
         self.mean = mu + nu
         self.variance = (sigma**2) + (nu**2)
 
-        assert_negative_support_support(sigma, 'sigma', 'ExGaussian')
-        assert_negative_support_support(nu, 'nu', 'ExGaussian')
+        assert_negative_support(sigma, 'sigma', 'ExGaussian')
+        assert_negative_support(nu, 'nu', 'ExGaussian')
 
     def random(self, point=None, size=None, repeat=None):
         mu, sigma, nu = draw_values([self.mu, self.sigma, self.nu],
@@ -1321,7 +1321,7 @@ def __init__(self, mu=0.0, kappa=None, transform='circular',
         if transform == 'circular':
             self.transform = transforms.Circular()
 
-        assert_negative_support_support(kappa, 'kappa', 'VonMises')
+        assert_negative_support(kappa, 'kappa', 'VonMises')
 
     def random(self, point=None, size=None, repeat=None):
         mu, kappa = draw_values([self.mu, self.kappa],
@@ -1378,8 +1378,8 @@ def __init__(self, mu=0.0, sd=None, tau=None, alpha=1,  *args, **kwargs):
         self.mean = mu + self.sd * (2 / np.pi)**0.5 * alpha / (1 + alpha**2)**0.5
         self.variance = self.sd**2 * (1 - (2 * alpha**2) / ((1 + alpha**2) * np.pi))
 
-        assert_negative_support_support(tau, 'tau', 'SkewNormal')
-        assert_negative_support_support(sd, 'sd', 'SkewNormal')
+        assert_negative_support(tau, 'tau', 'SkewNormal')
+        assert_negative_support(sd, 'sd', 'SkewNormal')
 
     def random(self, point=None, size=None, repeat=None):
         mu, tau, sd, alpha = draw_values(