pyflow-analysis 0.1.0__py3-none-any.whl

pyflow/util/PADS/IntegerPartitions.py

@@ -0,0 +1,317 @@
+"""Generate and manipulate partitions of integers into sums of integers.
+
+D. Eppstein, August 2005.
+"""
+
+import unittest
+
+
+def mckay(n):
+    """
+    Integer partitions of n, in reverse lexicographic order.
+    Note that the generated output consists of the same list object,
+    repeated the correct number of times; the caller must leave this
+    list unchanged, and must make a copy of any partition that is
+    intended to last longer than the next call into the generator.
+    The algorithm follows Knuth v4 fasc3 p38 in rough outline.
+    """
+    if n == 0:
+        yield []
+    if n <= 0:
+        return
+    partition = [n]
+    last_nonunit = (n > 1) - 1
+    while True:
+        yield partition
+        if last_nonunit < 0:
+            return
+        if partition[last_nonunit] == 2:
+            partition[last_nonunit] = 1
+            partition.append(1)
+            last_nonunit -= 1
+            continue
+        replacement = partition[last_nonunit] - 1
+        total_replaced = replacement + len(partition) - last_nonunit
+        reps, rest = divmod(total_replaced, replacement)
+        partition[last_nonunit:] = reps * [replacement]
+        if rest:
+            partition.append(rest)
+        last_nonunit = len(partition) - (partition[-1] == 1) - 1
+
+
+def revlex_partitions(n):
+    """
+    Integer partitions of n, in reverse lexicographic order.
+    The output and asymptotic runtime are the same as mckay(n),
+    but the algorithm is different: it involves no division,
+    and is simpler than mckay, but uses O(n) extra space for
+    a recursive call stack.
+    """
+    if n == 0:
+        yield []
+    if n <= 0:
+        return
+    for p in revlex_partitions(n - 1):
+        if len(p) == 1 or (len(p) > 1 and p[-1] < p[-2]):
+            p[-1] += 1
+            yield p
+            p[-1] -= 1
+        p.append(1)
+        yield p
+        p.pop()
+
+
+def lex_partitions(n):
+    """Similar to revlex_partitions, but in lexicographic order."""
+    if n == 0:
+        yield []
+    if n <= 0:
+        return
+    for p in lex_partitions(n - 1):
+        p.append(1)
+        yield p
+        p.pop()
+        if len(p) == 1 or (len(p) > 1 and p[-1] < p[-2]):
+            p[-1] += 1
+            yield p
+            p[-1] -= 1
+
+
+partitions = revlex_partitions  # default partition generating algorithm
+
+
+def binary_partitions(n):
+    """
+    Generate partitions of n into powers of two, in revlex order.
+    Knuth exercise 7.2.1.4.64.
+    The average time per output is constant.
+    But this doesn't really solve the exercise, because it isn't loopless...
+    """
+
+    # Generate the binary representation of n
+    if n < 0:
+        return
+    pow = 1
+    sum = 0
+    while pow <= n:
+        pow <<= 1
+    partition = []
+    while pow:
+        if sum + pow <= n:
+            partition.append(pow)
+            sum += pow
+        pow >>= 1
+
+    # Find all partitions of numbers up to n into powers of two > 1,
+    # in revlex order, by repeatedly splitting the smallest nonunit power,
+    # and replacing the following sequence of 1's by the first revlex
+    # partition with maximum power less than the result of the split.
+
+    # Time analysis:
+    #
+    # Each outer iteration increases len(partition) by at most one
+    # (only if the power being split is a 2) and each inner iteration
+    # in which some ones are replaced by x decreases len(partition),
+    # so the number of those inner iterations is less than one per
+    # output.
+    #
+    # Each time a power 2^k is split, it creates two or more 2^{k-1}'s,
+    # all of which must eventually be split as well.  So, it S_k denotes
+    # the number of times a 2^k is split, and X denotes the total
+    # number of outputs generated, then S_k <= X/2^{k-1}.
+    # On an outer iteration in which 2^k is split, there will be k
+    # inner iterations in which x is halved, so the total number
+    # of such inner iterations is <= sum_k k*X/2^{k-1} = O(X).
+    #
+    # Therefore the overall average time per output is constant.
+
+    last_nonunit = len(partition) - 1 - (n & 1)
+    while True:
+        yield partition
+        if last_nonunit < 0:
+            return
+        if partition[last_nonunit] == 2:
+            partition[last_nonunit] = 1
+            partition.append(1)
+            last_nonunit -= 1
+            continue
+        partition.append(1)
+        x = partition[last_nonunit] = partition[last_nonunit + 1] = (
+            partition[last_nonunit] >> 1
+        )  # make the split!
+        last_nonunit += 1
+        while x > 1:
+            if len(partition) - last_nonunit - 1 >= x:
+                del partition[-x + 1 :]
+                last_nonunit += 1
+                partition[last_nonunit] = x
+            else:
+                x >>= 1
+
+
+def fixed_length_partitions(n, L):
+    """
+    Integer partitions of n into L parts, in colex order.
+    The algorithm follows Knuth v4 fasc3 p38 in rough outline;
+    Knuth credits it to Hindenburg, 1779.
+    """
+
+    # guard against special cases
+    if L == 0:
+        if n == 0:
+            yield []
+        return
+    if L == 1:
+        if n > 0:
+            yield [n]
+        return
+    if n < L:
+        return
+
+    partition = [n - L + 1] + (L - 1) * [1]
+    while True:
+        yield partition
+        if partition[0] - 1 > partition[1]:
+            partition[0] -= 1
+            partition[1] += 1
+            continue
+        j = 2
+        s = partition[0] + partition[1] - 1
+        while j < L and partition[j] >= partition[0] - 1:
+            s += partition[j]
+            j += 1
+        if j >= L:
+            return
+        partition[j] = x = partition[j] + 1
+        j -= 1
+        while j > 0:
+            partition[j] = x
+            s -= x
+            j -= 1
+        partition[0] = s
+
+
+def conjugate(p):
+    """
+    Find the conjugate of a partition.
+    E.g. len(p) = max(conjugate(p)) and vice versa.
+    """
+    result = []
+    j = len(p)
+    if j <= 0:
+        return result
+    while True:
+        result.append(j)
+        while len(result) >= p[j - 1]:
+            j -= 1
+            if j == 0:
+                return result
+
+
+# If run standalone, perform unit tests
+
+
+class PartitionTest(unittest.TestCase):
+    counts = [1, 1, 2, 3, 5, 7, 11, 15, 22, 30, 42, 56, 77, 101, 135]
+
+    def testCounts(self):
+        """Check that each generator has the right number of outputs."""
+        for n in range(len(self.counts)):
+            self.assertEqual(self.counts[n], len(list(mckay(n))))
+            self.assertEqual(self.counts[n], len(list(lex_partitions(n))))
+            self.assertEqual(self.counts[n], len(list(revlex_partitions(n))))
+
+    def testSums(self):
+        """Check that all outputs are partitions of the input."""
+        for n in range(len(self.counts)):
+            for p in mckay(n):
+                self.assertEqual(n, sum(p))
+            for p in revlex_partitions(n):
+                self.assertEqual(n, sum(p))
+            for p in lex_partitions(n):
+                self.assertEqual(n, sum(p))
+
+    def testRevLex(self):
+        """Check that the revlex generators' outputs are in revlex order."""
+        for n in range(len(self.counts)):
+            last = [n + 1]
+            for p in mckay(n):
+                self.assert_(last > p)
+                last = list(p)  # make less-mutable copy
+            last = [n + 1]
+            for p in revlex_partitions(n):
+                self.assert_(last > p)
+                last = list(p)  # make less-mutable copy
+
+    def testLex(self):
+        """Check that the lex generator's outputs are in lex order."""
+        for n in range(1, len(self.counts)):
+            last = []
+            for p in lex_partitions(n):
+                if not (last < p):
+                    print("last:", last, "p:", p)
+                self.assert_(last < p)
+                last = list(p)  # make less-mutable copy
+
+    def testRange(self):
+        """Check that all numbers in output partitions are in range."""
+        for n in range(len(self.counts)):
+            for p in mckay(n):
+                for x in p:
+                    self.assert_(0 < x <= n)
+            for p in lex_partitions(n):
+                for x in p:
+                    self.assert_(0 < x <= n)
+            for p in revlex_partitions(n):
+                for x in p:
+                    self.assert_(0 < x <= n)
+
+    def testFixedLength(self):
+        """Check that the fixed length partition outputs are correct."""
+        for n in range(len(self.counts)):
+            pn = [list(p) for p in revlex_partitions(n)]
+            pn.sort()
+            np = 0
+            for L in range(n + 1):
+                pnL = [list(p) for p in fixed_length_partitions(n, L)]
+                pnL.sort()
+                np += len(pnL)
+                self.assertEqual(pnL, [p for p in pn if len(p) == L])
+            self.assertEqual(np, len(pn))
+
+    def testConjugatePartition(self):
+        """Check that conjugating a partition forms another partition."""
+        for n in range(len(self.counts)):
+            for p in partitions(n):
+                c = conjugate(p)
+                for x in c:
+                    self.assert_(0 < x <= n)
+                self.assertEqual(sum(c), n)
+
+    def testConjugateInvolution(self):
+        """Check that double conjugation returns the same partition."""
+        for n in range(len(self.counts)):
+            for p in partitions(n):
+                self.assertEqual(p, conjugate(conjugate(p)))
+
+    def testConjugateMaxLen(self):
+        """Check the max-length reversing property of conjugation."""
+        for n in range(1, len(self.counts)):
+            for p in partitions(n):
+                self.assertEqual(len(p), max(conjugate(p)))
+
+    def testBinary(self):
+        """Test that the binary partitions are generated correctly."""
+        for n in range(len(self.counts)):
+            binaries = []
+            for p in partitions(n):
+                for x in p:
+                    if x & (x - 1):
+                        break
+                else:
+                    binaries.append(list(p))
+            self.assertEqual(binaries, [list(p) for p in binary_partitions(n)])
+
+
+if __name__ == "__main__":
+    unittest.main()

