HEX

File: //usr/local/lib/python3.10/dist-packages/numpy/matrixlib/__pycache__/defmatrix.cpython-310.pyc
o

���g�w�@s�gd�ZddlZddlZddlZddlmZddlmmZ	ddlm
Z
mZddlm
Z
dd�Zed	�dd
d��Zed	�Gdd
�d
e	j��Zdd�Zed	�ddd��ZeZdS))�matrix�bmat�mat�asmatrix�N�)�
set_module)�concatenate�isscalar��matrix_powercCs�dD]}|�|d�}q|�d�}g}d}|D]7}|�d�}g}|D]}|��}	|�ttj|	��q!|dkr:t|�}
n
t|�|
krDtd��|d7}|�|�q|S)Nz[]��;r�,zRows not the same size.�)	�replace�split�extend�map�ast�literal_eval�len�
ValueError�append)�data�char�rows�newdata�count�row�trow�newrow�col�temp�Ncols�r$�D/usr/local/lib/python3.10/dist-packages/numpy/matrixlib/defmatrix.py�_convert_from_strings$


r&�numpycCst||dd�S)a@
    Interpret the input as a matrix.

    Unlike `matrix`, `asmatrix` does not make a copy if the input is already
    a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.

    Parameters
    ----------
    data : array_like
        Input data.
    dtype : data-type
       Data-type of the output matrix.

    Returns
    -------
    mat : matrix
        `data` interpreted as a matrix.

    Examples
    --------
    >>> x = np.array([[1, 2], [3, 4]])

    >>> m = np.asmatrix(x)

    >>> x[0,0] = 5

    >>> m
    matrix([[5, 2],
            [3, 4]])

    F��dtype�copy)r)rr)r$r$r%r%s!rc@sfeZdZdZdZdGdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZdHdd�ZdIdd �ZdJd"d#�ZdHd$d%�ZdKd'd(�ZdKd)d*�ZdHd+d,�ZdLd-d.�ZdLd/d0�ZdLd1d2�ZdLd3d4�ZdLd5d6�ZdLd7d8�ZdLd9d:�Zed;d<��Z ed=d>��Z!ed?d@��Z"dJdAdB�Z#edCdD��Z$edEdF��Z%e$j&Z'e!j&Z(e"j&Z)e%j&Z*e j&Z+dS)Mra�
    matrix(data, dtype=None, copy=True)

    .. note:: It is no longer recommended to use this class, even for linear
              algebra. Instead use regular arrays. The class may be removed
              in the future.

    Returns a matrix from an array-like object, or from a string of data.
    A matrix is a specialized 2-D array that retains its 2-D nature
    through operations.  It has certain special operators, such as ``*``
    (matrix multiplication) and ``**`` (matrix power).

    Parameters
    ----------
    data : array_like or string
       If `data` is a string, it is interpreted as a matrix with commas
       or spaces separating columns, and semicolons separating rows.
    dtype : data-type
       Data-type of the output matrix.
    copy : bool
       If `data` is already an `ndarray`, then this flag determines
       whether the data is copied (the default), or whether a view is
       constructed.

    See Also
    --------
    array

    Examples
    --------
    >>> a = np.matrix('1 2; 3 4')
    >>> a
    matrix([[1, 2],
            [3, 4]])

    >>> np.matrix([[1, 2], [3, 4]])
    matrix([[1, 2],
            [3, 4]])

    g$@NTcCsBtjdtdd�t|t�r#|j}|dur|}||kr|s|S|�|�St|tj�rM|dur1|j}nt�|�}|�	|�}||jkrE|�|�S|rK|�
�S|St|t�rVt|�}tj
|||d�}|j}|j}	|dkrltd��|dkrsd}	n
|dkr}d|	df}	d	}
|dkr�|jjr�d
}
|
s�|jjs�|�
�}tjj||	|j||
d�}|S)Nz�the matrix subclass is not the recommended way to represent matrices or deal with linear algebra (see https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html). Please adjust your code to use regular ndarray.r)�
stacklevelr(zmatrix must be 2-dimensionalr�rrr�C�F)�buffer�order)�warnings�warn�PendingDeprecationWarning�
isinstancerr)�astype�N�ndarray�viewr*�strr&�array�ndim�shaper�flags�fortran�
contiguous�__new__)�subtyperr)r*�dtype2�intype�new�arrr;r<r0�retr$r$r%r@tsP�






