\hcSSKJrJrJr SSKJrJrJrJrJ r J r J r J r SSKJ r SSKJr SSKJrJrJr SSKJr SSKJr SQS jrSRS jrSSS jrS rSTS jrSrSrSrSUSjr SVSjr!SUSjr"Sr#SWSjr$Sr%SVSjr&Sr'Sr(Sr)Sr*Sr+Sr,SXSjr-Sr.S r/S!r0S"r1S#r2SXS$jr3SXS%jr4SRS&jr5SXS'jr6S(r7SXS)jr8SYS*jr9SZS+jr:S,r;S-rS0r?S1r@S2rASZS3jrBS4rCS5rDSVS6jrES7rFS8rGS[S9jrH\4S:jrIS;rJS<rKSXS=jrLS>rMS?rNS\S@jrOSArP"SBSC5rQ\R\S\Q44SDjrTSXSEjrU\"SFSGSHSI9SXSJj5rV\"SKSGSHSI9SL5rW\"SMSGSNSI9SO5rX\"SMSGSNSI9SP5rYg)])Counter defaultdict OrderedDict)chain combinationscombinations_with_replacementcycleislice permutationsproductgroupby)r )gt)multiset_partitions_taocp list_visitorMultisetPartitionTraverseras_int) deprecatedNc^^^[TT5R[T55ummnTT- S-n[UUU4Sj[ U555$)aj Return True if the sequence is the same from left to right as it is from right to left in the whole sequence (default) or in the Python slice ``s[i: j]``; else False. Examples ======== >>> from sympy.utilities.iterables import is_palindromic >>> is_palindromic([1, 0, 1]) True >>> is_palindromic('abcbb') False >>> is_palindromic('abcbb', 1) False Normal Python slicing is performed in place so there is no need to create a slice of the sequence for testing: >>> is_palindromic('abcbb', 1, -1) True >>> is_palindromic('abcbb', -4, -1) True See Also ======== sympy.ntheory.digits.is_palindromic: tests integers c3L># UHnTTU-TTS- U- :Hv M g7fN).0kijss Q/var/www/auris/envauris/lib/python3.13/site-packages/sympy/utilities/iterables.py !is_palindromic..6s*:AqQx1QUQY<'!$)sliceindiceslenallrange)rrr_ms``` r is_palindromicr+sG>Aqk!!#a&)GAq! Q A :q: ::c \^SSKJn Ub#U(dU$US:aUS-nO[SU-5eTcSnOU4Sjn/nUHinU"U5(aH[US5(a[ Xc5(d UR nUR [XaTS95 MXURU5 Mk U$) a  Recursively denest iterable containers. >>> from sympy import flatten >>> flatten([1, 2, 3]) [1, 2, 3] >>> flatten([1, 2, [3]]) [1, 2, 3] >>> flatten([1, [2, 3], [4, 5]]) [1, 2, 3, 4, 5] >>> flatten([1.0, 2, (1, None)]) [1.0, 2, 1, None] If you want to denest only a specified number of levels of nested containers, then set ``levels`` flag to the desired number of levels:: >>> ls = [[(-2, -1), (1, 2)], [(0, 0)]] >>> flatten(ls, levels=1) [(-2, -1), (1, 2), (0, 0)] If cls argument is specified, it will only flatten instances of that class, for example: >>> from sympy import Basic, S >>> class MyOp(Basic): ... pass ... >>> flatten([MyOp(S(1), MyOp(S(2), S(3)))], cls=MyOp) [1, 2, 3] adapted from https://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks r) NDimArrayrz.expected non-negative number of levels, got %sc"[U[5$N) is_sequencesetxs r reducibleflatten..reduciblehsq#& &r,c>[UT5$r0) isinstance)r4clss r r5r6ksa% %r,args)levelsr9) sympy.tensor.arrayr. ValueErrorhasattrr8r:extendflattenappend)iterabler;r9r.r5resultels ` r r@r@9sH- O aZ aKF@6IK K { ' &F R==r6"":b+D+DWW MM'"= > MM"   Mr,c^^TS:d[T5T-(a[ST-5e[[UU4Sj[ T5565$)zqGroup ``iter`` into tuples of length ``n``. Raise an error if the length of ``iter`` is not a multiple of ``n``. rz#iter length is not a multiple of %ic34># UH nTUST2v M g7fr0r)rriterns r r!unflatten..s3(Qd14a4j(s)r&r=listzipr()rGrHs``r unflattenrL{sA 1uD A >BCC 3%(34 55r,c &[[U55n[[U5U5up4US:dU(a [ S5eSn[ U5nS/U-n[ [U55Hn/n UH~n [U [5(aU RXXZ-5 XZ- nM3[[U 55n[ U 5n U RU "[XXS-U 5S55 XS- nM U"U 5Xx'M [ U5"U5$)aJReshape the sequence according to the template in ``how``. Examples ======== >>> from sympy.utilities import reshape >>> seq = list(range(1, 9)) >>> reshape(seq, [4]) # lists of 4 [[1, 2, 3, 4], [5, 6, 7, 8]] >>> reshape(seq, (4,)) # tuples of 4 [(1, 2, 3, 4), (5, 6, 7, 8)] >>> reshape(seq, (2, 2)) # tuples of 4 [(1, 2, 3, 4), (5, 6, 7, 8)] >>> reshape(seq, (2, [2])) # (i, i, [i, i]) [(1, 2, [3, 4]), (5, 6, [7, 8])] >>> reshape(seq, ((2,), [2])) # etc.... [((1, 2), [3, 4]), ((5, 6), [7, 8])] >>> reshape(seq, (1, [2], 1)) [(1, [2, 3], 4), (5, [6, 7], 8)] >>> reshape(tuple(seq), ([[1], 1, (2,)],)) (([[1], 2, (3, 4)],), ([[5], 6, (7, 8)],)) >>> reshape(tuple(seq), ([1], 1, (2,))) (([1], 2, (3, 4)), ([5], 6, (7, 8))) >>> reshape(list(range(12)), [2, [3], {2}, (1, (3,), 1)]) [[0, 1, [2, 3, 4], {5, 6}, (7, (8, 9, 10), 11)]] rzLtemplate must sum to positive number that divides the length of the sequenceN) sumr@divmodr&r=typer(r8intr?rAreshape) seqhowr*rHremr containerrvr_rvhihi_types r rRrRsJ GCLA CHa FA1u23 3 AS I B 3r7^B"c"" 3!&>* $r( 773!%="#=a#@AB# 9R=r,c U(a)[U5VVs/sHup#[U5PM snn$[U5VVs/sHupCU[[U554PM snn$s snnfs snnf)aa Splits a sequence into a list of lists of equal, adjacent elements. Examples ======== >>> from sympy import group >>> group([1, 1, 1, 2, 2, 3]) [[1, 1, 1], [2, 2], [3]] >>> group([1, 1, 1, 2, 2, 3], multiple=False) [(1, 3), (2, 2), (3, 1)] >>> group([1, 1, 3, 2, 2, 1], multiple=False) [(1, 2), (3, 1), (2, 2), (1, 1)] See Also ======== multiset )r rJr&)rSmultipler)grs r groupr^sV,&-cl3ldaal33*1#, 7,$!QDG , 774 7s A%"A+c#^ # [U5n[U5n/n/n[5m U 4SjnSnU"X$5 U"X55 U[U5[U5-::ak[U[U5- S-[U55HnXGU- XX4v M US- nU"X$5 U"X55 U[U5[U5-::aMjgg7f)z4Cartesian product of two possibly infinite iterablescL>[UT5nUTLaURU5 ggr0)nextrA)itelemsesentinels r rA_iproduct2..appends' X  H  LLO r,rrN)rGobjectr&r() iterable1 iterable2it1it2elems1elems2rArHr*res @r _iproduct2rns y/C y/C F FxH A 3 3 s6{S[( (qV}QF 4AA#; * *5 Qss s6{S[( (s CCCc'# [U5S:XaSv g[U5S:XaUSHnU4v M g[U5S:Xa[U6ShvN gUSUSSp2[U[U65H upEU4U-v M gN27f)an Cartesian product of iterables. Generator of the Cartesian product of iterables. This is analogous to itertools.product except that it works with infinite iterables and will yield any item from the infinite product eventually. Examples ======== >>> from sympy.utilities.iterables import iproduct >>> sorted(iproduct([1,2], [3,4])) [(1, 3), (1, 4), (2, 3), (2, 4)] With an infinite iterator: >>> from sympy import S >>> (3,) in iproduct(S.Integers) True >>> (3, 4) in iproduct(S.Integers, S.Integers) True .. seealso:: `itertools.product `_ rrNrr)r&rniproduct) iterablesrdfirstothersefeos r rprps8 9~ Y1 1A$J Y1 y)))!! imv &(9:FB%"* ; *sABB3BcF[[U5R55$)a Return the hashable sequence in multiset form with values being the multiplicity of the item in the sequence. Examples ======== >>> from sympy.utilities.iterables import multiset >>> multiset('mississippi') {'i': 4, 'm': 1, 'p': 2, 's': 4} See Also ======== group )dictritems)rSs r multisetry s"  ""$ %%r,c.^TS:a [S5e[T5mUcSnOI[U5nTR5U:a([SRTR555eU(dPUS:a6[ T5SSR US5Vs/sH o3S:XaS OSPM sn$[ [S5TS S 9$US:a[ T5SSR US5$U4S j[ST-55$![a SnNf=fs snf) aReturn a list of length ``bits`` corresponding to the binary value of ``n`` with small bits to the right (last). If bits is omitted, the length will be the number required to represent ``n``. If the bits are desired in reversed order, use the ``[::-1]`` slice of the returned list. If a sequence of all bits-length lists starting from ``[0, 0,..., 0]`` through ``[1, 1, ..., 1]`` are desired, pass a non-integer for bits, e.g. ``'all'``. If the bit *string* is desired pass ``str=True``. Examples ======== >>> from sympy.utilities.iterables import ibin >>> ibin(2) [1, 0] >>> ibin(2, 4) [0, 0, 1, 0] If all lists corresponding to 0 to 2**n - 1, pass a non-integer for bits: >>> bits = 2 >>> for i in ibin(2, 'all'): ... print(i) (0, 0) (0, 1) (1, 0) (1, 1) If a bit string is desired of a given length, use str=True: >>> n = 123 >>> bits = 10 >>> ibin(n, bits, str=True) '0001111011' >>> ibin(n, bits, str=True)[::-1] # small bits left '1101111000' >>> list(ibin(3, 'all', str=True)) ['000', '001', '010', '011', '100', '101', '110', '111'] rz negative numbers are not allowedNz`bits` must be >= {}r01rT) repetitionc3`># UH#n[U5SSRTS5v M% g7f)rNr|)binrjust)rrrHs r r!ibin..{s+BkCF12J$$Q,,ks+.)r=r bit_lengthformatrr variationsr()rHbitsstrrs` r ibinr6sX 1u;<<q A | C$>> from sympy import variations >>> list(variations([1, 2], 2)) [(1, 2), (2, 1)] ``variations(seq, n, True)`` will return the `N^n` permutations obtained by allowing repetition of elements: >>> list(variations([1, 2], 2, repetition=True)) [(1, 1), (1, 2), (2, 1), (2, 2)] If you ask for more items than are in the set you get the empty set unless you allow repetitions: >>> list(variations([0, 1], 3, repetition=False)) [] >>> list(variations([0, 1], 3, repetition=True))[:4] [(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1)] .. seealso:: `itertools.permutations `_, `itertools.product `_ rr)r)repeat)tupler&rGr r )rSrHr~s r rr~sLF Cj s8a<8OC## 6; 3) )r,c*^UcqU(d5[R"U4Sj[[T5S-555$[R"U4Sj[[T5S-555$U(d [ TU5$[ TU5$)aGenerates all `k`-subsets (combinations) from an `n`-element set, ``seq``. A `k`-subset of an `n`-element set is any subset of length exactly `k`. The number of `k`-subsets of an `n`-element set is given by ``binomial(n, k)``, whereas there are `2^n` subsets all together. If `k` is ``None`` then all `2^n` subsets will be returned from shortest to longest. Examples ======== >>> from sympy import subsets ``subsets(seq, k)`` will return the `\frac{n!}{k!(n - k)!}` `k`-subsets (combinations) without repetition, i.e. once an item has been removed, it can no longer be "taken": >>> list(subsets([1, 2], 2)) [(1, 2)] >>> list(subsets([1, 2])) [(), (1,), (2,), (1, 2)] >>> list(subsets([1, 2, 3], 2)) [(1, 2), (1, 3), (2, 3)] ``subsets(seq, k, repetition=True)`` will return the `\frac{(n - 1 + k)!}{k!(n - 1)!}` combinations *with* repetition: >>> list(subsets([1, 2], 2, repetition=True)) [(1, 1), (1, 2), (2, 2)] If you ask for more items than are in the set you get the empty set unless you allow repetitions: >>> list(subsets([0, 1], 3, repetition=False)) [] >>> list(subsets([0, 1], 3, repetition=True)) [(0, 0, 0), (0, 0, 1), (0, 1, 1), (1, 1, 1)] c3<># UHn[TU5v M g7fr0rrrrSs r r!subsets..s#(F1DA)5S!(<(<1Drc3<># UHn[TU5v M g7fr0)rrs r r!rs$(F1DA)Fc1(M(M1Dr)r from_iterabler(r&rr)rSrr~s` r subsetsrsT y&&(F16s3x!|1D(FG G&&(F16s3x!|1D(FG GQ' '0a8 8r,c#J# [U5nUHnX!;dM Uv M g7f)z Only yield elements from `iterator` that do not occur in `exclude`. Parameters ========== iterator : iterable iterator to take elements from exclude : iterable elements to exclude Returns ======= iterator : iterator filtered iterator N)r2)iteratorexcluders r filter_symbolsrs%&'lG  Gs# #c/# [U=(d /5nUcSSKJn UnU<U<3nU"U/UQ70UD6nX;aUv US- nM$7f)a Generate an infinite stream of Symbols consisting of a prefix and increasing subscripts provided that they do not occur in ``exclude``. Parameters ========== prefix : str, optional The prefix to use. By default, this function will generate symbols of the form "x0", "x1", etc. cls : class, optional The class to use. By default, it uses ``Symbol``, but you can also use ``Wild`` or ``Dummy``. start : int, optional The start number. By default, it is 0. exclude : list, tuple, set of cls, optional Symbols to be excluded. *args, **kwargs Additional positional and keyword arguments are passed to the *cls* class. Returns ======= sym : Symbol The subscripted symbols. r)Symbolr)r2 sympy.corer) prefixr9startrr: assumptionsrnamers r numbered_symbolsrs^>'-R G { & '  +t +{ + G   sAAcSSKJn SSKnURnU"5=UlnU"5 X2lUR 5$!X2lf=f)aReturn the printed output of func(). ``func`` should be a function without arguments that produces output with print statements. >>> from sympy.utilities.iterables import capture >>> from sympy import pprint >>> from sympy.abc import x >>> def foo(): ... print('hello world!') ... >>> 'hello' in capture(foo) # foo, not foo() True >>> capture(lambda: pprint(2/x)) '2\n-\nx\n' r)StringION)iorsysstdoutgetvalue)funcrrrfiles r capturer+sE$ ZZF "CJ  ==? s AA cU(d3[[5nUHnX1"U5RU5 M U$//4=nupgUHnXQ"U5RU5 M Xv4$![[4a [ S5ef=f)a Sift the sequence, ``seq`` according to ``keyfunc``. Returns ======= When ``binary`` is ``False`` (default), the output is a dictionary where elements of ``seq`` are stored in a list keyed to the value of keyfunc for that element. If ``binary`` is True then a tuple with lists ``T`` and ``F`` are returned where ``T`` is a list containing elements of seq for which ``keyfunc`` was ``True`` and ``F`` containing those elements for which ``keyfunc`` was ``False``; a ValueError is raised if the ``keyfunc`` is not binary. Examples ======== >>> from sympy.utilities import sift >>> from sympy.abc import x, y >>> from sympy import sqrt, exp, pi, Tuple >>> sift(range(5), lambda x: x % 2) {0: [0, 2, 4], 1: [1, 3]} sift() returns a defaultdict() object, so any key that has no matches will give []. >>> sift([x], lambda x: x.is_commutative) {True: [x]} >>> _[False] [] Sometimes you will not know how many keys you will get: >>> sift([sqrt(x), exp(x), (y**x)**2], ... lambda x: x.as_base_exp()[0]) {E: [exp(x)], x: [sqrt(x)], y: [y**(2*x)]} Sometimes you expect the results to be binary; the results can be unpacked by setting ``binary`` to True: >>> sift(range(4), lambda x: x % 2, binary=True) ([1, 3], [0, 2]) >>> sift(Tuple(1, pi), lambda x: x.is_rational, binary=True) ([1], [pi]) A ValueError is raised if the predicate was not actually binary (which is a good test for the logic where sifting is used and binary results were expected): >>> unknown = exp(1) - pi # the rationality of this is unknown >>> args = Tuple(1, pi, unknown) >>> sift(args, lambda x: x.is_rational, binary=True) Traceback (most recent call last): ... ValueError: keyfunc gave non-binary output The non-binary sifting shows that there were 3 keys generated: >>> set(sift(args, lambda x: x.is_rational).keys()) {None, False, True} If you need to sort the sifted items it might be better to use ``ordered`` which can economically apply multiple sort keys to a sequence while sorting. See Also ======== ordered zkeyfunc gave non-binary output)rrJrA IndexError TypeErrorr=)rSkeyfuncbinaryr*rsiftFTs r rrIsR   A gajM  #b&D41  ?   # #A & 4KI& ?=> > ?s A))Bcb[[U5U5VVs/sHup#UPM snn$s snnf)z+Return ``n`` items from ``iter`` iterator. )rKr()rGrHr)values r takers)#&uQx#6 8#6xqU#6 88 8s+c>0nUHnURU5 M U$)z-Merge dictionaries into a single dictionary. )update)dictsmergedrws r dict_mergers$ F d Mr,c ^^[T5(d/$[T5S:XaTS$Sm[[ST555H2m[UU4Sj[[T5555(aM2 O TS- mTSST$)aDReturn the subsequence that is a common start of sequences in ``seqs``. >>> from sympy.utilities.iterables import common_prefix >>> common_prefix(list(range(3))) [0, 1, 2] >>> common_prefix(list(range(3)), list(range(4))) [0, 1, 2] >>> common_prefix([1, 2, 3], [1, 2, 5]) [1, 2] >>> common_prefix([1, 2, 3], [1, 3, 5]) [1] rrc38# UHn[U5v M g7fr0r&rrs r r! common_prefix..s,t!s1vvtc3F># UHnTUTTST:Hv M g7frNrrrrseqss r r!r(F5E471:a+5E!Nr'r&r(minrrs`@r common_prefixrs~ t99 TaAw A 3,t,, -FU3t95EFFF . Q 72A;r,c 4^^[T5(d/$[T5S:XaTS$Sm[S[ST55*S- S5H2m[UU4Sj[[T5555(aM2 O TS-mTS:Xa/$TSTS-S$)a>Return the subsequence that is a common ending of sequences in ``seqs``. >>> from sympy.utilities.iterables import common_suffix >>> common_suffix(list(range(3))) [0, 1, 2] >>> common_suffix(list(range(3)), list(range(4))) [] >>> common_suffix([1, 2, 3], [9, 2, 3]) [2, 3] >>> common_suffix([1, 2, 3], [9, 7, 3]) [3] rrr{c38# UHn[U5v M g7fr0rrs r r! common_suffix..s1DqCFFDrc3F># UHnTUTTST:Hv M g7frrrs r r!rrrNrrs`@r common_suffixrs t99 TaAw A 21D111A5r :FU3t95EFFF ; QBw Awq1uvr,c#Z# [U5n[U5H nUSUS-v M g7f)z Generate all prefixes of a sequence. Examples ======== >>> from sympy.utilities.iterables import prefixes >>> list(prefixes([1,2,3,4])) [[1], [1, 2], [1, 2, 3], [1, 2, 3, 4]] Nrr&r(rSrHrs r prefixesrs. CA 1X&1q5ks)+c#^# [U5n[U5HnXU- S- Sv M g7f)z Generate all postfixes of a sequence. Examples ======== >>> from sympy.utilities.iterables import postfixes >>> list(postfixes([1,2,3,4])) [[4], [3, 4], [2, 3, 4], [1, 2, 3, 4]] rNrrs r postfixesrs0 CA 1Xa%!)*os+-c0Uup#/n[U5n[U5nURSU55 UcSn[XQSS9nU(aUR 5nUR U5 [U5HupxXv:XdM UR Xx45 UH upX:XdM M/ U"U5n [U5H&upU"U 5nX:dMURX5 Ml UR U5 M U(aMU(a [S5eU$)a) Topological sort of graph's vertices. Parameters ========== graph : tuple[list, list[tuple[T, T]] A tuple consisting of a list of vertices and a list of edges of a graph to be sorted topologically. key : callable[T] (optional) Ordering key for vertices on the same level. By default the natural (e.g. lexicographic) ordering is used (in this case the base type must implement ordering relations). Examples ======== Consider a graph:: +---+ +---+ +---+ | 7 |\ | 5 | | 3 | +---+ \ +---+ +---+ | _\___/ ____ _/ | | / \___/ \ / | V V V V | +----+ +---+ | | 11 | | 8 | | +----+ +---+ | | | \____ ___/ _ | | \ \ / / \ | V \ V V / V V +---+ \ +---+ | +----+ | 2 | | | 9 | | | 10 | +---+ | +---+ | +----+ \________/ where vertices are integers. This graph can be encoded using elementary Python's data structures as follows:: >>> V = [2, 3, 5, 7, 8, 9, 10, 11] >>> E = [(7, 11), (7, 8), (5, 11), (3, 8), (3, 10), ... (11, 2), (11, 9), (11, 10), (8, 9)] To compute a topological sort for graph ``(V, E)`` issue:: >>> from sympy.utilities.iterables import topological_sort >>> topological_sort((V, E)) [3, 5, 7, 8, 11, 2, 9, 10] If specific tie breaking approach is needed, use ``key`` parameter:: >>> topological_sort((V, E), key=lambda v: -v) [7, 5, 11, 3, 10, 8, 9, 2] Only acyclic graphs can be sorted. If the input graph has a cycle, then ``ValueError`` will be raised:: >>> topological_sort((V, E + [(10, 7)])) Traceback (most recent call last): ... ValueError: cycle detected References ========== .. [1] https://en.wikipedia.org/wiki/Topological_sorting c3*# UH upUv M g7fr0r)rvus r r!#topological_sort..Zs(adaacU$r0r)rs r keytopological_sort..key]sLr,T)rreversezcycle detected) r2rJdifference_updatesortedpoprAremove enumerateinsertr=)graphrVELSnoderr_u_vkvrrkss r topological_sortr sN DA A AA QA(a(( {  q4(A uuw GDAy! FBw QB )!  V7HHQN! !- # !. )**r,cUupUVs0sHo3/_M nnUHupVXERU5 M [X5$s snf)a! Strongly connected components of a directed graph in reverse topological order. Parameters ========== G : tuple[list, list[tuple[T, T]] A tuple consisting of a list of vertices and a list of edges of a graph whose strongly connected components are to be found. Examples ======== Consider a directed graph (in dot notation):: digraph { A -> B A -> C B -> C C -> B B -> D } .. graphviz:: digraph { A -> B A -> C B -> C C -> B B -> D } where vertices are the letters A, B, C and D. This graph can be encoded using Python's elementary data structures as follows:: >>> V = ['A', 'B', 'C', 'D'] >>> E = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'B'), ('B', 'D')] The strongly connected components of this graph can be computed as >>> from sympy.utilities.iterables import strongly_connected_components >>> strongly_connected_components((V, E)) [['D'], ['B', 'C'], ['A']] This also gives the components in reverse topological order. Since the subgraph containing B and C has a cycle they must be together in a strongly connected component. A and D are connected to the rest of the graph but not in a cyclic manner so they appear as their own strongly connected components. Notes ===== The vertices of the graph must be hashable for the data structures used. If the vertices are unhashable replace them with integer indices. This function uses Tarjan's algorithm to compute the strongly connected components in `O(|V|+|E|)` (linear) time. References ========== .. [1] https://en.wikipedia.org/wiki/Strongly_connected_component .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm See Also ======== sympy.utilities.iterables.connected_components )rA_strongly_connected_components)GrrviGmapv1v2s r strongly_connected_componentsrsLd DA QrFQD   )! 22 s AcZ^^ ^ ^ ^ ^ 0m 0m [5m /m /m [5nUU U U U 4SjnU U U U U 4SjnUHnnUT ;aM U"U5 T (dMT Supg[Xr5nXLa U"U5 O*UT ;a U"U5 OUT ;a[T UT U5T U'T (aMRMp T $)zAMore efficient internal routine for strongly_connected_componentscx>[T5nU=TU'TU'STU'TRU[TU545 gr0)r&rArG)rindexr callstackr%lowlinkstacks r r-_strongly_connected_components..startsBE "'' WQZa!T$q']+,r,cH>TUTU:Xa_TR5S/nUSULa,URTR5S5 USULaM,TRUSSS25 TR5up#T(aTSup[TUTU5TU'gg)Nrr{)popitemrArr) r componentrr)r componentsr%rrs r finish._strongly_connected_components..finishs 2;'"+ %+,IB-r)  !34B-r)   i"o .  bMEBgbk72;7GBK r,r{)rrgrar)rrnomorerrrrrjrrrr%rrs ` @@@@@r rrs(GG MEIJ XF-- 8 8 <  aimGBc"B|r 7"b u!'"+wr{; i " r,cfUup/nUHupEURXE4XT4/5 M [X45$)aY Connected components of an undirected graph or weakly connected components of a directed graph. Parameters ========== G : tuple[list, list[tuple[T, T]] A tuple consisting of a list of vertices and a list of edges of a graph whose connected components are to be found. Examples ======== Given an undirected graph:: graph { A -- B C -- D } .. graphviz:: graph { A -- B C -- D } We can find the connected components using this function if we include each edge in both directions:: >>> from sympy.utilities.iterables import connected_components >>> V = ['A', 'B', 'C', 'D'] >>> E = [('A', 'B'), ('B', 'A'), ('C', 'D'), ('D', 'C')] >>> connected_components((V, E)) [['A', 'B'], ['C', 'D']] The weakly connected components of a directed graph can found the same way. Notes ===== The vertices of the graph must be hashable for the data structures used. If the vertices are unhashable replace them with integer indices. This function uses Tarjan's algorithm to compute the connected components in `O(|V|+|E|)` (linear) time. References ========== .. [1] https://en.wikipedia.org/wiki/Component_%28graph_theory%29 .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm See Also ======== sympy.utilities.iterables.strongly_connected_components )r?r)rrr E_undirectedrrs r connected_componentsrsBN DALbXx01 (!): ;;r,cT[U5S:Xa/$U[U5-nXSUSU-$)z Left rotates a list x by the number of steps specified in y. Examples ======== >>> from sympy.utilities.iterables import rotate_left >>> a = [0, 1, 2] >>> rotate_left(a, 1) [1, 2, 0] rNrr4ys r rotate_leftr gs5 1v{  CF A R51Ra5=r,cl[U5S:Xa/$[U5U[U5-- nXSUSU-$)z Right rotates a list x by the number of steps specified in y. Examples ======== >>> from sympy.utilities.iterables import rotate_right >>> a = [0, 1, 2] >>> rotate_right(a, 1) [2, 0, 1] rNrr s r rotate_rightrzs> 1v{  ASVA R51Ra5=r,cSSKJn UcUnX-nS/[U5-nSn[S[U55HnX6nXFU- S- nUS:waGXsXX-S-:wa:U"U5U"X5U-S-5:aXh- S- nXHnUS:waXsXX-S-:waM:XsXX-S-:waU"U5U"X55:aUnSXFU- 'MUS-XFU- 'M U$)a Returns the number of steps of left rotation required to obtain lexicographically minimal string/list/tuple, etc. Examples ======== >>> from sympy.utilities.iterables import least_rotation, rotate_left >>> a = [3, 1, 5, 1, 2] >>> least_rotation(a) 3 >>> rotate_left(a, _) [1, 2, 3, 1, 5] References ========== .. [1] https://en.wikipedia.org/wiki/Lexicographically_minimal_string_rotation rIdr{r)(sympy.functions.elementary.miscellaneousrr&r() r4rrrfrrsjrs r least_rotationrs*< {"C A s1v A A 1SV_ T c!eH2g"!#a%.2wQs1uX&CEA2g"!#a%. 13q5>2wQT"AcFqSAcF Hr,c ## SSKJn Uc[U[5(ak[ SUR 555(a [ S5e[UR 55nX:agU"U5Vs/sHoUX/PM nnOC[U5n[U5nX:ag[U5nU"U5Vs/sHoUX4PM nnAO[SU55nX:dU(d/v g[U5HpunupWXq:a U/U-v US - n[[X5SS 5H<n[!SX- X&S -S5H!nU/U-U-n [U 5U:XdMU v M# M> Mr gs snfs snf![a= [U"U55n[USS9Vs/sHn[U5PM Os snfnnNf=f7f) a Return the unique combinations of size ``n`` from multiset ``m``. Examples ======== >>> from sympy.utilities.iterables import multiset_combinations >>> from itertools import combinations >>> [''.join(i) for i in multiset_combinations('baby', 3)] ['abb', 'aby', 'bby'] >>> def count(f, s): return len(list(f(s, 3))) The number of combinations depends on the number of letters; the number of unique combinations depends on how the letters are repeated. >>> s1 = 'abracadabra' >>> s2 = 'banana tree' >>> count(combinations, s1), count(multiset_combinations, s1) (165, 23) >>> count(combinations, s2), count(multiset_combinations, s2) (165, 54) rorderedNc3># UHn[U5S:v M g7frrrrs r r!(multiset_combinations..5*Q6!9q=*counts cannot be negativeFr\c3*# UH upUv M g7fr0rrrrs r r!rs adaarrr{)sympy.core.sortingrr8rwanyvaluesr=rNrJr&ryrr^rr(rmultiset_combinations) r*rHr]rNrrrrrWs r r%r%s4+y a  5!((*555 !<==AHHJAu$+AJ/JqQTJA/AQAAAu @QK(/ 3 1Y 3   a uA"1IAvvc!e E3q9a,.tQUA!efIFAQB2w!| G- &'04 @$&+A&>?&>T!W&>?? @s[A8G:E4 G)E>>E9 E>BG#G9E>>'G%F;:GGGGc#B# SSKJn Uc[U[5(aL[ SUR 555(a [ S5eU"U5Vs/sHoDX/PM nnO4[U"U55n[USS9Vs/sHn[U5PM nnAUVs/sHofSS:dM UPM nn[S U55nU(aUb X:dUS:aU(dUbUS:Xa/v gUS:XaUH upIU/v M g[U5S:Xa3USupIUcU OX::aUOSn [U 5Vs/sHoTPM snv g[S U55(a6[UVV s/sHupIUPM sn nU5Hn [U 5v M gUbUOUn[U5HNunupIXuS==S-ss'[SUS- U5Hn U (dM U/U -v M XuS==S- ss'MP gs snfs snfs snfs snfs sn nf7f) aG Return the unique permutations of multiset ``m``. Examples ======== >>> from sympy.utilities.iterables import multiset_permutations >>> from sympy import factorial >>> [''.join(i) for i in multiset_permutations('aab')] ['aab', 'aba', 'baa'] >>> factorial(len('banana')) 720 >>> len(list(multiset_permutations('banana'))) 60 rrNc3># UHn[U5S:v M g7frrrs r r!(multiset_permutations.. rrrFrrc3*# UH oSv M g7frr)rgis r r!r)s !bebrc30# UH upUS:Hv M g7frrr!s r r!r)s #Q!Vs)r"rr8rwr#r$r=rJr^rNr&r(r'r rmultiset_permutations) r*sizer]rrrr+doSUMrprs r r-r-s +y a  5!((*555 !<==$+AJ/JqQTJA/AWQZ A"'E":;":Qa":A;  &qqEAI"qB & !b ! !C !tzTAXdldaiH DA#I RA!uADID1(#(Qq(## # # # #R0RTQqR0$7Aq'M8'tS"2IAv E!HMH*42>1#'M? E!HMH '/0< &$0sPAHH* H H H& H6H>> from sympy.utilities.iterables import _partition >>> _partition('abcde', [1, 0, 1, 2, 0]) [['b', 'e'], ['a', 'c'], ['d']] Specifying the number of bins in the partition is optional: >>> _partition('abcde', [1, 0, 1, 2, 0], 3) [['b', 'e'], ['a', 'c'], ['d']] The output of _set_partitions can be passed as follows: >>> output = (3, [1, 0, 1, 2, 0]) >>> _partition('abcde', *output) [['b', 'e'], ['a', 'c'], ['d']] See Also ======== combinatorics.partitions.Partition.from_rgs r)maxr8rQr(rrA)rSvectorr*rr1rs r _partitionr5*sk8 y K!O FC 1XXXA&!  CF" H s A0c#&# S/U-nS/U-nSnX24v X0:wauUnUS-nX$nXS:waOSX$'MUS- nXRU'US- nX4U- - nUS==X- - ss'XS:Xa SX'US- nXS- ==S-ss'X==S- ss'X24v X0:waMtgg7f)a[Cycle through all partitions of n elements, yielding the current number of partitions, ``m``, and a mutable list, ``q`` such that ``element[i]`` is in part ``q[i]`` of the partition. NOTE: ``q`` is modified in place and generally should not be changed between function calls. Examples ======== >>> from sympy.utilities.iterables import _set_partitions, _partition >>> for m, q in _set_partitions(3): ... print('%s %s %s' % (m, q, _partition('abc', q, m))) 1 [0, 0, 0] [['a', 'b', 'c']] 2 [0, 0, 1] [['a', 'b'], ['c']] 2 [0, 1, 0] [['a', 'c'], ['b']] 2 [0, 1, 1] [['a'], ['b', 'c']] 3 [0, 1, 2] [['a'], ['b'], ['c']] Notes ===== This algorithm is similar to, and solves the same problem as, Algorithm 7.2.1.5H, from volume 4A of Knuth's The Art of Computer Programming. Knuth uses the term "restricted growth string" where this code refers to a "partition vector". In each case, the meaning is the same: the value in the ith element of the vector specifies to which part the ith set element is to be assigned. At the lowest level, this code implements an n-digit big-endian counter (stored in the array q) which is incremented (with carries) to get the next partition in the sequence. A special twist is that a digit is constrained to be at most one greater than the maximum of all the digits to the left of it. The array p maintains this maximum, so that the code can efficiently decide when a digit can be incremented in place or whether it needs to be reset to 0 and trigger a carry to the next digit. The enumeration starts with all the digits 0 (which corresponds to all the set elements being assigned to the same 0th part), and ends with 0123...n, which corresponds to each set element being assigned to a different, singleton, part. This routine was rewritten to use 0-based lists while trying to preserve the beauty and efficiency of the original algorithm. References ========== .. [1] Nijenhuis, Albert and Wilf, Herbert. (1978) Combinatorial Algorithms, 2nd Ed, p 91, algorithm "nexequ". Available online from https://www.math.upenn.edu/~wilf/website/CombAlgDownld.html (viewed November 17, 2012). rrNr)rHr1qncr*rs r _set_partitionsr9Psl AA AA B %K '  FAAtqyAD  Q! Q !e  !  7AE !GB a%A   e % 's B BBc ## [U[5(aUnU(aX:ag[[U55nUS:Xa USS/v g[ U5HXup4UbX1:XdM[U5Vs/sHn/PM nn[U5HnXdUR X5 M Uv MZ g[ U5S:Xa[U[5(aU/n[U5(d{[ U5nU(aX:agUS:Xa USS/v gUSSn[X!SS9H@upUbX:XdM/n[U 5Hn URXz-/X-5 M Uv MB gSSK J n [U "U55n[ U5nU(aX:agUS:Xa USS/v g[[US56up[ U 5[ U5:a[U(a4[!5nUR#XS- U5Hn[%X5v M g['U 5Hn[%X5v M g[ U5H|up4UbX1:XdM[U5Vs/sHn/PM nn[U5HnXdUR U5 M UVVs/sHoUVs/sHnUUPM snPM snnv M~ gs snfs snfs snfs snnf7f)a Return unique partitions of the given multiset (in list form). If ``m`` is None, all multisets will be returned, otherwise only partitions with ``m`` parts will be returned. If ``multiset`` is an integer, a range [0, 1, ..., multiset - 1] will be supplied. Examples ======== >>> from sympy.utilities.iterables import multiset_partitions >>> list(multiset_partitions([1, 2, 3, 4], 2)) [[[1, 2, 3], [4]], [[1, 2, 4], [3]], [[1, 2], [3, 4]], [[1, 3, 4], [2]], [[1, 3], [2, 4]], [[1, 4], [2, 3]], [[1], [2, 3, 4]]] >>> list(multiset_partitions([1, 2, 3, 4], 1)) [[[1, 2, 3, 4]]] Only unique partitions are returned and these will be returned in a canonical order regardless of the order of the input: >>> a = [1, 2, 2, 1] >>> ans = list(multiset_partitions(a, 2)) >>> a.sort() >>> list(multiset_partitions(a, 2)) == ans True >>> a = range(3, 1, -1) >>> (list(multiset_partitions(a)) == ... list(multiset_partitions(sorted(a)))) True If m is omitted then all partitions will be returned: >>> list(multiset_partitions([1, 1, 2])) [[[1, 1, 2]], [[1, 1], [2]], [[1, 2], [1]], [[1], [1], [2]]] >>> list(multiset_partitions([1]*3)) [[[1, 1, 1]], [[1], [1, 1]], [[1], [1], [1]]] Counting ======== The number of partitions of a set is given by the bell number: >>> from sympy import bell >>> len(list(multiset_partitions(5))) == bell(5) == 52 True The number of partitions of length k from a set of size n is given by the Stirling Number of the 2nd kind: >>> from sympy.functions.combinatorial.numbers import stirling >>> stirling(5, 2) == len(list(multiset_partitions(5, 2))) == 15 True These comments on counting apply to *sets*, not multisets. Notes ===== When all the elements are the same in the multiset, the order of the returned partitions is determined by the ``partitions`` routine. If one is counting partitions then it is better to use the ``nT`` function. See Also ======== partitions sympy.combinatorics.partitions.Partition sympy.combinatorics.partitions.IntegerPartition sympy.functions.combinatorial.numbers.nT NrTr.rrF)r8rQrJr(r9rAr&r has_variety partitionsrr?r"rrKr^r enum_rangerr)ryr*rHr8r7rrWr4r.r1rrelementsmultiplicitiesmptstaters r multiset_partitionsrCsZ(C    a> 6A;-  %Q'EByBG"'),)Qb),qAtHOOHK0" (  8}j377: x  M   6A;-   RaL!!T2GDyDIAIIqseADj)# 3 /)* M   6A;-   $'h(>#?  x=3x= (02 ^^NaCCE&u77D7~FE&u77G)+9&+Bi0i"iB0"1XQ4*&=?@R3AHQK3R@@ ,o-r14@sVAK $ K 1 J5=B-K .DK  K  J:/K  KJ?#K*K ?KK c#*# US::d(UbUS:dUbUS:dU(a"U(aX-U:aU(aS04v g0v gUcUnO [X5n[U=(d UU5n[U5[U5[U5p!n[X5upEX$0nU/nU(aSXe'URU5 X- [ U5- nU(a,[ UR 55UR54v OUR5v US/:waUSS:XaUS URS5n X- nOSn USn XjS- =oU 'X- n U S:XaUS Xj US- nU S-n [X5upEU[ U5-n X:a U(dgMTXFU 'URU 5 U(aSXe'URU5 X-nU(a,[ UR 55UR54v OUR5v US/:waMgg7f)aGenerate all partitions of positive integer, n. Each partition is represented as a dictionary, mapping an integer to the number of copies of that integer in the partition. For example, the first partition of 4 returned is {4: 1}, "4: one of them". Parameters ========== n : int m : int, optional limits number of parts in partition (mnemonic: m, maximum parts) k : int, optional limits the numbers that are kept in the partition (mnemonic: k, keys) size : bool, default: False If ``True``, (M, P) is returned where M is the sum of the multiplicities and P is the generated partition. If ``False``, only the generated partition is returned. Examples ======== >>> from sympy.utilities.iterables import partitions The numbers appearing in the partition (the key of the returned dict) are limited with k: >>> for p in partitions(6, k=2): # doctest: +SKIP ... print(p) {2: 3} {1: 2, 2: 2} {1: 4, 2: 1} {1: 6} The maximum number of parts in the partition (the sum of the values in the returned dict) are limited with m (default value, None, gives partitions from 1 through n): >>> for p in partitions(6, m=2): # doctest: +SKIP ... print(p) ... {6: 1} {1: 1, 5: 1} {2: 1, 4: 1} {3: 2} References ========== .. [1] modified from Tim Peter's version to allow for k and m values: https://code.activestate.com/recipes/218332-generator-for-integer-partitions/ See Also ======== sympy.combinatorics.partitions.Partition sympy.combinatorics.partitions.IntegerPartition rNrr{) rrrOrAboolrNr$copyr) rHr*rr.r7rmskeysroomreusernewcountneeds r r=r==sv Q !a% !a% aAC!G R%K Hy  I AFAAQiF1I!A !>> from sympy.utilities.iterables import ordered_partitions All partitions of 5 in ascending lexicographical: >>> for p in ordered_partitions(5): ... print(p) [1, 1, 1, 1, 1] [1, 1, 1, 2] [1, 1, 3] [1, 2, 2] [1, 4] [2, 3] [5] Only partitions of 5 with two parts: >>> for p in ordered_partitions(5, 2): ... print(p) [1, 4] [2, 3] When ``m`` is given, a given list objects will be used more than once for speed reasons so you will not see the correct partitions unless you make a copy of each as it is generated: >>> [p for p in ordered_partitions(7, 3)] [[1, 1, 1], [1, 1, 1], [1, 1, 1], [2, 2, 2]] >>> [list(p) for p in ordered_partitions(7, 3)] [[1, 1, 5], [1, 2, 4], [1, 3, 3], [2, 2, 3]] When ``n`` is a multiple of ``m``, the elements are still sorted but the partitions themselves will be *unordered* if sort is False; the default is to return them in ascending lexicographical order. >>> for p in ordered_partitions(6, 2): ... print(p) [1, 5] [2, 4] [3, 3] But if speed is more important than ordering, sort can be set to False: >>> for p in ordered_partitions(6, 2, sort=False): ... print(p) [1, 5] [3, 3] [2, 4] References ========== .. [1] Generating Integer Partitions, [online], Available: https://jeromekelleher.net/generating-integer-partitions.html .. [2] Jerome Kelleher and Barry O'Sullivan, "Generating All Partitions: A Comparison Of Two Encodings", [online], Available: https://arxiv.org/pdf/0909.2331v2.pdf rNr{rrF)sortT)r(ordered_partitionsr&) rHr*rOar rr4wbaxmirs r rPrPs \ 1u !a%y CE  !e FAqAq1u*!Qq1u*AA&!!QiQQ & 5ADqABQ%K!!e" ac c!e q!$(#AAAaCAGaf,QU;BRB.01b1ub1AcdGG c"fAcdG <  1+B0TB24"5"Qq5""5#$#$#b&#$C&$2 #6s1AF+FF A;FF)9F"F 0*Fc#.# SSKJnJn [SU"U"U55-5nSn/nU(a+XC-U::aUR U5 XC- nUS-nU(aM+[ U5S- US-- nUS:aUv XVS:XaSXV'UR S5 US-nM.UR S5 XV==S-ss'XV=ouUS-'US- nUS:a4U[ U5U- S- ::aXW*S-S2 US- nXuU'OUS-nUS:aM4US:aMS/U-v g7f)a Generates the binary partition of *n*. A binary partition consists only of numbers that are powers of two. Each step reduces a `2^{k+1}` to `2^k` and `2^k`. Thus 16 is converted to 8 and 8. Examples ======== >>> from sympy.utilities.iterables import binary_partitions >>> for i in binary_partitions(5): ... print(i) ... [4, 1] [2, 2, 1] [2, 1, 1, 1] [1, 1, 1, 1, 1] References ========== .. [1] TAOCP 4, section 7.2.1.5, problem 64 r)ceillog2rrN)mathrWrXrQrAr&)rHrWrXpoweracc partitionlast_numr4s r binary_partitionsr^IsL4 DaM" #E CI  ;!    U # LC !  % 9~!QU+H a-  ! #"#I    Q  MH !&/&99hl #A !eC NX-11b1fg&A &'(#a !e a-$ #a%KsADB'DD Dc ^SSKJn SSKJn [ U[ [ X45(ag[ 5m[U4SjU55$![a, [U5[[[U555:gs$f=f)zReturn True if there are any duplicate elements in ``seq``. Examples ======== >>> from sympy import has_dups, Dict, Set >>> has_dups((1, 2, 1)) True >>> has_dups(range(3)) False >>> all(has_dups(c) is False for c in (set(), Set(), dict(), Dict())) True r)Dict)SetFc3b># UH$oT;dTRU5(dM Sv M& g7fTN)add)rruniques r r!has_dups..s!EAV vzz!}44s/ /) sympy.core.containersr`sympy.sets.setsrar8rwr2r#rr&rJuniq)rSr`rares @r has_dupsrjsj+##c4-.. UF0EEEE 03x3tDI///0sA 3BBcP[U5HupUS:XaUnMUW:wdM g g)zReturn True if there are any different elements in ``seq``. Examples ======== >>> from sympy import has_variety >>> has_variety((1, 2, 1)) True >>> has_variety((1, 1, 1)) False rTF)r)rSrrres r r<r<s/# 6HH}  r,c#^^# [T5mUU4Sjn[5nU=(d /n[T5H/upEXS;aM UR U5(aM$Uv U"5 M1 g![a SmNjf=f![ah WU;aUv U"5 UR U5 [ TS5(a[TWS-SU5ShvN g[TU5ShvN gf=f7f)a Yield unique elements from ``seq`` as an iterator. The second parameter ``result`` is used internally; it is not necessary to pass anything for this. Note: changing the sequence during iteration will raise a RuntimeError if the size of the sequence is known; if you pass an iterator and advance the iterator you will change the output of this routine but there will be no warning. Examples ======== >>> from sympy.utilities.iterables import uniq >>> dat = [1, 4, 1, 5, 4, 2, 1, 2] >>> type(uniq(dat)) in (list, tuple) False >>> list(uniq(dat)) [1, 4, 5, 2] >>> list(uniq(x for x in dat)) [1, 4, 5, 2] >>> list(uniq([[1], [2, 1], [1]])) [[1], [2, 1]] NcB>Tb[T5T:wa [S5egg)Nz&sequence changed size during iteration)r& RuntimeError)rHrSsr checkuniq..checks' =SX]GH H+=r, __getitem__r)r&rr2rrdrAr>ri)rSrCroseenrrrHs` @r riris4 HI )u2cNDAI!#   ) F?G G MM!  3 & &CAK0 0 0C( ( ()s{C4 A-C4(A?A?A?,C4- A<9C4;A<<C4?AC1CC1C4C1(C+)C1.C40C11C4c## [U5nUS:a [S5eUS:XaSv g US:Xa Sv Sv g US:Xa /SQS hvN g US- nS /S /U--n[[U55n[ U5v S n[U5H!nX%(dMX5US:dMXSU4nM# UupVUcg XRU-nX7X5sX5'X7'X'X%sX%'X''US :XdXq:XdX7X'-X7:aS X''[U5HnX5X7:dMSX%'M [US-U5HnX5X7:dMS X%'M MN7f) a{ Return permutations of [0, 1, ..., n - 1] such that each permutation differs from the last by the exchange of a single pair of neighbors. The ``n!`` permutations are returned as an iterator. In order to obtain the next permutation from a random starting permutation, use the ``next_trotterjohnson`` method of the Permutation class (which generates the same sequence in a different manner). Examples ======== >>> from itertools import permutations >>> from sympy.utilities.iterables import generate_bell >>> from sympy import zeros, Matrix This is the sort of permutation used in the ringing of physical bells, and does not produce permutations in lexicographical order. Rather, the permutations differ from each other by exactly one inversion, and the position at which the swapping occurs varies periodically in a simple fashion. Consider the first few permutations of 4 elements generated by ``permutations`` and ``generate_bell``: >>> list(permutations(range(4)))[:5] [(0, 1, 2, 3), (0, 1, 3, 2), (0, 2, 1, 3), (0, 2, 3, 1), (0, 3, 1, 2)] >>> list(generate_bell(4))[:5] [(0, 1, 2, 3), (0, 1, 3, 2), (0, 3, 1, 2), (3, 0, 1, 2), (3, 0, 2, 1)] Notice how the 2nd and 3rd lexicographical permutations have 3 elements out of place whereas each "bell" permutation always has only two elements out of place relative to the previous permutation (and so the signature (+/-1) of a permutation is opposite of the signature of the previous permutation). How the position of inversion varies across the elements can be seen by tracing out where the largest number appears in the permutations: >>> m = zeros(4, 24) >>> for i, p in enumerate(generate_bell(4)): ... m[:, i] = Matrix([j - 3 for j in list(p)]) # make largest zero >>> m.print_nonzero('X') [XXX XXXXXX XXXXXX XXX] [XX XX XXXX XX XXXX XX XX] [X XXXX XX XXXX XX XXXX X] [ XXXXXX XXXXXX XXXXXX ] See Also ======== sympy.combinatorics.permutations.Permutation.next_trotterjohnson References ========== .. [1] https://en.wikipedia.org/wiki/Method_ringing .. [2] https://stackoverflow.com/questions/4856615/recursive-permutation/4857018 .. [3] https://web.archive.org/web/20160313023044/http://programminggeeks.com/bell-algorithm-for-permutation/ .. [4] https://en.wikipedia.org/wiki/Steinhaus%E2%80%93Johnson%E2%80%93Trotter_algorithm .. [5] Generating involutions, derangements, and relatives by ECO Vincent Vajnovszki, DMTCS vol 1 issue 12, 2010 rzn must be a positive integer)rr)rr)rr))rrr)rrr)rrr)rrr)rrr)rrrNrr{Nr{)rr=rJr(r)rHr*oplbigrr)rs r generate_bellrysoB q A1u788Av a  aUUU ESB46\ qN(NC1X55QTCF]qT'CDAyqE AqtJAD!$5"%LBE25Av1Y>> from sympy.utilities.iterables import generate_involutions >>> list(generate_involutions(3)) [(0, 1, 2), (0, 2, 1), (1, 0, 2), (2, 1, 0)] >>> len(list(generate_involutions(4))) 10 References ========== .. [1] https://mathworld.wolfram.com/PermutationInvolution.html N)rJr(r )rHidxr1rs r generate_involutionsr|SsD8 uQx.C # A1w!|G s 1AAc #^^^^^^^# SSKJn [T5n[UR55n [T5mU S-T:ag[U5T:Xa[T5ShvN gUH n X*U :XdM O [T5Vs/sHnTUW :wdMUPM n n[T5Vs/sHnTUW :XdMUPM n nS/T-mSU -T:Xa[U HnW TU'M [U Vs/sHnTUPM sn5H n [X5H up~UTU'M Tv M" S/T-TSS&gTSU -- S:Xa[UR55TU - S-:Xa[ U 5HupU SUXS-S-nUHnW TU'M [!UVs/sHnTUPM sn5HFn TUTU'[X5H upUTU'M UnU HnTUTUsTU'TU'Tv UnM MH M S/T-TSS&gUUU4SjmUUU4SjmUUUUU4Sjm[#UR%5S S 9mT"[T5S- 5ShvN S/T-TSS&g![a [ [ U"[ T5555n/nTH(nUHnX6U:XdM URU5 M& M* [U5H nUVs/sHoUPM Os snfsnv M" gf=fGNs snfs snfs snfs snfN7f) aVGenerate derangements of the elements of s *in place*. Examples ======== >>> from sympy.utilities.iterables import multiset_derangements, uniq Because the derangements of multisets (not sets) are generated in place, copies of the return value must be made if a collection of derangements is desired or else all values will be the same: >>> list(uniq([i for i in multiset_derangements('1233')])) [[None, None, None, None]] >>> [i.copy() for i in multiset_derangements('1233')] [['3', '3', '1', '2'], ['3', '3', '2', '1']] >>> [''.join(i) for i in multiset_derangements('1233')] ['3312', '3321'] rrNrrc3># T SSnT SSnT SSnT SSn/n/n/n[[T 55HTnT UbM T UU:XaURU5 M'T UU:XaURU5 MCURU5 MV [U5U:d[U5U:agUHnUT U'M UHnUT U'M [Xa[U5- 5H9nUHn UT U 'M UHnT UbM UT U'M T v UHnST U'M M; UHnST U'M UHnST U'M g7f)z]Place the last two elements into the partially completed derangement, and yield the results. rrN)r(r&rAr) rQa_ctrSb_ctforced_aforced_b open_freera_placea_posrWrrs r finish_derangements2multiset_derangements..finish_derangementssp GAJAwqz GAJAwqz s1vA!u}Q419OOA&qTQYOOA&$$Q' x=4 3x=4#7 ABqEABqE#Ic(m/CDG 5 !a5=BqEH1EABqEABqEsAE B9E[T5Vs/sHnTUbM TUU:wdMUPM sn$s snfr0)r()rrrHrWrs r iopen$multiset_derangements..iopen s3!8C8ar!u18CCCs 111c3># US:XaT"5ShvN gT Uup[T"U5U5H2nUHnUTU'M T"US- 5ShvN UHnSTU'M M4 gNUN7fNrr) rMmxriir/rrrWrs r r/!multiset_derangements..do s 6+, , ,GEA!%(B/BBrFa!e9$$B!BrF0 -%s!A.A*=A.A,A.,A.cUSUS4$)Nrrrr3s r 'multiset_derangements..0 sAaD!A$ q1  1R4x1}RYY[)QVaZ7u%EA"1Icd +E1!"7A1Q4"7822 ZEABqE(A#%a5"Q%LBqE2a5HA 9 &q1/bD ""* "((*"7 8D#d)a-   F1HBqEE  9WT!W-./ B6R<HHQK 'q)A#$%1aq61% %* 2 ( / +(="#8D!sL  I A L 'K2(L <L  K5K5$L 3 K:K: (L 2K?BL L (B)L L L  ?K/#,K/KK/,L .K//L 5L c^^TcSSKnURmU4SjmU4Sjn[U5n[U5n[ UR 5SS9nUSupx[U5n SU-U- n U S:aU(a [ S 5e[U5V V s/sHupXSS:XdMU PM n n n U"X5 [ U SU 5n[U5n[U5Hn URU 5 M [UT5nUHn URXSS5 M [U5[LaS RU5$U$U [U5:Xa9[U5nT"U5 [!S [#X555(aU$M-S/U -nSnU[U5*:aUS -nUUunn [%U 5V s/sHoU bM X U:wdMU PM n n [U 5U :a[%U 5Hn SX'M O5U"X5 [%U 5H n UXU 'M U[U5*:aMU$Ms sn n fs sn f) aReturn a list of elements in which none are in the same positions as they were originally. If an element fills more than half of the positions then an error will be raised since no derangement is possible. To obtain a derangement of as many items as possible--with some of the most numerous remaining in their original positions--pass `strict=False`. To produce a pseudorandom derangment, pass a pseudorandom selector like `choice` (see below). Examples ======== >>> from sympy.utilities.iterables import random_derangement >>> t = 'SymPy: a CAS in pure Python' >>> d = random_derangement(t) >>> all(i != j for i, j in zip(d, t)) True A predictable result can be obtained by using a pseudorandom generator for the choice: >>> from sympy.core.random import seed, choice as c >>> seed(1) >>> d = [''.join(random_derangement(t, c)) for i in range(5)] >>> assert len(set(d)) != 1 # we got different values By reseeding, the same sequence can be obtained: >>> seed(1) >>> d2 = [''.join(random_derangement(t, c)) for i in range(5)] >>> assert d == d2 Nrc>[[U5S- SS5H/nT"USUS-5nURU5nXXsX'X'M1 g)z Knuth shufflerrr{N)r(r&r)rWrr4rchoices r shuffle#random_derangement..shuffleX sRs2w{Ar*Ar&1q5z"A A5"%LBE25+r,c>T"U5 USU$)z1shuffle rv and return the first n values Nr)rWrHrs r pick random_derangement..pick^ s  "1v r,c US$rrr3s r r$random_derangement..e s!A$r,rr{rzno derangement possiblec3.# UH upX:gv M g7fr0rrrrs r r!%random_derangement.. s0Zca16Zr)secretsrryr&rrxr=rrJreversedrrandom_derangementrrPrjoinr'rKr()trstrictrrrHtotrrrHxsrcoptsstayrWrrdrs ` @r rr5 s0@~(  !B a&C   /B rFEA AA 2B Av 67 7 )! ? fqVAY ? Td3Bi  !W$A FF1I F +A IIaB #"1gnrwwr{4"4CG| !W BK0SZ000& I- VAXAs2wh,Q!u1#(8K8a!u8Kt9q="1X $&T qA"#BAwK"s2wh, +@4LsH;&H;? I IIc#F# [U5S:ag[U5S:Xa USUS/v g[U5S:Xa!USUSUS/v USUSUS/v g[U5H2n[S[X555(aM%[ U5v M4 g7f)zX yield derangements of items in ``s`` which are assumed to contain no repeated elements rNrrrtc3.# UH upX:Hv M g7fr0rrs r r!$_set_derangements.. s0ida16ir)r&r r#rKrJrr1s r rr s  1vz 1v{tQqTl 1v{tQqT1Q4  tQqT1Q4   !_0c!i000q'Ms B B!B!c## [U5(d[U5ShvN g[U5Hn[U5v M gN%7f)a Return unique derangements of the elements of iterable ``s``. Examples ======== >>> from sympy.utilities.iterables import generate_derangements >>> list(generate_derangements([0, 1, 2])) [[1, 2, 0], [2, 0, 1]] >>> list(generate_derangements([0, 1, 2, 2])) [[2, 2, 0, 1], [2, 2, 1, 0]] >>> list(generate_derangements([0, 1, 1])) [] See Also ======== sympy.functions.combinatorial.factorials.subfactorial N)rjrrrJrs r generate_derangementsr s;* A;;$Q'''&q)Aq'M* (sA A&A c#^# US:XaUS:agS/U-m[T5v US:XagUS- nTUUS- :XaUS-nUS:XagTUUS- :XaMTU==S- ss'[X- S- 5HnTUTXC-S-'M XS--S:Xa:U(a&[U4Sj[US- 555(a [T5v M7f)a A routine to generate necklaces that may (free=True) or may not (free=False) be turned over to be viewed. The "necklaces" returned are comprised of ``n`` integers (beads) with ``k`` different values (colors). Only unique necklaces are returned. Examples ======== >>> from sympy.utilities.iterables import necklaces, bracelets >>> def show(s, i): ... return ''.join(s[j] for j in i) The "unrestricted necklace" is sometimes also referred to as a "bracelet" (an object that can be turned over, a sequence that can be reversed) and the term "necklace" is used to imply a sequence that cannot be reversed. So ACB == ABC for a bracelet (rotate and reverse) while the two are different for a necklace since rotation alone cannot make the two sequences the same. (mnemonic: Bracelets can be viewed Backwards, but Not Necklaces.) >>> B = [show('ABC', i) for i in bracelets(3, 3)] >>> N = [show('ABC', i) for i in necklaces(3, 3)] >>> set(N) - set(B) {'ACB'} >>> list(necklaces(4, 2)) [(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 1), (0, 1, 0, 1), (0, 1, 1, 1), (1, 1, 1, 1)] >>> [show('.o', i) for i in bracelets(4, 2)] ['....', '...o', '..oo', '.o.o', '.ooo', 'oooo'] References ========== .. [1] https://mathworld.wolfram.com/Necklace.html .. [2] Frank Ruskey, Carla Savage, and Terry Min Yih Wang, Generating necklaces, Journal of Algorithms 13 (1992), 414-430; https://doi.org/10.1016/0196-6774(92)90047-G rNrr{c3L># UHnTTUSS2TSUS2-:*v M g7frur)rrrQs r r!necklaces.. s20bUaPQa2h2a76K1KUar#)rr(r')rHrfreerrrQs @r necklacesr s\ Av!a% AA (NAv  Eda!em FABwda!em ! quqy!AQ4AaeaiL" A;! TS0bUZ[\_`[`Ua0b-b-b(N s ACA8Cc[XSS9$)z>Wrapper to necklaces to return a free (unrestricted) necklace.T)r)r)rHrs r braceletsr s Q %%r,c#F# [[SU55nUSSv XS:a XUX'Om[US- SS5HXnXS:wdM XS- n[US- SS5H nXU:XdM O UW- n[X S-5H nXU- X'M O gM7f)aC This algorithm generates oriented forests. An oriented graph is a directed graph having no symmetric pair of directed edges. A forest is an acyclic graph, i.e., it has no cycles. A forest can also be described as a disjoint union of trees, which are graphs in which any two vertices are connected by exactly one simple path. Examples ======== >>> from sympy.utilities.iterables import generate_oriented_forest >>> list(generate_oriented_forest(4)) [[0, 1, 2, 3], [0, 1, 2, 2], [0, 1, 2, 1], [0, 1, 2, 0], [0, 1, 1, 1], [0, 1, 1, 0], [0, 1, 0, 1], [0, 1, 0, 0], [0, 0, 0, 0]] References ========== .. [1] T. Beyer and S.M. Hedetniemi: constant time generation of rooted trees, SIAM J. Computing Vol. 9, No. 4, November 1980 .. [2] https://stackoverflow.com/questions/1633833/oriented-forest-taocp-algorithm-in-python r{rNr)rJr()rHPr1targetr7offsetrs r generate_oriented_forestr s4 U2q\A e 4!8qT7AD1q5!R(419TAXF"1q5!R046>!1UF"1!e_ V}-)! sA B! B!3.B!cSSKJn UcUn[U[XS95nU(d%USSS2n[U[XRS95n[ XFUS9n[ U[ 5(d [U5$U$)as Return the rotation of the sequence in which the lexically smallest elements appear first, e.g. `cba \rightarrow acb`. The sequence returned is a tuple, unless the input sequence is a string in which case a string is returned. If ``directed`` is False then the smaller of the sequence and the reversed sequence is returned, e.g. `cba \rightarrow abc`. If ``key`` is not None then it is used to extract a comparison key from each element in iterable. Examples ======== >>> from sympy.combinatorics.polyhedron import minlex >>> minlex((1, 2, 0)) (0, 1, 2) >>> minlex((1, 0, 2)) (0, 2, 1) >>> minlex((1, 0, 2), directed=False) (0, 1, 2) >>> minlex('11010011000', directed=True) '00011010011' >>> minlex('11010011000', directed=False) '00011001011' >>> minlex(('bb', 'aaa', 'c', 'a')) ('a', 'bb', 'aaa', 'c') >>> minlex(('bb', 'aaa', 'c', 'a'), key=len) ('c', 'a', 'bb', 'aaa') rrNrr{)rrr rrr8rr)rSdirectedrrbestrseqrbests r minlexr: slF< {"C sN38 9D 4R4yD."?@4C()c225;<>> from sympy.utilities.iterables import runs >>> from operator import ge >>> runs([0, 1, 2, 2, 1, 4, 3, 2, 2]) [[0, 1, 2], [2], [1, 4], [3], [2], [2]] >>> runs([0, 1, 2, 2, 1, 4, 3, 2, 2], op=ge) [[0, 1, 2, 2], [1, 4], [3], [2, 2]] r{)rGra StopIterationrA)rSrvcyclesruneis r runsri sF s)CCyk  cB bb'?? JJrN  MM# $C         c Ms" A! A3! A0/A03 B?Bc## US:Xa U(aU/v g[S[U55H&n[XSUS- 5HnUSU/U-v M M( g7f)aReturns the partition of sequence $l$ into $n$ bins Explanation =========== Given the sequence $l_1 \cdots l_m \in V^+$ where $V^+$ is the Kleene plus of $V$ The set of $n$ partitions of $l$ is defined as: .. math:: \{(s_1, \cdots, s_n) | s_1 \in V^+, \cdots, s_n \in V^+, s_1 \cdots s_n = l_1 \cdots l_m\} Parameters ========== l : Sequence[T] A nonempty sequence of any Python objects n : int A positive integer Yields ====== out : list[Sequence[T]] A list of sequences with concatenation equals $l$. This should conform with the type of $l$. Examples ======== >>> from sympy.utilities.iterables import sequence_partitions >>> for out in sequence_partitions([1, 2, 3, 4], 2): ... print(out) [[1], [2, 3, 4]] [[1, 2], [3, 4]] [[1, 2, 3], [4]] Notes ===== This is modified version of EnricoGiampieri's partition generator from https://stackoverflow.com/questions/13131491/partition-n-items-into-k-bins-in-python-lazily See Also ======== sequence_partitions_empty rN)r(r&sequence_partitionsrwrHrparts r rr s[j Av!c  1c!f '"q1u5DRa5'D. 6sAAc## US:agUS:XaU/v g[S[U5S-5H&n[XSUS- 5HnUSU/U-v M M( g7f)a'Returns the partition of sequence $l$ into $n$ bins with empty sequence Explanation =========== Given the sequence $l_1 \cdots l_m \in V^*$ where $V^*$ is the Kleene star of $V$ The set of $n$ partitions of $l$ is defined as: .. math:: \{(s_1, \cdots, s_n) | s_1 \in V^*, \cdots, s_n \in V^*, s_1 \cdots s_n = l_1 \cdots l_m\} There are more combinations than :func:`sequence_partitions` because empty sequence can fill everywhere, so we try to provide different utility for this. Parameters ========== l : Sequence[T] A sequence of any Python objects (can be possibly empty) n : int A positive integer Yields ====== out : list[Sequence[T]] A list of sequences with concatenation equals $l$. This should conform with the type of $l$. Examples ======== >>> from sympy.utilities.iterables import sequence_partitions_empty >>> for out in sequence_partitions_empty([1, 2, 3, 4], 2): ... print(out) [[], [1, 2, 3, 4]] [[1], [2, 3, 4]] [[1, 2], [3, 4]] [[1, 2, 3], [4]] [[1, 2, 3, 4], []] See Also ======== sequence_partitions rNr)r(r&sequence_partitions_emptyrs r rr sgj 1uAvc  1c!fqj !-aeQU;DRa5'D. <"sAAc ## Uc[X5ShvN gUS:Xa1[U5H!n[U5n[X15ShvN M# gUS:Xa[X5ShvN gUS:Xa2[X5H"n[ U5Hn[U5v M M$ gUS:Xa[ [ U5USS9HupdXa:waM [U5Hdn/nS=p[U5n[UR55H0up[U 5Hn X-n URXyU 5 U n M M2 Uv Mf M g[SU-5eGN;GN N7f) a Return sequence ``l`` partitioned into ``k`` bins. Examples ======== The default is to give the items in the same order, but grouped into k partitions without any reordering: >>> from sympy.utilities.iterables import kbins >>> for p in kbins(list(range(5)), 2): ... print(p) ... [[0], [1, 2, 3, 4]] [[0, 1], [2, 3, 4]] [[0, 1, 2], [3, 4]] [[0, 1, 2, 3], [4]] The ``ordered`` flag is either None (to give the simple partition of the elements) or is a 2 digit integer indicating whether the order of the bins and the order of the items in the bins matters. Given:: A = [[0], [1, 2]] B = [[1, 2], [0]] C = [[2, 1], [0]] D = [[0], [2, 1]] the following values for ``ordered`` have the shown meanings:: 00 means A == B == C == D 01 means A == B 10 means A == D 11 means A == A >>> for ordered_flag in [None, 0, 1, 10, 11]: ... print('ordered = %s' % ordered_flag) ... for p in kbins(list(range(3)), 2, ordered=ordered_flag): ... print(' %s' % p) ... ordered = None [[0], [1, 2]] [[0, 1], [2]] ordered = 0 [[0, 1], [2]] [[0, 2], [1]] [[0], [1, 2]] ordered = 1 [[0], [1, 2]] [[0], [2, 1]] [[1], [0, 2]] [[1], [2, 0]] [[2], [0, 1]] [[2], [1, 0]] ordered = 10 [[0, 1], [2]] [[2], [0, 1]] [[0, 2], [1]] [[1], [0, 2]] [[0], [1, 2]] [[1, 2], [0]] ordered = 11 [[0], [1, 2]] [[0, 1], [2]] [[0], [2, 1]] [[0, 2], [1]] [[1], [0, 2]] [[1, 0], [2]] [[1], [2, 0]] [[1, 2], [0]] [[2], [0, 1]] [[2, 0], [1]] [[2], [1, 0]] [[2, 1], [0]] See Also ======== partitions, multiset_partitions N r rTr;z/ordered must be one of 00, 01, 10 or 11, not %s) rr-rJrCr r=r&rrxr(rAr=)rwrrplr1permkgotlirWrrr. multiplicityr*s r kbinsr sKb&q,,, B'*BbB*21 1 1+ B&q,,, B$Q*A$Q4j (+ A!#a&!$7GDy+A. "X*0*;&D"<0H "(+1+< /8 = GI I5 - 2,s4EE2EEE%E&C*EEEc ## [S/[U5URS5- -6HJn[U5n[ U5"UVs/sHo"(aX!R 5-OUPM sn5v ML gs snf7f)zReturn iterator in which the signs of non-zero elements of t are permuted. Examples ======== >>> from sympy.utilities.iterables import permute_signs >>> list(permute_signs((0, 1, 2))) [(0, 1, 2), (0, -1, 2), (0, 1, -2), (0, -1, -2)] )rr{rN)r r&countrJrPr)rsignsrs r permute_signsrz sg7)SVaggaj%89:U 1g!$A9 +A>c.^U4Sj[T55$)a(Return iterator in which the signs of non-zero elements of t and the order of the elements are permuted and all returned values are unique. Examples ======== >>> from sympy.utilities.iterables import signed_permutations >>> list(signed_permutations((0, 1, 2))) [(0, 1, 2), (0, -1, 2), (0, 1, -2), (0, -1, -2), (0, 2, 1), (0, -2, 1), (0, 2, -1), (0, -2, -1), (1, 0, 2), (-1, 0, 2), (1, 0, -2), (-1, 0, -2), (1, 2, 0), (-1, 2, 0), (1, -2, 0), (-1, -2, 0), (2, 0, 1), (-2, 0, 1), (2, 0, -1), (-2, 0, -1), (2, 1, 0), (-2, 1, 0), (2, -1, 0), (-2, -1, 0)] c3l># UH)n[U5Hn[T5"U5v M M+ g7fr0)rrP)rrrrs r r!&signed_permutations.. s4 # 81q!A GAJJ!  8s14)r-)rs`r signed_permutationsr s  # 5a 8 ##r,c#v# [U5n[[U55HnUv [X!5nM g7f)acReturn a generator giving the items in s as list where each subsequent list has the items rotated to the left (default) or right (``dir=-1``) relative to the previous list. Examples ======== >>> from sympy import rotations >>> list(rotations([1,2,3])) [[1, 2, 3], [2, 3, 1], [3, 1, 2]] >>> list(rotations([1,2,3], -1)) [[1, 2, 3], [3, 1, 2], [2, 3, 1]] N)rJr(r&r )rdirrSrs r rotationsr s1 q'C 3s8_ ##s79c'# [SU55n[U5nU(aUH nU"5v M U(aMgg![a US-n[[X55nN0f=f7f)zroundrobin recipe taken from itertools documentation: https://docs.python.org/3/library/itertools.html#itertools-recipes roundrobin('ABC', 'D', 'EF') --> A D E B F C Recipe credited to George Sakkis c3L# UHn[U5Rv M g7fr0)rG__next__)rrbs r r!roundrobin.. s8i$r(##is"$rN)r r&rr )rqnextspendingnxts r roundrobinr sh 8i8 8E)nG  2e  ' 2 qLG&01E 2s-%A.AA.A.#A+(A.*A++A.c\rSrSrSrSrg) NotIterablei z Use this as mixin when creating a class which is not supposed to return true when iterable() is called on its instances because calling list() on the instance, for example, would result in an infinite loop. rN)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rr,r rr s   r,rc[US5(a UR$[U5 U(a[ X5(+$g![a gf=f)a Return a boolean indicating whether ``i`` is SymPy iterable. True also indicates that the iterator is finite, e.g. you can call list(...) on the instance. When SymPy is working with iterables, it is almost always assuming that the iterable is not a string or a mapping, so those are excluded by default. If you want a pure Python definition, make exclude=None. To exclude multiple items, pass them as a tuple. You can also set the _iterable attribute to True or False on your class, which will override the checks here, including the exclude test. As a rule of thumb, some SymPy functions use this to check if they should recursively map over an object. If an object is technically iterable in the Python sense but does not desire this behavior (e.g., because its iteration is not finite, or because iteration might induce an unwanted computation), it should disable it by setting the _iterable attribute to False. See also: is_sequence Examples ======== >>> from sympy.utilities.iterables import iterable >>> from sympy import Tuple >>> things = [[1], (1,), set([1]), Tuple(1), (j for j in [1, 2]), {1:2}, '1', 1] >>> for i in things: ... print('%s %s' % (iterable(i), type(i))) True <... 'list'> True <... 'tuple'> True <... 'set'> True True <... 'generator'> False <... 'dict'> False <... 'str'> False <... 'int'> >>> iterable({}, exclude=None) True >>> iterable({}, exclude=str) True >>> iterable("no", exclude=str) False _iterableFT)r>rrGrr8)rrs r rBrB sR^q+{{ Qa)))  s A AAc[US5=(a [U5=(d [U5=(a [X5$)ar Return a boolean indicating whether ``i`` is a sequence in the SymPy sense. If anything that fails the test below should be included as being a sequence for your application, set 'include' to that object's type; multiple types should be passed as a tuple of types. Note: although generators can generate a sequence, they often need special handling to make sure their elements are captured before the generator is exhausted, so these are not included by default in the definition of a sequence. See also: iterable Examples ======== >>> from sympy.utilities.iterables import is_sequence >>> from types import GeneratorType >>> is_sequence([]) True >>> is_sequence(set()) False >>> is_sequence('abc') False >>> is_sequence('abc', include=str) True >>> generator = (c for c in 'abc') >>> is_sequence(generator) False >>> is_sequence(generator, include=(str, GeneratorType)) True rq)r>rBrEr8)rincludes r r1r1 s9D A} %  QK # M # q "$r,z Using postorder_traversal from the sympy.utilities.iterables submodule is deprecated. Instead, use postorder_traversal from the top-level sympy namespace, like sympy.postorder_traversal z1.10z$deprecated-traversal-functions-moved)deprecated_since_versionactive_deprecations_targetcSSKJn U"XS9$)Nr)postorder_traversal)rI)sympy.core.traversalr)rrI_postorder_traversals r rr3 sQ  00r,z Using interactive_traversal from the sympy.utilities.iterables submodule is deprecated. Instead, use interactive_traversal from the top-level sympy namespace, like sympy.interactive_traversal cSSKJn U"U5$)Nr)interactive_traversal)sympy.interactive.traversalr )expr_interactive_traversals r r r C s\ !$ ''r,z Importing default_sort_key from sympy.utilities.iterables is deprecated. Use from sympy import default_sort_key instead. z#deprecated-sympy-core-compatibilitycSSKJn U"U0UD6$)Nr)default_sort_key)sympyr)r:kwargs_default_sort_keys r rrT s< d -f --r,cSSKJn U"U0UD6$)Nrr)rr)r:r_ordereds r rra s* T $V $$r,r)NN)r)T)NF)F)r4Nrrr0)NNF)NTrc)r)Z collectionsrrr itertoolsrrrr r r r r cartesoperatorrsympy.utilities.enumerativerrrsympy.utilities.miscrsympy.utilities.decoratorrr+r@rLrRr^rnrpryrrrrrrrrrrrrrrrrrr rrr%r-r5r9rCr=rPr^rjr<riryr|rrrrrrrrrrrrrrrrrrrwrBr1rr rrrr,r rsH99 ( II(0";J?D69x866'T&,ECP,*^59p0+\BK<\&&' T=!~1h# LL^[A|AHE)P7t02,3)lhV"Jzz^B&8?D& +\,=^"J:!z<!~mI` > #($(2*  dK07t%$P $E G1 G1  $E G( G(  $@ ..  $@ %%r,