Funciones de Bessel en SymPy Symbolic Math Program

Introducción
Una gran cantidad de los problemas más diversos relacionados con casi todas las ramas más importantes de la física matemática y diseñados para responder preguntas técnicas tópicas están asociados con la aplicación de las funciones de Bessel.

Las funciones de Bessel se usan ampliamente para resolver problemas de acústica, radiofísica, hidrodinámica, problemas de física atómica y nuclear. Numerosas aplicaciones de las funciones de Bessel a la teoría de la conductividad térmica y la teoría de la elasticidad (problemas en las vibraciones de la placa, problemas de la teoría de la carcasa, problemas para determinar la concentración de tensión cerca de grietas).

Tal popularidad de las funciones de Bessel se explica por el hecho de que resolver ecuaciones de física matemática que contienen el operador de Laplace en coordenadas cilíndricas mediante el método clásico de separación de variables conduce a una ecuación diferencial ordinaria, que sirve para determinar estas funciones [1].

Las funciones de Bessel llevan el nombre del astrónomo alemán Friedrich Bessel, quien en 1824, al estudiar el movimiento de los planetas alrededor del sol, derivó las relaciones de recurrencia para las funciones de Bessel $$$J_ {v} (x)$ recibido por enteros $$$v$ representación integral de una función $$$J_ {v} (x)$ , demostró la existencia de innumerables ceros de función $$$J_ {0} (x)$ y compilé las primeras tablas para funciones $$$J_ {1} (x)$ y $$$J_ {2} (x)$ .

Sin embargo, por primera vez una de las funciones de Bessel $$$J_ {0} (x)$ Fue considerado en 1732 por Daniel Bernoulli en un trabajo dedicado a la oscilación de cadenas pesadas. D. Bernoulli encontró una expresión de función $$$J_ {0} (x)$ en forma de serie de potencia y notó (sin prueba) que la ecuación $$$J_ {0} (x) = 0$ tiene innumerables raíces válidas.

El siguiente trabajo, en el que se encuentran las funciones de Bessel, fue el trabajo de Leonardo Euler en 1738, dedicado al estudio de las vibraciones de una membrana circular. En este trabajo, L. Euler encontró enteros $$$v$ Expresión de la función de Bessel $$$J_ {v} (x)$ en forma de una serie de poderes $$$x$ , y en trabajos posteriores extendió esta expresión al caso de valores de índice arbitrarios $$$v$ . Además, L. Euler demostró que para $$$v$ igual a un entero y medio, funciones $$$J_ {v} (x)$ expresado a través de funciones elementales.

Señaló (sin evidencia) que con validez $$$v$ las funciones $$$J_ {v} (x)$ tienen innumerables ceros reales y dieron una representación integral para $$$J_ {v} (x)$ . Algunos investigadores creen que los principales resultados relacionados con las funciones de Bessel y sus aplicaciones en física matemática están relacionados con el nombre de L. Euler.

Estudiar la propiedad de las funciones de Bessel y al mismo tiempo dominar los métodos para resolver ecuaciones que se reducen a las funciones de Bessel, permite el programa distribuido libremente de SymPy de matemáticas simbólicas, la biblioteca de Python.

En el programa de matemática simbólica SymPy, se pueden construir gráficos de las funciones de Bessel del primer tipo de órdenes enteras utilizando la relación para la suma de una serie:

$$

$$J_ {p} (x) = \ sum_ {m = 0} ^ {\ infty} \ frac {x ^ {2m + p} (- 1) ^ {m}} {2 ^ {2m + p} m! \ Gamma (p + m + 1)}$$

Usando la relación para la suma de una serie, podemos probar la propiedad de estas funciones para órdenes enteras

$$

$$J_ {1} (x) = - J _ {- 1} (x):$$

Para demostrar las condiciones de Cauchy, construimos una función $$$J_ {1/3} (x)$ y su derivada $$$\ frac {dJ_ {1/3} (x)} {dx}:$ :




