Scrivere la propria funzione radice quadrata

Come scrivi la tua funzione per trovare la radice quadrata più precisa di un intero?

Dopo averlo fatto su Google, ho trovato questo (archiviato dal suo link originale ), ma prima, non l’ho capito completamente, e secondo, è anche approssimativo.

Assumi radice quadrata come numero intero più vicino (alla radice effettiva) o float.

Il seguente piano di calcolo (sqrt (N)) per N> 0:

 x = 2^ceil(numbits(N)/2) loop: y = floor((x + floor(N/x))/2) if y >= x return x x = y 

Questa è una versione del metodo di Newton data in Crandall & Pomerance, “Prime Numbers: A Computational Perspective”. La ragione per cui dovresti usare questa versione è che le persone che sanno quello che stanno facendo hanno provato che converge esattamente al piano della radice quadrata, ed è semplice quindi la probabilità di commettere un errore di implementazione è piccola. È anche veloce (anche se è ansible build un algoritmo ancora più veloce, ma farlo correttamente è molto più complesso). Una ricerca binaria correttamente implementata può essere più veloce per N molto piccoli, ma si può anche usare una tabella di ricerca.

Per arrotondare al numero intero più vicino, basta calcolare t = floor (sqrt (4N)) usando l’algoritmo sopra. Se il bit meno significativo di t è impostato, quindi scegliere x = (t + 1) / 2; altrimenti scegli t / 2. Si noti che questo round su una cravatta; puoi anche arrotondare (o arrotondare per pareggiare) osservando se il resto è diverso da zero (cioè se t ^ 2 == 4N).

Si noti che non è necessario utilizzare l’aritmetica in virgola mobile. In realtà, non dovresti. Questo algoritmo dovrebbe essere implementato interamente usando gli interi (in particolare, le funzioni floor () indicano solo che deve essere usata la divisione di interi regolari).

A seconda delle esigenze, è ansible utilizzare una semplice strategia divide et impera. Non convergerà velocemente come altri metodi, ma potrebbe essere molto più semplice da capire per un principiante. Inoltre, poiché è un algoritmo O (log n) (dimezzando lo spazio di ricerca ogni iterazione), il caso peggiore per un float a 32 bit sarà 32 iterazioni.

Diciamo che vuoi la radice quadrata di 62.104. Scegli un valore a metà tra 0 e quello, e piazza il valore. Se il quadrato è più alto del tuo numero, devi concentrarti su numeri inferiori al punto medio. Se è troppo basso, concentrati su quelli più alti.

Con la matematica reale, potresti continuare a dividere lo spazio di ricerca in due per sempre (se non ha una radice quadrata razionale). In realtà, i computer alla fine esauriranno la precisione e avrai la tua approssimazione. Il seguente programma C illustra il punto:

 #include  #include  int main (int argc, char *argv[]) { float val, low, high, mid, oldmid, midsqr; int step = 0; // Get argument, force to non-negative. if (argc < 2) { printf ("Usage: sqrt \n"); return 1; } val = fabs (atof (argv[1])); // Set initial bounds and print heading. low = 0; high = mid = val; oldmid = -1; printf ("%4s %10s %10s %10s %10s %10s %s\n", "Step", "Number", "Low", "High", "Mid", "Square", "Result"); // Keep going until accurate enough. while (fabs(oldmid - mid) >= 0.00001) { oldmid = mid; // Get midpoint and see if we need lower or higher. mid = (high + low) / 2; midsqr = mid * mid; printf ("%4d %10.4f %10.4f %10.4f %10.4f %10.4f ", ++step, val, low, high, mid, midsqr); if (mid * mid > val) { high = mid; printf ("- too high\n"); } else { low = mid; printf ("- too low\n"); } } // Desired accuracy reached, print it. printf ("sqrt(%.4f) = %.4f\n", val, mid); return 0; } 

