o
    !ôj×Š  ã                   @   sš  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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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$m%Z% d dl&m'Z' d dl(m)Z)m*Z*m+Z+ G dd„ deƒZ,G dd„ de,ed�Z-G dd„ de,ƒZ.G dd„ de.ƒZ/G dd„ de.ƒZ0G dd„ de,ƒZ1d)d!d"„Z2G d#d$„ d$e,ƒZ3G d%d&„ d&e3ƒZ4G d'd(„ d(e3ƒZ5d S )*é    )ÚBasic)Úcacheit)ÚTuple)Úcall_highest_priority)Úglobal_parameters)ÚAppliedUndefÚexpand©ÚMul)ÚInteger)ÚEq)ÚSÚ	Singleton)Úordered)ÚDummyÚSymbolÚWild©Úsympify)ÚMatrix)ÚlcmÚfactor)ÚIntervalÚIntersection)ÚIdx)ÚflattenÚis_sequenceÚiterablec                   @   s  e Zd ZdZdZdZedd„ ƒZdd„ Ze	dd	„ ƒZ
e	d
d„ ƒZe	dd„ ƒZe	dd„ ƒZe	dd„ ƒZe	dd„ ƒZe	dd„ ƒZedd„ ƒZdd„ Zdd„ Zdd„ Zdd„ Zd d!„ Zd"d#„ Zed$ƒd%d&„ ƒZd'd(„ Zed)ƒd*d+„ ƒZd,d-„ Zd.d/„ Zed0ƒd1d2„ ƒZd3d4„ Z d5d6„ Z!d:d8d9„Z"d7S );ÚSeqBasezBase class for sequencesTé   c                 C   s(   z| j }W |S  ty   tj}Y |S w )z[Return start (if possible) else S.Infinity.

        adapted from Set._infimum_key
        )ÚstartÚNotImplementedErrorr   ÚInfinity)Úexprr    © r$   úi/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/sympy/series/sequences.pyÚ
_start_key    s   þþzSeqBase._start_keyc                 C   s   t | j|jƒ}|j|jfS )zTReturns start and stop.

        Takes intersection over the two intervals.
        )r   ÚintervalÚinfÚsup)ÚselfÚotherr'   r$   r$   r%   Ú_intersect_interval,   s   zSeqBase._intersect_intervalc                 C   ó   t d|  ƒ‚)z&Returns the generator for the sequencez(%s).gen©r!   ©r*   r$   r$   r%   Úgen4   ó   zSeqBase.genc                 C   r-   )z-The interval on which the sequence is definedz(%s).intervalr.   r/   r$   r$   r%   r'   9   r1   zSeqBase.intervalc                 C   r-   )ú:The starting point of the sequence. This point is includedz
(%s).startr.   r/   r$   r$   r%   r    >   r1   zSeqBase.startc                 C   r-   )z8The ending point of the sequence. This point is includedz	(%s).stopr.   r/   r$   r$   r%   ÚstopC   r1   zSeqBase.stopc                 C   r-   )zLength of the sequencez(%s).lengthr.   r/   r$   r$   r%   ÚlengthH   r1   zSeqBase.lengthc                 C   ó   dS )z-Returns a tuple of variables that are boundedr$   r$   r/   r$   r$   r%   Ú	variablesM   s   zSeqBase.variablesc                    s   ‡ fdd„ˆ j D ƒS )aG  
        This method returns the symbols in the object, excluding those
        that take on a specific value (i.e. the dummy symbols).

        Examples
        ========

        >>> from sympy import SeqFormula
        >>> from sympy.abc import n, m
        >>> SeqFormula(m*n**2, (n, 0, 5)).free_symbols
        {m}
        c                    s$   h | ]}|j  ˆ j¡D ]}|’qqS r$   )Úfree_symbolsÚ