Sin embargo, para cálculos prácticos, se utiliza el maravilloso módulo mpmath, que permite resolver numéricamente no solo ecuaciones con funciones de Bessel del primer y segundo tipo, incluidas las modificadas de todos los órdenes admisibles, sino también construir gráficos con escala automática.

Además, el módulo mpmath no requiere herramientas especiales para compartir matemática simbólica y numérica. La historia de la creación de este módulo y la posibilidad de su uso para la transformación inversa de Laplace que ya he considerado en la publicación [2]. Ahora continuamos la discusión sobre mpmath para trabajar con las funciones de Bessel [3].

Función de Bessel del primer tipo $$$J_ {N} (x)$
mpmath.besselj (n, x, derivada = 0) : proporciona una función Bessel del primer tipo $$$Jn (x)$ . Las funciones $$$J_ {N} (x)$ es una solución a la siguiente ecuación diferencial:

$$

$$x ^ {2} {y} '' + x {y} '+ (x ^ {2} -n ^ {2}) y = 0$$

Para todo lo positivo $$$n$ se comporta como un seno o coseno, multiplicado por un coeficiente que disminuye lentamente con $$$x \ rightarrow \ pm \ infty$
Función de Bessel del primer tipo $$$J_ {N} (x)$ es un caso especial de función hipergeométrica $$${o} F_ {1}$ :

$$

$$J_ {n} (x) = \ frac {x ^ {n}} {2 ^ {n} \ Gamma (n + 1)} {o} F_ {1} (n + 1, \ frac {x ^ { 2}} {4})$$

La función de Bessel se puede diferenciar $$$m$ veces siempre que la derivada enésima no sea igual a cero:

$$

$$\ frac {d ^ {m}} {dx ^ {m}} J_ {n} (x)$$

