HomeCalculatorsMathSpecial FunctionsSpecial Functions Calculator
Math calculator

Special Functions Calculator

Evaluate erf, Gamma, Bessel, Lambert W, beta and sinc. Explore a live graph, worked examples, input limits and shareable results computed locally.

Instant result
Result
—

Enter values to calculate.

Inputs—
Mode—
Formula—
Trust summary CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published modes
Input interpretation
Enter values to calculate.
Result
—
Verified scope
all published modes
Assurance
Core
Declared partition coverage
PASS · 15/15 declared partitions (erf, erfc, gamma, lgamma, bessel-j, bessel-y, bessel-i, bessel-k, lambert-w, lambert-wm1, beta, incomplete-beta, sinc, normalized-sinc, invalid-domain) · Matrix
Known limitations
  • Core CVP does not include live graph, viewport, or pointer interaction.
Model
Real erf, erfc, Gamma, log-gamma, integer-order J_n, Y_n, I_n, and K_n, Lambert W_0 and W_{-1}, complete Euler beta, incomplete beta, unnormalized sinc, and normalized sinc.
Scope
Relative accuracy weakens near zeros of Bessel J/Y. Small positive K tails are retained within Float64 range.
Verification
Engine tested · Source checked · v1.10.6 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published modes· View Manifest · CVP overview · Specification
Versions
Calculation 1.10.6 · CVP protocol 1.0.0-proposed · Evidence 2026-10-28.metric-scope-v3
Verification revision
2026-10-28.metric-scope-v3 · 1/1 property · digest c70f9a6399c7
Legacy regression
57/58 tests · Production surface contract 6/6
Trust layers
Verification VERIFIED · Production CURRENT · Overall CVP state: VERIFIED under CVP 1.0.0-proposed
Reference
O1 model · O2 expected_values · O2 expected_values · O2 expected_values · O2 numerical_behavior
Interfaces
PASS · UI (SSR) / REST / MCP — ui-ssr is query-result HTML, not a live browser session. Error-path engine·REST·MCP 1/1 (status, code, calculation_version). SSR compared on URL-canonical requested calculations; empty query is idle (not an error) and JSON-typed object/array inputs are REST/MCP-only. Special response contract also checks all 14 mode formulas and unrounded numeric summaries, including erfc/K tails and a subnormal erf input; UI is shared presentation/SSR, not a live browser session.
Supplemental domain review
Not performed
Named expert review
Not performed
CVP suite
1000/1000 golden · 8/8 CVP boundary · 24/24 invalid · 1/1 property · 3/3 metamorphic · 24/24 cross-interface · 1/1 cross-calculator · 6/6 CVP contract · Manifest
Sources
Sources
Evidence
13 legacy golden · 8 legacy boundary · legacy regression suite · 1000/1000 oracle-backed golden · 24/24 invalid · Artifact integrity PASS
This calculator CURRENT · Public schema 1.10.6 matches · Semantic contract ✓ · Production attested · Public/cache ✓ · Origin ✓
Semantic contract
PASS
Full verification

Manifest identity, reference classes, interfaces, suite, and production records.

Formulas

Core equations used by this calculator.

Error functionerf(x) = (2/√π) ∫₀ˣ e^{−t²} dt
GammaΓ(x) = ∫₀^∞ t^{x−1} e^{−t} dt
Log-gammalgamma(x) = ln Γ(x), x > 0
Bessel JJ_n(x) = (x/2)^n Σ_k (−1)^k (x/2)^{2k} / (k! (n+k)!)
Bessel YY_n(x) Neumann, x > 0
Bessel II_n(x) = (x/2)^n Σ_k (x/2)^{2k} / (k! (n+k)!)
Bessel KK_n(x) Macdonald, x > 0
Lambert WW(x) e^{W(x)} = x
Lambert W₋₁W_{-1}(x) e^{W_{-1}(x)} = x, −1/e ≤ x < 0
BetaB(x, y) = Γ(x)Γ(y) / Γ(x+y)
Incomplete betaB_x(a, b) = ∫₀ˣ t^{a−1} (1−t)^{b−1} dt
sincsinc(x) = sin(x)/x, sinc(0)=1
Normalized sincsinc(x) = sin(πx)/(πx), sinc(0)=1
ierfc and lgamma are hub modes. Discovery pages lock erf, gamma, Bessel J, Bessel Y, Bessel I, Bessel K, Lambert W, Lambert W₋₁, Beta, incomplete beta, sinc, and normalized sinc. Γ(n)=(n−1)! for positive integers, but n! stays on /factorial. Not CAS.

