WOLFRAM

Wolfram Language & System Documentation Center

NResidue[expr,{z,z0}]

numerically finds the residue of expr near the point z=z0.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Generalizations & Extensions  
Options  
Radius  
WorkingPrecision  
Applications  
Properties & Relations  
Possible Issues  
See Also
Tech Notes
Related Guides
Cite this Page
NumericalCalculus`
NumericalCalculus`

NResidue

NResidue[expr,{z,z0}]

numerically finds the residue of expr near the point z=z0.

Details and Options

  • To use NResidue, you first need to load the Numerical Calculus Package using Needs["NumericalCalculus`"].
  • The expression expr must be numeric when its argument x is numeric.
  • The residue is defined as the coefficient of (z-z0)-1 in the Laurent expansion of expr.
  • NResidue numerically integrates around a small circle centered at the point z0 in the complex plane. NResidue will return an incorrect result when the punctured disk is not analytic.
  • NResidue is unable to recognize small numbers that should in fact be zero. Chop is often needed to eliminate these spurious residuals.
  • Although Residue usually needs to be able to evaluate power series at a point, NResidue can find residues even if the power series cannot be computed.
  • NResidue has the same options as NIntegrate, with the following additions and changes:
  • Radius 1/100radius of contour on which integral is evaluated
    MethodTrapezoidalintegration method to use

Examples

open all close all

Basic Examples  (1)

Wolfram Language code: Needs["NumericalCalculus`"]

Residue of the function about the origin:

Wolfram Language code: NResidue[(1/x), {x, 0}]

Scope  (2)

Wolfram Language code: Needs["NumericalCalculus`"]

NResidue can find residues of functions with essential singularities:

Wolfram Language code: NResidue[Sin[(1/10x)], {x, 0}]//Chop

Since Series is unable to handle essential singularities, Residue returns unevaluated:

Wolfram Language code: Residue[Sin[(1/10x)], {x, 0}]
Wolfram Language code: Needs["NumericalCalculus`"]

NResidue allows for some error in the location of the pole:

Wolfram Language code: NResidue[(1/1.7 - 2.7z + z^2), {z, 1.}]//Chop

Due to machine-precision arithmetic, z -> 1. is not a pole:

Wolfram Language code: (1/1.7 - 2.7z + z^2) /. z -> 1.

With Residue, the error in the location of the pole yields a result of zero:

Wolfram Language code: Residue[(1/1.7 - 2.7z + z^2), {z, 1.}]

Generalizations & Extensions  (1)

Wolfram Language code: Needs["NumericalCalculus`"]

NResidue threads element-wise over lists:

Wolfram Language code: NResidue[{Exp[(1/x)], Sin[(1/x)], Cos[(1/x)]}, {x, 0}, Radius -> 1]//Chop

Options  (3)

Radius  (2)

Wolfram Language code: Needs["NumericalCalculus`"]

Use Radius to shrink the radius of the contour of integration to isolate a single pole:

Wolfram Language code: NResidue[(1/x) + (1/x + 0.005), {x, 0}]//Chop
Wolfram Language code: NResidue[(1/x) + (1/x + .005), {x, 0}, Radius -> .001]//Chop
Wolfram Language code: Needs["NumericalCalculus`"]

Increase the radius to improve convergence of the integration if no other poles are nearby:

Wolfram Language code: NResidue[Exp[(1/x)], {x, 0}]//Chop
Wolfram Language code: NResidue[Exp[(1/x)], {x, 0}, Radius -> 1]//Chop

WorkingPrecision  (1)

Wolfram Language code: Needs["NumericalCalculus`"]

NResidue accepts options for NIntegrate, which are sometimes necessary to get an accurate result:

Wolfram Language code: NResidue[Exp[(1/x)] + Exp[(1/x - (1/100))], {x, 0}, Radius -> (1/200), MaxRecursion -> 10, WorkingPrecision -> 100, PrecisionGoal -> 10]//Chop

Applications  (2)

Wolfram Language code: Needs["NumericalCalculus`"]

Use NResidue to evaluate derivatives of a function evaluated at a point:

Wolfram Language code: Derivative[10][Zeta][0]//N[#, {30, 30}]&
Wolfram Language code: 10!NResidue[(Zeta[x]/x^11), {x, 0}, Radius -> (1/2), WorkingPrecision -> 30]
Wolfram Language code: Needs["NumericalCalculus`"]

Residues of numerical functions:

Wolfram Language code: f[a_ ? NumericQ] := NIntegrate[Exp[(t^2/a)](1/10 + a t), {t, 0, 1}]
Wolfram Language code: NResidue[f[a], {a, 0}, Radius -> 1]//Chop

Properties & Relations  (1)

Wolfram Language code: Needs["NumericalCalculus`"]

NSeries can also compute residues of numerical functions:

Wolfram Language code: f[x_ ? NumericQ] := Exp[(1/x)]
Wolfram Language code: NResidue[f[x], {x, 0}, Radius -> 1]//Chop

Using NSeries:

Wolfram Language code: SeriesCoefficient[NSeries[f[x], {x, 0, 5}], -1]//Chop

Possible Issues  (1)

Wolfram Language code: Needs["NumericalCalculus`"]

NResidue will return an incorrect result when the integration contour contains branch cuts:

Wolfram Language code: Residue[Sqrt[x - 1]Sqrt[x + 1], {x, 0}]
Wolfram Language code: NResidue[Sqrt[x - 1]Sqrt[x + 1], {x, 0}, Radius -> 2]
Wolfram Research (2007), NResidue, Wolfram Language function, https://reference.wolfram.com/language/NumericalCalculus/ref/NResidue.html.

Text

Wolfram Research (2007), NResidue, Wolfram Language function, https://reference.wolfram.com/language/NumericalCalculus/ref/NResidue.html.

CMS

Wolfram Language. 2007. "NResidue." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/NumericalCalculus/ref/NResidue.html.

APA

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

BibTeX

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

BibLaTeX

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