Python - mise en Œuvre d'une équation numérique solveur (Newton-Raphson)

Je vous avertis, ce qui pourrait être source de confusion, et le code que j'ai écrit plus d'une mindmap de code terminé..

Je suis en train de mettre en œuvre le Newton-Raphson la méthode pour résoudre les équations.
Ce que je n'arrive pas à comprendre est comment écrire ce

Python - mise en Œuvre d'une équation numérique solveur (Newton-Raphson)

équation en Python, pour calculer le prochain rapprochement (xn+1) à partir de la dernière approximation de (xn). J'ai utiliser une boucle, de se rapprocher et plus proche de la vraie réponse, et la boucle doit se terminer lorsque le changement entre les approximations est inférieure à la variable h.

  1. Comment puis-je écrire le code de l'équation?
  2. Comment puis-je mettre fin à la boucle quand les approximations ne sont pas de changer plus?

    Calcule la dérivée de l'équation de f au point x, avec la précision de h (c'est utilisé dans l'équation pour résoudre())

    def derivative(f, x, h):
    deriv = (1.0/(2*h))*(f(x+h)-f(x-h))
    return deriv

    L'équation numérique solveur

    Censé boucle jusqu'à ce que la différence entre les approximations est inférieur à h

    def solve(f, x0, h):
    xn = x0
    prev = 0

    while ( approx - prev > h):
         xn = xn - (f(xn))/derivative(f, xn, h)

    return xn
Est l'équation que vous avez des problèmes pour donné? Parce que sinon, vous ne pouvez pas écrire l'équation. Une fois que vous l'avez, le mettre en œuvre comme def f(x): etc. - juste une autre définition de la fonction. Et vous avez besoin de prendre le valeur absolue de la différence de test pour la fin de la boucle (après laquelle votre solve fonction sera de retour).
Netwon-Raphson la méthode trouve le zéro de la fonction (résout l'équation f(x)=0)
Je sais, mais vous devez savoir ce qu'est f... il a demandé: "comment dois-je écrire le code de l'équation".

OriginalL'auteur user2906011 | 2013-12-18

  1. 8

    Ici est la mise en œuvre d'un N-R solveur l'expansion de ce que vous avez écrit ci-dessus (complet, de travail). J'ai ajouté un supplément de quelques lignes pour montrer ce qui se passe...

    def derivative(f, x, h):
      return (f(x+h) - f(x-h)) / (2.0*h)  # might want to return a small non-zero if ==0

def quadratic(x):
    return 2*x*x-5*x+1     # just a function to show it works

def solve(f, x0, h):
    lastX = x0
    nextX = lastX + 10* h  # "different than lastX so loop starts OK
    while (abs(lastX - nextX) > h):  # this is how you terminate the loop - note use of abs()
        newY = f(nextX)                     # just for debug... see what happens
        print "f(", nextX, ") = ", newY     # print out progress... again just debug
        lastX = nextX
        nextX = lastX - newY / derivative(f, lastX, h)  # update estimate using N-R
    return nextX

xFound = solve(quadratic, 5, 0.01)    # call the solver
print "solution: x = ", xFound        # print the result

    de sortie:

    f( 5.1 ) =  27.52
f( 3.31298701299 ) =  6.38683083151
f( 2.53900845771 ) =  1.19808560807
f( 2.30664271935 ) =  0.107987672721
f( 2.28109300639 ) =  0.00130557566462
solution: x =  2.28077645501

    Edit - vous pouvez également vérifier la valeur de newY et de s'arrêter quand il est "proche de zéro" - mais en général, vous gardez cela va jusqu'à ce que le changement de x est <=h (vous pouvez discuter sur la valeur de la = signe dans une méthode numérique - je préfère le plus emphatique < moi-même, en pensant que l'un des plus itération ne fera pas de mal.).

    Je viens toujours ici quand j'ai besoin d'écrire le N-R à partir de zéro. Trois ajouts: si derivative est une fonction interne et h est une variable interne (et, éventuellement, une plus petite valeur) le solveur est contenue dans une seule fonction. Aussi, vérifiez pour ZeroDivisionError lors du calcul de nextX

    OriginalL'auteur Floris

  2. 2

    Si le code en vertu de l'essai: "ne peut pas être mis en œuvre et le compilateur est donné à l'erreur "ZeroDivisionError' puis il va exécuter le code en vertu de l'exception de ZeroDivisionError:'. Bien que, si vous souhaitez un compte pour un autre compilateur exception 'XYZ' avec un code spécifique à la mise en œuvre puis ajouter un supplément " à l'exception de XYZ:"

     try:
    nextX = lastX - newY / derivative(function, lastX, h)
 except ZeroDivisionError:
    return newY
    Si vous pourriez préciser, expliquer ce que fait le code en vrais mots, il serait apprécié 🙂
    (Une modification a été faite.) Assez bien si le compilateur renvoie la "ZeroDivisionError' exception car il n'a pas diviser un nombre par zéro, alors au lieu d'appliquer le code sous "à l'exception de ZeroDivisionError:" qui dans ce cas renvoie la valeur de newY parce qu'il ne pouvait pas être divisé par zéro.

    OriginalL'auteur 74U n3U7r1no

  3. 0

    Vous aurez la chance d'obtenir la convergence depuis votre dérivé n'est pas exact, à la limite de la précision numérique.

    De côté à partir de votre pas de protection contre la division par zéro, il n'y a rien de mal avec votre mise en œuvre de Newton-Raphson résultat: c'est votre déclaration xn = xn - (f(xn))/derivative(f, xn, h)

    Mais puisque vous êtes en utilisant une approximation dérivés, vous devez passer à une autre optimisation du système une fois que vous avez la racine entre crochets. Donc autant que le Newton Raphson partie est concernée, que est votre arrêt maladie. Une bonne utilisation de l'optimiseur à utiliser est brent qui vous permettra de toujours trouver une racine une fois entre crochets; même sans un dérivé.

    J'ai édité pour être plus précis à propos de l'raisonnable bits.

    OriginalL'auteur Bathsheba

  4. 0

    Comment puis-je écrire le code de l'équation?

    De Newton-Raphson la méthode fait trouve les zéros d'une fonction. Pour résoudre une équation g(x) = y, on doit faire la fonction transmise au solveur g(x)-y de sorte que lorsque la fonction transmise au solveur donne zéro, g(x)=y.

    Comment puis-je mettre fin à la boucle quand les approximations ne sont pas de changer plus?

    Votre code déjà le fait que lorsque les deux approximations sont égaux les uns aux autres, la différence sera 0, ce qui est moins que h.

    current_approx - previous_approx > h devrait être current_approx - previous_approx >= h puisque vous le voulez à la fin lorsque la différence est inférieure à h. Également amélioré les noms de variable.

    def derivative(f, x, accuracy):
    deriv = (1.0/(2*accuracy))*(f(x+accuracy)-f(x-accuracy))
    return deriv

def solve(f, approximation, h):
    current_approx = approximation
    prev_approximation = float("inf") # So that the first time the while loop will run

    while current_approx - prev_approx >= h:
        prev_approximation = current_approx
        current_approx = current_approx - (f(current_approx))/derivative(f, current_approx, h)

    return current_approx
    Merci!!!! "Le Newton-Raphson la méthode trouve effectivement l'ensemble des zéros d'une fonction. Pour résoudre une équation g(x) = y, on doit faire la fonction transmise au solveur g(x)-y de sorte que lorsque la fonction transmise au solveur donne zéro, g(x)=y." C'était mon prochain problème lorsque vous essayez de tester mon solve() la méthode. Comment voulez-vous dire g(x)-y ?
    Cela signifie que si vous avez une équation, dire x^2 = 4, puis à le résoudre, il faudrait passer à une fonction retournant x^2-4 parce que le Newton-Raphson solveur trouve x telles que la fonction donne 0. Si x^2-4=0, puis x^2=4, une solution à la fonction est solution de l'équation.
    Donc, si je suis en train de le tester sur dire x^2-1=0, et 2^x-1=0, il devrait fonctionner?
    Pour x^2-1=0, il suffit de passer une fonction retournant x^2-1 pour le solveur.
    C'est ce que j'ai fait tout à l'heure... j'ai ajouté une instruction d'impression à l'intérieur de la alors que en boucle, juste pour vérifier si la boucle tourne même, et il ne le fait pas. Le problème est: prev_approximation = float("inf"), tandis que current_approx - prev_approximation >= h: parce que current_approx moins un nombre infini ne devrait pas être plus grand que h droite?

    OriginalL'auteur Ramchandra Apte