differencer6   )Ú.0ÚiÚjr/   r$   r%   Ú	<setcomp>`   s    ÿz'SeqBase.free_symbols.<locals>.<setcomp>©Úargsr/   r$   r/   r%   r7   R   s   zSeqBase.free_symbolsc                 C   s0   || j k s
|| jkrtd|| jf ƒ‚|  |¡S )z#Returns the coefficient at point ptzIndex %s out of bounds %s)r    r3   Ú
IndexErrorr'   Ú_eval_coeff©r*   Úptr$   r$   r%   Úcoeffc   s   
zSeqBase.coeffc                 C   s   t d| j ƒ‚)NzhThe _eval_coeff method should be added to%s to return coefficient so it is availablewhen coeff calls it.)r!   ÚfuncrA   r$   r$   r%   r@   j   s   ýzSeqBase._eval_coeffc                 C   s<   | j tju r
| j}n| j }| j tju rd}nd}|||  S )a¯  Returns the i'th point of a sequence.

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

        If start point is negative infinity, point is returned from the end.
        Assumes the first point to be indexed zero.

        Examples
        =========

        >>> from sympy import oo
        >>> from sympy.series.sequences import SeqPer

        bounded

        >>> SeqPer((1, 2, 3), (-10, 10))._ith_point(0)
        -10
        >>> SeqPer((1, 2, 3), (-10, 10))._ith_point(5)
        -5

        End is at infinity

        >>> SeqPer((1, 2, 3), (0, oo))._ith_point(5)
        5

        Starts at negative infinity

        >>> SeqPer((1, 2, 3), (-oo, 0))._ith_point(5)
        -5
        éÿÿÿÿé   )r    r   ÚNegativeInfinityr3   )r*   r:   ÚinitialÚstepr$   r$   r%   Ú
_ith_pointp   s    zSeqBase._ith_pointc                 C   r5   )aI  
        Should only be used internally.

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

        self._add(other) returns a new, term-wise added sequence if self
        knows how to add with other, otherwise it returns ``None``.

        ``other`` should only be a sequence object.

        Used within :class:`SeqAdd` class.
        Nr$   ©r*   r+   r$   r$   r%   Ú_addœ   ó   zSeqBase._addc                 C   r5   )aS  
        Should only be used internally.

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

        self._mul(other) returns a new, term-wise multiplied sequence if self
        knows how to multiply with other, otherwise it returns ``None``.

        ``other`` should only be a sequence object.

        Used within :class:`SeqMul` class.
        Nr$   rK   r$   r$   r%   Ú_mul¬   rM   zSeqBase._mulc                 C   s
   t | |ƒS )a�  
        Should be used when ``other`` is not a sequence. Should be
        defined to define custom behaviour.

        Examples
        ========

        >>> from sympy import SeqFormula
        >>> from sympy.abc import n
        >>> SeqFormula(n**2).coeff_mul(2)
        SeqFormula(2*n**2, (n, 0, oo))

        Notes
        =====

        '*' defines multiplication of sequences with sequences only.
        r	   rK   r$   r$   r%   Ú	coeff_mul¼   s   
zSeqBase.coeff_mulc                 C   ó$   t |tƒstdt|ƒ ƒ‚t| |ƒS )a4  Returns the term-wise addition of 'self' and 'other'.

        ``other`` should be a sequence.

        Examples
        ========

        >>> from sympy import SeqFormula
        >>> from sympy.abc import n
        >>> SeqFormula(n**2) + SeqFormula(n**3)
        SeqFormula(n**3 + n**2, (n, 0, oo))
        zcannot add sequence and %s©Ú
isinstancer   Ú	TypeErrorÚtypeÚSeqAddrK   r$   r$   r%   Ú__add__Ð   s   

zSeqBase.__add__rV   c                 C   s   | | S ©Nr$   rK   r$   r$   r%   Ú__radd__á   ó   zSeqBase.__radd__c                 C   s&   t |tƒstdt|ƒ ƒ‚t| | ƒS )a7  Returns the term-wise subtraction of ``self`` and ``other``.

        ``other`` should be a sequence.

        Examples
        ========

        >>> from sympy import SeqFormula
        >>> from sympy.abc import n
        >>> SeqFormula(n**2) - (SeqFormula(n))
        SeqFormula(n**2 - n, (n, 0, oo))
        zcannot subtract sequence and %srQ   rK   r$   r$   r%   Ú__sub__å   s   
zSeqBase.__sub__rZ   c                 C   s
   |  | S rW   r$   rK   r$   r$   r%   Ú__rsub__ö   ó   
zSeqBase.__rsub__c                 C   s
   |   d¡S )zÓNegates the sequence.

        Examples
        ========

        >>> from sympy import SeqFormula
        >>> from sympy.abc import n
        >>> -SeqFormula(n**2)
        SeqFormula(-n**2, (n, 0, oo))
        rE   )rO   r/   r$   r$   r%   Ú__neg__ú   s   
zSeqBase.__neg__c                 C   rP   )a{  Returns the term-wise multiplication of 'self' and 'other'.

        ``other`` should be a sequence. For ``other`` not being a
        sequence see :func:`coeff_mul` method.

        Examples
        ========

        >>> from sympy import SeqFormula
        >>> from sympy.abc import n
        >>> SeqFormula(n**2) * (SeqFormula(n))
        SeqFormula(n**3, (n, 0, oo))
        zcannot multiply sequence and %s)rR   r   rS   rT   ÚSeqMulrK   r$   r$   r%   Ú__mul__  s   

zSeqBase.__mul__r_   c                 C   s   | | S rW   r$   rK   r$   r$   r%   Ú__rmul__  rY   zSeqBase.__rmul__c                 c   s,   � t | jƒD ]}|  |¡}|  |¡V  qd S rW   )Úranger4   rJ   rC   )r*   r:   rB   r$   r$   r%   Ú__iter__  s
   €
þzSeqBase.__iter__c                    st   t |tƒrˆ  |¡}ˆ  |¡S t |tƒr8|j|j}}|d u r!d}|d u r(ˆ j}‡ fdd„t|||j	p4dƒD ƒS d S )Nr   c                    s   g | ]
}ˆ   ˆ  |¡¡‘qS r$   )rC   rJ   )r9   r:   r/   r$   r%   Ú
<listcomp>,  ó    z'SeqBase.__getitem__.<locals>.<listcomp>rF   )
rR   ÚintrJ   rC   Úslicer    r3   r4   ra   rI   )r*   Úindexr    r3   r$   r/   r%   Ú__getitem__"  s   




ÿúzSeqBase.__getitem__Nc                    s,  ddl m‰  ‡ fdd„| d|… D ƒ}t|ƒ}|du r |d }nt||d ƒ}g }td|d ƒD ]r}d| }	g }
t|ƒD ]}|
 |||| … ¡ q<t|
ƒ}| ¡ dkr¢ˆ | t|||	… ƒ¡ƒ}||	krpt	|ddd… ƒ} n3g }
t||| ƒD ]}|
 |||| … ¡ qyt|
ƒ}|| t||	d… ƒkr¢t	|ddd… ƒ} nq0|du r©|S t|ƒ}|dkrµg dfS ||d  ||d   d||d  ||   }}t|d ƒD ]5}||| ||  7 }t|| d ƒD ]}||| ||  ||| d   8 }qè||| ||d   8 }qÔ|ˆ t
|ƒt
|ƒ ƒfS )	a£  
        Finds the shortest linear recurrence that satisfies the first n
        terms of sequence of order `\leq` ``n/2`` if possible.
        If ``d`` is specified, find shortest linear recurrence of order
        `\leq` min(d, n/2) if possible.
        Returns list of coefficients ``[b(1), b(2), ...]`` corresponding to the
        recurrence relation ``x(n) = b(1)*x(n-1) + b(2)*x(n-2) + ...``
        Returns ``[]`` if no recurrence is found.
        If gfvar is specified, also returns ordinary generating function as a
        function of gfvar.

        Examples
        ========

        >>> from sympy import sequence, sqrt, oo, lucas
        >>> from sympy.abc import n, x, y
        >>> sequence(n**2).find_linear_recurrence(10, 2)
        []
        >>> sequence(n**2).find_linear_recurrence(10)
        [3, -3, 1]
        >>> sequence(2**n).find_linear_recurrence(10)
        [2]
        >>> sequence(23*n**4+91*n**2).find_linear_recurrence(10)
        [5, -10, 10, -5, 1]
        >>> sequence(sqrt(5)*(((1 + sqrt(5))/2)**n - (-(1 + sqrt(5))/2)**(-n))/5).find_linear_recurrence(10)
        [1, 1]
        >>> sequence(x+y*(-2)**(-n), (n, 0, oo)).find_linear_recurrence(30)
        [1/2, 1/2]
        >>> sequence(3*5**n + 12).find_linear_recurrence(20,gfvar=x)
        ([6, -5], 3*(5 - 21*x)/((x - 1)*(5*x - 1)))
        >>> sequence(lucas(n)).find_linear_recurrence(15,gfvar=x)
        ([1, 1], (x - 2)/(x**2 + x - 1))
        r   ©Úsimplifyc                    s   g | ]}ˆ t |ƒƒ‘qS r$   )r   )r9   Útri   r$   r%   rc   R  s    z2SeqBase.find_linear_recurrence.<locals>.<listcomp>Né   rF   rE   )Úsympy.simplifyrj   ÚlenÚminra   Úappendr   ÚdetÚLUsolver   r   )r*   ÚnÚdZgfvarÚxZlxÚrÚcoeffsÚlÚl2ZmlistÚkÚmÚyr:   r;   r$   ri   r%   Úfind_linear_recurrence/  sL   "
€2&zSeqBase.find_linear_recurrence)NN)#Ú__name__Ú
__module__Ú__qualname__Ú__doc__Úis_commutativeÚ_op_priorityÚstaticmethodr&   r,   Úpropertyr0   r'   r    r3   r4   r6   r7   r   rC   r@   rJ   rL   rN   rO   rV   r   rX   rZ   r[   r]   r_   r`   rb   rh   r}   r$   r$   r$   r%   r      sR    








