ó
~9­\c           @  s"  d  d l  m Z m Z d  d l m Z m Z d  d l m Z m Z m	 Z	 d  d l
 m Z d  d l m Z m Z m Z m Z m Z d  d l m Z d  d l m Z d  d l m Z m Z m Z d  d	 l m Z d  d
 l m Z d  d l m Z d  d l  m! Z! m" Z" d  d l# m$ Z$ d  d l% m& Z& m' Z' d  d l( m) Z) d  d l* m+ Z+ d  d l, m- Z- m. Z. d  d l/ m0 Z0 m1 Z1 d e f d „  ƒ  YZ2 d e2 f d „  ƒ  YZ3 d „  Z4 d „  Z5 d „  Z6 d „  Z7 d „  Z8 d „  Z9 d „  Z: d „  Z; d „  Z< d  „  Z= d! „  Z> d" „  Z? d# „  Z@ d$ „  ZA d% S(&   iÿÿÿÿ(   t   print_functiont   division(   t   askt   Q(   t   Basict   Addt   sympify(   t   range(   t   typedt   exhaustt	   conditiont   do_onet   unpack(   t	   bottom_up(   t   sift(   t
   MatrixExprt
   ZeroMatrixt   Identity(   t   MatMul(   t   MatAdd(   t   MatPow(   t	   Transposet	   transpose(   t   Trace(   t   dett   Determinant(   t   MatrixSlice(   t   Inverse(   t   Matrixt
   ShapeError(   t   ret   imt   BlockMatrixc           B  sÚ   e  Z d  Z d „  Z e d „  ƒ Z e d „  ƒ Z e d „  ƒ Z e d „  ƒ Z e d „  ƒ Z	 d „  Z
 d „  Z d	 „  Z d
 „  Z d „  Z d „  Z d „  Z d „  Z d „  Z e d „  ƒ Z e d „  ƒ Z d „  Z RS(   s¯  A BlockMatrix is a Matrix composed of other smaller, submatrices

    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]])

    c         G  sA   d d l  m } t t | ƒ } | | Œ  } t j |  | ƒ } | S(   Niÿÿÿÿ(   t   ImmutableDenseMatrix(   t   sympy.matrices.immutableR!   t   mapR   R   t   __new__(   t   clst   argsR!   t   matt   obj(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR$   0   s
    c         C  s   d } } |  j  } x6 t | j d ƒ D]! } | | | d f j d 7} q' Wx6 t | j d ƒ D]! } | | d | f j d 7} q` W| | f S(   Ni    i   (   t   blocksR   t   shape(   t   selft   numrowst   numcolst   Mt   i(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR*   8   s    
	c         C  s
   |  j  j S(   N(   R)   R*   (   R+   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt
   blockshapeB   s    c         C  s   |  j  d S(   Ni    (   R&   (   R+   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR)   F   s    c         C  s4   g  t  |  j d ƒ D] } |  j | d f j ^ q S(   Ni    (   R   R0   R)   t   rows(   R+   R/   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   rowblocksizesJ   s    c         C  s4   g  t  |  j d ƒ D] } |  j d | f j ^ q S(   Ni   i    (   R   R0   R)   t   cols(   R+   R/   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   colblocksizesN   s    c         C  sU   t  | t ƒ oT |  j | j k oT |  j | j k oT |  j | j k oT |  j | j k S(   N(   t
   isinstanceR    R*   R0   R2   R4   (   R+   t   other(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   structurally_equalR   s
    c         C  s=   t  | t ƒ r5 |  j | j k r5 t |  j | j ƒ S|  | S(   N(   R5   R    R4   R2   R)   (   R+   R6   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt	   _blockmulY   s    c         C  s:   t  | t ƒ r2 |  j | ƒ r2 t |  j | j ƒ S|  | S(   N(   R5   R    R7   R)   (   R+   R6   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt	   _blockadd`   s    c         C  sX   g  |  j  D] } t | ƒ ^ q
 } t |  j d |  j d | ƒ } | j ƒ  } t | ƒ S(   Ni    i   (   R)   R   R   R0   R    (   R+   t   matrixt   matricesR.   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   _eval_transposeg   s    " c         C  s_   |  j  |  j k rO t g  t |  j d ƒ D] } t |  j | | f ƒ ^ q) Œ  St d ƒ ‚ d  S(   Ni    s+   Can't perform trace of irregular blockshape(   R2   R4   R   R   R0   R   R)   t   NotImplementedError(   R+   R/   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   _eval_tracep   s
    7c         C  s­   |  j  d k r£ |  j j ƒ  \ \ } } \ } } t t j | ƒ ƒ rh t | ƒ t | | | j | ƒ St t j | ƒ ƒ r£ t | ƒ t | | | j | ƒ Sn  t |  ƒ S(   Ni   (   i   i   (	   R0   R)   t   tolistR   R   t
   invertibleR   t   IR   (   R+   t   At   Bt   Ct   D(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   _eval_determinantw   s    !#&c         C  sŽ   g  |  j  D] } t | ƒ ^ q
 } t |  j d |  j d | ƒ } g  |  j  D] } t | ƒ ^ qL } t |  j d |  j d | ƒ } | | f S(   Ni    i   (   R)   R   R   R0   R   (   R+   R:   t   real_matricest   im_matrices(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   as_real_imag   s
    " " c         C  s
   |  j  ƒ  S(   s	  Return transpose of matrix.

        Examples
        ========

        >>> from sympy import MatrixSymbol, BlockMatrix, ZeroMatrix
        >>> from sympy.abc import l, 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]])
        (   R<   (   R+   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR   Š   s    c         C  s›   x= t  |  j ƒ D], \ } } | | k  t k r2 Pq | | 8} q Wx= t  |  j ƒ D], \ } } | | k  t k rr PqP | | 8} qP W|  j | | f | | f S(   N(   t	   enumerateR2   t   FalseR4   R)   (   R+   R/   t   jt	   row_blockR,   t	   col_blockR-   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   _entry¡   s    c         C  s¬   |  j  d |  j  d k r t Sx‡ t |  j  d ƒ D]r } xi t |  j  d ƒ D]T } | | k ry |  j | | f j ry t S| | k rL |  j | | f j rL t SqL Wq2 Wt S(   Ni    i   (   R0   RK   R   R)   t   is_Identityt   is_ZeroMatrixt   True(   R+   R/   RL   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRP   ¯   s    ##c         C  s   |  j  |  j k S(   N(   R2   R4   (   R+   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   is_structurally_symmetric»   s    c         C  sK   |  | k r t  St | t ƒ r5 |  j | j k r5 t  St t |  ƒ j | ƒ S(   N(   RR   R5   R    R)   t   supert   equals(   R+   R6   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRU   ¿   s
    !(   t   __name__t
   __module__t   __doc__R$   t   propertyR*   R0   R)   R2   R4   R7   R8   R9   R<   R>   RF   RI   R   RO   RP   RS   RU   (    (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR       s&   	
							
				t   BlockDiagMatrixc           B  s   e  Z d  Z d „  Z e d „  ƒ Z e d „  ƒ Z e d „  ƒ Z e d „  ƒ Z e d „  ƒ Z	 e d „  ƒ Z
 d d	 „ Z d
 „  Z d „  Z RS(   sL  
    A BlockDiagMatrix is a BlockMatrix with matrices only along the diagonal

    >>> from sympy import MatrixSymbol, BlockDiagMatrix, symbols, Identity
    >>> 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]])

    c         G  s   t  j t | Œ S(   N(   R   R$   RZ   (   R%   t   mats(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR$   Ô   s    c         C  s   |  j  S(   N(   R&   (   R+   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   diag×   s    c         C  s”   d d l  m } |  j } g  t t | ƒ ƒ D]X } g  t t | ƒ ƒ D]9 } | | k ra | | n t | | j | | j ƒ ^ qE ^ q, } | | ƒ S(   Niÿÿÿÿ(   R!   (   R"   R!   R&   R   t   lenR   R1   R3   (   R+   R!   R[   R/   RL   t   data(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR)   Û   s
    	nc         C  s0   t  d „  |  j Dƒ ƒ t  d „  |  j Dƒ ƒ f S(   Nc         s  s   |  ] } | j  Vq d  S(   N(   R1   (   t   .0t   block(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pys	   <genexpr>æ   s    c         s  s   |  ] } | j  Vq d  S(   N(   R3   (   R_   R`   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pys	   <genexpr>ç   s    (   t   sumR&   (   R+   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR*   ä   s    c         C  s   t  |  j ƒ } | | f S(   N(   R]   R&   (   R+   t   n(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR0   é   s    c         C  s   g  |  j  D] } | j ^ q
 S(   N(   R&   R1   (   R+   R`   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR2   î   s    c         C  s   g  |  j  D] } | j ^ q
 S(   N(   R&   R3   (   R+   R`   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR4   ò   s    t   ignoredc         C  s&   t  g  |  j D] } | j ƒ  ^ q Œ  S(   N(   RZ   R&   t   inverse(   R+   t   expandR'   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   _eval_inverseö   s    c         C  sk   t  | t ƒ rW |  j | j k rW t g  t |  j | j ƒ D] \ } } | | ^ q: Œ  St j |  | ƒ Sd  S(   N(   R5   RZ   R4   R2   t   zipR&   R    R8   (   R+   R6   t   at   b(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR8   ù   s    6c         C  s   t  | t ƒ r{ |  j | j k r{ |  j | j k r{ |  j | j k r{ t g  t |  j | j ƒ D] \ } } | | ^ q^ Œ  St j |  | ƒ Sd  S(   N(	   R5   RZ   R0   R2   R4   Rg   R&   R    R9   (   R+   R6   Rh   Ri   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR9      s    6(   RV   RW   RX   R$   RY   R\   R)   R*   R0   R2   R4   Rf   R8   R9   (    (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRZ   Æ   s   			c      
   C  s®   d „  } t  t t  t | t i t t t ƒ t 6t t t	 ƒ t
 6t t 6t t 6t t 6t t t ƒ t 6ƒ ƒ ƒ ƒ ƒ } | |  ƒ } t | d d ƒ } | d k	 r¦ | ƒ  S| Sd S(   s=  Evaluates a block matrix expression

    >>> from sympy import MatrixSymbol, BlockMatrix, symbols,                           Identity, Matrix, 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]])
    c         S  s   t  |  t ƒ o |  j t ƒ S(   N(   R5   R   t   hasR    (   t   expr(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   <lambda>   t    t   doitN(   R	   R   R
   R   R   t	   bc_mataddt   bc_block_plus_identR   t	   bc_matmult   bc_distR   R   t   bc_transposeR   t
   bc_inverseR   t	   bc_unpackt   deblockR    t   getattrt   None(   Rk   t   hasbmt   rulet   resultRn   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   block_collapse
  s    	"c         C  s   |  j  d k r |  j d S|  S(   Ni   i    (   i   i   (   i    i    (   R0   R)   (   Rk   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRu   0  s    c         C  s}   t  |  j d „  ƒ } | t } | s) |  S| t } | d } x! | d D] } | j | ƒ } qH W| ru t | Œ  | S| Sd  S(   Nc         S  s   t  |  t ƒ S(   N(   R5   R    (   R.   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRl   6  Rm   i    i   (   R   R&   RR   RK   R9   R   (   Rk   R&   R)   t	   nonblocksR`   Ri   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRo   5  s    


c           sÖ   g  |  j  D] } | j r
 | ^ q
 } | s/ |  Sg  |  j  D] } t | t ƒ r9 | ^ q9 ‰  ˆ  rÒ t ‡  f d †  ˆ  Dƒ ƒ rÒ ˆ  d j rÒ t g  ˆ  d j D] } t | ƒ ^ qš Œ  } t	 | t
 | ƒ ˆ  Œ j ƒ  S|  S(   Nc         3  s"   |  ] } | j  ˆ  d  ƒ Vq d S(   i    N(   R7   (   R_   Ri   (   R)   (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pys	   <genexpr>J  s    i    (   R&   RP   R5   R    t   allRS   RZ   R2   R   R   R]   Rn   (   Rk   t   argt   identst   kt   block_id(    (   R)   sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRp   D  s    %+"&c      	   C  s–   |  j  ƒ  \ } } | d k r’ t t | ƒ t ƒ r’ t | ƒ j } t g  t | j ƒ D]6 } g  t | j ƒ D] } | | | | f ^ qk ^ qU ƒ S|  S(   s     Turn  a*[X, Y] into [a*X, a*Y] i   (   t   as_coeff_mmulR5   R   R    R)   R   R1   R3   (   Rk   t   factorR'   RC   R/   RL   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRr   R  s    !Jc         C  s}  t  |  t ƒ rK |  j d j rD d |  j d g |  j d } } q] |  Sn |  j ƒ  \ } } d } x| d t | ƒ k  ri| | | d !\ } } t  | t ƒ rØ t  | t ƒ rØ | j | ƒ | | <| j | d ƒ qf t  | t ƒ r| j t | g g ƒ ƒ | | <| j | d ƒ qf t  | t ƒ r\t | g g ƒ j | ƒ | | <| j | d ƒ qf | d 7} qf Wt	 | | Œ j
 ƒ  S(   Ni   i    i   (   R5   R   R&   t
   is_Integert   as_coeff_matricesR]   R    R8   t   popR   Rn   (   Rk   R„   R;   R/   RB   RC   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRq   \  s&    %c         C  s"   t  t |  j ƒ j j t ƒ j ƒ S(   N(   R    R|   R   R)   t	   applyfuncR   t   T(   Rk   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRs   u  s    c         C  s5   t  |  ƒ } |  | k r | St t t |  j ƒ ƒ ƒ S(   N(   t   blockinverse_1x1t   blockinverse_2x2R   t   reblock_2x2R   (   Rk   t   expr2(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRt   y  s    c         C  sT   t  |  j t ƒ rP |  j j d k rP t |  j j d j ƒ  g g ƒ } t | ƒ S|  S(   Ni   i    (   i   i   (   R5   R   R    R0   R   R)   Rd   (   Rk   R'   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRŠ     s    $"
c         C  sÌ   t  |  j t ƒ rÄ |  j j d k rÄ |  j j j ƒ  \ \ } } \ } } t | | | j | j | j | | | | j | j g | | | j | j | | j | | | j | j g g ƒ S|  Sd  S(   Ni   (   i   i   (   R5   R   R    R0   R)   R?   RA   (   Rk   RB   RC   RD   RE   (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyR‹   …  s
    $$<@c           s4  t  |  t ƒ s# |  j j t ƒ r' |  Sd „  } |  j j | ƒ ‰  d d l m } yÉ | d t ‡  f d †  t ˆ  j	 d ƒ Dƒ ƒ g  ƒ } xƒ t d ˆ  j	 d ƒ D]k } | ˆ  | d f j ƒ } x: t d ˆ  j	 d ƒ D]" } | j
 ˆ  | | f j ƒ } q× W| j | ƒ } q¡ Wt | ƒ SWn t k
 r/|  SXd S(   s(    Flatten a BlockMatrix of BlockMatrices c         S  s#   t  |  t ƒ r |  St |  g g ƒ S(   N(   R5   R    (   t   x(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRl   ”  Rm   iÿÿÿÿ(   R   i    c         3  s)   |  ] } ˆ  d  | f j  j d Vq d S(   i    i   N(   R)   R*   (   R_   R/   (   t   bb(    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pys	   <genexpr>™  s    i   N(   R5   R    R)   Rj   Rˆ   t   sympyR   Ra   R   R*   t   row_joint   col_joinR   (   RC   t   wrapR   t   MMt   rowR.   t   col(    (   R   sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRv     s    #	5 c         C  s«   t  |  t ƒ s- t d „  |  j j Dƒ ƒ r1 |  St } | |  j d | |  j d d d … f ƒ g | |  j d d … d f ƒ | |  j d d … d d … f ƒ g g ƒ S(   sC    Reblock a BlockMatrix so that it has 2x2 blocks of block matrices c         s  s   |  ] } | d  k Vq d S(   i   N(    (   R_   t   d(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pys	   <genexpr>¨  s    i    i   N(   i    i    (   R5   R    R~   R)   R*   (   RC   t   BM(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyRŒ   ¦  s
    -,c         C  sB   d } g  } x/ |  D]' } | j  | | | f ƒ | | 7} q W| S(   s½    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)]
    i    (   t   append(   t   sizest   lowt   rvt   size(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   bounds°  s    c      	   C  sT   t  | ƒ } t  | ƒ } t g  | D]+ } g  | D] } t |  | | ƒ ^ q/ ^ q" ƒ S(   s   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]])
    (   Rž   R    R   (   Rk   t   rowsizest   colsizest	   rowboundst	   colboundst   rowboundt   colbound(    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   blockcut¾  s    N(B   t
   __future__R    R   R   R   R   t
   sympy.coreR   R   R   t   sympy.core.compatibilityR   t   sympy.strategiesR   R	   R
   R   R   t   sympy.strategies.traverseR   t   sympy.utilitiesR   t"   sympy.matrices.expressions.matexprR   R   R   t!   sympy.matrices.expressions.matmulR   t!   sympy.matrices.expressions.mataddR   t!   sympy.matrices.expressions.matpowR   t$   sympy.matrices.expressions.transposeR   R   t    sympy.matrices.expressions.traceR   t&   sympy.matrices.expressions.determinantR   R   t    sympy.matrices.expressions.sliceR   t"   sympy.matrices.expressions.inverseR   t   sympy.matricesR   R   t$   sympy.functions.elementary.complexesR   R   R    RZ   R|   Ru   Ro   Rp   Rr   Rq   Rs   Rt   RŠ   R‹   Rv   RŒ   Rž   R¥   (    (    (    sE   lib/python2.7/site-packages/sympy/matrices/expressions/blockmatrix.pyt   <module>   sB   (°D	&				
							
	