`stdlib_specialfunctions_gamma`#

`gamma` - Calculate the gamma function #

Description #

The gamma function is defined as the analytic continuation of a convergent improper integral function on the whole complex plane except zero and negative integers:

\[\Gamma(z)=\int_{0}^{\infty}x^{z-1}e^{-x}dx, \;\; z\in \mathbb{C} \setminus 0, -1, -2, \cdots\]

Fortran 2018 standard implements the intrinsic gamma function of real type argument in single and double precisions. Here the gamma function is extended to both integer and complex arguments. The values of the gamma function with integer arguments are exact. The values of the gamma function with complex arguments are approximated in single and double precisions by using Lanczos approximation.

Syntax #

result = gamma (x)

Class #

Elemental function

Arguments #

x: should be a positive integer or a complex type number

Return value #

The function returns a value with the same type and kind as input argument.

Example #

program example_gamma
  use stdlib_kinds, only: sp, dp, int64
  use stdlib_specialfunctions_gamma, only: gamma
  implicit none

  integer :: i
  integer(int64) :: n
  real :: x
  real(dp) :: y
  complex(sp) :: z

  i = 10
  n = 15_int64
  x = 2.5
  y = 4.3_dp
  z = (2.3, 0.6)

  print *, gamma(i)              !integer gives exact result
! 362880

  print *, gamma(n)
! 87178291200

  print *, gamma(x)              ! intrinsic function call
! 1.32934034

  print *, gamma(y)              ! intrinsic function call
! 8.8553433604540341

  print *, gamma(z)
! (0.988054395, 0.383354813)

end program example_gamma

`log_gamma` - Calculate the natural logarithm of the gamma function #

Status #

Experimental

Description #

Mathematically, logarithm of gamma function is a special function with complex arguments by itself. Due to the different branch cut structures and a different principal branch, natural logarithm of gamma function log_gamma(z) with complex argument is different from the ln(Gamma(z)). The two have the same real part but different imaginary part.

Fortran 2018 standard implements intrinsic log_gamma function of absolute value of real type argument in single and double precision. Here the log_gamma function is extended to both integer and complex arguments. The values of log_gamma function with complex arguments are approximated in single and double precisions by using Stirling’s approximation.

program example_log_gamma
  use stdlib_kinds, only: sp, dp
  use stdlib_specialfunctions_gamma, only: log_gamma
  implicit none

  integer :: i
  real :: x
  real(dp) :: y
  complex(sp) :: z

  i = 10
  x = 8.76
  y = x
  z = (5.345, -3.467)

  print *, log_gamma(i)     !default single precision output
!12.8018274

  print *, log_gamma(x)     !intrinsic function call

!10.0942659

  print *, log_gamma(y)     !intrinsic function call

!10.094265528673880

  print *, log_gamma(z)     !same kind as input

!(2.56165648, -5.73382425)

end program example_log_gamma

program example_log_factorial
  use stdlib_kinds, only: int64
  use stdlib_specialfunctions_gamma, only: lf => log_factorial
  implicit none
  integer :: n

  n = 10
  print *, lf(n)

! 15.1044130

  print *, lf(35_int64)

! 92.1361771
end program example_log_factorial

When x < 0, p must be positive integer.

program example_ligamma
  use stdlib_specialfunctions_gamma, only: lig => lower_incomplete_gamma
  implicit none
  integer :: p
  real :: p1

  p = 3
  p1 = 2.3
  print *, lig(p, -5.0)

! -2521.02417

  print *, lig(p1, 5.0)

! 1.09715652
end program example_ligamma

When x < 0, p must be a positive integer.

program example_uigamma
  use stdlib_specialfunctions_gamma, only: uig => upper_incomplete_gamma
  implicit none

  print *, uig(3, -5.0)

!2523.02295

  print *, uig(2.3, 5.0)

!6.95552528E-02
end program example_uigamma

The values of regularized gamma P is in the range of [0, 1]

program example_gamma_p
  use stdlib_specialfunctions_gamma, only: rgp => regularized_gamma_p
  implicit none

  print *, rgp(3.0, 5.0)

! 0.875347972
end program example_gamma_p

The values of regularized gamma Q is in the range of [0, 1]

program example_gamma_q
  use stdlib_specialfunctions_gamma, only: rgq => regularized_gamma_q
  implicit none

  print *, rgq(3.0, 5.0)

! 0.124652028
end program example_gamma_q

stdlib_specialfunctions_gamma#

`stdlib_specialfunctions_gamma`#