From 035b86ff6fafe90d1a829cac8cfbe2023c7606e7 Mon Sep 17 00:00:00 2001 From: aloctavodia Date: Mon, 18 May 2026 15:44:41 +0300 Subject: [PATCH] add lmoments --- preliz/distributions/asymmetric_laplace.py | 32 ++++++++++++++ preliz/distributions/bernoulli.py | 32 ++++++++++++++ preliz/distributions/beta.py | 32 ++++++++++++++ preliz/distributions/betabinomial.py | 32 ++++++++++++++ preliz/distributions/betascaled.py | 32 ++++++++++++++ preliz/distributions/binomial.py | 32 ++++++++++++++ preliz/distributions/cauchy.py | 32 ++++++++++++++ preliz/distributions/chi_squared.py | 32 ++++++++++++++ preliz/distributions/discrete_uniform.py | 32 ++++++++++++++ preliz/distributions/distributions.py | 46 +++++++++++++++++++ preliz/distributions/exgaussian.py | 32 ++++++++++++++ preliz/distributions/exponential.py | 32 ++++++++++++++ preliz/distributions/gamma.py | 32 ++++++++++++++ preliz/distributions/geometric.py | 32 ++++++++++++++ preliz/distributions/gumbel.py | 32 ++++++++++++++ preliz/distributions/halfcauchy.py | 32 ++++++++++++++ preliz/distributions/halfnormal.py | 32 ++++++++++++++ preliz/distributions/halfstudentt.py | 32 ++++++++++++++ preliz/distributions/hypergeometric.py | 32 ++++++++++++++ preliz/distributions/inversegamma.py | 32 ++++++++++++++ preliz/distributions/kumaraswamy.py | 32 ++++++++++++++ preliz/distributions/laplace.py | 32 ++++++++++++++ preliz/distributions/logistic.py | 32 ++++++++++++++ preliz/distributions/logitnormal.py | 32 ++++++++++++++ preliz/distributions/loglogistic.py | 32 ++++++++++++++ preliz/distributions/lognormal.py | 32 ++++++++++++++ preliz/distributions/moyal.py | 32 ++++++++++++++ preliz/distributions/negativebinomial.py | 32 ++++++++++++++ preliz/distributions/normal.py | 32 ++++++++++++++ preliz/distributions/pareto.py | 32 ++++++++++++++ preliz/distributions/poisson.py | 32 ++++++++++++++ preliz/distributions/rice.py | 32 ++++++++++++++ preliz/distributions/skew_studentt.py | 32 ++++++++++++++ preliz/distributions/skewnormal.py | 32 ++++++++++++++ preliz/distributions/studentt.py | 32 ++++++++++++++ preliz/distributions/triangular.py | 32 ++++++++++++++ preliz/distributions/truncatednormal.py | 32 ++++++++++++++ preliz/distributions/uniform.py | 32 ++++++++++++++ preliz/distributions/vonmises.py | 32 ++++++++++++++ preliz/distributions/wald.py | 32 ++++++++++++++ preliz/distributions/weibull.py | 32 ++++++++++++++ preliz/distributions/zi_binomial.py | 32 ++++++++++++++ preliz/distributions/zi_negativebinomial.py | 32 ++++++++++++++ preliz/distributions/zi_poisson.py | 32 ++++++++++++++ preliz/tests/test_lmoments.py | 49 +++++++++++++++++++++ 45 files changed, 1471 insertions(+) create mode 100644 preliz/tests/test_lmoments.py diff --git a/preliz/distributions/asymmetric_laplace.py b/preliz/distributions/asymmetric_laplace.py index a8d3df11..b9b37eae 100644 --- a/preliz/distributions/asymmetric_laplace.py +++ b/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) diff --git a/preliz/distributions/bernoulli.py b/preliz/distributions/bernoulli.py index 53925bd0..087f4209 100644 --- a/preliz/distributions/bernoulli.py +++ b/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) diff --git a/preliz/distributions/beta.py b/preliz/distributions/beta.py index eafac955..2e24f248 100644 --- a/preliz/distributions/beta.py +++ b/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) diff --git a/preliz/distributions/betabinomial.py b/preliz/distributions/betabinomial.py index 735b53bc..67df91f1 100644 --- a/preliz/distributions/betabinomial.py +++ b/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) diff --git a/preliz/distributions/betascaled.py b/preliz/distributions/betascaled.py index f4ccb81b..297a3ecf 100644 --- a/preliz/distributions/betascaled.py +++ b/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) diff --git a/preliz/distributions/binomial.py b/preliz/distributions/binomial.py index 5d6798c0..7c50a450 100644 --- a/preliz/distributions/binomial.py +++ b/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) diff --git a/preliz/distributions/cauchy.py b/preliz/distributions/cauchy.py index a97dc271..b006a54c 100644 --- a/preliz/distributions/cauchy.py +++ b/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) diff --git a/preliz/distributions/chi_squared.py b/preliz/distributions/chi_squared.py index 3ed39bfd..c0ee1450 100644 --- a/preliz/distributions/chi_squared.py +++ b/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) diff --git a/preliz/distributions/discrete_uniform.py b/preliz/distributions/discrete_uniform.py index ef320ae2..571b5d10 100644 --- a/preliz/distributions/discrete_uniform.py +++ b/preliz/distributions/discrete_uniform.py @@ -105,6 +105,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.lower, self.upper) + def lmoment1(self): + return ptd_lmoment1(self.lower, self.upper) + + def lmoment2(self): + return ptd_lmoment2(self.lower, self.upper) + + def lmoment3(self): + return ptd_lmoment3(self.lower, self.upper) + + def lmoment4(self): + return ptd_lmoment4(self.lower, self.upper) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.lower, self.upper, size=size, rng=random_state) @@ -181,6 +193,26 @@ def ptd_kurtosis(lower, upper): return ptd_discreteuniform.kurtosis(lower, upper) +@pytensor_jit +def ptd_lmoment1(lower, upper): + return ptd_discreteuniform.lmoment1(lower, upper) + + +@pytensor_jit +def ptd_lmoment2(lower, upper): + return ptd_discreteuniform.lmoment2(lower, upper) + + +@pytensor_jit +def ptd_lmoment3(lower, upper): + return ptd_discreteuniform.lmoment3(lower, upper) + + +@pytensor_jit +def ptd_lmoment4(lower, upper): + return ptd_discreteuniform.lmoment4(lower, upper) + + @pytensor_rng_jit def ptd_rvs(lower, upper, size, rng): return ptd_discreteuniform.rvs(lower, upper, size=size, random_state=rng) diff --git a/preliz/distributions/distributions.py b/preliz/distributions/distributions.py index 382517d1..baae5aab 100644 --- a/preliz/distributions/distributions.py +++ b/preliz/distributions/distributions.py @@ -268,6 +268,22 @@ def kurtosis(self): """Excess kurtosis.""" raise NotImplementedError + def lmoment1(self): + """L-moment1 (mean).""" + raise NotImplementedError + + def lmoment2(self): + """L-moment2 (l-scale).""" + raise NotImplementedError + + def lmoment3(self): + """L-moment3 (l-skewness). This the ratio of L-moment3 to L-moment2.""" + raise NotImplementedError + + def lmoment4(self): + """L-moment4 (l-kurtosis). This the ratio of L-moment4 to L-moment2.""" + raise NotImplementedError + def moments(self, types="mvsk"): """ Compute moments of the distribution. @@ -301,6 +317,36 @@ def moments(self, types="mvsk"): return moments + def lmoments(self, types="1234"): + """ + Compute L-moments of the distribution. + + Parameters + ---------- + types : str + The type of moments to compute. Default is '1234' + where '1' = L-moment1 (mean), '2' = L-moment2 (l-scale), + '3' = L-moment3 (l-skewness), and '4' = L-moment4 (l-kurtosis). + To compute the standard deviation use 'd' + Valid combinations are any subset of '1234'. + """ + moments = [] + for m_t in types: + if m_t not in "1234": + raise ValueError( + "The input string should only contain the letters '1', '2', '3', or '4'." + ) + if m_t == "1": + moments.append(self.lmoment1()) + elif m_t == "2": + moments.append(self.lmoment2()) + elif m_t == "3": + moments.append(self.lmoment3()) + elif m_t == "4": + moments.append(self.lmoment4()) + + return moments + def eti(self, mass=None, fmt=".2f"): """Equal-tailed interval containing `mass`. diff --git a/preliz/distributions/exgaussian.py b/preliz/distributions/exgaussian.py index e9053e80..2fd2776a 100644 --- a/preliz/distributions/exgaussian.py +++ b/preliz/distributions/exgaussian.py @@ -110,6 +110,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.sigma, self.nu) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.sigma, self.nu) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.sigma, self.nu) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.sigma, self.nu) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.sigma, self.nu) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.sigma, self.nu, size=size, rng=random_state) @@ -187,6 +199,26 @@ def ptd_kurtosis(mu, sigma, nu): return ptd_exgaussian.kurtosis(mu, sigma, nu) +@pytensor_jit +def ptd_lmoment1(mu, sigma, nu): + return ptd_exgaussian.lmoment1(mu, sigma, nu) + + +@pytensor_jit +def ptd_lmoment2(mu, sigma, nu): + return ptd_exgaussian.lmoment2(mu, sigma, nu) + + +@pytensor_jit +def ptd_lmoment3(mu, sigma, nu): + return ptd_exgaussian.lmoment3(mu, sigma, nu) + + +@pytensor_jit +def ptd_lmoment4(mu, sigma, nu): + return ptd_exgaussian.lmoment4(mu, sigma, nu) + + @pytensor_rng_jit def ptd_rvs(mu, sigma, nu, size, rng): return ptd_exgaussian.rvs(mu, sigma, nu, size=size, random_state=rng) diff --git a/preliz/distributions/exponential.py b/preliz/distributions/exponential.py index 2f910204..1c4ea164 100644 --- a/preliz/distributions/exponential.py +++ b/preliz/distributions/exponential.py @@ -116,6 +116,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.lam) + def lmoment1(self): + return ptd_lmoment1(self.lam) + + def lmoment2(self): + return ptd_lmoment2(self.lam) + + def lmoment3(self): + return ptd_lmoment3(self.lam) + + def lmoment4(self): + return ptd_lmoment4(self.lam) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.lam, size=size, rng=random_state) @@ -189,6 +201,26 @@ def ptd_kurtosis(lam): return ptd_exponential.kurtosis(lam) +@pytensor_jit +def ptd_lmoment1(lam): + return ptd_exponential.lmoment1(lam) + + +@pytensor_jit +def ptd_lmoment2(lam): + return ptd_exponential.lmoment2(lam) + + +@pytensor_jit +def ptd_lmoment3(lam): + return ptd_exponential.lmoment3(lam) + + +@pytensor_jit +def ptd_lmoment4(lam): + return ptd_exponential.lmoment4(lam) + + @pytensor_rng_jit def ptd_rvs(lam, size, rng): return ptd_exponential.rvs(lam, size=size, random_state=rng) diff --git a/preliz/distributions/gamma.py b/preliz/distributions/gamma.py index e60bd361..7fd10f20 100644 --- a/preliz/distributions/gamma.py +++ b/preliz/distributions/gamma.py @@ -149,6 +149,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) @@ -221,6 +233,26 @@ def ptd_kurtosis(alpha, beta): return ptd_gamma.kurtosis(alpha, beta) +@pytensor_jit +def ptd_lmoment1(alpha, beta): + return ptd_gamma.lmoment1(alpha, beta) + + +@pytensor_jit +def ptd_lmoment2(alpha, beta): + return ptd_gamma.lmoment2(alpha, beta) + + +@pytensor_jit +def ptd_lmoment3(alpha, beta): + return ptd_gamma.lmoment3(alpha, beta) + + +@pytensor_jit +def ptd_lmoment4(alpha, beta): + return ptd_gamma.lmoment4(alpha, beta) + + @pytensor_rng_jit def ptd_rvs(alpha, beta, size, rng): return ptd_gamma.rvs(alpha, beta, size=size, random_state=rng) diff --git a/preliz/distributions/geometric.py b/preliz/distributions/geometric.py index 9863a891..dda30459 100644 --- a/preliz/distributions/geometric.py +++ b/preliz/distributions/geometric.py @@ -90,6 +90,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) @@ -163,6 +175,26 @@ def ptd_kurtosis(p): return ptd_geometric.kurtosis(p) +@pytensor_jit +def ptd_lmoment1(p): + return ptd_geometric.lmoment1(p) + + +@pytensor_jit +def ptd_lmoment2(p): + return ptd_geometric.lmoment2(p) + + +@pytensor_jit +def ptd_lmoment3(p): + return ptd_geometric.lmoment3(p) + + +@pytensor_jit +def ptd_lmoment4(p): + return ptd_geometric.lmoment4(p) + + @pytensor_rng_jit def ptd_rvs(p, size, rng): return ptd_geometric.rvs(p, size=size, random_state=rng) diff --git a/preliz/distributions/gumbel.py b/preliz/distributions/gumbel.py index 8161fd74..c78d0d98 100644 --- a/preliz/distributions/gumbel.py +++ b/preliz/distributions/gumbel.py @@ -103,6 +103,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.beta) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.beta) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.beta) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.beta) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.beta) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.beta, size=size, rng=random_state) @@ -176,6 +188,26 @@ def ptd_kurtosis(mu, beta): return ptd_gumbel.kurtosis(mu, beta) +@pytensor_jit +def ptd_lmoment1(mu, beta): + return ptd_gumbel.lmoment1(mu, beta) + + +@pytensor_jit +def ptd_lmoment2(mu, beta): + return ptd_gumbel.lmoment2(mu, beta) + + +@pytensor_jit +def ptd_lmoment3(mu, beta): + return ptd_gumbel.lmoment3(mu, beta) + + +@pytensor_jit +def ptd_lmoment4(mu, beta): + return ptd_gumbel.lmoment4(mu, beta) + + @pytensor_rng_jit def ptd_rvs(mu, beta, size, rng): return ptd_gumbel.rvs(mu, beta, size=size, random_state=rng) diff --git a/preliz/distributions/halfcauchy.py b/preliz/distributions/halfcauchy.py index fde8aec6..b9a2faa2 100644 --- a/preliz/distributions/halfcauchy.py +++ b/preliz/distributions/halfcauchy.py @@ -92,6 +92,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.beta) + def lmoment1(self): + return ptd_lmoment1(self.beta) + + def lmoment2(self): + return ptd_lmoment2(self.beta) + + def lmoment3(self): + return ptd_lmoment3(self.beta) + + def lmoment4(self): + return ptd_lmoment4(self.beta) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.beta, size=size, rng=random_state) @@ -163,6 +175,26 @@ def ptd_kurtosis(beta): return ptd_halfcauchy.kurtosis(beta) +@pytensor_jit +def ptd_lmoment1(beta): + return ptd_halfcauchy.lmoment1(beta) + + +@pytensor_jit +def ptd_lmoment2(beta): + return ptd_halfcauchy.lmoment2(beta) + + +@pytensor_jit +def ptd_lmoment3(beta): + return ptd_halfcauchy.lmoment3(beta) + + +@pytensor_jit +def ptd_lmoment4(beta): + return ptd_halfcauchy.lmoment4(beta) + + @pytensor_rng_jit def ptd_rvs(beta, size, rng): return ptd_halfcauchy.rvs(beta, size=size, random_state=rng) diff --git a/preliz/distributions/halfnormal.py b/preliz/distributions/halfnormal.py index ed87bb06..db7aab25 100644 --- a/preliz/distributions/halfnormal.py +++ b/preliz/distributions/halfnormal.py @@ -124,6 +124,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.sigma) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.sigma, size=size, rng=random_state) @@ -195,6 +207,26 @@ def ptd_kurtosis(sigma): return ptd_halfnormal.kurtosis(sigma) +@pytensor_jit +def ptd_lmoment1(sigma): + return ptd_halfnormal.lmoment1(sigma) + + +@pytensor_jit +def ptd_lmoment2(sigma): + return ptd_halfnormal.lmoment2(sigma) + + +@pytensor_jit +def ptd_lmoment3(sigma): + return ptd_halfnormal.lmoment3(sigma) + + +@pytensor_jit +def ptd_lmoment4(sigma): + return ptd_halfnormal.lmoment4(sigma) + + @pytensor_rng_jit def ptd_rvs(sigma, size, rng): return ptd_halfnormal.rvs(sigma, size=size, random_state=rng) diff --git a/preliz/distributions/halfstudentt.py b/preliz/distributions/halfstudentt.py index 387e3451..8b42665a 100644 --- a/preliz/distributions/halfstudentt.py +++ b/preliz/distributions/halfstudentt.py @@ -144,6 +144,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.nu, self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.nu, self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.nu, self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.nu, self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.nu, self.sigma) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.nu, self.sigma, size=size, rng=random_state) @@ -233,6 +245,26 @@ def ptd_kurtosis(nu, sigma): return ptd_halfstudentt.kurtosis(nu, sigma) +@pytensor_jit +def ptd_lmoment1(nu, sigma): + return ptd_halfstudentt.lmoment1(nu, sigma) + + +@pytensor_jit +def ptd_lmoment2(nu, sigma): + return ptd_halfstudentt.lmoment2(nu, sigma) + + +@pytensor_jit +def ptd_lmoment3(nu, sigma): + return ptd_halfstudentt.lmoment3(nu, sigma) + + +@pytensor_jit +def ptd_lmoment4(nu, sigma): + return ptd_halfstudentt.lmoment4(nu, sigma) + + @pytensor_rng_jit def ptd_rvs(nu, sigma, size, rng): return ptd_halfstudentt.rvs(nu, sigma, size=size, random_state=rng) diff --git a/preliz/distributions/hypergeometric.py b/preliz/distributions/hypergeometric.py index c6d9a527..b3d582c1 100644 --- a/preliz/distributions/hypergeometric.py +++ b/preliz/distributions/hypergeometric.py @@ -101,6 +101,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.N, self.k, self.n) + def lmoment1(self): + return ptd_lmoment1(self.N, self.k, self.n) + + def lmoment2(self): + return ptd_lmoment2(self.N, self.k, self.n) + + def lmoment3(self): + return ptd_lmoment3(self.N, self.k, self.n) + + def lmoment4(self): + return ptd_lmoment4(self.N, self.k, self.n) + def mode(self): return ptd_mode(self.N, self.k, self.n) @@ -175,6 +187,26 @@ def ptd_kurtosis(N, k, n): return ptd_hypergeometric.kurtosis(N, k, n) +@pytensor_jit +def ptd_lmoment1(N, k, n): + return ptd_hypergeometric.lmoment1(N, k, n) + + +@pytensor_jit +def ptd_lmoment2(N, k, n): + return ptd_hypergeometric.lmoment2(N, k, n) + + +@pytensor_jit +def ptd_lmoment3(N, k, n): + return ptd_hypergeometric.lmoment3(N, k, n) + + +@pytensor_jit +def ptd_lmoment4(N, k, n): + return ptd_hypergeometric.lmoment4(N, k, n) + + @pytensor_rng_jit def ptd_rvs(N, k, n, size, rng): return ptd_hypergeometric.rvs(N, k, n, size=size, random_state=rng) diff --git a/preliz/distributions/inversegamma.py b/preliz/distributions/inversegamma.py index 056bc9a5..93a7f2a0 100644 --- a/preliz/distributions/inversegamma.py +++ b/preliz/distributions/inversegamma.py @@ -138,6 +138,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) @@ -210,6 +222,26 @@ def ptd_kurtosis(alpha, beta): return ptd_inversegamma.kurtosis(alpha, beta) +@pytensor_jit +def ptd_lmoment1(alpha, beta): + return ptd_inversegamma.lmoment1(alpha, beta) + + +@pytensor_jit +def ptd_lmoment2(alpha, beta): + return ptd_inversegamma.lmoment2(alpha, beta) + + +@pytensor_jit +def ptd_lmoment3(alpha, beta): + return ptd_inversegamma.lmoment3(alpha, beta) + + +@pytensor_jit +def ptd_lmoment4(alpha, beta): + return ptd_inversegamma.lmoment4(alpha, beta) + + @pytensor_rng_jit def ptd_rvs(alpha, beta, size, rng): return ptd_inversegamma.rvs(alpha, beta, size=size, random_state=rng) diff --git a/preliz/distributions/kumaraswamy.py b/preliz/distributions/kumaraswamy.py index 257e8c70..93efad45 100644 --- a/preliz/distributions/kumaraswamy.py +++ b/preliz/distributions/kumaraswamy.py @@ -98,6 +98,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.a, self.b) + def lmoment1(self): + return ptd_lmoment1(self.a, self.b) + + def lmoment2(self): + return ptd_lmoment2(self.a, self.b) + + def lmoment3(self): + return ptd_lmoment3(self.a, self.b) + + def lmoment4(self): + return ptd_lmoment4(self.a, self.b) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.a, self.b, size=size, rng=random_state) @@ -169,6 +181,26 @@ def ptd_kurtosis(a, b): return ptd_kumaraswamy.kurtosis(a, b) +@pytensor_jit +def ptd_lmoment1(a, b): + return ptd_kumaraswamy.lmoment1(a, b) + + +@pytensor_jit +def ptd_lmoment2(a, b): + return ptd_kumaraswamy.lmoment2(a, b) + + +@pytensor_jit +def ptd_lmoment3(a, b): + return ptd_kumaraswamy.lmoment3(a, b) + + +@pytensor_jit +def ptd_lmoment4(a, b): + return ptd_kumaraswamy.lmoment4(a, b) + + @pytensor_rng_jit def ptd_rvs(a, b, size, rng): return ptd_kumaraswamy.rvs(a, b, size=size, random_state=rng) diff --git a/preliz/distributions/laplace.py b/preliz/distributions/laplace.py index ed7d7558..a73c6c64 100644 --- a/preliz/distributions/laplace.py +++ b/preliz/distributions/laplace.py @@ -98,6 +98,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.b) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.b) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.b) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.b) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.b) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.b, size=size, rng=random_state) @@ -171,6 +183,26 @@ def ptd_kurtosis(mu, b): return ptd_laplace.kurtosis(mu, b) +@pytensor_jit +def ptd_lmoment1(mu, b): + return ptd_laplace.lmoment1(mu, b) + + +@pytensor_jit +def ptd_lmoment2(mu, b): + return ptd_laplace.lmoment2(mu, b) + + +@pytensor_jit +def ptd_lmoment3(mu, b): + return ptd_laplace.lmoment3(mu, b) + + +@pytensor_jit +def ptd_lmoment4(mu, b): + return ptd_laplace.lmoment4(mu, b) + + @pytensor_rng_jit def ptd_rvs(mu, b, size, rng): return ptd_laplace.rvs(mu, b, size=size, random_state=rng) diff --git a/preliz/distributions/logistic.py b/preliz/distributions/logistic.py index 2cad0048..d04d047f 100644 --- a/preliz/distributions/logistic.py +++ b/preliz/distributions/logistic.py @@ -98,6 +98,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.s) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.s) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.s) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.s) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.s) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.s, size=size, rng=random_state) @@ -170,6 +182,26 @@ def ptd_kurtosis(mu, s): return ptd_logistic.kurtosis(mu, s) +@pytensor_jit +def ptd_lmoment1(mu, s): + return ptd_logistic.lmoment1(mu, s) + + +@pytensor_jit +def ptd_lmoment2(mu, s): + return ptd_logistic.lmoment2(mu, s) + + +@pytensor_jit +def ptd_lmoment3(mu, s): + return ptd_logistic.lmoment3(mu, s) + + +@pytensor_jit +def ptd_lmoment4(mu, s): + return ptd_logistic.lmoment4(mu, s) + + @pytensor_rng_jit def ptd_rvs(mu, s, size, rng): return ptd_logistic.rvs(mu, s, size=size, random_state=rng) diff --git a/preliz/distributions/logitnormal.py b/preliz/distributions/logitnormal.py index f9bfdc9c..519ddd64 100644 --- a/preliz/distributions/logitnormal.py +++ b/preliz/distributions/logitnormal.py @@ -125,6 +125,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.sigma) + def mode(self): return ptd_mode(self.mu, self.sigma) @@ -202,6 +214,26 @@ def ptd_kurtosis(mu, sigma): return ptd_logitnormal.kurtosis(mu, sigma) +@pytensor_jit +def ptd_lmoment1(mu, sigma): + return ptd_logitnormal.lmoment1(mu, sigma) + + +@pytensor_jit +def ptd_lmoment2(mu, sigma): + return ptd_logitnormal.lmoment2(mu, sigma) + + +@pytensor_jit +def ptd_lmoment3(mu, sigma): + return ptd_logitnormal.lmoment3(mu, sigma) + + +@pytensor_jit +def ptd_lmoment4(mu, sigma): + return ptd_logitnormal.lmoment4(mu, sigma) + + @pytensor_rng_jit def ptd_rvs(mu, sigma, size, rng): return ptd_logitnormal.rvs(mu, sigma, size=size, random_state=rng) diff --git a/preliz/distributions/loglogistic.py b/preliz/distributions/loglogistic.py index 62f52d98..c853975a 100644 --- a/preliz/distributions/loglogistic.py +++ b/preliz/distributions/loglogistic.py @@ -102,6 +102,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) @@ -173,6 +185,26 @@ def ptd_kurtosis(alpha, beta): return ptd_loglogistic.kurtosis(alpha, beta) +@pytensor_jit +def ptd_lmoment1(alpha, beta): + return ptd_loglogistic.lmoment1(alpha, beta) + + +@pytensor_jit +def ptd_lmoment2(alpha, beta): + return ptd_loglogistic.lmoment2(alpha, beta) + + +@pytensor_jit +def ptd_lmoment3(alpha, beta): + return ptd_loglogistic.lmoment3(alpha, beta) + + +@pytensor_jit +def ptd_lmoment4(alpha, beta): + return ptd_loglogistic.lmoment4(alpha, beta) + + @pytensor_rng_jit def ptd_rvs(alpha, beta, size, rng): return ptd_loglogistic.rvs(alpha, beta, size=size, random_state=rng) diff --git a/preliz/distributions/lognormal.py b/preliz/distributions/lognormal.py index 1fc23452..fb3adb30 100644 --- a/preliz/distributions/lognormal.py +++ b/preliz/distributions/lognormal.py @@ -106,6 +106,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.sigma) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.sigma, size=size, rng=random_state) @@ -180,6 +192,26 @@ def ptd_kurtosis(mu, sigma): return ptd_lognormal.kurtosis(mu, sigma) +@pytensor_jit +def ptd_lmoment1(mu, sigma): + return ptd_lognormal.lmoment1(mu, sigma) + + +@pytensor_jit +def ptd_lmoment2(mu, sigma): + return ptd_lognormal.lmoment2(mu, sigma) + + +@pytensor_jit +def ptd_lmoment3(mu, sigma): + return ptd_lognormal.lmoment3(mu, sigma) + + +@pytensor_jit +def ptd_lmoment4(mu, sigma): + return ptd_lognormal.lmoment4(mu, sigma) + + @pytensor_rng_jit def ptd_rvs(mu, sigma, size, rng): return ptd_lognormal.rvs(mu, sigma, size=size, random_state=rng) diff --git a/preliz/distributions/moyal.py b/preliz/distributions/moyal.py index 47fe6f9e..f81707bb 100644 --- a/preliz/distributions/moyal.py +++ b/preliz/distributions/moyal.py @@ -105,6 +105,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.sigma) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.sigma, size=size, rng=random_state) @@ -178,6 +190,26 @@ def ptd_kurtosis(mu, sigma): return ptd_moyal.kurtosis(mu, sigma) +@pytensor_jit +def ptd_lmoment1(mu, sigma): + return ptd_moyal.lmoment1(mu, sigma) + + +@pytensor_jit +def ptd_lmoment2(mu, sigma): + return ptd_moyal.lmoment2(mu, sigma) + + +@pytensor_jit +def ptd_lmoment3(mu, sigma): + return ptd_moyal.lmoment3(mu, sigma) + + +@pytensor_jit +def ptd_lmoment4(mu, sigma): + return ptd_moyal.lmoment4(mu, sigma) + + @pytensor_rng_jit def ptd_rvs(mu, sigma, size, rng): return ptd_moyal.rvs(mu, sigma, size=size, random_state=rng) diff --git a/preliz/distributions/negativebinomial.py b/preliz/distributions/negativebinomial.py index 87baa955..413ff374 100644 --- a/preliz/distributions/negativebinomial.py +++ b/preliz/distributions/negativebinomial.py @@ -152,6 +152,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) @@ -223,6 +235,26 @@ def ptd_kurtosis(n, p): return ptd_negativebinomial.kurtosis(n, p) +@pytensor_jit +def ptd_lmoment1(n, p): + return ptd_negativebinomial.lmoment1(n, p) + + +@pytensor_jit +def ptd_lmoment2(n, p): + return ptd_negativebinomial.lmoment2(n, p) + + +@pytensor_jit +def ptd_lmoment3(n, p): + return ptd_negativebinomial.lmoment3(n, p) + + +@pytensor_jit +def ptd_lmoment4(n, p): + return ptd_negativebinomial.lmoment4(n, p) + + @pytensor_rng_jit def ptd_rvs(n, p, size, rng): return ptd_negativebinomial.rvs(n, p, size=size, random_state=rng) diff --git a/preliz/distributions/normal.py b/preliz/distributions/normal.py index bebb7230..365250e0 100644 --- a/preliz/distributions/normal.py +++ b/preliz/distributions/normal.py @@ -155,6 +155,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.sigma) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.sigma, size=size, rng=random_state) @@ -245,6 +257,26 @@ def ptd_kurtosis(mu, sigma): return ptd_normal.kurtosis(mu, sigma) +@pytensor_jit +def ptd_lmoment1(mu, sigma): + return ptd_normal.lmoment1(mu, sigma) + + +@pytensor_jit +def ptd_lmoment2(mu, sigma): + return ptd_normal.lmoment2(mu, sigma) + + +@pytensor_jit +def ptd_lmoment3(mu, sigma): + return ptd_normal.lmoment3(mu, sigma) + + +@pytensor_jit +def ptd_lmoment4(mu, sigma): + return ptd_normal.lmoment4(mu, sigma) + + @pytensor_rng_jit def ptd_rvs(mu, sigma, size, rng): return ptd_normal.rvs(mu, sigma, size=size, random_state=rng) diff --git a/preliz/distributions/pareto.py b/preliz/distributions/pareto.py index 4d075259..3eb04f44 100644 --- a/preliz/distributions/pareto.py +++ b/preliz/distributions/pareto.py @@ -98,6 +98,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.alpha, self.m) + def lmoment1(self): + return ptd_lmoment1(self.alpha, self.m) + + def lmoment2(self): + return ptd_lmoment2(self.alpha, self.m) + + def lmoment3(self): + return ptd_lmoment3(self.alpha, self.m) + + def lmoment4(self): + return ptd_lmoment4(self.alpha, self.m) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.alpha, self.m, size=size, rng=random_state) @@ -171,6 +183,26 @@ def ptd_kurtosis(alpha, m): return ptd_pareto.kurtosis(alpha, m) +@pytensor_jit +def ptd_lmoment1(alpha, m): + return ptd_pareto.lmoment1(alpha, m) + + +@pytensor_jit +def ptd_lmoment2(alpha, m): + return ptd_pareto.lmoment2(alpha, m) + + +@pytensor_jit +def ptd_lmoment3(alpha, m): + return ptd_pareto.lmoment3(alpha, m) + + +@pytensor_jit +def ptd_lmoment4(alpha, m): + return ptd_pareto.lmoment4(alpha, m) + + @pytensor_rng_jit def ptd_rvs(alpha, m, size, rng): return ptd_pareto.rvs(alpha, m, size=size, random_state=rng) diff --git a/preliz/distributions/poisson.py b/preliz/distributions/poisson.py index 07d943f4..a7f60700 100644 --- a/preliz/distributions/poisson.py +++ b/preliz/distributions/poisson.py @@ -96,6 +96,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu) + def lmoment1(self): + return ptd_lmoment1(self.mu) + + def lmoment2(self): + return ptd_lmoment2(self.mu) + + def lmoment3(self): + return ptd_lmoment3(self.mu) + + def lmoment4(self): + return ptd_lmoment4(self.mu) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, size=size, rng=random_state) @@ -167,6 +179,26 @@ def ptd_kurtosis(mu): return ptd_poisson.kurtosis(mu) +@pytensor_jit +def ptd_lmoment1(mu): + return ptd_poisson.lmoment1(mu) + + +@pytensor_jit +def ptd_lmoment2(mu): + return ptd_poisson.lmoment2(mu) + + +@pytensor_jit +def ptd_lmoment3(mu): + return ptd_poisson.lmoment3(mu) + + +@pytensor_jit +def ptd_lmoment4(mu): + return ptd_poisson.lmoment4(mu) + + @pytensor_rng_jit def ptd_rvs(mu, size, rng): return ptd_poisson.rvs(mu, size=size, random_state=rng) diff --git a/preliz/distributions/rice.py b/preliz/distributions/rice.py index 86e5dd43..9e8ff166 100644 --- a/preliz/distributions/rice.py +++ b/preliz/distributions/rice.py @@ -136,6 +136,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.nu, self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.nu, self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.nu, self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.nu, self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.nu, self.sigma) + def rvs(self, size=1, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.nu, self.sigma, size=size, rng=random_state) @@ -208,6 +220,26 @@ def ptd_kurtosis(nu, sigma): return ptd_rice.kurtosis(nu, sigma) +@pytensor_jit +def ptd_lmoment1(nu, sigma): + return ptd_rice.lmoment1(nu, sigma) + + +@pytensor_jit +def ptd_lmoment2(nu, sigma): + return ptd_rice.lmoment2(nu, sigma) + + +@pytensor_jit +def ptd_lmoment3(nu, sigma): + return ptd_rice.lmoment3(nu, sigma) + + +@pytensor_jit +def ptd_lmoment4(nu, sigma): + return ptd_rice.lmoment4(nu, sigma) + + @pytensor_rng_jit def ptd_rvs(nu, sigma, size, rng): return ptd_rice.rvs(nu, sigma, size=size, random_state=rng) diff --git a/preliz/distributions/skew_studentt.py b/preliz/distributions/skew_studentt.py index 0c5ebbd8..4b64d2dc 100644 --- a/preliz/distributions/skew_studentt.py +++ b/preliz/distributions/skew_studentt.py @@ -137,6 +137,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.a, self.b, self.mu, self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.a, self.b, self.mu, self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.a, self.b, self.mu, self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.a, self.b, self.mu, self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.a, self.b, self.mu, self.sigma) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.a, self.b, self.mu, self.sigma, size=size, rng=random_state) @@ -208,6 +220,26 @@ def ptd_kurtosis(a, b, mu, sigma): return ptd_skew_studentt.kurtosis(a, b, mu, sigma) +@pytensor_jit +def ptd_lmoment1(a, b, mu, sigma): + return ptd_skew_studentt.lmoment1(a, b, mu, sigma) + + +@pytensor_jit +def ptd_lmoment2(a, b, mu, sigma): + return ptd_skew_studentt.lmoment2(a, b, mu, sigma) + + +@pytensor_jit +def ptd_lmoment3(a, b, mu, sigma): + return ptd_skew_studentt.lmoment3(a, b, mu, sigma) + + +@pytensor_jit +def ptd_lmoment4(a, b, mu, sigma): + return ptd_skew_studentt.lmoment4(a, b, mu, sigma) + + @pytensor_rng_jit def ptd_rvs(a, b, mu, sigma, size, rng): return ptd_skew_studentt.rvs(a, b, mu, sigma, size=size, random_state=rng) diff --git a/preliz/distributions/skewnormal.py b/preliz/distributions/skewnormal.py index c9c6b53a..ace3f51e 100644 --- a/preliz/distributions/skewnormal.py +++ b/preliz/distributions/skewnormal.py @@ -139,6 +139,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.sigma, self.alpha) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.sigma, self.alpha) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.sigma, self.alpha) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.sigma, self.alpha) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.sigma, self.alpha) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.sigma, self.alpha, size=size, rng=random_state) @@ -214,6 +226,26 @@ def ptd_kurtosis(mu, sigma, alpha): return ptd_skewnormal.kurtosis(mu, sigma, alpha) +@pytensor_jit +def ptd_lmoment1(mu, sigma, alpha): + return ptd_skewnormal.lmoment1(mu, sigma, alpha) + + +@pytensor_jit +def ptd_lmoment2(mu, sigma, alpha): + return ptd_skewnormal.lmoment2(mu, sigma, alpha) + + +@pytensor_jit +def ptd_lmoment3(mu, sigma, alpha): + return ptd_skewnormal.lmoment3(mu, sigma, alpha) + + +@pytensor_jit +def ptd_lmoment4(mu, sigma, alpha): + return ptd_skewnormal.lmoment4(mu, sigma, alpha) + + @pytensor_rng_jit def ptd_rvs(mu, sigma, alpha, size, rng): return ptd_skewnormal.rvs(mu, sigma, alpha, size=size, random_state=rng) diff --git a/preliz/distributions/studentt.py b/preliz/distributions/studentt.py index 621d184f..d29a31a3 100644 --- a/preliz/distributions/studentt.py +++ b/preliz/distributions/studentt.py @@ -143,6 +143,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.nu, self.mu, self.sigma) + def lmoment1(self): + return ptd_lmoment1(self.nu, self.mu, self.sigma) + + def lmoment2(self): + return ptd_lmoment2(self.nu, self.mu, self.sigma) + + def lmoment3(self): + return ptd_lmoment3(self.nu, self.mu, self.sigma) + + def lmoment4(self): + return ptd_lmoment4(self.nu, self.mu, self.sigma) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.nu, self.mu, self.sigma, size=size, rng=random_state) @@ -224,6 +236,26 @@ def ptd_kurtosis(nu, mu, sigma): return ptd_studentt.kurtosis(nu, mu, sigma) +@pytensor_jit +def ptd_lmoment1(nu, mu, sigma): + return ptd_studentt.lmoment1(nu, mu, sigma) + + +@pytensor_jit +def ptd_lmoment2(nu, mu, sigma): + return ptd_studentt.lmoment2(nu, mu, sigma) + + +@pytensor_jit +def ptd_lmoment3(nu, mu, sigma): + return ptd_studentt.lmoment3(nu, mu, sigma) + + +@pytensor_jit +def ptd_lmoment4(nu, mu, sigma): + return ptd_studentt.lmoment4(nu, mu, sigma) + + @pytensor_rng_jit def ptd_rvs(nu, mu, sigma, size, rng): return ptd_studentt.rvs(nu, mu, sigma, size=size, random_state=rng) diff --git a/preliz/distributions/triangular.py b/preliz/distributions/triangular.py index 036f4810..b0acb734 100644 --- a/preliz/distributions/triangular.py +++ b/preliz/distributions/triangular.py @@ -109,6 +109,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.lower, self.c, self.upper) + def lmoment1(self): + return ptd_lmoment1(self.lower, self.c, self.upper) + + def lmoment2(self): + return ptd_lmoment2(self.lower, self.c, self.upper) + + def lmoment3(self): + return ptd_lmoment3(self.lower, self.c, self.upper) + + def lmoment4(self): + return ptd_lmoment4(self.lower, self.c, self.upper) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.lower, self.c, self.upper, size=size, rng=random_state) @@ -187,6 +199,26 @@ def ptd_kurtosis(lower, c, upper): return ptd_triangular.kurtosis(lower, c, upper) +@pytensor_jit +def ptd_lmoment1(lower, c, upper): + return ptd_triangular.lmoment1(lower, c, upper) + + +@pytensor_jit +def ptd_lmoment2(lower, c, upper): + return ptd_triangular.lmoment2(lower, c, upper) + + +@pytensor_jit +def ptd_lmoment3(lower, c, upper): + return ptd_triangular.lmoment3(lower, c, upper) + + +@pytensor_jit +def ptd_lmoment4(lower, c, upper): + return ptd_triangular.lmoment4(lower, c, upper) + + @pytensor_rng_jit def ptd_rvs(lower, c, upper, size, rng): return ptd_triangular.rvs(lower, c, upper, size=size, random_state=rng) diff --git a/preliz/distributions/truncatednormal.py b/preliz/distributions/truncatednormal.py index 50f69556..cdeb06ac 100644 --- a/preliz/distributions/truncatednormal.py +++ b/preliz/distributions/truncatednormal.py @@ -123,6 +123,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.sigma, self.lower, self.upper) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.sigma, self.lower, self.upper) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.sigma, self.lower, self.upper) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.sigma, self.lower, self.upper) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.sigma, self.lower, self.upper) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.sigma, self.lower, self.upper, size=size, rng=random_state) @@ -196,6 +208,26 @@ def ptd_kurtosis(mu, sigma, lower, upper): return ptd_truncatednormal.kurtosis(mu, sigma, lower, upper) +@pytensor_jit +def ptd_lmoment1(mu, sigma, lower, upper): + return ptd_truncatednormal.lmoment1(mu, sigma, lower, upper) + + +@pytensor_jit +def ptd_lmoment2(mu, sigma, lower, upper): + return ptd_truncatednormal.lmoment2(mu, sigma, lower, upper) + + +@pytensor_jit +def ptd_lmoment3(mu, sigma, lower, upper): + return ptd_truncatednormal.lmoment3(mu, sigma, lower, upper) + + +@pytensor_jit +def ptd_lmoment4(mu, sigma, lower, upper): + return ptd_truncatednormal.lmoment4(mu, sigma, lower, upper) + + @pytensor_rng_jit def ptd_rvs(mu, sigma, lower, upper, size, rng): return ptd_truncatednormal.rvs(mu, sigma, lower, upper, size=size, random_state=rng) diff --git a/preliz/distributions/uniform.py b/preliz/distributions/uniform.py index 3b35f46f..8030e0ba 100644 --- a/preliz/distributions/uniform.py +++ b/preliz/distributions/uniform.py @@ -104,6 +104,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.lower, self.upper) + def lmoment1(self): + return ptd_lmoment1(self.lower, self.upper) + + def lmoment2(self): + return ptd_lmoment2(self.lower, self.upper) + + def lmoment3(self): + return ptd_lmoment3(self.lower, self.upper) + + def lmoment4(self): + return ptd_lmoment4(self.lower, self.upper) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.lower, self.upper, size=size, rng=random_state) @@ -179,6 +191,26 @@ def ptd_kurtosis(lower, upper): return ptd_uniform.kurtosis(lower, upper) +@pytensor_jit +def ptd_lmoment1(lower, upper): + return ptd_uniform.lmoment1(lower, upper) + + +@pytensor_jit +def ptd_lmoment2(lower, upper): + return ptd_uniform.lmoment2(lower, upper) + + +@pytensor_jit +def ptd_lmoment3(lower, upper): + return ptd_uniform.lmoment3(lower, upper) + + +@pytensor_jit +def ptd_lmoment4(lower, upper): + return ptd_uniform.lmoment4(lower, upper) + + @pytensor_rng_jit def ptd_rvs(lower, upper, size, rng): return ptd_uniform.rvs(lower, upper, size=size, random_state=rng) diff --git a/preliz/distributions/vonmises.py b/preliz/distributions/vonmises.py index 6ae7df21..a4346abc 100644 --- a/preliz/distributions/vonmises.py +++ b/preliz/distributions/vonmises.py @@ -100,6 +100,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.kappa) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.kappa) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.kappa) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.kappa) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.kappa) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.kappa, size=size, rng=random_state) @@ -202,6 +214,26 @@ def ptd_kurtosis(mu, kappa): return ptd_vonmises.kurtosis(mu, kappa) +@pytensor_jit +def ptd_lmoment1(mu, kappa): + return ptd_vonmises.lmoment1(mu, kappa) + + +@pytensor_jit +def ptd_lmoment2(mu, kappa): + return ptd_vonmises.lmoment2(mu, kappa) + + +@pytensor_jit +def ptd_lmoment3(mu, kappa): + return ptd_vonmises.lmoment3(mu, kappa) + + +@pytensor_jit +def ptd_lmoment4(mu, kappa): + return ptd_vonmises.lmoment4(mu, kappa) + + @pytensor_rng_jit def ptd_rvs(mu, kappa, size, rng): return ptd_vonmises.rvs(mu, kappa, size=size, random_state=rng) diff --git a/preliz/distributions/wald.py b/preliz/distributions/wald.py index bc690379..5153e3bd 100644 --- a/preliz/distributions/wald.py +++ b/preliz/distributions/wald.py @@ -147,6 +147,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.mu, self.lam) + def lmoment1(self): + return ptd_lmoment1(self.mu, self.lam) + + def lmoment2(self): + return ptd_lmoment2(self.mu, self.lam) + + def lmoment3(self): + return ptd_lmoment3(self.mu, self.lam) + + def lmoment4(self): + return ptd_lmoment4(self.mu, self.lam) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.mu, self.lam, size=size, rng=random_state) @@ -219,6 +231,26 @@ def ptd_kurtosis(mu, lam): return ptd_wald.kurtosis(mu, lam) +@pytensor_jit +def ptd_lmoment1(mu, lam): + return ptd_wald.lmoment1(mu, lam) + + +@pytensor_jit +def ptd_lmoment2(mu, lam): + return ptd_wald.lmoment2(mu, lam) + + +@pytensor_jit +def ptd_lmoment3(mu, lam): + return ptd_wald.lmoment3(mu, lam) + + +@pytensor_jit +def ptd_lmoment4(mu, lam): + return ptd_wald.lmoment4(mu, lam) + + @pytensor_rng_jit def ptd_rvs(mu, lam, size, rng): return ptd_wald.rvs(mu, lam, size=size, random_state=rng) diff --git a/preliz/distributions/weibull.py b/preliz/distributions/weibull.py index 0ec26aad..6b3ac968 100644 --- a/preliz/distributions/weibull.py +++ b/preliz/distributions/weibull.py @@ -103,6 +103,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) @@ -177,6 +189,26 @@ def ptd_kurtosis(alpha, beta): return ptd_weibull.kurtosis(alpha, beta) +@pytensor_jit +def ptd_lmoment1(alpha, beta): + return ptd_weibull.lmoment1(alpha, beta) + + +@pytensor_jit +def ptd_lmoment2(alpha, beta): + return ptd_weibull.lmoment2(alpha, beta) + + +@pytensor_jit +def ptd_lmoment3(alpha, beta): + return ptd_weibull.lmoment3(alpha, beta) + + +@pytensor_jit +def ptd_lmoment4(alpha, beta): + return ptd_weibull.lmoment4(alpha, beta) + + @pytensor_rng_jit def ptd_rvs(alpha, beta, size, rng): return ptd_weibull.rvs(alpha, beta, size=size, random_state=rng) diff --git a/preliz/distributions/zi_binomial.py b/preliz/distributions/zi_binomial.py index bef40008..e5f9c73e 100644 --- a/preliz/distributions/zi_binomial.py +++ b/preliz/distributions/zi_binomial.py @@ -112,6 +112,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.psi, self.n, self.p) + def lmoment1(self): + return ptd_lmoment1(self.psi, self.n, self.p) + + def lmoment2(self): + return ptd_lmoment2(self.psi, self.n, self.p) + + def lmoment3(self): + return ptd_lmoment3(self.psi, self.n, self.p) + + def lmoment4(self): + return ptd_lmoment4(self.psi, self.n, self.p) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.psi, self.n, self.p, size=size, rng=random_state) @@ -183,6 +195,26 @@ def ptd_kurtosis(psi, n, p): return ptd_zibinomial.kurtosis(psi, n, p) +@pytensor_jit +def ptd_lmoment1(psi, n, p): + return ptd_zibinomial.lmoment1(psi, n, p) + + +@pytensor_jit +def ptd_lmoment2(psi, n, p): + return ptd_zibinomial.lmoment2(psi, n, p) + + +@pytensor_jit +def ptd_lmoment3(psi, n, p): + return ptd_zibinomial.lmoment3(psi, n, p) + + +@pytensor_jit +def ptd_lmoment4(psi, n, p): + return ptd_zibinomial.lmoment4(psi, n, p) + + @pytensor_rng_jit def ptd_rvs(psi, n, p, size, rng): return ptd_zibinomial.rvs(psi, n, p, size=size, random_state=rng) diff --git a/preliz/distributions/zi_negativebinomial.py b/preliz/distributions/zi_negativebinomial.py index a4e1d0a3..3f383cb9 100644 --- a/preliz/distributions/zi_negativebinomial.py +++ b/preliz/distributions/zi_negativebinomial.py @@ -168,6 +168,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.psi, self.n, self.p) + def lmoment1(self): + return ptd_lmoment1(self.psi, self.n, self.p) + + def lmoment2(self): + return ptd_lmoment2(self.psi, self.n, self.p) + + def lmoment3(self): + return ptd_lmoment3(self.psi, self.n, self.p) + + def lmoment4(self): + return ptd_lmoment4(self.psi, self.n, self.p) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.psi, self.n, self.p, size=size, rng=random_state) @@ -239,6 +251,26 @@ def ptd_kurtosis(psi, n, p): return ptd_zinegativebinomial.kurtosis(psi, n, p) +@pytensor_jit +def ptd_lmoment1(psi, n, p): + return ptd_zinegativebinomial.lmoment1(psi, n, p) + + +@pytensor_jit +def ptd_lmoment2(psi, n, p): + return ptd_zinegativebinomial.lmoment2(psi, n, p) + + +@pytensor_jit +def ptd_lmoment3(psi, n, p): + return ptd_zinegativebinomial.lmoment3(psi, n, p) + + +@pytensor_jit +def ptd_lmoment4(psi, n, p): + return ptd_zinegativebinomial.lmoment4(psi, n, p) + + @pytensor_rng_jit def ptd_rvs(psi, n, p, size, rng): return ptd_zinegativebinomial.rvs(psi, n, p, size=size, random_state=rng) diff --git a/preliz/distributions/zi_poisson.py b/preliz/distributions/zi_poisson.py index 68f12974..c3f60e5f 100644 --- a/preliz/distributions/zi_poisson.py +++ b/preliz/distributions/zi_poisson.py @@ -113,6 +113,18 @@ def skewness(self): def kurtosis(self): return ptd_kurtosis(self.psi, self.mu) + def lmoment1(self): + return ptd_lmoment1(self.psi, self.mu) + + def lmoment2(self): + return ptd_lmoment2(self.psi, self.mu) + + def lmoment3(self): + return ptd_lmoment3(self.psi, self.mu) + + def lmoment4(self): + return ptd_lmoment4(self.psi, self.mu) + def rvs(self, size=None, random_state=None): random_state = np.random.default_rng(random_state) return ptd_rvs(self.psi, self.mu, size=size, rng=random_state) @@ -178,6 +190,26 @@ def ptd_kurtosis(psi, mu): return ptd_zipoisson.kurtosis(psi, mu) +@pytensor_jit +def ptd_lmoment1(psi, mu): + return ptd_zipoisson.lmoment1(psi, mu) + + +@pytensor_jit +def ptd_lmoment2(psi, mu): + return ptd_zipoisson.lmoment2(psi, mu) + + +@pytensor_jit +def ptd_lmoment3(psi, mu): + return ptd_zipoisson.lmoment3(psi, mu) + + +@pytensor_jit +def ptd_lmoment4(psi, mu): + return ptd_zipoisson.lmoment4(psi, mu) + + @pytensor_rng_jit def ptd_rvs(psi, mu, size, rng): return ptd_zipoisson.rvs(psi, mu, size=size, random_state=rng) diff --git a/preliz/tests/test_lmoments.py b/preliz/tests/test_lmoments.py new file mode 100644 index 00000000..7dc3e053 --- /dev/null +++ b/preliz/tests/test_lmoments.py @@ -0,0 +1,49 @@ +import numpy as np + +import preliz as pz +from preliz.internal.distribution_helper import init_vals + +dists_with_lmoments = [ + "AsymmetricLaplace", + "Beta", + "Bernoulli", + "Binomial", + "Cauchy", + "DiscreteUniform", + "ExGaussian", + "Gamma", + "Gumbel", + "HalfNormal", + "HyperGeometric", + "Kumaraswamy", + "Laplace", + "NegativeBinomial", + "Normal", + "Pareto", + "Poisson", + "TruncatedNormal", + "Uniform", + "Wald", + "Weibull", + "ZeroInflatedNegativeBinomial", + "ZeroInflatedPoisson", +] + + +def test_lmoments(): + for name_dist, params in init_vals.items(): + if name_dist not in dists_with_lmoments: + continue + dist = getattr(pz, name_dist)(**params) + lm1, lm2, lm3, lm4 = dist.lmoments() + mean = dist.mean() + + if np.isnan(mean): + assert np.isnan(lm1) + else: + assert np.isclose(lm1, mean) + + assert lm2 >= 0 or np.isnan(lm2) + + assert np.isnan(lm3) or -1 <= lm3 <= 1 + assert np.isnan(lm4) or -1 <= lm4 <= 1