.NET හි දශම, පාවෙන සහ දෙගුණයක් අතර වෙනස?

අතර ඇති වෙනස කුමක්ද decimal, floatහා double.NET දී?

කවුරුහරි මේවායින් එකක් භාවිතා කරන්නේ කවදාද?

floatහා doubleකරන පාවෙන ද්විමය අවස්ථාවක වර්ග . වෙනත් වචන වලින් කිවහොත්, ඔවුන් මෙවැනි සංඛ්‍යාවක් නියෝජනය කරයි:

10001.10010110011

ද්විමය අංකය සහ ද්විමය ලක්ෂ්‍යයේ පිහිටීම යන දෙකම අගය තුළ කේතනය කර ඇත.

decimalයනු පාවෙන දශම ස්ථානය වර්ගය . වෙනත් වචන වලින් කිවහොත්, ඔවුන් මෙවැනි සංඛ්‍යාවක් නියෝජනය කරයි:

12345.65789

නැවතත්, දශම ලක්ෂයේ අංකය සහ පිහිටීම යන දෙකම අගය තුළ කේතනය කර ඇත - decimalඑය ස්ථාවර ලක්ෂ්‍ය වර්ගයක් වෙනුවට පාවෙන ලක්ෂ්‍ය වර්ගයක් බවට පත් කරයි .

සැලකිල්ලට ගත යුතු වැදගත්ම දෙය නම් පූර්ණ සංඛ්‍යා නොවන දේ දශම ස්වරූපයෙන් නිරූපණය කිරීමට මිනිසුන් පුරුදු වී ඇති අතර දශම නිරූපණයන්හි නිශ්චිත ප්‍රති results ල අපේක්ෂා කිරීමයි; ද්විමය පාවෙන ලක්ෂ්‍යයේ සියලුම දශම සංඛ්‍යා හරියටම නිරූපණය කළ නොහැක - උදාහරණයක් ලෙස - 0.1, එබැවින් ඔබ ද්විමය පාවෙන ලක්ෂ්‍ය අගයක් භාවිතා කරන්නේ නම් ඔබට ඇත්ත වශයෙන්ම 0.1 ට ආසන්න අගයක් ලැබෙනු ඇත. පාවෙන දශම ලක්ෂ්‍යයක් භාවිතා කරන විට ඔබට තවමත් ආසන්න අගයන් ලැබෙනු ඇත - උදාහරණයක් ලෙස 1 න් 3 න් බෙදීමේ ප්‍රති result ලය හරියටම නිරූපණය කළ නොහැක.

විට භාවිතා කළ යුතු දේ සඳහා:

• “ස්වාභාවිකවම නිශ්චිත දශම” වන අගයන් සඳහා භාවිතා කිරීම හොඳයි decimal. මෙය සාමාන්‍යයෙන් මිනිසුන් විසින් නිර්මාණය කරන ලද ඕනෑම සංකල්පයකට සුදුසු ය: මූල්‍යමය අගයන් වඩාත්ම පැහැදිලි උදාහරණය වන නමුත් අනෙක් ඒවා ද තිබේ. උදාහරණයක් ලෙස කිමිදුම්කරුවන්ට හෝ අයිස් ස්කේටරයට ලබා දී ඇති ලකුණු සලකා බලන්න.

• කෙසේ හෝ හරියටම මැනිය නොහැකි සොබාදහමේ වඩා පුරාවස්තු වන අගයන් සඳහා , float/ doubleවඩාත් යෝග්‍ය වේ. උදාහරණයක් ලෙස, විද්‍යාත්මක දත්ත සාමාන්‍යයෙන් මෙම ස්වරූපයෙන් නිරූපණය කෙරේ. මෙන්න, මුල් අගයන් ආරම්භ කිරීම සඳහා "දශම නිරවද්‍ය" නොවනු ඇත, එබැවින් අපේක්ෂිත ප්‍රති results ල "දශම නිරවද්‍යතාව" පවත්වා ගැනීම වැදගත් නොවේ. පාවෙන ද්විමය ලක්ෂ්‍ය වර්ග දශමයට වඩා වැඩ කිරීමට වේගවත්ය.

