WOLFRAM

Wolfram Language & System Documentation Center

LogGamma[z]

gives the logarithm of the gamma function .

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Numerical Evaluation  
Specific Values  
Visualization  
Show More Show More
Function Properties  
Differentiation  
Integration  
Series Expansions  
Function Identities and Simplifications  
Function Representations  
Applications  
Properties & Relations  
Possible Issues  
Neat Examples  
See Also
Tech Notes
Related Guides
Related Links
History
Cite this Page

LogGamma

LogGamma[z]

gives the logarithm of the gamma function .

Details

  • Mathematical function, suitable for both symbolic and numerical manipulation.
  • LogGamma[z] is analytic throughout the complex z plane, except for a single branch cut discontinuity along the negative real axis. Log[Gamma[z]] has a more complex branch cut structure.
  • For certain special arguments, LogGamma automatically evaluates to exact values.
  • LogGamma can be evaluated to arbitrary numerical precision.
  • LogGamma automatically threads over lists.
  • LogGamma can be used with Interval and CenteredInterval objects. »

Examples

open all close all

Basic Examples  (5)

Evaluate numerically:

Wolfram Language code: LogGamma[2.5]

Evaluate at large arguments:

Wolfram Language code: LogGamma[10. ^ 1000]

Plot over a subset of the reals:

Wolfram Language code: Plot[LogGamma[x], {x, 0, 5}]

Plot over a subset of the complexes:

Wolfram Language code: ComplexPlot3D[LogGamma[z], {z, -2 - 2I, 2 + 2I}, PlotLegends -> Automatic]

Series expansion about the origin:

Wolfram Language code: Series[LogGamma[z], {z, 0, 4}]

Series expansion at Infinity:

Wolfram Language code: Series[LogGamma[z], {z, ∞, 4}]

Scope  (36)

Numerical Evaluation  (5)

Evaluate numerically to high precision:

Wolfram Language code: N[LogGamma[22 / 10], 50]

The precision of the output tracks the precision of the input:

Wolfram Language code: LogGamma[2.20000000000000000000000]

Complex arguments:

Wolfram Language code: LogGamma[2.5 + 3I]

Evaluate LogGamma efficiently at high precision:

Wolfram Language code: LogGamma[2.2`500]//Timing
Wolfram Language code: LogGamma[2.2`5000];//Timing

Compute worst-case guaranteed intervals using Interval and CenteredInterval objects:

Wolfram Language code: LogGamma[Interval[{0.41, 0.42}]]
Wolfram Language code: LogGamma[CenteredInterval[0.4, 0.01]]

Or compute average-case statistical intervals using Around:

Wolfram Language code: LogGamma[ Around[1.2, 0.01]]

Compute the elementwise values of an array:

Wolfram Language code: LogGamma[{{1 / 2, -1}, {0, 1 / 2}}]

Or compute the matrix LogGamma function using MatrixFunction:

Wolfram Language code: MatrixFunction[LogGamma[#]&, {{1 / 2, -1}, {0, 1 / 2}}]//FullSimplify

Specific Values  (4)

Give exact results for integers and half-integers:

Wolfram Language code: LogGamma[5]
Wolfram Language code: LogGamma[-3 / 2]

Some singular points of LogGamma:

Wolfram Language code: {LogGamma[0], LogGamma[-1], LogGamma[-2], LogGamma[-3]}

Values at infinity:

Wolfram Language code: LogGamma[{Infinity, -Infinity, I Infinity}]
Wolfram Language code: LogGamma[ComplexInfinity]

Find a zero of LogGamma:

Wolfram Language code: xzero = Solve[LogGamma[x] == 0 && 0 < x < 2, x, Reals][[1, 1, 2]]//Quiet
Wolfram Language code: Plot[LogGamma[x], {x, 0, 4}, Epilog -> Style[Point[{xzero, LogGamma[xzero]}], PointSize[Large], Red]]

Visualization  (2)

Plot LogGamma:

Wolfram Language code: Plot[LogGamma[x], {x, 0, 5}]

Plot the real part of TemplateBox[{z}, LogGamma]:

Wolfram Language code: ComplexContourPlot[Re[LogGamma[z]], {z, -4 - 4I, 4 + 4 I}, Contours -> 20]

Plot the imaginary part of TemplateBox[{z}, LogGamma]:

Wolfram Language code: ComplexContourPlot[Im[LogGamma[z]], {z, -4 - 4I, 4 + 4 I}, Contours -> 20]

Function Properties  (8)

LogGamma is defined for all positive real values:

Wolfram Language code: FunctionDomain[LogGamma[x], x]

Complex domain:

Wolfram Language code: FunctionDomain[LogGamma[z], z, Complexes]

LogGamma is not an analytic function:

Wolfram Language code: FunctionAnalytic[LogGamma[x], x]

Has both singularities and discontinuities:

Wolfram Language code: FunctionSingularities[LogGamma[x], x]
Wolfram Language code: FunctionDiscontinuities[LogGamma[x], x]

LogGamma is neither nondecreasing nor nonincreasing:

Wolfram Language code: FunctionMonotonicity[{LogGamma[x], x > 0}, x]

LogGamma is not injective:

Wolfram Language code: FunctionInjective[LogGamma[x], x]
Wolfram Language code: Plot[{LogGamma[x], 1}, {x, 0, 5}]

LogGamma is not surjective:

Wolfram Language code: FunctionSurjective[LogGamma[x], x]
Wolfram Language code: Plot[{LogGamma[x], -2}, {x, 0, 6}]

LogGamma is neither non-negative nor non-positive:

Wolfram Language code: FunctionSign[{LogGamma[x], x > 0}, x]

LogGamma is convex on its real domain:

Wolfram Language code: FunctionConvexity[{LogGamma[x], x > 0}, x]

Differentiation  (3)

First derivative of LogGamma:

Wolfram Language code: D[LogGamma[x], x]

Higher derivatives of LogGamma:

Wolfram Language code: Table[D[LogGamma[x], {x, n}], {n, 1, 4}]
Wolfram Language code: Plot[Evaluate[%], {x, 0, 4}, PlotLegends -> {"First Derivative", "Second Derivative", "Third Derivative", "Fourth Derivative"}]

Formula for the ^(th) derivative:

Wolfram Language code: D[LogGamma[x], {x, n}]

Integration  (3)

Indefinite integral of LogGamma:

Wolfram Language code: Integrate[LogGamma[x], x]

Compute integrals involving LogGamma:

Wolfram Language code: Integrate[x LogGamma[x], {x, 0, 1}]
Wolfram Language code: Integrate[LogGamma[1 + x], x]
Wolfram Language code: Integrate[x^2LogGamma[x], x]

Definite integral for complex values of LogGamma:

Wolfram Language code: Integrate[LogGamma[x], {x, -2, 0}]

Series Expansions  (5)

Series expansion at the origin:

Wolfram Language code: Series[LogGamma[z], {z, 0, 5}]

Taylor expansion for LogGamma around :

Wolfram Language code: Series[LogGamma[x], {x, 1, 3}]

Plot the first three approximations for LogGamma around :

Wolfram Language code: terms = Normal@Table[Series[LogGamma[x], {x, 1, m}], {m, 1, 3}]; Plot[{LogGamma[x], terms}, {x, 0, 2}]

Series expansion at infinity:

Wolfram Language code: Series[LogGamma[z], {z, Infinity, 5}]

Give the result for an arbitrary symbolic direction :

Wolfram Language code: Series[LogGamma[z], {z, DirectedInfinity[], 5}]

Series expansion at poles of the LogGamma function:

Wolfram Language code: Series[LogGamma[z], {z, -5, 3}]

LogGamma can be applied to a power series:

Wolfram Language code: LogGamma[1 + x + (x^2/2) + O[x]^4]

Function Identities and Simplifications  (3)

Use FullSimplify to simplify logarithmic gamma functions:

Wolfram Language code: FullSimplify[LogGamma[z] - Log[Gamma[z]], z > 0]

Use FunctionExpand to express through Gamma:

Wolfram Language code: FunctionExpand[LogGamma[z], z > 0]

Recurrence relation:

Wolfram Language code: LogGamma[z] == LogGamma[z + 1] - Log[z]//FullSimplify

Function Representations  (3)

Series representation of LogGamma:

Wolfram Language code: FullSimplify[LogGamma[z] == Sum[(z/k) - Log[1 + (z/k)], {k, 1, Infinity}] - z EulerGamma - Log[z]]

Integral representation of LogGamma through PolyGamma:

Wolfram Language code: Integrate[PolyGamma[t], {t, 1, z}]

TraditionalForm formatting:

Wolfram Language code: LogGamma[z]//TraditionalForm

Applications  (4)

Calculate ratio of Gamma functions at very large arguments:

Wolfram Language code: Exp[LogGamma[10. ^ 16] - LogGamma[10. ^ 16 + 12.]]

Direct calculation fails because intermediate numbers are too large:

Wolfram Language code: Gamma[10. ^ 15] / Gamma[10. ^ 15 + 12]

Find the first few digits of :

Wolfram Language code: Block[{$MaxExtraPrecision = Infinity}, 10 ^ N[FractionalPart[LogGamma[10 ^ 100 + 1] / Log[10]], 10]]

Plot of the imaginary part of LogGamma[z] and Log[Gamma[z]] over the complex plane:

Wolfram Language code: Table[With[{f = f}, Plot3D[Im[f[x + I y]], {x, -3, 3}, {y, -1, 1}, PlotTheme -> "Detailed", ImageSize -> Small]], {f, {LogGamma, Log @* Gamma}}]

Determine the number of bins to use for bimodal data by Knuth's Bayesian method:

Wolfram Language code: ExampleData[{"Statistics", "OldFaithful"}, "ColumnDescriptions"]
Wolfram Language code: data = ExampleData[{"Statistics", "OldFaithful"}][[All, 1]];
Wolfram Language code: optBins[data_, M_Integer] := Block[{nn = Length[data], n, p1, p2, min, max}, {min, max} = Through[{Min, Max}[data]]; n = N[HistogramList[data, {min, max + (max - min) / M, (max - min) / M}][[2]]]; p1 = nn Log[M] + LogGamma[M / 2] - LogGamma[nn + M / 2]; p2 = -M LogGamma[1 / 2] + Total[LogGamma[n + 1 / 2]];p1 + p2]

The optimal number of bins maximizes the log of the posterior density:

Wolfram Language code: oBins = Table[{nbin, optBins[data, nbin]}, {nbin, Length[data] / 6}];
Wolfram Language code: ListLinePlot[oBins, Filling -> Axis, AxesOrigin -> {0, -300}]

Properties & Relations  (6)

Use FullSimplify to simplify logarithmic gamma functions:

Wolfram Language code: FullSimplify[LogGamma[z] - Log[Gamma[z]], z > 0]

Use FunctionExpand to express through Gamma:

Wolfram Language code: FunctionExpand[LogGamma[z], z > 0]

Numerically find a root of a transcendental equation:

Wolfram Language code: FindRoot[LogGamma[z] - 4 LogGamma[z + 2] ^ 2 + z == 2, {z, 1}]

Check that TemplateBox[{x}, LogGamma] is convex for :

Wolfram Language code: Reduce[Implies[x > 0, LogGamma''[x] > 0], Reals]

Find minimum of TemplateBox[{x}, LogGamma] on the positive real axis:

Wolfram Language code: {minval, minargRule} = NMinimize[{LogGamma[x], x > 0}, x]

Visualize the result:

Wolfram Language code: Plot[LogGamma[x], {x, 0, 3}, Epilog -> {Red, PointSize[Large], Point[{x /. minargRule, minval}]}]

In TraditionalForm, is automatically interpreted as the gamma function:

Wolfram Language code: logΓ(z)

Possible Issues  (2)

For many complex values :

Wolfram Language code: Plot3D[Abs[LogGamma[x + I y] - Log[Gamma[x + I y]]], {x, -5, 5}, {y, -5, 5}]

Algorithmically generated results typically contain instead of :

Wolfram Language code: Sum[Log[k ^ 2 + 5k + 6], {k, 1, n}]

Neat Examples  (2)

Plot LogGamma at the Gaussian integers:

Wolfram Language code: Block[{$MaxExtraPrecision = 100}, ArrayPlot[Table[Mod[Re@Round[LogGamma[x + I y]], 2], {x, 1, 50}, {y, 1, 50}]]]

Riemann surface of LogGamma:

Wolfram Language code: With[{ϵ = 10 ^ -6}, Show[Table[Plot3D[Im[LogGamma[x + I y] + 2 Pi I k], {x, i + ϵ, i + 1 - ϵ}, {y, j + ϵ, j + 1 - ϵ}, Mesh -> False, PlotRange -> All, BoundaryStyle -> None, PlotPoints -> 6], {k, -1, 1}, {i, -3, 2}, {j, -3, 2}], BoxRatios -> {1, 1, 1}, ViewPoint -> {-2.5, -2, 1.4}]]
Wolfram Research (1991), LogGamma, Wolfram Language function, https://reference.wolfram.com/language/ref/LogGamma.html (updated 2022).

Text

Wolfram Research (1991), LogGamma, Wolfram Language function, https://reference.wolfram.com/language/ref/LogGamma.html (updated 2022).

CMS

Wolfram Language. 1991. "LogGamma." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2022. https://reference.wolfram.com/language/ref/LogGamma.html.

APA

Wolfram Language. (1991). LogGamma. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/LogGamma.html

BibTeX

@misc{reference.wolfram_2026_loggamma, author="Wolfram Research", title="{LogGamma}", year="2022", howpublished="\url{https://reference.wolfram.com/language/ref/LogGamma.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_loggamma, organization={Wolfram Research}, title={LogGamma}, year={2022}, url={https://reference.wolfram.com/language/ref/LogGamma.html}, note=[Accessed: 13-June-2026]}