യഥാർത്ഥ തരങ്ങളുടെ അയഥാർത്ഥ സവിശേഷതകൾ, അല്ലെങ്കിൽ യഥാർത്ഥത്തിൽ ശ്രദ്ധിക്കുക

പ്രസിദ്ധീകരണത്തിന് ശേഷം ലേഖനങ്ങൾ PostgreSQL-ൽ ടൈപ്പുചെയ്യുന്നതിന്റെ സവിശേഷതകളെക്കുറിച്ച്, ആദ്യത്തെ അഭിപ്രായം യഥാർത്ഥ സംഖ്യകളുമായി പ്രവർത്തിക്കുന്നതിന്റെ ബുദ്ധിമുട്ടുകളെക്കുറിച്ചായിരുന്നു. എനിക്ക് ലഭ്യമായ SQL അന്വേഷണങ്ങളുടെ കോഡ് എത്ര തവണ റിയൽ തരം ഉപയോഗിക്കുന്നുവെന്ന് കാണാൻ ഞാൻ തീരുമാനിച്ചു. ഇത് പലപ്പോഴും ഉപയോഗിക്കാറുണ്ടെന്നും ഡവലപ്പർമാർ എല്ലായ്പ്പോഴും ഇതിന് പിന്നിലുള്ള അപകടങ്ങളെക്കുറിച്ച് മനസ്സിലാക്കുന്നില്ല എന്നും ഇത് മാറുന്നു. കമ്പ്യൂട്ടർ മെമ്മറിയിൽ യഥാർത്ഥ നമ്പറുകൾ സംഭരിക്കുന്നതിന്റെ സവിശേഷതകളെക്കുറിച്ചും അവയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനെക്കുറിച്ചും ഇന്റർനെറ്റിലും ഹബ്രെയിലും ധാരാളം നല്ല ലേഖനങ്ങൾ ഉണ്ടെങ്കിലും ഇത്. അതിനാൽ, ഈ ലേഖനത്തിൽ ഞാൻ PostgreSQL-ൽ അത്തരം സവിശേഷതകൾ പ്രയോഗിക്കാൻ ശ്രമിക്കും, കൂടാതെ അവയുമായി ബന്ധപ്പെട്ട പ്രശ്‌നങ്ങൾ വേഗത്തിൽ പരിശോധിക്കാൻ ശ്രമിക്കും, അതുവഴി SQL അന്വേഷണ ഡെവലപ്പർമാർക്ക് അവ ഒഴിവാക്കാൻ എളുപ്പമാകും.

PostgreSQL ഡോക്യുമെന്റേഷൻ സംക്ഷിപ്തമായി പ്രസ്താവിക്കുന്നു: "അത്തരം പിശകുകളുടെ മാനേജ്മെന്റും കണക്കുകൂട്ടൽ സമയത്ത് അവയുടെ പ്രചരണവും ഗണിതശാസ്ത്രത്തിന്റെയും കമ്പ്യൂട്ടർ സയൻസിന്റെയും ഒരു മുഴുവൻ ശാഖയുടെയും വിഷയമാണ്, അത് ഇവിടെ ഉൾപ്പെടുത്തിയിട്ടില്ല" (വായനക്കാരനെ IEEE 754 സ്റ്റാൻഡേർഡിലേക്ക് വിവേകപൂർവ്വം പരാമർശിക്കുമ്പോൾ). ഏത് തരത്തിലുള്ള പിശകുകളാണ് ഇവിടെ ഉദ്ദേശിക്കുന്നത്? നമുക്ക് അവ ക്രമത്തിൽ ചർച്ച ചെയ്യാം, എന്തുകൊണ്ടാണ് ഞാൻ വീണ്ടും പേന എടുത്തതെന്ന് ഉടൻ വ്യക്തമാകും.

ഉദാഹരണമായി നമുക്ക് ഒരു ലളിതമായ അഭ്യർത്ഥന എടുക്കാം:

********* ЗАПРОС *********
SELECT 0.1::REAL;
**************************
float4
--------
    0.1
(1 строка)

തൽഫലമായി, ഞങ്ങൾ പ്രത്യേകമായി ഒന്നും കാണില്ല - ഞങ്ങൾക്ക് പ്രതീക്ഷിച്ച 0.1 ലഭിക്കും. എന്നാൽ ഇപ്പോൾ നമുക്ക് ഇത് 0.1 ആയി താരതമ്യം ചെയ്യാം:

********* ЗАПРОС *********
SELECT 0.1::REAL = 0.1;
**************************
?column?
----------
f
(1 строка)

തുല്യമല്ല! എന്തെല്ലാം അത്ഭുതങ്ങൾ! എന്നാൽ കൂടുതൽ, കൂടുതൽ. ആരോ പറയും, REAL ഭിന്നസംഖ്യകളോട് മോശമായി പെരുമാറുമെന്ന് എനിക്കറിയാം, അതിനാൽ ഞാൻ അവിടെ പൂർണ്ണ സംഖ്യകൾ നൽകും, എല്ലാം തീർച്ചയായും ശരിയാകും. ശരി, നമുക്ക് 123 എന്ന നമ്പർ റിയലിലേക്ക് കാസ്‌റ്റ് ചെയ്യാം:

********* ЗАПРОС *********
SELECT 123456789::REAL::INT;
**************************
   int4   
-----------
123456792
(1 строка)

അത് 3 എണ്ണം കൂടിയായി! അത്രയേയുള്ളൂ, ഡാറ്റാബേസ് ഒടുവിൽ എങ്ങനെ കണക്കാക്കണമെന്ന് മറന്നു! അതോ നമ്മൾ എന്തെങ്കിലും തെറ്റിദ്ധരിക്കുകയാണോ? നമുക്ക് അത് കണ്ടുപിടിക്കാം.

ആദ്യം, നമുക്ക് മെറ്റീരിയൽ ഓർമ്മിക്കാം. നിങ്ങൾക്കറിയാവുന്നതുപോലെ, ഏത് ദശാംശ സംഖ്യയും പത്തിന്റെ ശക്തികളായി വികസിപ്പിക്കാം. അതിനാൽ, 123.456 എന്ന സംഖ്യ 1*102 + 2*101 + 3*100 + 4*10-1 + 5*10-2 + ​​6*10-3 ന് തുല്യമായിരിക്കും. എന്നാൽ കമ്പ്യൂട്ടർ ബൈനറി രൂപത്തിൽ അക്കങ്ങൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു, അതിനാൽ അവ രണ്ടിന്റെ ശക്തികളിൽ വിപുലീകരണ രൂപത്തിൽ പ്രതിനിധീകരിക്കേണ്ടതുണ്ട്. അതിനാൽ, ബൈനറിയിലെ 5.625 എന്ന സംഖ്യയെ 101.101 ആയി പ്രതിനിധീകരിക്കുന്നു, അത് 1*22 + 0*21 + 1*20 + 1*2-1 + 0*2-2 + 1*2-3 ന് തുല്യമായിരിക്കും. രണ്ടിന്റെ പോസിറ്റീവ് ശക്തികൾ എല്ലായ്പ്പോഴും മുഴുവൻ ദശാംശ സംഖ്യകൾ (1, 2, 4, 8, 16, മുതലായവ) നൽകുന്നുവെങ്കിൽ, നെഗറ്റീവ് ഉള്ളവയിൽ എല്ലാം കൂടുതൽ സങ്കീർണ്ണമാണ് (0.5, 0.25, 0.125, 0,0625, മുതലായവ). പ്രശ്നം അതാണ് എല്ലാ ദശാംശങ്ങളെയും ഒരു പരിമിത ബൈനറി ഭിന്നസംഖ്യയായി പ്രതിനിധീകരിക്കാൻ കഴിയില്ല. അങ്ങനെ, ഒരു ബൈനറി ഭിന്നസംഖ്യയുടെ രൂപത്തിൽ നമ്മുടെ കുപ്രസിദ്ധമായ 0.1 ആവർത്തന മൂല്യം 0.0 (0011) ആയി ദൃശ്യമാകുന്നു. തത്ഫലമായി, കമ്പ്യൂട്ടർ മെമ്മറിയിലെ ഈ സംഖ്യയുടെ അന്തിമ മൂല്യം ബിറ്റ് ഡെപ്ത് അനുസരിച്ച് വ്യത്യാസപ്പെടും.

