View
213
Download
0
Category
Preview:
Citation preview
Integer Representations and Counting in the Bit Probe Model
M. Zaiur Rahman and J. Ian MunroCheriton School of Computer Science
University of WaterlooWaterloo On
Canada
Integer Representations
• Standard: n bits representing {0..2n}
• # bits … optimal
• Increment: – Θ(n) bit inspections/changes worst case– O(1) amortized, but not if we include
decrement
Redundant Binary Numbers
• Use “digits” 0,1,2 but representation is in binary, 2 is a delayed carrye.g. 01220 = 10100
• Space 2n bits (or reduce to about (lg 3) n)– Increment O(1), as we de-amortize the scan
to release the rightmost carry– Decrement is tricky, easiest to use digit “-1”– Note the extra lg n bits for the scan pointer
Gray Codes .. Due to Gray ..of course
Binary Reflected Gray Code (BRGC)– Of dimension n (i.e. n bits, numbers [0..2n]– A sequence of 2n strings each of length n
G(n) = 0.G(n-1), 1.G(n-1)R
(reversal is on the sequence order, not the individual codes)
Increment on a Gray Code
• Even parity: flip rightmost 1 bit
Increment on a Gray Code
• Even parity: flip rightmost bit
00110000 → 00110001
Increment on a Gray Code
• Even parity: flip rightmost bit
00110000 → 00110001
• Odd parity: flip the bit to left of rightmost 1
01110000 → 01010000
Increment on a Gray Code
• Even parity: flip rightmost bit
00110000 → 00110001
• Odd parity: flip the bit to left of rightmost 1
01110000 → 01010000• Costs:1 bit changed, n inspections (worst case)
• Or: add parity bit, O(1) amortized insert, 2 bits changed
• Integrate parity bit with code (no extra bit [Lucal])
Our First Result: Lower Bound
Theorem: Any representation of [0..2n] using exactly n bits requires Ω(√n) bit inspections in the worst case.
Proof: Model, apply Sunflower Lemma and manipulate
Sunflower Lemma [Ёrdos & Rado]
• Sunflower with p petals– Sets S1, …, Sp so SiSj is same for all i,j
Lemma: S1, …, Sp is a system of sets each of size at most q. If m>(p-1)q+1q!, then it contains a subcollection with p petals
Use the lemma with m as small as possible
Back to Algorithms
• We want a scheme that balances (as well as possible)– Bit changes– Bit inspections– Extra bits
Lower bound says no extra bits lots of inspections
The increment in BRGC
• Key issue … that rightmost 1
Lemma: On increment or decrement, the position of rightmost 1 in any segment of the leftmost bits changes only when that bit is flipped, except for the case of leftmost bit going 1→0 on increment (or 0 → 1 on decrement)
De-amortizing
• The lemma lets us de-amortize: as with redundant binary representation.
With some details:
Theorem: There is a representation using n + lg n + 3 bits (a pointer is in there), requiring 2 lg n +4 bit inspections and 4 bit changes for increment or decrement.
Moving Along
• Complicating issue:Mixing increments and decrements forces us to add flags – (for {inc, dec} and {done yet , not done}
• Idea: use the lower order lg n bits to give the pointer into the leftmost n - lg n bits– This would seem to require a table (or model
issue) to translate
But
• Permute the code of the leading n – lg n bits and use trailing bits directly to walk through them in “code order”
• Indeed, we don’t need n – lg n to be a power of 2
Theorem: There is a representation using n + 3 bits, requiring lg n + 6 bit inspections and 7 bit changes for increment or decrement.
Addition and Subtraction
• Adding or subtracting and m digit (standard notation) integer to update an n digit integer (n > m): – n + O(lg2n) bits, – O(m + lg n) inspections/changes
Open Issues
• Improve the lower bound to n bits inspected in no extra bits
• Lower bound trading off bits changed with space and bits inspected
• Tweaking upper bounds
Recommended