Función de Bessel del primer tipo $$$J_ {N} (x)$ para órdenes enteras positivas n = 0,1,2,3 - la solución de la ecuación de Bessel:

 from mpmath import* j0 = lambda x: besselj(0,x) j1 = lambda x: besselj(1,x) j2 = lambda x: besselj(2,x) j3 = lambda x: besselj(3,x) plot([j0,j1,j2,j3],[0,14] 

Función de Bessel del primer tipo $$$J_ {N} (x)$ en el plano complejo:

 from sympy import* from mpmath import* cplot(lambda z: besselj(1,z), [-8,8], [-8,8], points=50000) 

Ejemplos:
Función $$$besselj (N, x)$ proporciona un resultado con un número dado de dígitos $$$(mp.dps)$ después de la coma:

 from mpmath import* mp.dps = 15; mp.pretty = True print(besselj(2, 1000)) nprint(besselj(4, 0.75)) nprint(besselj(2, 1000j)) mp.dps = 25 nprint( besselj(0.75j, 3+4j)) mp.dps = 50 nprint( besselj(1, pi)) 

Un argumento de función puede ser un gran número:

 from mpmath import* mp.dps = 25 nprint( besselj(0, 10000)) nprint(besselj(0, 10**10)) nprint(besselj(2, 10**100)) nprint( besselj(2, 10**5*j)) 

Las funciones de Bessel del primer tipo satisfacen simetrías simples con respecto a $$$x = 0$ :

 from sympy import* from mpmath import* mp.dps = 15 nprint([besselj(n,0) for n in range(5)]) nprint([besselj(n,pi) for n in range(5)]) nprint([besselj(n,-pi) for n in range(5)]) 

Las raíces no son periódicas, pero la distancia entre raíces sucesivas se aproxima asintóticamente $$$2π$ . Las funciones de Bessel del primer tipo tienen el siguiente código:

 from mpmath import* print(quadosc(j0, [0, inf], period=2*pi)) print(quadosc(j1, [0, inf], period=2*pi)) 

Para $$$n = 1/2$ o $$$n = −1 / 2$ La función de Bessel se reduce a una función trigonométrica:

 from sympy import* from mpmath import* x = 10 print(besselj(0.5, x)) print(sqrt(2/(pi*x))*sin(x)) print(besselj(-0.5, x)) print(sqrt(2/(pi*x))*cos(x)) 

Los derivados de cualquier orden se pueden calcular, las órdenes negativas corresponden a la integración :

 from mpmath import* mp.dps = 25 print(besselj(0, 7.5, 1)) print(diff(lambda x: besselj(0,x), 7.5)) print(besselj(0, 7.5, 10)) print(diff(lambda x: besselj(0,x), 7.5, 10)) print(besselj(0,7.5,-1) - besselj(0,3.5,-1)) print(quad(j0, [3.5, 7.5])) 

La diferenciación con el orden no entero da una derivada fraccional en el sentido de la integral diferencial de Riemann-Liouville, calculada utilizando la función $$$difint ()$ :

 from mpmath import* mp.dps = 15 print(besselj(1, 3.5, 0.75)) print(differint(lambda x: besselj(1, x), 3.5, 0.75)) 

Otras formas de llamar a la función Bessel del primer tipo de cero y primer orden
mpmath.j0 (x) - Calcula la función Bessel $$$J_ {0} (x)$ ;
mpmath.j1 (x) - Calcula la función Bessel $$$J_ {1} (x)$ ;

Funciones de Bessel del segundo tipo.
bessely (n, x, derivada = 0) Calcula la función Bessel de segundo tipo a partir de la relación:

$$

$$Y_ {n} (x) = \ frac {J_ {n} (x) cos (\ pi \ cdot n) -J _ {- n} (x)} {sin (\ pi \ cdot n)}$$

Para un entero $$$n$ La siguiente fórmula debe entenderse como el límite. La función de Bessel se puede diferenciar $$$m$ veces siempre que la derivada enésima no sea igual a cero:
$$$\ frac {d ^ {m}} {dx ^ {m}} Y_ {n} (x)$
Función de Bessel del segundo tipo. $$$Y_ {n} (x)$ para órdenes positivas enteras $$$n = 0,1,2,3$ .

 from sympy import* from mpmath import* y0 = lambda x: bessely(0,x) y1 = lambda x: bessely(1,x) y2 = lambda x: bessely(2,x) y3 = lambda x: bessely(3,x) plot([y0,y1,y2,y3],[0,10],[-4,1]) 

2ª función de Bessel amable $$$Y_ {n} (x)$ en el plano complejo

 from sympy import* from mpmath import* cplot(lambda z: bessely(1,z), [-8,8], [-8,8], points=50000) 

Ejemplos:
Algunos valores de funciones $$$Y_ {n} (x)$ :

 from sympy import* from mpmath import* mp.dps = 25; mp.pretty = True print(bessely(0,0)) print(bessely(1,0)) print(bessely(2,0)) print(bessely(1, pi)) print(bessely(0.5, 3+4j)) 

Los argumentos pueden ser grandes:

 from sympy import* from mpmath import* mp.dps = 25; mp.pretty = True print(bessely(0, 10000)) print(bessely(2.5, 10**50)) print(bessely(2.5, -10**50)) 

Los derivados de cualquier orden, incluidos los negativos, se pueden calcular:

 from sympy import* from mpmath import* mp.dps = 25; mp.pretty = True print(bessely(2, 3.5, 1)) print(diff(lambda x: bessely(2, x), 3.5)) print(bessely(0.5, 3.5, 1)) print(diff(lambda x: bessely(0.5, x), 3.5)) print(diff(lambda x: bessely(2, x), 0.5, 10)) print(bessely(2, 0.5, 10)) print(bessely(2, 100.5, 100)) print(quad(lambda x: bessely(2,x), [1,3])) print(bessely(2,3,-1) - bessely(2,1,-1)) 

Función de Bessel modificada del primer tipo

 mpmath.besseli(n, x, derivative=0) 

besseli (n, x, derivada = 0) modificó la función de Bessel del primer tipo

$$

$$I_ {n} (x) = \ mathit {i} ^ {- n} J_ {n} (ix)$$

$$

$$\ frac {d ^ {m}} {dx ^ {m}} I_ {n} (x)$$

Función modificada de Bessel $$$I_n (x)$ para pedidos reales $$$n = 0,1,2,3$ :

 from mpmath import* i0 = lambda x: besseli(0,x) i1 = lambda x: besseli(1,x) i2 = lambda x: besseli(2,x) i3 = lambda x: besseli(3,x) plot([i0,i1,i2,i3],[0,5],[0,5]) 

Función modificada de Bessel $$$I_ {n} (x)$ en el plano complejo

 from mpmath import* cplot(lambda z: besseli(1,z), [-8,8], [-8,8], points=50000) 

Ejemplos:
Algunos significados $$$I_ {n} (x)$

 from mpmath import* mp.dps = 25; mp.pretty = True print(besseli(0,0)) print(besseli(1,0)) print(besseli(0,1)) print(besseli(3.5, 2+3j)) 

Los argumentos pueden ser grandes:

 from mpmath import* mp.dps = 25; mp.pretty = True print(besseli(2, 1000)) print(besseli(2, 10**10)) print(besseli(2, 6000+10000j)) 

Para los enteros n, se cumple la siguiente representación integral:

 from mpmath import* mp.dps = 15; mp.pretty = True n = 3 x = 2.3 print(quad(lambda t: exp(x*cos(t))*cos(n*t), [0,pi])/pi) print(besseli(n,x)) 

Se pueden calcular derivados de cualquier orden:

 from mpmath import* mp.dps = 25; mp.pretty = True print(besseli(2, 7.5, 1)) print(diff(lambda x: besseli(2,x), 7.5)) print(besseli(2, 7.5, 10)) print(diff(lambda x: besseli(2,x), 7.5, 10)) print(besseli(2,7.5,-1) - besseli(2,3.5,-1)) print(quad(lambda x: besseli(2,x), [3.5, 7.5])) 

Funciones de Bessel modificadas del segundo tipo,

 mpmath.besselk(n, x) 

Besselk (n, x) funciones de Bessel de segundo tipo modificadas

$$

$$K_ {n} (x) = \ frac {\ pi} {4} \ frac {I _ {- n} (x) -I_ {n} (x)} {sin (\ pi \ cdot n)}$$

Para un entero $$$n$ Esta fórmula debe entenderse como un límite.
Función de Bessel modificada del segundo tipo $$$K_ {n} (x)$ para material $$$n = 0,1,2,3$ :

 from mpmath import* k0 = lambda x: besselk(0,x) k1 = lambda x: besselk(1,x) k2 = lambda x: besselk(2,x) k3 = lambda x: besselk(3,x) plot([k0,k1,k2,k3],[0,8],[0,5]) 

Función de Bessel modificada del segundo tipo $$$K_ {n} (x))$ en el plano complejo

 from mpmath import* cplot(lambda z: besselk(1,z), [-8,8], [-8,8], points=50000) 

