o
    ¦ƒðjøI  ã                   @  sæ  d Z ddlmZ ddlmZmZmZmZ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 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m Z  edƒZ!edƒZ"edƒZ#edƒZ$edƒZ%edƒZ&G dd„ de
ƒZ'G dd„ de
ƒZ(dd„ Z)G dd„ de
ƒZ*G dd„ de
ƒZ+G dd„ deƒZ,G dd „ d e
ƒZ-G d!d"„ d"e
ƒZ.G d#d$„ d$e
ƒZ/G d%d&„ d&e
ƒZ0G d'd(„ d(eƒZ1e1ƒ Z2d)d*„ Z3e3d+ƒZ4d]d-d,d,d.œd/d0„Z5d1d2„ Z6d3d4„ Z7d^d5d6„Z8d^d7d8„Z9d]d9d:„Z:d^d;d<„Z;d^d=d>„Z<d]d?d@„Z=G dAdB„ dBe
ƒZ>G dCdD„ dDe
ƒZ?G dEdF„ dFeƒZ@G dGdH„ dHe@ƒZAG dIdJ„ dJe@ƒZBG dKdL„ dLe@ƒZCG dMdN„ dNe@ƒZDG dOdP„ dPe@ƒZEG dQdR„ dReAƒZFG dSdT„ dTeƒZGG dUdV„ dVeGƒZHG dWdX„ dXeGƒZIG dYdZ„ dZe
eƒZJG d[d\„ d\e
eƒZKd,S )_z¬
AST nodes specific to Fortran.

The functions defined in this module allows the user to express functions such as ``dsign``
as a SymPy function for symbolic manipulation.
é    )Úannotations)	Ú	AttributeÚ	CodeBlockÚFunctionCallÚNodeÚnoneÚStringÚTokenÚ	_mk_TupleÚVariable)ÚBasic©ÚTuple)ÚExpr)ÚFunction)ÚFloatÚInteger)ÚStr)Úsympify©ÚtrueÚfalse)ÚiterableÚpureÚ	elementalÚ	intent_inÚ
intent_outÚintent_inoutÚallocatablec                   @  s(   e Zd ZdZd ZZeZedd„ ƒZ	dS )ÚProgramaf   Represents a 'program' block in Fortran.

    Examples
    ========

    >>> from sympy.codegen.ast import Print
    >>> from sympy.codegen.fnodes import Program
    >>> prog = Program('myprogram', [Print([42])])
    >>> from sympy import fcode
    >>> print(fcode(prog, source_format='free'))
    program myprogram
        print *, 42
    end program

    )ÚnameÚbodyc                 C  ó   t | Ž S ©N©r   ©r!   © r&   ú–/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/venv/lib/python3.10/site-packages/sympy/codegen/fnodes.pyÚ<lambda>4   ó    zProgram.<lambda>N)
Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__Ú_fieldsr   Ú_construct_nameÚstaticmethodÚ_construct_bodyr&   r&   r&   r'   r   "   s
    r   c                   @  s    e Zd ZdZd ZZeZeZdS )Ú
use_renameaÊ   Represents a renaming in a use statement in Fortran.

    Examples
    ========

    >>> from sympy.codegen.fnodes import use_rename, use
    >>> from sympy import fcode
    >>> ren = use_rename("thingy", "convolution2d")
    >>> print(fcode(ren, source_format='free'))
    thingy => convolution2d
    >>> full = use('signallib', only=['snr', ren])
    >>> print(fcode(full, source_format='free'))
    use signallib, only: snr, thingy => convolution2d

    )ÚlocalÚoriginalN)	r*   r+   r,   r-   r.   r/   r   Ú_construct_localÚ_construct_originalr&   r&   r&   r'   r3   7   s
    r3   c                 C  s   t | dƒr| jS t| ƒS )Nr    )Úhasattrr    r   ©Úargr&   r&   r'   Ú_nameK   s   
r;   c                   @  sB   e Zd ZdZd ZZeedœZee	ƒZ
edd„ ƒZedd„ ƒZdS )ÚuseaÑ   Represents a use statement in Fortran.

    Examples
    ========

    >>> from sympy.codegen.fnodes import use
    >>> from sympy import fcode
    >>> fcode(use('signallib'), source_format='free')
    'use signallib'
    >>> fcode(use('signallib', [('metric', 'snr')]), source_format='free')
    'use signallib, metric => snr'
    >>> fcode(use('signallib', only=['snr', 'convolution2d']), source_format='free')
    'use signallib, only: snr, convolution2d'

    )Ú	namespaceÚrenameÚonly)r>   r?   c                 C  ó   t dd„ | D ƒŽ S )Nc                 S  s"   g | ]}t |tƒr|nt|Ž ‘qS r&   )Ú