കമ്പ്യൂട്ടർ മെമ്മറിയിൽ യഥാർത്ഥ സംഖ്യകൾ എങ്ങനെ സംഭരിക്കപ്പെടുന്നുവെന്ന് ഓർമ്മിക്കേണ്ട സമയമാണിത്. പൊതുവായി പറഞ്ഞാൽ, ഒരു യഥാർത്ഥ സംഖ്യയിൽ മൂന്ന് പ്രധാന ഭാഗങ്ങൾ അടങ്ങിയിരിക്കുന്നു - ചിഹ്നം, മാന്റിസ, ഘാതം. ചിഹ്നം പ്ലസ് അല്ലെങ്കിൽ മൈനസ് ആകാം, അതിനാൽ അതിനായി ഒരു ബിറ്റ് അനുവദിച്ചിരിക്കുന്നു. എന്നാൽ മാന്റിസയുടെയും എക്‌സ്‌പോണന്റിന്റെയും ബിറ്റുകളുടെ എണ്ണം നിർണ്ണയിക്കുന്നത് യഥാർത്ഥ തരം അനുസരിച്ചാണ്. അതിനാൽ, യഥാർത്ഥ തരത്തിന്, മാന്റിസയുടെ ദൈർഘ്യം 23 ബിറ്റുകളാണ് (1 ന് തുല്യമായ ഒരു ബിറ്റ് മാന്റിസയുടെ തുടക്കത്തിലേക്ക് സൂക്ഷ്‌മമായി ചേർത്തിരിക്കുന്നു, ഫലം 24 ആണ്), എക്‌സ്‌പോണന്റ് 8 ബിറ്റുകളാണ്. ആകെ 32 ബിറ്റുകൾ അല്ലെങ്കിൽ 4 ബൈറ്റുകൾ. ഡബിൾ പ്രിസിഷൻ തരത്തിന്, മാന്റിസയുടെ നീളം 52 ബിറ്റുകളും എക്‌സ്‌പോണന്റ് 11 ബിറ്റുകളുമായിരിക്കും, മൊത്തം 64 ബിറ്റുകൾ അല്ലെങ്കിൽ 8 ബൈറ്റുകൾ. PostgreSQL ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾക്കായി ഉയർന്ന കൃത്യതയെ പിന്തുണയ്ക്കുന്നില്ല.

നമുക്ക് നമ്മുടെ ദശാംശ സംഖ്യയായ 0.1 യഥാർത്ഥവും ഇരട്ട പ്രിസിഷൻ തരങ്ങളിലേക്കും പാക്ക് ചെയ്യാം. എക്‌സ്‌പോണന്റിന്റെ ചിഹ്നവും മൂല്യവും ഒന്നുതന്നെയായതിനാൽ, ഞങ്ങൾ മാന്റിസയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും (എക്‌സ്‌പോണന്റിന്റെയും പൂജ്യ യഥാർത്ഥ മൂല്യങ്ങളുടെയും മൂല്യങ്ങൾ സംഭരിക്കുന്നതിന്റെ വ്യക്തമല്ലാത്ത സവിശേഷതകൾ ഞാൻ മനഃപൂർവ്വം ഒഴിവാക്കുന്നു, കാരണം അവ മനസ്സിലാക്കുന്നത് സങ്കീർണ്ണമാക്കുകയും സത്തയിൽ നിന്ന് വ്യതിചലിക്കുകയും ചെയ്യുന്നു. പ്രശ്നത്തിന്, താൽപ്പര്യമുണ്ടെങ്കിൽ, IEEE 754 സ്റ്റാൻഡേർഡ് കാണുക). നമുക്ക് എന്ത് ലഭിക്കും? മുകളിലെ വരിയിൽ ഞാൻ റിയൽ തരത്തിനായി "മന്തിസ്സ" നൽകും (അവസാന ബിറ്റിന്റെ റൗണ്ടിംഗ് 1 കൊണ്ട് അടുത്തുള്ള പ്രതിനിധീകരിക്കാവുന്ന നമ്പറിലേക്ക്, അല്ലെങ്കിൽ അത് 0.099999 ആയിരിക്കും...), താഴത്തെ വരിയിൽ - ഇതിനായി ഇരട്ട പ്രിസിഷൻ തരം:

0.000110011001100110011001101
0.00011001100110011001100110011001100110011001100110011001

