Application Center - Maplesoft
  Submit your work
Application Center Applications Approximation von BESSEL-Funktionen durch FOURIER-Reihen Preview

App Preview:

Approximation von BESSEL-Funktionen durch FOURIER-Reihen

You can switch back to the summary page by clicking here.

Learn about Maple
Download Application



 

   Juni /Juli 2015

                                       

                                      

            Approximation von BESSEL-Funktionen durch FOURIER-Reihen

 

                                        Univ.-Prof. Dr.-Ing. habil. Josef  BETTEN

                                                  RWTH Aachen University

                      Mathematical Models in Materials Science and Continuum Mechanics

                                                       Augustinerbach 4-20

                                                   D-52056  A a c h e n ,  Germany

                                                    

                                                  <betten@mmw.ewth-aachen.de>

 

 

Mit Hilfe der Maplesoftware können Bessel-Funktionen bequem dargestellt werden. So sind Bessel-Funktionen erster Art für gerade und ungerade  Ordnung n folgendermaßen definiert.

 

> 

restart:

> 

J[2*n](x):=(1/Pi)*Int(cos(x*sin(t))*cos(2*n*t),t=0..Pi)=           BesselJ(2*n,x);   #  n = 0,1,2,...

J[2*n](x) := (1/Pi)*(Int(cos(x*sin(t))*cos(2*n*t), t = 0 .. Pi)) = BesselJ(2*n, x)

(1)
> 

J[2*n+1](x):=(1/Pi)*Int(sin(x+sin(t))*sin((2*n+1)*t),t=0..Pi)=     BesselJ(2*n+1,x);   #  n = 0,1,2,...

J[2*n+1](x) := (1/Pi)*(Int(sin(x+sin(t))*sin((2*n+1)*t), t = 0 .. Pi)) = BesselJ(2*n+1, x)

(2)

 

FOURIER-Reihen sind für den hier betrachteten Bereich  [0..8*Pi]  folgendermaßen definiert.

 

> 

FOURIER_series(x):=         a[0]/2+sum(a[k]*cos(k*x)+b[k]*sin(k*x),k=1..infinity);

FOURIER_series(x) := (1/2)*a[0]+sum(a[k]*cos(k*x)+b[k]*sin(k*x), k = 1 .. infinity)

(3)
> 

a[k]:=(1/4/Pi)*Int(f(x)*cos(k*x),x=0..8*Pi);

a[k] := (1/4)*((1/Pi)*(Int(f(x)*cos(k*x), x = 0 .. 8*Pi)))

(4)
> 

a[0]:=simplify(subs(k=0,%));

a[0] := (1/4)*((1/Pi)*(Int(f(x), x = 0 .. 8*Pi)))

(5)
> 

b[k]:=(1/4/Pi)*Int(f(x)*sin(k*x),x=0..8*Pi);

b[k] := (1/4)*((1/Pi)*(Int(f(x)*sin(k*x), x = 0 .. 8*Pi)))

(6)
> 

# BESSEL-Funktion erster Art der Ordnung eins als Beispiel

> 

J[1](x):=BesselJ(1,x);

J[1](x) := BesselJ(1, x)

(7)
> 

F(x):=J[1](x);

F(x) := BesselJ(1, x)

(8)
> 

A[0]:=simplify(value(subs(f(x)=F(x),a[0])));

A[0] := -(1/4)*((-1+BesselJ(0, 8*Pi))/Pi)

(9)
> 

A[0]:=evalf(%);

A[0] := 0.7066735435e-1

(10)
> 

A[k]:=simplify(value(subs(f(x)=F(x),a[k])));

A[k] := (1/4)*((1/Pi)*(int(BesselJ(1, x)*cos(k*x), x = 0 .. 8*Pi)))

(11)
> 

for i in [seq(i,i=1..5)] do A[i]:=evalf(subs(k=i,A[k])) od;

A[1] := -.1510964948

A[2] := -0.9191654848e-2

A[3] := -0.3664864065e-2

A[4] := -0.1991032421e-2

A[5] := -0.1254535417e-2

(12)
> 

B[k]:=simplify(value(subs(f(x)=F(x),b[k])));

B[k] := (1/4)*((1/Pi)*(int(BesselJ(1, x)*sin(k*x), x = 0 .. 8*Pi)))

(13)
> 

for i in [seq(i,i=1..5)] do B[i]:=evalf(subs(k=i,B[k])) od;

B[1] := .2239356690

B[2] := 0.5795181175e-2

B[3] := 0.3290765808e-2

B[4] := 0.2346148014e-2

B[5] := 0.1834939160e-2

(14)
> 

