pm_distGenExpGamma Module Reference

This module contains classes and procedures for computing various statistical quantities related to the GenExpGamma distribution. More...

Data Types
type	distGenExpGamma_type
	This is the derived type for signifying distributions that are of type GenExpGamma as defined in the description of pm_distGenExpGamma. More...
interface	getGenExpGammaCDF
	Generate and return the Cumulative Distribution Function (CDF) of the GenExpGamma distribution for an input x within the support of the distribution \(x \in (-\infty,+\infty)\). More...
interface	getGenExpGammaLogPDF
	Generate and return the natural logarithm of the Probability Density Function (PDF) of the GenExpGamma distribution. More...
interface	getGenExpGammaLogPDFNF
	Generate and return the natural logarithm of the normalization factor of the Probability Density Function (PDF) of the GenExpGamma distribution. More...
interface	setGenExpGammaCDF
	Return the Cumulative Distribution Function (CDF) of the GenExpGamma distribution for an input x within the support of the distribution \(x \in (-\infty,+\infty)\). More...
interface	setGenExpGammaLogPDF
	Return the natural logarithm of the Probability Density Function (PDF) of the GenExpGamma distribution. More...

Variables
character(*, SK), parameter	MODULE_NAME = "@pm_distGenExpGamma"

Detailed Description

This module contains classes and procedures for computing various statistical quantities related to the GenExpGamma distribution.

Specifically, this module contains routines for computing the following quantities of the GenExpGamma distribution:

1. the Probability Density Function (PDF)
2. the Cumulative Distribution Function (CDF)
3. the Random Number Generation from the distribution (RNG)
4. the Inverse Cumulative Distribution Function (ICDF) or the Quantile Function

A variable \(X\) is said to be GenExpGamma-distributed if its PDF with location \(-\infty < \log(\sigma) < +\infty\), scale (inverse rate) \(\omega > 0\), and shape \(\kappa > 0\) parameters is described by the following equation,

\begin{equation} \large \pi(x | \kappa, \omega, \log(\sigma)) = \frac{1}{\omega \Gamma(\kappa)} ~ \exp\Bigg( \kappa\bigg(\frac{x - \log(\sigma)}{\omega}\bigg) - \exp\bigg(\frac{x - \log(\sigma)}{\omega}\bigg) \Bigg) ~,~ -\infty < x < \infty \end{equation}

where \(\eta = \frac{1}{\omega \Gamma(\kappa)}\) is the normalization factor of the PDF.
When \(\sigma = 1\), the GenExpGamma PDF simplifies to the form,

\begin{equation} \large \pi(x) = \frac{1}{\omega \Gamma(\kappa)} ~ \exp\Bigg(\kappa \frac{x}{\omega} - \exp\bigg(\frac{x}{\omega}\bigg) \Bigg) ~,~ -\infty < x < \infty \end{equation}

If \((\sigma, \omega) = (1, 1)\), that is, \(x\) is standardized, the GenExpGamma PDF further simplifies to the form,

\begin{equation} \large \pi(x) = \frac{1}{\Gamma(\kappa)} ~ \exp\Bigg(\kappa x - \exp(x) \Bigg) ~,~ -\infty < x < \infty \end{equation}

Setting the shape parameter to \(\kappa = 1\) further simplifies the PDF to the form,

\begin{equation} \large \pi(x) = \exp\Bigg(x - \exp(x)\Bigg) ~,~ -\infty < x < \infty \end{equation}

The parameter \(\log(\sigma)\) determines the horizontal location of the mode of this unimodal GenExpGamma PDF.
While the PDF is always unimodal, the overall height and steepness of the PDF curve are determined by the values of \(\kappa\) and \(\omega\).
In addition, the tails of the PDF are fat, in the sense that the PDF decreases algebraically rather than decreasing exponentially for large values of \(x\).
The term GenExpGamma is shorthand for Exponential-Gamma, and the GenExpGamma distribution is sometimes referred to as the generalized extreme value distribution.
The term also sometimes collectively refers to a number of qualitatively similar probability distributions.
The GenExpGamma distribution is mathematically defined to be the distribution of \(\log(X)\) where \(X\) follows a GenGamma distribution.
GenExpGamma distribution is also significant because of the statistical extreme value theorem, which states that the maximum of a sample of i.i.d. random variables can only converge in distribution to one of three possible distributions,

1. Gumbel distribution,
2. Frechet distribution,
3. Weibull distribution,

