original

Author: hsiangjenli

library/itertools.po

@@ -1981,6 +1981,175 @@ msgid ""
 "        while True:\n"
 "            yield function()"
 msgstr ""
+"from collections import Counter, deque\n"
+"from contextlib import suppress\n"
+"from functools import reduce\n"
+"from math import comb, prod, sumprod, isqrt\n"
+"from operator import itemgetter, getitem, mul, neg\n"
+"\n"
+"def take(n, iterable):\n"
+"    \"Return first n items of the iterable as a list.\"\n"
+"    return list(islice(iterable, n))\n"
+"\n"
+"def prepend(value, iterable):\n"
+"    \"Prepend a single value in front of an iterable.\"\n"
+"    # prepend(1, [2, 3, 4]) → 1 2 3 4\n"
+"    return chain([value], iterable)\n"
+"\n"
+"def tabulate(function, start=0):\n"
+"    \"Return function(0), function(1), ...\"\n"
+"    return map(function, count(start))\n"
+"\n"
+"def repeatfunc(function, times=None, *args):\n"
+"    \"Repeat calls to a function with specified arguments.\"\n"
+"    if times is None:\n"
+"        return starmap(function, repeat(args))\n"
+"    return starmap(function, repeat(args, times))\n"
+"\n"
+"def flatten(list_of_lists):\n"
+"    \"Flatten one level of nesting.\"\n"
+"    return chain.from_iterable(list_of_lists)\n"
+"\n"
+"def ncycles(iterable, n):\n"
+"    \"Returns the sequence elements n times.\"\n"
+"    return chain.from_iterable(repeat(tuple(iterable), n))\n"
+"\n"
+"def loops(n):\n"
+"    \"Loop n times. Like range(n) but without creating integers.\"\n"
+"    # for _ in loops(100): ...\n"
+"    return repeat(None, n)\n"
+"\n"
+"def tail(n, iterable):\n"
+"    \"Return an iterator over the last n items.\"\n"
+"    # tail(3, 'ABCDEFG') → E F G\n"
+"    return iter(deque(iterable, maxlen=n))\n"
+"\n"
+"def consume(iterator, n=None):\n"
+"    \"Advance the iterator n-steps ahead. If n is None, consume entirely.\"\n"
+"    # Use functions that consume iterators at C speed.\n"
+"    if n is None:\n"
+"        deque(iterator, maxlen=0)\n"
+"    else:\n"
+"        next(islice(iterator, n, n), None)\n"
+"\n"
+"def nth(iterable, n, default=None):\n"
+"    \"Returns the nth item or a default value.\"\n"
+"    return next(islice(iterable, n, None), default)\n"
+"\n"
+"def quantify(iterable, predicate=bool):\n"
+"    \"Given a predicate that returns True or False, count the True results."
+"\"\n"
+"    return sum(map(predicate, iterable))\n"
+"\n"
+"def first_true(iterable, default=False, predicate=None):\n"
+"    \"Returns the first true value or the *default* if there is no true "
+"value.\"\n"
+"    # first_true([a,b,c], x) → a or b or c or x\n"
+"    # first_true([a,b], x, f) → a if f(a) else b if f(b) else x\n"
+"    return next(filter(predicate, iterable), default)\n"
+"\n"
+"def all_equal(iterable, key=None):\n"
+"    \"Returns True if all the elements are equal to each other.\"\n"
+"    # all_equal('4٤௪౪໔', key=int) → True\n"
+"    return len(take(2, groupby(iterable, key))) <= 1\n"
+"\n"
+"def unique_justseen(iterable, key=None):\n"
+"    \"Yield unique elements, preserving order. Remember only the element "
+"just seen.\"\n"
+"    # unique_justseen('AAAABBBCCDAABBB') → A B C D A B\n"
+"    # unique_justseen('ABBcCAD', str.casefold) → A B c A D\n"
+"    if key is None:\n"
+"        return map(itemgetter(0), groupby(iterable))\n"
+"    return map(next, map(itemgetter(1), groupby(iterable, key)))\n"
+"\n"
+"def unique_everseen(iterable, key=None):\n"
+"    \"Yield unique elements, preserving order. Remember all elements ever "
+"seen.\"\n"
+"    # unique_everseen('AAAABBBCCDAABBB') → A B C D\n"
+"    # unique_everseen('ABBcCAD', str.casefold) → A B c D\n"
+"    seen = set()\n"
+"    if key is None:\n"
+"        for element in filterfalse(seen.__contains__, iterable):\n"
+"            seen.add(element)\n"
+"            yield element\n"
+"    else:\n"
+"        for element in iterable:\n"
+"            k = key(element)\n"
+"            if k not in seen:\n"
+"                seen.add(k)\n"
+"                yield element\n"
+"\n"
+"def unique(iterable, key=None, reverse=False):\n"
+"   \"Yield unique elements in sorted order. Supports unhashable inputs.\"\n"
+"   # unique([[1, 2], [3, 4], [1, 2]]) → [1, 2] [3, 4]\n"
+"   sequenced = sorted(iterable, key=key, reverse=reverse)\n"
+"   return unique_justseen(sequenced, key=key)\n"
+"\n"
+"def sliding_window(iterable, n):\n"
+"    \"Collect data into overlapping fixed-length chunks or blocks.\"\n"
+"    # sliding_window('ABCDEFG', 4) → ABCD BCDE CDEF DEFG\n"
+"    iterator = iter(iterable)\n"
+"    window = deque(islice(iterator, n - 1), maxlen=n)\n"
+"    for x in iterator:\n"
+"        window.append(x)\n"
+"        yield tuple(window)\n"
+"\n"
+"def grouper(iterable, n, *, incomplete='fill', fillvalue=None):\n"
+"    \"Collect data into non-overlapping fixed-length chunks or blocks.\"\n"
+"    # grouper('ABCDEFG', 3, fillvalue='x') → ABC DEF Gxx\n"
+"    # grouper('ABCDEFG', 3, incomplete='strict') → ABC DEF ValueError\n"
+"    # grouper('ABCDEFG', 3, incomplete='ignore') → ABC DEF\n"
+"    iterators = [iter(iterable)] * n\n"
+"    match incomplete:\n"
+"        case 'fill':\n"
+"            return zip_longest(*iterators, fillvalue=fillvalue)\n"
+"        case 'strict':\n"
+"            return zip(*iterators, strict=True)\n"
+"        case 'ignore':\n"
+"            return zip(*iterators)\n"
+"        case _:\n"
+"            raise ValueError('Expected fill, strict, or ignore')\n"
+"\n"
+"def roundrobin(*iterables):\n"
+"    \"Visit input iterables in a cycle until each is exhausted.\"\n"
+"    # roundrobin('ABC', 'D', 'EF') → A D E B F C\n"
+"    # Algorithm credited to George Sakkis\n"
+"    iterators = map(iter, iterables)\n"
+"    for num_active in range(len(iterables), 0, -1):\n"
+"        iterators = cycle(islice(iterators, num_active))\n"
+"        yield from map(next, iterators)\n"
+"\n"
+"def subslices(seq):\n"
+"    \"Return all contiguous non-empty subslices of a sequence.\"\n"
+"    # subslices('ABCD') → A AB ABC ABCD B BC BCD C CD D\n"
+"    slices = starmap(slice, combinations(range(len(seq) + 1), 2))\n"
+"    return map(getitem, repeat(seq), slices)\n"
+"\n"
+"def iter_index(iterable, value, start=0, stop=None):\n"
+"    \"Return indices where a value occurs in a sequence or iterable.\"\n"
+"    # iter_index('AABCADEAF', 'A') → 0 1 4 7\n"
+"    seq_index = getattr(iterable, 'index', None)\n"
+"    if seq_index is None:\n"
+"        iterator = islice(iterable, start, stop)\n"
+"        for i, element in enumerate(iterator, start):\n"
+"            if element is value or element == value:\n"
+"                yield i\n"
+"    else:\n"
+"        stop = len(iterable) if stop is None else stop\n"
+"        i = start\n"
+"        with suppress(ValueError):\n"
+"            while True:\n"
+"                yield (i := seq_index(value, i, stop))\n"
+"                i += 1\n"
+"\n"
+"def iter_except(function, exception, first=None):\n"
+"    \"Convert a call-until-exception interface to an iterator interface.\"\n"
+"    # iter_except(d.popitem, KeyError) → non-blocking dictionary iterator\n"
+"    with suppress(exception):\n"
+"        if first is not None:\n"
+"            yield first()\n"
+"        while True:\n"
+"            yield function()"
 
 #: ../../library/itertools.rst:1008
 msgid "The following recipes have a more mathematical flavor:"
