ó ~9­\c@sdddlZddlmZddlmZddlmZmZmZm Z m Z m Z m Z ddl mZddlmZddlmZmZddlmZdd lmZdd lmZdd lmZmZmZmZmZdd l m!Z!m"Z"dd l#m$Z$defd„ƒYZ%de%fd„ƒYZ&d„Z'de%fd„ƒYZ(de%fd„ƒYZ)de%fd„ƒYZ*d„Z+de%fd„ƒYZ,d„Z-d„Z.d„Z/d„Z0d „Z1d!„Z2d"„Z3d#„Z4d$„Z5gd%„Z6d&„Z7d'e8fd(„ƒYZ9d)e:fd*„ƒYZ;d+„Z<d,„Z=d-„Z>d.„Z?dS(/iÿÿÿÿN(treduce(t defaultdict(tIndexedt IndexedBasetTupletSumtAddtStInteger(t Permutation(tBasic(t accumulatetdefault_sort_key(tMul(t_sympify(tKroneckerDelta(tMatAddtMatMultTracet Transposet MatrixSymbol(t MatrixExprt MatrixElement(t NDimArrayt_CodegenArrayAbstractcBs/eZed„ƒZd„Zed„ƒZRS(cCs|jS(s  Returns the ranks of the objects in the uppermost tensor product inside the current object. In case no tensor products are contained, return the atomic ranks. Examples ======== >>> from sympy.codegen.array_utils import CodegenArrayTensorProduct, CodegenArrayContraction >>> from sympy import MatrixSymbol >>> M = MatrixSymbol("M", 3, 3) >>> N = MatrixSymbol("N", 3, 3) >>> P = MatrixSymbol("P", 3, 3) Important: do not confuse the rank of the matrix with the rank of an array. >>> tp = CodegenArrayTensorProduct(M, N, P) >>> tp.subranks [2, 2, 2] >>> co = CodegenArrayContraction(tp, (1, 2), (3, 4)) >>> co.subranks [2, 2, 2] (t _subranks(tself((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pytsubranksscCs t|jƒS(s* The sum of ``subranks``. (tsumR(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pytsubrank0scCs|jS(N(t_shape(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pytshape6s(t__name__t __module__tpropertyRRR(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRs tCodegenArrayContractioncBsÑeZdZd„Zed„ƒZed„ƒZed„ƒZed„ƒZd„Z ed„ƒZ e d„ƒZ e d „ƒZ e d „ƒZe d „ƒZd „Zd „Zd„Zed„ƒZRS(sx This class is meant to represent contractions of arrays in a form easily processable by the code printers. cs:tˆƒ‰t|ƒ}tˆƒdkr.|St|tƒrM|j|ˆŒStj||ˆŒ}t|ƒ|_ t |j ƒ|_ ‡fd†t t |j ƒƒDƒ}||_|j‰ˆr-xEˆD]=}tt‡fd†|DƒƒƒdkrÇtdƒ‚qÇqÇWt‡fd†tˆƒDƒƒ‰nˆ|_|S(Nics>i|]4}tgˆD]}||k^qƒr||“qS((tall(t.0titcind(tcontraction_indices(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys Ns c3s|]}ˆ|VqdS(N((R%tj(R(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys Usis+contracting indices of different dimensionsc3s7|]-\‰}t‡fd†ˆDƒƒs|VqdS(c3s|]}ˆ|kVqdS(N((R%R)(R&(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys WsN(tany(R%tshp(R((R&s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys Ws(t_sort_contraction_indicesRtlent isinstanceR#t_flattenR t__new__t _get_subranksRt_get_mapping_from_subrankst_mappingtrangeRt_free_indices_to_positionRtsett ValueErrorttuplet enumerateR(tclstexprR(tkwargstobjtfree_indices_to_positionR&((R(Rs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR0@s&  %   (% cCsxi}g|D]}|D] }|^qq }d}x?|D]7}x||kr[|d7}qBW|||<|d7}q9W|S(Nii((t free_indicesR(R>R&R)tflattened_contraction_indicestcountertind((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt!_get_free_indices_to_position_map[s&  c Csò|j}g|D]}|D] }|^qq}|jƒt|ƒ}t|ƒ}||}gt|ƒD] }d^qh}d} d} xet|ƒD]W}x4| |krÏ| || krÏ| d7} | d7} qœW||c| 7<| d7} q“W|S(s» Get the mapping of indices at the positions before the contraction occures. Examples ======== >>> from sympy.codegen.array_utils import CodegenArrayContraction, CodegenArrayTensorProduct >>> from sympy import MatrixSymbol >>> M = MatrixSymbol("M", 3, 3) >>> N = MatrixSymbol("N", 3, 3) >>> cg = CodegenArrayContraction(CodegenArrayTensorProduct(M, N), [1, 2]) >>> cg._get_index_shifts(cg) [0, 2] Indeed, ``cg`` after the contraction has two dimensions, 0 and 1. They need to be shifted by 0 and 2 to get the corresponding positions before the contraction (that is, 0 and 3). ii(R(tsorttget_rankR-R4( R;tinner_contraction_indicesR&R)t all_innert total_rankt inner_rankt outer_ranktshiftsRAtpointer((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt_get_index_shiftsgs  &     cs/tj|ƒ‰t‡fd†|Dƒƒ}|S(Nc3s+|]!}t‡fd†|DƒƒVqdS(c3s|]}ˆ||VqdS(N((R%R)(RK(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ‘sN(R8(R%R&(RK(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ‘s(R#RMR8(R;touter_contraction_indices((RKs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt'_convert_outer_indices_to_inner_indicesŽscGs5|j}tj||Œ}||}t|j|ŒS(N(R(R#ROR;(R;RNRFR(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR/”s  cCs:|j}g|jD]#}g|D]}||^q ^qS(s Return tuples containing the argument index and position within the argument of the index position. Examples ======== >>> from sympy import MatrixSymbol, MatrixExpr, Sum, Symbol >>> from sympy.abc import i, j, k, l, N >>> from sympy.codegen.array_utils import CodegenArrayContraction, CodegenArrayTensorProduct >>> A = MatrixSymbol("A", N, N) >>> B = MatrixSymbol("B", N, N) >>> cg = CodegenArrayContraction(CodegenArrayTensorProduct(A, B), (1, 2)) >>> cg._get_contraction_tuples() [[(0, 1), (1, 0)]] Here the contraction pair `(1, 2)` meaning that the 2nd and 3rd indices of the tensor product `A\otimes B` are contracted, has been transformed into `(0, 1)` and `(1, 0)`, identifying the same indices in a different notation. `(0, 1)` is the second index (1) of the first argument (i.e. 0 or `A`). `(1, 0)` is the first index (i.e. 0) of the second argument (i.e. 1 or `B`). (R3R((RtmappingR&R)((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt_get_contraction_tuples›s csO|j}dgtt|ƒƒ‰g|D]"}t‡fd†|Dƒƒ^q)S(Nic3s#|]\}}ˆ||VqdS(N((R%R)tk(tcumulative_ranks(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ¼s(RtlistR R8(R;tcontraction_tuplestranksR&((RSs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt*_contraction_tuples_to_contraction_indices·s cCs|jS(N(t _free_indices(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR?¾scCs t|jƒS(N(tdictR5(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR>ÂscCs |jdS(Ni(targs(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR;ÆscCs |jdS(Ni(RZ(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR(ÊscCsŽ|j}t|tƒs'tdƒ‚n|j}i}d}xKt|ƒD]=\}}x.t|ƒD] }||f||<|d7}qbWqIW|S(Ns(only for contractions of tensor productsii(R;R.tCodegenArrayTensorProducttNotImplementedErrorRR9R4(RR;RVRPRAR&trankR)((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt"_contraction_indices_to_componentsÎs  c sá|j}t|tƒs|S|j}tt|ƒdd„ƒ}t|Œ\‰}‡fd†t|ƒDƒ}|jƒ}g|D]/}g|D]\}} ||| f^qŽ^q}t|Œ} |j| |ƒ} t | | ŒS(s Sort arguments in the tensor product so that their order is lexicographical. Examples ======== >>> from sympy import MatrixSymbol, MatrixExpr, Sum, Symbol >>> from sympy.abc import i, j, k, l, N >>> from sympy.codegen.array_utils import CodegenArrayContraction >>> A = MatrixSymbol("A", N, N) >>> B = MatrixSymbol("B", N, N) >>> C = MatrixSymbol("C", N, N) >>> D = MatrixSymbol("D", N, N) >>> cg = CodegenArrayContraction.from_MatMul(C*D*A*B) >>> cg CodegenArrayContraction(CodegenArrayTensorProduct(C, D, A, B), (1, 2), (3, 4), (5, 6)) >>> cg.sort_args_by_name() CodegenArrayContraction(CodegenArrayTensorProduct(A, B, C, D), (0, 7), (1, 2), (5, 6)) tkeycSst|dƒS(Ni(R (tx((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pytôtcs(i|]\}}ˆj|ƒ|“qS((tindex(R%R&targ(t pos_sorted(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ös ( R;R.R[RZtsortedR9tzipRQRWR#( RR;RZt sorted_datat args_sortedtreordering_mapRUR&R)RRtc_tptnew_contr_indices((Res8lib/python2.7/site-packages/sympy/codegen/array_utils.pytsort_args_by_nameÛs   <  cCst|j|jŒS(s“ Returns a dictionary of links between arguments in the tensor product being contracted. See the example for an explanation of the values. Examples ======== >>> from sympy import MatrixSymbol, MatrixExpr, Sum, Symbol >>> from sympy.abc import i, j, k, l, N >>> from sympy.codegen.array_utils import CodegenArrayContraction >>> A = MatrixSymbol("A", N, N) >>> B = MatrixSymbol("B", N, N) >>> C = MatrixSymbol("C", N, N) >>> D = MatrixSymbol("D", N, N) Matrix multiplications are pairwise contractions between neighboring matrices: `A_{ij} B_{jk} C_{kl} D_{lm}` >>> cg = CodegenArrayContraction.from_MatMul(A*B*C*D) >>> cg CodegenArrayContraction(CodegenArrayTensorProduct(A, B, C, D), (1, 2), (3, 4), (5, 6)) >>> cg._get_contraction_links() {0: {1: (1, 0)}, 1: {0: (0, 1), 1: (2, 0)}, 2: {0: (1, 1), 1: (3, 0)}, 3: {0: (2, 1)}} This dictionary is interpreted as follows: argument in position 0 (i.e. matrix `A`) has its second index (i.e. 1) contracted to `(1, 0)`, that is argument in position 1 (matrix `B`) on the first index slot of `B`, this is the contraction provided by the index `j` from `A`. The argument in position 1 (that is, matrix `B`) has two contractions, the ones provided by the indices `j` and `k`, respectively the first and second indices (0 and 1 in the sub-dict). The link `(0, 1)` and `(2, 0)` respectively. `(0, 1)` is the index slot 1 (the 2nd) of argument in position 0 (that is, `A_{\ldot j}`), and so on. (t_get_contraction_linksRR((R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRns(cCs±g}g}g}x=|jD]2}t|tƒrA|j|ƒq|j|ƒqWgtt|ƒdƒD]"}d|dd|df^qi}tj|ƒtt |Œ|ŒS(Nii( RZR.RtappendR4R-R tfromiterR#R[(R;t args_nonmatRZt contractionsRdR&((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt from_MatMul*s? (R R!t__doc__R0t staticmethodRCRMROR/RQRWR"R?R>R;R(R^RmRnRs(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR#;s   '  % *cCst|dƒr|jSdS(NR((thasattrR(R;((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt get_shape;sR[cBs&eZdZd„Zed„ƒZRS(sF Class to represent the tensor product of array-like objects. c s«g|D]}t|ƒ^q}|j|ƒ}g|D]}t|ƒ^q5}t|ƒdkrg|dSd„t|ƒDƒ}|r2ttdg|ƒƒd ‰|g|D]$}t|tƒrÈ|j n|^qªŒ}g|j ƒD];\‰}|j D]%}t ‡‡fd†|Dƒƒ^q÷qä}t||ŒSt j||Œ}||_g|D]‰tˆƒ^qT} td„| DƒƒrŽd|_nt d„| Dƒƒ|_|S(NiicSs.i|]$\}}t|tƒr||“qS((R.R#(R%R&Rd((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys Os iÿÿÿÿc3s|]}ˆˆ|VqdS(N((R%RR(RSR&(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys Sscss|]}|dkVqdS(N(tNone(R%R&((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ^scss"|]}|D] }|Vq qdS(N((R%R&R)((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys as(RR/RER-R9RTR R.R#R;titemsR(R8R R0RRwR*RxR( R:RZRdRVRrttpR)R(R=tshapes((RSR&s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR0Es$7N   cCsEg|D]4}t||ƒr%|jn|gD] }|^q,q}|S(N(R.RZ(R:RZRdR&((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR/dsA(R R!RtR0t classmethodR/(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR[As tCodegenArrayElementwiseAddcBseZdZd„ZRS(s0 Class for elementwise array additions. cGs!g|D]}t|ƒ^q}tj||Œ}g|D]}t|ƒ^q8}tt|ƒƒ}t|ƒdkrƒtdƒ‚n||_g|D]}|j ^q“}ttg|D]}|dk rµ|^qµƒƒdkrîtdƒ‚nt d„|Dƒƒrd|_ n |d|_ |S(Nis!summing arrays of different rankssmismatching shapes in additioncss|]}|dkVqdS(N(Rx(R%R&((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ysi( RR R0RERTR6R-R7RRRxR*R(R:RZRdR=RVR{R&((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR0ns 7  (R R!RtR0(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR}jstCodegenArrayPermuteDimscBs>eZdZd„Zed„ƒZed„ƒZd„ZRS(sì Class to represent permutation of axes of arrays. Examples ======== >>> from sympy.codegen.array_utils import CodegenArrayPermuteDims >>> from sympy import MatrixSymbol >>> M = MatrixSymbol("M", 3, 3) >>> cg = CodegenArrayPermuteDims(M, [1, 0]) The object ``cg`` represents the transposition of ``M``, as the permutation ``[1, 0]`` will act on its indices by switching them: `M_{ij} \Rightarrow M_{ji}` This is evident when transforming back to matrix form: >>> from sympy.codegen.array_utils import recognize_matrix_expression >>> recognize_matrix_expression(cg) M.T >>> N = MatrixSymbol("N", 3, 2) >>> cg = CodegenArrayPermuteDims(N, [1, 0]) >>> cg.shape (2, 3) csÅddlm}t|ƒ}|ˆƒ‰ˆjd}|t|ƒkrK|Stj||ˆƒ}t|ƒg|_|j ‰ˆdkr“d|_ n.t ‡‡fd†t tˆƒƒDƒƒ|_ |S(Niÿÿÿÿ(R ic3s|]}ˆˆ|ƒVqdS(N((R%R&(t permutationR(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ©s(tsympy.combinatoricsR RRZRfR R0RERRRxRR8R4R-(R:R;RR tplistR=((RRs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR0œs      .cCs |jdS(Ni(RZ(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR;¬scCs |jdS(Ni(RZ(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR°scs)|j}t|tƒrf|j}|jƒ}tt|ƒƒ}g|D]}|j|ƒ^qF}i}d}xÉt||j ƒD]µ\}} ||||!} ||7}t | ƒ} t gtt | ƒdƒD]"} | | d| | dk^q̓sü|Sg| D]} | j | ƒ^q} t| | ƒ|| d>> from sympy.codegen.array_utils import (CodegenArrayPermuteDims, CodegenArrayTensorProduct, nest_permutation) >>> from sympy import MatrixSymbol >>> from sympy.combinatorics import Permutation >>> Permutation.print_cyclic = True >>> M = MatrixSymbol("M", 3, 3) >>> N = MatrixSymbol("N", 3, 3) >>> cg = CodegenArrayPermuteDims(CodegenArrayTensorProduct(M, N), [1, 0, 3, 2]) >>> cg CodegenArrayPermuteDims(CodegenArrayTensorProduct(M, N), (0 1)(2 3)) >>> nest_permutation(cg) CodegenArrayTensorProduct(CodegenArrayPermuteDims(M, (0 1)), CodegenArrayPermuteDims(N, (0 1))) In ``cg`` both ``M`` and ``N`` are transposed. The cyclic representation of the permutation after the tensor product is `(0 1)(2 3)`. After nesting it down the expression tree, the usual transposition permutation `(0 1)` appears. iic3s|]}ˆ|ƒVqdS(N((R%R)(tnewpermutation(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys çs(R;R.R[RRRTR4RRgRZRfR$R-RcR~R#t cyclic_formROR R(R8R}(RR;RRtlR&tptdargsRARdtp0ts0R)tsubpermutationRZtcyclest newcyclesRl((R‚s8lib/python2.7/site-packages/sympy/codegen/array_utils.pytnest_permutation´s6   "  E"#   2,(R R!RtR0R"R;RRŒ(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR~€s  cCs!t|tƒr|jƒS|SdS(N(R.R~RŒ(R;((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRŒïs tCodegenArrayDiagonalcBsDeZdZd„Zed„ƒZed„ƒZed„ƒZRS(sö Class to represent the diagonal operator. In a 2-dimensional array it returns the diagonal, this looks like the operation: `A_{ij} \rightarrow A_{ii}` The diagonal over axes 1 and 2 (the second and third) of the tensor product of two 2-dimensional arrays `A \otimes B` is `\Big[ A_{ab} B_{cd} \Big]_{abcd} \rightarrow \Big[ A_{ai} B_{id} \Big]_{adi}` In this last example the array expression has been reduced from 4-dimensional to 3-dimensional. Notice that no contraction has occurred, rather there is a new index `i` for the diagonal, contraction would have reduced the array to 2 dimensions. Notice that the diagonalized out dimensions are added as new dimensions at the end of the indices. cs,t|ƒ}gˆD]}tt|ƒŒ^q‰t|tƒrP|j|ˆŒStj||ˆŒ}t|ƒ|_ |j ‰ˆdkr•d|_ n“xEˆD]=}t t‡fd†|Dƒƒƒdkrœtdƒ‚qœqœWt‡fd†tˆƒDƒƒ}t‡fd†ˆDƒƒ}|||_ |S(Nc3s|]}ˆ|VqdS(N((R%R)(R(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys sis+contracting indices of different dimensionsc3s7|]-\‰}t‡fd†ˆDƒƒs|VqdS(c3s|]}ˆ|kVqdS(N((R%R)(R&(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys sN(R*(R%R+(tdiagonal_indices(R&s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys sc3s|]}ˆ|dVqdS(iN((R%R&(R(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys s(RRRfR.RR/R R0R1RRRxRR-R6R7R8R9(R:R;RŽR&R=tshp1tshp2((RŽRs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR0 s  %    (" cCs |jdS(Ni(RZ(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR;"scCs |jdS(Ni(RZ(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRŽ&sc s$|j}g|D]}|D] }|^qq}|jƒt|ƒ}t|ƒ}||}gt|ƒD] }d^qh‰d} d} xet|ƒD]W}x4| |krÏ| || krÏ| d7} | d7} qœWˆ|c| 7<| d7} q“Wt‡fd†|Dƒƒ}||} t|j| ŒS(Niic3s+|]!}t‡fd†|DƒƒVqdS(c3s|]}ˆ||VqdS(N((R%R)(RK(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys <sN(R8(R%R&(RK(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys <s(RŽRDRER-R4R8RR;( R;touter_diagonal_indicestinner_diagonal_indicesR&R)RGRHRIRJRARLRŽ((RKs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR/*s$ &      ( R R!RtR0R"R;RŽRuR/(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRös  cCsÌt|ttfƒrdSt|tƒr2|jƒSt|tƒrK|jƒSt|tƒra|jSt|tƒr–|j }|dkr‰dSt |ƒSnt|t ƒr¯|jƒSt|t ƒrÈ|jƒSdS(Niiÿÿÿÿi(R.RRRRRR]RRRRxR-t_RecognizeMatOpt_RecognizeMatMulLines(R;R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyREAs$       cCs't|tƒr|jSt|ƒgSdS(N(R.RRRE(R;((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR1WscCs^i}d}xKt|ƒD]=\}}x.t|ƒD] }||f||<|d7}q2WqW|S(Nii(R9R4(RRPRAR&R]R)((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR2^sc GsÄt|ƒ}g|D]#}g|D]}||^q ^q}ttƒ}xo|D]g}t|ƒdkrvtdƒ‚n|\\}} \} } | | f||| <|| f|| | s R_cs ˆj|ƒS(N(Rc(R`(tflattened_indices(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRa…Rb( RRTR9R.tintRRoRyRDR8(Ržtaxes_contractionR&RBt ret_indicest diag_indicesRŽ((Ržs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt_get_diagonal_indiceszs % #  cCslxOt|ƒD]A\}}||kr)|St|ttfƒr ||kr |Sq Wtd||fƒ‚dS(Ns%s not found in %s(R9R.R6t frozensett IndexError(t subindicesRBR&tsind((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt _get_argindexŒs  !c"s{t|tƒr§|j}|j}t|ƒ\}}|j}|r¤x\|jD]Q\}}}t||ƒ} |dkp‡|d|| krtd|ƒ‚nqLWng} t |ƒ}t|t ƒr¸t |j ƒ} |t | ƒ } |t | ƒ }xG|D]?} | | kr<| j | ƒ}| j| |ƒt| |>> from sympy.codegen.array_utils import parse_indexed_expression >>> from sympy import MatrixSymbol, Sum, symbols >>> from sympy.combinatorics import Permutation >>> Permutation.print_cyclic = True >>> i, j, k, d = symbols("i j k d") >>> M = MatrixSymbol("M", d, d) >>> N = MatrixSymbol("N", d, d) Recognize the trace in summation form: >>> expr = Sum(M[i, i], (i, 0, d-1)) >>> parse_indexed_expression(expr) CodegenArrayContraction(M, (0, 1)) Recognize the extraction of the diagonal by using the same index `i` on both axes of the matrix: >>> expr = M[i, i] >>> parse_indexed_expression(expr) CodegenArrayDiagonal(M, (0, 1)) This function can help perform the transformation expressed in two different mathematical notations as: `\sum_{j=0}^{N-1} A_{i,j} B_{j,k} \Longrightarrow \mathbf{A}\cdot \mathbf{B}` Recognize the matrix multiplication in summation form: >>> expr = Sum(M[i, j]*N[j, k], (j, 0, d-1)) >>> parse_indexed_expression(expr) CodegenArrayContraction(CodegenArrayTensorProduct(M, N), (1, 2)) Specify that ``k`` has to be the starting index: >>> parse_indexed_expression(expr, first_indices=[k]) CodegenArrayPermuteDims(CodegenArrayContraction(CodegenArrayTensorProduct(M, N), (1, 2)), (0 1)) (R«tremovetextendRcR~(R;t first_indicestresultR­R&R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pytparse_indexed_expression#s.  ,"cCs-t|tƒrtSt|tƒr)|jStS(N(R.R”tTrueR“tmultiple_linestFalse(R;((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt_has_multiple_lines]s R“cBs;eZdZd„Zd„Zd„Zd„Zd„ZRS(s< Class to help parsing matrix multiplication lines. cCsD||_||_td„|Dƒƒr1t}nt}||_dS(Ncss|]}t|ƒVqdS(N(RÈ(R%Rd((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ls(toperatorRZR*RÅRÇRÆ(RRÉRZRÆ((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt__init__is    cCs|jtkrdSdS(Nii(RÉR(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR]rscCsq|j}|tkrd}n5|tkr3d}n |j}d|t|jƒfSd|jd„|jDƒƒS(Nt*t+s_RecognizeMatOp(%s, %s)s_RecognizeMatOp(%s)css|]}t|ƒVqdS(N(trepr(R%R&((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys s(RÉRRR RÍRZtjoin(Rtopts((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt__repr__xs      cCsIt|t|ƒƒstS|j|jkr/tS|j|jkrEtStS(N(R.ttypeRÇRÉRZRÅ(Rtother((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt__eq__ƒscCs t|jƒS(N(titerRZ(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt__iter__Œs(R R!RtRÊR]RÑRÔRÖ(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR“es   R”cBs)eZdZd„Zd„Zd„ZRS(sB This class handles multiple parsed multiplication lines. cCs*t|ƒdkr|dStj||ƒS(Nii(R-RTR0(R:RZ((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR0”scCs/td„g|D]}t|ƒ^qtjƒS(NcSs||S(N((R`ty((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRašRb(RRERtOne(RR&((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR]™scCsdtt|ƒjƒS(Ns_RecognizeMatMulLines(%s)(tsuperR”RÑ(R((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRÑœs(R R!RtR0R]RÑ(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyR”s  cs,t|tƒs|g}ng|D]}t|ƒ^q"}td„gt||ƒD]\}}|dkrS|^qStjƒ}t|ƒ}t||Œ}g|D]}|D] } | ^q¬q¢‰t |ƒ} ‡fd†t | ƒDƒ} g} x |rû| r?t | j ƒdd„ƒ\} }| j | ƒ||\}}nd} t |ƒ}d}||}}g}d}xOtrÁ||}|dkr¤tt|gƒ}n|j|ƒ||krÁPnd|}|j |ƒ}||kr8| r.g| j ƒD](\}} || ||fkrù|^qùd}nd}Pnt|ƒdkrYtdƒ‚n||\}}||krst|ƒdkr¨tttt|ƒgƒg}ntt|ƒg}PqsqsW|j |dƒ| j |dƒ| jtt|ƒƒqòW|dkr"| djjd|ƒnt| ƒS( NcSs||S(N((R`R×((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRa¤Rbics%i|]}|ˆkr||“qS(((R%R&(tflatten_contractions(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys ªs R_cSs|dS(Ni((R`((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRa®Rbiis not a matrix multiplication line(R.RTRERRgRRØR2RnRR4R›RytpopRxRÅR“RRoR-R\RRRZtinsertR”(R(RZR&RRdtsranktcoeffRPR•R)RHR?t return_listt first_indextstarting_argindt starting_postcurrent_argindt current_post matmul_argst last_indextelemt other_post link_dict((RÚs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyt_support_function_tp1_recognize sb F &  !          B ! cCst|ƒ}t|ƒS(sD Recognize matrix expressions in codegen objects. If more than one matrix multiplication line have been detected, return a list with the matrix expressions. Examples ======== >>> from sympy import MatrixSymbol, MatrixExpr, Sum, Symbol >>> from sympy.abc import i, j, k, l, N >>> from sympy.codegen.array_utils import CodegenArrayContraction, CodegenArrayTensorProduct >>> from sympy.codegen.array_utils import recognize_matrix_expression, parse_indexed_expression >>> A = MatrixSymbol("A", N, N) >>> B = MatrixSymbol("B", N, N) >>> C = MatrixSymbol("C", N, N) >>> D = MatrixSymbol("D", N, N) >>> expr = Sum(A[i, j]*B[j, k], (j, 0, N-1)) >>> cg = parse_indexed_expression(expr) >>> recognize_matrix_expression(cg) A*B >>> cg = parse_indexed_expression(expr, first_indices=[k]) >>> recognize_matrix_expression(cg) (A*B).T Transposition is detected: >>> expr = Sum(A[j, i]*B[j, k], (j, 0, N-1)) >>> cg = parse_indexed_expression(expr) >>> recognize_matrix_expression(cg) A.T*B >>> cg = parse_indexed_expression(expr, first_indices=[k]) >>> recognize_matrix_expression(cg) (A.T*B).T Detect the trace: >>> expr = Sum(A[i, i], (i, 0, N-1)) >>> cg = parse_indexed_expression(expr) >>> recognize_matrix_expression(cg) Trace(A) Recognize some more complex traces: >>> expr = Sum(A[i, j]*B[j, i], (i, 0, N-1), (j, 0, N-1)) >>> cg = parse_indexed_expression(expr) >>> recognize_matrix_expression(cg) Trace(A*B) More complicated expressions: >>> expr = Sum(A[i, j]*B[k, j]*A[l, k], (j, 0, N-1), (k, 0, N-1)) >>> cg = parse_indexed_expression(expr) >>> recognize_matrix_expression(cg) A*B.T*A.T Expressions constructed from matrix expressions do not contain literal indices, the positions of free indices are returned instead: >>> expr = A*B >>> cg = CodegenArrayContraction.from_MatMul(expr) >>> recognize_matrix_expression(cg) A*B If more than one line of matrix multiplications is detected, return separate matrix multiplication factors: >>> cg = CodegenArrayContraction(CodegenArrayTensorProduct(A, B, C, D), (1, 2), (5, 6)) >>> recognize_matrix_expression(cg) [A*B, C*D] The two lines have free indices at axes 0, 3 and 4, 7, respectively. (t_recognize_matrix_expressiont_unfold_recognized_expr(R;trec((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pytrecognize_matrix_expressionÝsK c s-t|tƒr®t|jƒ}|j}t|tƒr‚|jtkr‚g}x'|jD]}|j t ||ƒƒqUWtt|ƒSt|t ƒržt ||ƒSt ||gƒSt|t ƒr÷g}x$|jD]}|j t|ƒƒqÍWtt|ƒSt|t tfƒr|St|tƒrÄ|jjdddgkrTttt|jƒgƒSt|jtƒr»|jj}gtt|ƒƒD]}|j|ƒ^q…}g} d} x0|D](} | j || | | !ƒ| | 7} q³Wg} x™t| |jjƒD]‚\} }| t| ƒkr9| j t|ƒ| dfƒqût| ƒdkrw| j ttt|ƒgƒ| dfƒqût‚qûW| jdd„ƒg| D]}|d^q›} t | ƒSt‚net|tƒrg|jD]}t|ƒ^qÝ}g|D]}t|ƒ^qü‰tˆƒrùt‡fd†t|ƒDƒƒrKt‚ngt|ƒD](\}}ˆ|rw|jn|g^qX}tj|Œ}ttg|D]J}t g|D]1}t|t ƒrÍ|n|gD] }|^qÔq²ƒ^q¢ƒ}|St |ƒSt|tƒr|St|t ƒr)|S|S(NiiiR_cSs|dS(Ni((R`((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRaRRbc3s.|]$\}}ˆ|r|jtkVqdS(N(RÉR(R%R&ta(RÆ(s8lib/python2.7/site-packages/sympy/codegen/array_utils.pys [s(!R.R#RëR;R(R“RÉRRZRoRêR”R}RRR~RRR[RR4RRgRfR-R\RDRÈR*R9t itertoolstproductR(R;RZR(taddendsRdtadd_argsRVR&tnewrangetnewposRAR]Rºtpost expand_argstitR)RRtret((RÆs8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRë,sp     . " ,   " " ;` cCslt|tƒr8|jg|jD]}t|ƒ^qŒSt|tƒrdg|D]}t|ƒ^qNS|SdS(N(R.R“RÉRZRìR”(R;R&((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pyRìis )(@Rðt functoolsRt collectionsRtsympyRRRRRRRR€R tsympy.core.basicR tsympy.core.compatibilityR R tsympy.core.mulR tsympy.core.sympifyRt(sympy.functions.special.tensor_functionsRtsympy.matrices.expressionsRRRRRt"sympy.matrices.expressions.matexprRRtsympy.tensor.arrayRRR#RwR[R}R~RŒRRER1R2RnR,R£R¨R«R¿RÄRÈtobjectR“RTR”RêRîRëRì(((s8lib/python2.7/site-packages/sympy/codegen/array_utils.pytsL 4()ÿ )o K     s  : + = O =