,


r   c                   @   s8   e Zd ZdZedd„ ƒZedd„ ƒZdd„ Zdd	„ Zd
S )ÚEmptySequenceaÌ  Represents an empty sequence.

    The empty sequence is also available as a singleton as
    ``S.EmptySequence``.

    Examples
    ========

    >>> from sympy import EmptySequence, SeqPer
    >>> from sympy.abc import x
    >>> EmptySequence
    EmptySequence
    >>> SeqPer((1, 2), (x, 0, 10)) + EmptySequence
    SeqPer((1, 2), (x, 0, 10))
    >>> SeqPer((1, 2)) * EmptySequence
    EmptySequence
    >>> EmptySequence.coeff_mul(-1)
    EmptySequence
    c                 C   ó   t jS rW   )r   ÚEmptySetr/   r$   r$   r%   r'   �  ó   zEmptySequence.intervalc                 C   r‡   rW   )r   ÚZeror/   r$   r$   r%   r4   “  r‰   zEmptySequence.lengthc                 C   s   | S )ú"See docstring of SeqBase.coeff_mulr$   )r*   rC   r$   r$   r%   rO   —  s   zEmptySequence.coeff_mulc                 C   s   t g ƒS rW   )Úiterr/   r$   r$   r%   rb   ›  s   zEmptySequence.__iter__N)	r~   r   r€   r�   r…   r'   r4   rO   rb   r$   r$   r$   r%   r†   z  s    

