o
    8Va0O                     @   s  d dl Z d dl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 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mZ dd Z G dd deZ!dd Z"G dd de!eZ#e# Z$Z%e&fddZ'e&fddZ(dd Z)dd Z*d d! Z+ed"d#d$d% Z,dBd'd(Z-d)d* Z.d&d+d,d-d.Z/dCd/d0Z0g fd1d2Z1d3d4 Z2d5d6 Z3d7d8 Z4	+	dDd;d<Z5dEd>d?Z6d@dA Z7dS )F    N)Basic)is_sequence)Symbol)sympify)cossin)simplify)doctest_depends_on)SymPyDeprecationWarning   )
ShapeError)	_cholesky_LDLdecomposition)
MatrixBase)MutableRepMatrix	RepMatrix)_lower_triangular_solve_upper_triangular_solvec                 C   s   | j S )zReturns True if x is zero.)Zis_zero)x r   6/usr/lib/python3/dist-packages/sympy/matrices/dense.py_iszero   s   r   c                   @   s   e Zd ZdZdZdZdZedd Zdd Z	d	d
 Z
dd ZdddZdddZdd Zdd Zeje_eje_eje_eje_dS )DenseMatrixzJMatrix implementation based on DomainMatrix as the internal representationFgQ$@   c                 C   s   t ddddd  |  S )Nz$The private _mat attribute of Matrixzthe .flat() methodiT  z1.9)ZfeatureZ
useinsteadZissueZdeprecated_since_version)r
   warnZflatselfr   r   r   _mat&   s   zDenseMatrix._matc                 K   s(   | j |dd|dt|dddS )NmethodZGE
iszerofunctry_block_diagF)r   r   r    )invgetr   )r   kwargsr   r   r   _eval_inverse1   s   

zDenseMatrix._eval_inversec                 C   s   ddl m} || j S )z4Returns an Immutable version of this Matrix
        r   )ImmutableDenseMatrix)Z	immutabler%   Z_fromrepZ_repcopy)r   clsr   r   r   as_immutable6   s   zDenseMatrix.as_immutablec                 C   s   t | S )aB  Returns a mutable version of this matrix

        Examples
        ========

        >>> from sympy import ImmutableMatrix
        >>> X = ImmutableMatrix([[1, 2], [3, 4]])
        >>> Y = X.as_mutable()
        >>> Y[1, 1] = 5 # Can set values in Y
        >>> Y
        Matrix([
        [1, 2],
        [3, 5]])
        )Matrixr   r   r   r   
as_mutable<   s   zDenseMatrix.as_mutableTc                 C      t | |dS N)	hermitian)r   r   r-   r   r   r   choleskyM      zDenseMatrix.choleskyc                 C   r+   r,   )r   r.   r   r   r   LDLdecompositionP   r0   zDenseMatrix.LDLdecompositionc                 C   
   t | |S N)r   r   Zrhsr   r   r   lower_triangular_solveS      
z"DenseMatrix.lower_triangular_solvec                 C   r2   r3   )r   r4   r   r   r   upper_triangular_solveV   r6   z"DenseMatrix.upper_triangular_solveNT)__name__
__module____qualname____doc__Zis_MatrixExprZ_op_priorityZ_class_prioritypropertyr   r$   r(   r*   r/   r1   r5   r7   r   r   r   r   r   r   r   r   r      s$    



r   c                 C   sV   t | ddr
|  S t| tr| S t| dr)|  }t|jdkr%t|S t	| S | S )z0Return a matrix as a Matrix, otherwise return x.Z	is_MatrixF	__array__r   )
getattrr*   
isinstancer   hasattrr>   lenshaper   r)   )r   ar   r   r   _force_mutable_   s   

rE   c                   @   s   e Zd Zdd ZdS )MutableDenseMatrixc                 K   s6   |    D ]\\}}}t|fi || ||f< qdS )zApplies simplify to the elements of a matrix in place.

        This is a shortcut for M.applyfunc(lambda x: simplify(x, ratio, measure))

        See Also
        ========

        sympy.simplify.simplify.simplify
        N)Ztodokitems	_simplify)r   r#   ijelementr   r   r   r   o   s   
zMutableDenseMatrix.simplifyN)r9   r:   r;   r   r   r   r   r   rF   m   s    rF   c                 C   s8   ddl m} |t| |}t| D ]\}}|||< q|S )zmConverts python list of SymPy expressions to a NumPy array.

    See Also
    ========

    matrix2numpy
    r   empty)numpyrM   rB   	enumerate)ldtyperM   rD   rI   sr   r   r   
