U
     ‹ÑhÇc  ã                1   @  s6  d Z ddlmZ ddlmZ ddl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mZ dd	lmZ 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/d0d1d2d3d4d5d6d7d8d9d:g1Zd;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSœZG dTdU„ dUeƒZd[dWdX„ZdYdZ„ ZdVS )\ai  
Octave (and Matlab) code printer

The `OctaveCodePrinter` converts SymPy expressions into Octave expressions.
It uses a subset of the Octave language for Matlab compatibility.

A complete code generator, which uses `octave_code` extensively, can be found
in `sympy.utilities.codegen`.  The `codegen` module can be used to generate
complete source code files.

é    )Úannotations)ÚAny)ÚMulÚPowÚSÚRational)Ú_keep_coeff)Úequal_valued)ÚCodePrinter)Ú
precedenceÚ
PRECEDENCE©ÚsearchÚsinÚcosÚtanZcotÚsecZcscÚasinÚacosZacotÚatanÚatan2ZasecZacscÚsinhÚcoshÚtanhZcothZcschZsechÚasinhÚacoshÚatanhZacothZasechZacschÚerfcZerfiÚerfZerfinvZerfcinvZbesseliÚbesseljZbesselkÚbesselyZ	bernoulliÚbetaZeulerÚexpÚ	factorialÚfloorZfresnelcZfresnelsÚgammaZharmonicÚlogZpolylogÚsignÚzetaZlegendreÚabsZangleZbincoeffÚceilZ
chebyshevUZ
chebyshevTZcoshintZcosintZconjZdiracZ	heavisideÚimagZ	laguerreLZlambertwZlogintZgammalnÚmaxÚminÚmodÚpsiÚrealZ
pochhammerZsinhintZsinint)ZAbsÚargZbinomialZceilingZ
chebyshevuZ
chebyshevtÚChiZCiÚ	conjugateZ
DiracDeltaZ	HeavisideZimZlaguerreZLambertWÚliZloggammaZMaxZMinZModZ	polygammaÚreZRisingFactorialZShiZSic                      s  e Zd ZU dZdZdZddddœZeej	fdi d	d	d
œŽZ	de
d< i f‡ 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/d0„ Zd1d2„ Zd3d4„ Zd5d6„ Zd7d8„ Z e Z!e Z"e Z#d9d:„ Z$d;d<„ Z%d=d>„ Z&d?d@„ Z'dAdB„ Z(dCdD„ Z)dEdF„ Z*dGdH„ Z+dIdJ„ Z,dKdL„ Z-dMdN„ Z.dOdP„ Z/dQdR„ Z0dSdT„ Z1dUdV„ Z2dWdX„ Z3dYdZ„ Z4d[d\„ Z5d]d^„ Z6d_d`„ Z7dadb„ Z8dcdd„ Z9dedf„ Z:dgdh„ Z;didj„ Z<dkdl„ Z=e= Z>Z?dmdn„ Z@e@ ZAZBdodp„ ZCdqdr„ ZDdsdt„ ZE‡  ZFS )uÚOctaveCodePrinterzL
    A printer to convert expressions to strings of Octave/Matlab code.
    Z_octaveZOctaveú&ú|ú~)ÚandÚorÚnoté   T)Z	precisionÚuser_functionsÚcontractÚinlinezdict[str, Any]Ú_default_settingsc                   sH   t ƒ  |¡ ttttƒƒ| _| j ttƒ¡ | di ¡}| j |¡ d S )Nr>   )	ÚsuperÚ__init__ÚdictÚzipÚknown_fcns_src1Úknown_functionsÚupdateÚknown_fcns_src2Úget)ÚselfÚsettingsZ	userfuncs©Ú	__class__© úC/tmp/user/2202/pip-unpacked-wheel-qe3242ng/sympy/printing/octave.pyrC   Y   s
    zOctaveCodePrinter.__init__c                 C  s   |d S )Né   rO   )rK   ÚprO   rO   rP   Ú_rate_index_positiona   s    z&OctaveCodePrinter._rate_index_positionc                 C  s   d| S )Nz%s;rO   )rK   Z
