import math

import calc

def fact(x):
result=1
while x>=1:
result=result*x
x=x-1
return result

def binom(total,slots):
if slots<0 or slots>total:
return 0
# return fact(total*1.0)/\
# (fact(slots*1.0)*\
# fact(total-slots))
nom=1
for k in range(0,slots):
nom*=total-k
denom=fact(slots)
return nom/denom

def binomPDF(totaltrials,successcnt,probofsuccess):
probofsuccnt=math.pow(probofsuccess,successcnt)
proboffailcnt=math.pow((1-probofsuccess),(totaltrials-successcnt))
binomco=binom(totaltrials,successcnt)
return binomco*probofsuccnt*proboffailcnt

def binommoreCDF(totaltrials,successcnt,probofsuccess):
result=0
while successcnt<=totaltrials:
result+=binomPDF(totaltrials,successcnt,probofsuccess)
successcnt+=1
return result

def binomlessCDF(totaltrials,successcnt,probofsuccess):
result=0
for sc in range(0,successcnt):
result+=binomPDF(totaltrials,sc,probofsuccess)
return result

def normalPDF(x,mean=0,deviat=1):
return (1/(deviat*math.sqrt(2*math.pi)))*\
math.exp(-(math.pow(x-mean,2)/(2*math.pow(deviat,2))))

def normalCDF(low,high,mean=0,deviat=1):
def f(x):
return normalPDF(x,mean,deviat)
ff=calc.I(f)
return ff(high,low)

def poisPDF(x,lamb):
return math.exp(-lamb)*(lamb**x)/fact(x)

def poisCDF(low,high,lamb):
sum=0
for k in range(low,high+1):
sum+=poisPDF(k,lamb)
 return sum

def gamma(alpha):
xmax=alpha*100
if alpha==int(alpha):
return fact(alpha-1)
def f(x):
return (x**(alpha-1))*math.exp(-x)
ff=calc.I(f)
return ff(xmax,0)

def gammalin(alpha):
al=alpha-1
ali=int(al)
alf=fact(ali)
if ali==al:
return alf
al1=fact(alpha)
rem=al-ali
rise=rem*(al1-alf)
return alf+rise

#http://en.wikipedia.org/wiki/Lanczos_approximation
#slightly modified
def lanczos(z):
# z = complex(z)
# Coefficients used by the GNU Scientific Library
g = 7
p = [0.99999999999980993, 676.5203681218851, -1259.1392167224028,
771.32342877765313, -176.61502916214059, 12.507343278686905,
-0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7]
# Reflection formula
#if z.real < 0.5:
if z < 0.5:
return math.pi / (math.sin(math.pi*z)*lanczos(1-z))
else:
z -= 1
x = p[0]
for i in range(1, g+2):
x += p[i]/(z+i)
t = z + g + 0.5
return math.sqrt(2*math.pi) * t**(z+0.5) * math.exp(-t) * x

def gammaPDF(x,shape,rate=.5):
# return ((rate**shape)/float(gamma(shape)))*\
return ((rate**shape)/float(lanczos(shape)))*\
(x**(shape-1))*\
math.exp(-rate*x)

def gammaCDF(low,high,shape,rate=.5):
def f(x):
return gammaPDF(x,shape,rate)
ff=calc.I(f)
return ff(high,low)

def chiPDF(chisq,df):
return gammaPDF(chisq,df/2.)
def chilessCDF(chisq,df):
return gammaCDF(10**-8,chisq,df/2.)

def chimoreCDF(chisq,df):
if df/2.>1:
return 1-gammaCDF(10**-8,chisq,df/2.)
return gammaCDF(chisq,df*100,df/2.)

def expect(x,y,z):
return (x*y)/(1.0*z)

def chisqterm(x,y):
return math.pow((x-y),2)/(y*1.0)

def addrow(arr):
res=0
for val in arr:
res+=val
return res

def addcol(arr,i):
res=0
for row in arr:
res+=row[i]
return res

def rowtots(arr):
res=[]
for row in arr:
res.append(addrow(row))
return res

def coltots(arr):
res=[]
for index in range(len(arr[0])):
res.append(addcol(arr,index))
return res

def info(arr):
res=0
total=0
for numb in arr:
total+=numb
for numb in arr:
if numb!=0:
res=res-((numb*1.0/total)*math.log((numb*1.0/total),2))
return res

class chi:
def __init__(self,tab):
self.tab=tab
self.rowcnt=len(tab)
self.colcnt=len(tab[0])
self.rowtots=rowtots(tab)
self.coltots=coltots(tab)
self.tot=addrow(self.rowtots)
self.val=self.getval()
self.df=(self.rowcnt-1)*(self.colcnt-1)
 self.prob=chimoreCDF(self.val,self.df)

def cellexp(self,x,y):
return expect(self.rowtots[y],self.coltots[x],self.tot)

def getval(self):
val=0
for rowind in range(len(self.tab)):
for colind in range(len(self.tab[rowind])):
exp=self.cellexp(colind,rowind)
if exp!=0:
val+=chisqterm(self.tab[rowind][colind],exp)
return val