Y(x):=A[0]/2+evalf(sum(A[k]*cos(k*x)+B[k]*sin(k*x),k=1..5));

Y(x) := 0.3533367718e-1-.1510964948*cos(x)+.2239356694*sin(x)-0.9191654848e-2*cos(2.*x)+0.5795181175e-2*sin(2.*x)-0.3664864065e-2*cos(3.*x)+0.3290765808e-2*sin(3.*x)-0.1991032421e-2*cos(4.*x)+0.2346148014e-2*sin(4.*x)-0.1254535417e-2*cos(5.*x)+0.1834939160e-2*sin(5.*x)

(15)
> 

# graphische Darstellung der BESSEL-Funktion und ihre FOURIER-Approximation:

> 

alias(th=thickness,co=color):

> 

p[1]:=plot(J[1](x),x=0..8*Pi,th=3,co=black,axes=boxed):

> 

p[2]:=plot(Y(x),x=0..8*Pi,th=2,co=black,                      title="BesselJ(1,x) und Fourier-Reihe k = 5"):

> 

p[3]:=plot(0,x=0..8*Pi,linestyle=4,co=black):

> 

plots[display](seq(p[k],k=1..3));

> 

# L-zwei Fehlernorm:

> 

L[2]:=sqrt((1/8/Pi)*Int((F(xi)-y(xi))^2,xi=0..8*Pi));

L[2] := (1/4)*(2^(1/2)*((1/Pi)*(Int((F(xi)-y(xi))^2, xi = 0 .. 8*Pi)))^(1/2))

(16)
> 

L[2][k=5]:=evalf(sqrt((1/8/Pi)*int((F(x)-Y(x))^2,x=0..8*Pi)));

L[2][k = 5] := .1076294900

(17)
> 

# Glättung (smoothing):

> 

g(k,N):=N*sin(Pi*k/N)/Pi/k;   #  smoothing factor

g(k, N) := N*sin(Pi*k/N)/(Pi*k)

(18)
> 

G(x,n,N):=Alpha[0]/2+sum(g(kappa,Nu)*(A[kappa]*cos(kappa*x)+ B[kappa]*sin(kappa*x)),kappa=1..n);   #  smoothing function

G(x, n, N) := (1/2)*Alpha[0]+sum(g(kappa, Nu)*(A[kappa]*cos(kappa*x)+B[kappa]*sin(kappa*x)), kappa = 1 .. n)

(19)
> 

#  Als Beispiel werde die Reihe Y(x) mit n = 5 und N = n + 1 gewählt:

> 

g(k,6):=subs(N=6,g(k,N));

g(k, 6) := 6*sin(Pi*k/6)/(Pi*k)

(20)
> 

G(x,n=5,N=6):=evalf(subs({Alpha[0]=A[0],n=5,Nu=6,kappa=k, g(kappa,Nu)=g(k,6),A[kappa]=A[k],B[kappa]=B[k]},G(x,n,N)));

G(x, n = 5, N = 6) := 0.3533367718e-1-.1442865242*cos(x)+.2138428121*sin(x)-0.7601437376e-2*cos(2.*x)+0.4792576256e-2*sin(2.*x)-0.2333124927e-2*cos(3.*x)+0.2094966580e-2*sin(3.*x)-0.8232852792e-3*cos(4.*x)+0.9701243948e-3*sin(4.*x)-0.2395986156e-3*cos(5.*x)+0.3504475653e-3*sin(5.*x)

(21)
> 

alias(th=thickness,co=color):

> 

p[1]:=plot(J[1](x),x=0..8*Pi,th=3,co=black,axes=boxed):

> 

p[2]:=plot(G(x,n=5,N=6),x=0..8*Pi,th=2,co=black,                   title="BESSELJ(1,x) # G(x,n=5,N=6), smoothing"):

> 

p[3]:=plot(0,x=0..8*Pi,linestyle=4,co=black):

> 

plots[display](seq(p[k],k=1..3));

> 

# L-zwei Fehlernorm:

> 

L[2][n=5,N=6]:=evalf(sqrt((1/8/Pi)*int((F(x)-G(x,n=5,N=6))^2,x=0..8*Pi)));

L[2][n = 5, N = 6] := .1080038982

(22)
> 

# L-zwei Fehlernorm zwischen Y(x) und seiner Glättung G(x,n=5,N=5):

> 

L[2][Y,G]:=evalf(sqrt((1/8/Pi)*int((Y(x)-G(x,n=5,N=6))^2,x=0..8*Pi)));

L[2][Y, G] := 0.8985260920e-2

(23)
> 