r†   )Ú	metaclassc                   @   óX   e Zd ZdZedd„ ƒZedd„ ƒZedd„ ƒZedd	„ ƒZed
d„ ƒZ	edd„ ƒZ
dS )ÚSeqExpraÙ  Sequence expression class.

    Various sequences should inherit from this class.

    Examples
    ========

    >>> from sympy.series.sequences import SeqExpr
    >>> from sympy.abc import x
    >>> from sympy import Tuple
    >>> s = SeqExpr(Tuple(1, 2, 3), Tuple(x, 0, 10))
    >>> s.gen
    (1, 2, 3)
    >>> s.interval
    Interval(0, 10)
    >>> s.length
    11

    See Also
    ========

    sympy.series.sequences.SeqPer
    sympy.series.sequences.SeqFormula
    c                 C   ó
   | j d S ©Nr   r=   r/   r$   r$   r%   r0   ¹  r\   zSeqExpr.genc                 C   s   t | jd d | jd d ƒS )NrF   rl   )r   r>   r/   r$   r$   r%   r'   ½  s   zSeqExpr.intervalc                 C   ó   | j jS rW   ©r'   r(   r/   r$   r$   r%   r    Á  rY   zSeqExpr.startc                 C   r’   rW   ©r'   r)   r/   r$   r$   r%   r3   Å  rY   zSeqExpr.stopc                 C   ó   | j | j d S ©NrF   ©r3   r    r/   r$   r$   r%   r4   É  ó   zSeqExpr.lengthc                 C   s   | j d d fS )NrF   r   r=   r/   r$   r$   r%   r6   Í  r˜   zSeqExpr.variablesN)r~   r   r€   r�   r…   r0   r'   r    r3   r4   r6   r$   r$   r$   r%   r�   Ÿ  s    




r�   c                   @   sR   e Zd ZdZddd„Zedd„ ƒZedd„ ƒZd	d
„ Zdd„ Z	dd„ Z
dd„ ZdS )ÚSeqPeraâ  
    Represents a periodic sequence.

    The elements are repeated after a given period.

    Examples
    ========

    >>> from sympy import SeqPer, oo
    >>> from sympy.abc import k

    >>> s = SeqPer((1, 2, 3), (0, 5))
    >>> s.periodical
    (1, 2, 3)
    >>> s.period
    3

    For value at a particular point

    >>> s.coeff(3)
    1

    supports slicing

    >>> s[:]
    [1, 2, 3, 1, 2, 3]

    iterable

    >>> list(s)
    [1, 2, 3, 1, 2, 3]

    sequence starts from negative infinity

    >>> SeqPer((1, 2, 3), (-oo, 0))[0:6]
    [1, 2, 3, 1, 2, 3]

    Periodic formulas

    >>> SeqPer((k, k**2, k**3), (k, 0, oo))[0:6]
    [0, 1, 8, 3, 16, 125]

    See Also
    ========

    sympy.series.sequences.SeqFormula
    Nc                 C   s"  t |ƒ}dd„ }d\}}}|d u r||ƒdtj}}}t|tƒr;t|ƒdkr-|\}}}nt|ƒdkr;||ƒ}|\}}t|ttfƒrJ|d u sJ|d u rRt	dt
|ƒ ƒ‚|tju r`|tju r`t	dƒ‚t |||fƒ}t|tƒrut tt|ƒƒƒ}nt	d	| ƒ‚t|d
 |d ƒtju rŠtjS t | ||¡S )Nc                 S   s$   | j }t| j ƒdkr| ¡ S tdƒS )NrF   rz   )r7   rn   Úpopr   )Ú
periodicalÚfreer$   r$   r%   Ú_find_x  s   zSeqPer.__new__.<locals>._find_x©NNNr   é   rl   úInvalid limits given: %sz/Both the start and end valuecannot be unboundedz6invalid period %s should be something like e.g (1, 2) rF   )r   r   r"   r   r   rn   rR   r   r   Ú
ValueErrorÚstrrG   Útupler   r   rˆ   r†   r   Ú__new__)Úclsr›   Úlimitsr�   ru   r    r3   r$   r$   r%   r¤     s0   


ÿzSeqPer.__new__c                 C   s
   t | jƒS rW   )rn   r0   r/   r$   r$   r%   Úperiod+  r\   zSeqPer.periodc                 C   ó   | j S rW   ©r0   r/   r$   r$   r%   r›   /  r‰   zSeqPer.periodicalc                 C   sF   | j tju r| j| | j }n|| j  | j }| j|  | jd |¡S r‘   )r    r   rG   r3   r§   r›   Úsubsr6   )r*   rB   Úidxr$   r$   r%   r@   3  s   zSeqPer._eval_coeffc                 C   s�   t |tƒrF| j| j}}|j|j}}t||ƒ}g }t|ƒD ]}|||  }	|||  }
| |	|
 ¡ q|  |¡\}}t|| jd ||fƒS dS ©zSee docstring of SeqBase._addr   N©	rR   r™   r›   r§   r   ra   rp   r,   r6   ©r*   r+   Zper1Zlper1Zper2Zlper2Z
per_lengthZnew_perru   Zele1Zele2r    r3   r$   r$   r%   rL   :  ó   

ózSeqPer._addc                 C   s�   t |tƒrF| j| j}}|j|j}}t||ƒ}g }t|ƒD ]}|||  }	|||  }
| |	|
 ¡ q|  |¡\}}t|| jd ||fƒS dS ©zSee docstring of SeqBase._mulr   Nr­   r®   r$   r$   r%   rN   K  r¯   zSeqPer._mulc                    s,   t ˆ ƒ‰ ‡ fdd„| jD ƒ}t|| jd ƒS )r‹   c                    s   g | ]}|ˆ  ‘qS r$   r$   ©r9   ru   ©rC   r$   r%   rc   _  s    z$SeqPer.coeff_mul.<locals>.<listcomp>rF   )r   r›   r™   r>   )r*   rC   Úperr$   r²   r%   rO   \  s   zSeqPer.coeff_mulrW   )r~   r   r€   r�   r¤   r…   r§   r›   r@   rL   rN   rO   r$   r$   r$   r%   r™   Ò  s    
