\c@ swddlmZmZddlmZdefdYZdZdZdZ dfd YZ d Z d S( i(tprint_functiontdivision(tranget PartComponentcB s8eZdZdZdZdZdZdZRS( sXInternal class used in support of the multiset partitions enumerators and the associated visitor functions. Represents one component of one part of the current partition. A stack of these, plus an auxiliary frame array, f, represents a partition of the multiset. Knuth's pseudocode makes c, u, and v separate arrays. tctutvcC sd|_d|_d|_dS(Ni(RRR(tself((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyt__init__ms  cC sd|j|j|jfS(s&for debug/algorithm animation purposessc:%d u:%d v:%d(RRR(R((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyt__repr__wscC sFt||joE|j|jkoE|j|jkoE|j|jkS(s<Define value oriented equality, which is useful for testers(t isinstancet __class__RRR(Rtother((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyt__eq__{scC s ||k S(s#Defined for consistency with __eq__((RR ((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyt__ne__s(RRR(t__name__t __module__t__doc__t __slots__RR R R(((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyR_s    cc st|}t|}gt||dD]}t^q-}dg|d}xAt|D]3}||}||_|||_|||_q`Wd|d>> from sympy.utilities.enumerative import list_visitor >>> from sympy.utilities.enumerative import multiset_partitions_taocp >>> # variables components and multiplicities represent the multiset 'abb' >>> components = 'ab' >>> multiplicities = [1, 2] >>> states = multiset_partitions_taocp(multiplicities) >>> list(list_visitor(state, components) for state in states) [[['a', 'b', 'b']], [['a', 'b'], ['b']], [['a'], ['b', 'b']], [['a'], ['b'], ['b']]] See Also ======== sympy.utilities.iterables.multiset_partitions: Takes a multiset as input and directly yields multiset partitions. It dispatches to a number of functions, including this one, for implementation. Most users will find it more convenient to use than multiset_partitions_taocp. iiN( tlentsumRRRRRtTruetFalsetmin(tmultiplicitiestmtntitpstacktftjtpstatlparttbtktxtstate((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytmultiset_partitions_taocpslD  *        $         c C s|\}}}g}xyt|dD]g}d}xK|||||d!D]0}|jdkrL|||j|j9}qLqLW|j|q&W|S(sUse with multiset_partitions_taocp to enumerate the ways a number can be expressed as a product of factors. For this usage, the exponents of the prime factors of a number are arguments to the partition enumerator, while the corresponding prime factors are input here. Examples ======== To enumerate the factorings of a number we can think of the elements of the partition as being the prime factors and the multiplicities as being their exponents. >>> from sympy.utilities.enumerative import factoring_visitor >>> from sympy.utilities.enumerative import multiset_partitions_taocp >>> from sympy import factorint >>> primes, multiplicities = zip(*factorint(24).items()) >>> primes (2, 3) >>> multiplicities (3, 1) >>> states = multiset_partitions_taocp(multiplicities) >>> list(factoring_visitor(state, primes) for state in states) [[24], [8, 3], [12, 2], [4, 6], [4, 2, 3], [6, 2, 2], [2, 2, 2, 3]] ii(RRRtappend( R%tprimesRR!Rt factoringRtfactorR((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytfactoring_visitor3s c C s|\}}}g}xt|dD]m}g}xQ|||||d!D]6}|jdkrL|j||jg|jqLqLW|j|q&W|S(sReturn a list of lists to represent the partition. Examples ======== >>> from sympy.utilities.enumerative import list_visitor >>> from sympy.utilities.enumerative import multiset_partitions_taocp >>> states = multiset_partitions_taocp([1, 2, 1]) >>> s = next(states) >>> list_visitor(s, 'abc') # for multiset 'a b b c' [['a', 'b', 'b', 'c']] >>> s = next(states) >>> list_visitor(s, [1, 2, 3]) # for multiset '1 2 2 3 [[1, 2, 2], [3]] ii(RRtextendRR'( R%t componentsRR!Rt partitionRtpartR((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyt list_visitorXs %tMultisetPartitionTraversercB seZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZRS(s) Has methods to ``enumerate`` and ``count`` the partitions of a multiset. This implements a refactored and extended version of Knuth's algorithm 7.1.2.5M [AOCP]_." The enumeration methods of this class are generators and return data structures which can be interpreted by the same visitor functions used for the output of ``multiset_partitions_taocp``. Examples ======== >>> from sympy.utilities.enumerative import MultisetPartitionTraverser >>> m = MultisetPartitionTraverser() >>> m.count_partitions([4,4,4,2]) 127750 >>> m.count_partitions([3,3,3]) 686 See Also ======== multiset_partitions_taocp sympy.utilities.iterables.multiset_partititions References ========== .. [AOCP] Algorithm 7.1.2.5M in Volume 4A, Combinatoral Algorithms, Part 1, of The Art of Computer Programming, by Donald Knuth. .. [Factorisatio] On a Problem of Oppenheim concerning "Factorisatio Numerorum" E. R. Canfield, Paul Erdos, Carl Pomerance, JOURNAL OF NUMBER THEORY, Vol. 17, No. 1. August 1983. See section 7 for a description of an algorithm similar to Knuth's. .. [Yorgey] Generating Multiset Partitions, Brent Yorgey, The Monad.Reader, Issue 8, September 2007. cC s(t|_d|_d|_d|_dS(Ni(Rtdebugtk1tk2tp1(R((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyRs   cC sl|jrhd}|j|j|jg}td|gt||D]}dj|^q@t|ndS(seUseful for usderstanding/debugging the algorithms. Not generally activated in end-user code.tabcdefghijklmnopqrstuvwxyzsDBG:tN(R2RR!RtprintR0tjointanimation_visitor(RtmsgtlettersR%R/((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytdb_traces   (cC st|}t|}gt||dD]}t^q-|_dg|d|_xDt|D]6}|j|}||_|||_|||_qfWd|jd<||jdcC s|j|dkr&|jd7_tSt|}x`t|dddD]H}|dkr|djd||j|djkr|jd7_tS|dkr||jdks|dkrI||jdkrI||jd8_x/t|d|D]}||j||_qW|dkr|djdkr|dj|dj||jd|djkr|jd7_|j dtSt SqIWtS(sDecrements part (a subrange of pstack), if possible, returning True iff the part was successfully decremented. Parameters ========== part part to be decremented (topmost part on the stack) ub the maximum number of parts allowed in a partition returned by the calling traversal. Notes ===== The goal of this modification of the ordinary decrement method is to fail (meaning that the subtree rooted at this part is to be skipped) when it can be proved that this part can only have child partitions which are larger than allowed by ``ub``. If a decision is made to fail, it must be accurate, otherwise the enumeration will miss some partitions. But, it is OK not to capture all the possible failures -- if a part is passed that shouldn't be, the resulting too-large partitions are filtered by the enumeration one level up. However, as is usual in constrained enumerations, failing early is advantageous. The tests used by this method catch the most common cases, although this implementation is by no means the last word on this problem. The tests include: 1) ``lpart`` must be less than ``ub`` by at least 2. This is because once a part has been decremented, the partition will gain at least one child in the spread step. 2) If the leading component of the part is about to be decremented, check for how many parts will be added in order to use up the unallocated multiplicity in that leading component, and fail if this number is greater than allowed by ``ub``. (See code for the exact expression.) This test is given in the answer to Knuth's problem 7.2.1.5.69. 3) If there is *exactly* enough room to expand the leading component by the above test, check the next component (if it exists) once decrementing has finished. If this has ``v == 0``, this next component will push the expansion over the limit by 1, so fail. iiisDecrement fails test 3( R!R5RRRRRR3R4R=R(RR/tubRARR#((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytdecrement_part_smalls(1 5> c C sI|dkr"|j|s"tSn||j}|dkr?tStd|D}td|D}||kr{tS|||}|dkrtSxtt|dddD]}|dkr|dj|kr|dj|8_tStSq||j|kr#||j|8_tS|||j8}d||_qWdS(sDecrements part, while respecting size constraint. A part can have no children which are of sufficient size (as indicated by ``lb``) unless that part has sufficient unallocated multiplicity. When enforcing the size constraint, this method will decrement the part (if necessary) by an amount needed to ensure sufficient unallocated multiplicity. Returns True iff the part was successfully decremented. Parameters ========== part part to be decremented (topmost part on the stack) amt Can only take values 0 or 1. A value of 1 means that the part must be decremented, and then the size constraint is enforced. A value of 0 means just to enforce the ``lb`` size constraint. lb The partitions produced by the calling enumeration must have more parts than this value. iics s|]}|jVqdS(N(R(t.0tpc((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pys oscs s|]}|jVqdS(N(R(RERF((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pys psiN(RBRR!RRRRR( RR/tamttlbt min_unalloct total_multt total_alloctdeficitR((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytdecrement_part_largeDs0     # cC s%|j||o$|j|d|S(sDecrements part (a subrange of pstack), if possible, returning True iff the part was successfully decremented. Parameters ========== part part to be decremented (topmost part on the stack) ub the maximum number of parts allowed in a partition returned by the calling traversal. lb The partitions produced by the calling enumeration must have more parts than this value. Notes ===== Combines the constraints of _small and _large decrement methods. If returns success, part has been decremented at least once, but perhaps by quite a bit more if needed to meet the lb constraint. i(RDRM(RR/RHRC((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytdecrement_part_ranges!cC s|j|j}|j|jd}|}t}xt|j|j|j|jdD]}|j|j|j|j|j|_|j|jdkrt}qX|j|j|j|_|r|j|j|j|_n]|j|j|j|jkr%|j|j|j|_t}n|j|j|j|_|d}qXW||kr|jd|_||j|jd>> from sympy.utilities.enumerative import list_visitor >>> from sympy.utilities.enumerative import MultisetPartitionTraverser >>> m = MultisetPartitionTraverser() >>> states = m.enum_all([2,2]) >>> list(list_visitor(state, 'ab') for state in states) [[['a', 'a', 'b', 'b']], [['a', 'a', 'b'], ['b']], [['a', 'a'], ['b', 'b']], [['a', 'a'], ['b'], ['b']], [['a', 'b', 'b'], ['a']], [['a', 'b'], ['a', 'b']], [['a', 'b'], ['a'], ['b']], [['a'], ['a'], ['b', 'b']], [['a'], ['a'], ['b'], ['b']]] See Also ======== multiset_partitions_taocp(): which provides the same result as this method, but is about twice as fast. Hence, enum_all is primarily useful for testing. Also see the function for a discussion of states and visitors. iNi(R@RRQRR!RRBRR(RRR%((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytenum_alls  cc s-d|_|dkrdS|j|xtr(t}x_|jr|jd|j|kr8|jd7_t}|jd|d|_Pq8q8W|r|j|j|jg}|VnxX|j |j |s|jd|jdkrdS|jd8_|jdqW|jd q)WdS( sEnumerate multiset partitions with no more than ``ub`` parts. Equivalent to enum_range(multiplicities, 0, ub) Parameters ========== multiplicities list of multiplicities of the components of the multiset. ub Maximum number of parts Examples ======== >>> from sympy.utilities.enumerative import list_visitor >>> from sympy.utilities.enumerative import MultisetPartitionTraverser >>> m = MultisetPartitionTraverser() >>> states = m.enum_small([2,2], 2) >>> list(list_visitor(state, 'ab') for state in states) [[['a', 'a', 'b', 'b']], [['a', 'a', 'b'], ['b']], [['a', 'a'], ['b', 'b']], [['a', 'b', 'b'], ['a']], [['a', 'b'], ['a', 'b']]] The implementation is based, in part, on the answer given to exercise 69, in Knuth [AOCP]_. See Also ======== enum_all, enum_large, enum_range iNsspread 1is Discardingis$Failed decrement, going to backtracksBacktracked tosdecrement ok, about to expand( t discardedR@RRQR=R!RRRRDRR(RRRCtgood_partitionR%((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyt enum_smalls0(        cc s d|_|t|krdS|j||j|jd|xtrt}xD|jr|j|jd|sW|jd7_t}PqWqWW|r|j|j |j g}|VnxA|j|jd|s|j dkrdS|j d8_ qWqHWdS(sEnumerate the partitions of a multiset with lb < num(parts) Equivalent to enum_range(multiplicities, lb, sum(multiplicities)) Parameters ========== multiplicities list of multiplicities of the components of the multiset. lb Number of parts in the partition must be greater than this lower bound. Examples ======== >>> from sympy.utilities.enumerative import list_visitor >>> from sympy.utilities.enumerative import MultisetPartitionTraverser >>> m = MultisetPartitionTraverser() >>> states = m.enum_large([2,2], 2) >>> list(list_visitor(state, 'ab') for state in states) [[['a', 'a'], ['b'], ['b']], [['a', 'b'], ['a'], ['b']], [['a'], ['a'], ['b', 'b']], [['a'], ['a'], ['b'], ['b']]] See Also ======== enum_all, enum_small, enum_range iNi( RTRR@RMRRRRQRRR!R(RRRHRUR%((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyt enum_largeUs&#   cc sd|_|dks'|t|kr+dS|j||j|jd|xDtrt}x|jr|jd|j|jd|s|jd|jd7_t}Pqc|j |krc|jd7_t}|jd|d|_ PqcqcW|r)|j |j |j g}|Vnx[|j |j||s|jd|j dkrgdS|j d8_ |jd q,W|jd qTWdS( sEnumerate the partitions of a multiset with ``lb < num(parts) <= ub``. In particular, if partitions with exactly ``k`` parts are desired, call with ``(multiplicities, k - 1, k)``. This method generalizes enum_all, enum_small, and enum_large. Examples ======== >>> from sympy.utilities.enumerative import list_visitor >>> from sympy.utilities.enumerative import MultisetPartitionTraverser >>> m = MultisetPartitionTraverser() >>> states = m.enum_range([2,2], 1, 2) >>> list(list_visitor(state, 'ab') for state in states) [[['a', 'a', 'b'], ['b']], [['a', 'a'], ['b', 'b']], [['a', 'b', 'b'], ['a']], [['a', 'b'], ['a', 'b']]] iNsspread 1s Discarding (large cons)is Discarding small consis$Failed decrement, going to backtracksBacktracked tosdecrement ok, about to expand( RTRR@RMRRRRQR=RR!RRRN(RRRHRCRUR%((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyt enum_ranges<        cC sd|_|j|xmtrx|jr1q"W|jd7_x>|j|js|jdkro|jS|jd8_qDWqWdS(sReturns the number of partitions of a multiset whose elements have the multiplicities given in ``multiplicities``. Primarily for comparison purposes. It follows the same path as enumerate, and counts, rather than generates, the partitions. See Also ======== count_partitions Has the same calling interface, but is much faster. iiN(tpcountR@RRQRBRRR!(RR((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytcount_partitions_slows   cC sd|_g|_t|ds-i|_n|j|t|j}|jj|dfgx:trxz|j rt|j}||jkr|j|j|d7_|j d8_ Pqq|jj||jfgqqW|jd7_xr|j |jsnx1|jj D] \}}|j||j|>> from sympy.utilities.enumerative import MultisetPartitionTraverser >>> m = MultisetPartitionTraverser() >>> m.count_partitions([9,8,2]) 288716 >>> m.count_partitions([2,2]) 9 >>> del m Notes ===== If one looks at the workings of Knuth's algorithm M [AOCP]_, it can be viewed as a traversal of a binary tree of parts. A part has (up to) two children, the left child resulting from the spread operation, and the right child from the decrement operation. The ordinary enumeration of multiset partitions is an in-order traversal of this tree, and with the partitions corresponding to paths from the root to the leaves. The mapping from paths to partitions is a little complicated, since the partition would contain only those parts which are leaves or the parents of a spread link, not those which are parents of a decrement link. For counting purposes, it is sufficient to count leaves, and this can be done with a recursive in-order traversal. The number of leaves of a subtree rooted at a particular part is a function only of that part itself, so memoizing has the potential to speed up the counting dramatically. This method follows a computational approach which is similar to the hypothetical memoized recursive function, but with two differences: 1) This method is iterative, borrowing its structure from the other enumerations and maintaining an explicit stack of parts which are in the process of being counted. (There may be multisets which can be counted reasonably quickly by this implementation, but which would overflow the default Python recursion limit with a recursive implementation.) 2) Instead of using the part data structure directly, a more compact key is constructed. This saves space, but more importantly coalesces some parts which would remain separate with physical keys. Unlike the enumeration functions, there is currently no _range version of count_partitions. If someone wants to stretch their brain, it should be possible to construct one by memoizing with a histogram of counts rather than a single count, and combining the histograms. itdp_mapiiN( RYtdp_stackthasattrR[R@tpart_keyRRR'RRQR!RBtpop(RRtpkeytkeytoldcount((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pytcount_partitionss0G      (RRRRR=R@RBRDRMRNRQRRRSRVRWRXRZRc(((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyR1us *   P C $ -  / F = > cC sAg}x.|D]&}|j|j|j|jq Wt|S(sHelper for MultisetPartitionTraverser.count_partitions that creates a key for ``part``, that only includes information which can affect the count for that part. (Any irrelevant information just reduces the effectiveness of dynamic programming.) Notes ===== This member function is a candidate for future exploration. There are likely symmetries that can be exploited to coalesce some ``part_key`` values, and thereby save space and improve performance. (R'RRttuple(R/trvalR((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyR^ls  N( t __future__RRtsympy.core.compatibilityRtobjectRR&R+R0R1R^(((s:lib/python2.7/site-packages/sympy/utilities/enumerative.pyts]6 %