o o ho|@sddlmZmZddlmZmZmZmZddlm Z ddl m Z ddl m Z mZddlmZmZmZmZmZddlmZddlmZmZdd lmZdd lmZmZdd lm Z dd l!m"Z"m#Z#dd l$m%Z%ddl&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2m3Z3ddl4m5Z5ddl6m7Z7m8Z8Gddde)Z9Gddde9Z:ddZ;ddZd"d#Z?d$d%Z@d&d'ZAd(d)ZBd*d+ZCd,d-ZDd.d/ZEd0d1ZFd2d3ZGd4d5ZHd6d7ZId8S)9)Qask)BasicAddMulS_sympifyadjoint)reim)typedexhaust conditiondo_oneunpack) bottom_up) is_sequencesift) filldedent)Matrix ShapeError)NonInvertibleMatrixError)det Determinant)Inverse)MatAdd) MatrixExpr MatrixElement)MatMul)MatPow MatrixSlice) ZeroMatrixIdentitytrace) Transpose transposecseZdZdZddZeddZeddZedd Zed d Z ed d Z ddZ ddZ ddZ ddZddZddZddZddZddZd d!Zd4d$d%Zd&d'Zd(d)Zd*d+Zd,d-Zed.d/Zed0d1Zfd2d3ZZS)5 BlockMatrixauA BlockMatrix is a Matrix comprised of other matrices. The submatrices are stored in a SymPy Matrix object but accessed as part of a Matrix Expression >>> from sympy import (MatrixSymbol, BlockMatrix, symbols, ... Identity, ZeroMatrix, block_collapse) >>> n,m,l = symbols('n m l') >>> X = MatrixSymbol('X', n, n) >>> Y = MatrixSymbol('Y', m, m) >>> Z = MatrixSymbol('Z', n, m) >>> B = BlockMatrix([[X, Z], [ZeroMatrix(m,n), Y]]) >>> print(B) Matrix([ [X, Z], [0, Y]]) >>> C = BlockMatrix([[Identity(n), Z]]) >>> print(C) Matrix([[I, Z]]) >>> print(block_collapse(C*B)) Matrix([[X, Z + Z*Y]]) Some matrices might be comprised of rows of blocks with the matrices in each row having the same height and the rows all having the same total number of columns but not having the same number of columns for each matrix in each row. In this case, the matrix is not a block matrix and should be instantiated by Matrix. >>> from sympy import ones, Matrix >>> dat = [ ... [ones(3,2), ones(3,3)*2], ... [ones(2,3)*3, ones(2,2)*4]] ... >>> BlockMatrix(dat) Traceback (most recent call last): ... ValueError: Although this matrix is comprised of blocks, the blocks do not fill the matrix in a size-symmetric fashion. To create a full matrix from these arguments, pass them directly to Matrix. >>> Matrix(dat) Matrix([ [1, 1, 2, 2, 2], [1, 1, 2, 2, 2], [1, 1, 2, 2, 2], [3, 3, 3, 4, 4], [3, 3, 3, 4, 4]]) See Also ======== sympy.matrices.matrixbase.MatrixBase.irregular c sjddlm}ddt|dks%t|dr%tfdd|dDdkr+ttd|r1|dngsrBdrBgtd dDdk}}|rD]}td d|Ddk}|sdnqS|}|rttdD]tfd dttDdk}|snqq|std dDdk}|r|rttd ttd|dd}t||}|S)NrImmutableDenseMatrixcSs t|ddS)N is_MatrixF)getattrir1z/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/matrices/expressions/blockmatrix.pySs z%BlockMatrix.__new__..csh|]}|qSr1r1.0r)isMatr1r2 Vz&BlockMatrix.__new__..z\ expecting a sequence of 1 or more rows containing Matrices.cSsh|]}t|qSr1)lenr5r1r1r2r9`r:cSsh|]}|jqSr1rowsr6r0r1r1r2r9dcsh|] }|jqSr1colsr>)cr=r1r2r9kscSsh|] }tdd|DqS)cs|]}|jVqdSNr@r>r1r1r2 rz0BlockMatrix.__new__...)sumr5r1r1r2r9qsa0 Although this matrix is comprised of blocks, the blocks do not fill the matrix in a size-symmetric fashion. To create a full matrix from these arguments, pass them directly to Matrix.a} When there are not the same number of rows in each row's matrices or there are not the same number of total columns in each row, the matrix is not a block matrix. If this matrix is known to consist of blocks fully filling a 2-D space then see Matrix.irregular.Fevaluate) sympy.matrices.immutabler,r;r ValueErrorrranger__new__) clsargskwargsr,blockyokr7matobjr1)rBr8r=r2rMQsR         zBlockMatrix.__new__cCsjd}}|j}t|jdD] }|||dfjd7}qt|jdD] }||d|fjd7}q#||fS)Nrr4)blocksrLshape)selfnumrowsnumcolsMr0r1r1r2rVszBlockMatrix.shapecCs|jjSrDrUrVrWr1r1r2 blockshapeszBlockMatrix.blockshapecCs |jdS)NrrOr\r1r1r2rUs zBlockMatrix.blockscfddtjdDS)Ncsg|] }j|dfjqSr)rUr=r>r\r1r2 z-BlockMatrix.rowblocksizes..rrLr]r\r1r\r2 rowblocksizeszBlockMatrix.rowblocksizescr_)Ncsg|] }jd|fjqSr`)rUrAr>r\r1r2rarbz-BlockMatrix.colblocksizes..r4rcr\r1r\r2 colblocksizesrezBlockMatrix.colblocksizescCs:t|to|j|jko|j|jko|j|jko|j|jkSrD) isinstancer*rVr]rdrfrWotherr1r1r2structurally_equals     zBlockMatrix.structurally_equalcCs.t|tr|j|jkrt|j|jS||SrD)rgr*rfrdrUrhr1r1r2 _blockmuls  zBlockMatrix._blockmulcCs,t|tr||rt|j|jS||SrD)rgr*rjrUrhr1r1r2 _blockadds zBlockMatrix._blockaddcC8dd|jD}t|jd|jd|}|}t|S)NcSg|]}t|qSr1r)r6matrixr1r1r2rar:z/BlockMatrix._eval_transpose..rr4rUrr]r)r*rWmatricesrZr1r1r2_eval_transposezBlockMatrix._eval_transposecCrm)NcSrnr1r rpr1r1r2rar:z-BlockMatrix._eval_adjoint..rr4rrrsr1r1r2 _eval_adjointrvzBlockMatrix._eval_adjointcs>jjkrfddtjdD}tdd|DSdS)Ncsg|] }j||fqSr1rUr>r\r1r2raz+BlockMatrix._eval_trace..rcSrnr1r&r6blockr1r1r2rar:)rdrfrLr]r)rWrUr1r\r2 _eval_traces zBlockMatrix._eval_tracecCs|jdkr t|jdS|jdkrH|j\\}}\}}tt|r2t|t|||j|Stt|rHt|t|||j|St|S)Nr4r4rrr) r]rrUtolistrr invertibleIr)rWABCDr1r1r2_eval_determinants  zBlockMatrix._eval_determinantcCs`dd|jD}t|jd|jd|}dd|jD}t|jd|jd|}t|t|fS)NcSrnr1)r rpr1r1r2rar:z2BlockMatrix._eval_as_real_imag..rr4cSrnr1)r rpr1r1r2rar:)rUrr]r*)rW real_matrices im_matricesr1r1r2_eval_as_real_imags zBlockMatrix._eval_as_real_imagcCst|j|SrD)r*rUdiff)rWxr1r1r2_eval_derivativeszBlockMatrix._eval_derivativecCs|S)aReturn transpose of matrix. Examples ======== >>> from sympy import MatrixSymbol, BlockMatrix, ZeroMatrix >>> from sympy.abc import m, n >>> X = MatrixSymbol('X', n, n) >>> Y = MatrixSymbol('Y', m, m) >>> Z = MatrixSymbol('Z', n, m) >>> B = BlockMatrix([[X, Z], [ZeroMatrix(m,n), Y]]) >>> B.transpose() Matrix([ [X.T, 0], [Z.T, Y.T]]) >>> _.transpose() Matrix([ [X, Z], [0, Y]]) )rur\r1r1r2r)szBlockMatrix.transposerFc Cs|jdkrr|j\\}}\}}||||d}zO|r*||j||||jn||}|dkr=||||WS|dkrJ||||WS|dkrW||||WS|dkrd||||WS|WStyqtdwtd) a Return the Schur Complement of the 2x2 BlockMatrix Parameters ========== mat : String, optional The matrix with respect to which the Schur Complement is calculated. 'A' is used by default generalized : bool, optional If True, returns the generalized Schur Component which uses Moore-Penrose Inverse Examples ======== >>> from sympy import symbols, MatrixSymbol, BlockMatrix >>> m, n = symbols('m n') >>> A = MatrixSymbol('A', n, n) >>> B = MatrixSymbol('B', n, m) >>> C = MatrixSymbol('C', m, n) >>> D = MatrixSymbol('D', m, m) >>> X = BlockMatrix([[A, B], [C, D]]) The default Schur Complement is evaluated with "A" >>> X.schur() -C*A**(-1)*B + D >>> X.schur('D') A - B*D**(-1)*C Schur complement with non-invertible matrices is not defined. Instead, the generalized Schur complement can be calculated which uses the Moore-Penrose Inverse. To achieve this, `generalized` must be set to `True` >>> X.schur('B', generalized=True) C - D*(B.T*B)**(-1)*B.T*A >>> X.schur('C', generalized=True) -A*(C.T*C)**(-1)*C.T*D + B Returns ======= M : Matrix The Schur Complement Matrix Raises ====== ShapeError If the block matrix is not a 2x2 matrix NonInvertibleMatrixError If given matrix is non-invertible References ========== .. [1] Wikipedia Article on Schur Component : https://en.wikipedia.org/wiki/Schur_complement See Also ======== sympy.matrices.matrixbase.MatrixBase.pinv r)rrrrrrrrzThe given matrix is not invertible. Please set generalized=True to compute the generalized Schur Complement which uses Moore-Penrose Inversez>Schur Complement can only be calculated for 2x2 block matrices)r]rUrTinvrr) rWrS generalizedrrrrdrr1r1r2schurs( E0 zBlockMatrix.schurc Cs|jdkrY|j\\}}\}}z|j}Wn ty tdwt|jd}t|jd}t|j}t||g|||gg} t || }t|||g|j |gg} | || fSt d)aLReturns the Block LDU decomposition of a 2x2 Block Matrix Returns ======= (L, D, U) : Matrices L : Lower Diagonal Matrix D : Diagonal Matrix U : Upper Diagonal Matrix Examples ======== >>> from sympy import symbols, MatrixSymbol, BlockMatrix, block_collapse >>> m, n = symbols('m n') >>> A = MatrixSymbol('A', n, n) >>> B = MatrixSymbol('B', n, m) >>> C = MatrixSymbol('C', m, n) >>> D = MatrixSymbol('D', m, m) >>> X = BlockMatrix([[A, B], [C, D]]) >>> L, D, U = X.LDUdecomposition() >>> block_collapse(L*D*U) Matrix([ [A, B], [C, D]]) Raises ====== ShapeError If the block matrix is not a 2x2 matrix NonInvertibleMatrixError If the matrix "A" is non-invertible See Also ======== sympy.matrices.expressions.blockmatrix.BlockMatrix.UDLdecomposition sympy.matrices.expressions.blockmatrix.BlockMatrix.LUdecomposition rzTBlock LDU decomposition cannot be calculated when "A" is singularrr4z@Block LDU decomposition is supported only for 2x2 block matrices) r]rUrrrr%rVr$r*BlockDiagMatrixrrr) rWrrrrAIIpIqZLUr1r1r2LDUdecompositionUs" *    zBlockMatrix.LDUdecompositionc Cs|jdkrZ|j\\}}\}}z|j}Wn ty tdwt|jd}t|jd}t|j}t|||g|j |gg} t | d|}t||g|||gg} | || fSt d)aLReturns the Block UDL decomposition of a 2x2 Block Matrix Returns ======= (U, D, L) : Matrices U : Upper Diagonal Matrix D : Diagonal Matrix L : Lower Diagonal Matrix Examples ======== >>> from sympy import symbols, MatrixSymbol, BlockMatrix, block_collapse >>> m, n = symbols('m n') >>> A = MatrixSymbol('A', n, n) >>> B = MatrixSymbol('B', n, m) >>> C = MatrixSymbol('C', m, n) >>> D = MatrixSymbol('D', m, m) >>> X = BlockMatrix([[A, B], [C, D]]) >>> U, D, L = X.UDLdecomposition() >>> block_collapse(U*D*L) Matrix([ [A, B], [C, D]]) Raises ====== ShapeError If the block matrix is not a 2x2 matrix NonInvertibleMatrixError If the matrix "D" is non-invertible See Also ======== sympy.matrices.expressions.blockmatrix.BlockMatrix.LDUdecomposition sympy.matrices.expressions.blockmatrix.BlockMatrix.LUdecomposition rzTBlock UDL decomposition cannot be calculated when "D" is singularrr4rz@Block UDL decomposition is supported only for 2x2 block matrices) r]rUrrrr%rVr$r*rrrr) rWrrrrDIrrrrrr1r1r2UDLdecompositions" *    zBlockMatrix.UDLdecompositionc Cs|jdkrO|j\\}}\}}z |tj}|j}Wn ty%tdwt|j}| tj}t ||g|||gg}t |||g|j |gg} || fSt d)a#Returns the Block LU decomposition of a 2x2 Block Matrix Returns ======= (L, U) : Matrices L : Lower Diagonal Matrix U : Upper Diagonal Matrix Examples ======== >>> from sympy import symbols, MatrixSymbol, BlockMatrix, block_collapse >>> m, n = symbols('m n') >>> A = MatrixSymbol('A', n, n) >>> B = MatrixSymbol('B', n, m) >>> C = MatrixSymbol('C', m, n) >>> D = MatrixSymbol('D', m, m) >>> X = BlockMatrix([[A, B], [C, D]]) >>> L, U = X.LUdecomposition() >>> block_collapse(L*U) Matrix([ [A, B], [C, D]]) Raises ====== ShapeError If the block matrix is not a 2x2 matrix NonInvertibleMatrixError If the matrix "A" is non-invertible See Also ======== sympy.matrices.expressions.blockmatrix.BlockMatrix.UDLdecomposition sympy.matrices.expressions.blockmatrix.BlockMatrix.LDUdecomposition rzSBlock LU decomposition cannot be calculated when "A" is singularz?Block LU decomposition is supported only for 2x2 block matrices) r]rUrrHalfrrr$rVrr*rr) rWrrrrrrrrrr1r1r2LUdecompositions )    zBlockMatrix.LUdecompositionc Ks||}}t|jD](\}}||k}|dkrn|dkr!||8}q ||jddkr2t|||Sq t|jD](\} } || k}|dkrFn|dkrO|| 8}q8| |jddkr`t|||Sq8|j|| f||fS)NTFrr4) enumeraterdr]rrfrU) rWr0jrPorig_iorig_j row_blockrXcmp col_blockrYr1r1r2_entrys(   zBlockMatrix._entrycCs|jd|jdkr dSt|jdD],}t|jdD]"}||kr.|j||fjs.dS||kr>|j||fjs>dSqqdS)Nrr4FT)r]rLrU is_Identity is_ZeroMatrix)rWr0rr1r1r2rszBlockMatrix.is_IdentitycCs |j|jkSrD)rdrfr\r1r1r2is_structurally_symmetric)s z%BlockMatrix.is_structurally_symmetriccs2||krdSt|tr|j|jkrdSt|S)NT)rgr*rUsuperequalsrh __class__r1r2r-s  zBlockMatrix.equals)rF)__name__ __module__ __qualname____doc__rMpropertyrVr]rUrdrfrjrkrlrurwr|rrrr)rrrrrrrr __classcell__r1r1rr2r*sB74          [<<:  r*c@seZdZdZddZeddZeddZedd Zed d Z ed d Z eddZ ddZ ddZ d ddZddZddZddZddZdS)!raA sparse matrix with block matrices along its diagonals Examples ======== >>> from sympy import MatrixSymbol, BlockDiagMatrix, symbols >>> n, m, l = symbols('n m l') >>> X = MatrixSymbol('X', n, n) >>> Y = MatrixSymbol('Y', m, m) >>> BlockDiagMatrix(X, Y) Matrix([ [X, 0], [0, Y]]) Notes ===== If you want to get the individual diagonal blocks, use :meth:`get_diag_blocks`. See Also ======== sympy.matrices.dense.diag cGstjtgdd|DRS)NcSrnr1r)r6mr1r1r2raPr:z+BlockDiagMatrix.__new__..)rrMr)rNmatsr1r1r2rMOszBlockDiagMatrix.__new__cC|jSrDr^r\r1r1r2diagRszBlockDiagMatrix.diagcs8ddlm}|jfddttD}||ddS)Nrr+cs(g|]fddttDqS)cs2g|]}|kr n tj|jqSr1)r$r=rAr6r)r0rr1r2raZs*z5BlockDiagMatrix.blocks...)rLr;r6rr/r2raZs   z*BlockDiagMatrix.blocks..FrH)rJr,rOrLr;)rWr,datar1rr2rUVs    zBlockDiagMatrix.blockscCs(tdd|jDtdd|jDfS)NcsrCrDr<rzr1r1r2rEarFz(BlockDiagMatrix.shape..csrCrDr@rzr1r1r2rEbrF)rGrOr\r1r1r2rV_szBlockDiagMatrix.shapecCst|j}||fSrD)r;rO)rWnr1r1r2r]ds zBlockDiagMatrix.blockshapecCdd|jDS)NcSg|]}|jqSr1r<rzr1r1r2rakr?z1BlockDiagMatrix.rowblocksizes..r^r\r1r1r2rdizBlockDiagMatrix.rowblocksizescCr)NcSrr1r@rzr1r1r2raor?z1BlockDiagMatrix.colblocksizes..r^r\r1r1r2rfmrzBlockDiagMatrix.colblocksizescCstdd|jDS)z%Returns true if all blocks are squarecsrCrD) is_squarer6rSr1r1r2rEsrFz5BlockDiagMatrix._all_square_blocks..)allrOr\r1r1r2_all_square_blocksqsz"BlockDiagMatrix._all_square_blockscCs"|rtdd|jDStjS)NcSrnr1)rrr1r1r2rawr:z5BlockDiagMatrix._eval_determinant..)rrrOrZeror\r1r1r2rusz!BlockDiagMatrix._eval_determinantignoredcCs$|rtdd|jDStd)NcSg|]}|qSr1)inverserr1r1r2ra~r:z1BlockDiagMatrix._eval_inverse..z Matrix det == 0; not invertible.)rrrOr)rWexpandr1r1r2 _eval_inverse|szBlockDiagMatrix._eval_inversecCstdd|jDS)NcSrr1rorr1r1r2rar:z3BlockDiagMatrix._eval_transpose..)rrOr\r1r1r2ruszBlockDiagMatrix._eval_transposecCs>t|tr|j|jkrtddt|j|jDSt||S)NcSsg|]\}}||qSr1r1r6abr1r1r2raz-BlockDiagMatrix._blockmul..)rgrrfrdziprOr*rkrhr1r1r2rks   zBlockDiagMatrix._blockmulcCsVt|tr%|j|jkr%|j|jkr%|j|jkr%tddt|j|jDSt||S)NcSsg|]\}}||qSr1r1rr1r1r2rarz-BlockDiagMatrix._blockadd..) rgrr]rdrfrrOr*rlrhr1r1r2rls     zBlockDiagMatrix._blockaddcCr)aReturn the list of diagonal blocks of the matrix. Examples ======== >>> from sympy import BlockDiagMatrix, Matrix >>> A = Matrix([[1, 2], [3, 4]]) >>> B = Matrix([[5, 6], [7, 8]]) >>> M = BlockDiagMatrix(A, B) How to get diagonal blocks from the block diagonal matrix: >>> diag_blocks = M.get_diag_blocks() >>> diag_blocks[0] Matrix([ [1, 2], [3, 4]]) >>> diag_blocks[1] Matrix([ [5, 6], [7, 8]]) r^r\r1r1r2get_diag_blocksszBlockDiagMatrix.get_diag_blocksN)r)rrrrrMrrrUrVr]rdrfrrrrurkrlrr1r1r1r2r5s,        rcCsddlm}dd}t|tttttttt t t t t t tttttti}ttt||d}||}t|dd}|durA|S|S)aEvaluates a block matrix expression >>> from sympy import MatrixSymbol, BlockMatrix, symbols, Identity, ZeroMatrix, block_collapse >>> n,m,l = symbols('n m l') >>> X = MatrixSymbol('X', n, n) >>> Y = MatrixSymbol('Y', m, m) >>> Z = MatrixSymbol('Z', n, m) >>> B = BlockMatrix([[X, Z], [ZeroMatrix(m, n), Y]]) >>> print(B) Matrix([ [X, Z], [0, Y]]) >>> C = BlockMatrix([[Identity(n), Z]]) >>> print(C) Matrix([[I, Z]]) >>> print(block_collapse(C*B)) Matrix([[X, Z + Z*Y]]) r)expr_fnscSst|to |tSrD)rgrhasr*exprr1r1r2r3r:z block_collapse..)fnsdoitN)sympy.strategies.utilrrrrr bc_mataddbc_block_plus_identr bc_matmulbc_distr!r( bc_transposer bc_inverser* bc_unpackdeblockrrr.)rrhasbmconditioned_rlruleresultrr1r1r2block_collapses2      rcCs|jdkr |jdS|S)Nr}r~)r]rUrr1r1r2rs  rcCs`t|jdd}|d}|s|S|d}|d}|ddD]}||}q|r.t||S|S)NcSs t|tSrDrgr*)rZr1r1r2r3s zbc_matadd..TFrr4)rrOrlr)rrOrU nonblocksr{rr1r1r2rs  rcsdd|jD}|s |Sdd|jDrJtfddDrJdjrJtdddjD}dd|jD}t|t|g|RS|S) NcSsg|]}|jr|qSr1)rr6argr1r1r2rasz'bc_block_plus_ident..cSsg|] }t|tr|qSr1rrr1r1r2raryc3s|] }|dVqdS)rN)rj)r6rrxr1r2rEsz&bc_block_plus_ident..rcSrnr1)r%)r6kr1r1r2ras cSs g|] }|jst|ts|qSr1)rrgr*rr1r1r2ras )rOrrrrdrr;r)ridentsblock_idrestr1rxr2rs rcs|\}dkr |St|}t|tr%|jfddD}t|St|tr>|jfddtjD}t|S|S)z Turn a*[X, Y] into [a*X, a*Y] r4csg|]}|qSr1r1r)factorr1r2rar:zbc_dist..cs(g|]fddtjDqS)csg|] }|fqSr1r1r)rrr0r1r2rarbz&bc_dist...)rLrArrrr/r2ras) as_coeff_mmulrrgrrr*rUrLr=)rrSunpackednew_Br1rr2rs    rcCs8t|tr#|jdjr!|jddkr!d|jdg|jd}}n|S|\}}d}|dt|kr|||d\}}t|trVt|trV||||<||dn4t|trn|t|gg||<||dnt|trt|gg|||<||dn|d7}|dt|ks3t |g|R S)Nr4rr) rgr!rO is_Integeras_coeff_matricesr;r*rkpopr r)rrrtr0rrr1r1r2rs(     rcCst|j}|SrD)rrru)rcollapser1r1r2r3s rcCs:t|jtr |St|}||kr|Sttt|jSrD)rgrrrblockinverse_1x1blockinverse_2x2r reblock_2x2)rexpr2r1r1r2r8s rcCs<t|jtr|jjdkrt|jjdgg}t|S|S)Nr}r)rgrr*r]rrUr)rrSr1r1r2rAsrc Cst|jtr|jjdkr|jj\\}}\}}t||||}|dkr*|j|j}|dkrO|j}t||||||| ||g| |||ggS|dkrt|j}t| |||g||||||| ||ggS|dkr|j} t| ||| | |||| g|| || ggS|dkr|j} t|| || g| ||| | |||| ggS|S)Nrrrrr) rgrr*r]rUr_choose_2x2_inversion_formularr) rrrrrformulaMIrBICIrr1r1r2rHs( <<<<rcCstt|}|dkr dStt|}|dkrdStt|}|dkr'dStt|}|dkr4dS|dkr:dS|dkr@dS|dkrFdS|dkrLdSdS)a\ Assuming [[A, B], [C, D]] would form a valid square block matrix, find which of the classical 2x2 block matrix inversion formulas would be best suited. Returns 'A', 'B', 'C', 'D' to represent the algorithm involving inversion of the given argument or None if the matrix cannot be inverted using any of those formulas. TrrrrFN)rrr)rrrrA_invB_invC_invD_invr1r1r2ras* rcst|tr |jts |Sdd}|j|zGtdtfddtjdDg}tdjdD]%}t|dfj}tdjdD] }| ||fj}qG| |}q4t|WSt yi|YSw)z( Flatten a BlockMatrix of BlockMatrices cSst|tr|St|ggSrDr)rr1r1r2r3ryzdeblock..rc3s$|] }d|fjjdVqdS)rr4Nr[r>bbr1r2rEs"zdeblock..r4) rgr*rUr applyfuncrrGrLrVrow_joincol_joinr)rwrapMMrowrZcolr1rr2rs (   rc CsDt|trtdd|jDs|St}|j\}}|j}td|D][}td|D]S}t||d|d|f}t||d||df}t|||dd|f} t|||d|df} t||| | } | durzt||g| | ggSq'q ||d||dddfg||dddf||ddddfggS)z Reblock a BlockMatrix so that it has 2x2 blocks of block matrices. If possible in such a way that the matrix continues to be invertible using the classical 2x2 block inversion formulas. css|]}|dkVqdS)rNr1)r6rr1r1r2rEszreblock_2x2..r4Nr~r)rgr*rr]rUrLrr) rBM rowblocks colblocksrUr0rrrrrrr1r1r2rs&  *rcCs0d}g}|D]}||||f||7}q|S)z Convert sequence of numbers into pairs of low-high pairs >>> from sympy.matrices.expressions.blockmatrix import bounds >>> bounds((1, 10, 50)) [(0, 1), (1, 11), (11, 61)] r)append)sizeslowrvsizer1r1r2boundss  rcs(t|}t|tfdd|DS)a Cut a matrix expression into Blocks >>> from sympy import ImmutableMatrix, blockcut >>> M = ImmutableMatrix(4, 4, range(16)) >>> B = blockcut(M, (1, 3), (1, 3)) >>> type(B).__name__ 'BlockMatrix' >>> ImmutableMatrix(B.blocks[0, 1]) Matrix([[1, 2, 3]]) cs g|] fddDqS)csg|]}t|qSr1r")r6colbound)rrowboundr1r2rasz'blockcut...r1r colboundsr)rr2ras   zblockcut..)rr*)rrowsizescolsizes rowboundsr1rr2blockcuts  rN)Jsympy.assumptions.askrr sympy.corerrrrsympy.core.sympifyr sympy.functionsr $sympy.functions.elementary.complexesr r sympy.strategiesrrrrrsympy.strategies.traversersympy.utilities.iterablesrrsympy.utilities.miscrsympy.matricesrrsympy.matrices.exceptionsr&sympy.matrices.expressions.determinantrr"sympy.matrices.expressions.inverser!sympy.matrices.expressions.mataddr"sympy.matrices.expressions.matexprrr!sympy.matrices.expressions.matmulr !sympy.matrices.expressions.matpowr! sympy.matrices.expressions.slicer#"sympy.matrices.expressions.specialr$r% sympy.matrices.expressions.tracer'$sympy.matrices.expressions.transposer(r)r*rrrrrrrrrrrrrrrrr1r1r1r2sT            {3 $