bessely

Bessel function of second kind

Syntax


             
              Y = bessely(nu,Z)


             
              Y = bessely(nu,Z,scale)

Description

example

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

example

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

collapse all

Plot Bessel Functions of Second Kind

Open Live Script

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

Open Live Script

Calculate the unscaled ( Y ) and scaled ( Ys ) Bessel function of the second kind $Y_{2} (z)$ for complex values of $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

collapse all

`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

collapse all

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{d y}{d z} + (z^{2} - ν^{2}) 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_{ν} (z) = {(\frac{z}{2})}^{ν} \sum_{(k = 0)}^{\infty} \frac{{(\frac{- z^{2}}{4})}^{k}}{k! Γ (ν + 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_{ν} (z) = \frac{J_{ν} (z) \cos (ν π) - J_{- ν} (z)}{\sin (ν π)} .$

Tips

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

$\begin{array}{l} H_{ν}^{(1)} (z) = J_{ν} (z) + i Y_{ν} (z) \\ H_{ν}^{(2)} (z) = J_{ν} (z) - i Y_{ν} (z) . \end{array}$

$H_{ν}^{(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 ).

Extended Capabilities

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

This 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™.

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

bessely

Syntax

Description

Examples

Plot Bessel Functions of Second Kind

Calculate Exponentially Scaled Bessel Function

Input Arguments

nu — Equation order scalar | vector | matrix | multidimensional array

Z — Functional domain scalar | vector | matrix | multidimensional array

scale — Toggle to scale function 0 (default) | 1

More About

Bessel Functions

Tips

Extended Capabilities

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

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

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

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

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

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

Version History

See Also

`nu` — Equation order
scalar | vector | matrix | multidimensional array

`Z` — Functional domain
scalar | vector | matrix | multidimensional array

`scale` — Toggle to scale function
`0` (default) | `1`

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

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

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

Thread-Based Environment
Run code in the background using MATLAB® `backgroundPool` or accelerate code with Parallel Computing Toolbox™ `ThreadPool` .

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

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