Ecco un paio di run in modo che tu possa avere un’idea di come funziona. Per 77:

 pax> sqrt 77 Step Number Low High Mid Square Result 1 77.0000 0.0000 77.0000 38.5000 1482.2500 - too high 2 77.0000 0.0000 38.5000 19.2500 370.5625 - too high 3 77.0000 0.0000 19.2500 9.6250 92.6406 - too high 4 77.0000 0.0000 9.6250 4.8125 23.1602 - too low 5 77.0000 4.8125 9.6250 7.2188 52.1104 - too low 6 77.0000 7.2188 9.6250 8.4219 70.9280 - too low 7 77.0000 8.4219 9.6250 9.0234 81.4224 - too high 8 77.0000 8.4219 9.0234 8.7227 76.0847 - too low 9 77.0000 8.7227 9.0234 8.8730 78.7310 - too high 10 77.0000 8.7227 8.8730 8.7979 77.4022 - too high 11 77.0000 8.7227 8.7979 8.7603 76.7421 - too low 12 77.0000 8.7603 8.7979 8.7791 77.0718 - too high 13 77.0000 8.7603 8.7791 8.7697 76.9068 - too low 14 77.0000 8.7697 8.7791 8.7744 76.9893 - too low 15 77.0000 8.7744 8.7791 8.7767 77.0305 - too high 16 77.0000 8.7744 8.7767 8.7755 77.0099 - too high 17 77.0000 8.7744 8.7755 8.7749 76.9996 - too low 18 77.0000 8.7749 8.7755 8.7752 77.0047 - too high 19 77.0000 8.7749 8.7752 8.7751 77.0022 - too high 20 77.0000 8.7749 8.7751 8.7750 77.0009 - too high 21 77.0000 8.7749 8.7750 8.7750 77.0002 - too high 22 77.0000 8.7749 8.7750 8.7750 76.9999 - too low 23 77.0000 8.7750 8.7750 8.7750 77.0000 - too low sqrt(77.0000) = 8.7750 

Per 62.104:

 pax> sqrt 62.104 Step Number Low High Mid Square Result 1 62.1040 0.0000 62.1040 31.0520 964.2267 - too high 2 62.1040 0.0000 31.0520 15.5260 241.0567 - too high 3 62.1040 0.0000 15.5260 7.7630 60.2642 - too low 4 62.1040 7.7630 15.5260 11.6445 135.5944 - too high 5 62.1040 7.7630 11.6445 9.7037 94.1628 - too high 6 62.1040 7.7630 9.7037 8.7334 76.2718 - too high 7 62.1040 7.7630 8.7334 8.2482 68.0326 - too high 8 62.1040 7.7630 8.2482 8.0056 64.0895 - too high 9 62.1040 7.7630 8.0056 7.8843 62.1621 - too high 10 62.1040 7.7630 7.8843 7.8236 61.2095 - too low 11 62.1040 7.8236 7.8843 7.8540 61.6849 - too low 12 62.1040 7.8540 7.8843 7.8691 61.9233 - too low 13 62.1040 7.8691 7.8843 7.8767 62.0426 - too low 14 62.1040 7.8767 7.8843 7.8805 62.1024 - too low 15 62.1040 7.8805 7.8843 7.8824 62.1323 - too high 16 62.1040 7.8805 7.8824 7.8815 62.1173 - too high 17 62.1040 7.8805 7.8815 7.8810 62.1098 - too high 18 62.1040 7.8805 7.8810 7.8807 62.1061 - too high 19 62.1040 7.8805 7.8807 7.8806 62.1042 - too high 20 62.1040 7.8805 7.8806 7.8806 62.1033 - too low 21 62.1040 7.8806 7.8806 7.8806 62.1038 - too low 22 62.1040 7.8806 7.8806 7.8806 62.1040 - too high 23 62.1040 7.8806 7.8806 7.8806 62.1039 - too high sqrt(62.1040) = 7.8806 

Per 49:

 pax> sqrt 49 Step Number Low High Mid Square Result 1 49.0000 0.0000 49.0000 24.5000 600.2500 - too high 2 49.0000 0.0000 24.5000 12.2500 150.0625 - too high 3 49.0000 0.0000 12.2500 6.1250 37.5156 - too low 4 49.0000 6.1250 12.2500 9.1875 84.4102 - too high 5 49.0000 6.1250 9.1875 7.6562 58.6182 - too high 6 49.0000 6.1250 7.6562 6.8906 47.4807 - too low 7 49.0000 6.8906 7.6562 7.2734 52.9029 - too high 8 49.0000 6.8906 7.2734 7.0820 50.1552 - too high 9 49.0000 6.8906 7.0820 6.9863 48.8088 - too low 10 49.0000 6.9863 7.0820 7.0342 49.4797 - too high 11 49.0000 6.9863 7.0342 7.0103 49.1437 - too high 12 49.0000 6.9863 7.0103 6.9983 48.9761 - too low 13 49.0000 6.9983 7.0103 7.0043 49.0598 - too high 14 49.0000 6.9983 7.0043 7.0013 49.0179 - too high 15 49.0000 6.9983 7.0013 6.9998 48.9970 - too low 16 49.0000 6.9998 7.0013 7.0005 49.0075 - too high 17 49.0000 6.9998 7.0005 7.0002 49.0022 - too high 18 49.0000 6.9998 7.0002 7.0000 48.9996 - too low 19 49.0000 7.0000 7.0002 7.0001 49.0009 - too high 20 49.0000 7.0000 7.0001 7.0000 49.0003 - too high 21 49.0000 7.0000 7.0000 7.0000 49.0000 - too low 22 49.0000 7.0000 7.0000 7.0000 49.0001 - too high 23 49.0000 7.0000 7.0000 7.0000 49.0000 - too high sqrt(49.0000) = 7.0000 