නිරවද්යතාව ප්රධාන වෙනසයි.

පාවෙන - ඉලක්කම් 7 (බිට් 32)

ද්විත්ව -15-16 ඉලක්කම් (බිට් 64)

දශම -28-29 සැලකිය යුතු ඉලක්කම් (බිට් 128)

දශම වලට වඩා වැඩි නිරවද්‍යතාවයක් ඇති අතර සාමාන්‍යයෙන් ඉහළ නිරවද්‍යතාවයක් අවශ්‍ය මූල්‍ය යෙදුම් තුළ භාවිතා වේ. ද්විත්ව / පාවීමට වඩා දශමයන් (සමහර පරීක්ෂණ වලදී 20X ගුණයක් දක්වා) මන්දගාමී වේ.

වාත්තු කිරීමකින් තොරව දශම හා පාවෙන / ද්විත්ව සංසන්දනය කළ නොහැකි අතර පාවෙන සහ ද්විත්ව විය හැකිය. දශම සංඛ්‍යා මඟින් කේතීකරණ හෝ පසුපස ශුන්‍යයන්ට ඉඩ ලබා දේ.

float flt = 1F/3;
double dbl = 1D/3;
decimal dcm = 1M/3;
Console.WriteLine("float: {0} double: {1} decimal: {2}", flt, dbl, dcm);

ප්‍රති ult ලය:

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

වටකුරුකරණයට සාපේක්ෂව නොඉවසන නිරවද්‍යතාව අවශ්‍ය වන මූල්‍ය ගණනය කිරීම් සඳහා දශම ව්‍යුහය තදින්ම සකසා ඇත. විද්‍යාත්මක යෙදුම් සඳහා දශම ප්‍රමාණවත් නොවේ, කෙසේ වෙතත්, හේතු කිහිපයක් නිසා:

• භෞතික ගැටලුවේ ප්‍රායෝගික සීමාවන් හෝ කෞතුක වස්තු මැනීම නිසා බොහෝ විද්‍යාත්මක ගණනය කිරීම් වලදී නිශ්චිත නිරවද්‍යතාවයක් නැතිවීම පිළිගත හැකිය. මූල්‍යමය වශයෙන් නිරවද්‍යතාව නැතිවීම පිළිගත නොහැකිය.
• බොහෝ මෙහෙයුම් සඳහා දශම බොහෝ (බොහෝ) මන්දගාමී වන අතර බොහෝ දුරට පාවෙන ලක්ෂ්‍ය මෙහෙයුම් ද්විමය වශයෙන් සිදු කෙරෙන අතර දශම දේවල් 10 වන පාදයේ සිදු කරයි (එනම් පාවෙන හා යුගල හසුරුවනු ලබන්නේ එම්එම්එක්ස් / එස්එස්ඊ වැනි FPU දෘඩාංග විසිනි. මෘදුකාංගයෙන් දශම ගණනය කරනු ලැබේ).
• නිරවද්‍යතාවයේ වැඩි ඉලක්කම් සඳහා සහය දක්වුවද, දශමයට දෙගුණයකට වඩා පිළිගත නොහැකි තරම් කුඩා අගයක් ඇත. එබැවින් බොහෝ විද්‍යාත්මක අගයන් නිරූපණය කිරීමට දශම භාවිතා කළ නොහැක.

+---------+----------------+---------+----------+---------------------------------------------+
| C#      | .Net Framework | Signed? | Bytes    | Possible Values                             |
| Type    | (System) type  |         | Occupied |                                             |
+---------+----------------+---------+----------+---------------------------------------------+
| sbyte   | System.Sbyte   | Yes     | 1        | -128 to 127                                 |
| short   | System.Int16   | Yes     | 2        | -32768 to 32767                             |
| int     | System.Int32   | Yes     | 4        | -2147483648 to 2147483647                   |
| long    | System.Int64   | Yes     | 8        | -9223372036854775808 to 9223372036854775807 |
| byte    | System.Byte    | No      | 1        | 0 to 255                                    |
| ushort  | System.Uint16  | No      | 2        | 0 to 65535                                  |
| uint    | System.UInt32  | No      | 4        | 0 to 4294967295                             |
| ulong   | System.Uint64  | No      | 8        | 0 to 18446744073709551615                   |
| float   | System.Single  | Yes     | 4        | Approximately ±1.5 x 10-45 to ±3.4 x 1038   |
|         |                |         |          |  with 7 significant figures                 |
| double  | System.Double  | Yes     | 8        | Approximately ±5.0 x 10-324 to ±1.7 x 10308 |
|         |                |         |          |  with 15 or 16 significant figures          |
| decimal | System.Decimal | Yes     | 12       | Approximately ±1.0 x 10-28 to ±7.9 x 1028   |
|         |                |         |          |  with 28 or 29 significant figures          |
| char    | System.Char    | N/A     | 2        | Any Unicode character (16 bit)              |
| bool    | System.Boolean | N/A     | 1 / 2    | true or false                               |
+---------+----------------+---------+----------+---------------------------------------------+

වැඩි විස්තර සඳහා මෙහි බලන්න .

වෙනත් පිළිතුරු සහ අදහස් වලින් දැනටමත් පිළිතුරු දී ඇති හොඳ (හා නරක) තොරතුරු ටොන් ගණනක් මම නැවත නොකියමි, නමුත් මම ඔබේ පසු විපරම් ප්‍රශ්නයට ඉඟියක් සමඟ පිළිතුරු දෙන්නෙමි:

කවුරුහරි මේවායින් එකක් භාවිතා කරන්නේ කවදාද?

ගණන් කළ අගයන් සඳහා දශම භාවිතා කරන්න

මනින ලද අගයන් සඳහා පාවෙන / ද්විත්ව භාවිතා කරන්න

උදාහරණ කිහිපයක්:

• මුදල් (අපි මුදල් ගණන් කරනවාද නැත්නම් මුදල් මැන බලනවාද?)

• දුර (අපි දුර ගණන් කරනවාද නැත්නම් දුර මැන බලනවාද? *)

• ලකුණු (අපි ලකුණු ගණන් කරනවාද නැත්නම් ලකුණු මනිනවාද?)

අපි සෑම විටම මුදල් ගණන් කරන අතර එය කිසි විටෙකත් මැනිය යුතු නැත. අපි සාමාන්‍යයෙන් දුර මැනීම. අපි බොහෝ විට ලකුණු ගණන් කරමු.

* සමහර අවස්ථාවලදී, මම නාමික දුර ලෙස හඳුන්වන දෙය , ඇත්ත වශයෙන්ම අපට දුර ගණනය කිරීමට අවශ්‍ය විය හැකිය. උදාහරණයක් ලෙස, සමහර විට අපි නගර වලට දුර පෙන්වන රට සං signs ා සමඟ කටයුතු කරන අතර, එම දුර කිසි විටෙකත් දශම සංඛ්‍යා එකකට වඩා (xxx.x km) නොමැති බව අපි දනිමු.

float නිරවද්යතාවයේ ඉලක්කම් 7 ක්

double නිරවද්‍යතාවයේ ඉලක්කම් 15 ක් පමණ ඇත

decimal නිරවද්‍යතාවයේ ඉලක්කම් 28 ක් පමණ ඇත

ඔබට වඩා හොඳ නිරවද්‍යතාවයක් අවශ්‍ය නම්, පාවෙන වෙනුවට දෙගුණයක් භාවිතා කරන්න. නූතන CPU වල දත්ත වර්ග දෙකම එකම ක්‍රියාකාරීත්වයක් ඇත. පාවෙන භාවිතා කිරීමේ එකම පරමාර්ථය වන්නේ ඔවුන් අඩු ඉඩ ප්‍රමාණයක් ගැනීමයි. ප්‍රායෝගිකව වැදගත් වන්නේ ඔබ ඒවායින් බොහොමයක් ලබාගෙන ඇත්නම් පමණි.