0(

r™   c                   @   sN   e Zd ZdZddd„Zedd„ ƒZdd„ Zd	d
„ Zdd„ Z	dd„ Z
dd„ ZdS )Ú
SeqFormulaaf  
    Represents sequence based on a formula.

    Elements are generated using a formula.

    Examples
    ========

    >>> from sympy import SeqFormula, oo, Symbol
    >>> n = Symbol('n')
    >>> s = SeqFormula(n**2, (n, 0, 5))
    >>> s.formula
    n**2

    For value at a particular point

    >>> s.coeff(3)
    9

    supports slicing

    >>> s[:]
    [0, 1, 4, 9, 16, 25]

    iterable

    >>> list(s)
    [0, 1, 4, 9, 16, 25]

    sequence starts from negative infinity

    >>> SeqFormula(n**2, (-oo, 0))[0:6]
    [0, 1, 4, 9, 16, 25]

    See Also
    ========

    sympy.series.sequences.SeqPer
    Nc                 C   sú   t |ƒ}dd„ }d\}}}|d u r||ƒdtj}}}t|tƒr;t|ƒdkr-|\}}}nt|ƒdkr;||ƒ}|\}}t|ttfƒrJ|d u sJ|d u rRt	dt
|ƒ ƒ‚|tju r`|tju r`t	dƒ‚t |||fƒ}t|d	 |d ƒtju rvtjS t | ||¡S )
Nc                 S   s2   | j }t|ƒdkr| ¡ S |stdƒS td|  ƒ‚)NrF   rz   z¦ specify dummy variables for %s. If the formula contains more than one free symbol, a dummy variable should be supplied explicitly e.g., SeqFormula(m*n**2, (n, 0, 5)))r7   rn   rš   r   r¡   )Úformularœ   r$   r$   r%   r�   �  s   ýÿz#SeqFormula.__new__.<locals>._find_xrž   r   rŸ   rl   r    z0Both the start and end value cannot be unboundedrF   )r   r   r"   r   r   rn   rR   r   r   r¡   r¢   rG   r   rˆ   r†   r   r¤   )r¥   rµ   r¦   r�   ru   r    r3   r$   r$   r%   r¤   Œ  s&   

zSeqFormula.__new__c                 C   r¨   rW   r©   r/   r$   r$   r%   rµ   ³  r‰   zSeqFormula.formulac                 C   s   | j d }| j ||¡S r‘   )r6   rµ   rª   )r*   rB   rt   r$   r$   r%   r@   ·  s   
zSeqFormula._eval_coeffc           	      C   s`   t |tƒr.| j| jd }}|j|jd }}|| ||¡ }|  |¡\}}t||||fƒS dS r¬   ©rR   r´   rµ   r6   rª   r,   ©	r*   r+   Zform1Úv1Zform2Úv2rµ   r    r3   r$   r$   r%   rL   »  ó   
ûzSeqFormula._addc           	      C   s`   t |tƒr.| j| jd }}|j|jd }}|| ||¡ }|  |¡\}}t||||fƒS dS r°   r¶   r·   r$   r$   r%   rN   Ä  rº   zSeqFormula._mulc                 C   s"   t |ƒ}| j| }t|| jd ƒS )r‹   rF   )r   rµ   r´   r>   )r*   rC   rµ   r$   r$   r%   rO   Í  s   
zSeqFormula.coeff_mulc                 O   s$   t t| jg|¢R i |¤Ž| jd ƒS r–   )r´   r   rµ   r>   )r*   r>   Úkwargsr$   r$   r%   r   Ó  s   $zSeqFormula.expandrW   )r~   r   r€   r�   r¤   r…   rµ   r@   rL   rN   rO   r   r$   r$   r$   r%   r´   c  s    
('
		r´   c                   @   s–   e Zd ZdZddd„Zedd„ ƒZedd	„ ƒZed
d„ ƒZedd„ ƒZ	edd„ ƒZ
edd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZdd„ Zdd„ ZdS )ÚRecursiveSeqaŒ  
    A finite degree recursive sequence.

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

    That is, a sequence a(n) that depends on a fixed, finite number of its
    previous values. The general form is

        a(n) = f(a(n - 1), a(n - 2), ..., a(n - d))

    for some fixed, positive integer d, where f is some function defined by a
    SymPy expression.

    Parameters
    ==========

    recurrence : SymPy expression defining recurrence
        This is *not* an equality, only the expression that the nth term is
        equal to. For example, if :code:`a(n) = f(a(n - 1), ..., a(n - d))`,
        then the expression should be :code:`f(a(n - 1), ..., a(n - d))`.

    yn : applied undefined function
        Represents the nth term of the sequence as e.g. :code:`y(n)` where
        :code:`y` is an undefined function and `n` is the sequence index.

    n : symbolic argument
        The name of the variable that the recurrence is in, e.g., :code:`n` if
        the recurrence function is :code:`y(n)`.

    initial : iterable with length equal to the degree of the recurrence
        The initial values of the recurrence.

    start : start value of sequence (inclusive)

    Examples
    ========

    >>> from sympy import Function, symbols
    >>> from sympy.series.sequences import RecursiveSeq
    >>> y = Function("y")
    >>> n = symbols("n")
    >>> fib = RecursiveSeq(y(n - 1) + y(n - 2), y(n), n, [0, 1])

    >>> fib.coeff(3) # Value at a particular point
    2

    >>> fib[:6] # supports slicing
    [0, 1, 1, 2, 3, 5]

    >>> fib.recurrence # inspect recurrence
    Eq(y(n), y(n - 2) + y(n - 1))

    >>> fib.degree # automatically determine degree
    2

    >>> for x in zip(range(10), fib): # supports iteration
    ...     print(x)
    (0, 0)
    (1, 1)
    (2, 1)
    (3, 2)
    (4, 3)
    (5, 5)
    (6, 8)
    (7, 13)
    (8, 21)
    (9, 34)

    See Also
    ========

    sympy.series.sequences.SeqFormula

    Nr   c                    s\  t |tƒstd |¡ƒ‚t |tƒr|jstd |¡ƒ‚|j|fkr%tdƒ‚|j‰td|fd�}d}| 	ˆ¡}|D ]3}	t
