What is a Multiplicative Hashing? - minseok127/HashSimulator GitHub Wiki

Multiplicative Hashing

Multiplicative Hashing์ด๋ž€ Middle Square์™€๋Š” ๋‹ค๋ฅด๊ฒŒ ์ž๊ธฐ ์ž์‹ ์ด ์•„๋‹Œ ํŠน์ •ํ•œ ์ƒ์ˆ˜๋ฅผ ๊ณฑํ•˜๋Š” ๋ฐฉ์‹์ž…๋‹ˆ๋‹ค.

์ด๋ฒˆ ํŽ˜์ด์ง€์—์„œ๋Š” Multiplicative Hashing์ด ์–ด๋–ค ํŠน์ง•์„ ๊ฐ€์ง€๋Š” ์ง€ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

Contents

Scheme

Multiplicative Hashing์€ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์ˆ˜์‹์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

h(k) = |_ M * ( (A / w) * K mod 1 ) _|  // ex) |_ x _| : x๋ณด๋‹ค ํฌ์ง€ ์•Š์€ ์ •์ˆ˜, A mod B : A๋ฅผ B๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€

bin์˜ ๊ฐœ์ˆ˜์ธ M์—๋‹ค๊ฐ€ ( (A / w) * K mod 1 )์ด๋ผ๋Š” ๊ฐ’์„ ๊ณฑํ•ด์„œ index๋ฅผ ๊ฒฐ์ •ํ•œ๋‹ค๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค.

(A / w) * K mod 1 ๋Š” Key์— (A / w)๋ผ๋Š” ๊ฐ’์„ ๊ณฑํ•œ ํ›„ ๊ทธ๊ฒƒ์„ 1๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€, ์ฆ‰ ์†Œ์ˆ˜๋ถ€๋ถ„์„ ๊ฒฐ๊ณผ๊ฐ’์œผ๋กœ ๊ฐ€์ง‘๋‹ˆ๋‹ค.

์ •๋ฆฌํ•˜์ž๋ฉด M์— 0์—์„œ 1 ์‚ฌ์ด์˜ ์†Œ์ˆ˜๋ฅผ ๊ณฑํ•œ ํ›„ ๊ทธ ๊ฐ’์˜ ์ •์ˆ˜๋ถ€๋ถ„์„ ์ทจํ•˜์—ฌ Index๋กœ ์‚ฌ์šฉํ•œ๋‹ค๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค.

Constants

๊ทธ๋ ‡๋‹ค๋ฉด ์—ฌ๊ธฐ์„œ A์™€ w๊ฐ€ ์˜๋ฏธํ•˜๋Š” ๊ฒƒ์€ ๋ฌด์—‡์ผ๊นŒ์š”?

A๋Š” integer๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์ฆ‰ 32๋น„ํŠธ๋กœ ํ‘œํ˜„๋˜๋Š” ์ •์ˆ˜๋ฅผ ๋œปํ•ฉ๋‹ˆ๋‹ค.

w๋Š” word size๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ๋Š” integer์˜ ํฌ๊ธฐ์ธ 2^32๋กœ ์ƒ๊ฐํ•ฉ๋‹ˆ๋‹ค.

MSB๋ฅผ ๋ถ€ํ˜ธ๋กœ ์ƒ๊ฐํ•˜์ง€ ์•Š๋Š” unsigned int๋ฅผ ๊ฐ€์ •ํ•ฉ๋‹ˆ๋‹ค.

์‹ค์ œ unsigned int์˜ ํฌ๊ธฐ๋Š” ์ตœ๋Œ€ 2^32 - 1์ด์ง€๋งŒ ํŽธ์˜๋ฅผ ์œ„ํ•ด 2^32๋กœ ์ƒ๊ฐํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

์ •๋ฆฌํ•˜์ž๋ฉด A / w๋Š” 0์—์„œ 1 ์‚ฌ์ด์˜ ์†Œ์ˆ˜๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

Interpretation

The Art of Computer Programming, vol. 3 by Donald Knuth์— ๋‚˜์˜ค๋Š” Multiplicative Hashing์— ๋Œ€ํ•œ ์„ค๋ช…์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