pyflow/util/PADS/LCA.py

@@ -0,0 +1,349 @@
+"""Range minimization and tree least common ancestor data structures
+with linear space and preprocessing time, and constant query time,
+from Bender and Farach-Colton, "The LCA Problem Revisited",
+Proc. LATIN 2000 (pp.88-94), http://www.cs.sunysb.edu/~bender/pub/lca.ps
+
+Some experimentation would be needed to determine how large a query
+range needs to be to make this faster than computing the min of the range
+directly, and how much input data is needed to make the linear space
+version pay off compared to the much simpler LogarithmicRangeMin that
+it uses as a subroutine.
+
+D. Eppstein, November 2003.
+"""
+
+import unittest, random
+from pyflow.util.PADS.UnionFind import UnionFind
+
+# sets.Set is deprecated in Python 3, use built-in set instead
+
+
+class RangeMin:
+    """If X is any list, RangeMin(X)[i:j] == min(X[i:j]).
+    Initializing RangeMin(X) takes time and space linear in len(X),
+    and querying the minimum of a range takes constant time per query.
+    """
+
+    def __init__(self, X):
+        """Set up structure with sequence X as data.
+        Uses an LCA structure on a Cartesian tree for the input."""
+        self._data = list(X)
+        if len(X) > 1:
+            big = map(max, self._ansv(False), self._ansv(True))
+            parents = dict([(i, big[i][1]) for i in range(len(X)) if big[i]])
+            self._lca = LCA(parents)
+
+    def __getslice__(self, left, right):
+        """Return min(X[left:right])."""
+        right = min(right, len(self._data))  # handle omitted right index
+        if right <= left:
+            return None  # empty range has no minimum
+        return self._data[self._lca(left, right - 1)]
+
+    def __len__(self):
+        """How much data do we have?  Needed for negative index in slice."""
+        return len(self._data)
+
+    def _ansv(self, reversed):
+        """All nearest smaller values.
+        For each x in the data, find the value smaller than x in the closest
+        position to the left of x (if not reversed) or to the right of x
+        (if reversed), and return list of pairs (smaller value,position).
+        Due to our use of positions as a tie-breaker, values equal to x
+        count as smaller on the left and larger on the right.
+        """
+        stack = [None]  # protect stack top with sentinel
+        output = [0] * len(self._data)
+        for xi in _pairs(self._data, reversed):
+            while stack[-1] > xi:
+                stack.pop()
+            output[xi[1]] = stack[-1]
+            stack.append(xi)
+        return output
+
+    def _lca(self, first, last):
+        """Function to replace LCA when we have too little data."""
+        return 0
+
+
+class RestrictedRangeMin:
+    """Linear-space RangeMin for integer data obeying the constraint
+        abs(X[i]-X[i-1])==1.
+    We don't actually check this constraint, but results may be incorrect
+    if it is violated.  For the use of this data structure from LCA, the
+    data are actually pairs rather than integers, but the minima of
+    all ranges are in the same positions as the minima of the integers
+    in the first positions of each pair, so the data structure still works.
+    """
+
+    def __init__(self, X):
+        # Compute parameters for partition into blocks.
+        # Position i in X becomes transformed into
+        # position i&self._blockmask in block i>>self.blocklen
+        self._blocksize = _log2(len(X)) // 2
+        self._blockmask = (1 << self._blocksize) - 1
+        blocklen = 1 << self._blocksize
+
+        # Do partition into blocks, find minima within
+        # each block, prefix minima in each block,
+        # and suffix minima in each block
+        blocks = []  # map block to block id
+        ids = {}  # map block id to PrecomputedRangeMin
+        blockmin = []  # map block to min value
+        self._prefix = [None]  # map data index to prefix min of block
+        self._suffix = []  # map data index to suffix min of block
+        for i in range(0, len(X), blocklen):
+            XX = X[i : i + blocklen]
+            blockmin.append(min(XX))
+            self._prefix += PrefixMinima(XX)
+            self._suffix += PrefixMinima(XX, reversed=True)
+            blockid = len(XX) < blocklen and -1 or self._blockid(XX)
+            blocks.append(blockid)
+            if blockid not in ids:
+                ids[blockid] = PrecomputedRangeMin(_pairs(XX))
+        self._blocks = [ids[b] for b in blocks]
+
+        # Build data structure for interblock queries
+        self._blockrange = LogarithmicRangeMin(blockmin)
+        self._data = list(X)
+
+    def __getslice__(self, left, right):
+        firstblock = left >> self._blocksize
+        lastblock = (right - 1) >> self._blocksize
+        if firstblock == lastblock:
+            i = left & self._blockmask
+            position = self._blocks[firstblock][i : i + right - left][1]
+            return self._data[position + (firstblock << self._blocksize)]
+        else:
+            best = min(self._suffix[left], self._prefix[right])
+            if lastblock > firstblock + 1:
+                best = min(best, self._blockrange[firstblock + 1 : lastblock])
+            return best
+
+    def _blockid(self, XX):
+        """Return value such that all blocks with the same
+        pattern of increments and decrements get the same id.
+        """
+        blockid = 0
+        for i in range(1, len(XX)):
+            blockid = blockid * 2 + (XX[i] > XX[i - 1])
+        return blockid
+
+
+class PrecomputedRangeMin:
+    """RangeMin solved in quadratic space by precomputing all solutions."""
+
+    def __init__(self, X):
+        self._minima = [PrefixMinima(X[i:]) for i in range(len(X))]
+
+    def __getslice__(self, x, y):
+        return self._minima[x][y - x - 1]
+
+    def __len__(self):
+        return len(self._minima)
+
+
+class LogarithmicRangeMin:
+    """RangeMin in O(n log n) space and constant query time."""
+
+    def __init__(self, X):
+        """Compute min(X[i:i+2**j]) for each possible i,j."""
+        self._minima = m = [list(X)]
+        for j in range(_log2(len(X))):
+            m.append(map(min, m[-1], m[-1][1 << j :]))
+
+    def __getslice__(self, x, y):
+        """Find range minimum by representing range as the union
+        of two overlapping subranges with power-of-two lengths.
+        """
+        j = _logtable[y - x]
+        row = self._minima[j]
+        return min(row[x], row[y - 2**j])
+
+    def __len__(self):
+        return len(self._minima[0])
+
+
+class LCA:
+    """Structure for finding least common ancestors in trees.
+    Tree nodes may be any hashable objects; a tree is specified
+    by a dictionary mapping nodes to their parents.
+    LCA(T)(x,y) finds the LCA of nodes x and y in tree T.
+    """
+
+    def __init__(self, parent, RangeMinFactory=RestrictedRangeMin):
+        """Construct LCA structure from tree parent relation."""
+        children = {}
+        for x in parent:
+            children.setdefault(parent[x], []).append(x)
+        root = [x for x in children if x not in parent]
+        if len(root) != 1:
+            raise ValueError("LCA input is not a tree")
+
+        levels = []
+        self._representatives = {}
+        self._visit(children, levels, root[0], 0)
+        if [x for x in parent if x not in self._representatives]:
+            raise ValueError("LCA input is not a tree")
+        self._rangemin = RangeMinFactory(levels)
+
+    def __call__(self, *nodes):
+        """Find least common ancestor of a set of nodes."""
+        r = [self._representatives[x] for x in nodes]
+        return self._rangemin[min(r) : max(r) + 1][1]
+
+    def _visit(self, children, levels, node, level):
+        """Perform Euler traversal of tree."""
+        self._representatives[node] = len(levels)
+        pair = (level, node)
+        levels.append(pair)
+        for child in children.get(node, []):
+            self._visit(children, levels, child, level + 1)
+            levels.append(pair)
+
+
+class OfflineLCA(dict):
+    """Find LCAs of all pairs in a given sequence, using Union-Find."""
+
+    def __init__(self, parent, pairs):
+        """Set up to find LCAs of pairs in tree defined by parent.
+        LCA of any given pair x,y can then be found by self[x][y].
+        However unlike the online LCA structure we can not find LCAs
+        of pairs that are not supplied to us at startup time.
+        """
+
+        # set up dictionary where answers get stored
+        dict.__init__(self)
+        for u, v in pairs:
+            self.setdefault(u, {})[v] = self.setdefault(v, {})[u] = None
+
+        # set up data structure for finding node ancestor on search path
+        # self.descendants forms a collection of disjoint sets,
+        #    one set for the descendants of each search path node.
+        # self.ancestors maps disjoint set ids to the ancestors themselves.
+        self.descendants = UnionFind()
+        self.ancestors = {}
+
+        # invert the parent relationship so we can traverse the tree
+        self.children = {}
+        for x, px in parent.items():
+            self.children.setdefault(px, []).append(x)
+        root = [x for x in self.children if x not in parent]
+        if len(root) != 1:
+            raise ValueError("LCA input is not a tree")
+
+        # initiate depth first traversal
+        self.visited = set()
+        self.traverse(root[0])
+
+    def traverse(self, node):
+        """Perform depth first traversal of tree."""
+        self.ancestors[self.descendants[node]] = node
+        for child in self.children.get(node, []):
+            self.traverse(child)
+            self.descendants.union(child, node)
+            self.ancestors[self.descendants[node]] = node
+        self.visited.add(node)
+        for query in self[node]:
+            if query in self.visited:
+                lca = self.ancestors[self.descendants[query]]
+                self[node][query] = self[query][node] = lca
+
+
+# Various utility functions
+
+
+def PrefixMinima(X, reversed=False):
+    """Compute table of prefix minima
+    (or suffix minima, if reversed=True) of list X.
+    """
+    current = None
+    output = [None] * len(X)
+    for x, i in _pairs(X, reversed):
+        if current is None:
+            current = x
+        else:
+            current = min(current, x)
+        output[i] = current
+    return output
+
+
+def _pairs(X, reversed=False):
+    """Return pairs (x,i) for x in list X, where i is
+    the index of x in the data, in forward or reverse order.
+    """
+    indices = range(len(X))
+    if reversed:
+        indices.reverse()
+    return [(X[i], i) for i in indices]
+
+
+_logtable = [None, 0]
+
+
+def _log2(n):
+    """Make table of logs reach up to n and return floor(log_2(n))."""
+    while len(_logtable) <= n:
+        _logtable.extend([1 + _logtable[-1]] * len(_logtable))
+    return _logtable[n]
+
+
+# if run as "python LCA.py", run tests on random data
+# and check that RangeMin's results are correct.
+
+
+class RandomRangeMinTest(unittest.TestCase):
+    def testRangeMin(self):
+        for trial in range(20):
+            data = [
+                random.choice(range(1000000)) for i in range(random.randint(1, 100))
+            ]
+            R = RangeMin(data)
+            for sample in range(100):
+                i = random.randint(0, len(data) - 1)
+                j = random.randint(i + 1, len(data))
+                self.assertEqual(R[i:j], min(data[i:j]))
+
+
+class LCATest(unittest.TestCase):
+    parent = {
+        "b": "a",
+        "c": "a",
+        "d": "a",
+        "e": "b",
+        "f": "b",
+        "g": "f",
+        "h": "g",
+        "i": "g",
+    }
+    lcas = {
+        ("a", "b"): "a",
+        ("b", "c"): "a",
+        ("c", "d"): "a",
+        ("d", "e"): "a",
+        ("e", "f"): "b",
+        ("e", "g"): "b",
+        ("e", "h"): "b",
+        ("c", "i"): "a",
+        ("a", "i"): "a",
+        ("f", "i"): "f",
+    }
+
+    def testLCA(self):
+        L = LCA(self.parent)
+        for k, v in self.lcas.items():
+            self.assertEqual(L(*k), v)
+
+    def testLogLCA(self):
+        L = LCA(self.parent, LogarithmicRangeMin)
+        for k, v in self.lcas.items():
+            self.assertEqual(L(*k), v)
+
+    def testOfflineLCA(self):
+        L = OfflineLCA(self.parent, self.lcas.keys())
+        for (p, q), v in self.lcas.items():
+            self.assertEqual(L[p][q], v)
+
+
+if __name__ == "__main__":
+    unittest.main()

