
    sg                     n    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y
)   )
MatrixExpr    )FunctionClassLambda)Dummy)_sympifysympify)Matrix)reimc                   T     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                    t        |      t        |      }}| j                  |       | j                  |       t        |      }t        |t        t
        f      st        dj                  |            d|j                  vrt        dj                  |            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         X/var/www/html/venv/lib/python3.12/site-packages/sympy/matrices/expressions/funcmatrix.pyr   zFunctionMatrix.__new__P   s    d^Xd^dtt%-!89F    EKK:AA%HJ J %(:uSzqAAq65A;/EwsD$66    c                      | j                   dd S )Nr   r   argsselfs    r   shapezFunctionMatrix.shapee   s    yy1~r    c                      | j                   d   S )Nr   r"   r$   s    r   r   zFunctionMatrix.lamdai   s    yy|r    c                 &    | j                  ||      S N)r   )r%   r   r   kwargss       r   _entryzFunctionMatrix._entrym   s    zz!Qr    c                 d    ddl m} ddlm}  ||       j	                  |      j                         S )Nr   )Trace)Sum) sympy.matrices.expressions.tracer-   sympy.concrete.summationsr.   rewritedoit)r%   r-   r.   s      r   _eval_tracezFunctionMatrix._eval_tracep   s&    :1T{""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33r    )__name__
__module____qualname____doc__r   propertyr&   r   r+   r3   r5   __classcell__)r   s   @r   r   r   	   sF    EL7*     /
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 # 0 ! 7m4Z m4r    