Delete arithmetic.py

arithmetic.py

-# Example implementation of simple arithmetic coding in Python (2.7+).
-#
-# USAGE 
-# 
-#  python -i arithmetic.py
-#  >>> m = {'a': 1, 'b': 1, 'c': 1}
-#  >>> model = dirichlet(m)
-#  >>> encode(model, "aabbaacc")	
-#  '00011110011110010'
-#
-# NOTES
-#
-#  This implementation has many shortcomings, e.g., 
-#   - There are several inefficient tests, loops, and conversions
-#   - There are a few places where code is uncessarily duplicated
-#   - It does not output the coded message as a stream
-#   - It can only code short messages due to machine precision
-#   - The is no defensive coding against errors (e.g., out-of-model symbols)
-#   - I've not implemented a decoder!
-#
-#  The aim was to make the implementation here as close as possible to
-#  the algorithm described in lectures while giving some extra detail about
-#  routines such as finding extensions to binary intervals.
-#
-#  For a more sophisticated implementation, please refer to:
-#
-#    "Arithmetic Coding for Data Compression"
-#    I. H. Witten, R. M. Neal, and J. G. Cleary
-#    Communications of the ACM, Col. 30 (6), 1987
-#
-# AUTHOR: Mark Reid
-# CREATED: 2014-09-30
-
-def encode(G, stream):
-    '''
-    Arithmetically encodes the given stream using the guesser function G
-    which returns probabilities over symbols P(x|xs) given a sequence xs.
-    '''
-    
-    u, v = 0.0, 1.0     # The interval [u, v) for the message
-    xs, bs = "", ""     # The message xs, and binary code bs
-    p = G(xs)           # Compute the initial distribution over symbols
-
-    # Iterate through stream, repeatedly finding the longest binary code 
-    # that surrounds the interval for the message so far
-    for x in stream:
-        # Record the new symbol
-        xs += x    
-
-        # Find the interval for the message so far
-        F_lo, F_hi = cdf_interval(p, x)        
-        u, v = u + (v-u)*F_lo, u + (v-u)*F_hi
-
-        # Find a binary code whose interval surrounds [u,v)
-        bs = extend_around(bs, u, v)
-
-        # Update the symbol probabilities
-        p = G(xs)
-
-    # Stream finished so find shortest extension of the code that sits inside
-    # the top half of [u, v)
-    bs = extend_inside(bs, u + (v-u)/2, v)
-
-    return bs
-
-##############################################################################
-# Models
-
-def dirichlet(m):
-    '''
-    Returns a Dirichlet model (as a function) for probabilities with 
-    prior counts given by the symbol to count dictionary m.
-    Probabilities returned by the returned functions are (symbol, prob)
-    dictionaries.
-    '''
-
-    # Build a function that returns P(x|xs) based on the priors in m
-    # and the counts of the symbols in xs
-    def p(xs):
-        counts = m.copy()
-        for x in xs:
-            counts[x] += 1
-
-        total = sum(counts.values())
-        return { a: float(c)/total for a, c in counts.items() }
-
-    # Return the constructed function
-    return p
-
-##############################################################################
-# Interval methods
-
-def cdf_interval(p, a):
-    '''
-    Compute the cumulative distribution interval [F(a'), F(a)) for the 
-    probabilities p (represented as a (symbol,prob) dict) where
-    F(a) = P(x <= a) and a' is the symbol preceeding a.
-    '''
-
-    F_lo, F_hi = 0, 0
-
-    A = sorted(p)
-    for x in A:
-        F_lo, F_hi = F_hi, F_hi + p[x]
-        if x == a:
-            break
-    
-    return F_lo, F_hi
-
-def binary_interval(bs):
-    '''
-    Returns an interval [n, m) for n and m integers, and denominator d
-    representing the interval [n/d, m/d) for the binary string bs.
-    '''
-    
-    n, d = to_rational(bs)
-    return n, n + 1, d
-
-def to_rational(bs):
-    '''Return numerator and denominator for ratio of 0.bs.'''
-    n = 0
-    for b in bs:
-        n *= 2
-        n += int(b)
-    
-    return n, 2**len(bs) 
-
-def around(bs, u, v):
-    '''Tests whether [0.bs, 0.bs111...) contains [u, v).'''
-    n, m, d = binary_interval(bs)
-    return (n <= u*d) and (v*d <= m)
-
-def extend_around(bs, u, v):
-    '''Find the longest extension of the given binary string so its interval 
-       wraps around the interval [u, v).'''
-    
-    contained = True
-    while contained:
-        if around(bs + "0", u, v):
-            bs += "0"
-        elif around(bs + "1", u, v):
-            bs += "1"
-        else:
-            contained = False
-    
-    return bs
-
-def inside(bs, u, v):
-    '''Tests whether [0.bs, 0.bs111...) is contained by [u, v).'''
-    n, m, d = binary_interval(bs)
-    return (u*d <= n) and (m <= v*d)
-
-def extend_inside(bs, u, v):
-    '''Find the shortest extension of the given binary string so its interval 
-       sits inside the interval [u, v).'''
-    
-    while not inside(bs, u, v):
-        # Test whether gap between binary interval and [u,v) is bigger at the
-        # bottom than at the top
-        n, m, d = binary_interval(bs)
-        if u*d - n > m - v*d:
-            bs += "1"   # If so, move bottom up by halving
-        else:
-            bs += "0"   # If not, move top down by halving
-                
-    return bs
-