#############################################################
##DR                          
## To use it, stay in the                                            
##same directory, get into Maple (by typing: maple <Enter> )         
##and then type:  read HIRSCH<Enter>                                 
##Then follow the instructions given there  
##
##Written by Ha Luu and Doron Zeilberger, Rutgers University
##############################################################

print(` This is DR `):
print(`Written by Ha Luu and Doron Zeilberger `):
print(``):

print(`---------------------------------------`):
 print(`For a list of the MAIN procedures type Help();, for help with`):
 print(`a specific procedure, type HelpWith(procedure_name);   .`):
 print(``):
print(`---------------------------------------`):
with(combinat):

Digits:=100:

Help:=proc()

if args=NULL then
 print(`The procedures are :ID, NumLr,NumLrs, GPLP, GFLPf,GFLPhi,LarPNumsP,NumPLr`):
 print(``):
else
	HelpWith(args):
fi:

end:

HelpWith:=proc()

if args=NULL then
 print(`The procedures are: ID, NumLr,NumLrs, GPLP, GFLPf,GFLPhi,LarPNumsP,NumPLr `):
 print(``):
 
elif nops([args])=1 and op(1,[args])=ID then
 print(`ID(f,x,k): Given the probabity generating function f`):
 print(`in the variable x, for some r.v. under some prob. distibution`):
 print(`outputs the list [av,var, std. moms].Try`):
 print(`ID((1+x)^10,x,4);`):
 
elif nops([args])=1 and op(1,[args])=NumLr then
 print(`NumLr(n,k): give a number n, find the total number of`):
 print(`ways to partition n such that the largest part is k.Try`):
 print(`NumLr(7,4);`):
 
elif nops([args])=1 and op(1,[args])=GFLP then
 print(`GFLP(k,t): the first k terms in the sequence of polynomials`):
 print(`P_i(t):= Sum of t^(largest part(partition)), over all partitions`):
 print(`of the integer i.Using the generating function, and taylor.Try:`):
 print(`GFLP(10,t);`):

elif nops([args])=1 and op(1,[args])=NumLrs then 
 print(`NumLrs(n): give a number n, out put list of numbers such that`):
 print(`the i-th entry is the number of way to partition n , with i`):
 print(`to be the largest part.Try:`):
 print(`NumLrs(100);`):
 
elif nops([args])=1 and op(1,[args])=GFLPf then 
 print(`GFLPf(k,t): the first k terms in the sequence of polynomials`):
 print(`P_i(t):= Sum of t^(largest part(partition)), over all partitions of`):
 print(`the integer i using the recurrence for A(n,k):=number of partitions `):
 print(`of n with largest part k. Try:`):
 print(`GFLPf(10,t);`):

elif nops([args])=1 and op(1,[args])=GFLPhi then 
 print(`GFLPhi(k,t,s): the first k terms in the sequence of polynomials`):
 print(`P_n(t,s):=sum of s^(largest part)*t^(hirsch index), over all`):
 print(`partition of the integer n, using the generating function and taylor.Try`):
 print(`Try GFLPhi(10,t,1);`):

elif nops([args])=1 and op(1,[args])=LarPNumsP then
 print(`LarPNumsP(n,p,q): is the number of partition n such that`):
 print(`the largest part is p and there is <=q parts by using recurrence function.Try:`):
 print(`LarPNumsP(8,5,3)`):

elif nops([args])=1 and op(1,[args])=NumPLr then
 print(`NumPLr(n,k,s): Given a number n, output A(n,k,s) such that`):
 print(`A(n,k,s) is total number of ways to partition n, with the largest`): 
 print(`part is k, and size of Durfee rectangle is s,using the recurrence equation.Try`):
 print(`NumPLr(8,3,2)`):

elif nops([args])=1 and op(1,[args])=ID2 then
 print(`ID2(f,x,y,k): Given the probabity generating function f`):
 print(`in the variable x,y for some r.v. under some prob. distibution`):
 print(`outputs the list [av,var, std. moms].Try:`):
 print(`ID(x^2+3*y^3,x,y,3)`):


fi:
end:


##############################################################
#
#ID(f,x,k): Given the probabity generating function f
#in the variable x, for some r.v. under some prob. distibution
#outputs the list [av,var, std. moms]

ID:=proc(e,x,k) local i,av,M, f:

f:=e/subs(x=1,e):

av:=subs(x=1,diff(f,x)):

M:=[av]:


f:=f/x^av:


f:=x*diff(f,x):
for i from 2 to k do
f:=x*diff(f,x):
M:=[op(M),subs(x=1,f)]:
od:
M:
 
normal([M[1],M[2],seq(M[i]/M[2]^(i/2),i=3..k)]):
end:

################################################################
#NumLr(n,k): Given a number n, output A(n,k) such that
#A(n,k) is total number of ways to partition n, with the largest 
#part is k, using the recurrence equation.

NumLr:=proc(n,k) local i:

option remember;

if n<0 then
	return 0:
elif n=k then
	return 1:
else
    return add(NumLr(n-k,i),i=1..k):
fi:
end:

##############################################################
#NumLrs(n): give a number n, out put list of numbers such that
#the i-th entry is the number of way to partition n , with i
#to be the largest part.

NumLrs:=proc(n) local i:

[seq(NumLr(n,i),i=1..n)]:

end:


###################################################################
#GFLP(k,t): the first k terms in the sequence of polynomials
#P_i(t):= Sum of t^(largest part(partition)), over all partitions of the integer i
#Using the generating function, and taylor
GFLP:=proc(k,t) local i,lu,q:
lu:=expand(taylor(mul(1/(1-q^i*t),i=1..k),q=0,k+2)):
[seq(coeff(lu,q,i),i=1...k)]:
end:



#GFLPf(k,t): the first k terms in the sequence of polynomials
#P_i(t):= Sum of t^(largest part(partition)), over all partitions of the integer i
#Using the recurrence for A(n,k):=number of partitions of n with largest part k
GFLPf:=proc(k,t) local i,n:
option remember:

[seq(add(NumLr(n,i)*t^i,i=1..n),n=1..k)]:

end:

#####################################################################-new stuffs
#####################################################################
#GFLPhi(k,t,s): the first k terms in the sequence of polynomials
#P_n(t,s):=sum of s^(largest part)*t^(hirsch index), over all
#partition of the integer n, using the generating function and taylor

GFLPhi:=proc(k,t,s) local i, n, q, lu :

lu:=add(q^(n^2)*t^n*s^n/mul((1-q^i),i=1..n)/mul(1-q^i*s,i=1..n),n=1..k):

lu:=expand(taylor(lu,q=0,k^2+1)):

[seq(coeff(lu,q,j),j=1..k^2)]:

end:


####################################################################
####################################################################
#LarPNumsP(n,p,q): is the number of partition n such that
#the largest part is p and there is <=q part
#by using recurrence function.

##A(8,3,2)=A(5,1,1)+A(5,2,1)+A(5,3,1)

LarPNumsP:=proc(n,p,q) local i,j:
option remember:

if n<0 then
	return 0:

elif q>n then
	return 0:
elif n=p and q=1 then
	return 1:
elif n<p then 
	return 0:
elif (n-p)<(q-1) then
	return 0:
else
	return add(add(A(n-p,i,j),i=1..p),j=1..q-1):
fi:

end:

####################################################################
####################################################################
#NumPLr(n,k,s): Given a number n, output A(n,k,s) such that
#A(n,k,s) is total number of ways to partition n, with the largest 
#part is k, and size of Durfee rectangle is s,using the recurrence equation.

NumPLr:=proc(n,k,s) local i,j:

if k<s then 
	return 0:
elif n-s^2<0 then
	return 0:
elif k=s then
	return NumLr(n-s^2,s):
else
    return add(LarPNumsP(i,k-s,s)*NumLr(n-s^2-i,s),i=k-s..(n-s^2-1))+LarPNumsP(n-s^2,k-s,s):
fi:
end:

#####################################################################
#####################################################################
#NumPLrs(n): give a number n, give a number n, out put list of lists of 
#such that the ii-th entry is the number of way to partition n , with i
#to be the largest part and j^2 to be the size of largest Durfee square

NumPLrs:=proc(n) local i,j:

[seq([seq(NumPLr(n,i,j),i=1..n)],j=1..floor(sqrt(n)))]:

end:


#####################################################################
#####################################################################
#ID2(f,x,y,k): Given the probabity generating function f
#in the variable x,y for some r.v. under some prob. distibution
#outputs the list [av,var, std. moms]
#####################################################################
ID2:=proc(e,x,y,k) local Mx,CPf,f1, f2, i, M, My, f:

f:=e/subs({x=1,y=1},e):

Mx:=subs({x=1,y=1},diff(f,x)):
My:=subs({x=1,y=1},diff(f,y)):
M:=[[Mx,My]]:

f:=f/(x^Mx*y^My):

f1:=x*diff(f,x):
f2:=y*diff(f,y):

for i from 2 to k do
f1:=x*diff(f1,x):
f2:=y*diff(f2,y):
M:=[op(M),[subs({x=1,y=1},f1),subs({x=1,y=1},f2)]]:
od:

M:

#[M[1],M[2],seq([M[i][1]/M[2][1]^(i/2),M[i][2]/M[2][2]^(i/2)],i=3..k)]:



end:


################################################################-very old stuffs
#Sidra(K,q,t): the polynomial of degree K^2 in q and K in t such the coefficient of q^n*t^k is the
#exact number of partitions of n whose size of Durfee square is k. Try:
#Sidra(5,q,t);
Sidra:=proc(K,q,t) local lu,k,j:
option remember:
lu:=add(q^(k^2)*t^k/mul(1-q^j,j=1..k)^2,k=1..K):
lu:=taylor(lu,q=0,K^2+1):
add(coeff(lu,q,j)*q^j,j=0..K^2):
end:


#PGFs(K,t): the list of polynomials of size K^2, whose i-th entry is the probability generating function
#for the random variable "size of Durfee sequare" defined on integer partitions of i. Try:
#PGFs(20,t);
PGFs:=proc(K,t) local lu,q,i:
lu:=Sidra(K,q,t):
[seq(sort(coeff(lu,q,i)/subs(t=1,coeff(lu,q,i))),i=1..K^2)]:
end:


#CGFs(K,t): the list of polynomials of size K^2, whose i-th entry is the combinatorial generating function
#for the random variable "size of Durfee sequare" defined on integer partitions of i. Try:
#CGFs(20,t);
CGFs:=proc(K,t) local lu,q,i:
lu:=Sidra(K,q,t):
[seq(sort(coeff(lu,q,i)),i=1..K^2)]:
end: