Add lmoments

preliz/distributions/asymmetric_laplace.py

@@ -135,6 +135,18 @@ def skewness(self):
     def kurtosis(self):
         return ptd_kurtosis(self.mu, self.b, self.kappa)
 
+    def lmoment1(self):
+        return ptd_lmoment1(self.mu, self.b, self.kappa)
+
+    def lmoment2(self):
+        return ptd_lmoment2(self.mu, self.b, self.kappa)
+
+    def lmoment3(self):
+        return ptd_lmoment3(self.mu, self.b, self.kappa)
+
+    def lmoment4(self):
+        return ptd_lmoment4(self.mu, self.b, self.kappa)
+
     def rvs(self, size=None, random_state=None):
         random_state = np.random.default_rng(random_state)
         return ptd_rvs(self.mu, self.b, self.kappa, size=size, rng=random_state)
@@ -209,6 +221,26 @@ def ptd_kurtosis(mu, b, kappa):
     return ptd_asymmetriclaplace.kurtosis(mu, b, kappa)
 
 
+@pytensor_jit
+def ptd_lmoment1(mu, b, kappa):
+    return ptd_asymmetriclaplace.lmoment1(mu, b, kappa)
+
+
+@pytensor_jit
+def ptd_lmoment2(mu, b, kappa):
+    return ptd_asymmetriclaplace.lmoment2(mu, b, kappa)
+
+
+@pytensor_jit
+def ptd_lmoment3(mu, b, kappa):
+    return ptd_asymmetriclaplace.lmoment3(mu, b, kappa)
+
+
+@pytensor_jit
+def ptd_lmoment4(mu, b, kappa):
+    return ptd_asymmetriclaplace.lmoment4(mu, b, kappa)
+
+
 @pytensor_rng_jit
 def ptd_rvs(mu, b, kappa, size, rng):
     return ptd_asymmetriclaplace.rvs(mu, b, kappa, size=size, random_state=rng)

preliz/distributions/bernoulli.py

@@ -128,6 +128,18 @@ def skewness(self):
     def kurtosis(self):
         return ptd_kurtosis(self.p)
 
+    def lmoment1(self):
+        return ptd_lmoment1(self.p)
+
+    def lmoment2(self):
+        return ptd_lmoment2(self.p)
+
+    def lmoment3(self):
+        return ptd_lmoment3(self.p)
+
+    def lmoment4(self):
+        return ptd_lmoment4(self.p)
+
     def rvs(self, size=None, random_state=None):
         random_state = np.random.default_rng(random_state)
         return ptd_rvs(self.p, size=size, rng=random_state)
@@ -193,6 +205,26 @@ def ptd_kurtosis(p):
     return ptd_bernoulli.kurtosis(p)
 
 
+@pytensor_jit
+def ptd_lmoment1(p):
+    return ptd_bernoulli.lmoment1(p)
+
+
+@pytensor_jit
+def ptd_lmoment2(p):
+    return ptd_bernoulli.lmoment2(p)
+
+
+@pytensor_jit
+def ptd_lmoment3(p):
+    return ptd_bernoulli.lmoment3(p)
+
+
+@pytensor_jit
+def ptd_lmoment4(p):
+    return ptd_bernoulli.lmoment4(p)
+
+
 @pytensor_rng_jit
 def ptd_rvs(p, size, rng):
     return ptd_bernoulli.rvs(p, size=size, random_state=rng)

preliz/distributions/beta.py

@@ -199,6 +199,18 @@ def skewness(self):
     def kurtosis(self):
         return ptd_kurtosis(self.alpha, self.beta)
 
+    def lmoment1(self):
+        return ptd_lmoment1(self.alpha, self.beta)
+
+    def lmoment2(self):
+        return ptd_lmoment2(self.alpha, self.beta)
+
+    def lmoment3(self):
+        return ptd_lmoment3(self.alpha, self.beta)
+
+    def lmoment4(self):
+        return ptd_lmoment4(self.alpha, self.beta)
+
     def rvs(self, size=None, random_state=None):
         random_state = np.random.default_rng(random_state)
         return ptd_rvs(self.alpha, self.beta, size=size, rng=random_state)
@@ -289,6 +301,26 @@ def ptd_kurtosis(alpha, beta):
     return ptd_beta.kurtosis(alpha, beta)
 
 