codestringrO   rO   rP   Ú_get_statemente   s    z OctaveCodePrinter._get_statementc                 C  s
   d  |¡S )Nz% {}©Úformat)rK   ÚtextrO   rO   rP   Ú_get_commenti   s    zOctaveCodePrinter._get_commentc                 C  s   d  ||¡S )Nz{} = {};rU   )rK   ÚnameÚvaluerO   rO   rP   Ú_declare_number_constm   s    z'OctaveCodePrinter._declare_number_constc                 C  s
   |   |¡S ©N)Úindent_code)rK   ÚlinesrO   rO   rP   Ú_format_codeq   s    zOctaveCodePrinter._format_codec                   s    |j \‰ }‡ fdd„t|ƒD ƒS )Nc                 3  s$   | ]}t ˆ ƒD ]}||fV  qqd S r\   )Úrange)Ú.0ÚjÚi©ÚrowsrO   rP   Ú	<genexpr>x   s     
  z=OctaveCodePrinter._traverse_matrix_indices.<locals>.<genexpr>)Úshaper`   )rK   ÚmatÚcolsrO   rd   rP   Ú_traverse_matrix_indicesu   s    
z*OctaveCodePrinter._traverse_matrix_indicesc                 C  s^   g }g }|D ]H}t | j|j|jd |jd gƒ\}}}| d|||f ¡ | d¡ q||fS )Né   zfor %s = %s:%sÚend)ÚmapÚ_printÚlabelÚlowerÚupperÚappend)rK   ÚindicesZ
open_linesZclose_linesrc   ÚvarÚstartÚstoprO   rO   rP   Ú_get_loop_opening_ending{   s    ÿ
z*OctaveCodePrinter._get_loop_opening_endingc                   s‚  |j r.|jr.tj| jr.dˆ tj | ¡ S t|ƒ‰ | ¡ \}}|dk r\t| |ƒ}d}nd}g }g }g }ˆj	dkr€| 
¡ }n
t |¡}|D ]ì}	|	j�r"|	j�r"|	jj�r"|	jj�r"|	jdkrÜ| t|	j|	j dd�¡ nDt|	jd jƒd	k�r
t|	jtƒ�r
| |	¡ | t|	j|	j ƒ¡ qŽ|	j�rp|	tjk	�rp|	jd	k�rR| t|	jƒ¡ |	jd	k�rz| t|	jƒ¡ qŽ| |	¡ qŽ|�pˆtjg}‡ ‡fd
d„|D ƒ}
‡ ‡fdd„|D ƒ}|D ]2}	|	j|k�r¶d|| |	j¡  || |	j¡< �q¶dd„ }|�s||||
ƒ S t|ƒd	k�rB|d j �r$dnd}||||
ƒ | |d  S tdd„ |D ƒƒ�rZdnd}||||
ƒ | d|||ƒ  S d S )Nz%sir   ú-Ú )ÚoldÚnoneéÿÿÿÿF)Úevaluaterk   c                   s   g | ]}ˆ  |ˆ ¡‘qS rO   ©Úparenthesize©ra   Úx©ÚprecrK   rO   rP   Ú
<listcomp>¶   s     z0OctaveCodePrinter._print_Mul.<locals>.<listcomp>c                   s   g | ]}ˆ  |ˆ ¡‘qS rO   r~   r€   r‚   rO   rP   r„   ·   s     z(%s)c                 S  sF   |d }t dt| ƒƒD ]*}| |d  jr,dnd}|| ||  }q|S )Nr   rk   Ú*ú.*)r`   ÚlenÚ	is_number)ÚaÚa_strÚrrc   ZmulsymrO   rO   rP   Úmultjoin¿   s
    z.OctaveCodePrinter._print_Mul.<locals>.multjoinú/ú./c                 s  s   | ]}|j V  qd S r\   ©rˆ   )ra   ZbirO   rO   rP   rf   Í   s     z/OctaveCodePrinter._print_Mul.<locals>.<genexpr>)rˆ   Zis_imaginaryr   ZImaginaryUnitZ
