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()