def __init__(self,b=sqrt(2),fixpoint_number=0,u=None,prec=53,iprec=None,N=5,direction=-1,debug=0):
"""
for the numbering of fixed points see function exp_fixpoint
u is the initial value such that slog(u)=0 and sexp(0)=u
for the attracting fixed point it defaults to u=1
otherwise it is undetermined
direction can be +1 (real values when approaching from the right of the fixpoint)
or -1 (real values when approaching from the left of the fixed point)
"""
if debug >= 1:
if b==sqrt(2): print 'b:',b
if fixpoint_number==0: print 'fixpoint_number:',fixpoint_number
if prec==53: print 'prec:',prec
if N==5: print 'N:',N
if direction==-1: print 'direction:',direction
bsym = b
self.bsym = bsym
self.N = N
if iprec==None:
iprec=prec+10
if debug>=1: print 'iprec:',iprec
self.iprec = iprec
self.prec = prec
self.fixpoint_number = fixpoint_number
eta = e**(1/e)
bname = repr(bsym).strip('0').replace('.',',')
if bsym == sqrt(2):
bname = "sqrt2"
if bsym == eta:
bname = "eta"
self.lnb = num(ln(bsym),iprec)
b = num(bsym,iprec)
self.b = b
self.path = "savings/islog_%s"%bname + "_N%04d"%N + "_iprec%05d"%iprec + "_fp%d"%fixpoint_number
if iprec != None:
b = num(b,iprec)
self.b = b
else:
if b == e and x0 == 0:
R = QQ
else:
R = SR
self.attracting = False
if b < eta and fixpoint_number == 0:
self.attracting = True
self.real_fp = False
if b <= eta and abs(fixpoint_number) <= 1:
self.real_fp = True
self.parabolic = False
if self.bsym == eta and abs(fixpoint_number) <= 1:
self.parabolic = True
if direction == +1:
self.attracting = False
if direction == -1:
self.attracting = True
if b <= eta and abs(fixpoint_number) <= 1:
R = RealField(iprec)
else:
R = ComplexField(iprec)
self.R = R
if self.parabolic:
fp = R(e) #just for not messing it into a complex number
else:
fp = exp_fixpoint(b,fixpoint_number,prec=iprec)
self.fp = fp #fixpoint
self.fpd = self.log(fp) #fixpont derivative
self.direction = direction
FR = FormalPowerSeriesRing(R)
fps = FR.Dec_exp(FR([0,b.log()])).rmul(fp)
if self.parabolic:
fps=fps.set_item(1,1).reclass()
if debug>=1: print "fp:",fp
[rho,ps] = fps.abel_coeffs()
if debug>=2: print 'fps:',fps
if debug>=2: print 'rho:',rho
if debug>=2: print 'abel_ps:',ps
self.chi_ps = fps.schroeder()
self.chipoly = self.chi_ps.polynomial(N+1)
self.chi_raw0 = lambda z: self.chipoly(direction*(z-self.fp))
PR = PolynomialRing(R,'x')
self.slogpoly = ps.polynomial(N)
if debug>=2: print self.slogpoly
self.slog_raw0 = lambda z: rho*(direction*(z-self.fp)).log() + self.slogpoly(z-self.fp)
#slog(u)==0
self.c = 0
if self.attracting and direction==-1 and u==None:
u=1
if debug>=1: print 'u:',u
if not u==None:
self.c = -self.slog(u)
pass
def __init__(self,b,N,iprec=512,u=None,x0=0):
"""
x0 is the development point for the Carleman matrix for the slog
u is the initial value such that slog(u)=0 or equivalently sexp(0)=u
if no u is specified we have slog(x0)=0
"""
bsym = b
self.bsym = bsym
self.N = N
self.iprec = iprec
x0sym = x0
self.x0sym = x0sym
self.prec = None
bname = repr(bsym).strip('0').replace('.',',')
if bsym == sqrt(2):
bname = "sqrt2"
if bsym == e**(1/e):
bname = "eta"
x0name = repr(x0sym)
if x0name.find('.') > -1:
if x0.is_real():
x0name = repr(float(x0sym)).strip('0').replace('.',',')
else:
x0name = repr(complex(x0sym)).strip('0').replace('.',',')
# by some reason save does not work with additional . inside the path
self.path = "savings/itet_%s"%bname + "_N%04d"%N + "_iprec%05d"%iprec + "_a%s"%x0name
if iprec != None:
b = num(bsym,iprec)
self.b = b
x0 = num(x0sym,iprec)
if x0.is_real():
R = RealField(iprec)
else:
R = ComplexField(iprec)
self.x0 = x0
else:
if b == e and x0 == 0:
R = QQ
else:
R = SR
self.R = R
#Carleman matrix
if x0 == 0:
#C = Matrix([[ m**n*log(b)**n/factorial(n) for n in range(N)] for m in range(N)])
coeffs = [ln(b)**n/factorial(n) for n in xrange(N)]
else:
#too slow
#C = Matrix([ [ln(b)**n/factorial(n)*sum([binomial(m,k)*k**n*(b**x0)**k*(-x0)**(m-k) for k in range(m+1)]) for n in range(N)] for m in range(N)])
coeffs = [b**x0-x0]+[b**x0*ln(b)**n/factorial(n) for n in xrange(1,N)]
def psmul(A,B):
N = len(B)
return [sum([A[k]*B[n-k] for k in xrange(n+1)]) for n in xrange(N)]
C = Matrix(R,N)
row = vector(R,[1]+(N-1)*[0])
C[0] = row
for m in xrange(1,N):
row = psmul(row,coeffs)
C[m] = row
A = (C - identity_matrix(N)).submatrix(1,0,N-1,N-1)
self.A = A
print "A computed."
if iprec != None:
A = num(A,iprec)
row = A.solve_left(vector([1] + (N-2)*[0]))
print "A solved."
self.slog0coeffs = [0]+[row[n] for n in range(N-1)]
self.slog0poly = PolynomialRing(R,'x')(self.slog0coeffs[:int(N)/2])
slog0ps = FormalPowerSeriesRing(R)(self.slog0coeffs)
sexp0ps = slog0ps.inv()
#print self.slog0ps | self.sexp0ps
self.sexp0coeffs = sexp0ps[:N]
self.sexp0poly = PolynomialRing(R,'x')(self.sexp0coeffs[:int(N)/2])
self.slog_raw0 = lambda z: self.slog0poly(z-self.x0)
print "slog reversed."
#the primary or the upper fixed point
pfp = exp_fixpoint(b,1,prec=iprec)
self.pfp = pfp
r = abs(x0-pfp)
#lower fixed point
lfp = None
if b <= R(e**(1/e)):
lfp = exp_fixpoint(b,0,prec=iprec)
r = min(r,abs(x0-lfp))
self.lfp = lfp
self.r = r
self.c = 0
if not u == None:
self.c = - self.slog(u)
