| Server IP : 93.86.61.54 / Your IP : 216.73.216.206 Web Server : Apache/2.4.62 (Ubuntu) System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64 User : www-data ( 33) PHP Version : 8.4.22 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /usr/lib/python3/dist-packages/sympy/simplify/__pycache__/ |
Upload File : |
o
�8Va�J � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZmZmZ ddlmZmZ ddl m Z ddl m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z? dd l@mAZAmBZB dd
lCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZP dd lQmRZRmSZS dd lTmUZU dd
lVmWZW ddlXmYZY ddlZm[Z[ dd� Z\dd� Z]dd� Z^dd� Z_dd� Z`G dd� de�ZaG d d � d e�Zbe d �ZcG d d � d �ZdG d!d"� d"�ZeG d#d$� d$�ZfG d%d&� d&�ZgG d'd(� d(�ZhG d)d*� d*eh�ZiG d+d,� d,eh�ZjG d-d.� d.eh�ZkG d/d0� d0eh�ZlG d1d2� d2eh�ZmG d3d4� d4eh�ZnG d5d6� d6eh�ZoG d7d8� d8eh�ZpG d9d:� d:eh�ZqG d;d<� d<eh�ZrG d=d>� d>eh�ZsG d?d@� d@eh�ZtG dAdB� dBeh�ZuG dCdD� dDeh�ZvdEdF� ZwdGdH� ZxdIdJ� ZydKdL� ZzdMdN� Z{dOdP� Z|dQdR� Z}dSdT� Z~dUdV� ZdWdX� Z�dYdZ� Z�d[a�g e d\�d]dd^fd_d`�Z�dadb� Z�d[a� ^ [dhddde�Z�dhdfdg�Z�d[S )ia@
Expand Hypergeometric (and Meijer G) functions into named
special functions.
The algorithm for doing this uses a collection of lookup tables of
hypergeometric functions, and various of their properties, to expand
many hypergeometric functions in terms of special functions.
It is based on the following paper:
Kelly B. Roach. Meijer G Function Representations.
In: Proceedings of the 1997 International Symposium on Symbolic and
Algebraic Computation, pages 205-211, New York, 1997. ACM.
It is described in great(er) detail in the Sphinx documentation.
� )� defaultdict)�product)� SYMPY_DEBUG)�S�Dummy�symbols�sympify�Tuple�expand�I�pi�Mul�
EulerGamma�oo�zoo� expand_func�Add�nan�Expr�Rational)�default_sort_key�reduce)�Mod)!�exp�sqrt�root�log�
lowergamma�cos�besseli�gamma�
uppergamma�expint�erf�sin�besselj�Ei�Ci�Si�Shi�sinh�cosh�Chi�fresnels�fresnelc�
polar_lift� exp_polar�floor�ceiling�rf� factorial�lerchphi� Piecewise�re�
elliptic_k�
elliptic_e)�polarify�
unpolarify)
�hyper�HyperRep_atanh�HyperRep_power1�HyperRep_power2�
HyperRep_log1�HyperRep_asin1�HyperRep_asin2�HyperRep_sqrts1�HyperRep_sqrts2�
HyperRep_log2�HyperRep_cosasin�HyperRep_sinasin�meijerg)�poly�Poly)�residue)�simplify)� powdenest��siftc C s* | j rt| d�S | �� \}} t|d�| S �N� )� is_Numberr � as_coeff_Add)�x�c� rV �</usr/lib/python3/dist-packages/sympy/simplify/hyperexpand.py�_mod1S s
rX c s� ddl m} tdtd�\� ���� ����fdd�}� ����fdd�}|d d t��� |� fd t� ��� |� � tj fd
� f|t� ��t� tj ��d
g�|d dgg�|� tj � d � tj� � d � g� d � � �d
d � gg�� |d d
|t ��d g�|d� dgg�|d��d gddgg�� |tjd ftd�f|t
��d g�|d dgg�|t dd
�d d � d
gddgg�� |tjtjftd�f|t ��tt dd
���g�|d dgg�|t dd
�tjgd�d � d
gg�� |� tj� ftjf|t
� ��t� tj �� g�|d dgg�|d� g�d� d d
d � tj�d� d d � gg�� |� � gtjg|t� ��t� ��g�|d dgg�|d� g� � d � d d � d
gg�� |d d gdtj g|t��d g�|d dgg�|�tj d � d d � d
gddgg�� |tjtjgtjg|t��t��g�|d
t dgg�|t dd
�dd
� d
gt dd
�tjgg�� |t dd
�tjgtjg|t��t��g�|dd
t gg�|t dd
�dd
� d
gt dd
�tjgg�� |t dd
�d d gtjd
g|�t
�� t ��d g�|t dd�tj d� t d
d�gg�|tjd�d � d
gdd��d gg d�g�� |t dd
�d d gd
d
g|ttj��t��d g�|t dd�dd� dd� dd� gg�|�d
�d ddgd d
�d dtjgg d�g�� |d g�g|�d � t�� t�d �� d g�|�d dgg�|d � � d gddgg�� |� gd
� g|�tj� t�d
� t� tj �d
� t� tj � dtj� �tj� t�d
� t� tj �d
� t� tj � dtj� g�|d dgg�|�d
�d
g�d
�d
d
� gg�� td�� }|� g� d g||� � t� |� � t�� g�|d dgg�|� d gd�gg�� |t dd
�gtjgt��tt� �t t t t�� � � |d gt dd�t dd�g|tt�t t d
t�� � t d
t �d� tt t d � tt� � t!d
t�� �t"d
t �d� tt t d � tt� � tt t d � d
t �d� tt�t �d� t d
t�� �t"d
t �d� tt t d � tt� � t t!d
t�� � t d
t �d� tt t d � tt� � tt t d � d
d g�|g d�g�|t dd�d t d d�g�t d d�dgg d�g�� |tj� gt dd
�� d g|� d
� d t tt� � t t t�� � � d
� d td�� � t� td�� � � d
� d t�� g�|g d�g�|t dd
�dd gd� d gdd�gg�� |d d gd
d
g|t#��t$�� t��d t%g�|d � ddd� gg�|g d�d�ddgg d�g d�g�� |d tjft!d
t�� �� |g �g|t���d � d
t�d d
t�� � t���d �d
t�d
t�� � g�|d dgg�|dd g�d � gg�� d�t d d� ��fdd �}�fd d �}|g tj� � tj g||d
� d ��|d
� ���t d d� |d
� d ��t�� |d
� ���t dd� g�d
d� td
� � �d d
� d |g d �g�|g d �dtj� d dgddtjd g�ddd � gg�� d
d� t d d� t&t t d � �|g � � tj d
� gd
ttd�� � d d
� td
� �d
|t'd
� d ��td
� d �� �td
� ��t'd
� d �� td
� d ��t'd
� �� �d
td
� �� t'd
� �� �d td
� ��t'd
� d �� td
� d ��t'd
� �� g� |g d �g�|dt d d�ddgdd d
� d
t dd
�dgddd d
� t d d�gd!� ddd � gg�� |� g� tj d
� g|�tj� t� tj t���d
�d � t� tj t��� t� t dd
� t��� �t dd
�� t� t dd
� t���d
g�|t� tj �d
dtj� d
t� tj � t� tj � dd � dgg�|d d
� d dg�d
tj� tjgd�dgg�� |tjg�d
� gtd � t(t� � |td � t���t�d t��� t��t� t���t�d t��� td � t���t�t��� t� t���t�t��� g� |g d�g�|�d tjdg�d�gdtj� gg�� |tjgt dd
�t dd
�g|t)d
t�� �d
t�� t d
t�� �d
t�� t!d
t�� �g�|g d�g�|t dd
�tjdgdt dd
�tjgdd
� dgg�� |t dd�gt dd
�t d"d�g|t ttt d �t �d� d
tt� �tttt d �t �d� d
tt� d t d
t�� �t�� t!d
t�� �g�|g d#�g�|t d$d�t d d�dgdt dd
�d gd�dgg�� |t d d�gtjt dd�g|tt�tt t d � t"d
t �d� tt t d � tt� � d
t �d� t!d
t�� �t d
t�� �t�� g�|g d�g�|t dd�t d d�dgg d%�d�tjgg�� |� � tj gd
� �d
� � d gt��td
� � d � t��d
d d
� |t�d t���td
� � t��� t��t�t��� td
� � t��� t��t�d t��� td
� � d t��� t�t���td
� � d t��� g� |g d �g�|dtjtjdg�d
d � d�d
g�d
d�d
� �d
gdtjtjd� gg�� |d d gd
d
t dd
�g|t*d
t�� �t$d
t�� � t!d
t�� �t��t d
t�� � d t%g�|d � dddd� gg�|dtjdt dd
�dgg d&�d�tjddgg d'�g d'�g�� |d d � gd
d
� d g|� t$� �t+d � � t% �� d
d
� d � � � t� �t,� � � � d d
� t�� � d
d
� d � �� d
d
� d g�|d � d d� d gg�|ddd� d gd� d dgdd�dgg d(�g�� d)S )*z Create our knowledge base. r ��Matrixza b c, z)�clsc s( t | |�}��t|�|� ��f�� d S �N��Hyper_Function�append�Formula)�ap�bq�res�func��a�brU �formulae�zrV rW �addh s
zadd_formulae.<locals>.addc
s. t | |�}��t|�d � ��f|||�� d S r\ r] )ra rb �B�C�Mrd re rV rW �addbl s
$zadd_formulae.<locals>.addbrV � rQ )rQ rQ )ro ���z3/2���� )r r r � � � � )rQ r r )rQ rp r )r rQ rp r )r r r r c s t | � �t| � � S r\ �r r% �rf ri �rT rV rW �fp� � zadd_formulae.<locals>.fpc s t | � �t| � � S r\ rw rx ry rV rW �fm� r{ zadd_formulae.<locals>.fm)rQ r r r )r rQ r r i��� )� r r ���)r r rQ )r r rQ r r )r r r r r )r r r rp N)-�sympy.matricesrZ r r r r> r �Halfr? r@ r= r rA rC rD rF rG rB �Oner8 r9 r rE r r r r/ r r r# r* r- r r+ r. r& r r r0 r% r$ r) r, r" r! )rh rZ rj rn �mzrz r| rV )rf rg rU rh rT ri rW � add_formulaeb sn
� , �� � $� &�"
8�� ,�,�����&��06�2*�. � �, � �� *� & �>
D8�� �H<���� ��2 �� &� "� .(�"� ,2�
�
�� ��& .$ �"$ ��� ��& �,�"*�2� $& � �� ��
6� 2�
�������,��� ��� ��$�� ���
��&2(*2&�� �� (���6. �
��r� c
s� ddl m} tttd��\� ���td��� �����fdd�}� �fdd�}|� � gg �� � gg |td � ��� t�� t� �� td � ��� � g�|d dgg�|�� d
gd� � gg�|� � fd d �}td
t �� �}t
d
t �� �}t d
t �� �t d
}t
d
t �� �}|� gg � � � tj gg |t t ��� tj || || t t ��� || || t t ��� g�|g d�g�|� tj d
dg�� tjgdd� gg�|� d S )Nr rY �abcz�rhoc
s, �� t| |||�� ���g||||�
� d S r\ )r_ �
MeijerFormula)�anra �bmrb rk rl rm �matcher�rf rg rU rh r� ri rV rW rj � s
�z!add_meijerg_formulae.<locals>.addc s� | j d }| j\}}d}t|| �� �sd}||}}t|| �� �s)|| dkr+d S ||g}|r5||g}�|� || it|gg |g �fS )Nr FT)r� r� rX rL �
G_Function)rd rT �yri �swapped�l)rf r� rV rW �detect_uppergamma� s
z/add_meijerg_formulae.<locals>.detect_uppergammarQ rp c s: | j d � | j\}}}t|| �� �dkr2t|| �� �dkr!dS tjtjtjf}|||}}}n+t� | �� �dkrMtjtjtjf}|||}}}ntjtjtjf}|||}}}t� | �� �dks�t� | �� �dks�t� | �� �tjks�� | dks�� | dkr�dS �� it� gg � fdd�|D �g �fS )z-http://functions.wolfram.com/07.34.03.0984.01r Nc s g | ] }� t j | �qS rV )r r� )�.0�try rV rW �
<listcomp>� � z=add_meijerg_formulae.<locals>.detect_3113.<locals>.<listcomp>)r� r� rX rL r r� �Zeror� )rd �u�v�w�sig�x1�x2r� �rf ry rW � detect_3113� s$
&z)add_meijerg_formulae.<locals>.detect_3113ro )rq r r )r� rZ �list�mapr r r r! r$ r r r( r r' r r� ) rh rZ rj r� r� �s�c_�S_rl rV r� rW �add_meijerg_formulae� s6 &� � & � &�r� c s � fdd�}|S )z@ Create a function that simplifies rational functions in ``z``. c sD | � � \}}|�� }t|� ��t|� ��\}}}||�� |�� S )z6 Efficiently simplify the rational function ``expr``. )�as_numer_denomr
rI �cancel�as_expr)�expr�numer�denomrU �ri rV rW �simp� s zmake_simp.<locals>.simprV )ri r� rV r� rW � make_simp� s r� c G s( t r| D ]}t|dd� qt� d S d S )N� )�end)r �print)�argsrf rV rV rW �debug� s
�r� c sp e Zd ZdZ� fdd�Zedd� �Zedd� �Zedd � �Z� fd
d �Z d d
� Z
dd� Z dd� Z dd� Z
� ZS )r^ z( A generalized hypergeometric function. c s8 t � �| �}tttt|��� |_tttt|��� |_|S r\ )�super�__new__r r� r� r
ra rb )r[ ra rb �obj�� __class__rV rW r� � s zHyper_Function.__new__c C s | j | jfS r\ )ra rb ��selfrV rV rW r� � s zHyper_Function.argsc C s t | j�t | j�fS r\ )�lenra rb r� rV rV rW �sizes� � zHyper_Function.sizesc C s t dd� | jD ��S )zt
Number of upper parameters that are negative integers
This is a transformation invariant.
c s s � | ] }t |jo
|j�V qd S r\ )�bool�
is_integer� is_negative�r� rT rV rV rW � <genexpr>� s � z'Hyper_Function.gamma.<locals>.<genexpr>)�sumra r� rV rV rW r � s zHyper_Function.gammac s t � �� | j| jf S r\ )r� �_hashable_contentra rb r� r� rV rW r� � s �z Hyper_Function._hashable_contentc C s t | j| j|�S r\ )r< ra rb )r� �argrV rV rW �__call__� � zHyper_Function.__call__c C s6 t | jt�t | jt�}}dd� }| j||�||�fS )a6
Compute the invariant vector.
Explanation
===========
The invariant vector is:
(gamma, ((s1, n1), ..., (sk, nk)), ((t1, m1), ..., (tr, mr)))
where gamma is the number of integer a < 0,
s1 < ... < sk
nl is the number of parameters a_i congruent to sl mod 1
t1 < ... < tr
ml is the number of parameters b_i congruent to tl mod 1
If the index pair contains parameters, then this is not truly an
invariant, since the parameters cannot be sorted uniquely mod1.
Examples
========
>>> from sympy.simplify.hyperexpand import Hyper_Function
>>> from sympy import S
>>> ap = (S.Half, S.One/3, S(-1)/2, -2)
>>> bq = (1, 2)
Here gamma = 1,
k = 3, s1 = 0, s2 = 1/3, s3 = 1/2
n1 = 1, n2 = 1, n2 = 2
r = 1, t1 = 0
m1 = 2:
>>> Hyper_Function(ap, bq).build_invariants()
(1, ((0, 1), (1/3, 1), (1/2, 2)), ((0, 2),))
c S sD t | �� �} tdd� | D ��s| jdd� d� tdd� | D ��} | S )Nc s s � | ]
}t |d t�V qdS )r N)�
isinstancer r� rV rV rW r� & s � z>Hyper_Function.build_invariants.<locals>.tr.<locals>.<genexpr>c S s t | d �S �Nr �r ry rV rV rW �<lambda>' � z=Hyper_Function.build_invariants.<locals>.tr.<locals>.<lambda>��keyc S s g | ] \}}|r|t |�f�qS rV �r� )r� �mod�valuesrV rV rW r� ( s �z?Hyper_Function.build_invariants.<locals>.tr.<locals>.<listcomp>)r� �items�any�sort�tuple)�bucketrV rV rW �tr$ s
z+Hyper_Function.build_invariants.<locals>.tr)rO ra rX rb r )r� �abuckets�bbucketsr� rV rV rW �build_invariants� s #z Hyper_Function.build_invariantsc C s� | j |j krdS dd� | j| j|j|jfD �\}}}}d}||f||ffD ]S\}}tt|�� �t|�� � �D ]@} | |vsM| |vsMt|| �t|| �krQ dS t|| �}
t|| �} |
�� | �� t|
| �D ] \} }
|t | |
�7 }qjq7q%|S )zd Estimate how many steps it takes to reach ``func`` from self.
Return -1 if impossible. rp c S � g | ]}t |t��qS rV �rO rX �r� �paramsrV rV rW r� 3 � �z-Hyper_Function.difficulty.<locals>.<listcomp>r )
r ra rb �setr� �keysr� r� �zip�abs)r� rd � oabuckets� obbucketsr� r� �diffr� �obucketr� �l1�l2�i�jrV rV rW �
difficulty. s( � �� zHyper_Function.difficultyc C st | j D ]}| jD ]}|| jr|| jdu r dS qq| j D ] }|dkr( dS q | jD ] }|jr7|jr7 dS q,dS )a�
Decide if ``self`` is a suitable origin.
Explanation
===========
A function is a suitable origin iff:
* none of the ai equals bj + n, with n a non-negative integer
* none of the ai is zero
* none of the bj is a non-positive integer
Note that this gives meaningful results only when none of the indices
are symbolic.
Fr T)ra rb r� r� �is_nonpositive)r� rf rg rV rV rW �_is_suitable_originE s
��
�
�z"Hyper_Function._is_suitable_origin)�__name__�
__module__� __qualname__�__doc__r� �propertyr� r� r r� r� r� r� r� �
__classcell__rV rV r� rW r^ � s
/r^ c sT e Zd ZdZ� fdd�Zedd� �Z� fdd�Zdd � Zd
d � Z ed d
� �Z
� Z S )r� z A Meijer G-function. c s` t � �| �}tttt|��� |_tttt|��� |_tttt|��� |_tttt|��� |_ |S r\ )
r� r� r r� r� r
r� ra r� rb )r[ r� ra r� rb r� r� rV rW r� e s zG_Function.__new__c C s | j | j| j| jfS r\ )r� ra r� rb r� rV rV rW r� m r� zG_Function.argsc s t � �� | j S r\ )r� r� r� r� r� rV rW r� q r� z G_Function._hashable_contentc C s t | j| j| j| j|�S r\ )rH r� ra r� rb )r� ri rV rV rW r� t s zG_Function.__call__c s� dd� t d�D � }\}}}}t|| j| j| j| jf�D ]\}}|D ] }|t|� �|� q"q t|d�D ] \}} |�� D ]\}
} | d � | j � fdd�| d� | ||
< q<q4t
d d� |D ��S )
a�
Compute buckets for the fours sets of parameters.
Explanation
===========
We guarantee that any two equal Mod objects returned are actually the
same, and that the buckets are sorted by real part (an and bq
descendending, bm and ap ascending).
Examples
========
>>> from sympy.simplify.hyperexpand import G_Function
>>> from sympy.abc import y
>>> from sympy import S
>>> a, b = [1, 3, 2, S(3)/2], [1 + y, y, 2, y + 3]
>>> G_Function(a, b, [2], [y]).compute_buckets()
({0: [3, 2, 1], 1/2: [3/2]},
{0: [2], y: [y, y + 1, y + 3]}, {0: [2]}, {y: [y]})
c S s g | ]}t t��qS rV )r r� )r� r� rV rV rW r� � � z.G_Function.compute_buckets.<locals>.<listcomp>rs )TFFTr c s | � S r\ rV ry ��x0rV rW r� � � z,G_Function.compute_buckets.<locals>.<lambda>)r� �reversec S s g | ]}t |��qS rV )�dict�r� r� rV rV rW r� � r� ) �ranger� r� ra r� rb rX r_ r� r� r� ) r� �dicts�pan�pap�pbm�pbq�dic�lisrT �flip�mr� rV r� rW �compute_bucketsw s "�
�zG_Function.compute_bucketsc C s$ t | j�t | j�t | j�t | j�fS r\ )r� r� ra r� rb r� rV rV rW � signature� s $zG_Function.signature) r� r� r� r� r� r� r� r� r� r r r� rV rV r� rW r� b s
%r� rT c @ s6 e Zd ZdZdd� Zd dd�Zedd� �Zd d
� ZdS ) r` a-
This class represents hypergeometric formulae.
Explanation
===========
Its data members are:
- z, the argument
- closed_form, the closed form expression
- symbols, the free symbols (parameters) in the formula
- func, the function
- B, C, M (see _compute_basis)
Examples
========
>>> from sympy.abc import a, b, z
>>> from sympy.simplify.hyperexpand import Formula, Hyper_Function
>>> func = Hyper_Function((a/2, a/3 + b, (1+a)/2), (a, b, (a+b)/7))
>>> f = Formula(func, z, None, [a, b])
c C s ddl m}m}m} dd� | jjD �}dd� | jjD �}tt|� | j t|� }t
|t�}|� � d } |g}
t | �D ]} |
�
| j |
d �| j � � q;||
�| _|dgdg| g�| _|| �} | �d|| d��} |�� dd� }
|
�� | �| ||
g� |�� d �| _dS ) z�
Compute a set of functions B=(f1, ..., fn), a nxn matrix M
and a 1xn matrix C such that:
closed_form = C B
z d/dz B = M B.
r )rZ �eye�zerosc S � g | ]}t | �qS rV ��_x�r� rf rV rV rW r� � r� z*Formula._compute_basis.<locals>.<listcomp>c S � g | ]}t | d �qS �rQ r �r� rg rV rV rW r� � � rQ rp N)r� rZ r r rd ra rb r
r
ri rJ �degreer� r_ r� rk rl �
col_insert�
all_coeffsr� �
row_insertrm )r� � closed_formrZ r r �afactors�bfactorsr� rI �nrg �_r r� rV rV rW �_compute_basis� s
&zFormula._compute_basisNc sd t |�}t |�}� fdd�t |�D �}|| _|| _|| _|| _|| _� | _|d ur0| �|� d S d S )Nc s g | ] }� � |�r|�qS rV ��hasr� �rd rV rW r� � r� z$Formula.__init__.<locals>.<listcomp>)r ri r rk rl rm rd r )r� rd ri rc r rk rl rm rV r rW �__init__� s �zFormula.__init__c C � t dd� t| j| j�tj�S )Nc S � | |d |d S �Nr rQ rV �r� r rV rV rW r� � r� z%Formula.closed_form.<locals>.<lambda>�r r� rl rk r r� r� rV rV rW r � � zFormula.closed_formc
s� ddl m} |j}|j}t|�t�jj�ks t|�t�jj�kr$td��g }�jD ]"� � �jjjv r8|� |� q)� �jjjv rE|� |� q)t
d� f ���fdd�t |� D �}dd� ||fD �\}}dd� ||fD �\} }
d d� �jD �} g } t � }
|D ]Љ�fd
d��jj�jjfD �\}}||f||ffD ]w\}}t
t|�� �t|�� � �D ]d}||vs�||vs�t|| �t|| �kr� nMt�j| �D ]E\� }�� jr�qLJ fd d�|| D �}��� }|� |
7 < |D ]!}|| D ]}||�|�| |
�\}|j�rt
d ��|� |� q�q�q�q�q�g }t�j| �D ]&\� }�� �tt|��}tt|��}|� �fd
d�t||d �D �� �q| ��fdd�t |� D �� q|| S )z�
Find substitutions of the free symbols that match ``func``.
Return the substitution dictionaries as a list. Note that the returned
instantiations need not actually match, or be valid!
r )�solvez-Cannot instantiate other number of parameterszAAt least one of the parameters of the formula must be equal to %sc s g | ] }t tt� j|����qS rV �r� r� r� r )r� r� r� rV rW r� s �z/Formula.find_instantiations.<locals>.<listcomp>c S r� rV r� r� rV rV rW r� � c S s g | ] }d d� |� � D ��qS )c S s i | ] \}}|t |��qS rV r� )r� rf �valsrV rV rW �
<dictcomp> r� z:Formula.find_instantiations.<locals>.<listcomp>.<dictcomp>)r� )r� r� rV rV rW r� � �c S s g | ]}d g�qS �r rV )r� r rV rV rW r� � c s g | ] }t |� fd d���qS )c s t | �� ��S r\ )rX �xreplacery ��replrV rW r�
� z8Formula.find_instantiations.<locals>.<listcomp>.<lambda>rN r� r- rV rW r�
r) c s g | ] }|� � �r|�qS rV r )r� r� r� rV rW r� r� zValue should not be truec s g | ]}� | �qS rV rV )r� r )�a0rV rW r� & r� rQ c 3 s$ � | ]
}t tt� j|���V qd S r\ r% )r� r� r� rV rW r� ' � �" z.Formula.find_instantiations.<locals>.<genexpr>)�
sympy.solversr$ ra rb r� rd � TypeErrorr r� r_ �
ValueErrorr r r� r� r� r� � free_symbols�copyr, r1 �minr2 �maxr� �extend) r� rd r$ ra rb �
symbol_values� base_replr� r� �a_inv�b_inv�critical_values�result�_n�symb_a�symb_br� r� r� r' �exprs�repl0r� �target�n0r� �min_�max_rV )rf r0 r. r� rW �find_instantiations� sr (
�
�
�
�
����
& zFormula.find_instantiations)NNN) r� r� r� r� r r r� r rI rV rV rV rW r` � s
r` c @ � e Zd ZdZdd� Zdd� ZdS )�FormulaCollectionz- A collection of formulae to use as origins. c C st i | _ i | _g | _t| j� | jD ]&}|jj}t|j�dkr)| j �|g �� |� q|j�
� }|| j�|i �|< qdS )z7 Doing this globally at module init time is a pain ... r N) �symbolic_formulae�concrete_formulaerh r� rd r� r� r �
setdefaultr_ r� )r� �fr� �invrV rV rW r 0 s
�zFormulaCollection.__init__c C s |� � }|j}|| jv r|| j| v r| j| | S || jvr!dS g }| j| D ]*}|�|�}|D ] }|j�|�}|�� s>q1|�|�} | dkrHq1|� | |||f� q1q(|j
dd� d� |D ]0\}
}}}t ||j dg |j
�|�|j�|�|j�|��} tdd� | j
| j| jfD ��s�| S q]dS )a{
Given the suitable target ``func``, try to find an origin in our
knowledge base.
Examples
========
>>> from sympy.simplify.hyperexpand import (FormulaCollection,
... Hyper_Function)
>>> f = FormulaCollection()
>>> f.lookup_origin(Hyper_Function((), ())).closed_form
exp(_z)
>>> f.lookup_origin(Hyper_Function([1], ())).closed_form
HyperRep_power1(-1, _z)
>>> from sympy import S
>>> i = Hyper_Function([S('1/4'), S('3/4 + 4')], [S.Half])
>>> f.lookup_origin(i).closed_form
HyperRep_sqrts1(-1/4, _z)
Nrp c S � | d S r� rV ry rV rV rW r� o r� z1FormulaCollection.lookup_origin.<locals>.<lambda>r� c s s$ � | ]
}|� tjtt t�V qd S r\ )r r �NaNr r )r� �erV rV rW r� s r1 z2FormulaCollection.lookup_origin.<locals>.<genexpr>)r� r� rM rL rI rd r, r� r� r_ r� r` ri rk �subsrl rm r� ) r� rd rP r� �possiblerO �replsr. �func2r� r �f2rV rV rW �
lookup_originC s8
�
� �z FormulaCollection.lookup_originN�r� r� r� r� r rY rV rV rV rW rK - s rK c @ s, e Zd ZdZdd� Zedd� �Zdd� ZdS ) r� z�
This class represents a Meijer G-function formula.
Its data members are:
- z, the argument
- symbols, the free symbols (parameters) in the formula
- func, the function
- B, C, M (c/f ordinary Formula)
c C sV dd� ||||fD �\}}}}t ||||�| _|| _|| _|
| _|| _|| _| | _d S )Nc S s g | ] }t ttt|��� �qS rV )r r� r� r
r� rV rV rW r� � s z*MeijerFormula.__init__.<locals>.<listcomp>)r� rd ri r �_matcherrk rl rm ) r� r� ra r� rb ri r rk rl rm r� rV rV rW r � s
zMeijerFormula.__init__c C r )Nc S r r rV r! rV rV rW r� � r� z+MeijerFormula.closed_form.<locals>.<lambda>r" r� rV rV rW r � r# zMeijerFormula.closed_formc C sl |j | jj kr dS | �|�}|dur4|\}}t|j|j|j|j| jg | j �
|�| j �
|�| j �
|�d�
S dS )z
Try to instantiate the current formula to (almost) match func.
This uses the _matcher passed on init.
N)
r rd r[ r� r� ra r� rb ri rk rT rl rm )r� rd rc rT �newfuncrV rV rW �try_instantiate� s
��z MeijerFormula.try_instantiateN)r� r� r� r� r r� r r] rV rV rV rW r� y s
r� c @ rJ )�MeijerFormulaCollectionz=
This class holds a collection of meijer g formulae.
c C sD g }t |� tt�| _|D ] }| j|jj �|� q
t| j�| _d S r\ )r� r r� rh rd r r_ r� )r� rh �formularV rV rW r � s
z MeijerFormulaCollection.__init__c C s@ |j | jvrdS | j|j D ]}|�|�}|dur | S qdS )z* Try to find a formula that matches func. N)r rh r] )r� rd r_ rc rV rV rW rY � s
��z%MeijerFormulaCollection.lookup_originNrZ rV rV rV rW r^ � s r^ c @ � e Zd ZdZdd� ZdS )�Operatora�
Base class for operators to be applied to our functions.
Explanation
===========
These operators are differential operators. They are by convention
expressed in the variable D = z*d/dz (although this base class does
not actually care).
Note that when the operator is applied to an object, we typically do
*not* blindly differentiate but instead use a different representation
of the z*d/dz operator (see make_derivative_operator).
To subclass from this, define a __init__ method that initializes a
self._poly variable. This variable stores a polynomial. By convention
the generator is z*d/dz, and acts to the right of all coefficients.
Thus this poly
x**2 + 2*z*x + 1
represents the differential operator
(z*d/dz)**2 + 2*z**2*d/dz.
This class is used only in the implementation of the hypergeometric
function expansion algorithm.
c C s� | j �� }|�� |g}|dd� D ] }|�||d �� q|d |d }t|dd� |dd� �D ]
\}}||| 7 }q3|S )a�
Apply ``self`` to the object ``obj``, where the generator is ``op``.
Examples
========
>>> from sympy.simplify.hyperexpand import Operator
>>> from sympy.polys.polytools import Poly
>>> from sympy.abc import x, y, z
>>> op = Operator()
>>> op._poly = Poly(x**2 + z*x + y, x)
>>> op.apply(z**7, lambda f: f.diff(z))
y*z**7 + 7*z**7 + 42*z**5
rQ Nrp r )�_polyr r� r_ r� )r� r� �op�coeffs�diffsrU �r�drV rV rW �apply� s
"zOperator.applyN)r� r� r� r� rh rV rV rV rW ra � s ra c @ r` )� MultOperatorz! Simply multiply by a "constant" c C s t |t�| _d S r\ )rJ r
rb )r� �prV rV rW r � r� zMultOperator.__init__N)r� r� r� r� r rV rV rV rW ri � s ri c @ rJ )�ShiftAz Increment an upper index. c C s0 t |�}|dkr td��tt| d t�| _d S )Nr z"Cannot increment zero upper index.rQ �r r4 rJ r
rb )r� �airV rV rW r � s zShiftA.__init__c C s dd| j �� d S )Nz<Increment upper %s.>rQ r �rb r r� rV rV rW �__str__� � zShiftA.__str__N�r� r� r� r� r ro rV rV rV rW rk � � rk c @ rJ )�ShiftBz Decrement a lower index. c C s4 t |�}|dkr td��tt|d d t�| _d S )NrQ z"Cannot decrement unit lower index.rl �r� �birV rV rW r s zShiftB.__init__c C s dd| j �� d d S )Nz<Decrement lower %s.>rQ r rn r� rV rV rW ro s zShiftB.__str__Nrq rV rV rV rW rs rr rs c @ rJ )�UnShiftAz Decrement an upper index. c
C s& t tt|||g��\}}}|| _|| _|| _t |�}t |�}|�|�d }|dkr-td��t|| t �}|D ] }|tt | t �9 }q6t
d�}t|| | |� } }
|D ]
} | |
| d � |� 9 } qS| � d� } | dkrotd��tt| �
� dd� |��� �|t | d �t �} t| | | t �| _dS )� Note: i counts from zero! rQ r z"Cannot decrement unit upper index.�Az0Cannot decrement upper index: cancels with lowerNrp �r� r� r �_ap�_bq�_i�popr4 rJ r
r �as_poly�nthr r� rT rb )
r� ra rb r� ri rm r rf rx r �Drg �b0rV rV rW r s* 0zUnShiftA.__init__c C � d| j | j| jf S )Nz&<Decrement upper index #%s of %s, %s.>�r| rz r{ r� rV rV rW ro 3 � �zUnShiftA.__str__Nrq rV rV rV rW rv s !rv c @ rJ )�UnShiftBz Increment a lower index. c
C s: t tt|||g��\}}}|| _|| _|| _t |�}t |�}|�|�d }|dkr-td��tt |d t �}|D ]
}|tt | d t �9 }q8t
d�}t|d | | d |�} t||�}
|D ] } |
| | � |� 9 }
q^|
� d�} | dkrwtd��tt|
�
� dd� |��� �|t |d d �t �}
t||
| t �| _dS )rw rQ r z Cannot increment -1 lower index.rk z*Cannot increment index: cancels with upperNrp ry )
r� ra rb r� ri ru r rg rk r� r rf r� rV rV rW r ; s4
��zUnShiftB.__init__c C r� )Nz&<Increment lower index #%s of %s, %s.>r� r� rV rV rW ro ] r� zUnShiftB.__str__Nrq rV rV rV rW r� 8 s "r� c @ rJ )� MeijerShiftAz Increment an upper b index. c C s t |�}t|t t�| _d S r\ �r rJ r
rb rt rV rV rW r e s zMeijerShiftA.__init__c C s d| j �� d S )Nz<Increment upper b=%s.>rQ rn r� rV rV rW ro i s zMeijerShiftA.__str__Nrq rV rV rV rW r� b � r� c @ rJ )� MeijerShiftBz Decrement an upper a index. c C s t |�}td| t t�| _d S rP r� rt rV rV rW r p � zMeijerShiftB.__init__c C s dd| j �� d S )Nz<Decrement upper a=%s.>rQ rn r� rV rV rW ro t rp zMeijerShiftB.__str__Nrq rV rV rV rW r� m r� r� c @ rJ )� MeijerShiftCz Increment a lower b index. c C s t |�}t| t t�| _d S r\ r� rt rV rV rW r { s zMeijerShiftC.__init__c C s d| j �� d S )Nz<Increment lower b=%s.>rQ rn r� rV rV rW ro r{ zMeijerShiftC.__str__Nrq rV rV rV rW r� x r� r� c @ rJ )� MeijerShiftDz Decrement a lower a index. c C s t |�}t|d t t�| _d S rP r� rt rV rV rW r � r� zMeijerShiftD.__init__c C s d| j �� d d S )Nz<Decrement lower a=%s.>rQ rn r� rV rV rW ro � rp zMeijerShiftD.__str__Nrq rV rV rV rW r� � r� r� c @ rJ )�MeijerUnShiftAz Decrement an upper b index. c C sd t tt|||||g��\}}}}}|| _|| _|| _|| _|| _t |�}t |�}t |�}t |�}|�|�d }t dt
�}|D ] } |t | t
t
�9 }q>|D ] } |t t
| t
�9 }qLt d�}
t ||
|
�} t ||
�} |D ]
}
| | d |
9 } qj|D ] }
| | |
d 9 } qw| � d�}|dkr�t
d��t t | �� dd� |
��� �|
|t
�t
�} t || | t
�| _dS )rw rQ rx r z(Cannot decrement upper b index (cancels)Nrp �r� r� r �_anrz �_bmr{ r| r} rJ r
r r r4 r r� rT rb )r� r� ra r� rb r� ri ru r rg rx r� r rf r� rV rV rW r � �8 "
,zMeijerUnShiftA.__init__c C � d| j | j| j| j| jf S )Nz0<Decrement upper b index #%s of %s, %s, %s, %s.>�r| r� rz r� r{ r� rV rV rW ro � � �zMeijerUnShiftA.__str__Nrq rV rV rV rW r� � s &r� c @ rJ )�MeijerUnShiftBz Increment an upper a index. c C sl t tt|||||g��\}}}}}|| _|| _|| _|| _|| _t |�}t |�}t |�}t |�}|�|�d }t |t
�}|D ]
} |t d| t
t
�9 }q>|D ]
} |t | d t
t
�9 }qNt d�}
t |
| d |
�} t d|
�} |D ] }
| | |
9 } qp|D ]}
| | |
9 } q|| � d�}|dkr�t
d��t t | �� dd� |
��� �|
d| t
�t
�} t || | t
�| _dS )rw rQ rk r z(Cannot increment upper a index (cancels)Nrp r� �r� r� ra r� rb r� ri rm r rf rk r� r rg r� rV rV rW r � �@ "
��zMeijerUnShiftB.__init__c C r� )Nz0<Increment upper a index #%s of %s, %s, %s, %s.>r� r� rV rV rW ro � r� zMeijerUnShiftB.__str__Nrq rV rV rV rW r� � s 'r� c @ rJ )�MeijerUnShiftCz Decrement a lower b index. c C sd t tt|||||g��\}}}}}|| _|| _|| _|| _|| _t |�}t |�}t |�}t |�}|�|�d }t dt
�}|D ] } |t | t
t
�9 }q>|D ] } |t t
| t
�9 }qLt d�}
t ||
|
�} t ||
�} |D ]
}
| | d |
9 } qj|D ] }
| | |
d 9 } qw| � d�}|dkr�t
d��t t | �� dd� |
��� �|
t
| �t
�} t || | t
�| _dS )rw rQ rl r z(Cannot decrement lower b index (cancels)Nrp r� )r� r� ra r� rb r� ri ru r rg rl r� r rf r� rV rV rW r � r� zMeijerUnShiftC.__init__c C r� )Nz0<Decrement lower b index #%s of %s, %s, %s, %s.>r� r� rV rV rW ro r� zMeijerUnShiftC.__str__Nrq rV rV rV rW r� � s &r� c @ rJ )�MeijerUnShiftDz Increment a lower a index. c C sl t tt|||||g��\}}}}}|| _|| _|| _|| _|| _t |�}t |�}t |�}t |�}|�|�d }t |t
�}|D ]
} |t d| t
t
�9 }q>|D ]
} |t | d t
t
�9 }qNt d�}
t |d |
|
�} t d|
�} |D ] }
| | |
9 } qp|D ]}
| | |
9 } q|| � d�}|dkr�t
d��t t | �� dd� |
��� �|
|d t
�t
�} t || | t
�| _dS )rw rQ rk r z(Cannot increment lower a index (cancels)Nrp r� r� rV rV rW r # r� zMeijerUnShiftD.__init__c C r� )Nz0<Increment lower a index #%s of %s, %s, %s, %s.>r� r� rV rV rW ro J r� zMeijerUnShiftD.__str__Nrq rV rV rV rW r� s 'r� c @ sD e Zd ZdZdd� Zedd� �Zedd� �Zedd � �Zd
d � Z d S )
� ReduceOrderz8 Reduce Order by cancelling an upper and a lower index. c C s� t |�}t |�}|| }|jr|dk rdS |jr |jr dS t�| �}tj}t|�D ]}|t | | || 9 }q)t
|t �|_ ||_ ||_
|S )z< For convenience if reduction is not possible, return None. r N)r �
is_Integerr� r� ra r� r r� r� r
rJ rb �_a�_b)r[ rm �bjr r� rj �krV rV rW r� R s
zReduceOrder.__new__c C s� t |�}t |�}|| }|js|jsdS t�| �}tj}t|�D ] }||t | | 9 }q t |t�|_
|dkr?||_ ||_ |S t
d|d dd�|_ t
d|d dd�|_ |S )zN Cancel b + sign*s and a + sign*s
This is for meijer G functions. Nrp rQ F)�evaluate)r r� r� ra r� r r� r� r
rJ rb r� r� r )r[ rg rf �signr r� rj r� rV rV rW �_meijerh s"
�zReduceOrder._meijerc C s | � ||d�S )Nrp �r� )r[ rg rf rV rV rW � meijer_minus� s zReduceOrder.meijer_minusc C s | � d| d| d�S rP r� )r[ rf rg rV rV rW � meijer_plus� s zReduceOrder.meijer_plusc C s d| j | jf S )Nz4<Reduce order by cancelling upper %s with lower %s.>)r� r� r� rV rV rW ro � s
�zReduceOrder.__str__N)
r� r� r� r� r� � classmethodr� r� r� ro rV rV rV rW r� O s
r� c C s� t | �} t |�}| j|d� |j|d� g }g }| D ].}d}tt|��D ]}|||| �}|dur8|�|� nq$|du rC|�|� q|�|� q|||fS )z? Order reduction algorithm used in Hypergeometric and Meijer G r� N)r� r� r� r� r} r_ ) ra rb �genr� �nap� operatorsrf rc r� rV rV rW �
_reduce_order� s$
�
r� c C s. t | j| jtt�\}}}tt|� t|� �|fS )a�
Given the hypergeometric function ``func``, find a sequence of operators to
reduces order as much as possible.
Explanation
===========
Return (newfunc, [operators]), where applying the operators to the
hypergeometric function newfunc yields func.
Examples
========
>>> from sympy.simplify.hyperexpand import reduce_order, Hyper_Function
>>> reduce_order(Hyper_Function((1, 2), (3, 4)))
(Hyper_Function((1, 2), (3, 4)), [])
>>> reduce_order(Hyper_Function((1,), (1,)))
(Hyper_Function((), ()), [<Reduce order by cancelling upper 1 with lower 1.>])
>>> reduce_order(Hyper_Function((2, 4), (3, 3)))
(Hyper_Function((2,), (3,)), [<Reduce order by cancelling
upper 4 with lower 3.>])
)r� ra rb r� r r^ r )rd r� �nbqr� rV rV rW � reduce_order� s r� c C sN t | j| jtjdd� �\}}}t | j| jtjt�\}}}t ||||�|| fS )a
Given the Meijer G function parameters, ``func``, find a sequence of
operators that reduces order as much as possible.
Return newfunc, [operators].
Examples
========
>>> from sympy.simplify.hyperexpand import (reduce_order_meijer,
... G_Function)
>>> reduce_order_meijer(G_Function([3, 4], [5, 6], [3, 4], [1, 2]))[0]
G_Function((4, 3), (5, 6), (3, 4), (2, 1))
>>> reduce_order_meijer(G_Function([3, 4], [5, 6], [3, 4], [1, 8]))[0]
G_Function((3,), (5, 6), (3, 4), (1,))
>>> reduce_order_meijer(G_Function([3, 4], [5, 6], [7, 5], [1, 5]))[0]
G_Function((3,), (), (), (1,))
>>> reduce_order_meijer(G_Function([3, 4], [5, 6], [7, 5], [5, 3]))[0]
G_Function((), (), (), ())
c S s
t | �S r\ r� ry rV rV rW r� � s
z%reduce_order_meijer.<locals>.<lambda>)
r� r� rb r� r� r� ra r� r r� )rd r r� �ops1�nbmr� �ops2rV rV rW �reduce_order_meijer� s
�
�r� c s � �fdd�}|S )z? Create a derivative operator, to be passed to Operator.apply. c s( �| � �� | � }|�t���}|S r\ )r� � applyfuncr� )rl rf �rm ri rV rW �doit� s z&make_derivative_operator.<locals>.doitrV )rm ri r� rV r� rW �make_derivative_operator� s r� c C s" | }t |�D ]}|�||�}q|S )zk
Apply the list of operators ``ops`` to object ``obj``, substituting
``op`` for the generator.
)�reversedrh )r� �opsrc rc �orV rV rW �apply_operators� s r� c sf dd� | j | j|j |jfD �\}}}}tt|�� ��tt|�� ��ks3tt|�� ��tt|�� ��kr;td| |f ��g }dd� � � �fdd�}� �fdd �} tt|�� �t|�� � td
�D ]�}
d } d } d }
d }|
|v ru||
} ||
} |
|v r�||
}
||
}t| �t| �ks�t|
�t|�kr�td| |f ��d d� | | |
|fD �\} } }
}d
d� }|||
�}|||
�}t| �dkr�|| g ||
||�7 }n]t|
�dkr�||| g | ||�7 }nL| d }| d }|d | dks�|
d | dkr�td��|| dk�r||| || ||�7 }|| | ||
||�7 }n|| | ||
||�7 }||| |
| ||�7 }| ||
< |
||
< q_|�� |S )a(
Devise a plan (consisting of shift and un-shift operators) to be applied
to the hypergeometric function ``target`` to yield ``origin``.
Returns a list of operators.
Examples
========
>>> from sympy.simplify.hyperexpand import devise_plan, Hyper_Function
>>> from sympy.abc import z
Nothing to do:
>>> devise_plan(Hyper_Function((1, 2), ()), Hyper_Function((1, 2), ()), z)
[]
>>> devise_plan(Hyper_Function((), (1, 2)), Hyper_Function((), (1, 2)), z)
[]
Very simple plans:
>>> devise_plan(Hyper_Function((2,), ()), Hyper_Function((1,), ()), z)
[<Increment upper 1.>]
>>> devise_plan(Hyper_Function((), (2,)), Hyper_Function((), (1,)), z)
[<Increment lower index #0 of [], [1].>]
Several buckets:
>>> from sympy import S
>>> devise_plan(Hyper_Function((1, S.Half), ()),
... Hyper_Function((2, S('3/2')), ()), z) #doctest: +NORMALIZE_WHITESPACE
[<Decrement upper index #0 of [3/2, 1], [].>,
<Decrement upper index #0 of [2, 3/2], [].>]
A slightly more complicated plan:
>>> devise_plan(Hyper_Function((1, 3), ()), Hyper_Function((2, 2), ()), z)
[<Increment upper 2.>, <Decrement upper index #0 of [2, 2], [].>]
Another more complicated plan: (note that the ap have to be shifted first!)
>>> devise_plan(Hyper_Function((1, -1), (2,)), Hyper_Function((3, -2), (4,)), z)
[<Decrement lower 3.>, <Decrement lower 4.>,
<Decrement upper index #1 of [-1, 2], [4].>,
<Decrement upper index #1 of [-1, 3], [4].>, <Increment upper -2.>]
c S r� rV r� r� rV rV rW r� % r� z devise_plan.<locals>.<listcomp>z%s not reachable from %sc S s� g }t t| ��D ]5}|| | | dkr|}d}n|}d}|| | | kr=||| |�g7 }| | |7 < || | | ks%q|S )Nr rQ rp )r� r� )�fro�to�inc�decr� r� �sh�chrV rV rW � do_shifts. s ��z devise_plan.<locals>.do_shiftsc s �| |dd� � ���fdd��S )z( Shift us from (nal, nbk) to (al, nbk). c S � t | | �S r\ )rk �rj r� rV rV rW r� @ r� z2devise_plan.<locals>.do_shifts_a.<locals>.<lambda>c s t | � �� |��S r\ )rv r� )�aother�bother�nbkri rV rW r� A r& rV )�nalr� �alr� r� �r� ri )r� r� r� rW � do_shifts_a> s �z devise_plan.<locals>.do_shifts_ac s �||� ���fdd�dd� �S )z( Shift us from (nal, nbk) to (nal, bk). c s t �� | � |��S r\ )r� r� )r� r� r� ri rV rW r� F r& z2devise_plan.<locals>.do_shifts_b.<locals>.<lambda>c S r� r\ )rs r� rV rV rW r� G r� rV )r� r� �bkr� r� r� )r� r� r� rW � do_shifts_bC s �z devise_plan.<locals>.do_shifts_br� rV c S s g | ]
}t t|�td ��qS )r� )�sortedr� r r� rV rV rW r� W s �c S s2 g }| � � D ]\}}||kr|t| | �7 }q|S r\ )r� r� )r r� r� r� �valuerV rV rW �othersZ s �zdevise_plan.<locals>.othersr rp zNon-suitable parameters.) ra rb r� r� r� r4 r� r r� )rE �originri r� r� � nabuckets� nbbucketsr� r� r� rf r� r� r� r� r� r� r� �namax�amaxrV r� rW � devise_plan� s\ .� $
�
r� c s� t | jt�t | jt�}}t|tj �dkrdS |tj d }|dkr%dS tj|vr,dS t|tj �}|�� |d � � dkrAdS t| j�}|� |� t| j�}|� � � � d8 � � fdd�|D �}� fdd�|D �}g }t
|d �D ] } |� t | d �� qs|�
� t� �|� }
|D ] } |
t| � � }
q�|D ] } |
t| � �9 }
q�|t|
�g7 }d}
t
� �D ]&} || t| � }|D ] } |t| | �9 }q�|D ] } |t| | � }q�|
|7 }
q�t||�||
fS )z? Try to recognise a hypergeometric sum that starts from k > 0. rQ Nr c � g | ]}|� �qS rV rV r� �r� rV rW r� � r� z#try_shifted_sum.<locals>.<listcomp>c r� rV rV r� r� rV rW r� � r� )rO ra rX rb r� r r� r� r� �remover� r_ rk r� r4 r3 ri r^ )rd ri r� r� rf r� r� r� r� r �facrf rg rj r rV r� rW �try_shifted_sum� sN
r� c s� t | jt�t | jt�}}|tj }|tj }|�� |�� dd� |D �}dd� |D �� � r<t� fdd�|D ��r<tS |s@dS |d }d}tj } t
t t | ��� D ](}
||9 }||
d }| jD ]}|||
9 }qa| jD ]} || |
}qm| |7 } qR| S ) zj Recognise polynomial cases. Returns None if not such a case.
Requires order to be fully reduced. c S � g | ]}|d kr|�qS r* rV r� rV rV rW r� � r z"try_polynomial.<locals>.<listcomp>c S r� r* rV r� rV rV rW r� � r c 3 s � | ] }|� d k V qdS )rp NrV r ��bl0rV rW r� � s � z!try_polynomial.<locals>.<genexpr>Nrp rQ )
rO ra rX rb r r� r� �allr r� r r� r� ) rd ri r� r� r0 r� �al0rf r� rc r rg rV r� rW �try_polynomial� s.
r� c * C s ddl m}m} ddlm} t| jt�t| jt�}}i }|� � D ]#\}}|dkr0||vr0 dS || } t
|�t
| �f||< |� |d� q!|i krKdS t j
|vrRdS |t j
\}
} |
| dg f|t j
< td�} t j}
t j}|� � D ]I\}\}} t|�t| �kr� dS t|| �D ]2\}}|| jr�|| }|
t|| |�9 }
|t||�9 }q�|| }|
t||�9 }
|t|| |�9 }q�qq||
| | �}t�|�}g }i }|D ]�}|�� \}
}|�| �s�t|
| �}|js�td��|�� \\}}||| |fg7 }q�|
�| ��rt d��|� | �\}\}d}|j �r|j }|j }|| k�r |dk n7|j!�rR|�"| �\}} d}| | k�r8| �"| �\}} ||| | k�rGt d | ��|| }||| 9 }nt d
��|�#|g ��$|
| |f� q�i } i } td �} |j%d d
� d� ddd| i}!|�r�t&|d d �D ]}| |!| �'| � |!|d < �q�|D ]\}}| �#t jg ��$||!| � �q�|� � D ]b\}}"|"D ]\}#}| �#t(| ||�g ��$|#� �q�|"j%dd
� d� t&d|"d d d �D ] }| t(| ||�fdt(| |d |�fg| t(| ||�< �q�| t(| d|�fdd| t jfg| t(| d|�< �q�i }$t)t jgt
| �*� � �D ] \}}||$|< �q#dd� t+t
|$� � �dd
� d�D �}%||%�}&|dgt|&� g�}'| � � D ]
\}}#t|#� |'|$| < �qP|t|&��}(| � � D ]\}}"|"D ]\}#})|#|(|$| |$|) f< �qn�qht,| | dg |&|'|(�S )z�
Try to find an expression for Hyper_Function ``func`` in terms of Lerch
Transcendents.
Return None if no such expression can be found.
r )rZ r )�apartNrQ r� zp should be monomialz<Need partial fraction decomposition with linear denominatorszunrecognised form %sz%unrecognised form of partial fractionri c S rQ rP rV ry rV rV rW r� 4 r� z try_lerchphi.<locals>.<lambda>r� rp c S rQ rP rV ry rV rV rW r� > r� ro c S s g | ]\}}t |��qS rV )r )r� rg r rV rV rW r� G r z try_lerchphi.<locals>.<listcomp>c S rQ rP rV ry rV rV rW r� H r� )-r� rZ r � sympy.polysr� rO ra rX rb r� r� r} r r� r r� r� r� � is_positiver3 r � make_argsr� r rJ � is_monomialr3 �LT�NotImplementedError� as_coeff_mul�is_Powr �base�is_Add�as_independentrN r_ r� r� r� r5 � enumerater� r� r` )*rd rZ r r� r� r� �pairedr� r� �bvalue�aints�bintsr� r� r� �avaluerf rg r� �partr� � monomials�termsr� rj �indep�depr �tmpr �derivrd ri �monr� rU �trans�basisrk rl rm �b2rV rV rW � try_lerchphi� s�
�
��
� �r� c C s� ddl m}m}m} td�}| jr�dd� | jD �}dd� | jD �}tt|� |t|� }t |t�}|�
� } g }
|| �} t | �D ]2} | jd | }
|
t |
gt
| jdd� � | j|�g7 }
| | d k rr|
| | | f< |
| | | d f< q@||
�}|dgdg| d g�}|| �g}t | �D ] } |�| || � q�|�� }|�� dg| }t|�D ]\} }t||| �D ]\}}|| || 7 < q�q�t|�D ] \} }| || d d| d f |�� d | | d | f< q�t| |dg ||| �S g }
t
| jdd� �}t t|��D ]}|
t g ||�g7 }
|| d7 < �q|
t g ||�g7 }
||
�}t|�} |dgdg| d g�}|| �} |t| j� | d| d f< t d| �D ] } | j| d | | | d f< | j| d | | | f< �qNt| |dg ||| �S ) zU
Create a formula object representing the hypergeometric function ``func``.
r )r rZ r ri c S r rV r r rV rV rW r� ` r� z0build_hypergeometric_formula.<locals>.<listcomp>c S r r
r r rV rV rW r� a r rQ N)�sympyr rZ r r ra rb r
r
rJ r r� r< r� r_ r r� r� r` r� )rd r rZ r ri r r r� rI r r� rm r� rf rk rl �derivsr� rc rU rf rg rb r� rV rV rW � build_hypergeometric_formulaT s^
( �
�8 r� c C sl t | �t |�}}|}t|�}|dkrtjS |dkr�|dkr�| | \}}}|dkrAt|| | �t|� t|| � t|| � S |dkrTt|| | �dkrT||}}|dkr�t|| | �dkr�|jr�|jr�dtt | d � t| � t|| d � t| d � t|d | d � S t|d d �t|| d � t|d � t|d | d � S t
| ||�S )z�
Try to find a closed-form expression for hyper(ap, bq, z), where ``z``
is supposed to be a "special" value, e.g. 1.
This function tries various of the classical summation formulae
(Gauss, Saalschuetz, etc).
r ro rQ rp ) r� r; r r� r rL r� r� r r r< ) ra rb ri rj �q�z_rf rg rU rV rV rW �hyperexpand_special� s0 0
, ��
�� r N�z0rQ �defaultc s
�j rtjS t�dd���dkrd�� �����fdd�}tdu r$t� atd| � t| �\} }|r7td | � ntd
� t| ��} | durhtd � t | |�fd d
��}
t |
� � �fdd
��}
t
t |
�� ����S tj
}
t| ��} | dur�| \} } }
td| � || 7 }t |
|�fdd
��}
t |
� � �fdd
��}
t |
�� ���}
t
��dv r�t| j�t| j�fdkr�t| �} || |��tt�}
|
�t�s�|
|
S t�| �}|du r�t| �}|du r�tdd� t| �}td|jd|j� |t| |j��7 }|||�|
}
t |
dd��tt�S )a7
Try to find an expression for the hypergeometric function ``func``.
Explanation
===========
The result is expressed in terms of a dummy variable ``z0``. Then it
is multiplied by ``premult``. Then ``ops0`` is applied.
``premult`` must be a*z**prem for some a independent of ``z``.
F)rT r � nonrepsmallc s� t | j�| j��|t| j�| j�����}ddlm} t |� t| j�| j���|| jjd � ���}�dkr?|� t
���}t dd� t || j
�| j���tj�� }|����}�r`|���}|S )Nr )r rQ c S r r rV r! rV rV rW r� � r� z5_hyperexpand.<locals>.carryout_plan.<locals>.<lambda>)r� rl rT ri r� rm r� r �shaper� r� r r� rk r r� �rewrite)rO r� rl r rf rc ��ops0�prem�premultr ri r rV rW �
carryout_plan� s$ � ���(
z#_hyperexpand.<locals>.carryout_planNz)Trying to expand hypergeometric function � Reduced order to � Could not reduce order.z Recognised polynomial.c � � | � � � S r\ �r� �rO �r rV rW r� � r/ z _hyperexpand.<locals>.<lambda>c r r\ r r r rV rW r� � r/ z+ Recognised shifted sum, reduced order to c r r\ r r r rV rW r� � r/ c r r\ r r r rV rW r� � r/ )rQ rp )ro rQ z Could not find an origin. z@Will return answer in terms of simpler hypergeometric functions.z Found an origin: � T��polar) �is_zeror r� r: � _collectionrK r� r� r� r� r; rL rT r� r� r� ra rb r� �replacer< r r rY r� r rd r� rM )rd ri r r r r
r r r� rc rj �nopsrO rf r_ rV r rW � _hyperexpand� sZ
$
�r c s\ dd� }t | j�� t | j��t | j��t | j��g }d}|�rd}|� |j� ����fdd�d�� �}|dur@||g7 }d}q |�|j� ����fd d�d�� �}|dur_||g7 }d}q |�|j� ����fd
d�d � � �}|dur~||g7 }d}q |�|j� ����fd d�d � � �}|dur�||g7 }d}q |� |j� fd
d�d g �}|dur�||g7 }d}q |�|j�fdd�d g �}|dur�||g7 }d}q |�|j�fdd�dg �}|dur�||g7 }d}q |�|j�fdd�dg �}|du�r||g7 }d}q |s � t |j�k�s$�t |j�k�s$�t |j�k�s$�t |j�k�r(td��|�� |S )a
Find operators to convert G-function ``fro`` into G-function ``to``.
Explanation
===========
It is assumed that ``fro`` and ``to`` have the same signatures, and that in fact
any corresponding pair of parameters differs by integers, and a direct path
is possible. I.e. if there are parameters a1 b1 c1 and a2 b2 c2 it is
assumed that a1 can be shifted to a2, etc. The only thing this routine
determines is the order of shifts to apply, nothing clever will be tried.
It is also assumed that ``fro`` is suitable.
Examples
========
>>> from sympy.simplify.hyperexpand import (devise_plan_meijer,
... G_Function)
>>> from sympy.abc import z
Empty plan:
>>> devise_plan_meijer(G_Function([1], [2], [3], [4]),
... G_Function([1], [2], [3], [4]), z)
[]
Very simple plans:
>>> devise_plan_meijer(G_Function([0], [], [], []),
... G_Function([1], [], [], []), z)
[<Increment upper a index #0 of [0], [], [], [].>]
>>> devise_plan_meijer(G_Function([0], [], [], []),
... G_Function([-1], [], [], []), z)
[<Decrement upper a=0.>]
>>> devise_plan_meijer(G_Function([], [1], [], []),
... G_Function([], [2], [], []), z)
[<Increment lower a index #0 of [], [1], [], [].>]
Slightly more complicated plans:
>>> devise_plan_meijer(G_Function([0], [], [], []),
... G_Function([2], [], [], []), z)
[<Increment upper a index #0 of [1], [], [], [].>,
<Increment upper a index #0 of [0], [], [], [].>]
>>> devise_plan_meijer(G_Function([0], [], [0], []),
... G_Function([-1], [], [1], []), z)
[<Increment upper b=0.>, <Decrement upper a=0.>]
Order matters:
>>> devise_plan_meijer(G_Function([0], [], [0], []),
... G_Function([1], [], [1], []), z)
[<Increment upper a index #0 of [0], [], [1], [].>, <Increment upper b=0.>]
c sp t t| |��D ].\}\� }� | jr5|� | dkr5t� fdd�|D ��r5||�}| | |7 < | S qdS )aD Try to apply ``shifter`` in order to bring some element in ``f``
nearer to its counterpart in ``to``. ``diff`` is +/- 1 and
determines the effect of ``shifter``. Counter is a list of elements
blocking the shift.
Return an operator if change was possible, else None.
r c 3 s � | ]}� |kV qd S r\ rV r� r� rV rW r� e s � z8devise_plan_meijer.<locals>.try_shift.<locals>.<genexpr>N)r� r� r� r� )rO r� �shifterr� �counter�idxrg r� rV r� rW � try_shiftZ s ����z%devise_plan_meijer.<locals>.try_shiftTFc � t � ���| ��S r\ )r� �r� ��fan�fap�fbm�fbqri rV rW r� r r+ z$devise_plan_meijer.<locals>.<lambda>rQ Nc r r\ )r� r r! rV rW r� y r+ c r r\ )r� r r! rV rW r� � r+ rp c r r\ )r� r r! rV rW r� � r+ c � t � | �S r\ )r� r )r" rV rW r� � r� c r& r\ )r� r )r# rV rW r� � r� c r& r\ )r� r )r$ rV rW r� � r� c r& r\ )r� r )r% rV rW r� � r� zCould not devise plan.)r� r� ra r� rb r� r� )r� r� ri r r� �changerc rV r! rW �devise_plan_meijer s� :
�
�
�
�
�02r( Fc s� t du rt� a |dkr
d}| }td| � td�}t| �\} ��r&td| � ntd� t �| �}|durvtd|j� �t|j| |�7 �t|j �
|j |��t |j
�
|j |�|��}|�t|��}||j�
|j |� } | d �
||�} t| d d
�S td � d d
� � � ��fdd�}
td��|
| j| j| j| j||�\} } dd� }
�D ]}t|j�
|d� tt i�t�|_q�|
|
| j�|
| j�|
| j�|
| j��d| �\}}t| �
||�d d
�} t|�
�d| �d d
�}t|t�s�|�
�d| �}| |�}|jdk�s |jdk�r+t |j�t |j�k�r+t |j �dk du�r+t |�t d�k�r+| du�r$d } |du�r+d }| d u �r9| � |�p6d�} n| � |�p?d�} |d u �rO|� |�pLd�}n|� |�pUd�}| du�ro|du�ro|dk�rhd}|t!k�rod} t| t��s{| �
||�} t|t��s�|�
||�}dd� }|| | �}|||�}t"||�ddt#fk�r�||k �r�| S |S t$|d |d �dk�r�t$|d |d �dk�r�t%| | f||f||�d f�S t%| | f||f||�d f�} | �&t'��r�|�s�td� | �&t'��r�|�r�| S ||�S )a�
Try to find an expression for the Meijer G function specified
by the G_Function ``func``. If ``allow_hyper`` is True, then returning
an expression in terms of hypergeometric functions is allowed.
Currently this just does Slater's theorem.
If expansions exist both at zero and at infinity, ``place``
can be set to ``0`` or ``zoo`` for the preferred choice.
Nr z1Try to expand Meijer G function corresponding to ri r
r z Found a Meijer G formula: r Tr z; Could not find a direct formula. Trying Slater's theorem.c S sP | D ]#}t | | �dkr%d}||v rt || �}|d t | | �k r% dS qdS )z Test if slater applies. rQ r FTr� )r� r� r� r� rV rV rW �can_do� s �z _meijergexpand.<locals>.can_doc %
s� t | |||�}|�� \}}} }�|| �stjdfS t| �t|� t|�t|� k }
t| �t|� t|�t|� kr?t��dk }
|
du rHtjdfS tj} |D �]*} t|| �dkr�|| d �d}
t|�}|��� |D ]
}|
t|� �9 }
qk| D ] }|
td� | �9 }
qx|D ] }|
td� | � }
q�|D ]
}|
t|� � }
q��fdd�t| �t|� D �}�fdd�t|�t|� D �}t tj
t|�t|� �}|| }�| � }t t ||�|��|�d d�}| |
| 7 } qM|| d ��fdd�|| dd � D �}t|�}�fd d�| | d |d � D �}t|�}|| D ]}|�|� �q t|�}| | d |� D ]} |�| � �q2|d
} d d� t
||�D �} td �} �| } |D ]}t|d��se|j�rett|��}| t|| �9 } �qS| D ]
} | td| | �9 } �qq|D ]
}| td| | � } �q�|D ] } | t| | � } �q�t| �} ttt| ���D ]}!t| | �|! �}"t|"��fd
d��}"| |"8 } �q��| � t tj
t|�t|� d �}|| }�| � }� fdd�t| �t|� D �dg }� fdd�t|�t|� D �}t t ||�|��|� d d�}tj
| t| � }#t|�D ]}$|#tj
| |$ t| ||$ d | |$ � 9 }#�q | D ]
} |#td| � �9 }#�q8|D ] }|#t|� �9 }#�qH|D ] } |#t| � � }#�qV|D ]
}|#td| � � }#�qd| |#| 7 } qM| |
fS )NFrQ r c � g | ]}d � | �qS r
rV r ��bhrV rW r� r z5_meijergexpand.<locals>.do_slater.<locals>.<listcomp>c r* r
rV r r+ rV rW r� r �r c r� rV rV )r� ru ��b_rV rW r� r� c r� rV rV )r� rm r. rV rW r� r� rp c S s g | ]\}}|| �qS rV rV )r� r� r� rV rV rW r� r r� c r r\ r r r� rV rW r� 4 r/ z3_meijergexpand.<locals>.do_slater.<locals>.<lambda>c r* r
rV r ��aurV rW r� < r c r* r
rV r r0 rV rW r� = r )r� r r r� r� r� r� r� r r/ � NegativeOner r^ r� r r rR �int�roundr r� rK r� r4 r3 )%r� r� ra rb ri �zfinalrd r r� r� �condrc r r� �bor� �ajr� r� r� �hargr �hyp�kir� �lirg �aorf �lu�dir� � integrandrf �residrl r� �r) r� r� )r1 r/ r, ri rW � do_slater� s�
� " $ � 0z!_meijergexpand.<locals>.do_slaterr� c S s dd� | D �S )Nc S s g | ]}d | �qS r
rV r� rV rV rW r� V r� z._meijergexpand.<locals>.tr.<locals>.<listcomp>rV )r� rV rV rW r� U s z_meijergexpand.<locals>.trrQ rp F�nonrepr c S sJ |du rd}n |du rd}nd}| � ttt t�rd}|| �t�| �� fS )NTr FrQ ro rr )r r r r �countr< � count_ops)r� r6 �c0rV rV rW �weight� s z _meijergexpand.<locals>.weightz@ Could express using hypergeometric functions, but not allowed.)(�_meijercollectionr^ r� r r� rY rd r( r� rl rT ri r� rm r� r� rk rM r� r� ra rb rJ rb r
r� r� �deltar� r7 �nur/ r r r7 r r8 r6 r r< )rd r � allow_hyperr �place�func0ri rO rl rf rC �slater1�cond1r� rc �slater2�cond2r rH �w1�w2rV rB rW �_meijergexpand� s�
�
g $"�
"&
0 rU c s8 t | �} �fdd�}� ��fdd�}| �t|��t|�S )a�
Expand hypergeometric functions. If allow_hyper is True, allow partial
simplification (that is a result different from input,
but still containing hypergeometric functions).
If a G-function has expansions both at zero and at infinity,
``place`` can be set to ``0`` or ``zoo`` to indicate the
preferred choice.
Examples
========
>>> from sympy.simplify.hyperexpand import hyperexpand
>>> from sympy.functions import hyper
>>> from sympy.abc import z
>>> hyperexpand(hyper([], [], z))
exp(z)
Non-hyperegeometric parts of the expression and hypergeometric expressions
that are not recognised are left unchanged:
>>> hyperexpand(1 + hyper([1, 1, 1], [], z))
hyper((1, 1, 1), (), z) + 1
c s, t t| |�|� d�}|d u rt| ||�S |S )Nr- )r r^ r< �ra rb ri rf r- rV rW �
do_replace� s z hyperexpand.<locals>.do_replacec sF t t| d | d |d |d �|� ��d�}|�tttt �s!|S d S )Nr rQ )r rM )rU r� r r r r rV �rL rM r rV rW � do_meijer� s ��z hyperexpand.<locals>.do_meijer)r r r< rH )rO rL r rM rW rY rV rX rW � hyperexpand� s rZ )Fr N)�r� � collectionsr � itertoolsr r� r �
sympy.corer r r r r r
r r r
r r r r r r r r �sympy.core.compatibilityr r �sympy.core.modr �sympy.functionsr r r r r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 �$sympy.functions.elementary.complexesr: r; � sympy.functions.special.hyperr< r= r> r? r@ rA rB rC rD rE rF rG rH r� rI rJ � sympy.seriesrK �sympy.simplifyrL �sympy.simplify.powsimprM �sympy.utilities.iterablesrO rX r� r� r� r� r^ r� r
r` rK r� r^ ra ri rk rs rv r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r( rI rU rZ rV rV rV rW �<module> s� : L �< $E @
L)5
)* ./31@
1 ;$
�j