Ejemplos:
Argumentos complicados y complejos:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselk(0,1)) print(besselk(0, -1)) print(besselk(3.5, 2+3j)) print(besselk(2+3j, 0.5)) 

Los argumentos son grandes números

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselk(0, 100)) print(besselk(1, 10**6)) print(besselk(1, 10**6*j)) print(besselk(4.5, fmul(10**50, j, exact=True))) 

Características del comportamiento de una función en un punto. $$$x = 0$ :

 from mpmath import * print(besselk(0,0)) print(besselk(1,0)) for n in range(-4, 5): print(besselk(n, '1e-1000')) 

Función Bessel Ceros

 besseljzero() mpmath.besseljzero(v, m, derivative=0) 

Por orden real $$$\ mathit {\ nu} \ geq 0$ y un entero positivo $$$m$ vuelve $$$j _ {\ nu, m}$ , el enésimo cero positivo de la función de Bessel del primer tipo $$$J _ {\ nu} (z)$ (ver besselj () ). Alternativamente, con $$$derivada = 1$ da el primer cero primo no negativo $$${j} '_ {\ nu, m}$ de $$${J} '_ {\ nu} (z)$ . Designaciones de acuerdos de indexación con Abramowitz & Stegun y DLMF. Presta atención a un caso especial. $$${j} '_ {0,1} = 0$ mientras que todos los otros ceros son positivos.