|	jƒdkrEtdƒ‚|	jd  || ¡| }
|
 ¡ r\|
jr\|
dk sctd	 |	¡ƒ‚|
 |krk|
 }q8|swd
d„ t|ƒD ƒ}t
|ƒ|kr�tdƒ‚t|ƒ}tˆ ƒ‰ tdd„ |D ƒŽ }t | ||||ˆ ¡}‡ ‡fdd„t|ƒD ƒ|_||_|S )NzErecurrence sequence must be an applied undefined function, found `{}`z0recurrence variable must be a symbol, found `{}`z)recurrence sequence does not match symbolrz   )Úexcluder   rF   z)Recurrence should be in a single variablezDRecurrence should have constant, negative, integer shifts (found {})c                 S   s   g | ]	}t d  |¡ƒ‘qS )zc_{})r   Úformat)r9   rz   r$   r$   r%   rc   G  ó    z(RecursiveSeq.__new__.<locals>.<listcomp>z)Number of initial terms must equal degreec                 s   s   � | ]}t |ƒV  qd S rW   r   r±   r$   r$   r%   Ú	<genexpr>O  s   € z'RecursiveSeq.__new__.<locals>.<genexpr>c                    s   i | ]\}}ˆˆ | ƒ|“qS r$   r$   )r9   rz   Úinit©r    r|   r$   r%   Ú
<dictcomp>S  s    z(RecursiveSeq.__new__.<locals>.<dictcomp>)rR   r   rS   r¾   r   Ú	is_symbolr>   rD   r   Úfindrn   ÚmatchÚis_constantÚ
is_integerra   r¡   r   r   r   r¤   Ú	enumerateÚcacheÚdegree)r¥   Ú
recurrenceÚynrs   rH   r    rz   rË   Zprev_ysZprev_yÚshiftÚseqr$   rÂ   r%   r¤   #  sH   
ÿÿ
þ
€zRecursiveSeq.__new__c                 C   r�   ©zEquation defining recurrence.r   r=   r/   r$   r$   r%   Ú_recurrenceX  ó   
zRecursiveSeq._recurrencec                 C   s   t | j| jd ƒS rÐ   )r   rÍ   r>   r/   r$   r$   r%   rÌ   ]  s   zRecursiveSeq.recurrencec                 C   r�   )z*Applied function representing the nth termrF   r=   r/   r$   r$   r%   rÍ   b  rÒ   zRecursiveSeq.ync                 C   r’   )z3Undefined function for the nth term of the sequence)rÍ   rD   r/   r$   r$   r%   r|   g  s   zRecursiveSeq.yc                 C   r�   )zSequence index symbolrl   r=   r/   r$   r$   r%   rs   l  rÒ   zRecursiveSeq.nc                 C   r�   )z"The initial values of the sequencerŸ   r=   r/   r$   r$   r%   rH   q  rÒ   zRecursiveSeq.initialc                 C   r�   )r2   é   r=   r/   r$   r$   r%   r    v  rÒ   zRecursiveSeq.startc                 C   r‡   )z&The ending point of the sequence. (oo))r   r"   r/   r$   r$   r%   r3   {  s   zRecursiveSeq.stopc                 C   s   | j tjfS )z&Interval on which sequence is defined.)r    r   r"   r/   r$   r$   r%   r'   €  r1   zRecursiveSeq.intervalc                 C   sŒ   || j  t| jƒk r| j|  |¡ S tt| jƒ|d ƒD ]}| j | }| j | j|i¡}| | j¡}|| j|  |¡< q| j|  | j | ¡ S r–   )r    rn   rÊ   r|   ra   rÑ   Úxreplacers   )r*   rg   ÚcurrentZ	seq_indexZcurrent_recurrenceZnew_termr$   r$   r%   r@   …  s   
zRecursiveSeq._eval_coeffc                 c   s    � | j }	 |  |¡V  |d7 }q)NTrF   )r    r@   )r*   rg   r$   r$   r%   rb   ”  s   €þzRecursiveSeq.__iter__r‘   )r~   r   r€   r�   r¤   r…   rÑ   rÌ   rÍ   r|   rs   rH   r    r3   r'   r@   rb   r$   r$   r$   r%   r¼   Ö  s.    
L5








