자신 만의 제곱근 함수 작성
정수의 가장 정확한 제곱근을 찾기위한 함수를 어떻게 작성합니까?
그것을 인터넷 검색 후, 나는 발견 이 (자사에서 보관 된 원본 링크 )하지만, 첫째, 나는 완전히 그것을 얻을하지 않았고, 둘째, 너무 근사하다.
제곱근을 가장 가까운 정수 (실제 근에 대한) 또는 실수로 가정합니다.
다음은 N> 0에 대한 floor (sqrt (N))를 계산합니다.
x = 2^ceil(numbits(N)/2)
loop:
y = floor((x + floor(N/x))/2)
if y >= x
return x
x = y
이것은 Crandall & Pomerance, "Prime Numbers : A Computational Perspective"에서 주어진 Newton의 방법의 버전입니다. 이 버전을 사용해야하는 이유는 자신이하는 일을 아는 사람들이 그것이 제곱근의 바닥까지 정확히 수렴한다는 것을 증명했고, 구현 오류가 발생할 확률이 적기 때문에 간단하기 때문입니다. 또한 빠릅니다 (더 빠른 알고리즘을 구성 할 수는 있지만 올바르게 수행하는 것은 훨씬 더 복잡합니다). 적절하게 구현 된 이진 검색은 매우 작은 N의 경우 더 빠를 수 있지만 여기에서 조회 테이블을 사용할 수도 있습니다.
가장 가까운 정수로 반올림 하려면 위의 알고리즘을 사용하여 t = floor (sqrt (4N))를 계산하십시오. t의 최하위 비트가 설정되면 x = (t + 1) / 2를 선택합니다. 그렇지 않으면 t / 2를 선택하십시오. 이것은 동점으로 반올림됩니다. 나머지가 0이 아닌지 (즉, t ^ 2 == 4N인지 여부)를 확인하여 내림 (또는 짝수로 반올림) 할 수도 있습니다.
부동 소수점 산술을 사용할 필요가 없습니다. 사실 그렇게해서는 안됩니다. 이 알고리즘은 전적으로 정수를 사용하여 구현해야합니다 (특히 floor () 함수는 일반 정수 분할을 사용해야 함을 나타냅니다).
필요에 따라 간단한 분할 및 정복 전략을 사용할 수 있습니다. 다른 방법 만큼 빠르게 수렴 하지는 않지만 초보자가 이해하기 훨씬 쉬울 수 있습니다. 또한 O (log n) 알고리즘 (각 반복마다 검색 공간의 절반)이기 때문에 32 비트 부동 소수점의 최악의 경우는 32 회 반복이됩니다.
62.104의 제곱근을 원한다고 가정 해 보겠습니다. 0과 그 사이의 중간 값을 선택하고 제곱합니다. 사각형이 자신의 숫자보다 높으면 중간 점보다 작은 숫자에 집중해야합니다. 너무 낮 으면 높은 것에 집중하십시오.
실제 수학을 사용하면 검색 공간을 두 개로 영원히 나눌 수 있습니다 (합리적 제곱근이없는 경우). 실제로 컴퓨터는 결국 정밀도가 떨어지고 근사치를 갖게됩니다. 다음 C 프로그램은 요점을 보여줍니다.
#include <stdio.h>
#include <stdlib.h>
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 <number>\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;
}
여기에 몇 가지 실행이 있으므로 어떻게 작동하는지 알 수 있습니다. 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
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
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
X의 제곱근을 계산하는 간단하지만 빠르지는 않은 방법 :
squareroot(x)
if x<0 then Error
a = 1
b = x
while (abs(a-b)>ErrorMargin)
a = (a+b)/2
b = x/a
endwhile
return a;
예 : squareroot (70000)
a b
1 70000
35001 2
17502 4
8753 8
4381 16
2199 32
1116 63
590 119
355 197
276 254
265 264
보시다시피 제곱근의 상한과 하한을 정의하고 크기가 허용 될 때까지 경계를 좁 힙니다.
더 효율적인 방법이 있지만이 방법은 프로세스를 설명하고 이해하기 쉽습니다.
정수를 사용하는 경우 무한 루프가있는 경우 Errormargin을 1로 설정하도록주의하십시오.
놀랍도록 빠르기 때문에 게임 디자인 세계의 전설 인 역 제곱근 1 / sqrt (x)를 계산하는 매우 흥미로운 방법을 지적하겠습니다. 또는 다음 게시물을 읽으십시오.
http://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/
추신 : 나는 당신이 제곱근을 원하지만 지진의 우아함이 내 모든 저항을 극복했습니다 :)
그건 그렇고, 위에서 언급 한 기사는 어딘가에서 지루한 Newton-Raphson 근사에 대해서도 이야기합니다.
물론 대략적인 것입니다. 이것이 부동 소수점 숫자를 사용한 수학이 작동하는 방식입니다.
어쨌든 표준 방법은 Newton의 방법 입니다. 이것은 즉시 떠오르는 다른 방법 인 Taylor의 시리즈를 사용하는 것과 거의 같습니다.
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()
산출:
111.10805551354051124500443874307524148991137745969772997648567316178259031751676
True
페이스 북 등에서 자주 묻는 인터뷰 질문입니다. 인터뷰에서 뉴턴의 방법을 사용하는 것은 좋은 생각이 아니라고 생각합니다. 당신이 정말로 이해하지 못하는 경우 면접관이 뉴턴 방법의 메커니즘을 물어 보면 어떨까요?
나는 모든 사람이 이해할 수 있다고 믿는 Java로 바이너리 검색 기반 솔루션을 제공했습니다.
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;
}
여기에서 내 코드를 테스트 할 수 있습니다. leetcode : sqrt (x)
Integer Square Roots 에 대한 훌륭한 기사를 찾았습니다 .
이것은 거기에 제시하는 약간 개선 된 버전입니다.
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;
}
삼각법을 사용하여 제곱근을 얻는 방법은 다음과 같습니다. 롱샷에 의한 가장 빠른 알고리즘은 아니지만 정확합니다. 코드는 자바 스크립트에 있습니다.
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);
정확한 제곱근 (또는 근이 비합리적인 숫자 인 경우 임의로 큰 정밀도)을 계산하는 데 사용할 수있는 학교에서 공부 한 알고리즘이 있습니다. 뉴턴의 알고리즘보다 확실히 느리지 만 정확합니다. 531.3025의 제곱근을 계산한다고 가정 해 보겠습니다.
먼저 소수점에서 시작하는 숫자를
{5} {31} 의 두 자리 그룹으로 나눕니다 . {30} {25}
그런 다음 :
1) 다음 과 같은 첫 번째 그룹의 가장 가까운 제곱근을 찾습니다. 첫 번째 그룹의 실제 제곱근 : sqrt ({5})> = 2.이 제곱근은 최종 답의 첫 번째 숫자입니다. 최종 제곱근에서 이미 찾은 숫자를 B로 표시하겠습니다. 따라서 현재 B = 2입니다.
2) 다음으로 {5}와 B ^ 2의 차이를 계산합니다. 5-4 = 1입니다.
3) 모든 후속 2 자리 그룹은 다음을 수행합니다.
나머지에 100을 곱한 다음 두 번째 그룹에 더합니다 : 100 + 31 = 131.
X를 찾으십시오-루트의 다음 숫자, 131> = ((B * 20) + X) * X. X = 3. 43 * 3 = 129 <131. 이제 B = 23. 또한 소수점 왼쪽에 2 자리 그룹이 더 이상 없기 때문에 최종 루트의 정수 자리를 모두 찾았습니다.
4) {30} 및 {25}에 대해 동일하게 반복합니다. 따라서 다음과 같습니다.
{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
최종 결과 = 23.05.
알고리즘은 이런 방식으로 복잡해 보이지만 학교에서 공부 한 "긴 나눗셈"에 사용하는 것과 동일한 표기법을 사용하여 종이에하면 훨씬 간단합니다.하지만 나눗셈을하지 않고 대신 제곱근을 계산합니다.
// 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;
}
가장 먼저 생각 나는 것은 이진 검색을 사용하기에 좋은 곳이라는 것입니다 (이 훌륭한 튜토리얼에서 영감을 얻었습니다 .).
의 제곱근 찾으려면 vaule, 우리는 검색 number의 (1..value)예측 인자가 처음으로 진정한입니다를. 우리가 선택하는 예측자는입니다 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;
}
이진 검색 사용
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);
}
}
}
일반적으로 정수의 제곱근 (예 : 2와 같은)은 근사값 만 계산할 수 있습니다 (부동 소수점 산술 문제 때문이 아니라 정확히 계산할 수없는 비합리적인 숫자이기 때문).
물론 일부 근사는 다른 것보다 낫습니다. 물론 값 1.732가 1.7보다 제곱근 3에 더 가깝다는 것을 의미합니다.
해당 링크의 코드에서 사용하는 방법은 첫 번째 근사치를 취하고이를 사용하여 더 나은 근사치 를 계산하는 방식으로 작동합니다 .
이것을 Newton의 방법이라고하며, 충분히 정확할 때까지 각각의 새로운 근사값으로 계산을 반복 할 수 있습니다.
사실 반복을 중지 할시기를 결정할 수있는 방법 이 있어야합니다. 그렇지 않으면 영원히 실행될 것입니다.
일반적으로 근사치의 차이가 결정한 값 보다 작을 때 중지 합니다.
편집 : 이미 찾은 두 가지보다 더 간단한 구현이있을 수 있다고 생각하지 않습니다.
그 반대는 이름에서 알 수 있지만 때때로 "충분히 가까움"은 "충분히 가까움"입니다. 어쨌든 흥미로운 읽기.
이진 검색을 사용하여 부동 제곱근 및 임의 정밀도를 처리 할 수있는 간단한 솔루션
루비로 코딩
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
2의 제곱근을 찾으려고하는데 추정치가 1.5라고 가정 해 봅시다. 우리는 a = 2, x = 1.5라고 말할 것입니다. 더 나은 추정치를 계산하기 위해 a를 x로 나눌 것입니다. 이것은 새로운 값 y = 1.333333을 제공합니다. 그러나 우리는 이것을 다음 추정치로 받아 들일 수 없습니다 (왜 안 되겠습니까?). 이전 추정치로 평균을 내야합니다. 따라서 다음 추정치 xx는 (x + y) / 2 또는 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은 근사치가 얼마나 정확해야하는지 결정합니다. 이 함수는 abs (x * x-a) <엡실론을 충족하는 첫 번째 근사값 x를 반환해야합니다. 여기서 abs (x)는 x의 절대 값입니다.
square_root(2, 1e-6)
Output: 1.4142141342163086
Well there are already quite a few answers, but here goes mine It's the most simplest piece of code ( for me ), here is the algorithm for it.
And code 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)
To calculate the square root of a number by help of inbuilt function
# 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<<z;
float squareroot(int x)
{
float s;
s = pow(x,.5)
return(s);
}
참고URL : https://stackoverflow.com/questions/1623375/writing-your-own-square-root-function
'code' 카테고리의 다른 글
| c #의 iif에 해당 (0) | 2020.11.03 |
|---|---|
| 함수를 사용하여 두 날짜 사이의 날짜 목록 가져 오기 (0) | 2020.11.03 |
| xdebug가 작동하는지 확인 (0) | 2020.11.03 |
| Firebase onTokenRefresh ()가 호출되지 않았습니다. (0) | 2020.11.03 |
| 자바 스크립트에서 날짜가 주말인지 확인하는 방법 (0) | 2020.11.03 |