From 9ca58c349205894e67f30dd1406a601a76d4469b Mon Sep 17 00:00:00 2001
From: cargar_github <candemas97@hotmail.com>
Date: Sun, 20 Apr 2025 22:22:44 -0500
Subject: [PATCH 1/3] start adding api reference

---
 docs/.vitepress/config.mts                    |  48 +-
 .../discrete/discrete-distributions.md        | 969 ++++++++++++++++++
 docs/api/intro/installation.md                |  38 +
 docs/api/intro/what-is-phitter.md             |  23 +
 .../simulation/process/own-distribution.md    |  22 +
 .../simulation/process/process-simulation.md  |  86 ++
 .../simulation/queue/queueing-simulation.md   | 297 ++++++
 docs/documentation/intro/what-is-phitter.md   |   2 +-
 8 files changed, 1483 insertions(+), 2 deletions(-)
 create mode 100644 docs/api/distributions/discrete/discrete-distributions.md
 create mode 100644 docs/api/intro/installation.md
 create mode 100644 docs/api/intro/what-is-phitter.md
 create mode 100644 docs/api/simulation/process/own-distribution.md
 create mode 100644 docs/api/simulation/process/process-simulation.md
 create mode 100644 docs/api/simulation/queue/queueing-simulation.md

diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts
index 61a091f..7cb642c 100644
--- a/docs/.vitepress/config.mts
+++ b/docs/.vitepress/config.mts
@@ -10,7 +10,8 @@ export default defineConfig({
             provider: "local",
         },
         nav: [
-            { text: "Documentation", link: "/documentation/intro/what-is-phitter" },
+            { text: "API Reference", link: "/api/intro/what-is-phitter" },
+            { text: "User Guide", link: "/documentation/intro/what-is-phitter" },
             { text: "Releases", link: "/release/release-main" },
             { text: "Phitter Web", link: "https://phitter.io/" },
         ],
@@ -246,6 +247,51 @@ export default defineConfig({
                     ],
                 },
             ],