Un metodo semplice (ma non molto veloce) per calcolare la radice quadrata di X:

 squareroot(x) if x<0 then Error a = 1 b = x while (abs(ab)>ErrorMargin) a = (a+b)/2 b = x/a endwhile return a; 

Esempio: squareroot (70000)

  ab 1 70000 35001 2 17502 4 8753 8 4381 16 2199 32 1116 63 590 119 355 197 276 254 265 264 

Come puoi vedere, definisce un limite superiore e uno inferiore per la radice quadrata e restringe il limite finché la sua dimensione non è accettabile.

Esistono metodi più efficienti, ma questo illustra il processo ed è facile da capire.

Stai attento a impostare Errormargin su 1 se usi interi, hai un ciclo infinito.

Permettetemi di evidenziare un metodo estremamente interessante per calcolare una radice quadrata inversa 1 / sqrt (x) che è una leggenda nel mondo del design del gioco perché è incredibilmente veloce. O aspetta, leggi il seguente post:

http://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/

PS: So che vuoi solo la radice quadrata ma l’eleganza del terremoto ha superato tutte le resistenze da parte mia 🙂

A proposito, l’articolo sopra menzionato parla anche della noiosa approssimazione di Newton-Raphson da qualche parte.

Certo che è approssimativo; è così che funziona la matematica con numeri in virgola mobile.

Ad ogni modo, il modo standard è con il metodo di Newton . È quasi come usare la serie di Taylor, l’altro modo che mi viene in mente immediatamente.

Calcola la radice quadrata con precisione arbitraria in Python

 #!/usr/bin/env python import decimal def sqrt(n): assert n > 0 with decimal.localcontext() as ctx: ctx.prec += 2 # increase precision to minimize round off error x, prior = decimal.Decimal(n), None while x != prior: prior = x x = (x + n/x) / 2 # quadratic convergence return +x # round in a global context decimal.getcontext().prec = 80 # desirable precision r = sqrt(12345) print r print r == decimal.Decimal(12345).sqrt() 

Produzione:

 111.10805551354051124500443874307524148991137745969772997648567316178259031751676 True 

È una domanda di intervista comune fatta da Facebook, ecc. Non credo sia una buona idea usare il metodo di Newton in un’intervista. E se l’intervistatore ti chiedesse il meccanismo del metodo di Newton quando non lo capisci davvero?

Ho fornito una soluzione basata su ricerca binaria in Java, che credo tutti possano capire.

 public int sqrt(int x) { if(x < 0) return -1; if(x == 0 || x == 1) return x; int lowerbound = 1; int upperbound = x; int root = lowerbound + (upperbound - lowerbound)/2; while(root > x/root || root+1 <= x/(root+1)){ if(root > x/root){ upperbound = root; } else { lowerbound = root; } root = lowerbound + (upperbound - lowerbound)/2; } return root; } 

Puoi testare il mio codice qui: leetcode: sqrt (x)

Trovato un grande articolo su Integer Square Roots .

Questa è una versione leggermente migliorata che presenta lì:

 unsigned long sqrt(unsigned long a){ int i; unsigned long rem = 0; unsigned long root = 0; for (i = 0; i < 16; i++){ root <<= 1; rem = (rem << 2) | (a >> 30); a <<= 2; if(root < rem){ root++; rem -= root; root++; } } return root >> 1; } 

