U
    9%ec/                     @  s   d 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
 ddlmZmZ dd	d
dddddddddddddddddddZG dd de
Zd%d!d"Zd#d$ Zd S )&z
Javascript code printer

The JavascriptCodePrinter converts single SymPy expressions into single
Javascript expressions, using the functions defined in the Javascript
Math object where possible.

    )annotations)Any)S)equal_valued)CodePrinter)
precedence
PRECEDENCEzMath.absz	Math.acosz
Math.acoshz	Math.asinz
Math.asinhz	Math.atanz
Math.atan2z
Math.atanhz	Math.ceilzMath.cosz	Math.coshzMath.expz
Math.floorzMath.logzMath.maxzMath.minz	Math.signzMath.sinz	Math.sinhzMath.tanz	Math.tanh)ZAbsacosacoshasinasinhatanatan2atanhZceilingcoscoshexpfloorlogZMaxZMinsignsinsinhtantanhc                   @  s   e Zd ZU dZdZdZdddi dddd	Zd
ed< i 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d0d1 Zd2d3 Zd4d5 ZdS )6JavascriptCodePrinterzK"A Printer to convert Python expressions to strings of JavaScript code
    Z_javascript
JavaScriptNauto   TF)orderZ	full_prec	precisionuser_functionsZhumanZallow_unknown_functionsZcontractzdict[str, Any]_default_settingsc                 C  s2   t | | tt| _|di }| j| d S )Nr    )r   __init__dictknown_functionsgetupdate)selfsettingsZ	userfuncs r)   T/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/printing/jscode.pyr"   >   s    
zJavascriptCodePrinter.__init__c                 C  s   |d S )N   r)   )r'   pr)   r)   r*   _rate_index_positionD   s    z*JavascriptCodePrinter._rate_index_positionc                 C  s   d| S )Nz%s;r)   )r'   Z
codestringr)   r)   r*   _get_statementG   s    z$JavascriptCodePrinter._get_statementc                 C  s
   d |S )Nz// {})format)r'   textr)   r)   r*   _get_commentJ   s    z"JavascriptCodePrinter._get_commentc                 C  s   d ||| jd S )Nzvar {} = {};r   )r/   ZevalfZ	_settings)r'   namevaluer)   r)   r*   _declare_number_constM   s    z+JavascriptCodePrinter._declare_number_constc                 C  s
   |  |S N)indent_code)r'   linesr)   r)   r*   _format_codeP   s    z"JavascriptCodePrinter._format_codec                   s    |j \}  fddt|D S )Nc                 3  s$   | ]}t  D ]}||fV  qqd S r5   )range).0ijcolsr)   r*   	<genexpr>U   s     
  zAJavascriptCodePrinter._traverse_matrix_indices.<locals>.<genexpr>)shaper9   )r'   matrowsr)   r=   r*   _traverse_matrix_indicesS   s    
z.JavascriptCodePrinter._traverse_matrix_indicesc              
   C  sZ   g }g }d}|D ]@}| || |j| |j| |jd d  | d q||fS )NzAfor (var %(varble)s=%(start)s; %(varble)s<%(end)s; %(varble)s++){   )Zvarblestartend})append_printlabellowerupper)r'   indicesZ
open_linesZclose_linesZ	loopstartr;   r)   r)   r*   _get_loop_opening_endingW   s    