En realidad, solo se calculan los ceros simples (todos los ceros de las funciones de Bessel son simples, excepto cuando $$$z = 0$ ) y $$$j _ {\ nu, m}$ se convierte en una función monotónica de $$$\ nu$ y $$$m$ . Los ceros se alternan según las desigualdades:

$$

$${j} '_ {\ nu, k} <j _ {\ nu, k} <{j}' _ {\ nu, k + 1}$$

$$

$$j _ {\ nu, 1} <j _ {\ nu + 1,2} <j _ {\ nu, 2} <j _ {\ nu + 1,2} <j _ {\ nu, 3} \ cdots$$

Ejemplos:
Ceros a la izquierda de las funciones de Bessel $$$J_ {0} (z)$ , $$$J_ {1} (z)$ , $$$J_ {2} (z)$

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(0,1)) print(besseljzero(0,2)) print(besseljzero(0,3)) print(besseljzero(1,1)) print(besseljzero(1,2)) print(besseljzero(1,3)) print(besseljzero(2,1)) print(besseljzero(2,2)) print(besseljzero(2,3)) 

Ceros a la izquierda de derivados de funciones de Bessel $$${J} '_ {0} (z)$ , $$${J} '_ {1} (z)$ , $$${J} '_ {2} (z)$

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(0,1,1)) print(besseljzero(0,2,1)) print(besseljzero(0,3,1)) print(besseljzero(1,1,1)) print(besseljzero(1,2,1)) print(besseljzero(1,3,1)) print(besseljzero(2,1,1)) print(besseljzero(2,2,1)) print(besseljzero(2,3,1)) 

Ceros con un índice grande:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(0,100)) print(besseljzero(0,1000)) print(besseljzero(0,10000)) print(besseljzero(5,100)) print(besseljzero(5,1000)) print(besseljzero(5,10000)) print(besseljzero(0,100,1)) print(besseljzero(0,1000,1)) print(besseljzero(0,10000,1)) 

Ceros de funciones con un orden grande:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(50,1)) print(besseljzero(50,2)) print(besseljzero(50,100)) print(besseljzero(50,1,1)) print(besseljzero(50,2,1)) print(besseljzero(50,100,1)) 

Ceros de funciones con orden fraccional:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(0.5,1)) print(besseljzero(1.5,1)) print(besseljzero(2.25,4)) 

Y $$$J _ {\ nu} (z)$ . y $$${J} '_ {\ nu} (z)$ se pueden expresar como productos infinitos en sus ceros:

 from mpmath import * mp.dps = 6; mp.pretty = True v,z = 2, mpf(1) nprint((z/2)**v/gamma(v+1) * \ nprod(lambda k: 1-(z/besseljzero(v,k))**2, [1,inf])) print(besselj(v,z)) nprint((z/2)**(v-1)/2/gamma(v) * \ nprod(lambda k: 1-(z/besseljzero(v,k,1))**2, [1,inf])) print(besselj(v,z,1)) 

 besselyzero() mpmath.besselyzero(v, m, derivative=0) 

Por orden real $$$\ mathit {\ nu} \ geq 0$ y un entero positivo $$$m$ vuelve $$$y _ {\ nu, m}$ , $$$m$ , mth positivo cero del segundo tipo de función de Bessel $$$Y _ {\ nu} (z)$ (Ver Bessely () ). Alternativamente, con $$$derivada = 1$ da el primer cero positivo $$${y} '_ {\ nu, m}$ de $$${Y} '_ {\ nu} (z)$ . Los ceros se alternan según las desigualdades:

$$

$$y _ {\ nu, k} <{y} '_ {\ nu, k} <y _ {\ nu, k + 1}$$

$$

$$y _ {\ nu, 1} <y _ {\ nu + 1,2} <y _ {\ nu, 2} <y _ {\ nu + 1,2} <y _ {\ nu, 3} \ cdots$$

Ejemplos:
Ceros a la izquierda de las funciones de Bessel $$$Y_ {0} (z)$ , $$$Y_ {1} (z)$ , $$$Y_ {2} (z)$

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(0,1)) print(besselyzero(0,2)) print(besselyzero(0,3)) print(besselyzero(1,1)) print(besselyzero(1,2)) print(besselyzero(1,3)) print(besselyzero(2,1)) print(besselyzero(2,2)) print(besselyzero(2,3)) 

Ceros a la izquierda de derivados de funciones de Bessel $$${Y} '_ {0} (z)$ , $$${Y} '_ {1} (z)$ , $$${Y} '_ {2} (z)$

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(0,1,1)) print(besselyzero(0,2,1)) print(besselyzero(0,3,1)) print(besselyzero(1,1,1)) print(besselyzero(1,2,1)) print(besselyzero(1,3,1)) print(besselyzero(2,1,1)) print(besselyzero(2,2,1)) print(besselyzero(2,3,1)) 

Ceros con un índice grande:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(0,100)) print(besselyzero(0,1000)) print(besselyzero(0,10000)) print(besselyzero(5,100)) print(besselyzero(5,1000)) print(besselyzero(5,10000)) print(besselyzero(0,100,1)) print(besselyzero(0,1000,1)) print(besselyzero(0,10000,1)) 

Ceros de funciones con un orden grande:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(50,1)) print(besselyzero(50,2)) print(besselyzero(50,100)) print(besselyzero(50,1,1)) print(besselyzero(50,2,1)) print(besselyzero(50,100,1)) 

Ceros de funciones con orden fraccional:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(0.5,1)) print(besselyzero(1.5,1)) print(besselyzero(2.25,4)) 

Aplicaciones de la función Bessel
La importancia de las funciones de Bessel se debe no solo a la aparición frecuente de la ecuación de Bessel en las aplicaciones, sino también al hecho de que las soluciones de muchas otras ecuaciones diferenciales lineales de segundo orden se pueden expresar en términos de funciones de Bessel. Para ver cómo aparecen, comenzamos con la ecuación de orden de Bessel $$$p$ en forma de:

$$

$$z ^ {2} \ frac {d ^ {2} w} {dz ^ {2}} + z \ frac {dw} {dz} + (z ^ {2} -p ^ {2}) w = 0 , (1)$$

y sustituir aquí

$$

$$w = x ^ {- \ alpha}, z = kx ^ {\ beta}, (2)$$

Luego, usando (2) e introduciendo las constantes $$$A, B, C$ de la ecuación (1), obtenemos:

$$

$$x ^ {2} {y} '' + Hacha {y} '+ (B + Cx ^ {q}) y = 0, (3)$$

$$

$$A = 1-2 \ alpha, B = \ alpha ^ {2} - \ beta ^ {2} p ^ {2}, C = \ beta ^ {2} k ^ {2}, q = 2 \ beta, (4)$$

De la ecuación (4) obtenemos:

$$