Ecco un modo per ottenere una radice quadrata usando la trigonometria. Non è l’algoritmo più veloce di un longshot, ma è preciso. Il codice è in javascript:

 var n = 5; //number to get the square root of var icr = ((n+1)/2); //intersecting circle radius var sqrt = Math.cos(Math.asin((icr-1)/icr))*icr; //square root of n alert(sqrt); 

C’è un algoritmo che ho studiato a scuola che puoi usare per calcolare radici quadrate esatte (o di precisione arbitrariamente grande se la radice è un numero irrazionale). È decisamente più lento degli algoritmi di Newton ma è esatto. Diciamo che vuoi calcolare la radice quadrata di 531.3025

La prima cosa è che dividi il tuo numero iniziando dal punto decimale in gruppi di 2 cifre:
{5} {31}. {30} {25}
Poi:
1) Trova la radice quadrata più vicina per il primo gruppo che è minore o uguale alla radice quadrata effettiva del primo gruppo: sqrt ({5})> = 2. Questa radice quadrata è la prima cifra della tua risposta finale. Indichiamo le cifre che abbiamo già trovato della nostra radice quadrata finale come B. Quindi al momento B = 2.
2) Successivamente calcola la differenza tra {5} e B ^ 2: 5 – 4 = 1.
3) Per tutti i successivi gruppi di 2 cifre, effettuare le seguenti operazioni:
Moltiplicare il resto per 100, quindi aggiungerlo al secondo gruppo: 100 + 31 = 131.
Trova X – la prossima cifra della tua radice, in modo che 131> = ((B * 20) + X) * X. X = 3. 43 * 3 = 129 <131. Ora B = 23. Anche perché non ci sono più gruppi di 2 cifre alla sinistra dei punti decimali, hai trovato tutti i numeri interi della tua radice finale.
4) Ripeti lo stesso per {30} e {25}. Quindi hai:
{30}: 131 – 129 = 2. 2 * 100 + 30 = 230> = (23 * 2 * 10 + X) * X -> X = 0 -> B = 23.0
{25}: 230 – 0 = 230. 230 * 100 + 25 = 23025. 23025> = (230 * 2 * 10 + X) * X -> X = 5 -> B = 23,05
Risultato finale = 23.05.
L’algoritmo sembra complicato in questo modo ma è molto più semplice se lo fai su carta usando la stessa notazione che usi per “long division” che hai studiato a scuola, eccetto che non fai divisione ma calcoli invece la radice quadrata.

La prima cosa che mi viene in mente è: questo è un buon posto per usare la ricerca binaria (ispirata da questi fantastici tutorial ).