How to use

1

Choose erf, erfc, Gamma, log-gamma, Bessel J, Bessel Y, Bessel I, Bessel K, Lambert W, Lambert W₋₁, Beta, incomplete beta, sinc, or normalized sinc

erf and erfc take any finite real x. Gamma is undefined at non-positive integers. log-gamma is real for x>0 on this seed. Bessel J and I need integer n=0…8 and |x|≤80. Bessel Y and K need integer n=0…8 and x>0. Lambert W_0 needs x ≥ −1/e. Lambert W_{-1} needs −1/e ≤ x < 0. Beta needs x>0, y>0. Incomplete beta needs a>0, b>0, 0≤x≤1. Unnormalized sinc(0)=1. Normalized sinc(1/2)=2/π.

2

Read the value

erf(1) ≈ 0.84270079295. Γ(1/2)=√π. Γ(6)=120. J_0(1) ≈ 0.765197686558. Y_0(1) ≈ 0.0882569642157. I_0(1) ≈ 1.26606587775. K_0(1) ≈ 0.421024438241. W_0(1) ≈ 0.56714329041. W_{-1}(−0.1) ≈ −3.57715206396. B(2,3)=1/12. B_{0.5}(2,3) ≈ 0.0572916666667. sinc(0)=1. normalized sinc(1/2)=2/π.

Example calculations

Common configurations with formula and result.

ϟ

erf(1)

x = 1

erf(1)
0.84270079295
ϟ

Half-integer Gamma

x = 0.5

Γ(1/2) = √π
√π
ϟ

Gamma of 6

x = 6

Γ(6) = 5!
120
ϟ

J_0(1)

n = 0, x = 1

J_0(1)
0.765197686558
ϟ

Y_0(1)

n = 0, x = 1

Y_0(1)
0.0882569642157
ϟ

I_0(1)

n = 0, x = 1

I_0(1)
1.26606587775
ϟ

K_0(1)

n = 0, x = 1

K_0(1)
0.421024438241
ϟ

W_0(1)

x = 1

W_0(1) = Ω
0.56714329041
ϟ

W_{-1}(−0.1)

x = −0.1

W_{-1}(−0.1)
−3.57715206396
ϟ

B(2, 3)

x = 2, y = 3

B(2, 3) = 1/12
0.0833333333333
ϟ

B_{0.5}(2, 3)

x = 0.5, a = 2, b = 3

B_{0.5}(2, 3)
0.0572916666667
ϟ

sinc(0)

x = 0

sinc(0) = 1
1
ϟ

Normalized sinc(1/2)

x = 0.5

sinc(1/2) = 2/π
0.636619772368

Special Functions calculator specification

Version 1.10.6 · Engine tested

Calculation status

Review policy · Evidence

Definition
Real special functions: erf(x)=(2/√π)∫₀ˣ e^{−t²} dt, erfc(x)=1−erf(x), Γ(x)=∫₀^∞ t^{x−1} e^{−t} dt for x>0, with continuation away from the poles at 0,−1,−2,…, lgamma(x)=ln Γ(x) for x>0, integer-order J_n(x), integer-order Y_n(x) for x>0, integer-order I_n(x), integer-order K_n(x) for x>0, principal Lambert W_0(x) for x≥−1/e, secondary Lambert W_{-1}(x) for −1/e≤x<0, complete Euler B(x,y)=Γ(x)Γ(y)/Γ(x+y) for x>0, y>0, incomplete beta B_x(a,b)=∫₀ˣ t^{a−1}(1−t)^{b−1} dt for a>0, b>0, 0≤x≤1, unnormalized sinc(x)=sin(x)/x with sinc(0)=1, and normalized sinc(x)=sin(πx)/(πx) with sinc(0)=1. Discovery /error-function, /gamma-function, /bessel-function, /bessel-y, /bessel-i, /bessel-k, /lambert-w, /lambert-w-minus-1, /beta-function, /incomplete-beta, /sinc-function, /normalized-sinc. Integer n! stays on factorial. Not CAS.
What it calculates
Real erf, erfc, Gamma, log-gamma, integer-order J_n, Y_n, I_n, and K_n, Lambert W_0 and W_{-1}, complete Euler beta, incomplete beta, unnormalized sinc, and normalized sinc.
Inputs
  • mode
  • x
  • y
  • n
  • a
  • b
Outputs
  • value
  • erf?
  • erfc?
  • gamma?
  • lgamma?
  • n?
  • branch?
  • y?
  • a?
  • b?
  • regularized?