isinstancer3   ©Ú.0r:   r&   r&   r'   Ú
<listcomp>d   ó   " ú use.<lambda>.<locals>.<listcomp>r   ©Úargsr&   r&   r'   r(   d   ó    zuse.<lambda>c                 C  r@   )Nc                 S  s"   g | ]}t |tƒr|nt|ƒ‘qS r&   )rA   r3   r;   rB   r&   r&   r'   rD   e   rE   rF   r   rG   r&   r&   r'   r(   e   rI   N)r*   r+   r,   r-   r.   r/   r   Údefaultsr1   r;   Ú_construct_namespaceÚ_construct_renameÚ_construct_onlyr&   r&   r&   r'   r<   Q   s    
r<   c                   @  s>   e Zd ZdZd ZZdeƒ iZeZ	e
dd„ ƒZedd„ ƒZdS )	ÚModulea\   Represents a module in Fortran.

    Examples
    ========

    >>> from sympy.codegen.fnodes import Module
    >>> from sympy import fcode
    >>> print(fcode(Module('signallib', ['implicit none'], []), source_format='free'))
    module signallib
    implicit none
    <BLANKLINE>
    contains
    <BLANKLINE>
    <BLANKLINE>
    end module

    )r    ÚdeclarationsÚdefinitionsrO   c                 C  s   dd„ |D ƒ}t |Ž S )Nc                 S  s"   g | ]}t |tƒrt|ƒn|‘qS r&   )rA   Ústrr   rB   r&   r&   r'   rD   €   rE   z2Module._construct_declarations.<locals>.<listcomp>r$   )ÚclsrH   r&   r&   r'   Ú_construct_declarations~   s   zModule._construct_declarationsc                 C  r"   r#   r$   r9   r&   r&   r'   r(   ƒ   r)   zModule.<lambda>N)r*   r+   r,   r-   r.   r/   r   rJ   r   r0   ÚclassmethodrS   r1   Ú_construct_definitionsr&   r&   r&   r'   rN   h   s    

rN   c                   @  s:   e Zd ZdZdZeej ZeZe	dd„ ƒZ
edd„ ƒZdS )Ú
Subroutineaê   Represents a subroutine in Fortran.

    Examples
    ========

    >>> from sympy import fcode, symbols
    >>> from sympy.codegen.ast import Print
    >>> from sympy.codegen.fnodes import Subroutine
    >>> x, y = symbols('x y', real=True)
    >>> sub = Subroutine('mysub', [x, y], [Print([x**2 + y**2, x*y])])
    >>> print(fcode(sub, source_format='free', standard=2003))
    subroutine mysub(x, y)
    real*8 :: x
    real*8 :: y
    print *, x**2 + y**2, x*y
    end subroutine

    )r    Ú
parametersr!   c                 C  s   t ttj| ƒŽ S r#   )r   Úmapr   Údeduced)Úparamsr&   r&   r'   r(   œ   s    zSubroutine.<lambda>c                 C  s   t |tƒr|S t|Ž S r#   )rA   r   )rR   Úitrr&   r&   r'   r2   ž   s   
zSubroutine._construct_bodyN)r*   r+   r,   r-   r.   r   r/   r   r0   r1   Ú_construct_parametersrT   r2   r&   r&   r&   r'   rV   †   s    
rV   c                   @  s(   e Zd ZdZd ZZeeƒZee	ƒZ
dS )ÚSubroutineCallzü Represents a call to a subroutine in Fortran.

    Examples
    ========

    >>> from sympy.codegen.fnodes import SubroutineCall
    >>> from sympy import fcode
    >>> fcode(SubroutineCall('mysub', 'x y'.split()))
    '       call mysub(x, y)'

    )r    Úsubroutine_argsN)r*   r+   r,   r-   r.   r/   r1   r;   r0   r
   Ú_construct_subroutine_argsr&   r&   r&   r'   r]   ¥   s
    r]   c                   @  s^   e Zd ZdZd ZZedƒedœZe	dd„ ƒZ