r¼   Nc                 C   s&   t | ƒ} t| tƒrt| |ƒS t| |ƒS )a  
    Returns appropriate sequence object.

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

    If ``seq`` is a SymPy sequence, returns :class:`SeqPer` object
    otherwise returns :class:`SeqFormula` object.

    Examples
    ========

    >>> from sympy import sequence
    >>> from sympy.abc import n
    >>> sequence(n**2, (n, 0, 5))
    SeqFormula(n**2, (n, 0, 5))
    >>> sequence((1, 2, 3), (n, 0, 5))
    SeqPer((1, 2, 3), (n, 0, 5))

    See Also
    ========

    sympy.series.sequences.SeqPer
    sympy.series.sequences.SeqFormula
    )r   r   r   r™   r´   )rÏ   r¦   r$   r$   r%   Úsequence›  s   


rÖ   c                   @   rŽ   )Ú	SeqExprOpaá  
    Base class for operations on sequences.

    Examples
    ========

    >>> from sympy.series.sequences import SeqExprOp, sequence
    >>> from sympy.abc import n
    >>> s1 = sequence(n**2, (n, 0, 10))
    >>> s2 = sequence((1, 2, 3), (n, 5, 10))
    >>> s = SeqExprOp(s1, s2)
    >>> s.gen
    (n**2, (1, 2, 3))
    >>> s.interval
    Interval(5, 10)
    >>> s.length
    6

    See Also
    ========

    sympy.series.sequences.SeqAdd
    sympy.series.sequences.SeqMul
    c                 C   s   t dd„ | jD ƒƒS )zjGenerator for the sequence.

        returns a tuple of generators of all the argument sequences.
        c                 s   ó   � | ]}|j V  qd S rW   r©   ©r9   Úar$   r$   r%   rÀ   á  ó   € z SeqExprOp.gen.<locals>.<genexpr>)r£   r>   r/   r$   r$   r%   r0   Û  s   zSeqExprOp.genc                 C   s   t dd„ | jD ƒŽ S )zeSequence is defined on the intersection
        of all the intervals of respective sequences
        c                 s   rØ   rW   ©r'   rÙ   r$   r$   r%   rÀ   è  rÛ   z%SeqExprOp.interval.<locals>.<genexpr>)r   r>   r/   r$   r$   r%   r'   ã  s   zSeqExprOp.intervalc                 C   r’   rW   r“   r/   r$   r$   r%   r    ê  rY   zSeqExprOp.startc                 C   r’   rW   r”   r/   r$   r$   r%   r3   î  rY   zSeqExprOp.stopc                 C   s   t tdd„ | jD ƒƒƒS )z%Cumulative of all the bound variablesc                 S   s   g | ]}|j ‘qS r$   )r6   rÙ   r$   r$   r%   rc   õ  s    z'SeqExprOp.variables.<locals>.<listcomp>)r£   r   r>   r/   r$   r$   r%   r6   ò  s   zSeqExprOp.variablesc                 C   r•   r–   r—   r/   r$   r$   r%   r4   ÷  r˜   zSeqExprOp.lengthN)r~   r   r€   r�   r…   r0   r'   r    r3   r6   r4   r$   r$   r$   r%   r×   Â  s    




r×   c                   @   ó,   e Zd ZdZdd„ Zedd„ ƒZdd„ ZdS )	rU   aš  Represents term-wise addition of sequences.

    Rules:
        * The interval on which sequence is defined is the intersection
          of respective intervals of sequences.
        * Anything + :class:`EmptySequence` remains unchanged.
        * Other rules are defined in ``_add`` methods of sequence classes.

    Examples
    ========

    >>> from sympy import EmptySequence, oo, SeqAdd, SeqPer, SeqFormula
    >>> from sympy.abc import n
    >>> SeqAdd(SeqPer((1, 2), (n, 0, oo)), EmptySequence)
    SeqPer((1, 2), (n, 0, oo))
    >>> SeqAdd(SeqPer((1, 2), (n, 0, 5)), SeqPer((1, 2), (n, 6, 10)))
    EmptySequence
    >>> SeqAdd(SeqPer((1, 2), (n, 0, oo)), SeqFormula(n**2, (n, 0, oo)))
    SeqAdd(SeqFormula(n**2, (n, 0, oo)), SeqPer((1, 2), (n, 0, oo)))
    >>> SeqAdd(SeqFormula(n**3), SeqFormula(n**2))
    SeqFormula(n**3 + n**2, (n, 0, oo))

    See Also
    ========

    sympy.series.sequences.SeqMul
    c                    s�   |  dtj¡}t|ƒ}‡ fdd„‰ ˆ |ƒ}dd„ |D ƒ}|s!tjS tdd„ |D ƒŽ tju r0tjS |r7t 	|¡S tt
|tjƒƒ}tj| g|¢R Ž S )NÚevaluatec                    óL   t | tƒrt | tƒrttˆ | jƒg ƒS | gS t| ƒr"ttˆ | ƒg ƒS tdƒ‚©Nz2Input must be Sequences or  iterables of Sequences)rR   r   rU   ÚsumÚmapr>   r   rS   ©Úarg©Ú_flattenr$   r%   ræ      ó   

z SeqAdd.__new__.<locals>._flattenc                 S   s   g | ]	}|t jur|‘qS r$   )r   r†   rÙ   r$   r$   r%   rc   ,  r¿   z"SeqAdd.__new__.<locals>.<listcomp>c                 s   rØ   rW   rÜ   rÙ   r$   r$   r%   rÀ   2  rÛ   z!SeqAdd.__new__.<locals>.<genexpr>)Úgetr   rÞ   Úlistr   r†   r   rˆ   rU   Úreducer   r   r&   r   r¤   ©r¥   r>   r»   rÞ   r$   rå   r%   r¤     s   