Formula
erf(x); erfc(x)=1−erf(x); Γ(x); lgamma(x)=ln Γ(x); J_n(x); Y_n(x); I_n(x); K_n(x); W_0(x) e^{W_0}=x; W_{-1}(x) e^{W_{-1}}=x; B(x,y)=Γ(x)Γ(y)/Γ(x+y); B_x(a,b); sinc(x)=sin(x)/x; sinc(x)=sin(πx)/(πx)
Assumptions
  • Relative accuracy weakens near zeros of Bessel J/Y. Small positive K tails are retained within Float64 range.
  • Real argument
  • Gamma poles at non-positive integers
  • lgamma is real for x > 0
  • Bessel J integer n=0…8, |x|≤80
  • Bessel Y integer n=0…8, x>0
  • Bessel I integer n=0…8, |x|≤80
  • Bessel K integer n=0…8, x>0
  • Lambert W_0 for x ≥ −1/e
  • Lambert W_{-1} for −1/e ≤ x < 0
  • Complete Euler B(x,y) for x>0, y>0
  • Incomplete B_x(a,b) for a>0, b>0, 0≤x≤1
  • Unnormalized sinc(x)=sin(x)/x, sinc(0)=1
  • Normalized sinc(x)=sin(πx)/(πx), sinc(0)=1
  • The Result Card includes an engine-linked Live graph for erf, erfc, Γ, ln Γ, J_n / Y_n / I_n / K_n, W₀ / W₋₁, B(x, y) vs x (y held), incomplete B_x on [0, 1], sinc, and normalized sinc. Same special-functions engine as REST/MCP. Integer n! stays on /factorial. Not CAS.
Units
  • dimensionless
Boundary conditions
  • non-finite x → INVALID_NUMBER
  • Gamma at 0, −1, −2, … → INVALID_INPUT
  • lgamma with x ≤ 0 → INVALID_INPUT
  • Bessel n not in 0…8 or |x|>80 → INVALID_INPUT
  • Y_n or K_n with x ≤ 0 → INVALID_INPUT
  • Lambert W_0 x < −1/e → INVALID_INPUT
  • Lambert W_{-1} x < −1/e or x ≥ 0 → INVALID_INPUT
  • Beta x ≤ 0 or y ≤ 0 → INVALID_INPUT
  • Incomplete beta a ≤ 0, b ≤ 0, or x ∉ [0,1] → INVALID_INPUT
  • unknown mode → INVALID_MODE
Example
mode=erf x=1 → 0.84270079295
Validation cases

13 published on this page · 57/58 tests · Production surface contract 6/6 · View evidence

  • mode=erf x=1 → 0.84270079295
  • mode=gamma x=0.5 → √π
  • mode=gamma x=6 → 120
  • mode=bessel_j n=0 x=1 → 0.765197686558
  • mode=bessel_y n=0 x=1 → 0.0882569642157
  • mode=bessel_i n=0 x=1 → 1.26606587775
  • mode=bessel_k n=0 x=1 → 0.421024438241
  • mode=lambert_w x=1 → 0.56714329041
  • mode=lambert_wm1 x=−0.1 → −3.57715206396
  • mode=beta x=2 y=3 → 0.0833333333333
  • mode=incomplete_beta x=0.5 a=2 b=3 → 0.0572916666667
  • mode=sinc x=0 → 1
  • mode=normalized_sinc x=0.5 → 0.636619772368
Sources
Calculation version
1.10.6

Background

Interpretation and common distinctions.

What does this special functions calculator compute?

This calculator evaluates its supported real error, gamma, beta, Bessel, Lambert W, and sinc functions. Select the intended function and branch, then follow the narrower input domain and precision limits published for that operation.

The published formula or method is erf(x); erfc(x)=1−erf(x); Γ(x); lgamma(x)=ln Γ(x); J_n(x); Y_n(x); I_n(x); K_n(x); W_0(x) e^{W_0}=x; W_{-1}(x) e^{W_{-1}}=x; B(x,y)=Γ(x)Γ(y)/Γ(x+y); B_x(a,b); sinc(x)=sin(x)/x; sinc(x)=sin(πx)/(πx). The following references support the stated mathematics or method:

Which inputs and limits should you check?

The mathematical function can have a wider domain than this calculator supports. Choose the intended function and branch, then check its input domain and published precision limits.

The worked example uses x = 1 with erf(1). Compare it with the Example calculations and the complete result for the same inputs.

How can you verify and cite this result?

