gammaln — Compute the natural logarithm of the gamma function element-wise in MATLAB and RunMat.

Y = gammaln(A) evaluates log(gamma(A)) for real nonnegative inputs while avoiding the overflow that can occur when computing gamma(A) first.

Syntax

Y = gammaln(A)

Inputs

NameTypeRequiredDefaultDescription
AAnyYesReal nonnegative numeric input.

Returns

NameTypeDescription
YNumericArrayNatural logarithm of the gamma function.

Errors

IdentifierWhenMessage
RunMat:gammaln:InvalidInputInput cannot be interpreted as real, nonsparse numeric data.gammaln: invalid input
RunMat:gammaln:DomainAt least one real input value is negative.gammaln: input must be nonnegative
RunMat:gammaln:InternalInternal tensor construction or provider interaction failed.gammaln: internal error

How gammaln works

  • gammaln(A) applies the log-gamma function element-by-element while preserving the input tensor shape.
  • Double inputs return double results; single tensors preserve single dtype metadata with single-rounded output values.
  • gammaln(0) returns Inf; gammaln(Inf) returns Inf; gammaln(NaN) returns NaN.
  • Scalar integer, logical, and character inputs are promoted through RunMat's ordinary numeric coercion path for compatibility with existing elementwise builtins.
  • Negative, complex, string, and sparse inputs produce stable typed errors.
  • Real GPU tensors stay on device when the provider implements unary_gammaln; otherwise RunMat gathers the tensor, evaluates on the host, and returns a host value with the computed results.

GPU memory and residency

Yes when the active provider implements unary_gammaln for real-valued gpuArray inputs. Providers without that hook trigger a host fallback, so the computed result is returned as a host tensor rather than a resident gpuArray.

Examples

Evaluate the log-gamma function at a scalar

y = gammaln(5)

Expected output:

y = 3.1781

Evaluate a half-integer input

y = gammaln(0.5)

Expected output:

y = 0.5724

Apply gammaln element-wise to an array

A = [0.5 1 2 5];
Y = gammaln(A)

Expected output:

Y = [0.5724 0 0 3.1781]

Avoid gamma overflow for large inputs

y = gammaln(171)

Expected output:

y = 706.5731

Run gammaln on GPU data

G = gpuArray([0.5 1 5]);
out = gammaln(G);
result = gather(out)

Expected output:

result = [0.5724 0 3.1781]

Using gammaln with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how gammaln changes the result.

Run a small gammaln example, explain the result, then change one input and compare the output.

FAQ

Why use gammaln(A) instead of log(gamma(A))?

gammaln evaluates the logarithm directly, so large positive inputs can remain finite even when gamma(A) would overflow before the logarithm is taken.

Does gammaln support complex or negative inputs?

No. MATLAB documents gammaln for real nonnegative input, and RunMat reports typed errors for complex and negative values.

Can gammaln run on GPU arrays?

Yes for real nonnegative tensors. The WGPU backend evaluates gammaln on device; other providers may fall back to host evaluation if they do not expose unary_gammaln.

Elementwise

abs · angle · bsxfun · complex · conj · double · erf · erfcinv · exp · expm1 · factorial · flintmax · gamma · heaviside · hypot · idivide · imag · intmax · intmin · ldivide · log · log10 · log1p · log2 · minus · nextpow2 · plus · pow2 · power · rdivide · real · realmax · realmin · realsqrt · rescale · sign · single · sqrt · swapbytes · times · uint32

Trigonometry

acos · acosh · asin · asinh · atan · atan2 · atanh · cos · cosd · cosh · cospi · deg2rad · pol2cart · rad2deg · sin · sind · sinh · sinpi · tan · tand · tanh

Reduction

all · any · bounds · cummax · cummin · cumprod · cumsum · cumtrapz · diff · gradient · max · maxk · mean · median · min · mink · movmax · movmean · movmedian · movmin · movprod · movstd · movsum · movvar · nnz · prod · rms · std · sum · trapz · var

Rounding

ceil · fix · floor · mod · rem · round

Factor

chol · decomposition · eig · eigs · lu · qr · svd

Solve

cond · det · inv · linsolve · norm · null · pinv · rank · rcond · rref · vecnorm

Symbolic

digits · int · limit · piecewise · sym · syms · vpa

Fft

fft · fft2 · fftshift · ifft · ifft2 · ifftshift

Discrete

lcm · primes

Ode

ode15s · ode23 · ode45

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code blazing on any GPU. It is licensed under the Apache 2.0 license.

  • RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
  • Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing

Download RunMat

Download RunMat for full performance, or use RunMat in your browser for zero setup.