$$\ left \ {\ begin {matrix} \ alpha = \ frac {1-A} {2}, \\ \ beta = \ frac {q} {2}, \\ k = \ frac {2 \ sqrt {C }} {q} \\ p = \ frac {\ sqrt {(1-A ^ {2} -4B}} {q} \\ \ end {matrix} \ right. (5)$$

Si $$$C> 0$ , $$$q \ neq 0$ , $$$(1-A) ^ {2} \ geqslant 4B$ , entonces la solución general (para $$$x> 0$ ) de la ecuación (3) tiene la forma:

$$

$$y (x) = x ^ {\ alpha} \ left [c_ {1} J_ {p} (kx ^ {\ beta}) + c_ {2} J _ {- p} (kx ^ {\ beta}) \ derecha] (6)$$

donde: $$$\ alpha$ , $$$\ beta$ , $$$k$ se determinan a partir del sistema (5). Si $$$p$ Es un entero entonces $$$J_ {p}$ necesita ser reemplazado por $$$Y_ {p}$ .

Doblado longitudinal de la columna vertical
Ahora consideraremos una tarea que es importante para aplicaciones prácticas. En esta tarea, se requiere determinar cuándo una columna vertical uniforme se dobla bajo su propio peso. Suponemos $$$x = 0$ en el extremo superior libre de la columna y $$$x = L> 0$ en su base; Suponemos que la base está rígidamente insertada (es decir, fija inmóvil) en la base (en el suelo), posiblemente en el hormigón.

Denota la desviación angular de la columna en el punto $$$x$ a través de $$$\ theta (x)$ . De la teoría de la elasticidad bajo estas condiciones se deduce que:

$$

$$EI \ frac {d ^ {2} \ theta} {dx ^ {2}} + g \ rho x \ theta = 0, (7)$$

donde $$$E$ - Módulo de Young del material de la columna, $$$I$ - momento de inercia de su sección transversal, $$$\ rho$ - densidad lineal de la columna y $$$g$ - aceleración gravitacional. Las condiciones de contorno son de la forma:

$$

$${\ theta} '(0) = 0, \ theta (L) = 0, (8)$$

Resolveremos el problema usando (7) y (8) con:

$$

$$\ lambda = \ gamma ^ {2} = \ frac {g \ rho} {EI} (9)$$

Reescribimos (7) teniendo en cuenta (9) bajo la condición (8):

$$

$$\ frac {d ^ {2} \ theta} {dx ^ {2}} + \ gamma ^ {2} x \ theta = 0; \ frac {d \ theta} {dx} = 0, \ theta (L) = 0. (10)$$

Una columna puede deformarse solo si hay una solución no trivial al problema (10); de lo contrario, la columna permanecerá en una posición no desviada de la vertical (es decir, físicamente incapaz de desviarse de la vertical).
La ecuación diferencial (10) es una ecuación de Airy. La ecuación (10) tiene la forma de la ecuación (3) para $$$A = B = 0$ , $$$C = \ gamma ^ {2}$ , $$$q = 3$ . Del sistema de ecuaciones (5) obtenemos $$$\ alpha = \ frac {1} {2}$ , $$$\ beta = \ frac {3} {2}$ , $$$k = \ frac {2} {3} \ gamma$ , $$$p = \ frac {1} {3}$ .
Por lo tanto, la solución general tiene la forma:

$$

$$\ theta (x) = x ^ {1/2} \ left [c_ {1} J_ {1/3} (\ frac {2} {3} \ gamma x ^ {3/2}) + c_ {2 } J _ {- 1/3} (\ frac {2} {3} \ gamma x ^ {3/2}) \ right]. (11)$$

Para aplicar las condiciones iniciales, sustituimos $$$p = \ pm \ frac {1} {3}$ en

$$

$$J_ {p} = \ sum_ {m = 0} ^ {\ infty} \ frac {(- 1) ^ {m}} {m! \ Gamma (p + m + 1)} \ left (\ frac {x } {2} \ right) ^ {2m + p} (12)$$

Después de la transformación (12), teniendo en cuenta la solución (11), obtenemos:

$$

$$\ theta (x) = \ frac {c_ {1} \ gamma ^ {1/3}} {3 ^ {1/3} \ Gamma (4/3)} \ left (x- \ frac {\ gamma ^ {2} x ^ {4}} {12} + \ frac {\ gamma ^ {4} x ^ {7}} {504} - \ cdot \ cdot \ cdot \ right) + \\ + \ frac {c_ { 2} 3 ^ {1/3}} {\ gamma ^ {1/3} \ Gamma (\ frac {2} {3})} \ left (1- \ frac {\ gamma ^ {2} x ^ {3 }} {6} + \ frac {\ gamma ^ {4} x ^ {6}} {180} - \ cdot \ cdot \ cdot \ right). (13)$$

Proporcionado en el punto de partida $$${\ theta} '(0) = 0$ tenemos $$$c_ {1} = 0$ , entonces (11) toma la forma:

$$

$$\ theta (x) = c_ {2} x ^ {1/2} J _ {- 1/3} (\ frac {2} {3} \ gamma x ^ {3/2}), (14)$$

Proporcionado en el punto final $$$\ theta (L) = 0$ , de (14) obtenemos:

$$

$$J _ {- 1/3} (\ frac {2} {3} \ gamma L ^ {3/2}) = 0 (15)$$

Cabe señalar que las transformaciones (13), (14) no podrían hacerse si se construyeran las gráficas de funciones $$$J_ {1/3} (x), J _ {- 1/3} (x)$ utilizando las capacidades consideradas del módulo mpmath:

 from mpmath import* mp.dps = 6; mp.pretty = True f=lambda x: besselj(-1/3,x) f1=lambda x: besselj(1/3,x) plot([f,f1], [0, 15]) 

Del gráfico se deduce que para x = 0 la función $$$J_ {1/3} (0) = 0$ y teniendo en cuenta la solución (11), obtenemos inmediatamente la ecuación necesaria (15), solo queda encontrar z, como se mostrará a continuación.

Por lo tanto, la columna se deforma solo si $$$z = \ frac {2} {3} \ gamma L ^ {3/2}$ Es la raíz de la ecuación $$$J _ {- 1/3} (z) = 0$ . Construye una función $$$J _ {- 1/3} (z)$ en una tabla separada:

 from mpmath import* mp.dps = 6; mp.pretty = True f=lambda x: besselj(-1/3,x) plot(f, [0, 15]) 

El gráfico muestra que la primera raíz es ligeramente menor que 2. Encuentra la raíz $$$z0$ de la ecuación $$$J _ {- 1/3} (z) = 0$ Puede, utilizando la función findroot (f, z0) , aceptar, de acuerdo con el gráfico, el punto de búsqueda $$$x0 = 1$ y seis decimales mp.dps = 6 :

 from mpmath import* mp.dps = 6; mp.pretty = True f=lambda x: besselj(-1/3,x) print("z0=%s"%findroot(f, 1) 

Obtenemos:
$$$z0 = 1.86635$
Calculamos la longitud crítica, por ejemplo, un asta de bandera, usando la fórmula (15):

Obtenemos:
8,47 m
10,25 m

Un asta hueca puede ser más alta que una sólida.

Propagación de ondas en una membrana delgada.

Una membrana delgada cuando las ondas de sonido golpean no solo oscila con la frecuencia de las ondas. La forma de las vibraciones de membrana se puede obtener en las funciones de Bessel de acuerdo con el siguiente listado, utilizando las fórmulas besselj () y besseljzero () :

Alternativa al módulo mpmath en funciones especiales de Bessel de la biblioteca SciPy

Sin profundizar en una discusión detallada de las funciones de Bessel de la biblioteca SciPy [4], daré solo dos listados para trazar funciones del primer y segundo tipo jv (v, x) , yv (v, x) :

Conclusiones:

El artículo describe los conceptos básicos de trabajar con las funciones de Bessel usando las bibliotecas mpmath, sympy y scipy, y proporciona ejemplos del uso de funciones para resolver ecuaciones diferenciales. El artículo puede ser útil para estudiar las ecuaciones de la física matemática.

Referencias

1. Funciones de Bessel
2. Usando la transformada inversa de Laplace para analizar los enlaces dinámicos de los sistemas de control
3. Funciones relacionadas con la función de Bessel
4. Funciones especiales (scipy.special).