o
    GZhK)                     @   sD  d Z ddlmZ ddlmZmZmZ ddlmZ ddl	m
Z
mZ ddlZdZi dd	d
dddddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8ZeD ]Zeee< qnejd9ejd:ejd;ejd<ejd=iZd>d?d@ZejgZG dAdB dBeZdGdCdDZdEdF ZdS )Ha	  
Maple code printer

The MapleCodePrinter converts single SymPy expressions into single
Maple expressions, using the functions defined in the Maple objects where possible.


FIXME: This module is still under actively developed. Some functions may be not completed.
    )S)IntegerIntegerConstantequal_valued)CodePrinter)
precedence
PRECEDENCEN) sincostansecZcscZcotsinhcoshtanhZsechZcschZcothexpfloor	factorialZ	bernoulliZeulerZ	fibonaccigcdlcm	conjugateZCiChiZEiZLiZSiZShierferfcZharmonicZLambertWsqrtZAbsabsloglnasinZarcsinacosZarccosatanZarctanZasecZarcsecZacscZarccscZacotZarccotasinhZarcsinhacoshZarccoshatanhZarctanhZasechZarcsechZacschZarccschZacothZarccothZceilingceilZMaxmaxZMinminZdoublefactorialZ
pochhammerZBesselIZBesselJZBesselKZBesselYZHankelH1ZHankelH2ZAiryAiZAiryBiZAppellF1ZFresnelCZFresnelSZLerchPhi)Z
factorial2ZRisingFactorialZbesseliZbesseljZbesselkZbesselyZhankelh1Zhankelh2ZairyaiZairybiZappellf1ZfresnelcZfresnelsZlerchphiPizexp(1)Catalangammaz(1/2 + (1/2)*sqrt(5))=z<>)z==z!=c                       s(  e Zd ZdZdZdZddddZeej	fi ddd	Z	dD fdd	Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd  Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 ZdEd2d3Zd4d5 Zd6d7 Zd8d9 Z d:d; Z!d<d= Z"d>d? Z#d@dA Z$dBdC Z%  Z&S )FMapleCodePrinterzF
    Printer which converts a SymPy expression into a maple code.
    Z_mapleZmapleandorznot )r+   r,   notT)inlineZallow_unknown_functionsNc                    s>   |d u ri }t  | tt| _|di }| j| d S )NZuser_functions)super__init__dictknown_functionsgetupdate)selfsettingsZ	userfuncs	__class__ C/var/www/auris/lib/python3.10/site-packages/sympy/printing/maple.pyr0   f   s   
zMapleCodePrinter.__init__c                 C   s   d| S )Nz%s;r9   )r5   Z
codestringr9   r9   r:   _get_statementn      zMapleCodePrinter._get_statementc                 C   s
   d |S )Nz# {})format)r5   textr9   r9   r:   _get_commentq   s   