මෙය සිත්ගන්නා සුළු බව මට පෙනී ගියේය. පාවෙන ලක්ෂ්‍ය අංක ගණිතය පිළිබඳව සෑම පරිගණක විද්‍යා ist යෙක්ම දැනගත යුතු දේ

කිසිවෙකු ඒ ගැන සඳහන් කර නැත

පෙරනිමි සැකසුම් වලදී, පාවෙන (System.Single) සහ යුගල (System.Double) කිසි විටෙකත් පිටාර ගැලීම් පරික්ෂා නොකරන අතර දශම (System.Decimal) සෑම විටම පිටාර ගැලීම් පරීක්ෂා කිරීම භාවිතා කරයි.

මම අදහස් කළේ

decimal myNumber = decimal.MaxValue;
myNumber += 1;

OverflowException විසි කරයි .

නමුත් මේවා එසේ නොවේ:

float myNumber = float.MaxValue;
myNumber += 1;

සහ

double myNumber = double.MaxValue;
myNumber += 1;

1. සම්පාදනය හා ධාවන වේලාව යන දෙකෙහිම ව්‍යතිරේකයකින් තොරව ද්විත්ව හා පාවෙන සංඛ්‍යා පූර්ණ ශුන්‍යයෙන් බෙදිය හැකිය.
2. දශම සංඛ්‍යා පූර්ණ ශුන්‍යයෙන් බෙදිය නොහැක. ඔබ එය කරන්නේ නම් සම්පාදනය සැමවිටම අසාර්ථක වනු ඇත.

පූර්ණ සංඛ්‍යා, සඳහන් කළ පරිදි, සම්පූර්ණ සංඛ්‍යා වේ. .7, .42, සහ .007 වැනි දෙයක් ඔවුන්ට ගබඩා කළ නොහැක. සම්පූර්ණ සංඛ්‍යා නොවන සංඛ්‍යා ගබඩා කිරීමට ඔබට අවශ්‍ය නම්, ඔබට වෙනත් ආකාරයේ විචල්‍යයක් අවශ්‍ය වේ. ඔබට ද්විත්ව වර්ගය හෝ පාවෙන වර්ගය භාවිතා කළ හැකිය. ඔබ මෙම වර්ගවල විචල්‍යයන් එකම ආකාරයකින් සකසා ඇත: වචනය භාවිතා කරනවා වෙනුවට int, ඔබ ටයිප් කරන්න doubleහෝ float. මෙවැනි:

float myFloat;
double myDouble;

( float"පාවෙන ලක්ෂ්‍යය" සඳහා කෙටි වන අතර, එයින් අදහස් කරන්නේ ලක්ෂ්‍යයක් සහිත අංකයක් අවසානයේ ඇති බවයි.)

මේ දෙක අතර වෙනස ඇත්තේ ඔවුන්ට රඳවා ගත හැකි සංඛ්‍යා ප්‍රමාණයෙනි. මක්නිසාද යත් float, ඔබේ අංකයේ ඉලක්කම් 7 ක් දක්වා තිබිය හැකිය. සඳහා doubles, ඔබ ඉලක්කම් 16 දක්වා විය හැකිය. වඩාත් නිවැරදිව කිවහොත්, නිල ප්‍රමාණය මෙන්න:

float:  1.5 × 10^-45  to 3.4 × 10^38  
double: 5.0 × 10^-324 to 1.7 × 10^308

float32-බිට් අංකයක් වන අතර doubleඑය 64-බිට් අංකයකි.

කේතය ලබා ගැනීමට ඔබගේ නව බොත්තම දෙවරක් ක්ලික් කරන්න. ඔබගේ බොත්තම් කේතයට පහත පේළි තුන එක් කරන්න:

double myDouble;
myDouble = 0.007;
MessageBox.Show(myDouble.ToString());

ඔබගේ වැඩසටහන නවතා කේතීකරණ කවුළුව වෙත ආපසු යන්න. මෙම රේඛාව වෙනස් කරන්න:

myDouble = 0.007;
myDouble = 12345678.1234567;

ඔබේ වැඩසටහන ක්‍රියාත්මක කර ඔබේ ද්විත්ව බොත්තම ක්ලික් කරන්න. පණිවිඩ කොටුව නිවැරදිව අංකය පෙන්වයි. කෙසේ වෙතත් අවසානයේ තවත් අංකයක් එක් කරන්න, එවිට C # නැවත ඉහළට හෝ පහළට එනු ඇත. සදාචාරය නම් ඔබට නිරවද්‍යතාවය අවශ්‍ය නම් වටයෑමෙන් ප්‍රවේශම් වන්න!

• පාවෙන: ± 1.5 x 10 ^ -45 සිට ± 3.4 x 10 ^ 38 (~ 7 සැලකිය යුතු සංඛ්‍යා
• ද්විත්ව: ± 5.0 x 10 ^ -324 සිට ± 1.7 x 10 ^ 308 (15-16 සැලකිය යුතු සංඛ්‍යා)
• දශම: ± 1.0 x 10 ^ -28 සිට ± 7.9 x 10 ^ 28 (සැලකිය යුතු සංඛ්‍යා 28-29)

මෙය මට සිත්ගන්නා සුළු නූලක් වී ඇත, අද මෙන්, අප සතුව ඇත්තේ ඉතා කුඩා දෝෂයකි, decimala ට වඩා අඩු නිරවද්‍යතාවයක් තිබීම සම්බන්ධයෙන් float.

අපගේ C # කේතයේ, අපි එක්සෙල් පැතුරුම්පතකින් සංඛ්‍යාත්මක අගයන් කියවමින් ඒවා a බවට පරිවර්තනය කර SQL සේවාදායක දත්ත ගබඩාවකට සුරැකීම සඳහා decimalමෙය decimalනැවත සේවාවක් වෙත යවමු .

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    decimal value = 0;
    Decimal.TryParse(cellValue.ToString(), out value);
}

දැන්, අපගේ එක්සෙල් අගයන් සියල්ලම පාහේ මෙය ලස්සනට ක්‍රියාත්මක විය. නමුත් සමහර අයට ඉතා කුඩා එක්සෙල් අගයන්, decimal.TryParseනැතිවූ අගය සම්පූර්ණයෙන්ම භාවිතා කිරීම. එවැනි එක් උදාහරණයක්

• cellValue = 0.00006317592

• Decimal.TryParse (cellValue.ToString (), පිටත අගය); // නැවත 0 වනු ඇත

විකාර සහගත ලෙස විසඳුම වූයේ එක්සෙල් අගයන් doubleපළමුව, පසුව a බවට පරිවර්තනය කිරීමයි decimal.

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    double valueDouble = 0;
    double.TryParse(cellValue.ToString(), out valueDouble);
    decimal value = (decimal) valueDouble;
    …
}

doubleA ට වඩා අඩු නිරවද්‍යතාවයක් තිබුණද decimal, මෙය සැබවින්ම සහතික කරන ලද කුඩා සංඛ්‍යාවක් තවමත් හඳුනා ගනු ඇත. කිසියම් හේතුවක් නිසා, double.TryParseඇත්ත වශයෙන්ම එවැනි කුඩා සංඛ්‍යා ලබා ගැනීමට හැකි වූ අතර decimal.TryParseඒවා ශුන්‍යයට සකසනු ඇත.

අමුතුයි. හරිම අමුතුයි.

