මගේ පිළිතුර තරමක් දිගු බැවින් මම එය කොටස් තුනකට බෙදා ඇත්තෙමි. ප්රශ්නය පාවෙන ලක්ෂ්ය ගණිතය පිළිබඳ බැවින්, යන්ත්‍රය ඇත්ත වශයෙන්ම කරන්නේ කුමක්ද යන්න පිළිබඳව මම අවධාරණය කර ඇත්තෙමි. මම එය ද්විත්ව (බිට් 64) නිරවද්‍යතාවයට විශේෂිත කර ඇත, නමුත් තර්කය ඕනෑම පාවෙන ලක්ෂ්ය ගණිතයකට සමානව අදාළ වේ.
පෙරවදන
ක IEEE 754 ද්විත්ව නිරවද්යතාවයකින් ද්විමය ඉපිලුම් ලක්ෂ්ය ආකෘතිය (binary64) අංකය ආකෘති ගණනාවක් නියෝජනය
අගය = (-1) ^ s * (1.m 51 m 50 ... m 2 m 1 m 0 ) 2 * 2 e-1023
බිටු 64 කින්:
- පළමු බිට් යනු සං bit ා බිට් ය :
1අංකය negative ණ නම්, 0එසේ නොමැති නම් 1 .
- ඊළඟ බිටු 11 වේ නිපුනයා වන, හිලව් 1023. විසින් වෙනත් වචන වලින් කිවහොත්, ද්විත්ව නිරවද්යතාවයකින් අංකය සිට නිපුනයා බිටු කියවීමෙන් පසු, 1023 දෙකක බලය ලබා ගැනීම සඳහා ශේෂයෙන් අඩු කළ යුතුය.
- ඉතිරි බිටු 52 යනු වැදගත්කම (හෝ මැන්ටිස්සා) ය. මැන්ටිස්සා හි, ඕනෑම ද්විමය අගයක වඩාත්ම වැදගත් කොටස වන බැවින් 'ඇඟවුම්'
1.සෑම විටම 2 මඟ හැරී ඇත 1.
1 - IEEE 754 වන සංකල්පය සඳහා ඉඩ අත්සන් ශුන්ය - +0හා -0වෙනස් ප්රතිකාර ඇත: 1 / (+0)ධනාත්මක අනන්තය ය; 1 / (-0)negative ණ අනන්තය. ශුන්ය අගයන් සඳහා, මැන්ටිස්සා සහ on ාතීය බිටු සියල්ලම ශුන්ය වේ. සටහන: ශුන්ය අගයන් (+0 සහ -0) පැහැදිලිවම 2 ලෙස වර්ගීකරණය කර නොමැත .
2 - ශුන්‍යයේ ඕෆ්සෙට් on ාතයක් (සහ ගම්‍ය වන 0.) ඇති සංඛ්‍යාත්මක සංඛ්යා සඳහා මෙය නොවේ . නිත්‍ය ද්විත්ව නිරවද්‍යතා සංඛ්යා පරාසය d min ≤ | x | Min d max , මෙහි d min (කුඩාම නිරූපණය කළ හැකි නොවන අංකය) 2 -1023 - 51 (≈ 4.94 * 10 -324 ) සහ d max (විශාලතම නිත්‍ය අංකය, මැන්ටිස්සා මුළුමනින්ම 1s වලින් සමන්විත වේ ) 2 -1023 + 1 - 2 -1023 - 51 (≈ 2.225 * 10 -308 ).
ද්විත්ව නිරවද්‍යතා සංඛ්යාවක් ද්විමය බවට හැරවීම
ද්විත්ව නිරවද්යතාවයකින් යුත් පාවෙන ලක්ෂ්ය සංඛ්යාවක් ද්විමය බවට පරිවර්තනය කිරීම සඳහා බොහෝ මාර්ගගත පරිවර්තකයන් පවතී (උදා: binaryconvert.com හි ), නමුත් මෙහි ද්විත්ව නිරවද්‍යතා අංකයක් සඳහා IEEE 754 නිරූපණය ලබා ගැනීම සඳහා සාම්පල C # කේතයක් ඇත (මම කොටස් තුන කොලෝන් සමඟ වෙන් කරමි ( :) :
public static string BinaryRepresentation(double value)
{
long valueInLongType = BitConverter.DoubleToInt64Bits(value);
string bits = Convert.ToString(valueInLongType, 2);
string leadingZeros = new string('0', 64 - bits.Length);
string binaryRepresentation = leadingZeros + bits;
string sign = binaryRepresentation[0].ToString();
string exponent = binaryRepresentation.Substring(1, 11);
string mantissa = binaryRepresentation.Substring(12);
return string.Format("{0}:{1}:{2}", sign, exponent, mantissa);
}
කාරණය වෙත ළඟා වීම: මුල් ප්රශ්නය
(TL; DR අනුවාදය සඳහා පහළට යන්න)
කැටෝ ජොන්ස්ටන් (ප්‍රශ්න අසන්නා) ඇසුවේ ඇයි 0.1 + 0.2! = 0.3.
ද්විමය වශයෙන් ලියා ඇත (කොලෝන් කොටස් තුන වෙන් කරයි), IEEE 754 අගයන් නිරූපණය කරන්නේ:
0.1 => 0:01111111011:1001100110011001100110011001100110011001100110011010
0.2 => 0:01111111100:1001100110011001100110011001100110011001100110011010
මැන්ටිස්සා පුනරාවර්තන ඉලක්කම් වලින් සමන්විත බව සලකන්න 0011. මේ ප්රධාන ගණනය කිරීම් කිසිදු දෝෂයක් වන්නේ ඇයි කිරීමට - 0.1, 0.2 හා 0.3 ද්විමය නියෝජනය කළ නොහැකි හරියටම දී පරිමිත ද්විමය බිට් ගණන වැඩි ඕනෑම 1/9 ට වඩා, 1/3 හෝ 1/7 තුල හරියටම නියෝජනය කළ හැකි දශම සංඛ්යා .
අපට on ාතයේ බලය 52 කින් අඩු කළ හැකි අතර ද්විමය නිරූපණයේ ලක්ෂ්‍යය ස්ථාන 52 කින් දකුණට මාරු කළ හැකිය (10 -3 * 1.23 == 10 -5 * 123 වැනි). එවිට ද්විමය නිරූපණය * 2 p ස්වරූපයෙන් නිරූපණය වන නිශ්චිත අගය ලෙස නිරූපණය කිරීමට මෙය අපට හැකියාව ලබා දෙයි . මෙහි 'a' යනු පූර්ණ සංඛ්යාවක් වේ.
On ාතයන් දශමයට පරිවර්තනය කිරීම, ඕෆ්සෙට් ඉවත් කිරීම සහ ඇඟවුම් කළ 1(වර්ග වරහන් වල) නැවත එකතු කිරීම , 0.1 සහ 0.2:
0.1 => 2^-4 * [1].1001100110011001100110011001100110011001100110011010
0.2 => 2^-3 * [1].1001100110011001100110011001100110011001100110011010
or
0.1 => 2^-56 * 7205759403792794 = 0.1000000000000000055511151231257827021181583404541015625
0.2 => 2^-55 * 7205759403792794 = 0.200000000000000011102230246251565404236316680908203125
අංක දෙකක් එකතු කිරීම සඳහා, on ාතකය සමාන විය යුතුය, එනම්:
0.1 => 2^-3 * 0.1100110011001100110011001100110011001100110011001101(0)
0.2 => 2^-3 * 1.1001100110011001100110011001100110011001100110011010
sum = 2^-3 * 10.0110011001100110011001100110011001100110011001100111
or
0.1 => 2^-55 * 3602879701896397 = 0.1000000000000000055511151231257827021181583404541015625
0.2 => 2^-55 * 7205759403792794 = 0.200000000000000011102230246251565404236316680908203125
sum = 2^-55 * 10808639105689191 = 0.3000000000000000166533453693773481063544750213623046875
එකතුව 2 n * 1 ආකාරයෙන් නොවන බැවින් {bbb} අපි on ාතකය එකකින් වැඩි කර දශම ( ද්විමය ) ලක්ෂ්‍යය ලබා ගැනීමට මාරු කරමු :
sum = 2^-2 * 1.0011001100110011001100110011001100110011001100110011(1)
= 2^-54 * 5404319552844595.5 = 0.3000000000000000166533453693773481063544750213623046875
දැන් මැන්ටිස්සා හි බිටු 53 ක් ඇත (53 වන කොටස ඉහත පේළියේ වර්ග වරහන් වල ඇත). පෙරනිමි මාදිලිය යයි වරදවා වටහා IEEE 754 සඳහා 'යනු ළඟම වටය ' - එනම්, අංකය x අගයන් දෙක අතර වැටෙන වූ සහ ආ , අවම වශයෙන් සැලකිය යුතු ටිකක් ශූන්ය වටිනාකම තෝරා ගනු ලැබේ.
a = 2^-54 * 5404319552844595 = 0.299999999999999988897769753748434595763683319091796875
= 2^-2 * 1.0011001100110011001100110011001100110011001100110011
x = 2^-2 * 1.0011001100110011001100110011001100110011001100110011(1)
b = 2^-2 * 1.0011001100110011001100110011001100110011001100110100
= 2^-54 * 5404319552844596 = 0.3000000000000000444089209850062616169452667236328125
A සහ b වෙනස් වන්නේ අවසාන බිට් එකෙන් පමණක් බව සලකන්න ; ...0011+ 1= ...0100. මෙම අවස්ථාවෙහිදී, අවම වශයෙන් සැලකිය යුතු බිංදුවක් සහිත අගය b වේ , එබැවින් එකතුව:
sum = 2^-2 * 1.0011001100110011001100110011001100110011001100110100
= 2^-54 * 5404319552844596 = 0.3000000000000000444089209850062616169452667236328125
0.3 හි ද්විමය නිරූපණය:
0.3 => 2^-2 * 1.0011001100110011001100110011001100110011001100110011
= 2^-54 * 5404319552844595 = 0.299999999999999988897769753748434595763683319091796875
එය වෙනස් වන්නේ 0.1 සහ 0.2 එකතුව 2 -54 හි ද්විමය නිරූපණයට පමණි .
0.1 සහ 0.2 යන ද්විමය නිරූපණය IEEE 754 මගින් අවසර දී ඇති සංඛ්යා වල වඩාත් නිවැරදි නිරූපණයන් වේ. පෙරනිමි වටකුරු මාදිලිය හේතුවෙන් මෙම නිරූපණයන් එකතු කිරීම මඟින් ප්‍රති results ල ලැබෙන්නේ අවම-වැදගත්-බිට් වලින් පමණක් වෙනස් වන අගයෙනි.
ටීඑල්; ඩී.ආර්
0.1 + 0.2අයිඊඊඊ 754 ද්විමය නිරූපණයකින් ලිවීම (කොලෝන් කොටස් තුන වෙන් කරයි) සහ එය සංසන්දනය කිරීමේදී 0.3, මෙය (මම විශේෂිත බිටු වර්ග වරහන් වල දමා ඇත):
0.1 + 0.2 => 0:01111111101:0011001100110011001100110011001100110011001100110[100]
0.3 => 0:01111111101:0011001100110011001100110011001100110011001100110[011]
නැවත දශමයට හරවන විට, මෙම අගයන්:
0.1 + 0.2 => 0.300000000000000044408920985006...
0.3 => 0.299999999999999988897769753748...
වෙනස හරියටම 2 -54 වන අතර එය ~ 5.5511151231258 × 10 -17 - මුල් අගයන් හා සසඳන විට වැදගත් නොවේ (බොහෝ යෙදුම් සඳහා).
පාවෙන ලක්ෂ්ය අංකයක අවසාන බිටු සංසන්දනය කිරීම සහජයෙන්ම භයානක ය, මන්දයත් “ සෑම පරිගණක විද්‍යා ist යෙක්ම පාවෙන ලක්ෂ්ය අංක ගණිතය ගැන දැනගත යුතු දේ ” (මෙම පිළිතුරේ සියලුම ප්රධාන කොටස් ආවරණය කරන) කියවන ඕනෑම කෙනෙකුට දැනගත හැකි වනු ඇත.
බොහෝ කැල්කියුලේටරයන් මෙම ගැටළුව මඟහරවා ගැනීම සඳහා අතිරේක ආරක්ෂක ඉලක්කම් භාවිතා කරයි , එය 0.1 + 0.2ලබා දෙන්නේ කෙසේද 0.3: අවසාන බිටු කිහිපය වටකුරු ය.
