def myRedGroeb(f, t, gen, dom):
#HAVING GROEBNER BASIS
g = myGroebner(f, t=t, gen=gen, dom=dom)
#HAVING MONIC GROEBNER BASIS
for i in range(len(g)):
g[i] = sym.monic(g[i])
#MAKING LIST OF LT(g):
lstLT = []
for i in range(len(g)):
lstLT.append(Poly(LT(g[i], order=t), gen, domain=dom))
#CHANGING THE NON REDUCED BASIS INTO ZERO
h = g.copy()
for i in range(len(g)):
while h[i] != 0:
denum = lstLT[0:i] + lstLT[i + 1:]
rem = myDiv(denum,
Poly(LT(h[i], order=t), gen, domain=dom),
t=t,
gen=gen,
dom=dom)[1]
if rem == 0:
g[i] = 0
break
else:
h[i] = h[i] - LT(h[i], order=t)
#REMOVING THE ZERO BASIS
g = list(filter(lambda a: a != 0, g))
print(f"Reduced Groebner = {g}")
return g
def GPD_meth(poly, var, div, myorder):
x, y = symbols('x y')
zero = symbols('0')
dlen = len(div) # num of dividents
q = []
NotDivide = False
divoccur = True
for k in range(0, len(div)): # init list of quos
q.append(zero)
###############################################
for i in range(0, len(div)):
#print("iteration",i)
if poly == 0:
break
if NotDivide == True:
NotDivide = False
while NotDivide == False:
LTP = LT(poly, var, order=myorder) # check if LTD divides LTP
LTD = LT(div[i], var, order=myorder)
#print("check3")
if quo(LTP, LTD) != 0 and rem(LTP, LTD) == 0:
#print("leading tems divisor/divident0:",LTP,LTD)
divLT = simplify(LTP / LTD) #works thatsgood
#print(divLT)
##########check changes in quo rem################
if q[i] == zero: # if quo is initialized
q[i] = simplify(divLT)
else:
q[i] = simplify(q[i] + divLT)
poly = simplify(poly - simplify(divLT * div[i]))
#print("check0",poly)
#print("new poly,new quo",poly,q[i])
##################################################
else:
NotDivide = True
break
return poly, q # final results
def leading_term(expr, *args):
"""
Returns the leading term in a sympy Polynomial.
expr: sympy.Expr
any sympy expression
args: list
list of input symbols for univariate/multivariate polynomials
"""
expr = sympify(str(expr))
P = Poly(expr, *args)
return LT(P)
def t_min_degree(expr, max_deg, large_number=1000):
"""
Takes an expression f(x,y) and computes the Taylor expansion
in x and y up to bi-degree fixed by max_deg. Then, picks the term
of lowest bi-degree.
For example:
x / (1 - y)
with value of max_deg = 3 will give
t * x + t**2 * x * y
up to bi-degree 2. Will return x.
"""
f = expr.subs([(x, x / t), (y, y / t)])
f_t_series = t**large_number * series(f, t, 0, max_deg).removeO()
leading_term = LT(f_t_series.expand(), t).subs(t, 1)
return leading_term
def myDiv(lst, f, t, gen, dom):
a = [0] * len(lst)
r = 0
p = f
while p != 0:
i = 0
divisionoccured = False
while i < len(lst) and divisionoccured == False:
if sym.div(Poly(LT(p, order=t), gen, domain=dom),
Poly(LT(lst[i], order=t), gen, domain=dom))[1] == 0:
a[i] = a[i] + sym.div(
Poly(LT(p, order=t), gen, domain=dom),
Poly(LT(lst[i], order=t), gen, domain=dom))[0]
p = p - sym.div(Poly(LT(p, order=t), gen, domain=dom),
Poly(LT(lst[i], order=t), gen,
domain=dom))[0] * lst[i]
divisionoccured = True
else:
i = i + 1
if divisionoccured == False:
r = r + LT(p, order=t)
p = p - LT(p, order=t)
return a, r
def calS(f, g, t):
x_gamma = lcm(LM(f, order=t), LM(g, order=t))
S = x_gamma / LT(f, order=t) * f - x_gamma / LT(g, order=t) * g
return S
def s_polynomial(f, g):
return expand(lcm(LM(f), LM(g)) * (1 / LT(f) * f - 1 / LT(g) * g))
def red(F, x):
p = F - LT(F, x)
return p
#a numpy array
floquetobj = StringIO(str(floquetFetch).strip('[ ]'))
floquet = np.loadtxt(floquetobj)
TopLength = len(str(itinerary))
#if str(itinerary)=='001':
#continue
Zeta0 = Zeta0 * (1 -
(sympy.exp(-s * T) * z**TopLength) / np.abs(floquet[0]))
conn.close()
from sympy import degree, LT
#Zeta0 = sympy.expand(Zeta0)
#Zeta00 = []
#ExpOrder = 4
raw_input("fdasfdsafdsa")
for j in range(ExpOrder, 0, -1):
while degree(Zeta00) > j:
Zeta0 = Zeta0 - LT(Zeta0)
if degree(Zeta0) <= ExpOrder:
Zeta00.insert(0, (np.float(Zeta00.subs(z, 1))))
#print Zeta00
#print Zeta00.subs(z, 1)
print Zeta00Val
plot(range(1, ExpOrder + 1), Zeta00Val)
plt.show()