e	eƒZe	eƒZe	eƒZe	eƒZe	dd„ ƒZdS )	ÚDoa�   Represents a Do loop in in Fortran.

    Examples
    ========

    >>> from sympy import fcode, symbols
    >>> from sympy.codegen.ast import aug_assign, Print
    >>> from sympy.codegen.fnodes import Do
    >>> i, n = symbols('i n', integer=True)
    >>> r = symbols('r', real=True)
    >>> body = [aug_assign(r, '+', 1/i), Print([i, r])]
    >>> do1 = Do(body, i, 1, n)
    >>> print(fcode(do1, source_format='free'))
    do i = 1, n
        r = r + 1d0/i
        print *, i, r
    end do
    >>> do2 = Do(body, i, 1, n, 2)
    >>> print(fcode(do2, source_format='free'))
    do i = 1, n, 2
        r = r + 1d0/i
        print *, i, r
    end do

    )r!   ÚcounterÚfirstÚlastÚstepÚ
concurrenté   )rd   re   c                 C  r"   r#   r$   r%   r&   r&   r'   r(   Ó   r)   zDo.<lambda>c                 C  s   | rt S tS r#   r   r9   r&   r&   r'   r(   Ø   s    N)r*   r+   r,   r-   r.   r/   r   r   rJ   r1   r2   r   Ú_construct_counterÚ_construct_firstÚ_construct_lastÚ_construct_stepÚ_construct_concurrentr&   r&   r&   r'   r`   ¶   s    r`   c                   @  s    e Zd ZdZd ZZeeƒZdS )ÚArrayConstructoraT   Represents an array constructor.

    Examples
    ========

    >>> from sympy import fcode
    >>> from sympy.codegen.fnodes import ArrayConstructor
    >>> ac = ArrayConstructor([1, 2, 3])
    >>> fcode(ac, standard=95, source_format='free')
    '(/1, 2, 3/)'
    >>> fcode(ac, standard=2003, source_format='free')
    '[1, 2, 3]'

    )ÚelementsN)	r*   r+   r,   r-   r.   r/   r1   r
   Ú_construct_elementsr&   r&   r&   r'   rl   Û   s    rl   c                   @  sL   e Zd ZdZd ZZdedƒiZee	ƒZ