@@ -2112,3 +2281,126 @@ msgid ""
 "        n -= n // prime\n"
 "    return n"
 msgstr ""
+"def multinomial(*counts):\n"
+"    \"Number of distinct arrangements of a multiset.\"\n"
+"    # Counter('abracadabra').values() → 5 2 2 1 1\n"
+"    # multinomial(5, 2, 2, 1, 1) → 83160\n"
+"    return prod(map(comb, accumulate(counts), counts))\n"
+"\n"
+"def powerset(iterable):\n"
+"    \"Subsequences of the iterable from shortest to longest.\"\n"
+"    # powerset([1,2,3]) → () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)\n"
+"    s = list(iterable)\n"
+"    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))\n"
+"\n"
+"def sum_of_squares(iterable):\n"
+"    \"Add up the squares of the input values.\"\n"
+"    # sum_of_squares([10, 20, 30]) → 1400\n"
+"    return sumprod(*tee(iterable))\n"
+"\n"
+"def reshape(matrix, columns):\n"
+"    \"Reshape a 2-D matrix to have a given number of columns.\"\n"
+"    # reshape([(0, 1), (2, 3), (4, 5)], 3) →  (0, 1, 2), (3, 4, 5)\n"
+"    return batched(chain.from_iterable(matrix), columns, strict=True)\n"
+"\n"
+"def transpose(matrix):\n"
+"    \"Swap the rows and columns of a 2-D matrix.\"\n"
+"    # transpose([(1, 2, 3), (11, 22, 33)]) → (1, 11) (2, 22) (3, 33)\n"
+"    return zip(*matrix, strict=True)\n"
+"\n"
+"def matmul(m1, m2):\n"
+"    \"Multiply two matrices.\"\n"
+"    # matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)]) → (49, 80), (41, 60)\n"
+"    n = len(m2[0])\n"
+"    return batched(starmap(sumprod, product(m1, transpose(m2))), n)\n"
+"\n"
+"def convolve(signal, kernel):\n"
+"    \"\"\"Discrete linear convolution of two iterables.\n"
+"    Equivalent to polynomial multiplication.\n"
+"\n"
+"    Convolutions are mathematically commutative; however, the inputs are\n"
+"    evaluated differently.  The signal is consumed lazily and can be\n"
+"    infinite. The kernel is fully consumed before the calculations begin.\n"
+"\n"
+"    Article:  https://betterexplained.com/articles/intuitive-convolution/\n"
+"    Video:    https://www.youtube.com/watch?v=KuXjwB4LzSA\n"
+"    \"\"\"\n"
+"    # convolve([1, -1, -20], [1, -3]) → 1 -4 -17 60\n"
+"    # convolve(data, [0.25, 0.25, 0.25, 0.25]) → Moving average (blur)\n"
+"    # convolve(data, [1/2, 0, -1/2]) → 1st derivative estimate\n"
+"    # convolve(data, [1, -2, 1]) → 2nd derivative estimate\n"
+"    kernel = tuple(kernel)[::-1]\n"
+"    n = len(kernel)\n"
+"    padded_signal = chain(repeat(0, n-1), signal, repeat(0, n-1))\n"
+"    windowed_signal = sliding_window(padded_signal, n)\n"
+"    return map(sumprod, repeat(kernel), windowed_signal)\n"
+"\n"
+"def polynomial_from_roots(roots):\n"
+"    \"\"\"Compute a polynomial's coefficients from its roots.\n"
+"\n"
+"       (x - 5) (x + 4) (x - 3)  expands to:   x³ -4x² -17x + 60\n"
+"    \"\"\"\n"
+"    # polynomial_from_roots([5, -4, 3]) → [1, -4, -17, 60]\n"
+"    factors = zip(repeat(1), map(neg, roots))\n"
+"    return list(reduce(convolve, factors, [1]))\n"
+"\n"
+"def polynomial_eval(coefficients, x):\n"
+"    \"\"\"Evaluate a polynomial at a specific value.\n"
+"\n"
+"    Computes with better numeric stability than Horner's method.\n"
+"    \"\"\"\n"
+"    # Evaluate x³ -4x² -17x + 60 at x = 5\n"
+"    # polynomial_eval([1, -4, -17, 60], x=5) → 0\n"
+"    n = len(coefficients)\n"
+"    if not n:\n"
+"        return type(x)(0)\n"
+"    powers = map(pow, repeat(x), reversed(range(n)))\n"
+"    return sumprod(coefficients, powers)\n"
+"\n"
+"def polynomial_derivative(coefficients):\n"
+"    \"\"\"Compute the first derivative of a polynomial.\n"
+"\n"
+"       f(x)  =  x³ -4x² -17x + 60\n"
+"       f'(x) = 3x² -8x  -17\n"
+"    \"\"\"\n"
+"    # polynomial_derivative([1, -4, -17, 60]) → [3, -8, -17]\n"
+"    n = len(coefficients)\n"
+"    powers = reversed(range(1, n))\n"
+"    return list(map(mul, coefficients, powers))\n"
+"\n"
+"def sieve(n):\n"
+"    \"Primes less than n.\"\n"
+"    # sieve(30) → 2 3 5 7 11 13 17 19 23 29\n"
+"    if n > 2:\n"
+"        yield 2\n"
+"    data = bytearray((0, 1)) * (n // 2)\n"
+"    for p in iter_index(data, 1, start=3, stop=isqrt(n) + 1):\n"
+"        data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\n"
+"    yield from iter_index(data, 1, start=3)\n"
+"\n"
+"def factor(n):\n"
+"    \"Prime factors of n.\"\n"
+"    # factor(99) → 3 3 11\n"
+"    # factor(1_000_000_000_000_007) → 47 59 360620266859\n"
+"    # factor(1_000_000_000_000_403) → 1000000000000403\n"
+"    for prime in sieve(isqrt(n) + 1):\n"
+"        while not n % prime:\n"
+"            yield prime\n"
+"            n //= prime\n"
+"            if n == 1:\n"
+"                return\n"
+"    if n > 1:\n"
+"        yield n\n"
+"\n"
+"def is_prime(n):\n"
+"    \"Return True if n is prime.\"\n"
+"    # is_prime(1_000_000_000_000_403) → True\n"
+"    return n > 1 and next(factor(n)) == n\n"
+"\n"
+"def totient(n):\n"
+"    \"Count of natural numbers up to n that are coprime to n.\"\n"
+"    # https://mathworld.wolfram.com/TotientFunction.html\n"
+"    # totient(12) → 4 because len([1, 5, 7, 11]) == 4\n"
+"    for prime in set(factor(n)):\n"
+"        n -= n // prime\n"
+"    return n"