« Mathématiques avec Python et Ruby/Analyse numérique en Ruby » : différence entre les versions

Un livre de Wikilivres.
Contenu supprimé Contenu ajouté
Aucun résumé des modifications
DannyS712 (discussion | contributions)
m <source> -> <syntaxhighlight> (phab:T237267)
 
Ligne 5 : Ligne 5 :
Les algorithmes ci-dessous seront appliqués à la fonction ''f'' : <math>x\mapsto x^2-5</math>. On va donc commencer par créer une ''méthode'' pour cela:
Les algorithmes ci-dessous seront appliqués à la fonction ''f'' : <math>x\mapsto x^2-5</math>. On va donc commencer par créer une ''méthode'' pour cela:


<source lang="ruby">
<syntaxhighlight lang="ruby">
def f(x)
def f(x)
return x**2-5
return x**2-5
end
end


</syntaxhighlight>
</source>


==Résolution numérique d'une équation==
==Résolution numérique d'une équation==
Ligne 16 : Ligne 16 :
Pour chercher à <math>10^{-14}</math> près un antécédent de 0 par ''f'', on peut utiliser la [[w:Méthode de dichotomie|méthode de dichotomie]]:
Pour chercher à <math>10^{-14}</math> près un antécédent de 0 par ''f'', on peut utiliser la [[w:Méthode de dichotomie|méthode de dichotomie]]:


<source lang="ruby">
<syntaxhighlight lang="ruby">
def zerof(a,b)
def zerof(a,b)
if f(a)*f(b)>0 then
if f(a)*f(b)>0 then
Ligne 35 : Ligne 35 :


puts(zerof(1,3))
puts(zerof(1,3))
</syntaxhighlight>
</source>


Le script affiche une solution parce que f(1) est négatif et f(3) positif. Sinon on aurait un message d'erreur.
Le script affiche une solution parce que f(1) est négatif et f(3) positif. Sinon on aurait un message d'erreur.
Ligne 43 : Ligne 43 :
On approche la tangente par une sécante. On utilise une méthode centrée:
On approche la tangente par une sécante. On utilise une méthode centrée:


<source lang="ruby">
<syntaxhighlight lang="ruby">
def NDerf(x)
def NDerf(x)
h=1e-10
h=1e-10
Ligne 50 : Ligne 50 :


puts(NDerf(2))
puts(NDerf(2))
</syntaxhighlight>
</source>


On voit que <math>f'(2)\simeq 4</math>
On voit que <math>f'(2)\simeq 4</math>
Ligne 58 : Ligne 58 :
La méthode des rectangles consiste à approcher <math>\int_a ^b f(t) \, dt</math> par la somme des aires des rectangles de largeur ''h'' et de hauteur ''f(a+nh)'' pour ''a+nh'' allant de ''a'' à ''b''. On choisit ''N'' assez grand (ici 1 000 000) pour que ''h'' soit petit et l'approximation bonne:
La méthode des rectangles consiste à approcher <math>\int_a ^b f(t) \, dt</math> par la somme des aires des rectangles de largeur ''h'' et de hauteur ''f(a+nh)'' pour ''a+nh'' allant de ''a'' à ''b''. On choisit ''N'' assez grand (ici 1 000 000) pour que ''h'' soit petit et l'approximation bonne:


<source lang="ruby">
<syntaxhighlight lang="ruby">
def Nintf(a,b)
def Nintf(a,b)
h=(b-a).to_f/1e6
h=(b-a).to_f/1e6
Ligne 64 : Ligne 64 :
end
end


puts(Nintf(0,2))</source>
puts(Nintf(0,2))</syntaxhighlight>

Version actuelle du 16 avril 2020 à 08:27

Fonction[modifier | modifier le wikicode]

Les algorithmes ci-dessous seront appliqués à la fonction f : . On va donc commencer par créer une méthode pour cela:

def f(x)
    return x**2-5
end

Résolution numérique d'une équation[modifier | modifier le wikicode]

Pour chercher à près un antécédent de 0 par f, on peut utiliser la méthode de dichotomie:

def zerof(a,b)
    if f(a)*f(b)>0 then
        puts('Pas de solution unique entre '+a.to_s+' et '+b.to_s+'.')
    else
        while ((a-b).abs>1e-14)
            m=(a+b)/2.0
            if f(m)*f(a)>0 then
                a=m
            else
                b=m
            end
        end
    end
    return m
end


puts(zerof(1,3))

Le script affiche une solution parce que f(1) est négatif et f(3) positif. Sinon on aurait un message d'erreur.

Calcul approché d'un nombre dérivé[modifier | modifier le wikicode]

On approche la tangente par une sécante. On utilise une méthode centrée:

def NDerf(x)
    h=1e-10
    return (f(x+h)-f(x-h))/(2*h)
end

puts(NDerf(2))

On voit que

Calcul approché d'une intégrale[modifier | modifier le wikicode]

La méthode des rectangles consiste à approcher par la somme des aires des rectangles de largeur h et de hauteur f(a+nh) pour a+nh allant de a à b. On choisit N assez grand (ici 1 000 000) pour que h soit petit et l'approximation bonne:

def Nintf(a,b)
    h=(b-a).to_f/1e6
    return (1..1000000).inject{|s,i| s+=h*f(a+h*i)}
end

puts(Nintf(0,2))