Per trovare la radice quadrata di vaule , stiamo cercando il number in (1..value) cui il predittore è vero per la prima volta. Il predittore che stiamo scegliendo è number * number - value > 0.00001 .

 double square_root_of(double value) { assert(value >= 1); double lo = 1.0; double hi = value; while( hi - lo > 0.00001) { double mid = lo + (hi - lo) / 2 ; std::cout << lo << "," << hi << "," << mid << std::endl; if( mid * mid - value > 0.00001) //this is the predictors we are using { hi = mid; } else { lo = mid; } } return lo; } 
 // Fastest way I found, an (extreme) C# unrolled version of: // http://www.hackersdelight.org/hdcodetxt/isqrt.c.txt (isqrt4) // It's quite a lot of code, basically a binary search (the "if" statements) // followed by an unrolled loop (the labels). // Most important: it's fast, twice as fast as "Math.Sqrt". // On my pc: Math.Sqrt ~35 ns, sqrt <16 ns (mean <14 ns) private static uint sqrt(uint x) { uint y, z; if (x < 1u << 16) { if (x < 1u << 08) { if (x < 1u << 04) return x < 1u << 02 ? x + 3u >> 2 : x + 15u >> 3; else { if (x < 1u << 06) { y = 1u << 03; x -= 1u << 04; if (x >= 5u << 02) { x -= 5u << 02; y |= 1u << 02; } goto L0; } else { y = 1u << 05; x -= 1u << 06; if (x >= 5u << 04) { x -= 5u << 04; y |= 1u << 04; } goto L1; } } } else // slower (on my pc): .... y = 3u << 04; } goto L1; } { if (x < 1u << 12) { if (x < 1u << 10) { y = 1u << 07; x -= 1u << 08; if (x >= 5u << 06) { x -= 5u << 06; y |= 1u << 06; } goto L2; } else { y = 1u << 09; x -= 1u << 10; if (x >= 5u << 08) { x -= 5u << 08; y |= 1u << 08; } goto L3; } } else { if (x < 1u << 14) { y = 1u << 11; x -= 1u << 12; if (x >= 5u << 10) { x -= 5u << 10; y |= 1u << 10; } goto L4; } else { y = 1u << 13; x -= 1u << 14; if (x >= 5u << 12) { x -= 5u << 12; y |= 1u << 12; } goto L5; } } } } else { if (x < 1u << 24) { if (x < 1u << 20) { if (x < 1u << 18) { y = 1u << 15; x -= 1u << 16; if (x >= 5u << 14) { x -= 5u << 14; y |= 1u << 14; } goto L6; } else { y = 1u << 17; x -= 1u << 18; if (x >= 5u << 16) { x -= 5u << 16; y |= 1u << 16; } goto L7; } } else { if (x < 1u << 22) { y = 1u << 19; x -= 1u << 20; if (x >= 5u << 18) { x -= 5u << 18; y |= 1u << 18; } goto L8; } else { y = 1u << 21; x -= 1u << 22; if (x >= 5u << 20) { x -= 5u << 20; y |= 1u << 20; } goto L9; } } } else { if (x < 1u << 28) { if (x < 1u << 26) { y = 1u << 23; x -= 1u << 24; if (x >= 5u << 22) { x -= 5u << 22; y |= 1u << 22; } goto La; } else { y = 1u << 25; x -= 1u << 26; if (x >= 5u << 24) { x -= 5u << 24; y |= 1u << 24; } goto Lb; } } else { if (x < 1u << 30) { y = 1u << 27; x -= 1u << 28; if (x >= 5u << 26) { x -= 5u << 26; y |= 1u << 26; } goto Lc; } else { y = 1u << 29; x -= 1u << 30; if (x >= 5u << 28) { x -= 5u << 28; y |= 1u << 28; } } } } } z = y | 1u << 26; y /= 2; if (x >= z) { x -= z; y |= 1u << 26; } Lc: z = y | 1u << 24; y /= 2; if (x >= z) { x -= z; y |= 1u << 24; } Lb: z = y | 1u << 22; y /= 2; if (x >= z) { x -= z; y |= 1u << 22; } La: z = y | 1u << 20; y /= 2; if (x >= z) { x -= z; y |= 1u << 20; } L9: z = y | 1u << 18; y /= 2; if (x >= z) { x -= z; y |= 1u << 18; } L8: z = y | 1u << 16; y /= 2; if (x >= z) { x -= z; y |= 1u << 16; } L7: z = y | 1u << 14; y /= 2; if (x >= z) { x -= z; y |= 1u << 14; } L6: z = y | 1u << 12; y /= 2; if (x >= z) { x -= z; y |= 1u << 12; } L5: z = y | 1u << 10; y /= 2; if (x >= z) { x -= z; y |= 1u << 10; } L4: z = y | 1u << 08; y /= 2; if (x >= z) { x -= z; y |= 1u << 08; } L3: z = y | 1u << 06; y /= 2; if (x >= z) { x -= z; y |= 1u << 06; } L2: z = y | 1u << 04; y /= 2; if (x >= z) { x -= z; y |= 1u << 04; } L1: z = y | 1u << 02; y /= 2; if (x >= z) { x -= z; y |= 1u << 02; } L0: return x > y ? y / 2 | 1u : y / 2; } 

usa la ricerca binaria

 public class FindSqrt { public static void main(String[] strings) { int num = 10000; System.out.println(sqrt(num, 0, num)); } private static int sqrt(int num, int min, int max) { int middle = (min + max) / 2; int x = middle * middle; if (x == num) { return middle; } else if (x < num) { return sqrt(num, middle, max); } else { return sqrt(num, min, middle); } } } 

In generale, la radice quadrata di un intero (come 2, per esempio) può essere solo approssimata (non a causa di problemi con l’aritmetica in virgola mobile, ma perché sono numeri irrazionali che non possono essere calcolati esattamente).

Certo, alcune approssimazioni sono migliori di altre. Voglio dire, ovviamente, che il valore 1.732 è una migliore approssimazione alla radice quadrata di 3, che 1.7

Il metodo utilizzato dal codice a quel link ha dato dei lavori prendendo una prima approssimazione e usandolo per calcolare una migliore approssimazione.

Questo è chiamato Metodo di Newton, e puoi ripetere il calcolo con ogni nuova approssimazione finché non è abbastanza preciso per te.

In effetti, ci deve essere un modo per decidere quando interrompere la ripetizione o verrà eseguito per sempre.

Di solito ti fermi quando la differenza tra approssimazioni è inferiore a un valore che decidi.

EDIT: Non penso che ci possa essere un’implementazione più semplice di quella che hai già trovato.

L’inverso, come dice il nome, ma a volte “abbastanza vicino” è “abbastanza vicino”; una lettura interessante comunque.

Origine di Quake3 Fast InvSqrt ()

 // A Java program to find floor(sqrt(x) public class Test { public static int floorSqrt(int x) { // Base Cases if (x == 0 || x == 1) return x; // Do Binary Search for floor(sqrt(x)) int start = 1, end = x, ans=0; while (start <= end) { int mid = (start + end) / 2; // If x is a perfect square if (mid*mid == x) return mid; // Since we need floor, we update answer when mid*mid is // smaller than x, and move closer to sqrt(x) if (mid*mid < x) { start = mid + 1; ans = mid; } else // If mid*mid is greater than x end = mid - 1; } return ans; } // Driver Method public static void main(String args[]) { int x = 11; System.out.println(floorSqrt(x)); } } 

uscita: 3 (piano)

 Let 's' be the answer. We know that 0 <= s <= x. Consider any random number r. If r*r <= x, s >= r If r*r > x, s < r. 

Algoritmo:

  • Inizia con 'start' = 0, end = 'x', Segui mentre 'start' è minore o uguale a 'end'.

  • a) Calcola 'meta' come (inizio + fine) / 2

  • b) confronta mid * mid con x.

  • c) Se x è uguale a metà * metà, ritorna a metà.
  • d) Se x è maggiore, esegui una ricerca binaria tra metà + 1 e fine. In questo caso, aggiorniamo anche ans (nota che abbiamo bisogno di floor).
  • e) Se x è più piccolo, fai una ricerca binaria tra inizio e metà-1