all of which are special cases of GenExpGamma distribution.
The GenExpGamma distribution is used in various branches of science to model a number of phenomena, including wind speeds in meteorology and ocean current speeds in ocean engineering.

The CDF of the GenExpGamma distribution over a strictly-positive support \(x \in (0, +\infty)\) with the three (shape, shape, scale) parameters \((\kappa > 0, \omega > 0, \sigma > 0)\) is defined by the regularized Lower Incomplete Gamma function as,

\begin{eqnarray} \large \mathrm{CDF}(x | \kappa, \sigma) & = & P\big(\kappa, \frac{x - \log(\sigma)}{\omega}\big) \\ & = & \frac{1}{\Gamma(\kappa)} \int_0^{\exp(\frac{x - \log(\sigma)}{\omega})} ~ t^{\kappa - 1}{\mathrm e}^{-t} ~ dt ~, \end{eqnarray}

where \(\Gamma(\kappa)\) represents the Gamma function.

Warning

The GenExpGamma distribution is also frequently mistakenly called GenLogGamma , which is an entirely different distribution.

Note

The relationship between the GenExpGamma and GenGamma distributions is similar to that of the Normal and LogNormal distributions.
In other words, a better more consistent naming for the GenExpGamma and GenGamma distributions could have been GenGamma and GenLogGamma distributions, respectively, similar to Normal and LogNormal distributions.

See also

pm_distGamma
pm_distGenGamma
Wolfram Research (2010), GenExpGammaDistribution, Wolfram Language function, https://reference.wolfram.com/language/ref/GenExpGammaDistribution.html (updated 2016)

Benchmarks:

Benchmark :: The runtime performance of getGenExpGammaLogPDF vs. setGenExpGammaLogPDF ⛓

! Test the performance of `getGenExpGammaLogPDF()` vs. `setGenExpGammaLogPDF()`.
program benchmark
 
    use iso_fortran_env, only: error_unit
    use pm_bench, only: bench_type
    use pm_kind, only: IK, RK, SK
 
    implicit none
 
    integer(IK)                         :: i
    integer(IK)                         :: isize
    integer(IK)                         :: fileUnit
    integer(IK)     , parameter         :: NSIZE = 18_IK
    integer(IK)     , parameter         :: NBENCH = 2_IK
    integer(IK)                         :: arraySize(NSIZE)
    real(RK)        , allocatable       :: Array(:), Point(:)
    real(RK)                            :: dummy = 0._RK
    type(bench_type)                    :: bench(NBENCH)
 
    bench(1) = bench_type(name = SK_"setGenExpGammaLogPDF", exec = setGenExpGammaLogPDF , overhead = setOverhead)
    bench(2) = bench_type(name = SK_"getGenExpGammaLogPDF", exec = getGenExpGammaLogPDF , overhead = setOverhead)
 
    arraySize = [( 2_IK**isize, isize = 1_IK, NSIZE )]
 
    write(*,"(*(g0,:,' '))")
    write(*,"(*(g0,:,' vs. '))") (bench(i)%name, i = 1, NBENCH)
    write(*,"(*(g0,:,' '))")
 
    open(newunit = fileUnit, file = "main.out", status = "replace")
 
        write(fileUnit, "(*(g0,:,','))") "arraySize", (bench(i)%name, i = 1, NBENCH)
 
        loopOverArraySize: do isize = 1, NSIZE
 
            write(*,"(*(g0,:,' '))") "Benchmarking with size", arraySize(isize)
 
            allocate(Array(arraySize(isize)), Point(arraySize(isize)))
            do i = 1, NBENCH
                bench(i)%timing = bench(i)%getTiming(minsec = 0.05_RK)
            end do
            deallocate(Array, Point)
 
            write(fileUnit,"(*(g0,:,','))") arraySize(isize), (bench(i)%timing%mean, i = 1, NBENCH)
 
        end do loopOverArraySize
 
        write(*,"(*(g0,:,' '))") dummy
        write(*,"(*(g0,:,' '))")
 
    close(fileUnit)
 
contains
 
    !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    ! procedure wrappers.
    !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
    subroutine setOverhead()
        call initialize()
        call finalize()
    end subroutine
 
    subroutine initialize()
        call random_number(Point)
    end subroutine
 
    subroutine finalize()
        dummy = dummy + Array(1)
    end subroutine
 
    subroutine setGenExpGammaLogPDF()
        block
            use pm_distGenExpGamma, only: setGenExpGammaLogPDF
            call initialize()
            call setGenExpGammaLogPDF(Array, Point)
            call finalize()
        end block
    end subroutine
 
    subroutine getGenExpGammaLogPDF()
        block
            use pm_distGenExpGamma, only: getGenExpGammaLogPDF
            call initialize()
            Array = getGenExpGammaLogPDF(Point)
            call finalize()
        end block
    end subroutine
 
