## Fichier  : HYPERG.tst
## Format   : Maple file
## Auteur   : Bruno Gauthier
## A propos : test file for HYPERG
## Date     : Wed Oct  8 08:34:37 METDST 1997
## UpDate   : Mon Jul  5 07:54:24 METDST 1999
###############################################################################

with(HYPERG);

`HYPERG/Verbose` := 0;  #0,1,2

debut := time():

##

print(`2. Background`);

IsHyperg(binomial(3*k,k),k);
IsHyperg( (-1)^n * RF[n,3] * 2^n / (n+b), n);
IsHyperg( sin(n), n);

HypergToRec(binomial(3*k,k),T(k));
HypergToRec( (-1)^n * RF[n,3] * 2^n / (n+b), U(n));

GenRec( {(2*n)!/n!/(n+1)!,2^n}, A(n) );
GenRec( {k,k^2,k^3}, U(k) );

IsHYP ( HYP[[a,-5,c],[d,-14],z] );
IsHYP ( HYP[[a,b,c],[d,e],z] );

IsRF ( RF[4,3] );
IsRF ( RF[a,s,d] );
IsRF ( RF[a,s] );

RfEval( RF[4,3] );
RfEval( RF[a,3] );
RfEval( RF[a,b] );

AddParam( HYP[[a,b],[d],1], c );
AddParam( QHYP[[b,c],[d],q,z], 3 );

HypPermUp( HYP[[a, b, d, c], [e, f, g], z], [2,3,1,4] );
HypPermLow( QHYP[[a, b, c, d], [e, f, g], q, z], [2,3,1] );
HypPermBoth( HYP[[a, b, c, d], [e, f, g], z], [2,3,1] );

HypSimplify( HYP[[a,b,c],[c],z] + HYP[[a,b,d],[d],z] );
HypSimplify( HYP[[a,b,c],[d,c],1/4*(-4*x+4*x^2+1)/(x*(x-1))],'factor' );
hf := HypSimplify( HYP[[a,b,3,e],[3,d,e],-2*z/z^2] );
RfEval( FirstTerms(hf,4) );
HypSimplify( HYP[[a,b],[b],z] );

HypDiff(HYP[[a,b,c],[d,e],z],z);

HypType( HYP[[a,b,c],[d,c],z] );                      # ordinary
HypType( HYP[[a,b,c],[1+a-b,1+a-c],z] );              # well-poised 
HypType( HYP[[-n,b,1+a/2,a],[a+1-b,a/2,a+1+n],z] );   # very-well poised 
HypType( HYP[[a,b,c,1],[a,a+1-c,a+1-b],z] );          # well-poised 
HypType( HYP[[x+1,-n-1/2,-n],[x-2*n,3/2],1] );        # nearly-poised (first kind)
HypType( HYP[[a,b,c],[1-b,1-c],z] );                  # nearly-poised (second kind)
HypType( VHYP[a,[b,2+c,d],z] );                       # very-well poised

HypOrder( HYP[[-n,b,1+a/2,a],[a+1-b,a/2,a+1+n],z] );  # very-well poised order
HypOrder( HYP[[a,b,c,1],[a,a+1-c,a+1-b],z] );         # well-poised order
HypOrder( HYP[[x+1,-n-1/2,-n],[x-2*n,3/2],1] );       # nearly-poised order

HypToVHyp( HYP[[-n,b,1+a/2,a],[a+1-b,a/2,a+1+n],z] ):

hf := VHYP[a, [b, c], 1];
IsVHYP( hf );
VHypToHyp( hf );
HypEval( hf );

vhf := VHYP[a,[b,c,3,s],z];
hf := VHypToHyp( vhf );
HypToVHyp( hf );

expr := RF[a,b] * RF[a,e] * HYP[[a,b,c],[d,e],z];
MapList( expr );
MapApply( RfEval, {[2]}, expr );

RecOrder( U(n+3)+U(n+2)+n*U(n-1)=3, U(n) );
SubsRec( U(n)-n*U(n+2)=0, U(n), a^n );
CheckRec( U(n)-n*U(n+2)=0, U(n), 2^n );
SimplifyRec( U(n)+U(n+2)+n*U(n)=3*n, U(n) );
SimplifyRec( cste*((n-2)*U(n)+U(n+2)+n*U(n)=3*n), U(n), 'factor' );
ShiftRec( U(n)+U(n+1), U(n) );
ShiftRec( U(n-1)+n*U(n+1)+3*n*U(n+2)=2*n, U(n), 3 );
IsHomog( (n+2)*U(n+1)-n*U(n)=n, U(n) );
Homog( (n+2)*U(n+1)-n*U(n)=n, U(n) );

##

print(`3. SumToHyp`);

SumToHyp( Sum(x^k,k) );
SumToHyp( Sum(1/(2*k-1)/(2*k+1)!,k=0..infinity) );
SumToHyp( Sum(x^k/k!,k=0..infinity) );
SumToHyp( Sum(2^k/(k!)^2,k=0..infinity) );
SumToHyp( Sum(2^n,k=0..infinity) );
SumToHyp( Sum(a^k*3*(-n+k-1)!/(k!*(-n-1)!),k=0..infinity) );
SumToHyp( Sum((-1)^k*(x/2)^(2*k+p)/(k!*(k+p)!),k=0..infinity) );
SumToHyp( Sum( (3*p)! / (p!)^2/(p-1)!*x^p,p=1..infinity) );
SumToHyp( Sum( (-1)^k*binomial(k,n-k),k=0..infinity) );
SumToHyp( Sum((-1)^k*RF[-n,k]/RF[a,k]*RF[n+a-3,k],k=0..infinity) );
# Hermite polynomials
SumToHyp( Sum(n!*(-1)^k*(2*x)^(n-2*k)/(n-2*k)!/k!,k) );
SumToHyp( Sum(binomial(M,k)*binomial(N,R-k),k) );
SumToHyp( Sum((n-l)!/2^(2*(n-m-k))/(m-k)!/(2*k)!/(n-l-m-k)!,k) );
h := HYP[[a,b],[c],z];
h := HypEval( h );
SumToHyp( h );
SumToHyp(2*sqrt(2)*Sum(RF[1/4,k]*RF[1/2,k]*RF[3/4,k]/k!/k!/k!*(1103+26390*k)*(1/99)^(4*k+2),k));
#and with complex parameters
SumToHyp(Sum(4*k^2+1,k));
SumToHyp(Sum((6*k+3)/(4*k^4+8*k^3+8*k^2+4*k+3),k));

##

print(`4. Rules for manipulating Gamma function and Rising factorials`);

BaseSplit( RF[a,n], 2 );
Ext1( RF[a,n], m );
Ext1( RF[a,n], infinity );
Ext2( RF[a,n], m );
Ext2( GAMMA(a), m );
Inv( GAMMA(a) );
Linear1( RF[a,n] );
Linear1( GAMMA(n) );
Linear2( RF[a,n] );
Neg1( RF[a,n] );
Neg1( 3/RF[a,n] );
Neg2( RF[a,n] );
Trans( RF[a,n] );
Split( GAMMA(a), m );
Split( a*GAMMA(a)*RF[a,b]*GAMMA(b), m );
Linear1( safdasda*RF[a,n]/GAMMA(n)*RF[b,n]*RF[c,n]^2 );

##

print(`5. Summation formulas`);

HypSum( HYP[[a],[],z], 1 );
HypSum( HYP[[a,-n],[c],z], 1 );
HypSum( HYP[[b,a],[c],1], 1 );
HypSum( HYP[[a,b],[c],z], 3 );
HypSum( HYP[[a,b],[c],1], 3 );
HypSum( HYP[[a,b],[2+a+b],1], 3 );
HypSum( HYP[[a,b],[1+a-b],-1], 4 );
HypSum( HYP[[a,b],[c],-1], 4 );
HypSum( HYP[[-n/2,1/2-n/2],[1/2+b],1], 5 );
HypSum( HYP[[a,b,c+n],[c,1+a],1], 1 );
HypSumPrint( HYP[[a,b,c+n],[c,1+a],1], 1 );
hf := SumToHyp(Sum((-1)^n/(2*n+1),n));
HypSum(hf,4);

##

print(`7. Contiguous formulas`);

HypContig( HYP[[a,b,c],[d,e],z], 1 );
HypContig( HYP[[a,b,c],[d,e],z], 2 );
HypContig( HYP[[1,b,c],[d,e],z], 2 );
HypContig( HYP[[a,b,c],[d,e],z], 14, 1 );
HypContig( HYP[[a,b,c],[d,e],z], 26, 1,3 );
HypContig( HYP[[a,b,c,d,e],[f,g,h],z], 31, 1,2 );

##

print(`8. Limit`);

th:=HYP[[a,b,-n],[c,1+a+b-c-n],1] = RF[-a+c,n]*RF[-b+c,n]/RF[c,n]/RF[-a-b+c,n];
Lim(th,b=infinity);

Lim(HYP[[a,b,-n],[c,1+a+b-c-n],1],b=infinity);

#confluence principle
Lim(HYP[[a,b],[c],z/b],b=infinity);
Lim(HYP[[a,b],[2*c],z*c],c=infinity);

