Puoi anche approssimare la funzione radice quadrata usando il metodo di Newton . Il metodo di Newton è un modo per approssimare dove sono le radici di una funzione. È anche un metodo iterativo in cui il risultato dell'iterazione precedente viene utilizzato nell'iterazione successiva fino alla convergenza. L'equazione del metodo di Newton per indovinare dove si trova la radice di una funzione data un'ipotesi iniziale è definita come:f(x)x0
x1=x0−f(x0)f′(x0)
x1 è la prima ipotesi di dove si trova la radice. Continuiamo a riciclare l'equazione e ad utilizzare i risultati delle iterazioni precedenti fino a quando la risposta non cambia. In generale, per determinare la congettura della radice al iterazione, data l'ipotesi al iterazione è definito come:(n+1)n
xn+1=xn−f(xn)f′(xn)
Per usare il metodo di Newton per approssimare la radice quadrata, supponiamo che ci venga dato un numero . Pertanto, per calcolare la radice quadrata, dobbiamo calcolare In quanto tale, cerchiamo di trovare una risposta tale che . Quadrare entrambi i lati, e spostando verso l'altro lato delle rese equazione . Pertanto, la risposta a questa equazione è ed è quindi la radice della funzione. Come tale, lascia che sia l'equazione di cui vogliamo trovare la radice. Sostituendo questo nel metodo di Newton, , e quindi:aa−−√x=a−−√ax2−a=0a−−√f(x)=x2−af′(x)=2x
xn+1=xn−x2n−a2xn
xn+1=12(xn+axn)
Pertanto, per calcolare la radice quadrata di , dobbiamo semplicemente calcolare il metodo di Newton fino a quando non convergere. Tuttavia, come notato da @ robertbristow-johnson, la divisione è un'operazione molto costosa, specialmente per i microcontrollori / DSP con risorse limitate. Inoltre, potrebbe esserci un caso in cui un'ipotesi può essere 0, il che comporterebbe un errore di divisione per 0 a causa dell'operazione di divisione. Pertanto, ciò che possiamo fare è usare il metodo di Newton e risolvere invece la funzione reciproca , ovvero . Ciò evita anche qualsiasi divisione, come vedremo più avanti. Quadrando entrambi i lati e spostando sul lato sinistro si ottiene così . Pertanto, la soluzione sarebbea1x=a−−√a−−√1x2−a=01a√ . Moltiplicando per , otterremmo il risultato desiderato. Ancora una volta, usando il metodo di Newton, abbiamo quindi:a
xn+1=xn−f(xn)f′(xn)
xn+1=xn−1(xn)2−a−2(xn)3
xn+1=12(3xn−(xn)3a)
Tuttavia, c'è un avvertimento che dovremmo considerare quando guardiamo l'equazione sopra. Per le radici quadrate, la soluzione dovrebbe essere positiva e quindi affinché le iterazioni (e il risultato) siano positive, devono essere soddisfatte le seguenti condizioni:
3xn−(xn)3a>0
3xn>(xn)3a
(xn)2a<3
Perciò:
(x0)2a<3
Pertanto, dato il numero di cui vogliamo calcolare la radice quadrata, la supposizione iniziale deve soddisfare la condizione di cui sopra. Dato che alla fine questo verrà posizionato su un microcontrollore, potremmo iniziare con qualsiasi valore di (diciamo 1), quindi continuare ad eseguire il looping e ridurre il valore di fino a quando la condizione di cui sopra è soddisfatta. Nota che ho evitato di fare divisione per calcolare direttamente quale sia il valore dix 0 x 0 10 - 6x0x0x0dovrebbe essere come divisione è un'operazione costosa. Una volta che abbiamo la nostra ipotesi iniziale, scorrere il metodo di Newton. Si noti che, a seconda dell'ipotesi iniziale, la convergenza potrebbe richiedere un tempo più o meno lungo. Tutto dipende da quanto sei vicino alla risposta effettiva. Puoi limitare il numero di iterazioni o attendere fino a quando la differenza relativa tra le due radici è inferiore a qualche soglia (come o giù di lì).10−6
Poiché il tag è alla ricerca di un algoritmo C, scriviamolo molto rapidamente:
#include <stdio.h> // For printf
#include <math.h> // For fabs
void main()
{
float a = 5.0; // Number we want to take the square root of
float x = 1.0; // Initial guess
float xprev; // Root for previous iteration
int count; // Counter for iterations
// Find a better initial guess
// Half at each step until condition is satisfied
while (x*x*a >= 3.0)
x *= 0.5;
printf("Initial guess: %f\n", x);
count = 1;
do {
xprev = x; // Save for previous iteration
printf("Iteration #%d: %f\n", count++, x);
x = 0.5*(3*xprev - (xprev*xprev*xprev)*a); // Find square root of the reciprocal
} while (fabs(x - xprev) > 1e-6);
x *= a; // Actual answer - Multiply by a
printf("Square root is: %f\n", x);
printf("Done!");
}
Questa è un'implementazione piuttosto basilare del metodo di Newton. Si noti che continuo a ridurre la supposizione iniziale della metà fino a quando la condizione di cui abbiamo parlato in precedenza è soddisfatta. Sto anche cercando di trovare la radice quadrata di 5. Sappiamo che questo è approssimativamente uguale a 2.236 o giù di lì. L'uso del codice sopra fornisce il seguente output:
Initial guess: 0.500000
Iteration #1: 0.500000
Iteration #2: 0.437500
Iteration #3: 0.446899
Iteration #4: 0.447213
Square root is: 2.236068
Done!
Si noti che il metodo di Newton è trovare la soluzione della soluzione reciproco e moltiplichiamo per alla fine per ottenere la nostra risposta finale. Inoltre, tieni presente che l'ipotesi iniziale è stata modificata per garantire che i criteri di cui ho parlato sopra siano soddisfatti. Solo per divertimento, proviamo a trovare la radice quadrata di 9876.a
Initial guess: 0.015625
Iteration #1: 0.015625
Iteration #2: 0.004601
Iteration #3: 0.006420
Iteration #4: 0.008323
Iteration #5: 0.009638
Iteration #6: 0.010036
Iteration #7: 0.010062
Square root is: 99.378067
Done!
Come puoi vedere, l'unica cosa diversa è quante iterazioni sono necessarie per calcolare la radice quadrata. Maggiore è il numero di ciò che si desidera calcolare, più iterazioni ci vorranno.
So che questo metodo è già stato suggerito in un post precedente, ma ho pensato che avrei derivato il metodo e fornito un po 'di codice!