end program benchmark

Example Unix compile command via Intel ifort compiler ⛓

#!/usr/bin/env sh
rm main.exe
ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Example Windows Batch compile command via Intel ifort compiler ⛓

del main.exe
set PATH=..\..\..\lib;%PATH%
ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe
main.exe

Example Unix / MinGW compile command via GNU gfortran compiler ⛓

#!/usr/bin/env sh
rm main.exe
gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Postprocessing of the benchmark output ⛓

#!/usr/bin/env python
 
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
import os
dirname = os.path.basename(os.getcwd()) 
 
fontsize = 14
 
df = pd.read_csv("main.out", delimiter = ",")
colnames = list(df.columns.values)
 
 
 
ax = plt.figure(figsize = 1.25 * np.array([6.4,4.6]), dpi = 200)
ax = plt.subplot()
 
for colname in colnames[1:]:
    plt.plot( df[colnames[0]].values
            , df[colname].values
            , linewidth = 2
            )
 
plt.xticks(fontsize = fontsize)
plt.yticks(fontsize = fontsize)
ax.set_xlabel(colnames[0], fontsize = fontsize)
ax.set_ylabel("Runtime [ seconds ]", fontsize = fontsize)
ax.set_title(" vs. ".join(colnames[1:])+"\nLower is better.", fontsize = fontsize)
ax.set_xscale("log")
ax.set_yscale("log")
plt.minorticks_on()
plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
ax.tick_params(axis = "y", which = "minor")
ax.tick_params(axis = "x", which = "minor")
ax.legend   ( colnames[1:]
           #, loc='center left'
           #, bbox_to_anchor=(1, 0.5)
            , fontsize = fontsize
            )
 
plt.tight_layout()
plt.savefig("benchmark." + dirname + ".runtime.png")
 
 
 
ax = plt.figure(figsize = 1.25 * np.array([6.4,4.6]), dpi = 200)
ax = plt.subplot()
 
plt.plot( df[colnames[0]].values
        , np.ones(len(df[colnames[0]].values))
        , linestyle = "--"
       #, color = "black"
        , linewidth = 2
        )
for colname in colnames[2:]:
    plt.plot( df[colnames[0]].values
            , df[colname].values / df[colnames[1]].values
            , linewidth = 2
            )
 
plt.xticks(fontsize = fontsize)
plt.yticks(fontsize = fontsize)
ax.set_xlabel(colnames[0], fontsize = fontsize)
ax.set_ylabel("Runtime compared to {}".format(colnames[1]), fontsize = fontsize)
ax.set_title("Runtime Ratio Comparison. Lower means faster.\nLower than 1 means faster than {}().".format(colnames[1]), fontsize = fontsize)
ax.set_xscale("log")
#ax.set_yscale("log")
plt.minorticks_on()
plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
ax.tick_params(axis = "y", which = "minor")
ax.tick_params(axis = "x", which = "minor")
ax.legend   ( colnames[1:]
           #, bbox_to_anchor = (1, 0.5)
           #, loc = "center left"
            , fontsize = fontsize
            )
 
plt.tight_layout()
plt.savefig("benchmark." + dirname + ".runtime.ratio.png")

Visualization of the benchmark output ⛓

Benchmark moral ⛓

1. The procedures under the generic interface getGenExpGammaLogPDF are functions while the procedures under the generic interface setGenExpGammaLogPDF are subroutines.
   From the benchmark results, it appears that the functional interface performs slightly less efficiently than the subroutine interface when the input x size is small.
   Otherwise, the difference appears to be marginal and insignificant in most practical situations.
   

Test:

test_pm_distGenExpGamma

Final Remarks ⛓

---

If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
   
2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.
   

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Copyright

Computational Data Science Lab

Author:

Amir Shahmoradi, Oct 16, 2009, 11:14 AM, Michigan

Variable Documentation

MODULE_NAME

character(*, SK), parameter pm_distGenExpGamma::MODULE_NAME = "@pm_distGenExpGamma"

Definition at line 139 of file pm_distGenExpGamma.F90.