word์˜ ์ œ์ผ ์™ผ์ชฝ์— ์†Œ์ˆ˜์ ์ด ์ฐํ˜€์žˆ๋‹ค๊ณ  ์ƒ๊ฐํ•˜๋ฉด Integer A๋Š” ์ด๊ฒƒ ์ž์ฒด๋กœ ์†Œ์ˆ˜(fraction)๋กœ ๋ณผ ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ฆ‰ A / w ๋ผ๋Š” ๋ถ„์ˆ˜๋ฅผ ์™ผ์ชฝ์— ์†Œ์ˆ˜์ ์ด ์ฐํ˜€์žˆ๋Š” Integer A์™€ ๊ฐ™์€ ๊ฒƒ์œผ๋กœ ๊ฐ„์ฃผํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

... 36 35 34 33 32 | 31 30 ... 2 1 0    // ๊ฐ ์ˆซ์ž๋Š” bit์˜ index๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.
    integer part   | fractional part    // ์ขŒ์ธก์€ ์ •์ˆ˜๋ถ€๋ถ„, ์šฐ์ธก์€ ์†Œ์ˆ˜๋ถ€๋ถ„ 

A / w๋ฅผ ์ด๋Ÿฌํ•œ ๋ฐฉ์‹์œผ๋กœ ์ €์žฅํ•  ๋•Œ ์ •์ˆ˜๋ถ€๋ถ„์€ ๋ชจ๋‘ 0์ด๊ณ  ์†Œ์ˆ˜๋ถ€๋ถ„์œผ๋กœ A์˜ bit๋“ค์ด ์ €์žฅ๋ฉ๋‹ˆ๋‹ค.

w๋Š” word size์ด๊ธฐ ๋•Œ๋ฌธ์— A๋ณด๋‹ค ํ•ญ์ƒ ํฐ ๊ฐ’์„ ๊ฐ€์ง‘๋‹ˆ๋‹ค.

๊ทธ ํ›„ K๋ฅผ ๊ณฑํ•˜๋ฉด ์†Œ์ˆ˜๋ถ€๋ถ„์˜ bit๋“ค์ด carry๋˜์–ด ์ •์ˆ˜๋ถ€๋ถ„์˜ bit๋“ค์ด ์ฑ„์›Œ์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์—ฌ๊ธฐ๊นŒ์ง€๊ฐ€ (A / w) * K์— ๋Œ€ํ•œ ๋‚ด์šฉ์ž…๋‹ˆ๋‹ค.

์ดํ›„ mod 1์„ ํ•œ๋‹ค๋Š” ๊ฒƒ์€ carry๋œ ์ •์ˆ˜๋ถ€๋ถ„ bit๋“ค์„ ์—†์• ์ค€๋‹ค๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค.

์ด๋ ‡๊ฒŒ ๋‚จ์€ ์†Œ์ˆ˜๊ฐ’์„ M์— ๊ณฑํ•˜์—ฌ 0์—์„œ M - 1์˜ Index๋ฅผ ์–ป๊ณ ์ž ํ•ฉ๋‹ˆ๋‹ค.

Implementation

์œ„์˜ ์•„์ด๋””์–ด๋ฅผ ์‹ค์ œ๋กœ ๊ตฌํ˜„ํ•œ๋‹ค๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๋จผ์ € M์„ 2^m์œผ๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ฆฌ๊ณ  AK mod w๋ฅผ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค. ์ด ๊ฐ’์„ m bit๋งŒํผ ์™ผ์ชฝ์œผ๋กœ ์˜ฎ๊ฒจ์„œ Integer ๋ฒ”์œ„๋ฅผ ๋ฒ—์–ด๋‚˜๋Š” m๊ฐœ์˜ bit๋ฅผ Index๋กœ ๊ฐ€์ง€๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ข€ ๋” ๊ตฌ์ฒด์ ์œผ๋กœ ์‚ดํŽด๋ณด๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

w๊ฐ€ 2^32์ด๊ธฐ ๋•Œ๋ฌธ์— AK mod w๋Š” AK์˜ ๊ฒฐ๊ณผ์—์„œ ์˜ค๋ฅธ์ชฝ๋ถ€ํ„ฐ 32 bit๋งŒ ๋‚จ๊ธด ๊ฒฐ๊ณผ์ž…๋‹ˆ๋‹ค.