ee	ƒZee	ƒZee	ƒZee	ƒZdS )ÚImpliedDoLoopaÉ   Represents an implied do loop in Fortran.

    Examples
    ========

    >>> from sympy import Symbol, fcode
    >>> from sympy.codegen.fnodes import ImpliedDoLoop, ArrayConstructor
    >>> i = Symbol('i', integer=True)
    >>> idl = ImpliedDoLoop(i**3, i, -3, 3, 2)  # -27, -1, 1, 27
    >>> ac = ArrayConstructor([-28, idl, 28]) # -28, -27, -1, 1, 27, 28
    >>> fcode(ac, standard=2003, source_format='free')
    '[-28, (i**3, i = -3, 3, 2), 28]'

    )Úexprra   rb   rc   rd   rd   rf   N)r*   r+   r,   r-   r.   r/   r   rJ   r1   r   Ú_construct_exprrg   rh   ri   rj   r&   r&   r&   r'   ro   î   s    ro   c                   @  s    e Zd ZdZdd„ Zdd„ ZdS )ÚExtentaC   Represents a dimension extent.

    Examples
    ========

    >>> from sympy.codegen.fnodes import Extent
    >>> e = Extent(-3, 3)  # -3, -2, -1, 0, 1, 2, 3
    >>> from sympy import fcode
    >>> fcode(e, source_format='free')
    '-3:3'
    >>> from sympy.codegen.ast import Variable, real
    >>> from sympy.codegen.fnodes import dimension, intent_out
    >>> dim = dimension(e, e)
    >>> arr = Variable('x', real, attrs=[dim, intent_out])
    >>> fcode(arr.as_Declaration(), source_format='free', standard=2003)
    'real*8, dimension(-3:3, -3:3), intent(out) :: x'

    c                 G  s`   t |ƒdkr|\}}t | t|ƒt|ƒ¡S t |ƒdks't |ƒdkr,|d dv r,t | ¡S tdƒ‚)Né   r   rf   )ú:Nz5Expected 0 or 2 args (or one argument == None or ':'))Úlenr   Ú__new__r   Ú
ValueError)rR   rH   ÚlowÚhighr&   r&   r'   rv     s   $
zExtent.__new__c                 C  s(   t | jƒdkr	dS d dd„ | jD ƒ¡S )Nr   rt   c                 s  s   � | ]}t |ƒV  qd S r#   )rQ   rB   r&   r&   r'   Ú	<genexpr>%  s   € z#Extent._sympystr.<locals>.<genexpr>)ru   rH   Újoin)ÚselfÚprinterr&   r&   r'   Ú	_sympystr"  s   zExtent._sympystrN)r*   r+   r,   r-   rv   r~   r&   r&   r&   r'   rr     s    	rr   c                  G  s¬   t | ƒdkr
tdƒ‚g }| D ]8}t|tƒr| |¡ qt|tƒr3|dkr+| tƒ ¡ q| t|ƒ¡ qt|ƒr?| t|Ž ¡ q| t|ƒ¡ qt | ƒdkrQtdƒ‚t	d|ƒS )aú   Creates a 'dimension' Attribute with (up to 7) extents.

    Examples
    ========

    >>> from sympy import fcode
    >>> from sympy.codegen.fnodes import dimension, intent_in
    >>> dim = dimension('2', ':')  # 2 rows, runtime determined number of columns
    >>> from sympy.codegen.ast import Variable, integer
    >>> arr = Variable('a', integer, attrs=[dim, intent_in])
    >>> fcode(arr.as_Declaration(), source_format='free', standard=2003)
    'integer*4, dimension(2, :), intent(in) :: a'

    é   z0Fortran only supports up to 7 dimensional arraysrt   r   zNeed at least one dimensionÚ	dimension)
ru   rw   rA   rr   ÚappendrQ   r   r   r   r   )rH   rW   r:   r&   r&   r'   r€   *  s    


r€   Ú*Nr&   )ÚattrsÚvalueÚtypec                C  s˜   t |tƒrt|jƒdkrtdt|ƒ ƒ‚nt|Ž }t|ƒ|g }|dur8|ttt	fvr3ttt	dœ| }| 
|¡ |du rDtj| ||d�S t| |||d�S )aë   Convenience function for creating a Variable instance for a Fortran array.

    Parameters
    ==========

    symbol : symbol
    dim : Attribute or iterable
        If dim is an ``Attribute`` it need to have the name 'dimension'. If it is
        not an ``Attribute``, then it is passed to :func:`dimension` as ``*dim``
    intent : str
        One of: 'in', 'out', 'inout' or None
    \*\*kwargs:
        Keyword arguments for ``Variable`` ('type' & 'value')

    Examples
    ========

    >>> from sympy import fcode
    >>> from sympy.codegen.ast import integer, real
    >>> from sympy.codegen.fnodes import array
    >>> arr = array('a', '*', 'in', type=integer)
    >>> print(fcode(arr.as_Declaration(), source_format='free', standard=2003))
    integer*4, dimension(*), intent(in) :: a
    >>> x = array('x', [3, ':', ':'], intent='out', type=real)
    >>> print(fcode(x.as_Declaration(value=1), source_format='free', standard=2003))
    real*8, dimension(3, :, :), intent(out) :: x = 1

    r€   z/Got an unexpected Attribute argument as dim: %sN)ÚinÚoutÚinout)r„   rƒ   )rA   r   rQ   r    rw   r€   Úlistr   r   r   r�   r   rY   )ÚsymbolÚdimÚintentrƒ   r„   r…   r&   r&   r'   ÚarrayO  s   
ÿ
r�   c                 C  s   t | tƒr	t| ƒS t| ƒS r#   )rA   rQ   r   r   r9   r&   r&   r'   Ú
_printable|  s   rŽ   c                 C  s   t dt| ƒgƒS )a   Creates an AST node for a function call to Fortran's "allocated(...)"

    Examples
    ========

    >>> from sympy import fcode
    >>> from sympy.codegen.fnodes import allocated
    >>> alloc = allocated('x')
    >>> fcode(alloc, source_format='free')
    'allocated(x)'

    Ú	allocated©r   rŽ   )r�   r&   r&   r'   r�   €  s   r�   c                 C  ó8   t dt| ƒg|rt|ƒgng  |rt|ƒg ƒS g  ƒS )ap   Creates an AST node for a function call to Fortran's "lbound(...)"

    Parameters
    ==========

    array : Symbol or String
    dim : expr
    kind : expr

    Examples
    ========

    >>> from sympy import fcode
    >>> from sympy.codegen.fnodes import lbound
    >>> lb = lbound('arr', dim=2)
    >>> fcode(lb, source_format='free')
    'lbound(arr, 2)'

    Úlboundr�   ©r�   r‹   Úkindr&   r&   r'   r’   �  ó   ÿþþþþr’   c                 C  r‘   )NÚuboundr�   r“   r&   r&   r'   r–   ¬  s   ÿþþþþr–   c                 C  s&   t dt| ƒg|rt|ƒg ƒS g  ƒS )aR   Creates an AST node for a function call to Fortran's "shape(...)"

    Parameters
    ==========

    source : Symbol or String
    kind : expr

    Examples
    ========

    >>> from sympy import fcode
    >>> from sympy.codegen.fnodes import shape
    >>> shp = shape('x')
    >>> fcode(shp, source_format='free')
    'shape(x)'

    Úshaper�   )Úsourcer”   r&   r&   r'   r—   µ  s   ÿþÿþr—   c                 C  r‘   )a…   Creates an AST node for a function call to Fortran's "size(...)"

    Examples
    ========

    >>> from sympy import fcode, Symbol
    >>> from sympy.codegen.ast import FunctionDefinition, real, Return
    >>> from sympy.codegen.fnodes import array, sum_, size
    >>> a = Symbol('a', real=True)
    >>> body = [Return((sum_(a**2)/size(a))**.5)]
    >>> arr = array(a, dim=[':'], intent='in')
    >>> fd = FunctionDefinition(real, 'rms', [arr], body)
    >>> print(fcode(fd, source_format='free', standard=2003))
    real*8 function rms(a)
    real*8, dimension(:), intent(in) :: a
    rms = sqrt(sum(a**2)*1d0/size(a))
    end function

    Úsizer�   r“   r&   r&   r'   r™   Ï  r•   r™   c                 C  s>   t dt| ƒt|ƒg|rt|ƒgng  |rt|ƒg ƒS g  ƒS )zž Creates an AST node for a function call to Fortran's "reshape(...)"

    Parameters
    ==========

    source : Symbol or String
    shape : ArrayExpr

    Úreshaper�   )r˜   r—   ÚpadÚorderr&   r&   r'   rš   ë  s   
ÿþþþþrš   c                 C  s   t d| r
t| ƒgƒS g ƒS )aú   Creates an Attribute ``bind_C`` with a name.

    Parameters
    ==========

    name : str

    Examples
    ========

    >>> from sympy import fcode, Symbol
    >>> from sympy.codegen.ast import FunctionDefinition, real, Return
    >>> from sympy.codegen.fnodes import array, sum_, bind_C
    >>> a = Symbol('a', real=True)
    >>> s = Symbol('s', integer=True)
    >>> arr = array(a, dim=[s], intent='in')
    >>> body = [Return((sum_(a**2)/s)**.5)]
    >>> fd = FunctionDefinition(real, 'rms', [arr, s], body, attrs=[bind_C('rms')])
    >>> print(fcode(fd, source_format='free', standard=2003))
    real*8 function rms(a, s) bind(C, name="rms")
    real*8, dimension(s), intent(in) :: a
    integer*4 :: s
    rms = sqrt(sum(a**2)/s)
    end function

    Úbind_C)r   r   )r    r&   r&   r'   r�   ý  s   r�   c                   @  s0   e Zd ZdZd ZZdeiZee	ƒZ
eeƒZdS )ÚGoToa    Represents a goto statement in Fortran

    Examples
    ========

    >>> from sympy.codegen.fnodes import GoTo
    >>> go = GoTo([10, 20, 30], 'i')
    >>> from sympy import fcode
    >>> fcode(go, source_format='free')
    'go to (10, 20, 30), i'

    )Úlabelsrp   rp   N)r*   r+   r,   r-   r.   r/   r   rJ   r1   r
   Ú_construct_labelsr   rq   r&   r&   r&   r'   rž     s    rž   c                   @  s(   e Zd ZdZd ZZdeiZee	ƒZ
dS )ÚFortranReturnaK   AST node explicitly mapped to a fortran "return".

    Explanation
    ===========

    Because a return statement in fortran is different from C, and
    in order to aid reuse of our codegen ASTs the ordinary
    ``.codegen.ast.Return`` is interpreted as assignment to
    the result variable of the function. If one for some reason needs
    to generate a fortran RETURN statement, this node should be used.

    Examples
    ========

    >>> from sympy.codegen.fnodes import FortranReturn
    >>> from sympy import fcode
    >>> fcode(FortranReturn('x'))
    '       return x'

    )Úreturn_valuer¢   N)r*   r+   r,   r-   r.   r/   r   rJ   r1   r   Ú_construct_return_valuer&   r&   r&   r'   r¡   -  s
    r¡   c                   @  s   e Zd ZdZdd„ ZdS )Ú	FFunctionéM   c                 C  sF   | j j}|jd | jk rtd|| jf ƒ‚d |d t|j| j	ƒ¡¡S )NÚstandardz%s requires Fortran %d or newerz{}({})z, )
Ú	__class__r*   Ú	_settingsÚ_required_standardÚNotImplementedErrorÚformatr{   rX   Ú_printrH   )r|   r}   r    r&   r&   r'   Ú_fcodeJ  s   ÿzFFunction._fcodeN)r*   r+   r,   r©   r­   r&   r&   r&   r'   r¤   G  s    r¤   c                   @  s   e Zd ZdZdS )ÚF95Functioné_   N)r*   r+   r,   r©   r&   r&   r&   r'   r®   R  s    r®   c                   @  ó   e Zd ZdZdZdS )Úisignz/ Fortran sign intrinsic for integer arguments. rs   N©r*   r+   r,   r-   Únargsr&   r&   r&   r'   r±   V  ó    r±   c                   @  r°   )Údsignz8 Fortran sign intrinsic for double precision arguments. rs   Nr²   r&   r&   r&   r'   rµ   [  r´   rµ   c                   @  r°   )Úcmplxz& Fortran complex conversion function. rs   Nr²   r&   r&   r&   r'   r¶   `  r´   r¶   c                   @  r°   )r”   z Fortran kind function. rf   Nr²   r&   r&   r&   r'   r”   e  r´   r”   c                   @  r°   )Úmergez Fortran merge function é   Nr²   r&   r&   r&   r'   r·   j  r´   r·   c                   @  s&   e Zd ZU ded< ded< dd„ ZdS )Ú_literalrQ   Ú_tokenÚintÚ	_decimalsc                 O  sp   d  | j¡|   d¡\}}| d¡ d¡}|d |dd …  d¡}}|dkr)dn|}|p.d| j | |p6d S )	Nz%.{}eÚeÚ0Ú.r   rf   ú+Ú )r«   r¼   ÚsplitÚstripÚrstripÚlstriprº   )r|   r}   rH   ÚkwargsÚmantissaÚsgnd_exÚex_sgnÚex_numr&   r&   r'   r­   s  s
   z_literal._fcodeN)r*   r+   r,   Ú__annotations__r­   r&   r&   r&   r'   r¹   o  s   
 r¹   c                   @  ó   e Zd ZdZdZdZdS )Ú