z.JavascriptCodePrinter._get_loop_opening_endingc                 C  s   t |}t|jdr&d| |j| S t|jdrBd| |j S |jtjd krbd| |j S d| |j| |jf S d S )Nz1/%sg      ?zMath.sqrt(%s)   zMath.cbrt(%s)zMath.pow(%s, %s))r   r   r   parenthesizebaserI   r   One)r'   exprPRECr)   r)   r*   
_print_Powd   s    
z JavascriptCodePrinter._print_Powc                 C  s"   t |jt |j }}d||f S )Nz%d/%d)intr,   q)r'   rT   r,   rX   r)   r)   r*   _print_Rationalp   s    z%JavascriptCodePrinter._print_Rationalc                   sn   |j \}}t|  fdd|j D \}}|jr8|jsD|jrR|jrR| d| S d| d| d| d| S )Nc                   s   g | ]} | qS r)   )rQ   )r:   argrU   r'   r)   r*   
<listcomp>w   s     z4JavascriptCodePrinter._print_Mod.<locals>.<listcomp>z % z((z) + z) % )argsr   Zis_nonnegativeZis_nonpositive)r'   rT   numZdenZsnumZsdenr)   r[   r*   
_print_Modt   s    
z JavascriptCodePrinter._print_Modc                 C  s,   |  |j}|  |j}|j}d|||S )Nz{} {} {})rI   lhsrhsZrel_opr/   )r'   rT   Zlhs_codeZrhs_codeopr)   r)   r*   _print_Relational   s    z'JavascriptCodePrinter._print_Relationalc                 C  s`   |j }tj}tj}tt|jD ]"}||j| | 7 }||| 9 }q d| |j	j
| |f S )Nz%s[%s])r@   r   ZZerorS   reversedr9   ZrankrM   rI   rR   rJ   )r'   rT   Zdimselemoffsetr;   r)   r)   r*   _print_Indexed   s    z$JavascriptCodePrinter._print_Indexedc                 C  s   |  |jS r5   )rI   rJ   r'   rT   r)   r)   r*   
_print_Idx   s    z JavascriptCodePrinter._print_Idxc                 C  s   dS )NzMath.Er)   rh   r)   r)   r*   _print_Exp1   s    z!JavascriptCodePrinter._print_Exp1c                 C  s   dS )NzMath.PIr)   rh   r)   r)   r*   	_print_Pi   s    zJavascriptCodePrinter._print_Pic                 C  s   dS )NzNumber.POSITIVE_INFINITYr)   rh   r)   r)   r*   _print_Infinity   s    z%JavascriptCodePrinter._print_Infinityc                 C  s   dS )NzNumber.NEGATIVE_INFINITYr)   rh   r)   r)   r*   _print_NegativeInfinity   s    z-JavascriptCodePrinter._print_NegativeInfinityc           
        s"  ddl m} |jd jdkr$tdg }||rt|jD ]\}\}}|dkrf|d |  n:|t	|jd kr|dkr|d n|d	 |   |}|| |d
 q<d
|S  fdd|jd d D }d |jd j }	d
||	 d
dt	| g S d S )Nr   )
AssignmentrO   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.z	if (%s) {rD   zelse {zelse if (%s) {rG   
c                   s(   g | ] \}}d   |  |f qS )z((%s) ? (
%s
)
)rI   )r:   ecr'   r)   r*   r\      s   z:JavascriptCodePrinter._print_Piecewise.<locals>.<listcomp>z: (
%s
)z:  ))Zsympy.codegen.astrn   r]   Zcond
ValueErrorhas	enumeraterH   rI   lenjoinrT   )
r'   rT   rn   r7   r;   rp   rq   Zcode0Zecpairs	last_liner)   rr   r*   _print_Piecewise   s(    




z&JavascriptCodePrinter._print_Piecewisec                 C  s2   d | j|jtd dd|j|j|jjd   S )Nz{}[{}]ZAtomT)strictrD   )r/   rQ   parentr   r<   r;   r@   rh   r)   r)   r*   _print_MatrixElement   s     z*JavascriptCodePrinter._print_MatrixElementc           
        s   t |tr$| |d}d|S d}dd dd |D }fdd|D } fd	d|D }g }d
}t|D ]J\}}	|	dkr||	 qr||| 8 }|d|| |	f  ||| 7 }qr|S )z0Accepts a string of code or a list of code linesT z   ){(z{
z(
)rG   rt   c                 S  s   g | ]}| d qS )z 	)lstripr:   liner)   r)   r*   r\      s     z5JavascriptCodePrinter.indent_code.<locals>.<listcomp>c                   s    g | ]}t tt|j qS r)   )rW   anymapendswithr   )	inc_tokenr)   r*   r\      s     c                   s    g | ]}t tt|j qS r)   )rW   r   r   
startswithr   )	dec_tokenr)   r*   r\      s   r   )r   ro   z%s%s)
isinstancestrr6   
splitlinesry   rw   rH   )
r'   codeZ
code_linestabZincreaseZdecreaseprettylevelnr   r)   )r   r   r*   r6      s*    



z!JavascriptCodePrinter.indent_code)__name__
__module____qualname____doc__Zprintmethodlanguager!   __annotations__r"   r-   r.   r1   r4   r8   rC   rN   rV   rY   r_   rc   rg   ri   rj   rk   rl   rm   r{   r~   r6   r)   r)   r)   r*   r   .   s@   


!r   Nc                 K  s   t || |S )a  Converts an expr to a string of javascript 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 is helpful in case of
        line-wrapping, or for expressions that generate multi-line statements.
    precision : integer, optional
        The precision for numbers such as pi [default=15].
    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, js_function_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].

    Examples
    ========

    >>> from sympy import jscode, symbols, Rational, sin, ceiling, Abs
    >>> x, tau = symbols("x, tau")
    >>> jscode((2*tau)**Rational(7, 2))
    '8*Math.sqrt(2)*Math.pow(tau, 7/2)'
    >>> jscode(sin(x), assign_to="s")
    's = Math.sin(x);'

    Custom printing can be defined for certain types by passing a dictionary of
    "type" : "function" to the ``user_functions`` kwarg. Alternatively, the
    dictionary value can be a list of tuples i.e. [(argument_test,
    js_function_string)].

    >>> custom_functions = {
    ...   "ceiling": "CEIL",
    ...   "Abs": [(lambda x: not x.is_integer, "fabs"),
    ...           (lambda x: x.is_integer, "ABS")]
    ... }
    >>> jscode(Abs(x) + ceiling(x), user_functions=custom_functions)
    'fabs(x) + CEIL(x)'

    ``Piecewise`` expressions are converted into conditionals. If an
    ``assign_to`` variable is provided an if statement is created, otherwise
    the ternary operator is used. Note that if the ``Piecewise`` lacks a
    default term, represented by ``(expr, True)`` then an error will be thrown.
    This is to prevent generating an expression that may not evaluate to
    anything.

    >>> from sympy import Piecewise
    >>> expr = Piecewise((x + 1, x > 0), (x, True))
    >>> print(jscode(expr, tau))
    if (x > 0) {
       tau = x + 1;
    }
    else {
       tau = x;
    }

    Support for loops is provided through ``Indexed`` types. With
    ``contract=True`` these expressions will be turned into loops, whereas
    ``contract=False`` will just print the assignment expression that should be
    looped over:

    >>> from sympy import Eq, IndexedBase, Idx
    >>> len_y = 5
    >>> y = IndexedBase('y', shape=(len_y,))
    >>> t = IndexedBase('t', shape=(len_y,))
    >>> Dy = IndexedBase('Dy', shape=(len_y-1,))
    >>> i = Idx('i', len_y-1)
    >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
    >>> jscode(e.rhs, assign_to=e.lhs, contract=False)
    'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'

    Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions
    must be provided to ``assign_to``. Note that any expression that can be
    generated normally can also exist inside a Matrix:

    >>> from sympy import Matrix, MatrixSymbol
    >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
    >>> A = MatrixSymbol('A', 3, 1)
    >>> print(jscode(mat, A))
    A[0] = Math.pow(x, 2);
    if (x > 0) {
       A[1] = x + 1;
    }
    else {
       A[1] = x;
    }
    A[2] = Math.sin(x);
    )r   Zdoprint)rT   Z	assign_tor(   r)   r)   r*   jscode   s    ir   c                 K  s   t t| f| dS )zPrints the Javascript representation of the given expression.

       See jscode for the meaning of the optional arguments.
    N)printr   )rT   r(   r)   r)   r*   print_jscodeN  s    r   )N)r   
__future__r   typingr   Z
sympy.corer   Zsympy.core.numbersr   Zsympy.printing.codeprinterr   Zsympy.printing.precedencer   r   r$   r   r   r   r)   r)   r)   r*   <module>   s@   	 5
l