Feature/distribution speed up

.gitignore

@@ -248,3 +248,4 @@ logo/
 /python_model_third_party.py
 /third_party_script.py
 /docs/source/auto_examples/
+scratch/

src/UQpy/distributions/collection/Beta.py

@@ -1,5 +1,4 @@
 from typing import Union
-
 import scipy.stats as stats
 from UQpy.distributions.baseclass import DistributionContinuous1D
 from beartype import beartype
@@ -30,3 +29,11 @@ def __init__(
             ordered_parameters=("a", "b", "loc", "scale"),
         )
         self._construct_from_scipy(scipy_name=stats.beta)
+
+    def __repr__(self):
+        s = "{a}, {b}"
+        if self.parameters["loc"] != 0.0:
+            s += ", loc={loc}"
+        if self.parameters["scale"] != 1.0:
+            s += ", scale={scale}"
+        return "Beta(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Binomial.py

@@ -22,3 +22,9 @@ def __init__(
         """
         super().__init__(n=n, p=p, loc=loc, ordered_parameters=("n", "p", "loc"))
         self._construct_from_scipy(scipy_name=stats.binom)
+
+    def __repr__(self):
+        s = "{n}, {p}"
+        if self.parameters["loc"] != 0.0:
+            s += ", loc={loc}"
+        return "Binomial(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Cauchy.py

@@ -19,3 +19,12 @@ def __init__(
         """
         super().__init__(loc=loc, scale=scale, ordered_parameters=("loc", "scale"))
         self._construct_from_scipy(scipy_name=stats.cauchy)
+
+    def __repr__(self):
+        s = []
+        if self.parameters["loc"] != 0.0:
+            s.append("loc={loc}")
+        if self.parameters["scale"] != 1.0:
+            s.append("scale={scale}")
+        s = ", ".join(s)
+        return "Cauchy(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/ChiSquare.py

@@ -24,3 +24,11 @@ def __init__(
             df=df, loc=loc, scale=scale, ordered_parameters=("df", "loc", "scale")
         )
         self._construct_from_scipy(scipy_name=stats.chi2)
+
+    def __repr__(self):
+        s = "{df}"
+        if self.parameters["loc"] != 0.0:
+            s += ", loc={loc}"
+        if self.parameters["scale"] != 1.0:
+            s += ", scale={scale}"
+        return "ChiSquare(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Exponential.py

@@ -19,3 +19,12 @@ def __init__(
         """
         super().__init__(loc=loc, scale=scale, ordered_parameters=("loc", "scale"))
         self._construct_from_scipy(scipy_name=stats.expon)
+
+    def __repr__(self):
+        s = []
+        if self.parameters["loc"] != 0.0:
+            s.append("loc={loc}")
+        if self.parameters["scale"] != 1.0:
+            s.append("scale={scale}")
+        s = ", ".join(s)
+        return "Exponential(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Gamma.py

@@ -25,3 +25,11 @@ def __init__(
             a=a, loc=loc, scale=scale, ordered_parameters=("a", "loc", "scale")
         )
         self._construct_from_scipy(scipy_name=stats.gamma)
+
+    def __repr__(self):
+        s = "{a}"
+        if self.parameters["loc"] != 0.0:
+            s += ", loc={loc}"
+        if self.parameters["scale"] != 1.0:
+            s += ", scale={scale}"
+        return "Gamma(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/GeneralizedExtreme.py

@@ -25,3 +25,11 @@ def __init__(
             c=c, loc=loc, scale=scale, ordered_parameters=("c", "loc", "scale")
         )
         self._construct_from_scipy(scipy_name=stats.genextreme)
+
+    def __repr__(self):
+        s = "{c}"
+        if self.parameters["loc"] != 0.0:
+            s += ", loc={loc}"
+        if self.parameters["scale"] != 1.0:
+            s += ", scale={scale}"
+        return "GeneralizedExtreme(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/InverseGaussian.py

@@ -25,3 +25,11 @@ def __init__(
             mu=mu, loc=loc, scale=scale, ordered_parameters=("mu", "loc", "scale")
         )
         self._construct_from_scipy(scipy_name=stats.invgauss)
+
+    def __repr__(self):
+        s = "{mu}"
+        if self.parameters["loc"] != 0.0:
+            s += ", loc={loc}"
+        if self.parameters["scale"] != 1.0:
+            s += ", scale={scale}"
+        return "InverseGauss(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/JointCopula.py

@@ -165,3 +165,6 @@ def update_parameters(self, **kwargs: dict):
                 self.copula.parameters[key] = value
             else:
                 self.marginals[int(index)].parameters[key] = value
+
+    def __repr__(self):
+        return f"JointCopula({self.marginals}, {self.copula})"

src/UQpy/distributions/collection/JointIndependent.py

@@ -14,8 +14,8 @@
 class JointIndependent(DistributionND):
     @beartype
     def __init__(
-            self,
-            marginals: Union[list[DistributionContinuous1D], list[DistributionDiscrete1D]],
+        self,
+        marginals: Union[list[DistributionContinuous1D], list[DistributionDiscrete1D]],
     ):
         """
         :param marginals: list of distribution objects that define the marginals.
@@ -24,12 +24,20 @@ def __init__(
         self.ordered_parameters = []
         for i, m in enumerate(marginals):
             self.ordered_parameters.extend(
-                [key + "_" + str(i) for key in m.ordered_parameters])
+                [key + "_" + str(i) for key in m.ordered_parameters]
+            )
 
         # Check and save the marginals
-        if not (isinstance(marginals, list)
-                and all(isinstance(d, (DistributionContinuous1D, DistributionDiscrete1D)) for d in marginals)):
-            raise ValueError("Input marginals must be a list of Distribution1d objects.")
+        if not (
+            isinstance(marginals, list)
+            and all(
+                isinstance(d, (DistributionContinuous1D, DistributionDiscrete1D))
+                for d in marginals
+            )
+        ):
+            raise ValueError(
+                "Input marginals must be a list of Distribution1d objects."
+            )
         self.marginals = marginals
 
         # If all marginals have a method, the joint has it to
@@ -70,6 +78,7 @@ def joint_log_pdf(dist, x):
                 self.log_pmf = MethodType(joint_log_pdf, self)
 
         if all(hasattr(m, "cdf") for m in self.marginals):
+
             def joint_cdf(dist, x):
                 x = dist.check_x_dimension(x)
                 # Compute cdf of independent marginals
@@ -107,8 +116,8 @@ def joint_fit(dist, data):
                 mle_all = {}
                 for ind_m, marg in enumerate(dist.marginals):
                     if any(
-                            param_value is None
-                            for param_value in marg.get_parameters().values()
+                        param_value is None
+                        for param_value in marg.get_parameters().values()
                     ):
                         mle_i = marg.fit(data[:, ind_m])
                     else:
@@ -125,8 +134,15 @@ def joint_fit(dist, data):
             def joint_moments(dist, moments2return="mvsk"):
                 # Go through all marginals
                 if len(moments2return) == 1:
-                    return np.array([marg.moments(moments2return=moments2return) for marg in dist.marginals])
-                moments_ = [np.empty((len(dist.marginals),)) for _ in range(len(moments2return))]
+                    return np.array(
+                        [
+                            marg.moments(moments2return=moments2return)
+                            for marg in dist.marginals
+                        ]
+                    )
+                moments_ = [
+                    np.empty((len(dist.marginals),)) for _ in range(len(moments2return))
+                ]
                 for ind_m, marg in enumerate(dist.marginals):
                     moments_i = marg.moments(moments2return=moments2return)
                     for j in range(len(moments2return)):
@@ -174,3 +190,6 @@ def update_parameters(self, **kwargs: dict):
             key_split = key_indexed.split("_")
             key, index = "_".join(key_split[:-1]), int(key_split[-1])
             self.marginals[index].parameters[key] = value
+
+    def __repr__(self):
+        return f"JointIndependent({self.marginals})"

src/UQpy/distributions/collection/Laplace.py

@@ -19,3 +19,12 @@ def __init__(
         """
         super().__init__(loc=loc, scale=scale, ordered_parameters=("loc", "scale"))
         self._construct_from_scipy(scipy_name=stats.laplace)
+
+    def __repr__(self):
+        s = []
+        if self.parameters["loc"] != 0.0:
+            s.append("loc={loc}")
+        if self.parameters["scale"] != 1.0:
+            s.append("scale={scale}")
+        s = ", ".join(s)
+        return "Laplace(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Levy.py

@@ -19,3 +19,12 @@ def __init__(
         """
         super().__init__(loc=loc, scale=scale, ordered_parameters=("loc", "scale"))
         self._construct_from_scipy(scipy_name=stats.levy)
+
+    def __repr__(self):
+        s = []
+        if self.parameters["loc"] != 0.0:
+            s.append("loc={loc}")
+        if self.parameters["scale"] != 1.0:
+            s.append("scale={scale}")
+        s = ", ".join(s)
+        return "Levy(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Logistic.py

@@ -19,3 +19,12 @@ def __init__(
         """
         super().__init__(loc=loc, scale=scale, ordered_parameters=("loc", "scale"))
         self._construct_from_scipy(scipy_name=stats.logistic)
+
+    def __repr__(self):
+        s = []
+        if self.parameters["loc"] != 0.0:
+            s.append("loc={loc}")
+        if self.parameters["scale"] != 1.0:
+            s.append("scale={scale}")
+        s = ", ".join(s)
+        return "Logistic(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Lognormal.py

@@ -25,3 +25,11 @@ def __init__(
             s=s, loc=loc, scale=scale, ordered_parameters=("s", "loc", "scale")
         )
         self._construct_from_scipy(scipy_name=stats.lognorm)
+
+    def __repr__(self):
+        s = "{s}"
+        if self.parameters["loc"] != 0.0:
+            s += ", loc={loc}"
+        if self.parameters["scale"] != 1.0:
+            s += ", scale={scale}"
+        return "Lognormal(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Maxwell.py

@@ -19,3 +19,12 @@ def __init__(
         """
         super().__init__(loc=loc, scale=scale, ordered_parameters=("loc", "scale"))
         self._construct_from_scipy(scipy_name=stats.maxwell)
+
+    def __repr__(self):
+        s = []
+        if self.parameters["loc"] != 0.0:
+            s.append("loc={loc}")
+        if self.parameters["scale"] != 1.0:
+            s.append("scale={scale}")
+        s = ", ".join(s)
+        return "Maxwell(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Multinomial.py

@@ -58,3 +58,6 @@ def moments(self, moments2return="mv"):
             return mean, cov
         else:
             raise ValueError('UQpy: moments2return must be "m", "v" or "mv".')
+
+    def __repr__(self):
+        return "Multinomial({n}, {p})".format(**self.parameters)

src/UQpy/distributions/collection/MultivariateNormal.py

@@ -25,8 +25,13 @@ def __init__(
             if isinstance(cov, (int, float)):
                 pass
             else:
-                if not (len(np.array(cov).shape) in [1, 2] and all(sh == len(mean) for sh in np.array(cov).shape)):
-                    raise ValueError("Input covariance must be a float or ndarray of appropriate dimensions.")
+                if not (
+                    len(np.array(cov).shape) in [1, 2]
+                    and all(sh == len(mean) for sh in np.array(cov).shape)
+                ):
+                    raise ValueError(
+                        "Input covariance must be a float or ndarray of appropriate dimensions."
+                    )
         super().__init__(mean=mean, cov=cov, ordered_parameters=["mean", "cov"])
 
     def cdf(self, x):
@@ -44,8 +49,9 @@ def log_pdf(self, x):
     def rvs(self, nsamples=1, random_state=None):
         if not (isinstance(nsamples, int) and nsamples >= 1):
             raise ValueError("Input nsamples must be an integer > 0.")
-        return stats.multivariate_normal.rvs(size=nsamples, random_state=random_state, **self.parameters
-                                             ).reshape((nsamples, -1))
+        return stats.multivariate_normal.rvs(
+            size=nsamples, random_state=random_state, **self.parameters
+        ).reshape((nsamples, -1))
 
     def fit(self, data):
         data = self.check_x_dimension(data)
@@ -65,3 +71,12 @@ def moments(self, moments2return="mv"):
             return self.get_parameters()["mean"], self.get_parameters()["cov"]
         else:
             raise ValueError('UQpy: moments2return must be "m", "v" or "mv".')
+
+    def __repr__(self):
+        s = "{mean}"
+        is_float_or_int = isinstance(self.parameters["cov"], (int, float))
+        if is_float_or_int:
+            if self.parameters["cov"] == 1.0:
+                return "MultivariateNormal(" + s.format(**self.parameters) + ")"
+        s += ", cov={cov}"
+        return "MultivariateNormal(" + s.format(**self.parameters) + ")"

src/UQpy/distributions/collection/Normal.py

@@ -1,12 +1,14 @@
 from typing import Union
+import numpy as np
 import scipy.stats as stats
 from beartype import beartype
+from scipy.special import erf, erfinv
 from UQpy.distributions.baseclass import DistributionContinuous1D
+from UQpy.utilities.ValidationTypes import NumericArrayLike
 
 
+@beartype
 class Normal(DistributionContinuous1D):
-
-    @beartype
     def __init__(
         self, loc: Union[None, float, int] = 0.0, scale: Union[None, float, int] = 1.0
     ):
@@ -17,3 +19,61 @@ def __init__(
         """
         super().__init__(loc=loc, scale=scale, ordered_parameters=("loc", "scale"))
         self._construct_from_scipy(scipy_name=stats.norm)
+        self.pdf = self.__probability_density_function
+        self.cdf = self.__cumulative_distribution_function
+        self.icdf = self.__inverse_cumulative_distribution_function
+
+    def __probability_density_function(
+        self, x: NumericArrayLike
+    ) -> Union[float, np.ndarray]:
+        """Probability density function for normal distribution
+
+        :param x: Points to evaluate pdf at
+        :return: PDF of ``x`` as defined by :math:`f_x(x)`
+        """
+        x_array = np.atleast_1d(x)
+        mean = self.parameters["loc"]
+        standard_deviation = self.parameters["scale"]
+        normalizing_constant = 1 / (standard_deviation * np.sqrt(2 * np.pi))
+        pdf = normalizing_constant * np.exp(
+            -0.5 * ((x_array - mean) / standard_deviation) ** 2
+        )
+        return pdf
+
+    def __cumulative_distribution_function(
+        self, x: NumericArrayLike
+    ) -> Union[float, np.ndarray]:
+        """Cumulative distribution function for the normal distribution defined with the error function
+
+        :param x: Points to evaluate cdf at
+        :return: CDF of ``x`` as defined by :math:`F_X(x)`
+        """
+        x_array = np.atleast_1d(x)
+        mean = self.parameters["loc"]
+        standard_deviation = self.parameters["scale"]
+        erf_input = (x_array - mean) / (standard_deviation * np.sqrt(2.0))
+        cdf = (1.0 + erf(erf_input)) / 2.0
+        return cdf
+
+    def __inverse_cumulative_distribution_function(
+        self, y: NumericArrayLike
+    ) -> Union[float, np.ndarray]:
+        """Compute the inverse CDF for the normal distribution with the inverse error function
+
+        :param y:
+        :return:
+        """
+        y_array = np.atleast_1d(y)
+        mean = self.parameters["loc"]
+        standard_deviation = self.parameters["scale"]
+        normalized_icdf = erfinv((2 * y_array) - 1)
+        icdf = (normalized_icdf * standard_deviation * np.sqrt(2.0)) + mean
+        return icdf
+
+    def __repr__(self):
+        s = []
+        if self.parameters["loc"] != 0.0:
+            s.append(f"loc={self.parameters['loc']}")
+        if self.parameters["scale"] != 1.0:
+            s.append(f"scale={self.parameters['scale']}")
+        return "Normal(" + ", ".join(s) + ")"

src/UQpy/distributions/collection/Pareto.py

@@ -24,3 +24,11 @@ def __init__(
             b=b, loc=loc, scale=scale, ordered_parameters=("b", "loc", "scale")
         )
         self._construct_from_scipy(scipy_name=stats.pareto)
+
+    def __repr__(self):
+        s = "{b}"
+        if self.parameters["loc"] != 0.0:
+            s += ", loc={loc}"
+        if self.parameters["scale"] != 1.0:
+            s += ", scale={scale}"
+        return "Pareto(" + s.format(**self.parameters) + ")"