വ്യക്തമായും, ഇവ തികച്ചും വ്യത്യസ്തമായ രണ്ട് സംഖ്യകളാണ്! അതിനാൽ, താരതമ്യം ചെയ്യുമ്പോൾ, ആദ്യ സംഖ്യ പൂജ്യങ്ങളാൽ പാഡ് ചെയ്യപ്പെടും, അതിനാൽ, രണ്ടാമത്തേതിനേക്കാൾ വലുതായിരിക്കും (റൗണ്ടിംഗ് കണക്കിലെടുക്കുമ്പോൾ - ബോൾഡിൽ അടയാളപ്പെടുത്തിയത്). ഇത് ഞങ്ങളുടെ ഉദാഹരണങ്ങളിൽ നിന്നുള്ള അവ്യക്തത വിശദീകരിക്കുന്നു. രണ്ടാമത്തെ ഉദാഹരണത്തിൽ, വ്യക്തമായി വ്യക്തമാക്കിയ സംഖ്യ 0.1 ഇരട്ട പ്രിസിഷൻ തരത്തിലേക്ക് കാസ്‌റ്റ് ചെയ്‌തിരിക്കുന്നു, തുടർന്ന് യഥാർത്ഥ തരത്തിന്റെ സംഖ്യയുമായി താരതമ്യം ചെയ്യുന്നു. രണ്ടും ഒരേ തരത്തിലേക്ക് ചുരുക്കിയിരിക്കുന്നു, നമ്മൾ മുകളിൽ കാണുന്നത് കൃത്യമായി ഉണ്ട്. നമുക്ക് ചോദ്യം പരിഷ്‌ക്കരിക്കാം, അങ്ങനെ എല്ലാം ശരിയാകും:

********* ЗАПРОС *********
SELECT 0.1::REAL > 0.1::DOUBLE PRECISION;
**************************
?column?
----------
t
(1 строка)

വാസ്തവത്തിൽ, 0.1 എന്ന സംഖ്യയെ യഥാർത്ഥവും ഇരട്ട സൂചകവുമായി ഇരട്ടിയായി കുറയ്ക്കുന്നതിലൂടെ, കടങ്കഥയ്ക്കുള്ള ഉത്തരം നമുക്ക് ലഭിക്കും:

********* ЗАПРОС *********
SELECT 0.1::REAL::DOUBLE PRECISION;
**************************

      float8       
-------------------
0.100000001490116
(1 строка)

മുകളിലുള്ള മൂന്നാമത്തെ ഉദാഹരണവും ഇത് വിശദീകരിക്കുന്നു. 123 എന്ന സംഖ്യ ലളിതമാണ് മാന്റിസയെ 24 ബിറ്റുകളായി ഘടിപ്പിക്കുക അസാധ്യമാണ് (23 സ്പഷ്ടമായ + 1 സൂചിപ്പിച്ചിരിക്കുന്നു). 24 ബിറ്റുകളിൽ ഉൾക്കൊള്ളിക്കാവുന്ന പരമാവധി പൂർണ്ണസംഖ്യ 224-1 = 16 ആണ്. അതിനാൽ, ഞങ്ങളുടെ സംഖ്യ 777 എന്നത് ഏറ്റവും അടുത്തുള്ള പ്രതിനിധീകരിക്കാവുന്ന 215 ലേക്ക് റൗണ്ട് ചെയ്‌തിരിക്കുന്നു. തരം ഇരട്ട സൂക്ഷ്‌മമായി മാറ്റുന്നതിലൂടെ, ഞങ്ങൾ ഇനി ഈ രംഗം കാണില്ല:

********* ЗАПРОС *********
SELECT 123456789::DOUBLE PRECISION::INT;
**************************
   int4   
-----------
123456789
(1 строка)

അത്രയേയുള്ളൂ. അത്ഭുതങ്ങളൊന്നുമില്ലെന്ന് ഇത് മാറുന്നു. എന്നാൽ വിവരിച്ചിരിക്കുന്നതെല്ലാം നിങ്ങൾക്ക് യഥാർത്ഥ തരം എത്രമാത്രം ആവശ്യമാണെന്ന് ചിന്തിക്കാനുള്ള നല്ല കാരണമാണ്. ഒരുപക്ഷേ അതിന്റെ ഉപയോഗത്തിന്റെ ഏറ്റവും വലിയ നേട്ടം, അറിയാവുന്ന കൃത്യത നഷ്ടപ്പെടുന്ന കണക്കുകൂട്ടലുകളുടെ വേഗതയാണ്. എന്നാൽ ഇത്തരത്തിലുള്ള പതിവ് ഉപയോഗത്തെ ന്യായീകരിക്കുന്ന ഒരു സാർവത്രിക സാഹചര്യം ഇതായിരിക്കുമോ? ചിന്തിക്കരുത്.

അവലംബം: www.habr.com