자신의 제곱근 기능을 작성합니다
https://stackoverflow.com/questions/1623375
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian해결책
다음은 n> 0에 대한 바닥 (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, "소수 : 계산 관점"에 제공된 Newton의 방법의 버전입니다. 이 버전을 사용해야하는 이유는 자신이하고있는 일을 아는 사람들이 그것이 제곱근의 바닥으로 정확히 수렴한다는 것을 증명했으며, 구현 오류를 만들 가능성이 작기 때문에 간단합니다. 또한 빠른 알고리즘을 구축 할 수는 있지만 올바르게하는 것이 훨씬 더 복잡합니다). 적절하게 구현 된 이진 검색은 매우 작은 N의 경우 더 빠를 수 있지만 조회 테이블을 사용할 수도 있습니다.
둥글게 가장 가까운 정수, 위의 알고리즘을 사용하여 T = Floor (SQRT (4N))를 계산합니다. 가장 유의미한 비트가 설정된 경우 x = (t+1)/2를 선택하십시오. 그렇지 않으면 t/2를 선택하십시오. 이것은 넥타이로 반올림합니다. 나머지가 0이 아닌지 (즉, t^2 == 4N)를 살펴보면 둥글거나 둥글게 둥글게 할 수도 있습니다.
부동 소수점 산술을 사용할 필요가 없습니다. 사실, 당신은해서는 안됩니다. 이 알고리즘은 정수를 사용하여 완전히 구현되어야합니다 (특히 Floor () 함수는 일반 정수 부서를 사용해야 함을 나타냅니다).
다른 팁
귀하의 요구에 따라 간단한 분열 및 대체 전략을 사용할 수 있습니다. 그것은 AS로 수렴하지 않습니다 빠른 다른 방법 으로서는 초보자가 이해하기가 훨씬 쉬울 수 있습니다. 또한, O (로그 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 근사에 대해 이야기합니다.
물론 그것은 대략적입니다. 그것이 부동 소수점 수의 수학이 작동하는 방식입니다.
어쨌든 표준 방식은 다음과 같습니다 뉴턴의 방법. 이것은 Taylor의 시리즈를 사용하는 것과 거의 같습니다.
파이썬에서 임의의 정밀도로 제곱근을 계산하십시오
#!/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
Facebook 등의 일반적인 인터뷰 질문입니다. 인터뷰에서 Newton의 방법을 사용하는 것이 좋은 생각이라고 생각하지 않습니다. 면접관이 실제로 이해하지 못할 때 뉴턴 방법의 메커니즘을 물으면 어떻게해야합니까?
나는 모든 사람들이 이해할 수 있다고 생각하는 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)
에 관한 훌륭한 기사를 찾았습니다 정수 광장 뿌리.
이것은 약간 개선 된 버전입니다.
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;
}
Trigonometry를 사용하여 제곱근을 얻는 방법은 다음과 같습니다. 장거리에 의해 가장 빠른 알고리즘은 아니지만 정확합니다. 코드는 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);
정확한 정사각형 뿌리를 계산하는 데 사용할 수있는 학교에서 공부 한 알고리즘이 있습니다 (또는 뿌리가 비이성적 인 숫자 인 경우 임의로 큰 정밀도). 뉴턴의 알고리즘보다 확실히 느리지 만 정확합니다. 531.3025의 제곱근을 계산하고 싶다고 가정 해 봅시다.
첫 번째는 소수점에서 시작하는 숫자를 소수점에서 2 자리의 그룹으로 나누는 것입니다.
{5}{31}.{30}{25}
그 다음에:
1) 첫 번째 그룹의 실제 제곱근과 작거나 동일한 첫 번째 그룹의 가장 가까운 제곱근을 찾으십시오 : SQRT ({5})> = 2. 우리가 이미 마지막 제곱근에서 찾은 숫자를 B로 표시하겠습니다. 그래서 현재 B = 2.
2) 다음으로 {5}와 b^2 : 5-4 = 1의 차이를 계산합니다.
3) 모든 후속 2 자리 그룹의 경우 다음을 수행합니다.
나머지를 100을 곱한 다음 두 번째 그룹에 추가하십시오 : 100 + 31 = 131.
131> = ((b*20) + x)*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> = (230 * 2 * 10 + x) * x-> x = 5-> b = 23.05
최종 결과 = 23.05.
알고리즘은 이런 식으로 복잡해 보이지만 학교에서 공부 한 "긴 분할"에 사용하는 것과 동일한 표기법을 사용하여 종이로 수행하는 경우 훨씬 간단합니다.
첫 번째는 내 마음에 오는 것입니다.이 바이너리 검색을 사용하기에 좋은 곳입니다 (이 위대한에서 영감을 얻었습니다. 튜토리얼.)
의 제곱근을 찾으려면 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;
}
// 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;
}
이진 검색을 사용하십시오
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의 방법이라고하며 각각의 새로운 근사치로 계산을 반복 할 수 있습니다. ~까지 당신에게 충분히 정확합니다.
사실 거기 ~ 해야 하다 반복을 막을시기를 결정하는 방법이 되십시오. 그렇지 않으면 영원히 실행됩니다.
일반적으로 근사치의 차이가 보다 적습니다 당신이 결정한 가치.
편집 : 나는 당신이 이미 찾은 두 가지보다 간단한 구현이있을 수 있다고 생각하지 않습니다.
이름이 말한 것처럼 반대는 "충분히" "충분히 가까이"입니다. 어쨌든 흥미로운 읽기.
이진 검색을 사용하여 Float Square 루트 및 임의의 정밀도를 처리 할 수있는 간단한 솔루션
루비로 코딩
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) <Epsilon을 만족시키는 첫 번째 근사 X를 반환해야합니다. 여기서 ABS (x)는 x의 절대 값입니다.
square_root(2, 1e-6)
Output: 1.4142141342163086
글쎄, 이미 꽤 많은 답이 있지만 여기에 가장 간단한 코드 (나를 위해)가 있습니다. 여기에 있습니다. 연산 그것을 위해.
및 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)
내장 기능의 도움으로 숫자의 제곱근을 계산하려면
# 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);
}