is_Integerrn   r   Zas_coeff_Mulr   ÚorderZas_ordered_factorsr   Z	make_argsÚis_commutativeZis_Powr"   Zis_RationalZis_negativerr   r   Úbaser‡   ÚargsÚ
isinstanceÚInfinityrR   r   ÚqZOneÚindexÚall)rK   ÚexprÚcÚer'   r‰   ÚbZ	pow_parenr“   ÚitemrŠ   Zb_strrŒ   ZdivsymrO   r‚   rP   Ú
_print_Mul‡   sb    
ÿ


ÿ
$
$ÿÿzOctaveCodePrinter._print_Mulc                 C  s,   |   |j¡}|   |j¡}|j}d |||¡S )Nz{} {} {})rn   ÚlhsÚrhsZrel_oprV   )rK   r™   Úlhs_codeÚrhs_codeÚoprO   rO   rP   Ú_print_RelationalÑ   s    z#OctaveCodePrinter._print_Relationalc                 C  sÒ   t dd„ |jD ƒƒrdnd}t|ƒ}t|jdƒr@d|  |j¡ S |jr°t|jdƒrz|jjr^dnd	}d
| d|  |j¡  S t|jdƒr°|jjr’dnd	}d
| d|  	|j|¡  S d|  	|j|¡||  	|j|¡f S )Nc                 s  s   | ]}|j V  qd S r\   r�   r€   rO   rO   rP   rf   Ø   s     z/OctaveCodePrinter._print_Pow.<locals>.<genexpr>ú^z.^g      à?zsqrt(%s)g      à¿r�   rŽ   Ú1r|   ú%sz%s%s%s)
r˜   r“   r   r	   r"   rn   r’   r‘   rˆ   r   )rK   r™   Z	powsymbolÚPRECÚsymrO   rO   rP   Ú
_print_Pow×   s    ÿzOctaveCodePrinter._print_Powc                 C  s(   t |ƒ}d|  |j|¡|  |j|¡f S )Nz%s^%s)r   r   r’   r"   ©rK   r™   r¨   rO   rO   rP   Ú_print_MatPowë   s    ÿzOctaveCodePrinter._print_MatPowc                 C  s(   t |ƒ}d|  |j|¡|  |j|¡f S )Nz%s \ %s)r   r   ZmatrixZvectorr«   rO   rO   rP   Ú_print_MatrixSolveð   s    ÿz$OctaveCodePrinter._print_MatrixSolvec                 C  s   dS )NÚpirO   ©rK   r™   rO   rO   rP   Ú	_print_Piõ   s    zOctaveCodePrinter._print_Pic                 C  s   dS )NZ1irO   r¯   rO   rO   rP   Ú_print_ImaginaryUnitù   s    z&OctaveCodePrinter._print_ImaginaryUnitc                 C  s   dS )Nzexp(1)rO   r¯   rO   rO   rP   Ú_print_Exp1ý   s    zOctaveCodePrinter._print_Exp1c                 C  s   dS )Nz(1+sqrt(5))/2rO   r¯   rO   rO   rP   Ú_print_GoldenRatio  s    z$OctaveCodePrinter._print_GoldenRatioc                 C  sä   ddl m} ddlm} ddlm} |j}|j}| jd s�t	|j|ƒr�g }g }|j
D ]"\}	}
| |||	ƒ¡ | |
¡ qT|t||ƒŽ }|  |¡S | jd rº| |¡s®| |¡rº|  ||¡S |  |¡}|  |¡}|  d||f ¡S d S )Nr   )Ú
Assignment)Ú	Piecewise)ÚIndexedBaser@   r?   z%s = %s)Zsympy.codegen.astr´   Z$sympy.functions.elementary.piecewiserµ   Zsympy.tensor.indexedr¶   rŸ   r    Ú	_settingsr”   r“   rr   rE   rn   ZhasZ_doprint_loopsrT   )rK   r™   r´   rµ   r¶   rŸ   r    ZexpressionsZ
conditionsr›   rš   Útempr¡   r¢   rO   rO   rP   Ú_print_Assignment  s(    
ÿ

z#OctaveCodePrinter._print_Assignmentc                 C  s   dS )NÚinfrO   r¯   rO   rO   rP   Ú_print_Infinity$  s    z!OctaveCodePrinter._print_Infinityc                 C  s   dS )Nz-infrO   r¯   rO   rO   rP   Ú_print_NegativeInfinity(  s    z)OctaveCodePrinter._print_NegativeInfinityc                 C  s   dS )NÚNaNrO   r¯   rO   rO   rP   Ú
_print_NaN,  s    zOctaveCodePrinter._print_NaNc                   s    dd  ‡ fdd„|D ƒ¡ d S )NÚ{ú, c                 3  s   | ]}ˆ   |¡V  qd S r\   ©rn   ©ra   r‰   ©rK   rO   rP   rf   1  s     z0OctaveCodePrinter._print_list.<locals>.<genexpr>Ú}©Újoinr¯   rO   rÃ   rP   Ú_print_list0  s    zOctaveCodePrinter._print_listc                 C  s   dS )NÚtruerO   r¯   rO   rO   rP   Ú_print_BooleanTrue7  s    z$OctaveCodePrinter._print_BooleanTruec                 C  s   dS )NÚfalserO   r¯   rO   rO   rP   Ú_print_BooleanFalse;  s    z%OctaveCodePrinter._print_BooleanFalsec                 C  s   t |ƒ ¡ S r\   )Ústrrp   r¯   rO   rO   rP   Ú_print_bool?  s    zOctaveCodePrinter._print_boolc                   sr   ˆ j ˆ jfdkrdS tjˆ jkr0dˆ j ˆ jf S ˆ j ˆ jfdkrNˆ ˆ d ¡S dd ‡ ‡fdd„tˆ j ƒD ƒ¡ S )	N)r   r   z[]zzeros(%s, %s))rk   rk   z[%s]z; c                 3  s2   | ]*}d   ‡fdd„ˆ |dd…f D ƒ¡V  qdS )ú c                   s   g | ]}ˆ   |¡‘qS rO   rÁ   rÂ   rÃ   rO   rP   r„   P  s     zAOctaveCodePrinter._print_MatrixBase.<locals>.<genexpr>.<listcomp>NrÅ   )ra   r‹   ©ÚArK   rO   rP   rf   P  s   ÿz6OctaveCodePrinter._print_MatrixBase.<locals>.<genexpr>)re   ri   r   ZZerorg   rn   rÆ   r`   )rK   rÐ   rO   rÏ   rP   Ú_print_MatrixBaseG  s    ÿz#OctaveCodePrinter._print_MatrixBasec                 C  sx   ddl m} | ¡ }|dd„ |D ƒgƒ}|dd„ |D ƒgƒ}|dd„ |D ƒgƒ}d|  |¡|  |¡|  |¡|j|jf S )Nr   )ÚMatrixc                 S  s   g | ]}|d  d ‘qS )r   rk   rO   ©ra   ÚkrO   rO   rP   r„   X  s     z<OctaveCodePrinter._print_SparseRepMatrix.<locals>.<listcomp>c                 S  s   g | ]}|d  d  ‘qS )rk   rO   rÓ   rO   rO   rP   r„   Y  s     c                 S  s   g | ]}|d  ‘qS )é   rO   rÓ   rO   rO   rP   r„   Z  s     zsparse(%s, %s, %s, %s, %s))Zsympy.matricesrÒ   Zcol_listrn   re   ri   )rK   rÐ   rÒ   ÚLÚIÚJZAIJrO   rO   rP   Ú_print_SparseRepMatrixT  s      ÿz(OctaveCodePrinter._print_SparseRepMatrixc                 C  s.   | j |jtd dd�d|jd |jd f  S )NZAtomT)Ústrictz(%s, %s)rk   )r   Úparentr   rc   rb   r¯   rO   rO   rP   Ú_print_MatrixElement_  s    ÿz&OctaveCodePrinter._print_MatrixElementc                   sL   ‡ fdd„}ˆ   |j¡d ||j|jjd ƒ d ||j|jjd ƒ d S )Nc                   sŒ   | d d }| d }| d }ˆ   |¡}||kr2dnˆ   |¡}|dkrr|dkrX||krXdS ||krd|S |d | S nd |ˆ   |¡|f¡S d S )Nr   rk   rÕ   rl   ú:)rn   rÆ   )r�   ZlimÚlÚhÚstepZlstrZhstrrÃ   rO   rP   Ústrslicee  s    
z6OctaveCodePrinter._print_MatrixSlice.<locals>.strsliceú(r   rÀ   rk   ú))rn   rÛ   Zrowslicerg   Zcolslice)rK   r™   rá   rO   rÃ   rP   Ú_print_MatrixSliced  s    ÿÿþþz$OctaveCodePrinter._print_MatrixSlicec                   s0   ‡ fdd„|j D ƒ}dˆ  |jj¡d |¡f S )Nc                   s   g | ]}ˆ   |¡‘qS rO   rÁ   )ra   rc   rÃ   rO   rP   r„   z  s     z4OctaveCodePrinter._print_Indexed.<locals>.<listcomp>z%s(%s)rÀ   )rs   rn   r’   ro   rÆ   )rK   r™   ZindsrO   rÃ   rP   Ú_print_Indexedy  s    z OctaveCodePrinter._print_Indexedc                 C  s   |   |j¡S r\   )rn   ro   r¯   rO   rO   rP   Ú
_print_Idx~  s    zOctaveCodePrinter._print_Idxc                   s&   t d ‰ dt‡ ‡fdd„|jD ƒƒ S )Nr   zdouble(%s == %s)c                 3  s   | ]}ˆ  |ˆ ¡V  qd S r\   r~   r€   r‚   rO   rP   rf   „  s   ÿz:OctaveCodePrinter._print_KroneckerDelta.<locals>.<genexpr>)r   Útupler“   r¯   rO   r‚   rP   Ú_print_KroneckerDelta‚  s    ÿz'OctaveCodePrinter._print_KroneckerDeltac                   s   d  ‡ ‡fdd„ˆ jD ƒ¡S )Nr†   c                   s   g | ]}ˆ  |tˆ ƒ¡‘qS rO   )r   r   )ra   r1   ©r™   rK   rO   rP   r„   ˆ  s   ÿz<OctaveCodePrinter._print_HadamardProduct.<locals>.<listcomp>)rÆ   r“   r¯   rO   ré   rP   Ú_print_HadamardProduct‡  s    ÿz(OctaveCodePrinter._print_HadamardProductc                 C  s*   t |ƒ}d |  |j|¡|  |j|¡g¡S )Nz.**)r   rÆ   r   r’   r"   r«   rO   rO   rP   Ú_print_HadamardPower‹  s
    þz&OctaveCodePrinter._print_HadamardPowerc                   sP   |j }t|ƒdkr,|d |d kr,|d g}d ‡ fdd„|D ƒ¡}d| d S )	NrÕ   r   rk   rÀ   c                 3  s   | ]}ˆ   |¡V  qd S r\   rÁ   )ra   ÚnrÃ   rO   rP   rf   –  s     z4OctaveCodePrinter._print_Identity.<locals>.<genexpr>zeye(rã   )rg   r‡   rÆ   )rK   r™   rg   ÚsrO   rÃ   rP   Ú_print_Identity’  s
    
z!OctaveCodePrinter._print_Identityc                 C  s$   d  |  |jd ¡|  |jd ¡¡S )Nz (gammainc({1}, {0}).*gamma({0}))r   rk   ©rV   rn   r“   r¯   rO   rO   rP   Ú_print_lowergamma™  s     ÿz#OctaveCodePrinter._print_lowergammac                 C  s$   d  |  |jd ¡|  |jd ¡¡S )Nz)(gammainc({1}, {0}, 'upper').*gamma({0}))r   rk   rï   r¯   rO   rO   rP   Ú_print_uppergammaŸ  s     ÿz#OctaveCodePrinter._print_uppergammac                 C  s   d|   |jd tj ¡ S )Nzsinc(%s)r   )rn   r“   r   ÚPir¯   rO   rO   rP   Ú_print_sinc¤  s    zOctaveCodePrinter._print_sincc                 C  s   d|   |j¡|   |j¡f S )Nzbesselh(%s, 1, %s)©rn   r�   Úargumentr¯   rO   rO   rP   Ú_print_hankel1©  s    
ÿz OctaveCodePrinter._print_hankel1c                 C  s   d|   |j¡|   |j¡f S )Nzbesselh(%s, 2, %s)rô   r¯   rO   rO   rP   Ú_print_hankel2®  s    
ÿz OctaveCodePrinter._print_hankel2c                 C  sD   ddl m}m} |j}|tjd|  ƒ||jtj |ƒ }|  |¡S )Nr   )Úsqrtr   rÕ   )	Úsympy.functionsrø   r   rõ   r   rò   r�   ÚHalfrn   )rK   r™   rø   r   r�   Úexpr2rO   rO   rP   Ú	_print_jn´  s    $zOctaveCodePrinter._print_jnc                 C  sD   ddl m}m} |j}|tjd|  ƒ||jtj |ƒ }|  |¡S )Nr   )rø   r    rÕ   )	rù   rø   r    rõ   r   rò   r�   rú   rn   )rK   r™   rø   r    r�   rû   rO   rO   rP   Ú	_print_yn»  s    $zOctaveCodePrinter._print_ync                 C  s   d|   |jd ¡ S )Nzairy(0, %s)r   ©rn   r“   r¯   rO   rO   rP   Ú_print_airyaiÂ  s    zOctaveCodePrinter._print_airyaic                 C  s   d|   |jd ¡ S )Nzairy(1, %s)r   rþ   r¯   rO   rO   rP   Ú_print_airyaiprimeÆ  s    z$OctaveCodePrinter._print_airyaiprimec                 C  s   d|   |jd ¡ S )Nzairy(2, %s)r   rþ   r¯   rO   rO   rP   Ú_print_airybiÊ  s    zOctaveCodePrinter._print_airybic                 C  s   d|   |jd ¡ S )Nzairy(3, %s)r   rþ   r¯   rO   rO   rP   Ú_print_airybiprimeÎ  s    z$OctaveCodePrinter._print_airybiprimec                 C  s*   |j \}}|dkr|  |¡S d|  |¡ S )Nrk   z
expint(%s))r“   Ú_print_not_supportedrn   )rK   r™   Úmur�   rO   rO   rP   Ú_print_expintÒ  s    

zOctaveCodePrinter._print_expintc                   sD   t |jƒdkst‚djˆ j|jj d ‡ fdd„t|jƒD ƒ¡d�S )NrÕ   z{name}({args})rÀ   c                   s   g | ]}ˆ   |¡‘qS rO   rÁ   r€   rÃ   rO   rP   r„   Ý  s     z?OctaveCodePrinter._one_or_two_reversed_args.<locals>.<listcomp>)rY   r“   )	r‡   r“   ÚAssertionErrorrV   rG   rN   Ú__name__rÆ   Úreversedr¯   rO   rÃ   rP   Ú_one_or_two_reversed_argsÙ  s
    þz+OctaveCodePrinter._one_or_two_reversed_argsc              	   C  s<   dj | j|jj |  |jd ¡|  |j|jdd … Ž ¡d�S )Nz{name}({arg1}, {arg2})r   rk   )rY   Zarg1Zarg2)rV   rG   rN   r  rn   r“   Úfuncr¯   rO   rO   rP   Ú_nested_binary_math_funcä  s
    ýz*OctaveCodePrinter._nested_binary_math_funcc           
        s,  |j d jdkrtdƒ‚g }ˆ jd r~‡ fdd„|j d d… D ƒ}dˆ  |j d j¡ }d |¡| d	t|ƒ  }d
| d	 S t|j ƒD ]”\}\}}|dkr²| 	dˆ  |¡ ¡ n:|t|j ƒd krØ|dkrØ| 	d¡ n| 	dˆ  |¡ ¡ ˆ  |¡}	| 	|	¡ |t|j ƒd krˆ| 	d¡ qˆd |¡S d S )Nr|   Tz¼All 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.r@   c                   s(   g | ] \}}d   ˆ  |¡ˆ  |¡¡‘qS )z({0}).*({1}) + (~({0})).*()rV   rn   )ra   r›   rš   rÃ   rO   rP   r„   ü  s
   þ ÿz6OctaveCodePrinter._print_Piecewise.<locals>.<listcomp>r§   z ...
rã   râ   r   zif (%s)rk   Úelsezelseif (%s)rl   Ú
)
r“   ZcondÚ
ValueErrorr·   rn   r™   rÆ   r‡   Ú	enumeraterr   )
rK   r™   r^   ZecpairsZelastÚpwrc   r›   rš   Zcode0rO   rÃ   rP   Ú_print_Piecewiseî  s*    

þ

z"OctaveCodePrinter._print_Piecewisec                 C  s0   t |jƒdkr"d|  |jd ¡ S |  |¡S d S )Nrk   zzeta(%s)r   )r‡   r“   rn   r  r¯   rO   rO   rP   Ú_print_zeta  s    zOctaveCodePrinter._print_zetac           
        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 linesTry   z  )z
^function z^if ú^elseif ú^else$z^for )z^end$r  r  c                 S  s   g | ]}|  d ¡‘qS )z 	)Úlstrip)ra   ÚlinerO   rO   rP   r„   (  s     z1OctaveCodePrinter.indent_code.<locals>.<listcomp>c                   s&   g | ]‰ t t‡ fd d„ˆD ƒƒƒ‘qS )c                 3  s   | ]}t |ˆ ƒV  qd S r\   r   ©ra   r5   ©r  rO   rP   rf   *  s     ú;OctaveCodePrinter.indent_code.<locals>.<listcomp>.<genexpr>©ÚintÚany©ra   )Ú	inc_regexr  rP   r„   *  s   ÿc                   s&   g | ]‰ t t‡ fd d„ˆD ƒƒƒ‘qS )c                 3  s   | ]}t |ˆ ƒV  qd S r\   r   r  r  rO   rP   rf   ,  s     r  r  r  )Ú	dec_regexr  rP   r„   ,  s   ÿr   )ry   r  z%s%s)r”   rÌ   r]   Ú
splitlinesrÆ   r  rr   )
rK   ÚcodeZ
code_linesÚtabZincreaseZdecreaseÚprettyÚlevelrì   r  rO   )r  r  rP   r]     s.    


ÿ
ÿ
zOctaveCodePrinter.indent_code)Gr  Ú
__module__Ú__qualname__Ú__doc__ZprintmethodÚlanguageÚ
_operatorsrD   r
   rA   Ú__annotations__rC   rS   rT   rX   r[   r_   rj   rw   rž   r¤   rª   r¬   r­   r°   r±   r²   r³   r¹   r»   r¼   r¾   rÇ   Z_print_tupleZ_print_TupleZ_print_ListrÉ   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	  Z_print_DiracDeltaZ_print_LambertWr  Z
_print_MaxZ
_print_Minr  r  r]   Ú__classcell__rO   rO   rM   rP   r6   A   sŒ   
ýüJ%r6   Nc                 K  s   t |ƒ | |¡S )aŠ  Converts `expr` to a string of Octave (or Matlab) code.

    The string uses a subset of the Octave language for Matlab compatibility.

    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].

    Examples
    ========

    >>> from sympy import octave_code, symbols, sin, pi
    >>> x = symbols('x')
    >>> octave_code(sin(x).series(x).removeO())
    'x.^5/120 - x.^3/6 + x'

    >>> from sympy import Rational, ceiling
    >>> x, y, tau = symbols("x, y, tau")
    >>> octave_code((2*tau)**Rational(7, 2))
    '8*sqrt(2)*tau.^(7/2)'

    Note that element-wise (Hadamard) operations are used by default between
    symbols.  This is because its very common in Octave to write "vectorized"
    code.  It is harmless if the values are scalars.

    >>> octave_code(sin(pi*x*y), assign_to="s")
    's = sin(pi*x.*y);'

    If you need a matrix product "*" or matrix power "^", you can specify the
    symbol as a ``MatrixSymbol``.

    >>> from sympy import Symbol, MatrixSymbol
    >>> n = Symbol('n', integer=True, positive=True)
    >>> A = MatrixSymbol('A', n, n)
    >>> octave_code(3*pi*A**3)
    '(3*pi)*A^3'

    This class uses several rules to decide which symbol to use a product.
    Pure numbers use "*", Symbols use ".*" and MatrixSymbols use "*".
    A HadamardProduct can be used to specify componentwise multiplication ".*"
    of two MatrixSymbols.  There is currently there is no easy way to specify
    scalar symbols, so sometimes the code might have some minor cosmetic
    issues.  For example, suppose x and y are scalars and A is a Matrix, then
    while a human programmer might write "(x^2*y)*A^3", we generate:

    >>> octave_code(x**2*y*A**3)
    '(x.^2.*y)*A^3'

    Matrices are supported using Octave inline notation.  When using
    ``assign_to`` with matrices, the name can be specified either as a string
    or as a ``MatrixSymbol``.  The dimensions must align in the latter case.

    >>> from sympy import Matrix, MatrixSymbol
    >>> mat = Matrix([[x**2, sin(x), ceiling(x)]])
    >>> octave_code(mat, assign_to='A')
    'A = [x.^2 sin(x) ceil(x)];'

    ``Piecewise`` expressions are implemented with logical masking by default.
    Alternatively, you can pass "inline=False" to use if-else conditionals.
    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
    >>> pw = Piecewise((x + 1, x > 0), (x, True))
    >>> octave_code(pw, assign_to=tau)
    'tau = ((x > 0).*(x + 1) + (~(x > 0)).*(x));'

    Note that any expression that can be generated normally can also exist
    inside a Matrix:

    >>> mat = Matrix([[x**2, pw, sin(x)]])
    >>> octave_code(mat, assign_to='A')
    'A = [x.^2 ((x > 0).*(x + 1) + (~(x > 0)).*(x)) 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,
    cfunction_string)].  This can be used to call a custom Octave function.

    >>> from sympy import Function
    >>> f = Function('f')
    >>> g = Function('g')
    >>> custom_functions = {
    ...   "f": "existing_octave_fcn",
    ...   "g": [(lambda x: x.is_Matrix, "my_mat_fcn"),
    ...         (lambda x: not x.is_Matrix, "my_fcn")]
    ... }
    >>> mat = Matrix([[1, x]])
    >>> octave_code(f(x) + g(x) + g(mat), user_functions=custom_functions)
    'existing_octave_fcn(x) + my_fcn(x) + my_mat_fcn([1 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]))
    >>> octave_code(e.rhs, assign_to=e.lhs, contract=False)
    'Dy(i) = (y(i + 1) - y(i))./(t(i + 1) - t(i));'
    )r6   Zdoprint)r™   Z	assign_torL   rO   rO   rP   Úoctave_code;  s     	r,  c                 K  s   t t| f|Žƒ dS )zŒPrints the Octave (or Matlab) representation of the given expression.

    See `octave_code` for the meaning of the optional arguments.
    N)Úprintr,  )r™   rL   rO   rO   rP   Úprint_octave_codeÆ  s    r.  )N)r'  Ú
__future__r   Útypingr   Z
sympy.corer   r   r   r   Zsympy.core.mulr   Zsympy.core.numbersr	   Zsympy.printing.codeprinterr
   Zsympy.printing.precedencer   r   r5   r   rF   rI   r6   r,  r.  rO   rO   rO   rP   Ú<module>   sª                                      øè   }
 