๊ทธ๋ฆฌ๊ณ  ์ด๊ฒƒ์€ Interpretation์˜ ์•„์ด๋””์–ด๋ฅผ ๊ธฐ์ค€์œผ๋กœ ์ƒ๊ฐํ•œ (A / w) * K mod 1 ๊ฒฐ๊ณผ์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๋‚จ์€ 32 bit์— ๋Œ€ํ•ด์„œ m์นธ ์™ผ์ชฝ์œผ๋กœ ์ด๋™์‹œํ‚ค๋ฉด m bit์˜ ์ •์ˆ˜๋ถ€๋ถ„์ด ์ƒ๊ฒจ๋‚˜๊ณ  ์ด๋ฅผ Index๋กœ ์‚ฌ์šฉํ•œ๋‹ค๋ฉด

M * ( (A / w) * K mod 1 )์™€ ๊ฐ™์€ ๊ฒฐ๊ณผ๊ฐ€ ๋‚˜ํƒ€๋‚˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

=> ๋’ค์— ๋‚˜์˜ค๋Š” Three-distance theorem์˜ ๊ด€์ ์—์„œ ๋ด์•ผํ•จ.
=> 2^31 + 2^30 + ... + 2^1 + 2^0 | 2^-1 + 2^-2 + 2^-3 ... + 2^-32
=> ๋ณต์žกํ•˜๊ฒŒ ์ƒ๊ฐํ•  ๊ฑฐ ์—†์ด ์ด๋ ‡๊ฒŒ ์ •์ˆ˜๋ถ€๋ถ„๊ณผ ์†Œ์ˆ˜๋ถ€๋ถ„์ด ํ‘œํ˜„๋  ๋•Œ, K์— ๊ณฑํ•ด์ง€๋Š” ๊ฐ’์ด ํ”ผ๋ณด๋‚˜์น˜ ๋น„์œจ์ธ ๊ฒฝ์šฐ
=> ์ฆ‰ (A/w)๊ฐ€ ํ”ผ๋ณด๋‚˜์ง€ ๋น„์œจ ๊ฐ’์ด๊ณ , ์ด๊ฒŒ 2^-1 + 2^-2 + ... + 2^-32์™€ ๊ฐ™์ด ์†Œ์ˆ˜๋ถ€๋ถ„์„ 2์ง„์ˆ˜๋กœ ๋‚˜ํƒ€๋‚ธ๋‹ค๊ณ  ์ƒ๊ฐํ•ด๋ณด์ž
=> ๊ทธ๋ฆฌ๊ณ  modular 1์„ ํ•œ๋‹ค๋Š”๊ฑด ์†Œ์ˆ˜๋ถ€๋ถ„์˜ ๋ชจ๋“  ๋น„ํŠธ๋ฅผ 1๋กœ ๋งŒ๋“ค๊ณ  &์—ฐ์‚ฐ๊ณผ ๊ฐ™๋‹ค.
=> key๊ฐ’๋งŒํผ์˜ step์„ ์ด๋™ํ•˜๊ณ  ๊ทธ๊ฑฐ์— M์„ ๊ณฑํ•œ ํ›„์— ์ •์ˆ˜๋ถ€๋ถ„์„ ์ทจํ•˜๋ฉด ๋ช‡ ๋ฒˆ์งธ bin์ธ์ง€ ๋‚˜์˜ด
=> M์„ 2์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์œผ๋กœํ•˜๋ฉด ์œ„์˜ ์—ฐ์‚ฐ์€ ์šฐ์ธก์œผ๋กœ (32 - m)์นธ shift์™€ ๊ฐ™๋‹ค.

์ด๋ฅผ ์‹ค์ œ๋กœ ์ฝ”๋“œ๋กœ ๋‚˜ํƒ€๋‚ด๋ณธ๋‹ค๋ฉด

