bessely

Bessel function of second kind

Syntax

Y = bessely(nu,Z)

Y = bessely(nu,Z,scale)

Description

Y = bessely(nu,Z) computes the Bessel function of the second kind Y_ν(z) for each element in array Z.

Y = bessely(nu,Z,scale) specifies whether to exponentially scale the Bessel function of the second kind to avoid overflow or loss of accuracy. If scale is 1, then the output of bessely is scaled by the factor exp(-abs(imag(Z))).

Examples

Plot Bessel Functions of Second Kind

Define the domain.

z = 0:0.1:20;

Calculate the first five Bessel functions of the second kind. Each row of Y contains the values of one order of the function evaluated at the points in z.

Y = zeros(5,201);
for i = 0:4
    Y(i+1,:) = bessely(i,z);
end

Plot all of the functions in the same figure.

plot(z,Y)
axis([-0.1 20.2 -2 0.6])
grid on
legend('Y_0','Y_1','Y_2','Y_3','Y_4','Location','Best')
title('Bessel Functions of the Second Kind for $\nu \in [0, 4]$','interpreter','latex')
xlabel('z','interpreter','latex')
ylabel('$Y_\nu(z)$','interpreter','latex')

Calculate Exponentially Scaled Bessel Function

Calculate the unscaled (Y) and scaled (Ys) Bessel function of the second kind ${\mathit{Y}}_2\left(\mathit{z}\right)$ for complex values of $\mathit{z}$.

x = -10:0.35:10;
y = x';
z = x + 1i*y;
scale = 1;
Y = bessely(2,z);
Ys = bessely(2,z,scale);

Compare the plots of the imaginary part of the scaled and unscaled functions. For large values of abs(imag(z)), the unscaled function quickly overflows the limits of double precision and stops being computable. The scaled function removes this dominant exponential behavior from the calculation and thus has a larger range of computability compared to the unscaled function.

surf(x,y,imag(Y))
title('Bessel Function of the Second Kind','interpreter','latex')
xlabel('real(z)','interpreter','latex')
ylabel('imag(z)','interpreter','latex')

surf(x,y,imag(Ys))
title('Scaled Bessel Function of the Second Kind','interpreter','latex')
xlabel('real(z)','interpreter','latex')
ylabel('imag(z)','interpreter','latex')

Input Arguments

nu — Equation order

scalar | vector | matrix | multidimensional array

Equation order, specified as a scalar, vector, matrix, or multidimensional array. nu is a real number that specifies the order of the Bessel function of the second kind. nu and Z must be the same size, or one of them can be scalar.

Example: bessely(3,0:5)

Data Types: single | double

Z — Functional domain

scalar | vector | matrix | multidimensional array

Functional domain, specified as a scalar, vector, matrix, or multidimensional array. bessely is real-valued where Z is positive. nu and Z must be the same size, or one of them can be scalar.

Example: bessely(1,[1-1i 1+0i 1+1i])

Data Types: single | double
Complex Number Support: Yes

scale — Toggle to scale function

0 (default) | 1

Toggle to scale function, specified as one of these values:

• 0 (default) — No scaling

• 1 — Scale the output of bessely by exp(-abs(imag(Z)))

On the complex plane, the magnitude of bessely grows rapidly as the value of abs(imag(Z)) increases, so exponentially scaling the output is useful for large values of abs(imag(Z)) where the results otherwise quickly lose accuracy or overflow the limits of double precision.

Example: bessely(3,0:5,1)

More About

Bessel Functions

This differential equation, where ν is a real constant, is called Bessel's equation:

$$z^2\frac{d^{2}y}{d{z}^2}+z\frac{dy}{dz}+\left(z^2-{\nu }^2\right)y=0.$$

Its solutions are known as Bessel functions.

The Bessel functions of the first kind, denoted J_ν(z) and J_–ν(z), form a fundamental set of solutions of Bessel's equation for noninteger ν. J_ν(z) is defined by

$$J_{\nu }(z)={\left(\frac{z}{2}\right)}^{\nu }{\displaystyle \sum }_{(k=0)}^{\infty }\frac{{\left(\frac{-z^2}{4}\right)}^k}{k!\Gamma (\nu +k+1)}.$$

You can calculate Bessel functions of the first kind using besselj.

The Bessel functions of the second kind, denoted Y_ν(z), form a second solution of Bessel's equation that is linearly independent of J_ν(z). Y_ν(z) is defined by

$$Y_{\nu }(z)=\frac{J_{\nu }(z)\cos (\nu \pi )-J_{-\nu }(z)}{\sin (\nu \pi )}.$$

Tips

The Bessel functions are related to the Hankel functions, also called Bessel functions of the third kind:

$$\begin{array}{l}{H}_{\nu }^{(1)}(z)=J_{\nu }(z)+i{Y}_{\nu }(z)\\ H_{\nu }^{(2)}(z)=J_{\nu }(z)-i{Y}_{\nu }(z).\end{array}$$

$$H_{\nu }^{(K)}(z)$$ is besselh, J_ν(z) is besselj, and Y_ν(z) is bessely. The Hankel functions also form a fundamental set of solutions to Bessel's equation (see besselh).

References

[1] Amos, D. E. “Algorithm 644: A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order.” ACM Transactions on Mathematical Software 12, no. 3 (September 1986): 265–273. https://dl.acm.org/doi/10.1145/7921.214331.

Extended Capabilities

Tall Arrays

Calculate with arrays that have more rows than fit in memory.

The bessely function fully supports tall arrays. For more information, see Tall Arrays.

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

• Always returns a complex result.

• Strict single-precision calculations are not supported. In the generated code, single-precision inputs produce single-precision outputs. However, variables inside the function might be double-precision.

GPU Code Generation

Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Usage notes and limitations:

• Always returns a complex result.

• Strict single-precision calculations are not supported. In the generated code, single-precision inputs produce single-precision outputs. However, variables inside the function might be double-precision.

Thread-Based Environment

Run code in the background using MATLAB® backgroundPool or accelerate code with Parallel Computing Toolbox™ ThreadPool.

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

GPU Arrays

Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

The bessely function supports GPU array input with these usage notes and limitations:

• The order nu must contain nonnegative, real, integer values.

• The argument Z must contain nonnegative real values.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Distributed Arrays

Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

This function fully supports distributed arrays. For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Version History

Introduced before R2006a