literal_spz' Fortran single precision real literal r½   é	   N©r*   r+   r,   r-   rº   r¼   r&   r&   r&   r'   rÍ   {  ó    rÍ   c                   @  rÌ   )Ú
literal_dpz' Fortran double precision real literal Údé   NrÏ   r&   r&   r&   r'   rÑ   �  rÐ   rÑ   c                   @  ó.   e Zd Zd ZZeedœZeeƒZ	eeƒZ
dS )Úsum_©r�   r‹   Úmask©r‹   r×   N©r*   r+   r,   r.   r/   r   rJ   r1   r   Ú_construct_arrayÚ_construct_dimr&   r&   r&   r'   rÕ   ‡  ó
    
rÕ   c                   @  rÔ   )Úproduct_rÖ   rØ   NrÙ   r&   r&   r&   r'   rÝ   Ž  rÜ   rÝ   r#   )NN)Lr-   Ú
__future__r   Úsympy.codegen.astr   r   r   r   r   r   r	   r
   r   Úsympy.core.basicr   Úsympy.core.containersr   Úsympy.core.exprr   Úsympy.core.functionr   Úsympy.core.numbersr   r   Úsympy.core.symbolr   Úsympy.core.sympifyr   Úsympy.logicr   r   Úsympy.utilities.iterablesr   r   r   r   r   r   r   r   r3   r;   r<   rN   rV   r]   r`   rl   ro   rr   Úassumed_extentr€   Úassumed_sizer�   rŽ   r�   r’   r–   r—   r™   rš   r�   rž   r¡   r¤   r®   r±   rµ   r¶   r”   r·   r¹   rÍ   rÑ   rÕ   rÝ   r&   r&   r&   r'   Ú<module>   sn    ,%!#-


	