// ์‹ค์ œ๋กœ ์ •์ˆ˜๋ถ€๋ถ„์˜ m bit๋ฅผ ์–ป๊ธฐ ์œ„ํ•ด์„œ๋Š” 
// AK๋ฅผ ์™ผ์ชฝ์œผ๋กœ m์นธ์ด ์•„๋‹ˆ๋ผ 
// ์˜ค๋ฅธ์ชฝ์œผ๋กœ 32 - m์นธ ์ด๋™์‹œ์ผœ์•ผํ•จ
return A * K >> (32 - m);

์ด์™€ ๊ฐ™์ด ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

AK mod 1

Multiplicative Hashing์ด Middle Square Hashing๊ณผ ๋‹ค๋ฅธ ์ ์€ key์— ๊ณฑํ•  ์ƒ์ˆ˜๋ฅผ ์ž„์˜๋กœ ์ •ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด ์ด๋Ÿฌํ•œ ํŠน์ง•์ด ์–ด๋–ค ๊ฒฐ๊ณผ๋ฅผ ๋ถˆ๋Ÿฌ์˜ค๊ฒŒ ๋ ๊นŒ์š”?

๋งŒ์•ฝ A๋ฅผ w์— ๋Œ€ํ•ด์„œ relatively prime(์ตœ๋Œ€ ๊ณต์•ฝ์ˆ˜๊ฐ€ 1)ํ•œ ๊ฐ’์œผ๋กœ ์„ค์ •ํ•œ๋‹ค๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์ผ์ด ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

A` * A mod w = 1

์ด๋Ÿฌํ•œ ์ˆ˜์‹์„ ๋งŒ์กฑํ•˜๋Š” A`๊ฐ€ ์กด์žฌํ•ฉ๋‹ˆ๋‹ค.

๋งŒ์•ฝ A์™€ w์˜ ์ตœ๋Œ€ ๊ณต์•ฝ์ˆ˜๊ฐ€ 1์ด ์•„๋‹ˆ๋ผ๋ฉด

์•„๋ฌด๋ฆฌ A์— ์–ด๋–ค ๊ฐ’์„ ๊ณฑํ•˜๋”๋ผ๋„ A` * A mod w์˜ ๊ฐ’์€ ํ•ด๋‹น ์ตœ๋Œ€ ๊ณต์•ฝ์ˆ˜์˜ ๋ฐฐ์ˆ˜๋กœ ํ‘œํ˜„๋ฉ๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด x = 3 * p, y = 4 * p ์ด๊ณ , p๊ฐ€ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜์ด๋ฉด

p p p p
p p p
0 0 0 p // y๋ฅผ x๋กœ ๋‚˜๋ˆˆ ๊ฒฐ๊ณผ p๋งŒ ๋‚จ์Œ

์–ด๋А ๊ฒƒ์ด๋“  n๋ฐฐ๋ฅผ ํ•˜์—ฌ๋„ p๋‹จ์œ„๋กœ ๋Š˜์–ด๋‚˜๊ฒŒ ๋˜๊ณ , ํ•œ์ชฝ์„ ๋‹ค๋ฅธ ํ•œ์ชฝ์œผ๋กœ ๋‚˜๋ˆ„์–ด๋„ p๋‹จ์œ„๋กœ ๋‚จ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

์–‘ ๋ณ€์— K๋ฅผ ๊ณฑํ•˜๋ฉด

K * A` * A mod w = K 
=> K = ((A` mod w) * (AK mod w)) mod w  // mod์˜ ๊ณ„์‚ฐ ์„ฑ์งˆ ์‚ฌ์šฉ 
=> K = (A` * (AK mod w)) mod w  // A` mod w = A`

์ด๋ฅผ ํ†ตํ•ด์„œ A์™€ w๊ฐ€ relatively prime์ผ ๋•Œ, Key๊ฐ€ ๋‹ฌ๋ผ์ง„๋‹ค๋ฉด AK mod w ๋˜ํ•œ ๋‹ฌ๋ผ์ง„๋‹ค๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

c.f) A < w, K < w

์ด๋Ÿฌํ•œ ์„ฑ์งˆ์€ key๋ฅผ randomizeํ•  ์ˆ˜ ์žˆ๋Š” ์ข‹์€ scrambling function์œผ๋กœ ์‚ฌ์šฉ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.