list2numpy   s
   
rS   c                 C   sP   ddl m} || j|}t| jD ]}t| jD ]}| ||f |||f< qq|S )zYConverts SymPy's matrix to a NumPy array.

    See Also
    ========

    list2numpy
    r   rL   )rN   rM   rC   rangeZrowscols)mrQ   rM   rD   rI   rJ   r   r   r   matrix2numpy   s   rW   c                 C   s0   t | }t| }||df| |dfdf}t|S )a  Returns a rotation matrix for a rotation of theta (in radians) about
    the 3-axis.

    Examples
    ========

    >>> from sympy import pi
    >>> from sympy.matrices import rot_axis3

    A rotation of pi/3 (60 degrees):

    >>> theta = pi/3
    >>> rot_axis3(theta)
    Matrix([
    [       1/2, sqrt(3)/2, 0],
    [-sqrt(3)/2,       1/2, 0],
    [         0,         0, 1]])

    If we rotate by pi/2 (90 degrees):

    >>> rot_axis3(pi/2)
    Matrix([
    [ 0, 1, 0],
    [-1, 0, 0],
    [ 0, 0, 1]])

    See Also
    ========

    rot_axis1: Returns a rotation matrix for a rotation of theta (in radians)
        about the 1-axis
    rot_axis2: Returns a rotation matrix for a rotation of theta (in radians)
        about the 2-axis
    r   )r   r   r   r   r   r)   ZthetaZctstZlilr   r   r   	rot_axis3   s   #
r[   c                 C   s0   t | }t| }|d| fd|d|ff}t|S )a  Returns a rotation matrix for a rotation of theta (in radians) about
    the 2-axis.

    Examples
    ========

    >>> from sympy import pi
    >>> from sympy.matrices import rot_axis2

    A rotation of pi/3 (60 degrees):

    >>> theta = pi/3
    >>> rot_axis2(theta)
    Matrix([
    [      1/2, 0, -sqrt(3)/2],
    [        0, 1,          0],
    [sqrt(3)/2, 0,        1/2]])

    If we rotate by pi/2 (90 degrees):

    >>> rot_axis2(pi/2)
    Matrix([
    [0, 0, -1],
    [0, 1,  0],
    [1, 0,  0]])

    See Also
    ========

    rot_axis1: Returns a rotation matrix for a rotation of theta (in radians)
        about the 1-axis
    rot_axis3: Returns a rotation matrix for a rotation of theta (in radians)
        about the 3-axis
    r   )r   r   r   rX   rY   r   r   r   	rot_axis2   s   #
r\   c                 C   s0   t | }t| }dd||fd| |ff}t|S )a  Returns a rotation matrix for a rotation of theta (in radians) about
    the 1-axis.

    Examples
    ========

    >>> from sympy import pi
    >>> from sympy.matrices import rot_axis1

    A rotation of pi/3 (60 degrees):

    >>> theta = pi/3
    >>> rot_axis1(theta)
    Matrix([
    [1,          0,         0],
    [0,        1/2, sqrt(3)/2],
    [0, -sqrt(3)/2,       1/2]])

    If we rotate by pi/2 (90 degrees):

    >>> rot_axis1(pi/2)
    Matrix([
    [1,  0, 0],
    [0,  0, 1],
    [0, -1, 0]])

    See Also
    ========

    rot_axis2: Returns a rotation matrix for a rotation of theta (in radians)
        about the 2-axis
    rot_axis3: Returns a rotation matrix for a rotation of theta (in radians)
        about the 3-axis
    )r   r   r   r   rX   rY   r   r   r   	rot_axis1   s   #
