Showing posts with label Division Method. Show all posts
Showing posts with label Division Method. Show all posts

Friday, 14 February 2014

(#4) Hash Function (ii)

02.Compression Map


මෙහිදී h1  මගින් සොයාගන්නාලද integer එක භාවිතා කොට store කිරීම සඳහා index number එකක් සොයාගැනීම සිදු කරයි.මෙහිද ප්‍රධආන ආකාර කිහිපයක් ඇත.
i.Division Method
ii.Mid-Square function
iii.Extraction
iv.Radix Transformation
v.Truncation
vi.MAD Method


i.Division


key එක k  ලෙස ගනිමු. මෙහිදී බොහෝ විට mod  කිරීම (modulus) සංඛ්‍යාවක් යම්කිසි සංඛ්‍යාවකින් බෙදා ශේෂය පිළිතුර ලෙස ලබා ගැනීම සිදු කරයි.බොහෝ විට key එක බෙදනු ලබන්නේ table size එකෙනි.එවිට ලැබෙන පිළිතුර හැමවිටම table  size එකට වඩා කුඩා වීම එයට හේතුවයි.

                         
                       h(k) = K mod TSize
                         
                      K = { 44, 56, 79}
                      h: U → {0, 1, ..., 10 }
                      h( k ) = k mod 11
උදාහරණයක් ලෙස 44 යන key එක සලකා බලමු.
          h( k ) = k mod 11
          h( 44) = 44 mod 11
                            =   0
h( k ) = k mod m
m සඳහා අගයක් තෝරා ගැනීමේදී පහත නීති අනුගමනය කල යුතුය.
2 බලයන් m ලෙස යොදා නොගනියි.
decimal  අගයන් keys ලෙස ඇති විට m සඳහා 10 බලයන් යොදා නොගනියි.
වඩාත් සුදුසු වන්නේ 2 බලයන්ට එතරම්ම සමීප නොවන ප්‍රථමක (prime ) සංඛ්‍යාය.

ii.Mid Square Function


key එක වර්ගකල  ලැබෙන පිළිතුරෙහි මැද ඇති ඉලක්කම් කිහිපයක් index number එක ලෙස තෝරාගැනීම මෙහිදී සිදු කරයි.key එක string එකක්නම් hash code map වලදී යොදාගත් ක්‍රමයක් භාවිතා කරමින් ප්‍රථමයෙන් එය integer එකක් බවට පත්කරගෙන සිටිය යුතුය.
උදාහරණයක් ලෙස 3121 key එක ලෙස ඇතැයි සලකන්න
h (3121) = (3121)2   = 9740641
h(3121) = 406


iii.Extraction

key එක ඉතා විශාල සංඛ්‍යාවක් වන අවස්ථා වලදී ඉන් කොටසක් වෙන් කරගෙන index number එක ලෙස භාවිතා කරයි.මෙහිදී මුල කොටස ,මැද  කොටස ,අග කොටස හෝ තෝරාගත් වෙනත් ඕනෑම කොටසක් භාවිතා කල හැකිය.
උදාහරණයක් ලෙස 123456789 යන key එක සලකන්න .

first four digits 1234
last four digits 6789
the first two combined with last two 1289 or
some other combination

iv.Radix Transformation

කිසියම් පාදයකින් ඇති key එකක් වෙනත් පාදයකට හරවා එය index එක ලෙස භාවිතා කිරීම මෙහිදී සිදු කරයි.පාදය වෙනස් කිරීමෙන් පසු ලැබෙන අගය විශාල වැඩිනම් එය mod කිරීම හෝ වෙනත් ක්‍රමයක් මගින් කුඩා අගයක් බවට පත්කරගත්හැකිය.
h(34510) = 4239
index number = 423

vi.Truncation

key එකේ ඇති part එකක් ඉවත් කර දමා ඉතිරිය index එක ලෙස භාවිතා කිරීමයි.

Employee number: 001364789
Table size: 1000
- h(x) = (last three digits) = 789
- h(x) = (digits 4, 6, 8) = 348
- h(x) = partition in 3-digits, add together,
and truncate
= (001) + (364) + (789) = 1154 and ignore last bit

vii.MAD



Multiple add and devide

මෙහිදී පහත දැක්වෙන ආකාරයේ සූත්‍රයක් භාවිතා කරයි.

h(k) = [(ak + b) mod p] mod n
n table size එකට වඩා කුඩා ප්‍රථමක (prime) සංඛ්‍යාවක් විය යුතුය.
a හා b  ධන නිඛිල (integers) විය යුතුය.
a mod n ≠0 විය යුතුය ,නැතහොත් සියලුම සංඛ්‍යා b වල එකම අගයක් කරා map  විය හැක.

Simple Uniform Hashing

ඕනෑම element එකක් තෝරාගත් slot එකකට යොමු වීමට ඇති සම්භාවිතාව සමාන නම් එය simple uniform hashing ලෙස හඳුන්වනු ලබයි.

Load Factor(α)


Hash function එකෙහි efficiency එක මැනීම සඳහා මෙය භාවිතා කරන අතර α හි අගය 1 ට ආසන්න වන තරමට function එකේ efficiency එක වැඩිය.

a = the number of elements stored in the table
             the size of the table’s array







Friday, 7 February 2014

(#3) Hash Function (i)

Hash function 


hash function එක අප බොහෝවිට functions දෙකක එකතුවක් මගින් සාදාගනුලබයි. hash function එක h නම් 
  
       h(x)  =  h2(h1(x))
 ලෙස වෙයි. මෙහිදී අපට store කිරීමට අවශ්‍ය කරන key එක integer එකක් බවට පත්කරගැනීම h1 function එකෙන් සිදු කරනු ලබයි.එම සොයාගනු ලබන integer  එක h2  function  එකට ආදේශ කළ  විට එම key එකට අදාළ index number එක ගණනය කරගනු ලැබේ. Hash function එක සාදාගැනීමට අවශ්‍යකරන sub functions දෙක සාදාගන්නා ආකාර කිහිපයක් ඇත.මේවා ප්‍රධාන කොටස් දෙකකට බෙදා දැක්විය හැකිය.
1.     Hash Code Map (h1 සෑදීමට බෝහවිට යොදාගනියි.)
2.     Compression Map (h2 සෑදීමට බොහෝවිට යොදාගනියි.)

Perfect Hash Function


 Search time එක O (1) වනපරිදි hash function එකක් ගොඩනැගිය හැකිනම් එවනි function එකකට  perfect hash function එකක්යැයි  කියනු ලැබේ.

01.Hash Code Map

                               i.            Integer Cast
                             ii.            Summing Components
                          iii.            Polynomial Accumilation

අපට store  කිරීමට අවශ්‍ය කරන key එකේ ඇති කුමක් හෝ attribute එකක් භාවිතා කරමින් එය integer එකකට පරිවර්තනය කරගැනීම මෙහිදී සිදු කරයි. උදාහරණයක් ලෙස store කලයුතු වන්නේ වචනයක්නම් එහි අකුරු වල ASCII values වල එකතුව යොදාගැනීම හෝ bit size එක යොදාගැනීම වැනි දෑ දක්වියහැකිය.

i.Integer Cast


මෙමගින් key එකේ වෙනත් data type එකකින් ඇති bit, integer එකක් බවට convert කරගැනීම සිදු කරයි.key එක ඇති data type එක integer  data type එකට වඩා කුඩා bit size එකක් ඇති data type එකක්නම්  මෙම ක්‍රමය වඩාත් සුදුසුවෙයි..(උදා; byte, short, int, float in java)  long සහ doube සඳහා මෙමෙ ක්‍රමය සුදුසු නොවේ.

         
                          •  int intKey = (int) „A‟; /* intKey = 65 */
                          •   char charKey = (char) 78;
                               /* charKey = „N‟ */

Integer Casting මගින් යම්කිසි වෙනත් data type එකක් integer එකක් බවට පත්කිරීම සිදුකලහැකිය.මෙහිදී සිදුකරනු ලබන්නේ එයයි.වෙනත් data type එකක ඇති key එක integer එකක් බවට පත්කළ එය කෙලින්ම key එක store කිරීමට අවශ්‍ය කරන array index number  එක ලෙස යෝදාගතහැකිය.

ii.Summing Components

key එක string  එකක් වන අවස්ථා වලදී මෙය භාවිතා කලහැකිය.එවිට string එකේ ඇති characters වල ASCII values වල එකතුව ලබාගනියි.එම ලැබෙන එකතුව key එක store කරන array index number එක ලෙස යොදාගනියි.key එක ලෙස පහත වචන ඇති අවස්ථා සලකන්න.එවිට එමගින් array index number එක සාදාගන්නා ආකාරය පහත උදාහරණවලින් දක්වා ඇත.

iii.Polinomial Accumilation


මෙහිදී key එකේ ඇති යම් යම් attributes භාවිතා කරමින් polynomial එකක් (බහුපදයක් ) සාදාගැනීම සිදු කරයි.

 x0ak-1 +  x1ak-2  +……+ xk-2a  + xk-1  
 xk-1 +  a(xk-2 + a(xk-3 +…..+ a(x2 + a x0))… )

  උදාහරණයක් ලෙස key එකට string එකක් ඇති අවසථාවක්  සලකමු.

එවිට , k = string එකේ ඇති characters ගණන
          x = character වල ASCII value එක
          a = string length එක 2න් බෙදූ විට ලැබෙන  අගය ලෙස ගනිමු.


x0ak-1 +  x1ak-2  +……+ xk-2a  + xk-1  

උදා: NOTE  යන වචනය key එක ලෙස ඇතැයි සලකන්න.
එවිට ,
k  = 4
a = 1
x0= 78, x1 = 79, x2 = 84, x3 = 69

Index number =  x0ak-1 +  x1ak-2  +……+ xk-2a  + xk-1  
                        =     78(2)4-1  + 79 (2)4-2  + 84 (2)4-3  + 69 (2)4-4
                                    =     78 (2)3     + 79(2)2    + 84 (2)1   + 69(2)0 
                        =     78* 8 + 79 * 4 + 84* 2 + 69 *1
                        =     624 + 316 + 168 + 69
                        =   1177
දැන් NOTE යන string එක array එකෙහි 1177 වන index එක තුල store කල හැක.