
    Ed                     v    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mZ  G d d	e          Zd
S )   )
MatrixExpr    )FunctionClassLambda)Dummy)_sympifysympify)Matrix)reimc                   `     e Zd ZdZ fdZed             Zed             Zd Zd Z	d Z
 xZS )FunctionMatrixa  Represents a matrix using a function (``Lambda``) which gives
    outputs according to the coordinates of each matrix entries.

    Parameters
    ==========

    rows : nonnegative integer. Can be symbolic.

    cols : nonnegative integer. Can be symbolic.

    lamda : Function, Lambda or str
        If it is a SymPy ``Function`` or ``Lambda`` instance,
        it should be able to accept two arguments which represents the
        matrix coordinates.

        If it is a pure string containing Python ``lambda`` semantics,
        it is interpreted by the SymPy parser and casted into a SymPy
        ``Lambda`` instance.

    Examples
    ========

    Creating a ``FunctionMatrix`` from ``Lambda``:

    >>> from sympy import FunctionMatrix, symbols, Lambda, MatPow
    >>> i, j, n, m = symbols('i,j,n,m')
    >>> FunctionMatrix(n, m, Lambda((i, j), i + j))
    FunctionMatrix(n, m, Lambda((i, j), i + j))

    Creating a ``FunctionMatrix`` from a SymPy function:

    >>> from sympy import KroneckerDelta
    >>> X = FunctionMatrix(3, 3, KroneckerDelta)
    >>> X.as_explicit()
    Matrix([
    [1, 0, 0],
    [0, 1, 0],
    [0, 0, 1]])

    Creating a ``FunctionMatrix`` from a SymPy undefined function:

    >>> from sympy import Function
    >>> f = Function('f')
    >>> X = FunctionMatrix(3, 3, f)
    >>> X.as_explicit()
    Matrix([
    [f(0, 0), f(0, 1), f(0, 2)],
    [f(1, 0), f(1, 1), f(1, 2)],
    [f(2, 0), f(2, 1), f(2, 2)]])

    Creating a ``FunctionMatrix`` from Python ``lambda``:

    >>> FunctionMatrix(n, m, 'lambda i, j: i + j')
    FunctionMatrix(n, m, Lambda((i, j), i + j))

    Example of lazy evaluation of matrix product:

    >>> Y = FunctionMatrix(1000, 1000, Lambda((i, j), i + j))
    >>> isinstance(Y*Y, MatPow) # this is an expression object
    True
    >>> (Y**2)[10,10] # So this is evaluated lazily
    342923500

    Notes
    =====

    This class provides an alternative way to represent an extremely
    dense matrix with entries in some form of a sequence, in a most
    sparse way.
    c                 j   t          |          t          |          }}|                     |           |                     |           t          |          }t          |t          t
          f          s"t          d                    |                    d|j        vr"t          d                    |                    t          |t
                    s:t          d          t          d          }}t          ||f |||                    }t                                          | |||          S )Nz4{} should be compatible with SymPy function classes.   z({} should be able to accept 2 arguments.ij)r   
_check_dimr	   
isinstancer   r   
ValueErrorformatnargsr   super__new__)clsrowscolslamdar   r   	__class__s         Elib/python3.11/site-packages/sympy/matrices/expressions/funcmatrix.pyr   zFunctionMatrix.__new__P   s   d^^Xd^^dtt%-!899 	 F      EK 	J:AA%HHJ J J %(( 	0::uSzzqAAq655A;;//EwwsD$666    c                      | j         dd         S )Nr   r   argsselfs    r   shapezFunctionMatrix.shapee   s    y1~r    c                     | j         d         S )Nr   r"   r$   s    r   r   zFunctionMatrix.lamdai   s    y|r    c                 .    |                      ||          S N)r   )r%   r   r   kwargss       r   _entryzFunctionMatrix._entrym   s    zz!Qr    c                 z    ddl m} ddlm}  ||                               |                                          S )Nr   )Trace)Sum) sympy.matrices.expressions.tracer-   sympy.concrete.summationsr.   rewritedoit)r%   r-   r.   s      r   _eval_tracezFunctionMatrix._eval_tracep   sN    ::::::111111uT{{""3'',,...r    c                 r    t          t          |                     t          t          |                     fS r)   )r   r
   r   r$   s    r   _eval_as_real_imagz!FunctionMatrix._eval_as_real_imagu   s)    6$<<  "VD\\"2"233r    )__name__
__module____qualname____doc__r   propertyr&   r   r+   r3   r5   __classcell__)r   s   @r   r   r   	   s        E EL7 7 7 7 7*   X   X     / / /
4 4 4 4 4 4 4r    r   N)matexprr   sympy.core.functionr   r   sympy.core.symbolr   sympy.core.sympifyr   r	   sympy.matricesr
   $sympy.functions.elementary.complexesr   r   r    r    r   <module>rC      s          5 5 5 5 5 5 5 5 # # # # # # 0 0 0 0 0 0 0 0 ! ! ! ! ! ! 7 7 7 7 7 7 7 7m4 m4 m4 m4 m4Z m4 m4 m4 m4 m4r    