#  Dieses Ergebnis zeigt, dass sich Y nur geringfügig von ihrer Glättung G unterscheidet, so dass eine Glättung überflüssig ist. Somit stimmen auch L[2][k=5] und L[2][n=5,N=6] nahezu überein.  

 

> 

#  Neben der oben betrachteten BESSEL-Funktion J(1,x) sind weitere BESSEL-Funtionen erster Art der Ordnung n bekannt:

> 

J(n,x):=BesselJ(n,x);

J(n, x) := BesselJ(n, x)

(24)
> 

for i in [0,1,2] do J(i,x):=subs(n=i,J(n,x)) od;

> 

 

J(0, x) := BesselJ(0, x)

J(1, x) := BesselJ(1, x)

J(2, x) := BesselJ(2, x)

(25)
> 

alias(th=thickness,co=color):

> 

p[0]:=plot(J(0,x),x=0..8*Pi,th=1,co=black,axes=boxed):

> 

p[1]:=plot(J(1,x),x=0..8*Pi,th=2,co=black):

> 

p[2]:=plot(J(2,x),x=0..8*Pi,th=3,co=black):

> 

p[3]:=plot(0,x=0..8*Pi,linestyle=4,co=black):

> 

p[4]:=plots[textplot]({[12.5,0.85,`BESSEL-Funktionen erster Art`],[2,0.7,`J[0]`],[3.5,0.6,`J[1]`],[4.5,0.5,`J[2]`]}):

> 

plots[display](seq(p[k],k=0..4));

 

> 

# entsprechend findet man weitere BESSEL-Funktionen erster Art:

> 

for i in [3,5,8] do J[i](x):=subs(n=i,BesselJ(n,x)) od;

J[3](x) := BesselJ(3, x)

J[5](x) := BesselJ(5, x)

J[8](x) := BesselJ(8, x)

(26)
> 

alias(th=thickness,co=color):

> 

p[1]:=plot(J[3](x),x=0..8*Pi,th=1,axes=boxed,th=3,co=black):

> 

p[2]:=plot(J[5](x),x=0..8*Pi,-0.4..0.8,th=2,co=black):

> 

p[3]:=plot(J[8](x),x=0..8*Pi,th=3,co=black):

> 

p[4]:=plot(0,x=0..8*Pi,linestyle=4,th=2,co=black):

> 

p[5]:=plots[textplot]({[12.5,0.65,`BESSEL-Funktionen erster Art`],[4.5,0.48,`J[3]`],[7,0.42,`J[5]`],[10,0.37,`J[8]`]}):

> 

plots[display](seq(p[k],k=1..5));

> 

J[32](x):=BesselJ(32,x);

J[32](x) := BesselJ(32, x)

(27)
> 

alias(th=thickness,co=color):

> 

p[1]:=plot(J[32](x),x=0..8*Pi,axes=boxed,th=4,co=black):

> 

p[2]:=plot(0,x=0..8*Pi,linestyle=4,th=3,co=black,title="BesselJ(32,x)"):

> 

plots[display](seq(p[k],k=1..2));

> 

 

> 

#  Die Ableitungen der Bessel-Funktionen ergeben sich zu:

> 

`J'`(n,x):=Diff(J(n,x),x)=diff(J(n,x),x);

> 

 

`J'`(n, x) := Diff(BesselJ(n, x), x) = -BesselJ(n+1, x)+n*BesselJ(n, x)/x

(28)
> 

for i in [0,1,2,3] do `J'`(i,x):=subs(n=i,-J(n+1,x)+n*J(n,x)/x) od;

`J'`(0, x) := -J(1, x)

`J'`(1, x) := -J(2, x)+BesselJ(1, x)/x

`J'`(2, x) := -J(3, x)+2*BesselJ(2, x)/x

`J'`(3, x) := -J(4, x)+3*BesselJ(3, x)/x

(29)

 

> 

alias(th=thickness,co=color):

> 

p[3]:=plot({seq((-BesselJ(n+1,x)+n*BesselJ(n,x)/x),n=0..3)}, x=0..8*Pi,axes=boxed,th=3,co=black):

> 

p[4]:=plot(0,x=0..8*Pi,linestyle=4,th=2,co=black,              title="Ableitungen J'(n,x) für n = [0,1,2,3]"):

> 

plots[display](seq(p[k],k=3..4));

 

Andere BESSEL-Funktionen erster Art lassen sich ebenso nach obigem Muster durch FOURIER-Reihen approximieren. Das gilt auch für BESSEL-Funktionen zweiter Art oder für FRENELsche Integrale, die beispielsweise bei Problemen der Wellenausbreitung auftreten.

>