CalculatorX is responsible for this page. The mathematical references above explain the model; implementation checks and their scope are documented separately in the math.special v1.10.6 Evidence and capability contract. Read the displayed verification and production state together with the specification's numerical limits.

Use the clean calculator URL to cite the tool. A shared input link identifies a particular calculation. Content updates, numerical verification, and domain reviews have separate dates and scopes.

Numerical precision and input policy

  • Real, dimensionless binary64 inputs; publishes12 significant digits, no arbitrary-precision/exact claim.
  • Default mode erf and Bessel order0 apply only when absent; explicit empty/null rejects. All supplied numeric aliases must agree; known irrelevant numeric parameters are parsed then ignored.
  • Gamma poles reject. Nonzero Gamma that underflows rejects NUMERICAL_RANGE_ERROR; positive overflow suggests lgamma. lgamma is computed directly for x>0, using a local Taylor expansion near its zeros1 and2.
  • Bessel integer n0–8, |x|≤80, Y/K require x>0; subnormal error and zeros limit relative accuracy.
  • Lambert W0 and W-1 explicit real branches; binary64 -1/e designated endpoint, no tolerance band absorbs adjacent inputs.
  • Beta shapes positive and at most1e6, except exact B(x,1)=1/x or B(1,y)=1/y. Incomplete beta shapes at most1e6. CF capped10000 steps; failure NO_CONVERGENCE.
  • erf/erfc and beta tails can round to zero only on binary64 underflow, not an absolute display cutoff. Regularized incomplete beta evaluated separately in logs.
  • Normalized sinc uses sinpi reduction and returns zero at representable nonzero integer x. Other tiny nonzero results retain significance.
  • Numeric references have relative1e-10, with J/Y near zeros absolute2e-14,4 minimum subnormals otherwise. No global error proof for all real inputs.
  • Browser interaction computes locally; parameterized share pages, REST and MCP send inputs to server. Logs/retention/region are deployment concerns; no zero-log promise.

Discovery pages lock their advertised function; the hub selects all14 operations. A shared link replays with the current engine and identifies its calculation version; it does not preserve a historical runtime. CSV and JSON exports retain the original decimal inputs, complete function result, formula and version.

Definitions and methods: NIST DLMF Gamma, incomplete beta, and Lambert W. CVP verification is separate from expert review and production freshness.

Other calculators in this family: Bessel I Calculator, Bessel J Calculator, Bessel K Calculator, Bessel Y Calculator, Beta Function Calculator, Error Function Calculator, Gamma Function Calculator, Incomplete Beta Calculator . Explore all Special Functions.

→ Bessel I Calculator Evaluate modified Bessel I functions for integer orders 0–8. Explore a live graph, worked examples, input limits and shareable results computed locally. › → Bessel J Calculator Evaluate integer-order Bessel J functions for orders 0–8. Explore a live graph, worked examples, input limits and shareable results computed locally. › → Bessel K Calculator Evaluate modified Bessel K functions for positive x, orders 0–8. Explore a live graph, worked examples, input limits and shareable results computed locally. › → Bessel Y Calculator Evaluate Bessel Y functions for positive x and orders 0–8. Explore a live graph, worked examples, input limits and shareable results computed locally. › → Beta Function Calculator Calculate the complete Euler beta function B(x,y). Explore a live graph, worked examples, input limits and shareable results computed locally. › → Error Function Calculator Calculate erf(x) and the complementary error function erfc(x). Explore a live graph, worked examples, input limits and shareable results computed locally. › → Gamma Function Calculator Calculate Gamma values for real inputs away from its poles. Explore a live graph, worked examples, input limits and shareable results computed locally. › → Incomplete Beta Calculator Calculate incomplete beta Bx(a,b) and regularized Ix(a,b). Explore a live graph, worked examples, input limits and shareable results computed locally. ›

Frequently asked questions

Key distinctions behind the calculation.

Is Γ(6)=120 the factorial calculator?

No. Γ(n)=(n−1)! for positive integers, on a different model. Integer n! stays on /calc/math/factorial.

Is this incomplete beta or normalized sinc?

Both are on this engine: incomplete beta is mode=incomplete_beta (/incomplete-beta); normalized sinc is mode=normalized_sinc (/normalized-sinc). This seed is erf, erfc, Γ, ln Γ, integer-order J_n, Y_n, I_n, K_n, principal W_0, secondary W_{-1}, complete Euler B(x,y), incomplete B_x(a,b), unnormalized sinc, and normalized sinc. Not CAS.

Where does this run?

Locally in the browser by default. REST and MCP call the same special-functions engine.