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$   ú˜/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/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ÚdÚgfvarÚxÚlxÚrÚcoeffsÚlÚl2Ú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   r}   )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    rv   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+   Úper1Úlper1Úper2Úlper2Ú
per_lengthÚnew_perrv   Úele1Ú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   rv   ©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   r}   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    rv   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+   Úform1Úv1Ú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 symbolr}   )Ú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   r}   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   r}   Ú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    r}   rØ   Úprev_ysÚ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   ÚcurrentÚ	seq_indexÚcurrent_recurrenceÚ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_argsÚid1Ú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   Úsympy.core.decoratorsr   Úsympy.core.parametersr   Úsympy.core.functionr   r   Ú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