+@pytensor_jit
+def ptd_lmoment1(alpha, beta):
+    return ptd_beta.lmoment1(alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment2(alpha, beta):
+    return ptd_beta.lmoment2(alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment3(alpha, beta):
+    return ptd_beta.lmoment3(alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment4(alpha, beta):
+    return ptd_beta.lmoment4(alpha, beta)
+
+
 @pytensor_rng_jit
 def ptd_rvs(alpha, beta, size, rng):
     return ptd_beta.rvs(alpha, beta, size=size, random_state=rng)

preliz/distributions/betabinomial.py

@@ -110,6 +110,18 @@ def skewness(self):
     def kurtosis(self):
         return ptd_kurtosis(self.n, self.alpha, self.beta)
 
+    def lmoment1(self):
+        return ptd_lmoment1(self.n, self.alpha, self.beta)
+
+    def lmoment2(self):
+        return ptd_lmoment2(self.n, self.alpha, self.beta)
+
+    def lmoment3(self):
+        return ptd_lmoment3(self.n, self.alpha, self.beta)
+
+    def lmoment4(self):
+        return ptd_lmoment4(self.n, self.alpha, self.beta)
+
     def rvs(self, size=None, random_state=None):
         random_state = np.random.default_rng(random_state)
         return ptd_rvs(self.n, self.alpha, self.beta, size=size, rng=random_state)
@@ -181,6 +193,26 @@ def ptd_kurtosis(n, alpha, beta):
     return ptd_betabinomial.kurtosis(n, alpha, beta)
 
 
+@pytensor_jit
+def ptd_lmoment1(n, alpha, beta):
+    return ptd_betabinomial.lmoment1(n, alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment2(n, alpha, beta):
+    return ptd_betabinomial.lmoment2(n, alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment3(n, alpha, beta):
+    return ptd_betabinomial.lmoment3(n, alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment4(n, alpha, beta):
+    return ptd_betabinomial.lmoment4(n, alpha, beta)
+
+
 @pytensor_rng_jit
 def ptd_rvs(n, alpha, beta, size, rng):
     return ptd_betabinomial.rvs(n, alpha, beta, size=size, random_state=rng)

preliz/distributions/betascaled.py

@@ -159,6 +159,18 @@ def skewness(self):
     def kurtosis(self):
         return ptd_kurtosis(self.alpha, self.beta, self.lower, self.upper)
 
+    def lmoment1(self):
+        return ptd_lmoment1(self.alpha, self.beta, self.lower, self.upper)
+
+    def lmoment2(self):
+        return ptd_lmoment2(self.alpha, self.beta, self.lower, self.upper)
+
+    def lmoment3(self):
+        return ptd_lmoment3(self.alpha, self.beta, self.lower, self.upper)
+
+    def lmoment4(self):
+        return ptd_lmoment4(self.alpha, self.beta, self.lower, self.upper)
+
     def rvs(self, size=None, random_state=None):
         random_state = np.random.default_rng(random_state)
         return ptd_rvs(self.alpha, self.beta, self.lower, self.upper, size=size, rng=random_state)
@@ -249,6 +261,26 @@ def ptd_kurtosis(alpha, beta, lower, upper):
     return ptd_betascaled.kurtosis(alpha, beta, lower, upper)
 
 
+@pytensor_jit
+def ptd_lmoment1(alpha, beta, lower, upper):
+    return ptd_betascaled.lmoment1(alpha, beta, lower, upper)
+
+
+@pytensor_jit
+def ptd_lmoment2(alpha, beta, lower, upper):
+    return ptd_betascaled.lmoment2(alpha, beta, lower, upper)
+
+
+@pytensor_jit
+def ptd_lmoment3(alpha, beta, lower, upper):
+    return ptd_betascaled.lmoment3(alpha, beta, lower, upper)
+
+
+@pytensor_jit
+def ptd_lmoment4(alpha, beta, lower, upper):
+    return ptd_betascaled.lmoment4(alpha, beta, lower, upper)
+
+
 @pytensor_rng_jit
 def ptd_rvs(alpha, beta, lower, upper, size, rng):
     return ptd_betascaled.rvs(alpha, beta, lower, upper, size=size, random_state=rng)

preliz/distributions/binomial.py

@@ -113,6 +113,18 @@ def skewness(self):
     def kurtosis(self):
         return ptd_kurtosis(self.n, self.p)
 
+    def lmoment1(self):
+        return ptd_lmoment1(self.n, self.p)
+
+    def lmoment2(self):
+        return ptd_lmoment2(self.n, self.p)
+
+    def lmoment3(self):
+        return ptd_lmoment3(self.n, self.p)
+
+    def lmoment4(self):
+        return ptd_lmoment4(self.n, self.p)
+
     def rvs(self, size=None, random_state=None):
         random_state = np.random.default_rng(random_state)
         return ptd_rvs(self.n, self.p, size=size, rng=random_state)
@@ -188,6 +200,26 @@ def ptd_kurtosis(n, p):
     return ptd_binomial.kurtosis(n, p)
 
 
+@pytensor_jit
+def ptd_lmoment1(n, p):
+    return ptd_binomial.lmoment1(n, p)
+
+
+@pytensor_jit
+def ptd_lmoment2(n, p):
+    return ptd_binomial.lmoment2(n, p)
+
+
+@pytensor_jit
+def ptd_lmoment3(n, p):
+    return ptd_binomial.lmoment3(n, p)
+
+
+@pytensor_jit
+def ptd_lmoment4(n, p):
+    return ptd_binomial.lmoment4(n, p)
+
+
 @pytensor_rng_jit
 def ptd_rvs(n, p, size, rng):
     return ptd_binomial.rvs(n, p, size=size, random_state=rng)

preliz/distributions/cauchy.py

@@ -98,6 +98,18 @@ def skewness(self):
     def kurtosis(self):
         return ptd_kurtosis(self.alpha, self.beta)
 
+    def lmoment1(self):
+        return ptd_lmoment1(self.alpha, self.beta)
+
+    def lmoment2(self):
+        return ptd_lmoment2(self.alpha, self.beta)
+
+    def lmoment3(self):
+        return ptd_lmoment3(self.alpha, self.beta)
+
+    def lmoment4(self):
+        return ptd_lmoment4(self.alpha, self.beta)
+
     def logcdf(self, x):
         return ptd_logcdf(x, self.alpha, self.beta)
 
@@ -175,6 +187,26 @@ def ptd_kurtosis(alpha, beta):
     return ptd_cauchy.kurtosis(alpha, beta)
 
 
+@pytensor_jit
+def ptd_lmoment1(alpha, beta):
+    return ptd_cauchy.lmoment1(alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment2(alpha, beta):
+    return ptd_cauchy.lmoment2(alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment3(alpha, beta):
+    return ptd_cauchy.lmoment3(alpha, beta)
+
+
+@pytensor_jit
+def ptd_lmoment4(alpha, beta):
+    return ptd_cauchy.lmoment4(alpha, beta)
+
+
 @pytensor_jit
 def ptd_logcdf(x, alpha, beta):
     return ptd_cauchy.logcdf(x, alpha, beta)

preliz/distributions/chi_squared.py

@@ -95,6 +95,18 @@ def skewness(self):
     def kurtosis(self):
         return ptd_kurtosis(self.nu)
 
+    def lmoment1(self):
+        return ptd_lmoment1(self.nu)
+
+    def lmoment2(self):
+        return ptd_lmoment2(self.nu)
+
+    def lmoment3(self):
+        return ptd_lmoment3(self.nu)
+
+    def lmoment4(self):
+        return ptd_lmoment4(self.nu)
+
     def rvs(self, size=None, random_state=None):
         random_state = np.random.default_rng(random_state)
         return ptd_rvs(self.nu, size=size, rng=random_state)
@@ -166,6 +178,26 @@ def ptd_kurtosis(nu):
     return ptd_chisquared.kurtosis(nu)
 
 
+@pytensor_jit
+def ptd_lmoment1(nu):
+    return ptd_chisquared.lmoment1(nu)
+
+
+@pytensor_jit
+def ptd_lmoment2(nu):
+    return ptd_chisquared.lmoment2(nu)
+
+
+@pytensor_jit
+def ptd_lmoment3(nu):
+    return ptd_chisquared.lmoment3(nu)
+
+
+@pytensor_jit
+def ptd_lmoment4(nu):
+    return ptd_chisquared.lmoment4(nu)
+
+
 @pytensor_rng_jit
 def ptd_rvs(nu, size, rng):
     return ptd_chisquared.rvs(nu, size=size, random_state=rng)