�zmatrix.__new__cCs�d|_t|t�r
|jr
dS|j}|dkrdS|dkr:tdd�|jD��}t|�}|dkr1||_dS|dkr9td��n|j}|dkrFd|_dS|dkrQd|df|_dS)	NFrcSsg|]}|dkr|�qS)rr$)�.0�xr$r$r%�
<listcomp>�sz-matrix.__array_finalize__.<locals>.<listcomp>zshape too large to be a matrix.rr,r)�_getitemr4rr;�tupler<rr)�self�objr;�newshaper$r$r%�__array_finalize__�s*��zmatrix.__array_finalize__cCs�d|_ztj�||�}Wd|_nd|_wt|tj�s|S|jdkr%|dS|jdkrW|jd}zt|�}Wnty@d}Ynw|dkrRt	|d�rR|df|_|Sd|f|_|S)NTFrr$r)
rJr6r7�__getitem__r4r;r<r�	Exceptionr	)rL�index�out�sh�nr$r$r%rP�s(


�

�zmatrix.__getitem__cCsDt|tjttf�rt�|t|��St|�st|d�s t�||�St	S)N�__rmul__)
r4r6r7�listrK�dotrr	�hasattr�NotImplemented�rL�otherr$r$r%�__mul__�s
zmatrix.__mul__cCst�||�S�N)r6rXr[r$r$r%rV�szmatrix.__rmul__cCs|||dd�<|Sr^r$r[r$r$r%�__imul__��zmatrix.__imul__cCs
t||�Sr^r
r[r$r$r%�__pow__�s
zmatrix.__pow__cCs|||dd�<|Sr^r$r[r$r$r%�__ipow__�r`zmatrix.__ipow__cCstSr^)rZr[r$r$r%�__rpow__�szmatrix.__rpow__cCs4|dur|dS|dkr|S|dkr|��Std��)z^A convenience function for operations that need to preserve axis
        orientation.
        N�rrrrzunsupported axis)�	transposer�rL�axisr$r$r%�_align�sz
matrix._aligncCs|dur|dS|S)z�A convenience function for operations that want to collapse
        to a scalar like _align, but are using keepdims=True
        Nrdr$rfr$r$r%�	_collapse�szmatrix._collapsecC�|����S)a�
        Return the matrix as a (possibly nested) list.

        See `ndarray.tolist` for full documentation.

        See Also
        --------
        ndarray.tolist

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.tolist()
        [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]

        )�	__array__�tolist�rLr$r$r%rl	sz
matrix.tolistcC�tjj||||dd��|�S)a
        Returns the sum of the matrix elements, along the given axis.

        Refer to `numpy.sum` for full documentation.

        See Also
        --------
        numpy.sum

        Notes
        -----
        This is the same as `ndarray.sum`, except that where an `ndarray` would
        be returned, a `matrix` object is returned instead.

        Examples
        --------
        >>> x = np.matrix([[1, 2], [4, 3]])
        >>> x.sum()
        10
        >>> x.sum(axis=1)
        matrix([[3],
                [7]])
        >>> x.sum(axis=1, dtype='float')
        matrix([[3.],
                [7.]])
        >>> out = np.zeros((2, 1), dtype='float')
        >>> x.sum(axis=1, dtype='float', out=np.asmatrix(out))
        matrix([[3.],
                [7.]])

        T��keepdims)r6r7�sumri�rLrgr)rSr$r$r%rq � z
matrix.sumcC�tjj||d�S)aD
        Return a possibly reshaped matrix.

        Refer to `numpy.squeeze` for more documentation.

        Parameters
        ----------
        axis : None or int or tuple of ints, optional
            Selects a subset of the axes of length one in the shape.
            If an axis is selected with shape entry greater than one,
            an error is raised.

        Returns
        -------
        squeezed : matrix
            The matrix, but as a (1, N) matrix if it had shape (N, 1).

        See Also
        --------
        numpy.squeeze : related function

        Notes
        -----
        If `m` has a single column then that column is returned
        as the single row of a matrix.  Otherwise `m` is returned.
        The returned matrix is always either `m` itself or a view into `m`.
        Supplying an axis keyword argument will not affect the returned matrix
        but it may cause an error to be raised.

        Examples
        --------
        >>> c = np.matrix([[1], [2]])
        >>> c
        matrix([[1],
                [2]])
        >>> c.squeeze()
        matrix([[1, 2]])
        >>> r = c.T
        >>> r
        matrix([[1, 2]])
        >>> r.squeeze()
        matrix([[1, 2]])
        >>> m = np.matrix([[1, 2], [3, 4]])
        >>> m.squeeze()
        matrix([[1, 2],
                [3, 4]])

        �rg)r6r7�squeezerfr$r$r%rvDs1zmatrix.squeezer-cCrt)aD
        Return a flattened copy of the matrix.

        All `N` elements of the matrix are placed into a single row.

        Parameters
        ----------
        order : {'C', 'F', 'A', 'K'}, optional
            'C' means to flatten in row-major (C-style) order. 'F' means to
            flatten in column-major (Fortran-style) order. 'A' means to
            flatten in column-major order if `m` is Fortran *contiguous* in
            memory, row-major order otherwise. 'K' means to flatten `m` in
            the order the elements occur in memory. The default is 'C'.

        Returns
        -------
        y : matrix
            A copy of the matrix, flattened to a `(1, N)` matrix where `N`
            is the number of elements in the original matrix.

        See Also
        --------
        ravel : Return a flattened array.
        flat : A 1-D flat iterator over the matrix.

        Examples
        --------
        >>> m = np.matrix([[1,2], [3,4]])
        >>> m.flatten()
        matrix([[1, 2, 3, 4]])
        >>> m.flatten('F')
        matrix([[1, 3, 2, 4]])

        �r0)r6r7�flatten�rLr0r$r$r%rxys#zmatrix.flattencCrn)a�
        Returns the average of the matrix elements along the given axis.

        Refer to `numpy.mean` for full documentation.

        See Also
        --------
        numpy.mean

        Notes
        -----
        Same as `ndarray.mean` except that, where that returns an `ndarray`,
        this returns a `matrix` object.

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3, 4)))
        >>> x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.mean()
        5.5
        >>> x.mean(0)
        matrix([[4., 5., 6., 7.]])
        >>> x.mean(1)
        matrix([[ 1.5],
                [ 5.5],
                [ 9.5]])

        Tro)r6r7�meanrirrr$r$r%rz�rszmatrix.meanrcC�tjj|||||dd��|�S)aU
        Return the standard deviation of the array elements along the given axis.

        Refer to `numpy.std` for full documentation.

        See Also
        --------
        numpy.std

        Notes
        -----
        This is the same as `ndarray.std`, except that where an `ndarray` would
        be returned, a `matrix` object is returned instead.

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3, 4)))
        >>> x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.std()
        3.4520525295346629 # may vary
        >>> x.std(0)
        matrix([[ 3.26598632,  3.26598632,  3.26598632,  3.26598632]]) # may vary
        >>> x.std(1)
        matrix([[ 1.11803399],
                [ 1.11803399],
                [ 1.11803399]])

        Tro)r6r7�stdri�rLrgr)rS�ddofr$r$r%r|�� z
matrix.stdcCr{)a2
        Returns the variance of the matrix elements, along the given axis.

        Refer to `numpy.var` for full documentation.

        See Also
        --------
        numpy.var

        Notes
        -----
        This is the same as `ndarray.var`, except that where an `ndarray` would
        be returned, a `matrix` object is returned instead.

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3, 4)))
        >>> x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.var()
        11.916666666666666
        >>> x.var(0)
        matrix([[ 10.66666667,  10.66666667,  10.66666667,  10.66666667]]) # may vary
        >>> x.var(1)
        matrix([[1.25],
                [1.25],
                [1.25]])

        Tro)r6r7�varrir}r$r$r%r��rz
matrix.varcCrn)a�
        Return the product of the array elements over the given axis.

        Refer to `prod` for full documentation.

        See Also
        --------
        prod, ndarray.prod

        Notes
        -----
        Same as `ndarray.prod`, except, where that returns an `ndarray`, this
        returns a `matrix` object instead.

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.prod()
        0
        >>> x.prod(0)
        matrix([[  0,  45, 120, 231]])
        >>> x.prod(1)
        matrix([[   0],
                [ 840],
                [7920]])

        Tro)r6r7�prodrirrr$r$r%r�szmatrix.prodcC�tjj|||dd��|�S)aG
        Test whether any array element along a given axis evaluates to True.

        Refer to `numpy.any` for full documentation.

        Parameters
        ----------
        axis : int, optional
            Axis along which logical OR is performed
        out : ndarray, optional
            Output to existing array instead of creating new one, must have
            same shape as expected output

        Returns
        -------
            any : bool, ndarray
                Returns a single bool if `axis` is ``None``; otherwise,
                returns `ndarray`

        Tro)r6r7�anyri�rLrgrSr$r$r%r�%sz
matrix.anycCr�)a�
        Test whether all matrix elements along a given axis evaluate to True.

        Parameters
        ----------
        See `numpy.all` for complete descriptions

        See Also
        --------
        numpy.all

        Notes
        -----
        This is the same as `ndarray.all`, but it returns a `matrix` object.

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> y = x[0]; y
        matrix([[0, 1, 2, 3]])
        >>> (x == y)
        matrix([[ True,  True,  True,  True],
                [False, False, False, False],
                [False, False, False, False]])
        >>> (x == y).all()
        False
        >>> (x == y).all(0)
        matrix([[False, False, False, False]])
        >>> (x == y).all(1)
        matrix([[ True],
                [False],
                [False]])

        Tro)r6r7�allrir�r$r$r%r�<s&z
matrix.allcCr�)a�
        Return the maximum value along an axis.

        Parameters
        ----------
        See `amax` for complete descriptions

        See Also
        --------
        amax, ndarray.max

        Notes
        -----
        This is the same as `ndarray.max`, but returns a `matrix` object
        where `ndarray.max` would return an ndarray.

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.max()
        11
        >>> x.max(0)
        matrix([[ 8,  9, 10, 11]])
        >>> x.max(1)
        matrix([[ 3],
                [ 7],
                [11]])

        Tro)r6r7�maxrir�r$r$r%r�d�!z
matrix.maxcC�tj�|||��|�S)a�
        Indexes of the maximum values along an axis.

        Return the indexes of the first occurrences of the maximum values
        along the specified axis.  If axis is None, the index is for the
        flattened matrix.

        Parameters
        ----------
        See `numpy.argmax` for complete descriptions

        See Also
        --------
        numpy.argmax

        Notes
        -----
        This is the same as `ndarray.argmax`, but returns a `matrix` object
        where `ndarray.argmax` would return an `ndarray`.

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.argmax()
        11
        >>> x.argmax(0)
        matrix([[2, 2, 2, 2]])
        >>> x.argmax(1)
        matrix([[3],
                [3],
                [3]])

        )r6r7�argmaxrhr�r$r$r%r���%z
matrix.argmaxcCr�)a�
        Return the minimum value along an axis.

        Parameters
        ----------
        See `amin` for complete descriptions.

        See Also
        --------
        amin, ndarray.min

        Notes
        -----
        This is the same as `ndarray.min`, but returns a `matrix` object
        where `ndarray.min` would return an ndarray.

        Examples
        --------
        >>> x = -np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[  0,  -1,  -2,  -3],
                [ -4,  -5,  -6,  -7],
                [ -8,  -9, -10, -11]])
        >>> x.min()
        -11
        >>> x.min(0)
        matrix([[ -8,  -9, -10, -11]])
        >>> x.min(1)
        matrix([[ -3],
                [ -7],
                [-11]])

        Tro)r6r7�minrir�r$r$r%r��r�z
matrix.mincCr�)a�
        Indexes of the minimum values along an axis.

        Return the indexes of the first occurrences of the minimum values
        along the specified axis.  If axis is None, the index is for the
        flattened matrix.

        Parameters
        ----------
        See `numpy.argmin` for complete descriptions.

        See Also
        --------
        numpy.argmin

        Notes
        -----
        This is the same as `ndarray.argmin`, but returns a `matrix` object
        where `ndarray.argmin` would return an `ndarray`.

        Examples
        --------
        >>> x = -np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[  0,  -1,  -2,  -3],
                [ -4,  -5,  -6,  -7],
                [ -8,  -9, -10, -11]])
        >>> x.argmin()
        11
        >>> x.argmin(0)
        matrix([[2, 2, 2, 2]])
        >>> x.argmin(1)
        matrix([[3],
                [3],
                [3]])

        )r6r7�argminrhr�r$r$r%r��r�z
matrix.argmincCr�)a�
        Peak-to-peak (maximum - minimum) value along the given axis.

        Refer to `numpy.ptp` for full documentation.

        See Also
        --------
        numpy.ptp

        Notes
        -----
        Same as `ndarray.ptp`, except, where that would return an `ndarray` object,
        this returns a `matrix` object.

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.ptp()
        11
        >>> x.ptp(0)
        matrix([[8, 8, 8, 8]])
        >>> x.ptp(1)
        matrix([[3],
                [3],
                [3]])

        )r6r7�ptprhr�r$r$r%r��sz
matrix.ptpcCs8|j\}}||krddlm}nddlm}t||��S)aI
        Returns the (multiplicative) inverse of invertible `self`.

        Parameters
        ----------
        None

        Returns
        -------
        ret : matrix object
            If `self` is non-singular, `ret` is such that ``ret * self`` ==
            ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return
            ``True``.

        Raises
        ------
        numpy.linalg.LinAlgError: Singular matrix
            If `self` is singular.

        See Also
        --------
        linalg.inv

        Examples
        --------
        >>> m = np.matrix('[1, 2; 3, 4]'); m
        matrix([[1, 2],
                [3, 4]])
        >>> m.getI()
        matrix([[-2. ,  1. ],
                [ 1.5, -0.5]])
        >>> m.getI() * m
        matrix([[ 1.,  0.], # may vary
                [ 0.,  1.]])

        r)�inv)�pinv)r<�numpy.linalgr�r�r)rL�Mr6�funcr$r$r%�Is

&zmatrix.IcC�|��S)a1
        Return `self` as an `ndarray` object.

        Equivalent to ``np.asarray(self)``.

        Parameters
        ----------
        None

        Returns
        -------
        ret : ndarray
            `self` as an `ndarray`

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.getA()
        array([[ 0,  1,  2,  3],
               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11]])

        )rkrmr$r$r%�AFszmatrix.AcCrj)a
        Return `self` as a flattened `ndarray`.

        Equivalent to ``np.asarray(x).ravel()``

        Parameters
        ----------
        None

        Returns
        -------
        ret : ndarray
            `self`, 1-D, as an `ndarray`

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
        matrix([[ 0,  1,  2,  3],
                [ 4,  5,  6,  7],
                [ 8,  9, 10, 11]])
        >>> x.getA1()
        array([ 0,  1,  2, ...,  9, 10, 11])


        )rk�ravelrmr$r$r%�A1dsz	matrix.A1cCrt)a	
        Return a flattened matrix.

        Refer to `numpy.ravel` for more documentation.

        Parameters
        ----------
        order : {'C', 'F', 'A', 'K'}, optional
            The elements of `m` are read using this index order. 'C' means to
            index the elements in C-like order, with the last axis index
            changing fastest, back to the first axis index changing slowest.
            'F' means to index the elements in Fortran-like index order, with
            the first index changing fastest, and the last index changing
            slowest. Note that the 'C' and 'F' options take no account of the
            memory layout of the underlying array, and only refer to the order
            of axis indexing.  'A' means to read the elements in Fortran-like
            index order if `m` is Fortran *contiguous* in memory, C-like order
            otherwise.  'K' means to read the elements in the order they occur
            in memory, except for reversing the data when strides are negative.
            By default, 'C' index order is used.

        Returns
        -------
        ret : matrix
            Return the matrix flattened to shape `(1, N)` where `N`
            is the number of elements in the original matrix.
            A copy is made only if necessary.

        See Also
        --------
        matrix.flatten : returns a similar output matrix but always a copy
        matrix.flat : a flat iterator on the array.
        numpy.ravel : related function which returns an ndarray

        rw)r6r7r�ryr$r$r%r��s$zmatrix.ravelcCr�)a@
        Returns the transpose of the matrix.

        Does *not* conjugate!  For the complex conjugate transpose, use ``.H``.

        Parameters
        ----------
        None

        Returns
        -------
        ret : matrix object
            The (non-conjugated) transpose of the matrix.

        See Also
        --------
        transpose, getH

        Examples
        --------
        >>> m = np.matrix('[1, 2; 3, 4]')
        >>> m
        matrix([[1, 2],
                [3, 4]])
        >>> m.getT()
        matrix([[1, 3],
                [2, 4]])

        )rermr$r$r%�T�szmatrix.TcCs$t|jjtj�r|����S|��S)a:
        Returns the (complex) conjugate transpose of `self`.

        Equivalent to ``np.transpose(self)`` if `self` is real-valued.

        Parameters
        ----------
        None

        Returns
        -------
        ret : matrix object
            complex conjugate transpose of `self`

        Examples
        --------
        >>> x = np.matrix(np.arange(12).reshape((3,4)))
        >>> z = x - 1j*x; z
        matrix([[  0. +0.j,   1. -1.j,   2. -2.j,   3. -3.j],
                [  4. -4.j,   5. -5.j,   6. -6.j,   7. -7.j],
                [  8. -8.j,   9. -9.j,  10.-10.j,  11.-11.j]])
        >>> z.getH()
        matrix([[ 0. -0.j,  4. +4.j,  8. +8.j],
                [ 1. +1.j,  5. +5.j,  9. +9.j],
                [ 2. +2.j,  6. +6.j, 10.+10.j],
                [ 3. +3.j,  7. +7.j, 11.+11.j]])

        )�
issubclassr)�typer6�complexfloatingre�	conjugatermr$r$r%�H�szmatrix.H)NT)NNNr^)r-)NNNr�NN),�__name__�
__module__�__qualname__�__doc__�__array_priority__r@rOrPr]rVr_rarbrcrhrirlrqrvrxrzr|r�r�r�r�r�r�r�r�r��propertyr�r�r�r�r�r��fget�getT�getA�getA1�getH�getIr$r$r$r%rIsZ(
4


$
5
%
"
"
"
!

(
#
'
#
'!
,


&
 
#
rc
Cs�|�d�}g}|D]\}|�d�}g}|D]	}|�|���q|}g}	|D]7}
|
��}
z||
}Wn%tyUz||
}WntyR}z	td|
�d��d�d}~wwYnw|	�|�q$|�t|	dd��q	t|dd�S)Nr
rzname z is not defined���rur)rr�strip�KeyError�	NameErrorrr)
r9�gdict�ldictr�rowtuprrr rH�coltupr!�thismat�er$r$r%�_from_string�s2

����r�cCs�t|t�r!|durt��j}|j}|j}n|}|}tt|||��St|t	t
f�rPg}|D]}t|tj�r>tt
|dd��S|�t
|dd��q,tt
|dd��St|tj�rZt|�SdS)a�
    Build a matrix object from a string, nested sequence, or array.

    Parameters
    ----------
    obj : str or array_like
        Input data. If a string, variables in the current scope may be
        referenced by name.
    ldict : dict, optional
        A dictionary that replaces local operands in current frame.
        Ignored if `obj` is not a string or `gdict` is None.
    gdict : dict, optional
        A dictionary that replaces global operands in current frame.
        Ignored if `obj` is not a string.

    Returns
    -------
    out : matrix
        Returns a matrix object, which is a specialized 2-D array.

    See Also
    --------
    block :
        A generalization of this function for N-d arrays, that returns normal
        ndarrays.

    Examples
    --------
    >>> A = np.mat('1 1; 1 1')
    >>> B = np.mat('2 2; 2 2')
    >>> C = np.mat('3 4; 5 6')
    >>> D = np.mat('7 8; 9 0')

    All the following expressions construct the same block matrix:

    >>> np.bmat([[A, B], [C, D]])
    matrix([[1, 1, 2, 2],
            [1, 1, 2, 2],
            [3, 4, 7, 8],
            [5, 6, 9, 0]])
    >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
    matrix([[1, 1, 2, 2],
            [1, 1, 2, 2],
            [3, 4, 7, 8],
            [5, 6, 9, 0]])
    >>> np.bmat('A,B; C,D')
    matrix([[1, 1, 2, 2],
            [1, 1, 2, 2],
            [3, 4, 7, 8],
            [5, 6, 9, 0]])

    Nr�rur)r4r9�sys�	_getframe�f_back�	f_globals�f_localsrr�rKrWr6r7rr)rMr�r��frame�	glob_dict�loc_dict�arr_rowsrr$r$r%rs$
6
�rr^r�)�__all__r�r1r�_utilsr�numpy.core.numeric�core�numericr6rr	r�rr&rr7rr�rrr$r$r$r%�<module>s0#0M