මතකය සහ ක්‍රියාකාරිත්වය යන දෙකම තීරණාත්මක වන ක්‍රීඩා සහ කාවැද්දූ පද්ධති වැනි යෙදුම් සඳහා, පාවීම සාමාන්‍යයෙන් සංඛ්‍යාත්මක තේරීම වන අතර එය වේගවත් වන අතර ද්විත්ව ප්‍රමාණයෙන් අඩකි. පූර්ණ සංඛ්‍යා තේරීමේ ආයුධය ලෙස භාවිතා කර ඇත, නමුත් පාවෙන ලක්ෂ්‍ය ක්‍රියාකාරිත්වය නවීන ප්‍රොසෙසරවල පූර්ණ සංඛ්‍යා ඉක්මවා ඇත. දශම ඉවරයි!

දශම, ද්විත්ව සහ පාවෙන විචල්‍ය වර්ග ඒවා අගයන් ගබඩා කරන ආකාරයට වෙනස් වේ. පාවීම යනු තනි නිරවද්‍යතාව (බිට් 32) පාවෙන ලක්ෂ්‍ය දත්ත වර්ගයකි, ද්විත්ව යනු ද්විත්ව නිරවද්‍යතාව (බිට් 64) පාවෙන ලක්ෂ්‍ය දත්ත වර්ගය සහ දශම යනු බිට් 128 පාවෙන ලක්ෂ්‍ය දත්ත වර්ගයකි.

පාවෙන - බිට් 32 (ඉලක්කම් 7)

ද්විත්ව - බිට් 64 (ඉලක්කම් 15-16)

දශම - බිට් 128 (සැලකිය යුතු ඉලක්කම් 28-29)

වැඩි විස්තර ... දශම, පාවෙන සහ ද්විත්ව අතර වෙනස

මෙම සියලු වර්ගවල ගැටළුව නම්, කිසියම් නිරවද්‍යතාවයක් නොපවතින අතර පහත දැක්වෙන උදාහරණයේ දී මෙන් කුඩා දශම සංඛ්‍යා සමඟ මෙම ගැටළුව ඇතිවිය හැකිය.

Dim fMean as Double = 1.18
Dim fDelta as Double = 0.08
Dim fLimit as Double = 1.1

If fMean - fDelta < fLimit Then
    bLower = True
Else
    bLower = False
End If

ප්‍රශ්නය: bLower විචල්‍යයේ අඩංගු අගය කුමක්ද?

පිළිතුර: බිට් 32 යන්ත්‍රයක bLower හි සත්‍යය අඩංගු වේ !!!

මම ඩබල් විසින් දශමයෙන් ආදේශ කළහොත්, bLower හි FALSE අඩංගු වන අතර එය හොඳ පිළිතුරකි.

දෙගුණයකින්, ගැටළුව වන්නේ fMean-fDelta = 1.09999999999 එය 1.1 ට වඩා අඩු වීමයි.

අවවාදයයි: වෙනත් සංඛ්‍යාවක් සඳහා ද එම ගැටළුව නිසැකවම පැවතිය හැකි යැයි මම සිතමි, මන්ද දශම යනු ඉහළ නිරවද්‍යතාවයකින් යුත් දෙගුණයක් පමණක් වන අතර නිරවද්‍යතාවයට සෑම විටම සීමාවක් ඇත.

ඇත්ත වශයෙන්ම, ද්විත්ව, පාවෙන සහ දශම COBOL හි ද්විමය දශමයට අනුරූප වේ!

COBOL හි ක්‍රියාත්මක කර ඇති වෙනත් සංඛ්‍යා වර්ග .Net හි නොවීම කනගාටුවට කරුණකි. COBOL නොදන්නා අය සඳහා, COBOL හි සංඛ්‍යාත්මක වර්ගයක් ඇත

BINARY or COMP like float or double or decimal
PACKED-DECIMAL or COMP-3 (2 digit in 1 byte)
ZONED-DECIMAL (1 digit in 1 byte) 

සරල වචන වලින්:

1. දශම, ද්විත්ව සහ පාවෙන විචල්‍ය වර්ග ඒවා අගයන් ගබඩා කරන ආකාරයට වෙනස් වේ.
2. නිරවද්‍යතාවය ප්‍රධාන වෙනසයි (මෙය තනි වෙනසක් නොවන බව සලකන්න) පාවෙන යනු තනි නිරවද්‍යතාව (බිට් 32) පාවෙන ලක්ෂ්‍ය දත්ත වර්ගය, ද්විත්ව ද්විත්ව නිරවද්‍යතාව (බිට් 64) පාවෙන ලක්ෂ්‍ය දත්ත වර්ගය සහ දශම 128-බිට් පාවෙන ලක්ෂ්‍ය දත්ත වර්ගය.
3. සාරාංශ වගුව:

/==========================================================================================
    Type       Bits    Have up to                   Approximate Range 
/==========================================================================================
    float      32      7 digits                     -3.4 × 10 ^ (38)   to +3.4 × 10 ^ (38)
    double     64      15-16 digits                 ±5.0 × 10 ^ (-324) to ±1.7 × 10 ^ (308)
    decimal    128     28-29 significant digits     ±7.9 x 10 ^ (28) or (1 to 10 ^ (28)
/==========================================================================================

මේ සෑම එකක් අතර ඇති ප්‍රධාන වෙනස වන්නේ නිරවද්‍යතාවයයි.

floatයනු 32-bit, සංඛ්යාව doubleයනු 64-bitඅංකය හා decimalයනු 128-bitසංඛ්යාව.

• දශම 128 බිට් (සැලකිය යුතු ඉලක්කම් 28-29) මූල්‍ය යෙදුම් සම්බන්ධයෙන් දශම වර්ග භාවිතා කිරීම වඩා හොඳ බැවින් එය ඔබට ඉහළ මට්ටමේ නිරවද්‍යතාවයක් සහ වටකුරු දෝෂ වළක්වා ගැනීමට පහසුය. නිරවද්‍යතාව අවශ්‍ය වන පූර්ණ සංඛ්‍යා නොවන ගණිතය සඳහා දශම භාවිතා කරන්න (උදා. මුදල් සහ මුදල්)

• ද්විත්ව 64 බිට් (ඉලක්කම් 15-16) මුදල් හැසිරවීම හැර සැබෑ අගයන් සඳහා සාමාන්‍යයෙන් භාවිතා වන දත්ත වර්ගය ද්විත්ව වර්ග වේ. වඩාත්ම නිවැරදි පිළිතුර අවශ්‍ය නොවන පූර්ණ සංඛ්‍යා නොවන ගණිතය සඳහා දෙවරක් භාවිතා කරන්න.

• පාවෙන 32 බිට් (ඉලක්කම් 7) එය වැඩිපුරම භාවිතා කරන්නේ ග්‍රැෆික් පුස්තකාලවල බැවින් සැකසුම් බලයන් සඳහා ඉතා ඉහළ ඉල්ලුමක් ඇති අතර වටකුරු දෝෂ දරාගත හැකි අවස්ථා ද භාවිතා කරයි.

Decimalsa ට වඩා මන්දගාමී වේ double/float.

Decimalsහා Floats/Doublesපවසන අන්දමට කාස්ට් තොරව සමාන කළ නො හැකි Floatsසහ Doublesකළ හැක.

Decimals කේතීකරණ හෝ පසුපස ශුන්‍යයන්ටද ඉඩ දෙන්න.

.Net (c #) හි දශම, පාවෙන සහ ද්විත්ව අර්ථ දැක්වීමට

ඔබ සාරධර්ම පහත පරිදි සඳහන් කළ යුතුය:

Decimal dec = 12M/6;
Double dbl = 11D/6;
float fl = 15F/6;

ප්‍රති .ල පරීක්ෂා කරන්න.

සහ එක් එක් අත්පත් කරගත් බයිට් වේ

Float - 4
Double - 8
Decimal - 12