+            "/api/": [
+                {
+                    text: "Introduction",
+                    // collapsed: false,
+                    items: [
+                        { text: "What is Phitter?", link: "/api/intro/what-is-phitter" },
+                        { text: "Installation", link: "/api/intro/installation" },
+                    ],
+                },
+                {
+                    text: "Simulation",
+                    // collapsed: false,
+                    items: [
+                        {
+                            text: "Process Simulation",
+                            collapsed: true,
+                            items: [
+                                { text: "phitter.simulation.own_distribution", collapsed: true, link: "/api/simulation/process/own-distribution" },
+                                { text: "phitter.simulation.process_simulation", collapsed: true, link: "/api/simulation/process/process-simulation" },
+                            ],
+                        },
+                        {
+                            text: "Queueing Simulation",
+                            collapsed: true,
+                            items: [
+                                { text: "phitter.simulation.queueing_simulation", collapsed: true, link: "/api/simulation/queue/queueing-simulation" },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    text: "Distributions",
+                    // collapsed: false,
+                    items: [
+                        {
+                            text: "Discrete",
+                            collapsed: true,
+                            items: [
+                                { text: "Discrete", link: "/api/distributions/discrete/discrete-distributions" },
+                                { text: "Installation", link: "/api/intro/installation" },
+                            ],
+                        },
+                    ],
+                },
+            ]
         },
         socialLinks: [
             { icon: "github", link: "https://github.com/phitter-core/phitter-kernel" },
diff --git a/docs/api/distributions/discrete/discrete-distributions.md b/docs/api/distributions/discrete/discrete-distributions.md
new file mode 100644
index 0000000..1e3e1de
--- /dev/null
+++ b/docs/api/distributions/discrete/discrete-distributions.md
@@ -0,0 +1,969 @@
+# phitter.discrete.discrete_distributions package
+
+## phitter.discrete.discrete_distributions.bernoulli module
+
+_class_ phitter.discrete.discrete*distributions.bernoulli.Bernoulli(\_parameters=None*, _discrete_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Bernoulli distribution
+
+- Parameters Bernoulli Distribution: {“p”: \*}
+
+<https://phitter.io/distributions/discrete/bernoulli>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central_moments(\_k\*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_discrete_measures*)
+
+Calculate proper parameters of the distribution from sample discrete_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**discrete_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“p”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pmf(_x_)
+
+Probability mass function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.discrete.discrete_distributions.binomial module
+
+_class_ phitter.discrete.discrete*distributions.binomial.Binomial(\_parameters=None*, _discrete_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Binomial distribution
+
+## - Parameters Binomial Distribution: {“n”: \*, “p”: \*}
+
+## - <https://phitter.io/distributions/discrete/binomial>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_discrete_measures*)
+
+Calculate proper parameters of the distribution from sample discrete_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**discrete_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“n”: \*, “p”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pmf(_x_)
+
+Probability mass function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.discrete.discrete_distributions.geometric module
+
+_class_ phitter.discrete.discrete*distributions.geometric.Geometric(\_parameters=None*, _discrete_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Geometric distribution
+
+## - Parameters Geometric Distribution: {“p”: \*}
+
+## - <https://phitter.io/distributions/discrete/geometric>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_discrete_measures*)
+
+Calculate proper parameters of the distribution from sample discrete_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**discrete_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“p”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pmf(_x_)
+
+Probability mass function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.discrete.discrete_distributions.hypergeometric module
+
+_class_ phitter.discrete.discrete*distributions.hypergeometric.Hypergeometric(\_parameters=None*, _discrete_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Hypergeometric_distribution
+
+## - Parameters Hypergeometric Distribution: {“N”: \*, “K”: \*, “n”: \*}
+
+## - <https://phitter.io/distributions/discrete/hypergeometric>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get_parameters(\_discrete_measures\*)
+
+Calculate proper parameters of the distribution from sample discrete_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+- **discrete_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“N”: \*, “K”: \*, “n”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pmf(_x_)
+
+Probability mass function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.discrete.discrete_distributions.logarithmic module
+
+_class_ phitter.discrete.discrete*distributions.logarithmic.Logarithmic(\_parameters=None*, _discrete_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Logarithmic distribution
+
+## - Parameters Logarithmic Distribution: {“p”: \*}
+
+## - <https://phitter.io/distributions/discrete/logarithmic>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_discrete_measures*)
+
+Calculate proper parameters of the distribution from sample discrete_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**discrete_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“p”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pmf(_x_)
+
+Probability mass function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.discrete.discrete_distributions.negative_binomial module
+
+_class_ phitter.discrete.discrete*distributions.negative_binomial.NegativeBinomial(\_parameters=None*, _discrete_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Negative binomial distribution
+
+## - Parameters NegativeBinomial Distribution: {“r”: \*, “p”: \*}
+
+## - <https://phitter.io/distributions/discrete/negative_binomial>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_discrete_measures*)
+
+Calculate proper parameters of the distribution from sample discrete_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**discrete_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“r”: \*, “p”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pmf(_x_)
+
+Probability mass function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.discrete.discrete_distributions.poisson module
+
+_class_ phitter.discrete.discrete*distributions.poisson.Poisson(\_parameters=None*, _discrete_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Poisson distribution
+
+## - Parameters Poisson Distribution: {“lambda”: \*}
+
+## - <https://phitter.io/distributions/discrete/poisson>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_discrete_measures*)
+
+Calculate proper parameters of the distribution from sample discrete_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**discrete_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“lambda”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pmf(_x_)
+
+Probability mass function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.discrete.discrete_distributions.uniform module
+
+_class_ phitter.discrete.discrete*distributions.uniform.Uniform(\_parameters=None*, _discrete_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Uniform distribution
+
+## - Parameters Uniform Distribution: {“a”: \*, “b”: \*}
+
+## - <https://phitter.io/distributions/discrete/uniform>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_discrete_measures*)
+
+Calculate proper parameters of the distribution from sample discrete_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**discrete_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pmf(_x_)
+
+Probability mass function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
diff --git a/docs/api/intro/installation.md b/docs/api/intro/installation.md
new file mode 100644
index 0000000..858de24
--- /dev/null
+++ b/docs/api/intro/installation.md
@@ -0,0 +1,38 @@
+# Installation
+
+## Installation from PyPI
+
+Phitter is hosted on [PyPI](https://pypi.org/project/phitter/) and may be installed by means of the `pip` package manager. To install the latest available version, execute the following command in a terminal:
+
+### Requirements
+
+```console
+python: >=3.9
+```
+
+### PyPI
+
+```bash
+pip install phitter
+```
+
+To install a specific version, append the desired version number. For instance, to install version 0.7.2:
+
+```bash
+pip install phitter==0.7.2
+```
+
+Detailed information concerning each release is provided in the [Release Notes](/release/release-main.md).
+
+> **Note:** It is strongly recommended to install the latest version of Phitter in order to ensure optimal stability and performance.
+
+## Dependencies
+
+- `scipy`>=1.1.0
+- `plotly`>=5.14.0
+- `kaleido`>=0.2.1
+- `matplotlib`>=3.3
+- `IPython`>=0.13
+- `pytest`
+- `pandas`>=1.5.0
+- `graphviz`>=0.5.1
diff --git a/docs/api/intro/what-is-phitter.md b/docs/api/intro/what-is-phitter.md
new file mode 100644
index 0000000..fbde0ec
--- /dev/null
+++ b/docs/api/intro/what-is-phitter.md
@@ -0,0 +1,23 @@
+# What is Phitter?
+
+Phitter is a Python library and [web application](https://phitter.io/) designed for accurately fitting and simulate statistical distributions to datasets. It provides intuitive usage, comprehensive visualization capabilities, and support for multiple distributions, facilitating enhanced data analysis projects.
+
+## Motivation
+
+When I began studying probability distribution fitting for event simulation, I realized that although data distributions were extensively studied, inferring the best fit for a given dataset was a non-trivial task. A common exercise is fitting a distribution with parameters that can be estimated from the sample, such as the normal distribution, whose parameters are the mean and standard deviation. I wondered: what if I want to automatically fit all known distributions? What if parameter inference for a particular distribution is challenging? These difficulties were further exacerbated when working within spreadsheet environments like Excel.
+
+Attempting to solve this problem, I discovered that software existed in the market capable of performing such tasks; however, they were typically commercial desktop applications. Motivated by this, I decided to create a free web-based application offering similar functionality. During this development, I encountered Python, which effectively addressed most data analysis challenges in a clear and standardized manner, though not specifically for distribution fitting.
+
+The powerful Scipy library, particularly its `stats` module, implements many distributions and solves the critical issue of parameter estimation from samples. Existing Python packages for distribution fitting generally iterate over Scipy’s distributions. However, a notable limitation of Scipy is that, for certain distributions, the implementation differs from widely recognized definitions. For example, the Beta distribution, as commonly referenced in literature cited in the following section, typically involves two shape parameters along with minimum and maximum values. In Scipy, however, the Beta distribution uses two shape parameters plus location and scale parameters.
+
+Considering these aspects, I developed individual implementations for each distribution to accelerate parameter estimation using the method of moments, supported by spreadsheet validation for consistency and immediate practical applicability. This development was largely based on Scipy's implementation, leveraging numpy behind the scenes. All these considerations form the motivation behind the creation of Phitter.
+
+## Features
+
+1. Phitter implements probability distributions as standardized as possible according to the following sources: [Wikipedia](https://wikipedia.org), [Compendium of Common Probability Distributions](https://www.causascientia.org/math_stat/Dists/Compendium.pdf), and [Handbook on Statistical Distributions for Experimentalists](https://www.stat.rice.edu/~dobelman/textfiles/DistributionsHandbook.pdf).
+
+2. Phitter aims to implement accelerated methods for calculating distribution parameters wherever feasible. To achieve this, it solves the distribution’s parametric equation system, significantly faster than Scipy’s `.fit` method. Nonetheless, this method is not applicable to every distribution. The estimation times for each distribution based on sample sizes are detailed in this table: [Estimation Time Parameters for Continuous Distributions](/documentation/benchmarks/continuous/continuous-parameters-estimation.md). For distributions where estimation time is recorded as zero for a given sample size, the parametric equation system has been solved. If estimation times increase, Phitter resorts to Scipy's maximum likelihood estimation method, significantly enhancing performance.
+
+3. To verify the distribution implementations or facilitate spreadsheet usage, refer to the documentation provided in [Continuous Distributions](/documentation/distributions/continuous-distributions.html) and [Discrete Distributions](/documentation/distributions/discrete-distributions.html).
+
+4. Phitter implements goodness-of-fit testing following the proposal outlined in the article: [Evaluating the Anderson-Darling Distribution](https://www.jstatsoft.org/article/view/v009i02).
diff --git a/docs/api/simulation/process/own-distribution.md b/docs/api/simulation/process/own-distribution.md
new file mode 100644
index 0000000..413c438
--- /dev/null
+++ b/docs/api/simulation/process/own-distribution.md
@@ -0,0 +1,22 @@
+# phitter.simulation.own_distribution package
+
+## phitter.simulation.own_distribution.own_distribution module
+
+_class_ phitter.simulation.own*distribution.own_distribution.OwnDistributions(\_parameters*)
+: Bases: `object`
+
+## ppf (_probability_)
+
+Assign a label according to a probability given by the created distribution
+
+#### Parameters
+
+- **probability** (_int_) – Number between 0 and 1
+
+#### Returns
+
+Returns label according to probability
+
+#### Return type
+
+`int`
diff --git a/docs/api/simulation/process/process-simulation.md b/docs/api/simulation/process/process-simulation.md
new file mode 100644
index 0000000..cc85af3
--- /dev/null
+++ b/docs/api/simulation/process/process-simulation.md
@@ -0,0 +1,86 @@
+# phitter.simulation.process_simulation package
+
+## phitter.simulation.process_simulation.process_simulation module
+
+_class_ phitter.simulation.process_simulation.process_simulation.ProcessSimulation
+: Bases: `object`
+
+## add*process(\_prob_distribution*, _parameters_, _process_id_, _number_of_products=1_, _number_of_servers=1_, _new_branch=False_, _previous_ids=None_)
+
+Add element to the simulation
+
+#### Parameters
+
+- **prob_distribution** (_str_) – Probability distribution to be used. You can use one of the following: ‘alpha’, ‘arcsine’, ‘argus’, ‘beta’, ‘beta_prime’, ‘beta_prime_4p’, ‘bradford’, ‘burr’, ‘burr_4p’, ‘cauchy’, ‘chi_square’, ‘chi_square_3p’, ‘dagum’, ‘dagum_4p’, ‘erlang’, ‘erlang_3p’, ‘error_function’, ‘exponential’, ‘exponential_2p’, ‘f’, ‘fatigue_life’, ‘folded_normal’, ‘frechet’, ‘f_4p’, ‘gamma’, ‘gamma_3p’, ‘generalized_extreme_value’, ‘generalized_gamma’, ‘generalized_gamma_4p’, ‘generalized_logistic’, ‘generalized_normal’, ‘generalized_pareto’, ‘gibrat’, ‘gumbel_left’, ‘gumbel_right’, ‘half_normal’, ‘hyperbolic_secant’, ‘inverse_gamma’, ‘inverse_gamma_3p’, ‘inverse_gaussian’, ‘inverse_gaussian_3p’, ‘johnson_sb’, ‘johnson_su’, ‘kumaraswamy’, ‘laplace’, ‘levy’, ‘loggamma’, ‘logistic’, ‘loglogistic’, ‘loglogistic_3p’, ‘lognormal’, ‘maxwell’, ‘moyal’, ‘nakagami’, ‘non_central_chi_square’, ‘non_central_f’, ‘non_central_t_student’, ‘normal’, ‘pareto_first_kind’, ‘pareto_second_kind’, ‘pert’, ‘power_function’, ‘rayleigh’, ‘reciprocal’, ‘rice’, ‘semicircular’, ‘trapezoidal’, ‘triangular’, ‘t_student’, ‘t_student_3p’, ‘uniform’, ‘weibull’, ‘weibull_3p’, ‘bernoulli’, ‘binomial’, ‘geometric’, ‘hypergeometric’, ‘logarithmic’, ‘negative_binomial’, ‘poisson’.
+
+- **parameters** (_dict_) – Parameters of the probability distribution.
+- **process_id** (_str_) – Unique name of the process to be simulated
+- **number_of_products** (_int_ _,\*\*optional_) – Number of elements that are needed to simulate in that stage. Value has to be greater than 0. Defaults equals to 1.
+- **number_of_servers** (_int\*\*,_ _optional_) – Number of servers that process has and are needed to simulate in that stage. Value has to be greater than 0. Defaults equals to 1.
+- **new_branch** (_bool_ _,\*\*optional_) – Required if you want to start a new process that does not have previous processes. You cannot use this parameter at the same time with “previous_id”. Defaults to False.
+- **previous_id** (_list**[**str**]**,_ _optional_) – Required if you have previous processes that are before this process. You cannot use this parameter at the same time with “new_branch”. Defaults to None.
+
+#### Return type
+
+`None`
+
+## process*graph(\_graph_direction='LR'*, _save_graph_pdf=False_)
+
+Generates the graph of the process
+
+#### Parameters
+
+- **graph_direction** (_str\*\*,_ _optional_) – You can show the graph in two ways: ‘LR’ left to right OR ‘TB’ top to bottom. Defaults to ‘LR’.
+
+- **save_graph_pdf** (_bool\*\*,_ _optional_) – You can save the process graph in a PDF file. Defaults to False.
+
+#### Return type
+
+`None`
+
+## run(_number_of_simulations=1_)
+
+Simulation of the described process
+
+#### Parameters
+
+- **number_of_simulations** (_int\*\*,_ _optional_) – Number of simulations of the process that you want to do. Defaults to 1.
+
+#### Returns
+
+Results of every simulation requested
+
+#### Return type
+
+`list[float]`
+
+## run*confidence_interval(\_confidence_level=0.95*, _number_of_simulations=1_, _replications=30_)
+
+Generates a confidence interval for the replications of the requested number of simulations.
+
+#### Parameters
+
+- **confidence_level** (_float\*\*,_ _optional_) – Confidence required of the interval. Defaults to 0.95.
+
+- **number_of_simulations** (_int\*\*,_ _optional_) – Number of simulations that are going to be run in each replication. Defaults to 1.
+- **replications** (_int\*\*,_ _optional_) – Number of samples needed. Defaults to 30.
+
+#### Returns
+
+Returns the lower bound, average, upper bound and standard deviation of the confidence interval
+
+#### Return type
+
+`tuple[float]`
+
+## simulation_metrics()
+
+Here you can find the average time per process and standard deviation
+
+#### Returns
+
+Average and Standard deviation
+
+#### Return type
+
+`pd.DataFrame`
diff --git a/docs/api/simulation/queue/queueing-simulation.md b/docs/api/simulation/queue/queueing-simulation.md
new file mode 100644
index 0000000..65feab8
--- /dev/null
+++ b/docs/api/simulation/queue/queueing-simulation.md
@@ -0,0 +1,297 @@
+# phitter.simulation.queueing_simulation package
+
+## phitter.simulation.queueing_simulation.queueing_simulation module
+
+_class_ phitter.simulation.queueing*simulation.queueing_simulation.QueueingSimulation(\_a*, _a_parameters_, _s_, _s_parameters_, _c_, _k=inf_, _n=inf_, _d='FIFO'_, _pbs_distribution=None_, _pbs_parameters=None_)
+: Bases: `object`
+
+## average_elements_queue()
+
+Average elements in queue
+
+#### Returns
+
+Average elements in queue
+
+#### Return type
+
+`float`
+
+## average_elements_system()
+
+Average elements in system
+
+#### Returns
+
+Average elements in system
+
+#### Return type
+
+`float`
+
+## average_time_queue()
+
+Average time in queue
+
+#### Returns
+
+Average time in queue
+
+#### Return type
+
+`float`
+
+## average_time_service()
+
+Average time in service
+
+#### Returns
+
+Average time in service
+
+#### Return type
+
+`float`
+
+## average_time_system()
+
+Average time in system
+
+#### Returns
+
+Average time in system
+
+#### Return type
+
+`float`
+
+## confidence*interval_metrics(\_simulation_time=inf*, _confidence_level=0.95_, _replications=30_)
+
+Generate a confidence interval for probabilities and metrics.
+
+#### Parameters
+
+- **simulation_time** (_int\*\*,_ _optional_) – Simulation time. Defaults to float(“Inf)
+
+- **confidence_level** (_int\*\*,_ _optional_) – Confidence level for the confidence interval for all the metrics and probabilities. Defaults to 0.95.
+- **replications** (_int\*\*,_ _optional_) – Number of samples of simulations to create. Defaults to 30.
+
+#### Returns
+
+Returns probabilities and metrics dataframe with confidene interval for all metrics.
+
+#### Return type
+
+`tuple[pd.DataFrame, pd.DataFrame]`
+
+## elements*prob(\_bins=50000*)
+
+Creates the probability for each number of elements. Example: Probability to be 0, prob. to be 1, prob. to be 2… depending on simulation values
+
+#### Parameters
+
+- **bins** (_int\*\*,_ _optional_) – Number of intervals to determine the probability to be in each stage. Defaults to 50000.
+
+#### Returns
+
+Element and probability result
+
+#### Return type
+
+`dict`
+
+## metrics_summary()
+
+Returns the summary of the following metrics: Average Time in System, Average Time in Queue, Average Time in Service, Std. Dev. Time in System, Std. Dev. Time in Queue, Std. Dev. Time in Service, Average Elements in System, Average Elements in Queue, Probability to join the System, Probability to finish after Time, Probability to Wait in Line
+
+#### Returns
+
+Returns dataframe with all the information
+
+#### Return type
+
+`pd.DataFrame`
+
+## no_clients_prob()
+
+Probability of no having clients
+
+#### Returns
+
+No clients probability
+
+#### Return type
+
+`float`
+
+## number_elements_prob(\_number\*, \_prob_type\*)
+
+Calculates the probability Exact, less or equals or greater or equals.
+
+#### Parameters
+
+- **number** (_int_) – Number that we want to identify the different probabilities
+
+- **prob_type** (_str_) – Could be one of the following options: ‘exact_value’, ‘greater_equals’, ‘less_equals’
+
+#### Returns
+
+Probability of the number of elements
+
+#### Return type
+
+`float`
+
+## number_probability_summary()
+
+Returns the probability for each element. The probability is Exact, less or equals or greater or equals; represented in each column.
+
+#### Returns
+
+Dataframe with all the needed probabilities for each element.
+
+#### Return type
+
+`pd.DataFrame`
+
+## probability_to_finish_after_time()
+
+Probability to finish after time
+
+#### Returns
+
+Probability to finish after time
+
+#### Return type
+
+`float`
+
+## probability_to_join_system()
+
+Probability to join the system
+
+#### Returns
+
+Probability to join the system
+
+#### Return type
+
+`float`
+
+## probability_to_wait_in_line()
+
+Probability to wait in the queue
+
+#### Returns
+
+Probability to wait in the queue
+
+#### Return type
+
+`float`
+
+## run(_simulation_time=inf_)
+
+Simulation of any queueing model.
+
+#### Parameters
+
+- **simulation_time** (_float\*\*,_ _optional_) – This variable defines the total duration of the simulation. It sets the length of time over which the simulation will model the system’s behavior. Defaults to float(“inf”)
+
+- **number_of_simulations** (_int\*\*,_ _optional_) – Number of simulations of the process. Can also be considered as the number of days or number of times you want to simulate your scenario. Defaults to 1.
+
+#### Returns
+
+Returns the Simulation
+
+#### Return type
+
+`pd.DataFrame`
+
+## servers_utilization()
+
+Determine the server utilization according to the simulation result
+
+#### Returns
+
+Utilization of all servers, you can find the server number in the rows
+
+#### Return type
+
+`pd.DataFrame`
+
+## standard_deviation_time_queue()
+
+Standard Deviation time in queue
+
+#### Returns
+
+Standard Deviation time in queue
+
+#### Return type
+
+`float`
+
+## standard_deviation_time_service()
+
+Standard Deviation time in service
+
+#### Returns
+
+Standard Deviation time in service
+
+#### Return type
+
+`float`
+
+## standard_deviation_time_system()
+
+Standard Deviation time in system
+
+#### Returns
+
+Standard Deviation time in system
+
+#### Return type
+
+`float`
+
+## system_utilization()
+
+Returns system utilization according to simulation
+
+#### Returns
+
+System Utilization
+
+#### Return type
+
+`float`
+
+## to_csv(\_file_name\*, \_index=True\*)
+
+Simulation results to CVS
+
+#### Parameters
+
+- **file_name** (_str_) – File Name to add to the CSV file. You should include “.csv” at the end of your file
+
+- **index** (_bool\*\*,_ _optional_) – Defaults to True. Add index in CSV file.
+
+#### Return type
+
+`None`
+
+## to_excel(\_file_name\*, \_sheet_name='Sheet1'\*, \_index=True\*)
+
+Simulation results to Excel File
+
+#### Parameters
+
+- **file_name** (_str_) – File Name to add to the Excel file. You should include “.xlsx” at the end of your file
+
+- **index** (_bool\*\*,_ _optional_) – Defaults to True. Add index in Excel file.
+
+#### Return type
+
+`None`
diff --git a/docs/documentation/intro/what-is-phitter.md b/docs/documentation/intro/what-is-phitter.md
index 0dc7b36..fbde0ec 100644
--- a/docs/documentation/intro/what-is-phitter.md
+++ b/docs/documentation/intro/what-is-phitter.md
@@ -1,6 +1,6 @@
 # What is Phitter?
 
-Phitter is a Python library and [web application](https://phitter.io/) designed for accurately fitting statistical distributions to datasets. It provides intuitive usage, comprehensive visualization capabilities, and support for multiple distributions, facilitating enhanced data analysis projects.
+Phitter is a Python library and [web application](https://phitter.io/) designed for accurately fitting and simulate statistical distributions to datasets. It provides intuitive usage, comprehensive visualization capabilities, and support for multiple distributions, facilitating enhanced data analysis projects.
 
 ## Motivation
 

From 306f87c0946962d8fd89c670977eb049b156230e Mon Sep 17 00:00:00 2001
From: cargar_github <candemas97@hotmail.com>
Date: Mon, 21 Apr 2025 21:31:56 -0500
Subject: [PATCH 2/3] modifing distributions

---
 docs/.vitepress/config.mts                    |   10 +-
 docs/api/distributions/continous/continous.md | 8807 +++++++++++++++++
 .../discrete/discrete-distributions.md        |   35 +-
 3 files changed, 8829 insertions(+), 23 deletions(-)
 create mode 100644 docs/api/distributions/continous/continous.md

diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts
index 7cb642c..09e8adc 100644
--- a/docs/.vitepress/config.mts
+++ b/docs/.vitepress/config.mts
@@ -285,8 +285,14 @@ export default defineConfig({
                             text: "Discrete",
                             collapsed: true,
                             items: [
-                                { text: "Discrete", link: "/api/distributions/discrete/discrete-distributions" },
-                                { text: "Installation", link: "/api/intro/installation" },
+                                { text: "Discrete", link: "/api/distributions/discrete/discrete-distributions" }
+                            ],
+                        },
+                        {
+                            text: "Continuous",
+                            collapsed: true,
+                            items: [
+                                { text: "Continous", link: "/api/distributions/continous/continous" }
                             ],
                         },
                     ],
diff --git a/docs/api/distributions/continous/continous.md b/docs/api/distributions/continous/continous.md
new file mode 100644
index 0000000..ced40b3
--- /dev/null
+++ b/docs/api/distributions/continous/continous.md
@@ -0,0 +1,8807 @@
+# phitter.continuous.continuous_distributions package
+
+## phitter.continuous.continuous_distributions.alpha module
+
+_class_ phitter.continuous.continuous*distributions.alpha.Alpha(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Alpha distribution
+
+- Parameters Alpha Distribution: {“alpha”: \*, “loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/alpha>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments (\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters (\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.arcsine module
+
+_class_ phitter.continuous.continuous*distributions.arcsine.Arcsine(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Arcsine distribution
+
+- Parameters Arcsine Distribution: {“a”: \*, “b”: \*}
+  <https://phitter.io/distributions/continuous/arcsine>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.argus module
+
+_class_ phitter.continuous.continuous*distributions.argus.Argus(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Argus distribution
+
+- Parameters Argus Distribution: {“chi”: \*, “loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/argus>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“chi”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.beta module
+
+_class_ phitter.continuous.continuous*distributions.beta.Beta(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Beta distribution
+
+- Parameters Beta Distribution: {“alpha”: \*, “beta”: \*, “A”: \*, “B”: \*}
+  <https://phitter.io/distributions/continuous/beta>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*, “A”: \*, “B”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.beta_prime module
+
+_class_ phitter.continuous.continuous*distributions.beta_prime.BetaPrime(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Beta Prime Distribution
+
+- Parameters BetaPrime Distribution: {“alpha”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/beta_prime>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.beta_prime_4p module
+
+_class_ phitter.continuous.continuous*distributions.beta_prime_4p.BetaPrime4P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Beta Prime 4P Distribution
+
+- Parameters BetaPrime4P Distribution: {“alpha”: \*, “beta”: \*, “loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/beta_prime_4p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.bradford module
+
+_class_ phitter.continuous.continuous*distributions.bradford.Bradford(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Bradford distribution
+
+- Parameters Bradford Distribution: {“c”: \*, “min”: \*, “max”: \*}
+  <https://phitter.io/distributions/continuous/bradford>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“c”: \*, “min”: \*, “max”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.burr module
+
+_class_ phitter.continuous.continuous*distributions.burr.Burr(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Burr distribution
+
+- Parameters Burr Distribution: {“A”: \*, “B”: \*, “C”: \*}
+  <https://phitter.io/distributions/continuous/burr>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“A”: \*, “B”: \*, “C”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.burr_4p module
+
+_class_ phitter.continuous.continuous*distributions.burr_4p.Burr4P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Burr distribution
+
+- Parameters Burr4P Distribution: {“A”: \*, “B”: \*, “C”: \*, “loc”: \*}
+  <https://phitter.io/distributions/continuous/burr_4p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“A”: \*, “B”: \*, “C”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.cauchy module
+
+_class_ phitter.continuous.continuous*distributions.cauchy.Cauchy(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Cauchy distribution
+
+- Parameters Cauchy Distribution: {“x0”: \*, “gamma”: \*}
+  <https://phitter.io/distributions/continuous/cauchy>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“x0”: \*, “gamma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.chi_square module
+
+_class_ phitter.continuous.continuous*distributions.chi_square.ChiSquare(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Chi Square distribution
+
+- Parameters ChiSquare Distribution: {“df”: \*}
+  <https://phitter.io/distributions/continuous/chi_square>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“df”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.chi_square_3p module
+
+_class_ phitter.continuous.continuous*distributions.chi_square_3p.ChiSquare3P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Chi Square distribution
+
+- Parameters ChiSquare3P Distribution: {“df”: \*, “loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/chi_square_3p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“df”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.dagum module
+
+_class_ phitter.continuous.continuous*distributions.dagum.Dagum(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Dagum distribution
+
+- Parameters Dagum Distribution: {“a”: \*, “b”: \*, “p”: \*}
+  <https://phitter.io/distributions/continuous/dagum>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*, “p”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.dagum_4p module
+
+_class_ phitter.continuous.continuous*distributions.dagum_4p.Dagum4P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Dagum distribution
+
+- Parameters Dagum4P Distribution: {“a”: \*, “b”: \*, “p”: \*, “loc”: \*}
+  <https://phitter.io/distributions/continuous/dagum_4p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*, “p”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.erlang module
+
+_class_ phitter.continuous.continuous*distributions.erlang.Erlang(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Erlang distribution
+
+- Parameters Erlang Distribution: {“k”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/erlang>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“k”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restriction
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.erlang_3p module
+
+_class_ phitter.continuous.continuous*distributions.erlang_3p.Erlang3P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Erlang 3p distribution
+
+- Parameters Erlang3P Distribution: {“k”: \*, “beta”: \*, “loc”: \*}
+  <https://phitter.io/distributions/continuous/erlang_3p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“k”: \*, “beta”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restriction
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.error_function module
+
+_class_ phitter.continuous.continuous*distributions.error_function.ErrorFunction(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Error Function distribution
+
+- Parameters ErrorFunction Distribution: {“h”: \*}
+  <https://phitter.io/distributions/continuous/error_function>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“h”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.exponential module
+
+_class_ phitter.continuous.continuous*distributions.exponential.Exponential(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Exponential distribution
+
+- Parameters Exponential Distribution: {“lambda”: \*}
+  <https://phitter.io/distributions/continuous/exponential>
+
+## cdf(_x_)
+
+Cumulative distribution function.
+
+- Calculated with known formula.
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“lambda”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.exponential_2p module
+
+_class_ phitter.continuous.continuous*distributions.exponential_2p.Exponential2P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Exponential distribution
+
+- Parameters Exponential2P Distribution: {“lambda”: \*, “loc”: \*}
+  <https://phitter.io/distributions/continuous/exponential_2p>
+
+## cdf(_x_)
+
+Cumulative distribution function.
+
+- Calculated with known formula.
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“lambda”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.f module
+
+_class_ phitter.continuous.continuous*distributions.f.F(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## F distribution
+
+- Parameters F Distribution: {“df1”: \*, “df2”: \*}
+  <https://phitter.io/distributions/continuous/f>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“df1”: \*, “df2”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.f_4p module
+
+_class_ phitter.continuous.continuous*distributions.f_4p.F4P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## F distribution
+
+- Parameters F4P Distribution: {“df1”: \*, “df2”: \*, “loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/f_4p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“df1”: \*, “df2”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.fatigue_life module
+
+_class_ phitter.continuous.continuous*distributions.fatigue_life.FatigueLife(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Fatigue life Distribution
+
+## Also known as Birnbaum-Saunders distribution
+
+- Parameters FatigueLife Distribution: {“gamma”: \*, “loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/fatigue_life>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“gamma”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.folded_normal module
+
+_class_ phitter.continuous.continuous*distributions.folded_normal.FoldedNormal(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Folded Normal Distribution
+
+## - <https://phitter.io/distributions/continuous/folded_normal>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.frechet module
+
+_class_ phitter.continuous.continuous*distributions.frechet.Frechet(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Fréchet Distribution
+
+## Also known as inverse Weibull distribution (Scipy name)
+
+## - <https://phitter.io/distributions/continuous/frechet>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.gamma module
+
+_class_ phitter.continuous.continuous*distributions.gamma.Gamma(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Gamma distribution
+
+- Parameters Gamma Distribution: {“alpha”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/gamma>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.gamma_3p module
+
+_class_ phitter.continuous.continuous*distributions.gamma_3p.Gamma3P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Gamma distribution
+
+- Parameters Gamma3P Distribution: {“alpha”: \*, “loc”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/gamma_3p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “loc”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.generalized_extreme_value module
+
+_class_ phitter.continuous.continuous*distributions.generalized_extreme_value.GeneralizedExtremeValue(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Generalized Extreme Value Distribution
+
+## - <https://phitter.io/distributions/continuous/generalized_extreme_value>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“xi”: \*, “mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.generalized_gamma module
+
+_class_ phitter.continuous.continuous*distributions.generalized_gamma.GeneralizedGamma(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Generalized Gamma Distribution
+
+## - <https://phitter.io/distributions/continuous/generalized_gamma>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “d”: \*, “p”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.generalized_gamma_4p module
+
+_class_ phitter.continuous.continuous*distributions.generalized_gamma_4p.GeneralizedGamma4P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Generalized Gamma Distribution
+
+## - <https://phitter.io/distributions/continuous/generalized_gamma_4p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “d”: \*, “p”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.generalized_logistic module
+
+_class_ phitter.continuous.continuous*distributions.generalized_logistic.GeneralizedLogistic(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Generalized Logistic Distribution
+
+## \* <https://phitter.io/distributions/continuous/generalized_logistic>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“loc”: \*, “scale”: \*, “c”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.generalized_normal module
+
+_class_ phitter.continuous.continuous*distributions.generalized_normal.GeneralizedNormal(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Generalized normal distribution
+
+- Parameters GeneralizedNormal Distribution: {“beta”: \*, “mu”: \*, “alpha”: \*}
+  <https://phitter.io/distributions/continuous/generalized_normal>
+
+This distribution is known whit the following names:
+
+- Error Distribution
+- Exponential Power Distribution
+- Generalized Error Distribution (GED)
+- Generalized Gaussian distribution (GGD)
+- Subbotin distribution
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“beta”: \*, “mu”: \*, “alpha”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restriction
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.generalized_pareto module
+
+_class_ phitter.continuous.continuous*distributions.generalized_pareto.GeneralizedPareto(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Generalized Pareto distribution
+
+- Parameters GeneralizedPareto Distribution: {“c”: \*, “mu”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/generalized_pareto>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“c”: \*, “mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.gibrat module
+
+_class_ phitter.continuous.continuous*distributions.gibrat.Gibrat(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Gibrat distribution
+
+- Parameters Gibrat Distribution: {“loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/gibrat>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.gumbel_left module
+
+_class_ phitter.continuous.continuous*distributions.gumbel_left.GumbelLeft(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Gumbel Left Distribution
+
+## Gumbel Min Distribution
+
+## Extreme Value Minimum Distribution
+
+## - <https://phitter.io/distributions/continuous/gumbel_left>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.gumbel_right module
+
+_class_ phitter.continuous.continuous*distributions.gumbel_right.GumbelRight(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Gumbel Right Distribution
+
+## Gumbel Max Distribution
+
+## Extreme Value Maximum Distribution
+
+## \* <https://phitter.io/distributions/continuous/gumbel_right>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.half_normal module
+
+_class_ phitter.continuous.continuous*distributions.half_normal.HalfNormal(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Half Normal Distribution
+
+## - <https://phitter.io/distributions/continuous/half_normal>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.hyperbolic_secant module
+
+_class_ phitter.continuous.continuous*distributions.hyperbolic_secant.HyperbolicSecant(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Hyperbolic Secant distribution
+
+- Parameters HyperbolicSecant Distribution: {“mu”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/hyperbolic_secant>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.inverse_gamma module
+
+_class_ phitter.continuous.continuous*distributions.inverse_gamma.InverseGamma(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Inverse Gamma Distribution
+
+## Also known Pearson Type 5 distribution
+
+- Parameters InverseGamma Distribution: {“alpha”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/inverse_gamma>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.inverse_gamma_3p module
+
+_class_ phitter.continuous.continuous*distributions.inverse_gamma_3p.InverseGamma3P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Inverse Gamma Distribution
+
+## Also known Pearson Type 5 distribution
+
+- Parameters InverseGamma3P Distribution: {“alpha”: \*, “beta”: \*, “loc”: \*}
+  <https://phitter.io/distributions/continuous/inverse_gamma_3p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.inverse_gaussian module
+
+_class_ phitter.continuous.continuous*distributions.inverse_gaussian.InverseGaussian(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Inverse Gaussian Distribution
+
+## Also known like Wald distribution
+
+- Parameters InverseGaussian Distribution: {“mu”: \*, “lambda”: \*}
+  <https://phitter.io/distributions/continuous/inverse_gaussian>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “lambda”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.inverse_gaussian_3p module
+
+_class_ phitter.continuous.continuous*distributions.inverse_gaussian_3p.InverseGaussian3P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Inverse Gaussian Distribution
+
+## Also known like Wald distribution
+
+- Parameters InverseGaussian3P Distribution: {“mu”: \*, “lambda”: \*, “loc”: \*}
+  <https://phitter.io/distributions/continuous/inverse_gaussian_3p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “lambda”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.johnson_sb module
+
+_class_ phitter.continuous.continuous*distributions.johnson_sb.JohnsonSB(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Johnson SB distribution
+
+- Parameters JohnsonSB Distribution: {“xi”: \*, “lambda”: \*, “gamma”: \*, “delta”: \*}
+  <https://phitter.io/distributions/continuous/johnson_sb>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated with the method proposed in [1].
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters** – {“xi”: \* , “lambda”: \* , “gamma”: \* , “delta”: \* }
+
+#### Return type
+
+{“xi”: \*, “lambda”: \*, “gamma”: \*, “delta”: \*}
+
+- References
+
+- [1]
+
+- George, F., & Ramachandran, K. M. (2011).
+- Estimation of parameters of Johnson’s system of distributions.
+- Journal of Modern Applied Statistical Methods, 10(2), 9.
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.johnson_su module
+
+_class_ phitter.continuous.continuous*distributions.johnson_su.JohnsonSU(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Johnson SU distribution
+
+- Parameters JohnsonSU Distribution: {“xi”: \*, “lambda”: \*, “gamma”: \*, “delta”: \*}
+  <https://phitter.io/distributions/continuous/johnson_su>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Return type
+`dict`[`str`, `float` | `int`]
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.kumaraswamy module
+
+_class_ phitter.continuous.continuous*distributions.kumaraswamy.Kumaraswamy(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Kumaraswami distribution
+
+- Parameters Kumaraswamy Distribution: {“alpha”: \*, “beta”: \*, “min”: \*, “max”: \*}
+  <https://phitter.io/distributions/continuous/kumaraswamy>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*, “min”: \*, “max”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.laplace module
+
+_class_ phitter.continuous.continuous*distributions.laplace.Laplace(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Laplace distribution
+
+- Parameters Laplace Distribution: {“mu”: \*, “b”: \*}
+  <https://phitter.io/distributions/continuous/laplace>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “b”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.levy module
+
+_class_ phitter.continuous.continuous*distributions.levy.Levy(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Levy distribution
+
+- Parameters Levy Distribution: {“mu”: \*, “c”: \*}
+  <https://phitter.io/distributions/continuous/levy>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “c”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.loggamma module
+
+_class_ phitter.continuous.continuous*distributions.loggamma.LogGamma(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## LogGamma distribution
+
+- Parameters LogGamma Distribution: {“c”: \*, “mu”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/loggamma>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“c”: \*, “mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.logistic module
+
+_class_ phitter.continuous.continuous*distributions.logistic.Logistic(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Logistic distribution
+
+- Parameters Logistic Distribution: {“mu”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/logistic>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.loglogistic module
+
+_class_ phitter.continuous.continuous*distributions.loglogistic.LogLogistic(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Loglogistic distribution
+
+- Parameters LogLogistic Distribution: {“alpha”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/loglogistic>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.loglogistic_3p module
+
+_class_ phitter.continuous.continuous*distributions.loglogistic_3p.LogLogistic3P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Loglogistic distribution
+
+- Parameters LogLogistic3P Distribution: {“loc”: \*, “alpha”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/loglogistic_3p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“loc”: \*, “alpha”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.lognormal module
+
+_class_ phitter.continuous.continuous*distributions.lognormal.LogNormal(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Lognormal distribution
+
+- Parameters LogNormal Distribution: {“mu”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/lognormal>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.maxwell module
+
+_class_ phitter.continuous.continuous*distributions.maxwell.Maxwell(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Maxwell distribution
+
+- Parameters Maxwell Distribution: {“alpha”: \*, “loc”: \*}
+  <https://phitter.io/distributions/continuous/maxwell>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.moyal module
+
+_class_ phitter.continuous.continuous*distributions.moyal.Moyal(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Moyal distribution
+
+- Parameters Moyal Distribution: {“mu”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/moyal>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.nakagami module
+
+_class_ phitter.continuous.continuous*distributions.nakagami.Nakagami(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Nakagami distribution
+
+- Parameters Nakagami Distribution: {“m”: \*, “omega”: \*}
+  <https://phitter.io/distributions/continuous/nakagami>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“m”: \*, “omega”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restriction
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.non_central_chi_square module
+
+_class_ phitter.continuous.continuous*distributions.non_central_chi_square.NonCentralChiSquare(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Non-Central Chi Square distribution
+
+- Parameters NonCentralChiSquare Distribution: {“lambda”: \*, “n”: \*}
+  <https://phitter.io/distributions/continuous/non_central_chi_square>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“lambda”: \*, “n”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.non_central_f module
+
+_class_ phitter.continuous.continuous*distributions.non_central_f.NonCentralF(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Non-Central F distribution
+
+- Parameters NonCentralF Distribution: {“lambda”: \*, “n1”: \*, “n2”: \*}
+  <https://phitter.io/distributions/continuous/non_central_f>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“lambda”: \*, “n1”: \*, “n2”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.non_central_t_student module
+
+_class_ phitter.continuous.continuous*distributions.non_central_t_student.NonCentralTStudent(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Non-Central T Student distribution
+
+- Parameters NonCentralTStudent Distribution: {“lambda”: \*, “n”: \*, “loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/non_central_t_student> Hand-book on Statistical Distributions (pag.116) … Christian Walck
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“lambda”: \*, “n”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.normal module
+
+_class_ phitter.continuous.continuous*distributions.normal.Normal(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Normal distribution
+
+- Parameters Normal Distribution: {“mu”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/normal>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“mu”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.pareto_first_kind module
+
+_class_ phitter.continuous.continuous*distributions.pareto_first_kind.ParetoFirstKind(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Pareto first kind distribution distribution
+
+- Parameters ParetoFirstKind Distribution: {“alpha”: \*, “xm”: \*, “loc”: \*}
+  <https://phitter.io/distributions/continuous/pareto_first_kind>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “xm”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restriction
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.pareto_second_kind module
+
+_class_ phitter.continuous.continuous*distributions.pareto_second_kind.ParetoSecondKind(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Pareto second kind distribution Distribution
+
+## Also known as Lomax Distribution or Pareto Type II distributions
+
+## - <https://phitter.io/distributions/continuous/pareto_second_kind>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “xm”: \*, “loc”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restriction
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.pert module
+
+_class_ phitter.continuous.continuous*distributions.pert.Pert(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Pert distribution
+
+- Parameters Pert Distribution: {“a”: \*, “b”: \*, “c”: \*}
+  <https://phitter.io/distributions/continuous/pert>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mean”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “median”: \* , “b”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*, “c”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.power_function module
+
+_class_ phitter.continuous.continuous*distributions.power_function.PowerFunction(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Power function distribution
+
+- Parameters PowerFunction Distribution: {“alpha”: \*, “a”: \*, “b”: \*}
+  <https://phitter.io/distributions/continuous/power_function>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “a”: \*, “b”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.rayleigh module
+
+_class_ phitter.continuous.continuous*distributions.rayleigh.Rayleigh(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Rayleigh distribution
+
+- Parameters Rayleigh Distribution: {“gamma”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/rayleigh>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“gamma”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.reciprocal module
+
+_class_ phitter.continuous.continuous*distributions.reciprocal.Reciprocal(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Reciprocal distribution
+
+- Parameters Reciprocal Distribution: {“a”: \*, “b”: \*}
+  <https://phitter.io/distributions/continuous/reciprocal>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.rice module
+
+_class_ phitter.continuous.continuous*distributions.rice.Rice(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Rice distribution
+
+- Parameters Rice Distribution: {“v”: \*, “sigma”: \*}
+  <https://phitter.io/distributions/continuous/rice>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“v”: \*, “sigma”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.semicircular module
+
+_class_ phitter.continuous.continuous*distributions.semicircular.Semicircular(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Semicicrcular Distribution
+
+## - <https://phitter.io/distributions/continuous/semicircular>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_dict_) – {“mu”: \* , “variance”: \* , “skewness”: \* , “kurtosis”: \* , “data”: \* }
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“loc”: \*, “R”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.t_student module
+
+_class_ phitter.continuous.continuous*distributions.t_student.TStudent(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## T distribution
+
+- Parameters TStudent Distribution: {“df”: \*}
+  <https://phitter.io/distributions/continuous/t_student>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“df”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.t_student_3p module
+
+_class_ phitter.continuous.continuous*distributions.t_student_3p.TStudent3P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## T distribution
+
+- Parameters TStudent3P Distribution: {“df”: \*, “loc”: \*, “scale”: \*}
+  <https://phitter.io/distributions/continuous/t_student_3p>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by solving the equations of the measures expected
+- for this distribution.The number of equations to consider is equal to the number
+- of parameters.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“df”: \*, “loc”: \*, “scale”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.trapezoidal module
+
+_class_ phitter.continuous.continuous*distributions.trapezoidal.Trapezoidal(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Trapezoidal distribution
+
+- Parameters Trapezoidal Distribution: {“a”: \*, “b”: \*, “c”: \*, “d”: \*}
+  <https://phitter.io/distributions/continuous/trapezoidal>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*, “c”: \*, “d”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.triangular module
+
+_class_ phitter.continuous.continuous*distributions.triangular.Triangular(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Triangular distribution
+
+- Parameters Triangular Distribution: {“a”: \*, “b”: \*, “c”: \*}
+  <https://phitter.io/distributions/continuous/triangular>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*, “c”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.uniform module
+
+_class_ phitter.continuous.continuous*distributions.uniform.Uniform(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Uniform distribution
+
+- Parameters Uniform Distribution: {“a”: \*, “b”: \*}
+  <https://phitter.io/distributions/continuous/uniform>
+
+## cdf(_x_)
+
+Cumulative distribution function
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“a”: \*, “b”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.weibull module
+
+_class_ phitter.continuous.continuous*distributions.weibull.Weibull(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Weibull distribution
+
+- Parameters Weibull Distribution: {“alpha”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/weibull>
+
+## cdf(_x_)
+
+Cumulative distribution function.
+
+- Calculated with known formula.
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
+
+## phitter.continuous.continuous_distributions.weibull_3p module
+
+_class_ phitter.continuous.continuous*distributions.weibull_3p.Weibull3P(\_parameters=None*, _continuous_measures=None_, _init_parameters_examples=False_)
+: Bases: `object`
+
+## Weibull distribution
+
+- Parameters Weibull3P Distribution: {“alpha”: \*, “loc”: \*, “beta”: \*}
+  <https://phitter.io/distributions/continuous/weibull_3p>
+
+## cdf(_x_)
+
+Cumulative distribution function.
+
+- Calculated with known formula.
+
+#### Return type
+
+`float` | `ndarray`
+
+## central*moments(\_k*)
+
+Parametric central moments. µ’[k] = E[(X - E[X])ᵏ] = ∫(x-µ[k])ᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## get*parameters(\_continuous_measures*)
+
+Calculate proper parameters of the distribution from sample continuous_measures.
+
+- The parameters are calculated by formula.
+
+#### Parameters
+
+**continuous_measures** (_MEASUREMESTS_) – attributes: mean, std, variance, skewness, kurtosis, median, mode, min, max, size, num_bins, data
+
+#### Returns
+
+**parameters**
+
+#### Return type
+
+{“alpha”: \*, “loc”: \*, “beta”: \*}
+
+## _property_ kurtosis*: float*
+
+Parametric kurtosis
+
+## _property_ mean*: float*
+
+Parametric mean
+
+## _property_ median*: float*
+
+Parametric median
+
+## _property_ mode*: float*
+
+Parametric mode
+
+## _property_ name
+
+## non*central_moments(\_k*)
+
+Parametric no central moments. µ[k] = E[Xᵏ] = ∫xᵏ∙f(x) dx
+
+#### Return type
+
+`float` | `None`
+
+## _property_ num_parameters*: int*
+
+Number of parameters of the distribution
+
+## parameter_restrictions()
+
+Check parameters restrictions
+
+#### Return type
+
+`bool`
+
+## _property_ parameters_example*: dict[str, int | float]*
+
+## pdf(_x_)
+
+Probability density function
+
+#### Return type
+
+`float` | `ndarray`
+
+## ppf(_u_)
+
+Percent point function. Inverse of Cumulative distribution function. If CDF[x] = u => PPF[u] = x
+
+#### Return type
+
+`float` | `ndarray`
+
+## sample(_n_, _seed=None_)
+
+Sample of n elements of ditribution
+
+#### Return type
+
+`ndarray`
+
+## _property_ skewness*: float*
+
+Parametric skewness
+
+## _property_ standard_deviation*: float*
+
+Parametric standard deviation
+
+## _property_ variance*: float*
+
+Parametric variance
diff --git a/docs/api/distributions/discrete/discrete-distributions.md b/docs/api/distributions/discrete/discrete-distributions.md
index 1e3e1de..a422a20 100644
--- a/docs/api/distributions/discrete/discrete-distributions.md
+++ b/docs/api/distributions/discrete/discrete-distributions.md
@@ -128,9 +128,8 @@ _class_ phitter.discrete.discrete*distributions.binomial.Binomial(\_parameters=N
 
 ## Binomial distribution
 
-## - Parameters Binomial Distribution: {“n”: \*, “p”: \*}
-
-## - <https://phitter.io/distributions/discrete/binomial>
+- Parameters Binomial Distribution: {“n”: \*, “p”: \*}
+  <https://phitter.io/distributions/discrete/binomial>
 
 ## cdf(_x_)
 
@@ -249,9 +248,8 @@ _class_ phitter.discrete.discrete*distributions.geometric.Geometric(\_parameters
 
 ## Geometric distribution
 
-## - Parameters Geometric Distribution: {“p”: \*}
-
-## - <https://phitter.io/distributions/discrete/geometric>
+- Parameters Geometric Distribution: {“p”: \*}
+  <https://phitter.io/distributions/discrete/geometric>
 
 ## cdf(_x_)
 
@@ -370,9 +368,8 @@ _class_ phitter.discrete.discrete*distributions.hypergeometric.Hypergeometric(\_
 
 ## Hypergeometric_distribution
 
-## - Parameters Hypergeometric Distribution: {“N”: \*, “K”: \*, “n”: \*}
-
-## - <https://phitter.io/distributions/discrete/hypergeometric>
+- Parameters Hypergeometric Distribution: {“N”: \*, “K”: \*, “n”: \*}
+  <https://phitter.io/distributions/discrete/hypergeometric>
 
 ## cdf(_x_)
 
@@ -491,9 +488,8 @@ _class_ phitter.discrete.discrete*distributions.logarithmic.Logarithmic(\_parame
 
 ## Logarithmic distribution
 
-## - Parameters Logarithmic Distribution: {“p”: \*}
-
-## - <https://phitter.io/distributions/discrete/logarithmic>
+- Parameters Logarithmic Distribution: {“p”: \*}
+  <https://phitter.io/distributions/discrete/logarithmic>
 
 ## cdf(_x_)
 
@@ -612,9 +608,8 @@ _class_ phitter.discrete.discrete*distributions.negative_binomial.NegativeBinomi
 
 ## Negative binomial distribution
 
-## - Parameters NegativeBinomial Distribution: {“r”: \*, “p”: \*}
-
-## - <https://phitter.io/distributions/discrete/negative_binomial>
+- Parameters NegativeBinomial Distribution: {“r”: \*, “p”: \*}
+  <https://phitter.io/distributions/discrete/negative_binomial>
 
 ## cdf(_x_)
 
@@ -733,9 +728,8 @@ _class_ phitter.discrete.discrete*distributions.poisson.Poisson(\_parameters=Non
 
 ## Poisson distribution
 
-## - Parameters Poisson Distribution: {“lambda”: \*}
-
-## - <https://phitter.io/distributions/discrete/poisson>
+- Parameters Poisson Distribution: {“lambda”: \*}
+  <https://phitter.io/distributions/discrete/poisson>
 
 ## cdf(_x_)
 
@@ -854,9 +848,8 @@ _class_ phitter.discrete.discrete*distributions.uniform.Uniform(\_parameters=Non
 
 ## Uniform distribution
 
-## - Parameters Uniform Distribution: {“a”: \*, “b”: \*}
-
-## - <https://phitter.io/distributions/discrete/uniform>
+- Parameters Uniform Distribution: {“a”: \*, “b”: \*}
+  <https://phitter.io/distributions/discrete/uniform>
 
 ## cdf(_x_)
 

From 95a81ba513fc228803192a6aafd10adaacda6a72 Mon Sep 17 00:00:00 2001
From: cargar_github <candemas97@hotmail.com>
Date: Tue, 22 Apr 2025 21:26:23 -0500
Subject: [PATCH 3/3] API Reference Finished

---
 docs/.vitepress/config.mts | 53 +-------------------------------------
 1 file changed, 1 insertion(+), 52 deletions(-)

diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts
index 09e8adc..a30f79c 100644
--- a/docs/.vitepress/config.mts
+++ b/docs/.vitepress/config.mts
@@ -10,8 +10,8 @@ export default defineConfig({
             provider: "local",
         },
         nav: [
-            { text: "API Reference", link: "/api/intro/what-is-phitter" },
             { text: "User Guide", link: "/documentation/intro/what-is-phitter" },
+            { text: "API Reference", link: "https://docs-phitter-kernel-api-reference.netlify.app/" },
             { text: "Releases", link: "/release/release-main" },
             { text: "Phitter Web", link: "https://phitter.io/" },
         ],
@@ -247,57 +247,6 @@ export default defineConfig({
                     ],
                 },
             ],
-            "/api/": [
-                {
-                    text: "Introduction",
-                    // collapsed: false,
-                    items: [
-                        { text: "What is Phitter?", link: "/api/intro/what-is-phitter" },
-                        { text: "Installation", link: "/api/intro/installation" },
-                    ],
-                },
-                {
-                    text: "Simulation",
-                    // collapsed: false,
-                    items: [
-                        {
-                            text: "Process Simulation",
-                            collapsed: true,
-                            items: [
-                                { text: "phitter.simulation.own_distribution", collapsed: true, link: "/api/simulation/process/own-distribution" },
-                                { text: "phitter.simulation.process_simulation", collapsed: true, link: "/api/simulation/process/process-simulation" },
-                            ],
-                        },
-                        {
-                            text: "Queueing Simulation",
-                            collapsed: true,
-                            items: [
-                                { text: "phitter.simulation.queueing_simulation", collapsed: true, link: "/api/simulation/queue/queueing-simulation" },
-                            ],
-                        },
-                    ],
-                },
-                {
-                    text: "Distributions",
-                    // collapsed: false,
-                    items: [
-                        {
-                            text: "Discrete",
-                            collapsed: true,
-                            items: [
-                                { text: "Discrete", link: "/api/distributions/discrete/discrete-distributions" }
-                            ],
-                        },
-                        {
-                            text: "Continuous",
-                            collapsed: true,
-                            items: [
-                                { text: "Continous", link: "/api/distributions/continous/continous" }
-                            ],
-                        },
-                    ],
-                },
-            ]
         },
         socialLinks: [
             { icon: "github", link: "https://github.com/phitter-core/phitter-kernel" },