La complessità temporale della soluzione di cui sopra è O (√ n).

Una soluzione semplice che può gestire la radice quadrata mobile e la precisione arbitraria mediante la ricerca binaria

codificato in ruby

 include Math def sqroot_precision num, precision upper = num lower = 0 middle = (upper + lower)/2.0 while true do diff = middle**2 - num return middle if diff.abs <= precision if diff > 0 upper = middle else diff < 0 lower = middle end middle = (upper + lower)/2.0 end end puts sqroot_precision 232.3, 0.0000000001 

Diciamo che stiamo cercando di trovare la radice quadrata di 2 e hai una stima di 1.5. Diremo a = 2 e x = 1.5. Per calcolare una stima migliore, divideremo per x. Questo dà un nuovo valore y = 1.333333. Tuttavia, non possiamo prendere questo come nostra prossima stima (perché no?). Dobbiamo fare una media con la stima precedente. Quindi la nostra prossima stima, xx sarà (x + y) / 2 o 1.416666.

 Double squareRoot(Double a, Double epsilon) { Double x = 0d; Double y = a; Double xx = 0d; // Make sure both x and y != 0. while ((x != 0d || y != 0d) && y - x > epsilon) { xx = (x + y) / 2; if (xx * xx >= a) { y = xx; } else { x = xx; } } return xx; } 

Epsilon determina quanto deve essere accurata l’approssimazione. La funzione dovrebbe restituire la prima approssimazione x che ottiene che soddisfa abs (x * x – a)

 square_root(2, 1e-6) Output: 1.4142141342163086 

Beh, ci sono già parecchie risposte, ma qui la mia è la parte di codice più semplice (per me), ecco l’ algoritmo per questo.

E codice in python 2.7:

 from __future__ import division val = 81 x = 10 def sqr(data,x): temp = x - ( (x**2 - data)/(2*x)) if temp == x: print temp return else: x = temp return sqr(data,x) #x =temp #sqr(data,x) sqr(val,x) 

Per calcolare la radice quadrata di un numero mediante l’aiuto della funzione integrata

 # include"iostream.h" # include"conio.h" # include"math.h" void main() { clrscr(); float x; cout<<"Enter the Number"; cin>>x; float squreroot(float); float z=squareroot(x); cout<