zSeqAdd.__new__c                    óž   d}|r?t | ƒD ]4\}‰ d}t | ƒD ]#\}‰||krqˆ  ˆ¡}|dur5‡ ‡fdd„| D ƒ}| |¡  nq|r<|}  nq|st| ƒdkrI|  ¡ S t| dd�S )a  Simplify :class:`SeqAdd` using known rules.

        Iterates through all pairs and ask the constituent
        sequences if they can simplify themselves with any other constituent.

        Notes
        =====

        adapted from ``Union.reduce``

        TFNc                    ó   g | ]
}|ˆ ˆfvr|‘qS r$   r$   rÙ   ©Úsrk   r$   r%   rc   U  rd   z!SeqAdd.reduce.<locals>.<listcomp>rF   ©rÞ   )rÉ   rL   rp   rn   rš   rU   ©r>   Únew_argsZid1Zid2Únew_seqr$   rî   r%   rê   =  s*   

ýþózSeqAdd.reducec                    s   t ‡ fdd„| jD ƒƒS )z9adds up the coefficients of all the sequences at point ptc                 3   s   � | ]}|  ˆ ¡V  qd S rW   r²   rÙ   ©rB   r$   r%   rÀ   c  s   € z%SeqAdd._eval_coeff.<locals>.<genexpr>)rá   r>   rA   r$   rô   r%   r@   a  s   zSeqAdd._eval_coeffN©r~   r   r€   r�   r¤   r„   rê   r@   r$   r$   r$   r%   rU   ü  s    $
#rU   c                   @   rÝ   )	r^   a'  Represents term-wise multiplication of sequences.

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

    Handles multiplication of sequences only. For multiplication
    with other objects see :func:`SeqBase.coeff_mul`.

    Rules:
        * The interval on which sequence is defined is the intersection
          of respective intervals of sequences.
        * Anything \* :class:`EmptySequence` returns :class:`EmptySequence`.
        * Other rules are defined in ``_mul`` methods of sequence classes.

    Examples
    ========

    >>> from sympy import EmptySequence, oo, SeqMul, SeqPer, SeqFormula
    >>> from sympy.abc import n
    >>> SeqMul(SeqPer((1, 2), (n, 0, oo)), EmptySequence)
    EmptySequence
    >>> SeqMul(SeqPer((1, 2), (n, 0, 5)), SeqPer((1, 2), (n, 6, 10)))
    EmptySequence
    >>> SeqMul(SeqPer((1, 2), (n, 0, oo)), SeqFormula(n**2))
    SeqMul(SeqFormula(n**2, (n, 0, oo)), SeqPer((1, 2), (n, 0, oo)))
    >>> SeqMul(SeqFormula(n**3), SeqFormula(n**2))
    SeqFormula(n**5, (n, 0, oo))

    See Also
    ========

    sympy.series.sequences.SeqAdd
    c                    s‚   |  dtj¡}t|ƒ}‡ fdd„‰ ˆ |ƒ}|stjS tdd„ |D ƒŽ tju r)tjS |r0t 	|¡S tt
|tjƒƒ}tj| g|¢R Ž S )NrÞ   c                    rß   rà   )rR   r   r^   rá   râ   r>   r   rS   rã   rå   r$   r%   ræ   �  rç   z SeqMul.__new__.<locals>._flattenc                 s   rØ   rW   rÜ   rÙ   r$   r$   r%   rÀ      rÛ   z!SeqMul.__new__.<locals>.<genexpr>)rè   r   rÞ   ré   r   r†   r   rˆ   r^   rê   r   r   r&   r   r¤   rë   r$   rå   r%   r¤   ‰  s   

zSeqMul.__new__c                    rì   )a.  Simplify a :class:`SeqMul` using known rules.

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

        Iterates through all pairs and ask the constituent
        sequences if they can simplify themselves with any other constituent.

        Notes
        =====

        adapted from ``Union.reduce``

        TFNc                    rí   r$   r$   rÙ   rî   r$   r%   rc   Æ  rd   z!SeqMul.reduce.<locals>.<listcomp>rF   rð   )rÉ   rN   rp   rn   rš   r^   rñ   r$   rî   r%   rê   «  s*   

ýþózSeqMul.reducec                 C   s"   d}| j D ]	}|| |¡9 }q|S )z<multiplies the coefficients of all the sequences at point ptrF   )r>   rC   )r*   rB   ÚvalrÚ   r$   r$   r%   r@   Ò  s   
zSeqMul._eval_coeffNrõ   r$   r$   r$   r%   r^   f  s    ""
&r^   rW   )6Úsympy.core.basicr   Úsympy.core.cacher   Úsympy.core.containersr   Zsympy.core.decoratorsr   Úsympy.core.parametersr   Úsympy.core.functionr   r   Zsympy.core.mulr
   Úsympy.core.numbersr   Úsympy.core.relationalr   Úsympy.core.singletonr   r   Úsympy.core.sortingr   Úsympy.core.symbolr   r   r   Úsympy.core.sympifyr   Úsympy.matricesr   Úsympy.polysr   r   Úsympy.sets.setsr   r   Úsympy.tensor.indexedr   Úsympy.utilities.iterablesr   r   r   r   r†   r�   r™   r´   r¼   rÖ   r×   rU   r^   r$   r$   r$   r%   Ú<module>   s@      b%3 s 
F':j