r]   )rN   )modulesc              	   K   sV   ddl m}m} ||td}||D ]}td| dtt|f fi |||< q|S )aI  Create a numpy ndarray of symbols (as an object array).

    The created symbols are named ``prefix_i1_i2_``...  You should thus provide a
    non-empty prefix if you want your symbols to be unique for different output
    arrays, as SymPy symbols with identical names are the same object.

    Parameters
    ----------

    prefix : string
      A prefix prepended to the name of every symbol.

    shape : int or tuple
      Shape of the created array.  If an int, the array is one-dimensional; for
      more than one dimension the shape must be a tuple.

    \*\*kwargs : dict
      keyword arguments passed on to Symbol

    Examples
    ========
    These doctests require numpy.

    >>> from sympy import symarray
    >>> symarray('', 3)
    [_0 _1 _2]

    If you want multiple symarrays to contain distinct symbols, you *must*
    provide unique prefixes:

    >>> a = symarray('', 3)
    >>> b = symarray('', 3)
    >>> a[0] == b[0]
    True
    >>> a = symarray('a', 3)
    >>> b = symarray('b', 3)
    >>> a[0] == b[0]
    False

    Creating symarrays with a prefix:

    >>> symarray('a', 3)
    [a_0 a_1 a_2]

    For more than one dimension, the shape must be given as a tuple:

    >>> symarray('a', (2, 3))
    [[a_0_0 a_0_1 a_0_2]
     [a_1_0 a_1_1 a_1_2]]
    >>> symarray('a', (2, 3, 2))
    [[[a_0_0_0 a_0_0_1]
      [a_0_1_0 a_0_1_1]
      [a_0_2_0 a_0_2_1]]
    <BLANKLINE>
     [[a_1_0_0 a_1_0_1]
      [a_1_1_0 a_1_1_1]
      [a_1_2_0 a_1_2_1]]]

    For setting assumptions of the underlying Symbols:

    >>> [s.is_real for s in symarray('a', 2, real=True)]
    [True, True]
    r   )rM   ndindex)rQ   z%s_%s_)rN   rM   r_   objectr   joinmapstr)prefixrC   r#   rM   r_   Zarrindexr   r   r   symarray%  s   Arg   Tc                    sH   t tt|s fdd}n fdd}t}t||| S )aY  Given linear difference operator L of order 'k' and homogeneous
       equation Ly = 0 we want to compute kernel of L, which is a set
       of 'k' sequences: a(n), b(n), ... z(n).

       Solutions of L are linearly independent iff their Casoratian,
       denoted as C(a, b, ..., z), do not vanish for n = 0.

       Casoratian is defined by k x k determinant::

                  +  a(n)     b(n)     . . . z(n)     +
                  |  a(n+1)   b(n+1)   . . . z(n+1)   |
                  |    .         .     .        .     |
                  |    .         .       .      .     |
                  |    .         .         .    .     |
                  +  a(n+k-1) b(n+k-1) . . . z(n+k-1) +

       It proves very useful in rsolve_hyper() where it is applied
       to a generating set of a recurrence to factor out linearly
       dependent solutions and return a basis:

       >>> from sympy import Symbol, casoratian, factorial
       >>> n = Symbol('n', integer=True)

       Exponential and factorial are linearly independent:

       >>> casoratian([2**n, factorial(n)], n) != 0
       True

    c                    s   |    |  S r3   ZsubsrI   rJ   nseqsr   r   <lambda>  s    zcasoratian.<locals>.<lambda>c                    s   |   | S r3   rh   ri   rj   r   r   rm         )listrc   r   rB   r)   det)rl   rk   Zzerofkr   rj   r   