Lim( HYP[[a1,a2,lbd*u],[b1,b2],z/lbd], lbd=infinity );
Lim( HYP[[a1,a2],[b1,b2,lbd*v],lbd*z], lbd=infinity );
Lim( HYP[[a1,a2,lbd*u],[b1,b2,lbd*v],z], lbd=infinity );

Lim( GAMMA(1+a+m)/GAMMA(1+a-b+m)*GAMMA(1+a-b-c+m)/GAMMA(1+a-c+m), m=infinity );

Lim( RF[-a+c,n]*RF[-b+c,n]/RF[c,n]/RF[-a-b+c,n], b=infinity );

Lim( GAMMA(a+m)/GAMMA(b+m), m=infinity );

Lim( GAMMA(1+a+m)/GAMMA(1+a-b+m), m=infinity );

Lim( GAMMA(1+a+m)*GAMMA(1+a),m=infinity );

##

print(`9.1 Polynomial solutions`);

PolySolRec((n+1)*x(n+1)-(n-k)*x(n)=1 ,x(n));
PolySolRec(3*U(n+2)-n*U(n+1)+(n-1)*U(n)=0,U(n));
PolySolRec(r(n+2)-2*r(n+1)+r(n)=2,r(n),{r(0)=-1,r(1)=m});
PolySolRec(3*U(n+2)-n*U(n+1)+(n-1)*U(n)=3,U(n));
PolySolRec(3*U(n+2)-2*U(n+1)-U(n)=0,U(n));
PolySolRec((n+2)*U(n+2)-(3*n+8)*U(n+1)+2*(n+3)*U(n)=0,U(n));
PolySolRec((2*n+1)*P(n+3)-(2*n+3)*P(n+2)+(2*n-3)*P(n+1)-(2*n-1)*P(n)=3,P(n));
PolySolRec(-(n+1)^2*U(n+2)+(n+2)*(2*n+1)*U(n+1)-(n+2)*(n+1)*U(n)=0,U(n));
PolySolRec(n*U(n+1)-(n+10)*U(n)=0,U(n));  
PolySolRec(C(n)-2*C(n+1)+C(n+2)=0,C(n));
PolySolRec(3*U(n+2)-2*U(n+1)-U(n)=0,U(n));
PolySolRec(C(n+2)*n+2*C(n+2)-3*C(n)-C(n)*n-C(n+1)=0,C(n));
PolySolRec( y(x)*(2*x^3+9*x^2+13*x+6)+(-8*x-4*x^3-12*x^2)*y(x+1)+y(x+2)*(2*x^3+3*x^2+x)=1016*x+28444*x^3+8100*x^2+58620*x^4+1386*x^10+126*x^11+79260*x^5+74088*x^6+48888*x^7+22680*x^8+7140*x^9, y(x) );
PolySolRec( U(n+1)-U(n)=10*n^9, U(n) );
PolySolRec( U(n+1)-U(n)=20*n^19, U(n) );

print(`9.2 Rational solutions`);

RatioSolRec(2*n*(n+3)*U(n)-(n+1)*(3*n+8)*U(n+1)+(n+2)^2*U(n+2)=0,U(n));
RatioSolRec((n+4)*U(n+2)+U(n+1)-(n+1)*U(n)=0,U(n));
RatioSolRec(-4*(2*m+3)*(2*m+1)*(m+1)*U(m)+(m+3)*(m+2)*(m+1)*U(m+1)=0,U(m));
RatioSolRec((n+4)*(2*n+1)*(n+2)*U(n+3)-(2*n+3)*(n+3)*(n+1)*U(n+2)
         +n*(n+2)*(2*n-3)*U(n+1)-(n-1)*(2*n-1)*(n+1)*U(n)=3,U(n));

print(`9.3 Hypergeometric solutions`);

HypSolRec( y(n) = (n-1)*y(n-1) + (n-1)*y(n-2),y(n));
HypSolRec( (k+n)*(1+k+n)*y(n) - 2*n*(1+k+n)*y(1+n) + n*(1+n)*y(2+n) = 0,y(n));
HypSolRec((n+4)*a(n+2)+a(n+1)-(n+1)*a(n)=0,a(n));
HypSolRec(a(n)=(n-1)*a(n-1)+(n-1)*a(n-2),a(n));
HypSolRec(a(n)=a(n-1)+(n-1)*a(n-2),a(n));
HypSolRec(2*(2*n-1)*c(n)=(n+1)*c(n+1),c(n));
HypSolRec((-4*n-2)*a(n)+(n+1)*a(n+1)=0,a(n)); 
HypSolRec(-4*(2*m+3)*(2*m+1)*U(m)+(m+3)*(m+2)*U(m+1)=0,U(m));  
HypSolRec(3*(2*n-1)*s(n)=(n+1)*s(n+1)+(n-2)*s(n-1),s(n));
HypSolRec(a(n+2)-199*a(n+1)+9900*a(n)=0,a(n));
HypSolRec((n-1)*y(n+2)-(n^2+3*n-2)*y(n+1)+2*n*(n+1)*y(n)=0,y(n));
HypSolRec(y(n)=(n-1)*y(n-1)+(n-1)*y(n-2),y(n)); 
HypSolRec((-6-27*k-27*k^2)*u(k)+(k^2+k)*u(k+1)=0,u(k));