pyflow/util/PADS/LCS.py

@@ -0,0 +1,38 @@
+"""Dynamic program for longest common subsequences
+
+D. Eppstein, March 2002.
+"""
+
+
+def LongestCommonSubsequence(A, B):
+    """Find longest common subsequence of iterables A and B."""
+    A = list(A)
+    B = list(B)
+
+    # Fill dictionary lcsLen[i,j] with length of LCS of A[:i] and B[:j]
+    lcsLen = {}
+    for i in range(len(A) + 1):
+        for j in range(len(B) + 1):
+            if i == 0 or j == 0:
+                lcsLen[i, j] = 0
+            elif A[i - 1] == B[j - 1]:
+                lcsLen[i, j] = lcsLen[i - 1, j - 1] + 1
+            else:
+                lcsLen[i, j] = max(lcsLen[i - 1, j], lcsLen[i, j - 1])
+
+    # Produce actual sequence by backtracking through pairs (i,j),
+    # using computed lcsLen values to guide backtracking
+    i = len(A)
+    j = len(B)
+    LCS = []
+    while lcsLen[i, j]:
+        while lcsLen[i, j] == lcsLen[i - 1, j]:
+            i -= 1
+        while lcsLen[i, j] == lcsLen[i, j - 1]:
+            j -= 1
+        i -= 1
+        j -= 1
+        LCS.append(A[i])
+
+    LCS.reverse()
+    return LCS