casoratianr  s   rs   c                  O   s   t j| i |S )z`Create square identity matrix n x n

    See Also
    ========

    diag
    zeros
    ones
    )r)   eyeargsr#   r   r   r   rt     s   rt   Fstrictunpackc                 O   s   t j|| |d|S )a]  Returns a matrix with the provided values placed on the
    diagonal. If non-square matrices are included, they will
    produce a block-diagonal matrix.

    Examples
    ========

    This version of diag is a thin wrapper to Matrix.diag that differs
    in that it treats all lists like matrices -- even when a single list
    is given. If this is not desired, either put a `*` before the list or
    set `unpack=True`.

    >>> from sympy import diag

    >>> diag([1, 2, 3], unpack=True)  # = diag(1,2,3) or diag(*[1,2,3])
    Matrix([
    [1, 0, 0],
    [0, 2, 0],
    [0, 0, 3]])

    >>> diag([1, 2, 3])  # a column vector
    Matrix([
    [1],
    [2],
    [3]])

    See Also
    ========
    .common.MatrixCommon.eye
    .common.MatrixCommon.diagonal - to extract a diagonal
    .common.MatrixCommon.diag
    .expressions.blockmatrix.BlockMatrix
    rw   )r)   diag)rx   ry   valuesr#   r   r   r   rz     s   "rz   c                 C   s   t j| |ddS )a  Apply the Gram-Schmidt process to a set of vectors.

    Parameters
    ==========

    vlist : List of Matrix
        Vectors to be orthogonalized for.

    orthonormal : Bool, optional
        If true, return an orthonormal basis.

    Returns
    =======

    vlist : List of Matrix
        Orthogonalized vectors

    Notes
    =====

    This routine is mostly duplicate from ``Matrix.orthogonalize``,
    except for some difference that this always raises error when
    linearly dependent vectors are found, and the keyword ``normalize``
    has been named as ``orthonormal`` in this function.

    See Also
    ========

    .matrices.MatrixSubspaces.orthogonalize

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process
    T)	normalizeZ	rankcheck)rF   Zorthogonalize)ZvlistZorthonormalr   r   r   GramSchmidt  s   $r}   c                 C   s\  t |trd|jvrtd|jdkr|j}| d }t|r+t|}|s*tdnt	dt
| ds:t	d|  t|}|| }t|}t|D ]#\}}t
|dsYt	d|  t|D ]}	|||	 |||	| f< q]qJt|D ]}	t|	|D ]}
| ||	 ||
 ||	| |
| f< qyqrt|D ]}	t|	d |D ]}
||	|
f ||
|	f< qq|S )a  Compute Hessian matrix for a function f wrt parameters in varlist
    which may be given as a sequence or a row/column vector. A list of
    constraints may optionally be given.

    Examples
    ========

    >>> from sympy import Function, hessian, pprint
    >>> from sympy.abc import x, y
    >>> f = Function('f')(x, y)
    >>> g1 = Function('g')(x, y)
    >>> g2 = x**2 + 3*y
    >>> pprint(hessian(f, (x, y), [g1, g2]))
    [                   d               d            ]
    [     0        0    --(g(x, y))     --(g(x, y))  ]
    [                   dx              dy           ]
    [                                                ]
    [     0        0        2*x              3       ]
    [                                                ]
    [                     2               2          ]
    [d                   d               d           ]
    [--(g(x, y))  2*x   ---(f(x, y))   -----(f(x, y))]
    [dx                   2            dy dx         ]
    [                   dx                           ]
    [                                                ]
    [                     2               2          ]
    [d                   d               d           ]
    [--(g(x, y))   3   -----(f(x, y))   ---(f(x, y)) ]
    [dy                dy dx              2          ]
    [                                   dy           ]

    References
    ==========

    https://en.wikipedia.org/wiki/Hessian_matrix

    See Also
    ========

    sympy.matrices.matrices.MatrixCalculus.jacobian
    wronskian
    r   z)`varlist` must be a column or row vector.r   z `len(varlist)` must not be zero.z*Improper variable list in hessian functiondiffz'Function `f` (%s) is not differentiable)r@   r   rC   r   rU   Ttolistr   rB   
ValueErrorr?   zerosrO   rT   r~   )rq   ZvarlistZconstraintsrk   rV   Noutrr   grI   rJ   r   r   r   hessian  s@   
,



*r   c                 C   s   t j|| dS )z
    Create a Jordan block:

    Examples
    ========

    >>> from sympy.matrices import jordan_cell
    >>> from sympy.abc import x
    >>> jordan_cell(x, 4)
    Matrix([
    [x, 1, 0, 0],
    [0, x, 1, 0],
    [0, 0, x, 1],
    [0, 0, 0, x]])
    )sizeZ
eigenvalue)r)   Zjordan_block)Zeigenvalrk   r   r   r   jordan_cellF  s   r   c                 C   s
   |  |S )a  Return the Hadamard product (elementwise product) of A and B

    >>> from sympy.matrices import matrix_multiply_elementwise
    >>> from sympy.matrices import Matrix
    >>> A = Matrix([[0, 1, 2], [3, 4, 5]])
    >>> B = Matrix([[1, 10, 100], [100, 10, 1]])
    >>> matrix_multiply_elementwise(A, B)
    Matrix([
    [  0, 10, 200],
    [300, 40,   5]])

    See Also
    ========

    sympy.matrices.common.MatrixCommon.__mul__
    )Zmultiply_elementwise)ABr   r   r   matrix_multiply_elementwiseZ  s   
r   c                  O   &   d|v r| d|d< tj| i |S )zReturns a matrix of ones with ``rows`` rows and ``cols`` columns;
    if ``cols`` is omitted a square matrix will be returned.

    See Also
    ========

    zeros
    eye
    diag
    crU   )popr)   onesru   r   r   r   r   n     r   c   d   c                 C   s   |pt |}|du r| }|r| |krtd| |f t| | }|dkr3||tt|| d }t| |}	|sR|D ]}
t|
|\}}|	|||	||f< q<|	S |D ]}
t|
|\}}||krq|	|| |	||f< |	||f< qT|	S )a  Create random matrix with dimensions ``r`` x ``c``. If ``c`` is omitted
    the matrix will be square. If ``symmetric`` is True the matrix must be
    square. If ``percent`` is less than 100 then only approximately the given
    percentage of elements will be non-zero.

    The pseudo-random number generator used to generate matrix is chosen in the
    following way.

    * If ``prng`` is supplied, it will be used as random number generator.
      It should be an instance of ``random.Random``, or at least have
      ``randint`` and ``shuffle`` methods with same signatures.
    * if ``prng`` is not supplied but ``seed`` is supplied, then new
      ``random.Random`` with given ``seed`` will be created;
    * otherwise, a new ``random.Random`` with default seed will be used.

    Examples
    ========

    >>> from sympy.matrices import randMatrix
    >>> randMatrix(3) # doctest:+SKIP
    [25, 45, 27]
    [44, 54,  9]
    [23, 96, 46]
    >>> randMatrix(3, 2) # doctest:+SKIP
    [87, 29]
    [23, 37]
    [90, 26]
    >>> randMatrix(3, 3, 0, 2) # doctest:+SKIP
    [0, 2, 0]
    [2, 0, 1]
    [0, 0, 1]
    >>> randMatrix(3, symmetric=True) # doctest:+SKIP
    [85, 26, 29]
    [26, 71, 43]
    [29, 43, 57]
    >>> A = randMatrix(3, seed=1)
    >>> B = randMatrix(3, seed=2)
    >>> A == B
    False
    >>> A == randMatrix(3, seed=1)
    True
    >>> randMatrix(3, symmetric=True, percent=50) # doctest:+SKIP
    [77, 70,  0],
    [70,  0,  0],
    [ 0,  0, 88]
    Nz4For symmetric matrices, r must equal c, but %i != %ir   )
randomZRandomr   rT   ZsampleintrB   r   divmodZrandint)rr   minmaxZseedZ	symmetricpercentZprngZijrV   ZijkrI   rJ   r   r   r   
randMatrix  s(   1
 r   bareissc                    sX   t dt D ]
}t |  |< qt }|dkrdS t|| fdd}||S )ax  
    Compute Wronskian for [] of functions

    ::

                         | f1       f2        ...   fn      |
                         | f1'      f2'       ...   fn'     |
                         |  .        .        .      .      |
        W(f1, ..., fn) = |  .        .         .     .      |
                         |  .        .          .    .      |
                         |  (n)      (n)            (n)     |
                         | D   (f1) D   (f2)  ...  D   (fn) |

    see: https://en.wikipedia.org/wiki/Wronskian

    See Also
    ========

    sympy.matrices.matrices.MatrixCalculus.jacobian
    hessian
    r   r   c                    s    |   |S r3   )r~   ri   	functionsvarr   r   rm     rn   zwronskian.<locals>.<lambda>)rT   rB   r   r)   rp   )r   r   r   rf   rk   Wr   r   r   	wronskian  s   
r   c                  O   r   )zReturns a matrix of zeros with ``rows`` rows and ``cols`` columns;
    if ``cols`` is omitted a square matrix will be returned.

    See Also
    ========

    ones
    eye
    diag
    r   rU   )r   r)   r   ru   r   r   r   r     r   r   r8   )F)Nr   r   NFr   N)r   )8r   Zsympy.core.basicr   Zsympy.core.compatibilityr   Zsympy.core.symbolr   Zsympy.core.sympifyr   Z(sympy.functions.elementary.trigonometricr   r   Zsympy.simplify.simplifyr   rH   Zsympy.utilities.decoratorr	   Zsympy.utilities.exceptionsr
   commonr   Zdecompositionsr   r   Zmatricesr   Z	repmatrixr   r   Zsolversr   r   r   r   rE   rF   ZMutableMatrixr)   ra   rS   rW   r[   r\   r]   rg   rs   rt   rz   r}   r   r   r   r   r   r   r   r   r   r   r   <module>   sN    G+++

L+
%)M

L 