##

print(`10.1 Gosper's algorithm`);

Gosper(binomial(n,k),n);
Gosper((-1)^k*binomial(n,k),n);
Gosper(binomial(n,k)/2^n-binomial(n-1,k)/2^(n-1),k);
Gosper((-1)^(k+1)*(4*k+1)*(2*k)!/(k!*4^k*(2*k-1)*(k+1)!),k);
Gosper(k*k!,k);
Gosper(binomial(1/2,m-j+1)*binomial(1/2,m+j),j);

print(`10.2 Zeilberger's algorithm`);

SumToRec(Sum(binomial(n,k),k),n,a);
SumToRec(Sum(binomial(n,k)^2,k),n,a);
SumToRec(Sum(binomial(n,k)^3,k),n,a);
SumToRec(Sum(binomial(x,k)*binomial(y,n-k),k),n,a);
SumToRec(Sum(k*binomial(2*n+1,2*k+1),k),n,a);
SumToRec(Sum((a+k-1)!*(b+k-1)!*(c-a-b+n-k-1)!/k!/(n-k)!/(c+k-1)!,k),n,A);
SumToRec(Sum(binomial(n,k)^2*x^k,k),n,A);
SumToRec(Sum(binomial(n-1,2*k)*binomial(2*k,k)/(k+1)*2^(n-2*k-1),k),n,A);
SumToRec(Sum(binomial(n,k)*5^((k-1)/2),k),n,A);
SumToRec(Sum(binomial(n,k)^2*binomial(n+k,k)^2,k),n,A); # Apery's numbers 
SumToRec(Sum(binomial(a+b+c+d+e-k,e-k)*binomial(a+d,k+d)
*binomial(b+c,k+c)/binomial(a+c+d+e,a+c)/binomial(b+c+d+e,c+e),k),e,S,'cert');

HypToRec(HYP[[a,b,-n],[d,e],1],a,A);
HypToRec(HYP[[a,b,-n],[d,e],z],a,A);
HypToRec(HYP[[-n,n+1],[1],(1-z)/2],n,LE);    # Legendre polynomial
HypToRec(HYP[[a,b,c,-n],[d,e,f],1],a,A);

##

print(`11. Time`);

Time( HypSolRec, 't', y(n)=(n-1)*y(n-1)+(n-1)*y(n-2), y(n) );
t;

##

print(`Examples`);

# Summation -> Zeil -> HypSol
s   := Sum(j^2*binomial(n,j),j);
rec := SumToRec(s,n,A);
sol := HypSolRec(rec,A(n));
simplify(product(op(sol),n=1..n-1));

# idem (hypergeometric notation)
f   := Sum(j^2*binomial(n,j),j);
h   := SumToHyp(f);
rec := HypToRec(h,n,A);
sol := HypSolRec(rec,A(n));
simplify(product(op(sol),n=1..n-1));

# HYP -> HypSol -> solution
h   := HYP[[- n + m + l, - m], [1/2], 1];
rec := HypToRec(h,m,A);
sol := HypSolRec(rec,A(m));
product(op(sol),m=0..m-1);

# Manipulation
h := Lim(HYP[[a,1+a/2,b,c,d,1+2*a-b-c-d+m,-m],
        [a/2,1+a-b,1+a-c,1+a-d,b+c+d-a-m,1+a+m],1],m=infinity);
h := subs(d=a/2,h);
HypSimplify( h );

# Manipulation
mysum := Sum(binomial(M,k)*binomial(N,R-k),k);
myhyp := SumToHyp( mysum );
myhyp := HypSum( myhyp, 1 );
expr  := RfEval( myhyp );
expr  := simplify( expr );

#
rec96  := SumToRec(Sum(binomial(2*n+1,n-1-3*k),k),n,R);
left96 := (2^n+1)*(2^n-1)/3;
CheckRec(rec96,R(n),left96);

# Numerical evaluation
h := HYP[[0.1,0.2],[0.4],1]:
HypSum( h, 3 );  # Gauss's theorem

##

fin := time():

fin-debut;

quit