File: //kunden/kunden/kunden/lib/python3/dist-packages/more_itertools/__pycache__/recipes.cpython-313.pyc
�
a` h�� � � � S r SSKrSSKJr SSKJr SSKJr SSKJ r J
r
SSK J r J
r
JrJrJrJrJrJrJrJrJrJrJr SSKJrJrJ r J r SS K J r J r J!r!J"r" SS
KJ#r#J$r$J%r% SS K&J'r' / S Qr(\)" 5 r* \+" S
S9 \
" \+S
S9r, SSKJ.r/ S r1STS jr2S r3SUS jr4SUS jr5SUS jr6\74S jr8S r9\9r:S r;S r<S r=SUS jr>S r? SS K J@rA S r@\?R \@l " S S!\B5 rCS" rDS# rESVS$ jrFS% rGS& rHS' rISUS( jrJSUS) jrKSWS+ jrLSUS, jrMSXS- jrNS.S/.S0 jrOSUS1 jrPS2 rQS3 rRS4 rSS5 rTS6 rUS7 rVS8 rWS9 rXS: rYS; rZS< r[S= r\SYS> jr]S? r^S*S.S@ jr_\'SA:� a SSBK J`ra S*S.SC jr`O\_r`\_R \`l SD rbSE rcSF rdSG re\f" \^" SH5 5 rgSI rhSJ riSK rjSL rkSM rl/ SNQrm\ SO 5 rnSP ro\R� " 5 RF rqSQ rrSR rsSS rtg! \- a \+r, GN^f = f! \0 a S r/ GNgf = f! \0 a \?r@ GN%f = f)Za Imported from the recipes section of the itertools documentation.
All functions taken from the recipes section of the itertools library docs
[1]_.
Some backward-compatible usability improvements have been made.
.. [1] http://docs.python.org/library/itertools.html#recipes
� N)�deque��suppress)�Sized)� lru_cache�partial)
�
accumulate�chain� combinations�compress�count�cycle�groupby�islice�product�repeat�starmap�tee� zip_longest)�prod�comb�isqrt�gcd)�mul�not_�
itemgetter�getitem)� randrange�sample�choice)�
hexversion)1� all_equal�batched�before_and_after�consume�convolve�
dotproduct�
first_true�factor�flatten�grouper�is_prime� iter_except�
iter_index�loops�matmul� multinomial�ncycles�nth�nth_combination�padnone�pad_none�pairwise� partition�polynomial_eval�polynomial_from_roots�polynomial_derivative�powerset�prepend�quantify�reshape�#random_combination_with_replacement�random_combination�random_permutation�random_product�
repeatfunc�
roundrobin�sieve�sliding_window� subslices�sum_of_squares�tabulate�tail�take�totient� transpose�
triplewise�unique�unique_everseen�unique_justseenT��strict)�sumprodc � � [ X5 $ �N)r' )�x�ys �8/usr/lib/python3/dist-packages/more_itertools/recipes.py�<lambda>r[ i s � �J�q� ,� c �* � [ [ X5 5 $ )z�Return first *n* items of the *iterable* as a list.
>>> take(3, range(10))
[0, 1, 2]
If there are fewer than *n* items in the iterable, all of them are
returned.
>>> take(10, range(3))
[0, 1, 2]
)�listr ��n�iterables rZ rL rL l s � � ��x�#� $�$r\ c �, � [ U [ U5 5 $ )a� Return an iterator over the results of ``func(start)``,
``func(start + 1)``, ``func(start + 2)``...
*func* should be a function that accepts one integer argument.
If *start* is not specified it defaults to 0. It will be incremented each
time the iterator is advanced.
>>> square = lambda x: x ** 2
>>> iterator = tabulate(square, -3)
>>> take(4, iterator)
[9, 4, 1, 0]
)�mapr
)�function�starts rZ rJ rJ | s � � �x��u� � &�&r\ c � � [ U[ 5 ( a# [ U[ S[ U5 U -
5 S5 $ [ [
XS95 $ )zsReturn an iterator over the last *n* items of *iterable*.
>>> t = tail(3, 'ABCDEFG')
>>> list(t)
['E', 'F', 'G']
r N��maxlen)�
isinstancer r �max�len�iterr r_ s rZ rK rK � s@ � � �(�E�"�"��h��A�s�8�}�q�'8� 9�4�@�@��E�(�-�.�.r\ c �L � Uc [ U SS9 g[ [ XU5 S5 g)a� Advance *iterable* by *n* steps. If *n* is ``None``, consume it
entirely.
Efficiently exhausts an iterator without returning values. Defaults to
consuming the whole iterator, but an optional second argument may be
provided to limit consumption.
>>> i = (x for x in range(10))
>>> next(i)
0
>>> consume(i, 3)
>>> next(i)
4
>>> consume(i)
>>> next(i)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
If the iterator has fewer items remaining than the provided limit, the
whole iterator will be consumed.
>>> i = (x for x in range(3))
>>> consume(i, 5)
>>> next(i)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
Nr rg )r �nextr )�iteratorr` s rZ r% r% � s' � �@ �y�
�h�q�!�
�V�H��
#�T�*r\ c �. � [ [ XS5 U5 $ )zmReturns the nth item or a default value.
>>> l = range(10)
>>> nth(l, 3)
3
>>> nth(l, 20, "zebra")
'zebra'
N)rn r )ra r` �defaults rZ r3 r3 � s � � ��x�D�)�7� 3�3r\ c �@ � [ X5 nU H
nU H n g g g)aw
Returns ``True`` if all the elements are equal to each other.
>>> all_equal('aaaa')
True
>>> all_equal('aaab')
False
A function that accepts a single argument and returns a transformed version
of each input item can be specified with *key*:
>>> all_equal('AaaA', key=str.casefold)
True
>>> all_equal([1, 2, 3], key=lambda x: x < 10)
True
FT)r )ra �keyro �first�seconds rZ r" r" � s- � �$ �x�%�H��� �F�� �� � r\ c �* � [ [ X5 5 $ )zWReturn the how many times the predicate is true.
>>> quantify([True, False, True])
2
)�sumrc )ra �preds rZ r> r> � s � � �s�4�"� #�#r\ c �, � [ U [ S5 5 $ )z�Returns the sequence of elements and then returns ``None`` indefinitely.
>>> take(5, pad_none(range(3)))
[0, 1, 2, None, None]
Useful for emulating the behavior of the built-in :func:`map` function.
See also :func:`padded`.
N)r
r �ra s rZ r6 r6 � s � � ��6�$�<� (�(r\ c �T � [ R " [ [ U 5 U5 5 $ )zjReturns the sequence elements *n* times
>>> list(ncycles(["a", "b"], 3))
['a', 'b', 'a', 'b', 'a', 'b']
)r
�
from_iterabler �tuple�ra r` s rZ r2 r2
s � � � � �v�e�H�o�q� 9� :�:r\ c �4 � [ [ [ X5 5 $ )z�Returns the dot product of the two iterables.
>>> dotproduct([10, 15, 12], [0.65, 0.80, 1.25])
33.5
>>> 10 * 0.65 + 15 * 0.80 + 12 * 1.25
33.5
In Python 3.12 and later, use ``math.sumprod()`` instead.
)rw rc r )�vec1�vec2s rZ r' r' s � � �s�3��#� $�$r\ c �. � [ R " U 5 $ )z�Return an iterator flattening one level of nesting in a list of lists.
>>> list(flatten([[0, 1], [2, 3]]))
[0, 1, 2, 3]
See also :func:`collapse`, which can flatten multiple levels of nesting.
)r
r| )� listOfListss rZ r* r* ! s � � � � �{� +�+r\ c �\ � Uc [ U [ U5 5 $ [ U [ X!5 5 $ )a Call *func* with *args* repeatedly, returning an iterable over the
results.
If *times* is specified, the iterable will terminate after that many
repetitions:
>>> from operator import add
>>> times = 4
>>> args = 3, 5
>>> list(repeatfunc(add, times, *args))
[8, 8, 8, 8]
If *times* is ``None`` the iterable will not terminate:
>>> from random import randrange
>>> times = None
>>> args = 1, 11
>>> take(6, repeatfunc(randrange, times, *args)) # doctest:+SKIP
[2, 4, 8, 1, 8, 4]
)r r )�func�times�argss rZ rD rD - s, � �,
�}��t�V�D�\�*�*� �4���,� -�-r\ c �J � [ U 5 u p[ US5 [ X5 $ )z�Returns an iterator of paired items, overlapping, from the original
>>> take(4, pairwise(count()))
[(0, 1), (1, 2), (2, 3), (3, 4)]
On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`.
N�r rn �zip)ra �a�bs rZ � _pairwiser� H s" � � �x�=�D�A���D�M� �q�9�r\ )r7 c � � [ U 5 $ rW )�itertools_pairwiserz s rZ r7 r7 \ s
� �!�(�+�+r\ c �, ^ � \ rS rSrSU 4S jjrSrU =r$ )�UnequalIterablesErrorib c �R >� SnUb USR " U6 -
n[ TU ] U5 g )Nz Iterables have different lengthsz/: index 0 has length {}; index {} has length {})�format�super�__init__)�self�details�msg� __class__s �rZ r� � UnequalIterablesError.__init__c s8 �� �0�� � � �E�M�M���
�C� ���� r\ � rW )�__name__�
__module__� __qualname__�__firstlineno__r� �__static_attributes__�
__classcell__)r� s @rZ r� r� b s
�� � � r\ r� c # �x # � [ U S[ 06 H# nU H nU[ L d M [ 5 e Uv � M% g 7f)N� fillvalue)r �_markerr� )� iterables�combo�vals rZ �_zip_equal_generatorr� m s: � � � �i�;�7�;���C��g�~�+�-�-� � � � <�s � :�:c �� � [ U S 5 n[ U SS S5 H u p#[ U5 nXA:w d M [ XU4S9e [ U 6 $ ! [ a [ U 5 s $ f = f)Nr � )r� )rk � enumerater� r� � TypeErrorr� )r� �
first_size�i�it�sizes rZ �
_zip_equalr� u su � � /���1� �&�
� �y���}�a�0�E�A��r�7�D��!�+�Z�D�4I�J�J� 1�
�I�� �� � /�#�I�.�.�/�s �0A �A � A#�"A#c � � [ U 5 /U- nUS:X a [ USU06$ US:X a [ U6 $ US:X a [ U6 $ [ S5 e)a� Group elements from *iterable* into fixed-length groups of length *n*.
>>> list(grouper('ABCDEF', 3))
[('A', 'B', 'C'), ('D', 'E', 'F')]
The keyword arguments *incomplete* and *fillvalue* control what happens for
iterables whose length is not a multiple of *n*.
When *incomplete* is `'fill'`, the last group will contain instances of
*fillvalue*.
>>> list(grouper('ABCDEFG', 3, incomplete='fill', fillvalue='x'))
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]
When *incomplete* is `'ignore'`, the last group will not be emitted.
>>> list(grouper('ABCDEFG', 3, incomplete='ignore', fillvalue='x'))
[('A', 'B', 'C'), ('D', 'E', 'F')]
When *incomplete* is `'strict'`, a subclass of `ValueError` will be raised.
>>> iterator = grouper('ABCDEFG', 3, incomplete='strict')
>>> list(iterator) # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
UnequalIterablesError
�fillr� rT �ignorez Expected fill, strict, or ignore)rl r r� r� �
ValueError)ra r` �
incompleter� � iteratorss rZ r+ r+ � s^ � �: �h� � �1�$�I��V���I�;��;�;��X� ��9�%�%��X� ��I�� ��;�<�<r\ c ' �� # � [ [ U 5 n[ [ U 5 SS5 H/ n[ [ X5 5 n[ [ U5 Sh v�N M1 g N 7f)a/ Visit input iterables in a cycle until each is exhausted.
>>> list(roundrobin('ABC', 'D', 'EF'))
['A', 'D', 'E', 'B', 'F', 'C']
This function produces the same output as :func:`interleave_longest`, but
may perform better for some inputs (in particular when the number of
iterables is small).
r ���N)rc rl �rangerk r r rn )r� r� �
num_actives rZ rE rE � sL � � � �D�)�$�I��C� �N�A�r�2�
��&��7�8� ��t�Y�'�'�'� 3�'�s �AA �A �
A c � � U c [ n [ US5 u p#n[ [ X5 5 u pV[ U[ [ U5 5 [ X65 4$ )aw
Returns a 2-tuple of iterables derived from the input iterable.
The first yields the items that have ``pred(item) == False``.
The second yields the items that have ``pred(item) == True``.
>>> is_odd = lambda x: x % 2 != 0
>>> iterable = range(10)
>>> even_items, odd_items = partition(is_odd, iterable)
>>> list(even_items), list(odd_items)
([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])
If *pred* is None, :func:`bool` is used.
>>> iterable = [0, 1, False, True, '', ' ']
>>> false_items, true_items = partition(None, iterable)
>>> list(false_items), list(true_items)
([0, False, ''], [1, True, ' '])
� )�boolr rc r r )rx ra �t1�t2�p�p1�p2s rZ r8 r8 � sK � �( �|����H�a� �I�B�A�
��T� �
�F�B� �R��T�2� � '��"�)9� :�:r\ c � ^� [ U 5 m[ R " U4S j[ [ T5 S- 5 5 5 $ )a Yields all possible subsets of the iterable.
>>> list(powerset([1, 2, 3]))
[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
:func:`powerset` will operate on iterables that aren't :class:`set`
instances, so repeated elements in the input will produce repeated elements
in the output.
>>> seq = [1, 1, 0]
>>> list(powerset(seq))
[(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]
For a variant that efficiently yields actual :class:`set` instances, see
:func:`powerset_of_sets`.
c 3 �< ># � U H n[ TU5 v � M g 7frW )r )�.0�r�ss �rZ � <genexpr>�powerset.<locals>.<genexpr>� s �� � � M�;L�a�|�A�q� 1� 1�;L�� � r� )r^ r
r| r� rk )ra r� s @rZ r< r< � s2 �� �"
�X��A� � � � M�5��Q��!��;L� M� M�Mr\ c # � # � [ 5 nUR n/ nUR nUSLnU H( nU( a U" U5 OUn X�; a U" U5 Uv � M( M* g! [ a X�; a U" U5 Uv � MK MN f = f7f)aJ
Yield unique elements, preserving order.
>>> list(unique_everseen('AAAABBBCCDAABBB'))
['A', 'B', 'C', 'D']
>>> list(unique_everseen('ABBCcAD', str.lower))
['A', 'B', 'C', 'D']
Sequences with a mix of hashable and unhashable items can be used.
The function will be slower (i.e., `O(n^2)`) for unhashable items.
Remember that ``list`` objects are unhashable - you can use the *key*
parameter to transform the list to a tuple (which is hashable) to
avoid a slowdown.
>>> iterable = ([1, 2], [2, 3], [1, 2])
>>> list(unique_everseen(iterable)) # Slow
[[1, 2], [2, 3]]
>>> list(unique_everseen(iterable, key=tuple)) # Faster
[[1, 2], [2, 3]]
Similarly, you may want to convert unhashable ``set`` objects with
``key=frozenset``. For ``dict`` objects,
``key=lambda x: frozenset(x.items())`` can be used.
N)�set�add�appendr� ) ra rs �seenset� seenset_add�seenlist� seenlist_add�use_key�element�ks rZ rQ rQ � s� � � �6 �e�G��+�+�K��H��?�?�L���o�G��� #�C��L��� �� ��A�� �
� � �� � �� � �Q�� �
� !� �s) �?A?�A�A?�A<�5A?�;A<�<A?c
� � Uc [ [ S5 [ U 5 5 $ [ [ [ [ S5 [ X5 5 5 $ )z�Yields elements in order, ignoring serial duplicates
>>> list(unique_justseen('AAAABBBCCDAABBB'))
['A', 'B', 'C', 'D', 'A', 'B']
>>> list(unique_justseen('ABBCcAD', str.lower))
['A', 'B', 'C', 'A', 'D']
r r� )rc r r rn )ra rs s rZ rR rR s< � � �{��:�a�=�'�(�"3�4�4� �t�S��A� ���(>�?� @�@r\ Fc �( � [ XUS9n[ X1S9$ )a� Yields unique elements in sorted order.
>>> list(unique([[1, 2], [3, 4], [1, 2]]))
[[1, 2], [3, 4]]
*key* and *reverse* are passed to :func:`sorted`.
>>> list(unique('ABBcCAD', str.casefold))
['A', 'B', 'c', 'D']
>>> list(unique('ABBcCAD', str.casefold, reverse=True))
['D', 'c', 'B', 'A']
The elements in *iterable* need not be hashable, but they must be
comparable for sorting to work.
)rs �reverse)rs )�sortedrR )ra rs r� � sequenceds rZ rP rP , s � � �x�'�:�I� �9� .�.r\ c # �t # � [ U5 Ub U" 5 v � U " 5 v � M ! , ( d f g= f7f)a� Yields results from a function repeatedly until an exception is raised.
Converts a call-until-exception interface to an iterator interface.
Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel
to end the loop.
>>> l = [0, 1, 2]
>>> list(iter_except(l.pop, IndexError))
[2, 1, 0]
Multiple exceptions can be specified as a stopping condition:
>>> l = [1, 2, 3, '...', 4, 5, 6]
>>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
[7, 6, 5]
>>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
[4, 3, 2]
>>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
[]
Nr )r� � exceptionrt s rZ r- r- @ s3 � � �,
�)� � � ��'�M���&�L� �
� �s � 8�'�
5�8c �, � [ [ X 5 U5 $ )ad
Returns the first true value in the iterable.
If no true value is found, returns *default*
If *pred* is not None, returns the first item for which
``pred(item) == True`` .
>>> first_true(range(10))
1
>>> first_true(range(10), pred=lambda x: x > 5)
6
>>> first_true(range(10), default='missing', pred=lambda x: x > 9)
'missing'
)rn �filter)ra rq rx s rZ r( r( ] s � �" ��t�&�� 0�0r\ r� �r c �n � U Vs/ s H n[ U5 PM snU - n[ S U 5 5 $ s snf )a� Draw an item at random from each of the input iterables.
>>> random_product('abc', range(4), 'XYZ') # doctest:+SKIP
('c', 3, 'Z')
If *repeat* is provided as a keyword argument, that many items will be
drawn from each iterable.
>>> random_product('abcd', range(4), repeat=2) # doctest:+SKIP
('a', 2, 'd', 3)
This equivalent to taking a random selection from
``itertools.product(*args, **kwarg)``.
c 3 �8 # � U H n[ U5 v � M g 7frW )r )r� �pools rZ r� �!random_product.<locals>.<genexpr>� s � � �0�%�$��� � �%�s �)r} )r r� r� �poolss rZ rC rC q s7 � � &*� *�T�T�U�4�[�T� *�V� 3�E� �0�%�0� 0�0��
+s �2c �` � [ U 5 nUc [ U5 OUn[ [ X!5 5 $ )aF Return a random *r* length permutation of the elements in *iterable*.
If *r* is not specified or is ``None``, then *r* defaults to the length of
*iterable*.
>>> random_permutation(range(5)) # doctest:+SKIP
(3, 4, 0, 1, 2)
This equivalent to taking a random selection from
``itertools.permutations(iterable, r)``.
)r} rk r )ra r� r� s rZ rB rB � s+ � � ��?�D��Y��D� �A�A� ��� � !�!r\ c � ^� [ U 5 m[ T5 n[ [ [ U5 U5 5 n[ U4S jU 5 5 $ )z�Return a random *r* length subsequence of the elements in *iterable*.
>>> random_combination(range(5), 3) # doctest:+SKIP
(2, 3, 4)
This equivalent to taking a random selection from
``itertools.combinations(iterable, r)``.
c 3 �. ># � U H
nTU v � M g 7frW r� �r� r� r� s �rZ r� �%random_combination.<locals>.<genexpr>� � �� � �*�'�Q��a��'�� �)r} rk r� r r� )ra r� r` �indicesr� s @rZ rA rA � s= �� � ��?�D� �D� �A��V�E�!�H�a�(�)�G� �*�'�*� *�*r\ c � ^^� [ U 5 m[ T5 m[ U4S j[ U5 5 5 n[ U4S jU 5 5 $ )a; Return a random *r* length subsequence of elements in *iterable*,
allowing individual elements to be repeated.
>>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP
(0, 0, 1, 2, 2)
This equivalent to taking a random selection from
``itertools.combinations_with_replacement(iterable, r)``.
c 3 �: ># � U H n[ T5 v � M g 7frW )r �r� r� r` s �rZ r� �6random_combination_with_replacement.<locals>.<genexpr>� s �� � �4�8�a�Y�q�\�\�8�s �c 3 �. ># � U H
nTU v � M g 7frW r� r� s �rZ r� r� � r� r� )r} rk r� r� )ra r� r� r` r� s @@rZ r@ r@ � s< �� � ��?�D� �D� �A��4�5��8�4�4�G� �*�'�*� *�*r\ c � � [ U 5 n[ U5 nUS: d X:� a [ eSn[ XU-
5 n[ SUS- 5 H nXTU-
U- - U- nM US: a X%-
nUS: d X%:� a [
e/ nU( aN XQ- U- US-
US-
pnX%:� a X%- nXTU-
- U- US-
pEX%:� a M UR
USU-
5 U( a MN [ U5 $ )a� Equivalent to ``list(combinations(iterable, r))[index]``.
The subsequences of *iterable* that are of length *r* can be ordered
lexicographically. :func:`nth_combination` computes the subsequence at
sort position *index* directly, without computing the previous
subsequences.
>>> nth_combination(range(5), 3, 5)
(0, 3, 4)
``ValueError`` will be raised If *r* is negative or greater than the length
of *iterable*.
``IndexError`` will be raised if the given *index* is invalid.
r r� r� )r} rk r� �minr� �
IndexErrorr� ) ra r� �indexr� r` �cr� r� �results rZ r4 r4 � s� � � ��?�D� �D� �A� �A��1�5��� �A� �A�1�u�
�A�
�1�a�!�e�_��
�Q����O�q� �� �
�q�y�
�
��
�� �u�z���
�F�
��%�1�*�a�!�e�Q��U�a���j� �J�E��A��;�!�#�Q��U�q� �j� �
�
�d�2��6�l�#� �!� ��=�r\ c � � [ U /U5 $ )a Yield *value*, followed by the elements in *iterator*.
>>> value = '0'
>>> iterator = ['1', '2', '3']
>>> list(prepend(value, iterator))
['0', '1', '2', '3']
To prepend multiple values, see :func:`itertools.chain`
or :func:`value_chain`.
)r
)�valuero s rZ r= r= � s � � �%��(� #�#r\ c # �� # � [ U5 SSS2 n[ U5 n[ S/US9U- n[ U [ SUS-
5 5 H! nUR U5 [
X5 v � M# g7f)u- Discrete linear convolution of two iterables.
Equivalent to polynomial multiplication.
For example, multiplying ``(x² -x - 20)`` by ``(x - 3)``
gives ``(x³ -4x² -17x + 60)``.
>>> list(convolve([1, -1, -20], [1, -3]))
[1, -4, -17, 60]
Examples of popular kinds of kernels:
* The kernel ``[0.25, 0.25, 0.25, 0.25]`` computes a moving average.
For image data, this blurs the image and reduces noise.
* The kernel ``[1/2, 0, -1/2]`` estimates the first derivative of
a function evaluated at evenly spaced inputs.
* The kernel ``[1, -2, 1]`` estimates the second derivative of a
function evaluated at evenly spaced inputs.
Convolutions are mathematically commutative; however, the inputs are
evaluated differently. The signal is consumed lazily and can be
infinite. The kernel is fully consumed before the calculations begin.
Supports all numeric types: int, float, complex, Decimal, Fraction.
References:
* Article: https://betterexplained.com/articles/intuitive-convolution/
* Video by 3Blue1Brown: https://www.youtube.com/watch?v=KuXjwB4LzSA
Nr� r rg r� )r} rk r r
r r� �_sumprod)�signal�kernelr` �windowrX s rZ r& r& � si � � �F �6�]�4�R�4�
�F� �F� �A�
�A�3�q�
!�A�
%�F�
�6�6�!�Q��U�+�
,���
�
�a���v�&�&� -�s �A*A,c �\ ^ ^^� [ T5 m/ mUU U4S jn[ TT5 nU" 5 U4$ )a� A variant of :func:`takewhile` that allows complete access to the
remainder of the iterator.
>>> it = iter('ABCdEfGhI')
>>> all_upper, remainder = before_and_after(str.isupper, it)
>>> ''.join(all_upper)
'ABC'
>>> ''.join(remainder) # takewhile() would lose the 'd'
'dEfGhI'
Note that the first iterator must be fully consumed before the second
iterator can generate valid results.
c 3 �h ># � T H' n T" U 5 ( a U v � M TR U 5 g g 7frW )r� )�elemr� � predicate�
transitions ���rZ �
true_iterator�'before_and_after.<locals>.true_iterator- s/ �� � ��D������
��!�!�$�'�� �s �/2)rl r
)r r� r �remainder_iteratorr s `` @rZ r$ r$ s5 �� �
�b��B��J�� �z�2�.�� �?� .� .�.r\ c � � [ U S5 u pn[ US5 [ US5 [ US5 [ XU5 $ )z�Return overlapping triplets from *iterable*.
>>> list(triplewise('ABCDE'))
[('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')]
r� Nr� )ra r� r� �t3s rZ rO rO = s; � � �X�q�!�J�B�B���T�N���T�N���T�N� �r�r�?�r\ c �| � [ X5 n[ U5 H u p4[ [ XCU5 S 5 M [ U6 $ rW )r r� rn r r� )ra r` r� r� ro s rZ �_sliding_window_islicer M s8 � ��H� �I� ��+� �� �V�H��
#�T�*� ,� � �?�r\ c # � # � [ U 5 n[ [ X!S-
5 US9nU H! nUR U5 [ U5 v � M# g 7f)Nr� rg )rl r r r� r} )ra r` ro r� rX s rZ �_sliding_window_dequer
U sC � � ��H�~�H�
�6�(��E�*�1�
5�F�
���
�
�a���F�m�� �s �A
A c � � US:� a [ X5 $ US:� a [ X5 $ US:X a [ U 5 $ US:X a [ U 5 $ [ SU 35 e)a= Return a sliding window of width *n* over *iterable*.
>>> list(sliding_window(range(6), 4))
[(0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5)]
If *iterable* has fewer than *n* items, then nothing is yielded:
>>> list(sliding_window(range(3), 4))
[]
For a variant with more features, see :func:`windowed`.
� � r� z n should be at least one, not )r
r r7 r� r� r~ s rZ rG rG ^ s^ � � �2�v�$�X�1�1�
�Q��%�h�2�2�
�a����!�!�
�a���8�}� ��9�!��=�>�>r\ c
� � [ U 5 n[ [ [ [ [ U5 S- 5 S5 5 n[
[ [ U5 U5 $ )z�Return all contiguous non-empty subslices of *iterable*.
>>> list(subslices('ABC'))
[['A'], ['A', 'B'], ['A', 'B', 'C'], ['B'], ['B', 'C'], ['C']]
This is similar to :func:`substrings`, but emits items in a different
order.
r� r ) r^ r �slicer r� rk rc r r )ra �seq�slicess rZ rH rH w s@ � � �x�.�C�
�U�L��s�3�x�!�|�)<�a� @�
A�F� �w��s� �V� ,�,r\ c �N � S/nU H n[ [ USU* 45 5 nM U$ )u Compute a polynomial's coefficients from its roots.
>>> roots = [5, -4, 3] # (x - 5) * (x + 4) * (x - 3)
>>> polynomial_from_roots(roots) # x³ - 4 x² - 17 x + 60
[1, -4, -17, 60]
Supports all numeric types: int, float, complex, Decimal, Fraction.
r� )r^ r& )�roots�poly�roots rZ r: r: � s1 � �
�3�D����H�T�A��u�:�.�/�� � �Kr\ c # � # � [ U SS5 nUc0 [ XU5 n[ XR5 H u pgXqL d Xq:X d M Uv � M gUc [ U 5 OUnUS-
n[ [
5 U" XS- U5 =nv � M ! , ( d f g= f7f)a� Yield the index of each place in *iterable* that *value* occurs,
beginning with index *start* and ending before index *stop*.
>>> list(iter_index('AABCADEAF', 'A'))
[0, 1, 4, 7]
>>> list(iter_index('AABCADEAF', 'A', 1)) # start index is inclusive
[1, 4, 7]
>>> list(iter_index('AABCADEAF', 'A', 1, 7)) # stop index is not inclusive
[1, 4]
The behavior for non-scalar *values* matches the built-in Python types.
>>> list(iter_index('ABCDABCD', 'AB'))
[0, 4]
>>> list(iter_index([0, 1, 2, 3, 0, 1, 2, 3], [0, 1]))
[]
>>> list(iter_index([[0, 1], [2, 3], [0, 1], [2, 3]], [0, 1]))
[0, 2]
See :func:`locate` for a more general means of finding the indexes
associated with particular values.
r� Nr� )�getattrr r� rk r r� )ra r� re �stop� seq_indexro r� r� s rZ r. r. � s� � � �2 ��'�4�0�I����(�4�0��#�H�4�J�A�� �7�#3��� 5�
!%� �s�8�}�$�� �A�I��
�j�
!�� %�e��U�D� 9�9�q�:� � "�
!�s �4B �-B �'A;�;
B �B c # �H # � U S:� a Sv � Sn[ S5 U S- - n[ USU[ U 5 S- S9 HL n[ USXU- 5 Sh v�N [ [ [ X3- XU- 5 5 5 X#U- XU- 2' X3- nMN [ USU5 Sh v�N g NO N7f)zYYield the primes less than n.
>>> list(sieve(30))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
r r� )r r� r� )r N)� bytearrayr. r �bytesrk r� )r` re �datar� s rZ rF rF � s� � � � �1�u���
�E� �V� ��Q�� '�D�
��a��U�1�X��\�
:�� �d�A�u�!�e�4�4�4�"'��E�!�%���E�,B�(C�"D���U�Q�Q��
� ���� ;� �$��5�)�)�)� 5� *�s% �A B"�B �A B"�B �B"� B"c # � # � US: a [ S5 e[ U 5 n[ [ X15 5 =n( aC U( a [ U5 U:w a [ S5 eUv � [ [ X15 5 =n( a MB gg7f)ar Batch data into tuples of length *n*. If the number of items in
*iterable* is not divisible by *n*:
* The last batch will be shorter if *strict* is ``False``.
* :exc:`ValueError` will be raised if *strict* is ``True``.
>>> list(batched('ABCDEFG', 3))
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)]
On Python 3.13 and above, this is an alias for :func:`itertools.batched`.
r� zn must be at least onezbatched(): incomplete batchN)r� rl r} r rk )ra r` rT ro �batchs rZ �_batchedr# � sp � � � �1�u��1�2�2��H�~�H����,�-�
-�%�
-� �c�%�j�A�o� � :�;� ;�� � ���,�-�
-�%�
-�
-�s �A8A>�<A>i�
)r# c � � [ XUS9$ )NrS )�itertools_batched)ra r` rT s rZ r# r# � s � � ��V�<�<r\ c � � [ U 6 $ )z�Swap the rows and columns of the input matrix.
>>> list(transpose([(1, 2, 3), (11, 22, 33)]))
[(1, 11), (2, 22), (3, 33)]
The caller should ensure that the dimensions of the input are compatible.
If the input is empty, no output will be produced.
)� _zip_strict�r� s rZ rN rN � s � � �� �r\ c �B � [ [ R " U 5 U5 $ )z�Reshape the 2-D input *matrix* to have a column count given by *cols*.
>>> matrix = [(0, 1), (2, 3), (4, 5)]
>>> cols = 3
>>> list(reshape(matrix, cols))
[(0, 1, 2), (3, 4, 5)]
)r# r
r| )�matrix�colss rZ r? r? s � � �5�&�&�v�.�� 5�5r\ c �x � [ US 5 n[ [ [ [ U [ U5 5 5 U5 $ )a Multiply two matrices.
>>> list(matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)]))
[(49, 80), (41, 60)]
The caller should ensure that the dimensions of the input matrices are
compatible with each other.
Supports all numeric types: int, float, complex, Decimal, Fraction.
r )rk r# r r� r rN )�m1�m2r` s rZ r0 r0 s0 � � �B�q�E�
�A� �7�8�W�R��2� �%?�@�!� D�Dr\ c �� � [ SU 5 HK nS=p#SnUS:X a4 X"- U- U - nX3- U- U - nX3- U- U - n[ X#-
U 5 nUS:X a M4 X@:w d MI Us $ [ S5 e)Nr� r zprime or under 5)r� r r� )r` r� rX rY �ds rZ �_factor_pollardr1 s� � � �1�a�[��� ��
���1�f�����a��A�����a��A�����a��A��A�E�1�
�A� �1�f�
�6��H� � �'�
(�(r\ �� c # �> # � U S: a g[ H! nX- ( a M Uv � X- n X- ( d M M# / nU S:� a U /O/ nU H? n U S: d [ U 5 ( a UR U 5 M, [ U 5 nX4X- 4-
nMA [ U5 Sh v�N g N7f)z�Yield the prime factors of n.
>>> list(factor(360))
[2, 2, 2, 3, 3, 5]
Finds small factors with trial division. Larger factors are
either verified as prime with ``is_prime`` or split into
smaller factors with Pollard's rho algorithm.
r Nr� i� )�_primes_below_211r, r� r1 r� )r` �prime�primes�todo�facts rZ r) r) . s� � � � �1�u�� #���)�)��K�
�K�A� �)�)� #� �F��a�%�A�3�R�D�
�� �v�:��!��� �M�M�!� �"�1�%�D� �1�9�%� %�D� � �f�~� � �s �B �B �A$B �B�B c � � [ U 5 nUS:X a [ U5 " S5 $ [ [ [ U5 [ [
U5 5 5 n[ X5 $ )aD Evaluate a polynomial at a specific value.
Computes with better numeric stability than Horner's method.
Evaluate ``x^3 - 4 * x^2 - 17 * x + 60`` at ``x = 2.5``:
>>> coefficients = [1, -4, -17, 60]
>>> x = 2.5
>>> polynomial_eval(coefficients, x)
8.125
Supports all numeric types: int, float, complex, Decimal, Fraction.
r )rk �typerc �powr �reversedr� r� )� coefficientsrX r` �powerss rZ r9 r9 O sI � � �L��A��A�v��A�w�q�z��
��f�Q�i��%��(�!3�
4�F� �L� )�)r\ c �$ � [ [ U 5 6 $ )z�Return the sum of the squares of the input values.
>>> sum_of_squares([10, 20, 30])
1400
Supports all numeric types: int, float, complex, Decimal, Fraction.
)r� r r( s rZ rI rI d s � � �S��W� � r\ c �t � [ U 5 n[ [ SU5 5 n[ [ [
X5 5 $ )u< Compute the first derivative of a polynomial.
Evaluate the derivative of ``x³ - 4 x² - 17 x + 60``:
>>> coefficients = [1, -4, -17, 60]
>>> derivative_coefficients = polynomial_derivative(coefficients)
>>> derivative_coefficients
[3, -8, -17]
Supports all numeric types: int, float, complex, Decimal, Fraction.
r� )rk r< r� r^ rc r )r= r` r> s rZ r; r; o s0 � � �L��A�
�e�A�q�k�
"�F� ��C� �.� /�/r\ c �J � [ [ U 5 5 H
nX U- - n M U $ )u� Return the count of natural numbers up to *n* that are coprime with *n*.
Euler's totient function φ(n) gives the number of totatives.
Totative are integers k in the range 1 ≤ k ≤ n such that gcd(n, k) = 1.
>>> n = 9
>>> totient(n)
6
>>> totatives = [x for x in range(1, n) if gcd(n, x) == 1]
>>> totatives
[1, 2, 4, 5, 7, 8]
>>> len(totatives)
6
Reference: https://en.wikipedia.org/wiki/Euler%27s_totient_function
)r� r) )r` r5 s rZ rM rM � s& � �& �V�A�Y� �� �%�Z��� � �Hr\ ))i� )r )i�� )� �I )l �tT7 )r � �= )l �ay)r �
� iS_ )l ;n>�)r r� � rD � )l � p� )r r� rH rD rI rF )l )r iE i�$ in i�� i=� i��k)l �%!H�n
�fW )
r r� rH rD rI rF � � rG � rB �% �) c �~ � U S-
U - R 5 S-
nX- nSU- U- U :X a US- ( a US:� d eX4$ )z#Return s, d such that 2**s * d == nr� r )�
bit_length)r` r� r0 s rZ �
_shift_to_oddrQ � sO � � �a�%�1�� � �"�Q�&�A� ��A�
��F�a�<�1� ��Q��1��6�1� 1� �4�Kr\ c �� � U S:� a U S- ( a SUs=:: a U : d e e[ U S-
5 u p#[ XU 5 nUS:X d X@S-
:X a g[ US-
5 H nXD- U - nX@S-
:X d M g g)Nr r� TF)rQ r; r� )r` �baser� r0 rX �_s rZ �_strong_probable_primerU � s� � �
��E��A��A��M��M�2� 2�M�2� 2� ��Q�� �D�A� �D�Q��A��A�v��!�e���
�1�q�5�\��
�E�A�I�� �A��:�� �
r\ c � ^ � T S: a T S; $ T S- ( a2 T S- ( a( T S- ( a T S- ( a T S- ( a
T S- ( d g [ H
u pT U: d M
O U 4S
j[ S 5 5 n[ U 4S jU 5 5 $ )
am Return ``True`` if *n* is prime and ``False`` otherwise.
Basic examples:
>>> is_prime(37)
True
>>> is_prime(3 * 13)
False
>>> is_prime(18_446_744_073_709_551_557)
True
Find the next prime over one billion:
>>> next(filter(is_prime, count(10**9)))
1000000007
Generate random primes up to 200 bits and up to 60 decimal digits:
>>> from random import seed, randrange, getrandbits
>>> seed(18675309)
>>> next(filter(is_prime, map(getrandbits, repeat(200))))
893303929355758292373272075469392561129886005037663238028407
>>> next(filter(is_prime, map(randrange, repeat(10**60))))
269638077304026462407872868003560484232362454342414618963649
This function is exact for values of *n* below 10**24. For larger inputs,
the probabilistic Miller-Rabin primality test has a less than 1 in 2**128
chance of a false positive.
rJ > r r� rH rD rI rF r� r� rH rD rI rF Fc 3 �B ># � U H n[ S TS-
5 v � M g7f)r r� N)�_private_randranger� s �rZ r� �is_prime.<locals>.<genexpr>� s �� � �A�y�!�#�A�q�1�u�-�-�y�s � �@ c 3 �< ># � U H n[ TU5 v � M g 7frW )rU )r� rS r` s �rZ r� rY � s �� � �A�5�4�%�a��.�.�5�r� )�_perfect_testsr� �all)r` �limit�basess ` rZ r, r, � sy �� �B �2�v��(�(�(�
��E�a�!�e��A��!�a�%�A��F�q�2�v��&� �� �u�9� � '� B�u�R�y�A�� �A�5�A� A�Ar\ c � � [ SU 5 $ )z�Returns an iterable with *n* elements for efficient looping.
Like ``range(n)`` but doesn't create integers.
>>> i = 0
>>> for _ in loops(5):
... i += 1
>>> i
5
Nr� )r` s rZ r/ r/ � s � � �$��?�r\ c �H � [ [ [ [ U 5 U 5 5 $ )ul Number of distinct arrangements of a multiset.
The expression ``multinomial(3, 4, 2)`` has several equivalent
interpretations:
* In the expansion of ``(a + b + c)⁹``, the coefficient of the
``a³b⁴c²`` term is 1260.
* There are 1260 distinct ways to arrange 9 balls consisting of 3 reds, 4
greens, and 2 blues.
* There are 1260 unique ways to place 9 distinct objects into three bins
with sizes 3, 4, and 2.
The :func:`multinomial` function computes the length of
:func:`distinct_permutations`. For example, there are 83,160 distinct
anagrams of the word "abracadabra":
>>> from more_itertools import distinct_permutations, ilen
>>> ilen(distinct_permutations('abracadabra'))
83160
This can be computed directly from the letter counts, 5a 2b 2r 1c 1d:
>>> from collections import Counter
>>> list(Counter('abracadabra').values())
[5, 2, 2, 1, 1]
>>> multinomial(5, 2, 1, 1, 2)
83160
A binomial coefficient is a special case of multinomial where there are
only two categories. For example, the number of ways to arrange 12 balls
with 5 reds and 7 blues is ``multinomial(5, 7)`` or ``math.comb(12, 5)``.
When the multiplicities are all just 1, :func:`multinomial`
is a special case of ``math.factorial`` so that
``multinomial(1, 1, 1, 1, 1, 1, 1) == math.factorial(7)``.
Reference: https://en.wikipedia.org/wiki/Multinomial_theorem
)r rc r r )�countss rZ r1 r1 s � �T ��D�*�V�,�f�5� 6�6r\ )r rW )r� N)NF)NN)r N)u�__doc__�random� collectionsr �
contextlibr �collections.abcr � functoolsr r � itertoolsr r
r r r
r r r r r r r r �mathr r r r �operatorr r r r r r r �sysr! �__all__�objectr� r� r' r� rU r� � ImportErrorrL rJ rK r% r3 r" r� r> r6 r5 r2 r' r* rD r� r7 r� r� r� r� r� r+ rE r8 r< rQ rR rP r- r( rC rB rA r@ r4 r= r& r$ rO r r
rG rH r: r. rF r# r# r% rN r? r0 r1 r} r4 r) r9 rI r; rM r\ rQ rU �RandomrX r, r/ r1 r� r\ rZ �<module>rq s ��� � � � !� (�� � � � (� '� 3� 3� ,� ,� �2 ��h �(��,��t�� �#�d�+�K�-�(�
%� '�$/�$%+�P
4��4 !� $� )� ��;�
%� ,�.�6 � )�8�
,� !�(�(�H�� �J� ��
/� %=�P(�$;�8N�** �Z A� /�(�:1�( "#� 1�("�$
+� +�"'�T $� ('�V /�B
� � �?�2 -� �$&;�R*�* %*� �( ���6�',� =� �G� �&�&�G�O� �6� E�
)� �%��*�%� � �B*�* �0�"
�2 �� �� ���& �]�]�_�.�.� �-B�` � *7��M% � ��K��� � -�,�H�-��` � ��H��s6 �3G �G" �>G2 �G � G �" G/�.G/�2G>�=G>