zMapleCodePrinter._get_commentc                 C   s   d ||| jd S )Nz	{} := {};	precision)r=   ZevalfZ	_settings)r5   namevaluer9   r9   r:   _declare_number_constt   s   z&MapleCodePrinter._declare_number_constc                 C   s   |S Nr9   )r5   linesr9   r9   r:   _format_codex      zMapleCodePrinter._format_codec                 C      |  t|S rD   _printlistr5   exprr9   r9   r:   _print_tuple{      zMapleCodePrinter._print_tuplec                 C   rH   rD   rI   rL   r9   r9   r:   _print_Tuple~   rO   zMapleCodePrinter._print_Tuplec                 C   s&   |  |j}|  |j}dj||dS )Nz{lhs} := {rhs})lhsrhs)rJ   rQ   rR   r=   )r5   rM   rQ   rR   r9   r9   r:   _print_Assignment   s   z"MapleCodePrinter._print_Assignmentc                 K   s   t |}t|jdrd| |j| S t|jdr!d| |j S t|jdr/d| |j S dj| |j|| |j|dS )	Nz1/%sg      ?zsqrt(%s)g      z
1/sqrt(%s)z{base}^{exp})baser   )r   r   r   parenthesizerU   rJ   r=   )r5   rM   kwargsPRECr9   r9   r:   
_print_Pow   s   zMapleCodePrinter._print_Powc                    sT   |j d jdur|j d jtjkrtd fdd|j D }d|}dj|dS )	NrT   TzAll Piecewise expressions must contain an (expr, True) statement to be used as a default condition. Without one, the generated expression may not evaluate to anything under some condition.c                    sN   g | ]#\}}|d ur|t jurdj | |dndj |dqS )Tz{c}, {e})cez{e})r[   )r   BooleanTruer=   rJ   ).0r[   rZ   r5   r9   r:   
<listcomp>   s    z5MapleCodePrinter._print_Piecewise.<locals>.<listcomp>z, zpiecewise({_inbrace}))_inbrace)argsZcondr   r\   
ValueErrorjoinr=   )r5   rM   Z
_coup_listr`   r9   r^   r:   _print_Piecewise   s   "

z!MapleCodePrinter._print_Piecewisec                 C   s,   t |jt |j}}djt|t|dS )Nz{p}/{q})pq)intre   rf   r=   str)r5   rM   re   rf   r9   r9   r:   _print_Rational   s   z MapleCodePrinter._print_Rationalc                 C   sJ   t |}| |j|}| |j|}|j}|tv rt| }dj|||dS )Nz{lhs} {rel_op} {rhs})rQ   rel_oprR   )r   rV   rQ   rR   rj   spec_relational_opsr=   )r5   rM   rX   Zlhs_codeZrhs_codeopr9   r9   r:   _print_Relational   s   z"MapleCodePrinter._print_Relationalc                 C   s   t | S rD   )number_symbolsrL   r9   r9   r:   _print_NumberSymbol   r<   z$MapleCodePrinter._print_NumberSymbolc                 C      dS )Nz	-infinityr9   rL   r9   r9   r:   _print_NegativeInfinity   rG   z(MapleCodePrinter._print_NegativeInfinityc                 C   rp   )Ninfinityr9   rL   r9   r9   r:   _print_Infinity   rG   z MapleCodePrinter._print_Infinityc                 C   rp   )Ntruer9   rL   r9   r9   r:   _print_BooleanTrue   rG   z#MapleCodePrinter._print_BooleanTruec                 C   rp   )Nfalser9   rL   r9   r9   r:   _print_BooleanFalse   rG   z$MapleCodePrinter._print_BooleanFalsec                 C   s   |rdS dS )Nrt   rv   r9   rL   r9   r9   r:   _print_bool   s   zMapleCodePrinter._print_boolc                 C   rp   )N	undefinedr9   rL   r9   r9   r:   
_print_NaN   rG   zMapleCodePrinter._print_NaNFc                 C   sH   t j|jv rdj|rdndd}|S dj| | |rdndd}|S )NzMatrix([], storage = {storage})sparseZrectangular)storagez#Matrix({list}, storage = {storage}))rK   r|   )r   ZZeroshaper=   rJ   tolist)r5   rM   r{   Z_strMr9   r9   r:   _get_matrix   s   

zMapleCodePrinter._get_matrixc                 C   s:   dj | j|jtd dd| |jd | |jd dS )Nz{parent}[{i_maple}, {j_maple}]ZAtomT)strict   )parentZi_mapleZj_maple)r=   rV   r   r   rJ   ijrL   r9   r9   r:   _print_MatrixElement   s
   z%MapleCodePrinter._print_MatrixElementc                 C      | j |ddS )NFr{   r   rL   r9   r9   r:   _print_MatrixBase   rO   z"MapleCodePrinter._print_MatrixBasec                 C   r   )NTr   r   rL   r9   r9   r:   _print_SparseRepMatrix   rO   z'MapleCodePrinter._print_SparseRepMatrixc                 C   s4   t |jttfr| t|S dj| |jdS )Nz$Matrix({var_size}, shape = identity))Zvar_size)
isinstancerowsr   r   rJ   sympyZSparseMatrixr=   rL   r9   r9   r:   _print_Identity   s   z MapleCodePrinter._print_Identityc                    s   t | t|j}d }t|d tjtjtjtjfs%|d |dd  }}|d u s-|dkr:d	 fdd|D S dj
|d	 fdd|D dS )	Nr   r   .c                 3       | ]	} | V  qd S rD   rV   r]   _mrX   r5   r9   r:   	<genexpr>       z1MapleCodePrinter._print_MatMul.<locals>.<genexpr>z{c}*{m}c                 3   r   rD   r   r   r   r9   r:   r      r   )rZ   m)r   rK   ra   r   r   Z
MatrixBaseZ
MatrixExprZMatrixSliceZMatrixSymbolrc   r=   )r5   rM   
_fact_listZ_constr9   r   r:   _print_MatMul   s   
$zMapleCodePrinter._print_MatMulc                 C   s   dj | |j| |jdS )NzMatrixPower({A}, {n}))An)r=   rJ   rU   r   rL   r9   r9   r:   _print_MatPow   s   zMapleCodePrinter._print_MatPowc                    s,   t | t|j}d fdd|D S )N*c                 3   r   rD   r   r   r   r9   r:   r      r   z:MapleCodePrinter._print_HadamardProduct.<locals>.<genexpr>)r   rK   ra   rc   )r5   rM   r   r9   r   r:   _print_HadamardProduct   s   
z'MapleCodePrinter._print_HadamardProductc                 C   sX   |j \}\}}|dkrdj| || |d}n	dj| |d}dj| ||dS )Nr   z{var}${order})varorderz{var})r   zdiff({func_expr}, {sec_arg}))Z	func_exprZsec_arg)ra   r=   rJ   )r5   rM   Z_fZ_var_orderZ_second_argr9   r9   r:   _print_Derivative   s   z"MapleCodePrinter._print_DerivativerD   )F)'__name__
__module____qualname____doc__Zprintmethodlanguage
_operatorsr1   r   Z_default_settingsr0   r;   r?   rC   rF   rN   rP   rS   rY   rd   ri   rm   ro   rq   rs   ru   rw   rx   rz   r   r   r   r   r   r   r   r   r   __classcell__r9   r9   r7   r:   r*   T   sP    

	

r*   c                 K   s   t || |S )aU  Converts ``expr`` to a string of Maple code.

    Parameters
    ==========

    expr : Expr
        A SymPy expression to be converted.
    assign_to : optional
        When given, the argument is used as the name of the variable to which
        the expression is assigned.  Can be a string, ``Symbol``,
        ``MatrixSymbol``, or ``Indexed`` type.  This can be helpful for
        expressions that generate multi-line statements.
    precision : integer, optional
        The precision for numbers such as pi  [default=16].
    user_functions : dict, optional
        A dictionary where keys are ``FunctionClass`` instances and values are
        their string representations.  Alternatively, the dictionary value can
        be a list of tuples i.e. [(argument_test, cfunction_string)].  See
        below for examples.
    human : bool, optional
        If True, the result is a single string that may contain some constant
        declarations for the number symbols.  If False, the same information is
        returned in a tuple of (symbols_to_declare, not_supported_functions,
        code_text).  [default=True].
    contract: bool, optional
        If True, ``Indexed`` instances are assumed to obey tensor contraction
        rules and the corresponding nested loops over indices are generated.
        Setting contract=False will not generate loops, instead the user is
        responsible to provide values for the indices in the code.
        [default=True].
    inline: bool, optional
        If True, we try to create single-statement code instead of multiple
        statements.  [default=True].

    )r*   Zdoprint)rM   Z	assign_tor6   r9   r9   r:   
maple_code  s   $r   c                 K   s   t t| fi | dS )a&  Prints the Maple representation of the given expression.

    See :func:`maple_code` for the meaning of the optional arguments.

    Examples
    ========

    >>> from sympy import print_maple_code, symbols
    >>> x, y = symbols('x y')
    >>> print_maple_code(x, assign_to=y)
    y := x
    N)printr   )rM   r6   r9   r9   r:   print_maple_code*  s   r   rD   )r   Z
sympy.corer   Zsympy.core.numbersr   r   r   Zsympy.printing.codeprinterr   Zsympy.printing.precedencer   r   r   Z_known_func_same_namer2   Z_funcr&   ZExp1r'   Z
EulerGammaZGoldenRatiorn   rk   ZComplexInfinityZnot_supported_symbolr*   r   r   r9   r9   r9   r:   <module>   s    
	
$
 
0'