كتابة دالة الجذر التربيعي الخاصة بك
https://stackoverflow.com/questions/1623375
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russianسؤال
كيف تكتب وظيفتك الخاصة للعثور على الجذر التربيعي الأكثر دقة لعدد صحيح؟
وبعد البحث في جوجل وجدته هذا (مؤرشفة من الرابط الأصلي)، ولكن أولاً، لم أفهمها بالكامل، وثانيًا، إنها تقريبية أيضًا.
افترض أن الجذر التربيعي هو أقرب عدد صحيح (للجذر الفعلي) أو عدد عشري.
المحلول
وهذا يحسب الكلمة التالية (الجذر التربيعي (N)) لN> 0:
x = 2^ceil(numbits(N)/2)
loop:
y = floor((x + floor(N/x))/2)
if y >= x
return x
x = y
وهذا هو نسخة من طريقة نيوتن الواردة في كراندال وPomerance "رئيس الأرقام: A الحاسوبية المنظور". السبب يجب استخدام هذا الإصدار هو أن الناس الذين يعرفون ما يفعلونه وقد ثبت أنه يتقاطع تماما مع الكلمة من الجذر التربيعي، وانها في غاية البساطة احتمال اتخاذ خطأ تنفيذ صغير. كما انها سريعة (على الرغم من أنه من الممكن لبناء خوارزمية أسرع - ولكن القيام بذلك بشكل صحيح هو أكثر تعقيدا من ذلك بكثير). بحث ثنائي تنفيذها بشكل صحيح يمكن أن يكون أسرع لN صغير جدا، ولكن هناك يمكنك استخدام فضلا طاولة البحث.
لجولة إلى <ط> أقرب صحيح، فقط بحساب ر = الكلمة (الجذر التربيعي (4N)) باستخدام خوارزمية أعلاه. إذا تم تعيين أقل قليلا كبير من ر، ثم اختر س = (ر + 1) / 2؛ إلا اختيار ر / 2. لاحظ أن هذا جولات حتى على التعادل. هل يمكن أيضا تقريبه (أو جولة لحتى) من خلال النظر في ما إذا كان الباقي هو غير صفرية (أي ما إذا كانت ر ^ 2 == 4N).
ملحوظة أنك لا تحتاج إلى استخدام الحساب الفاصلة العائمة. في الواقع، لا ينبغي. وينبغي تنفيذ هذه الخوارزمية تماما باستخدام الأعداد الصحيحة (على وجه الخصوص، والكلمة () وظائف تشير فقط أن قسمة عدد صحيح العادي ينبغي استخدامها).
نصائح أخرى
واعتمادا على احتياجاتك، استراتيجية فرق تسد وبسيطة يمكن استخدامها. انها لن تلتقي ك <م> سريع إلى بعض الأساليب الأخرى ولكن قد يكون من الأسهل كثيرا لمبتدئ لفهم. وبالإضافة إلى ذلك، لأنه هو وO (سجل ن) خوارزمية (خفض فضاء البحث كل التكرار)، أسوأ الحالات لتعويم 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;
وعلى سبيل المثال: جذر تربيعي (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 / الجذر التربيعي (س) الذي هو أسطورة في عالم تصميم لعبة لأنه العقل boggingly بسرعة. أو الانتظار، وقراءة آخر التالية:
http://betterexplained.com/articles/understanding-quakes -fast معكوس مربع الجذر /
وPS: أنا أعلم أنك تريد فقط الجذر التربيعي لكن أناقة الزلزال تغلب كل مقاومة من جهتي:)
وبالمناسبة، فإن ذكر المادة المذكورة أعلاه أيضا يتحدث عن مملة تقريب نيوتن-رافسون في مكان ما.
وبالطبع انها تقريبي. هذه هي الطريقة الرياضيات مع عمل أرقام الفاصلة العائمة.
وعلى أي حال، فإن الطريقة القياسية مع طريقة نيوتن . هذا هو تقريبا نفس باستخدام سلسلة تايلور، والطريقة الأخرى أن يتبادر إلى الذهن على الفور.
حساب الجذر التربيعي بدقة التعسفية في بيثون
#!/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
وانها مسألة مقابلة مشتركة سأله الفيسبوك الخ لا أعتقد انها فكرة جيدة لاستخدام طريقة نيوتن في مقابلة. ماذا لو كان المقابل يطلب منك آلية طريقة نيوتن عندما كنت لا أفهم حقا؟
وأنا قدمت حلا البحث الثنائي مقرها في جافا والتي أعتقد أن الجميع يمكن أن نفهم.
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: الجذر التربيعي (س)
وجدت كبيرة من المادة حول ساحة صحيح جذور .
وهذا هو نسخة محسنة قليلا انه يقدم هناك:
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;
}
وهنا طريقة الحصول على الجذر التربيعي باستخدام علم المثلثات. انها ليست أسرع خوارزمية من قبل longshot، ولكن من الدقيق. متاحة في جافا سكريبت:
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) البحث عن أقرب الجذر التربيعي للمجموعة الأولى التي هي أصغر أو يساوي الجذر التربيعي الفعلي من المجموعة الأولى: الجذر التربيعي ({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.
الخوارزمية تبدو معقدة بهذه الطريقة وإنما هو أبسط من ذلك بكثير إذا كنت تفعل ذلك على الورق باستخدام نفس الرموز التي تستخدمها ل "القسمة المطولة" كنت قد درست في المدرسة، إلا أنك لا تفعل تقسيم ولكن بدلا من حساب الجذر التربيعي.
وأول شيء يتبادر إلى ذهني هو: هذا هو مكان جيد للاستخدام البحث ثنائي (مستوحاة من هذا عظيم <وأ href = "http://www.topcoder.com/tc؟module=Static&d1=tutorials&d2=binarySearch "يختلط =" نوفولو noreferrer "> الدروس ).
لايجاد الجذر التربيعي ل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 هي قيمة تقريبية أفضل للجذر التربيعي لـ 3 بدلاً من 1.7
الطريقة التي يستخدمها الكود الموجود على هذا الرابط الذي قدمته تعمل عن طريق أخذ تقدير تقريبي أولي واستخدامه لحساب a أحسن تقريب.
وهذا ما يسمى طريقة نيوتن، ويمكنك تكرار العملية الحسابية مع كل عملية تقريبية جديدة حتى انها دقيقة بما فيه الكفاية بالنسبة لك.
في الواقع هناك يجب تكون هناك طريقة ما لتحديد متى يتم إيقاف التكرار وإلا فإنه سيستمر إلى الأبد.
عادة ستتوقف عندما يكون الفرق بين التقديرات تقريبية أقل من القيمة التي تقررها.
يحرر:لا أعتقد أنه يمكن أن يكون هناك تطبيق أبسط من التطبيقين اللذين وجدتهما بالفعل.
ومعكوس، كما يقول اسمها، ولكن في بعض الأحيان "قريبة بما فيه الكفاية" هو "قريبة بما فيه الكفاية". مثيرة للاهتمام قراءة على أي حال.
وهناك حل بسيط يمكن أن تتعامل مع الجذر تعويم الساحة والدقة التعسفي استخدام البحث الثنائي
ومشفرة في روبي
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.سنقول أ = 2، و س = 1.5.لحساب تقدير أفضل، سنقوم بتقسيم a على x.وهذا يعطي قيمة جديدة ص = 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;
}
تحدد إبسيلون مدى دقة التقريب المطلوب.يجب أن تقوم الدالة بإرجاع التقريب الأول x الذي تحصل عليه والذي يرضي abs(x*x - a) < epsilon، حيث abs(x) هي القيمة المطلقة لـ x.
square_root(2, 1e-6)
Output: 1.4142141342163086
وكذلك هناك بالفعل عدد غير قليل من الإجابات، ولكن هنا يذهب الألغام انها أبسط قطعة من رمز (بالنسبة لي) أكثر، وهنا في خوارزمية للحصول على ذلك.
والتعليمات البرمجية في بيثون 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);
}
