Répondre

Mazer666 · 06-01-2023 19:56:58

Il existe de nombreuses manières de trouver les racines de la fonction de Bessel, mais une façon simple d'aborder le problème consiste à utiliser l'algorithme de Newton. Voici comment cela fonctionne:

Choisissez une valeur de départ pour la racine que vous voulez trouver (par exemple, x0 = 1).

Utilisez la formule de Bessel pour calculer la valeur de la fonction de Bessel en x0 (appelons cela f(x0)).

Utilisez la dérivée de la formule de Bessel pour calculer la dérivée de la fonction de Bessel en x0 (appelons cela f'(x0)).

Calculez la nouvelle approximation de la racine en utilisant la formule suivante: x1 = x0 - f(x0) / f'(x0)

Répétez les étapes 2 à 4 jusqu'à ce que la précision souhaitée soit atteinte.

Voici comment cela pourrait être implémenté en Python:

from math import *

def jn(n, x):
# calcul de la fonction de Bessel en x
return sum((-1)**p / factorial(p) / factorial(n + p) * (x/2)**(2*p + n) for p in range(100))

def jn_deriv(n, x):
# calcul de la dérivée de la fonction de Bessel en x
return sum((-1)**p / factorial(p) / factorial(n + p) * (2*p + n) * (x/2)**(2*p + n - 1) for p in range(100))

def find_root(n, x0, precision):
# trouve une racine de la fonction de Bessel avec l'algorithme de Newton
x1 = x0 - jn(n, x0) / jn_deriv(n, x0)
while abs(x1 - x0) > precision:
x0, x1 = x1, x1 - jn(n, x1) / jn_deriv(n, x1)
return x1

root = find_root(0, 1, 1e-9) # trouve une racine de la fonction de Bessel J0
print(root)

Thomas20 · 12-03-2022 18:17:23

Bonjour,
Je voudrais trouver les racines nième de la fonction zéro de Bessel. pour cela je voudrai écrire un programme en matlab ou python mais sauf que je suis débutant dans ces deux langages.
Si quelqu'un a déjà fait ça ou pourrait m'aider.
Merci

J_n (x)=∑_(p=0)^∞▒〖〖(-1)〗^p/p!(n+p)!(〖x/2)〗^(2p+n) 〗

j'ai trouvé ça mais il ne marche que pour les 13 premieres racines et moi et jeux aller plus loin.
#Fonction de Bessel Calcul des racines
from math import *
def jnx(n,x):
j=(x/2)**n/factorial(n) #premier terme p=0 ; note : ** pour puissance
u,xcarré=j,(x/2)**2
umémorisé,stop=j,0
for p in range(1,pmax):
u*=-xcarré/(p*(p+n))
j+=u
return j
def signe(v):
if v>=0:
return 1
else:
return -1
def trouverracine(x1,x2,j1,j2):
while abs(x2-x1)>10**(-9): #limite de précision
x=(x1+x2)/2 #approche par dichotomie
j=jnx(n,x)
if signe(j)==signe(j1):
x1,j1=x,j
else:
x2,j2=x,j
return x

pmax=31 #limite de p dans la formule de Bessel
#Note valeur de pmax pour obtenir 4 chiffres significatifs quand n=5
#mais calcul et régulation d'erreur non fait, devrait faire partie du programme....
max=30 #limite de x dans l'encadrement des racines
n=0 #valeur de n dans la formule de Bessel
while n<6: # n de la foction de Bessel
print("n =",n,"****************")
x1,j1=1,jnx(n,1) #racines encadrées entre x1 et x2
x2,j2=2,jnx(n,2)
nombreracines=1
while nombreracines<6: #recherhe de l'encadrement d'une racine
while signe(j1)==signe(j2):
x1,j1=x2,j2
x2+=1
j2=jnx(n,x2)
print(format(trouverracine(x1,x2,j1,j2),".4f"))
nombreracines+=1
x1,j1=x2,j2 #itération pour les 5 premières racines
if x1>max: # Si les 5 premières racines n'étaient pas trouvées...
break
n+=1
# Fin du programme qui imprime en moins d'une seconde.

Forum de mathématiques - Bibm@th.net

Répondre

Résumé de la discussion (messages les plus récents en premier)

Pied de page des forums