def find_dzdx_poly_root(
dzdx_poly_: Poly,
xhat_: float,
xivhat0_: float,
guess: float = 0.1,
eta_: Optional[Rational] = None,
method: str = "brentq",
bracket: Tuple[float, float] = (0, 1e3),
) -> Any:
"""
TODO.
Args:
TODO
"""
if eta_ is not None and eta_ == Rational(1, 4):
poly_eqn_ = dzdx_poly_.subs({xhat: xhat_, xivhat_0: xivhat0_})
poly_lambda: Callable = lambdify([dzdx], poly_eqn_.as_expr())
# return poly_eqn_
dpoly_lambda: Optional[Callable] = lambdify(
[dzdx],
diff(poly_eqn_.as_expr(), dzdx) if method == "newton" else None,
)
bracket_: Optional[Tuple[float, float]] = (bracket if method
== "brentq" else None)
for guess_ in [0, guess]:
root_search = root_scalar(
poly_lambda,
fprime=dpoly_lambda,
method=method,
bracket=bracket_,
x0=guess_,
)
if root_search.converged:
break
dzdx_poly_root: float = root_search.root
else:
dzdx_poly_roots = nroots(
dzdx_poly_.subs({
xhat: xhat_,
xivhat_0: xivhat0_
}))
dzdx_poly_root = [
root_ for root_ in dzdx_poly_roots
if Abs(im(root_)) < 1e-10 and re(root_) > 0
][0]
return dzdx_poly_root
def horiz_line_bz_quadratic():
x = Symbol('x')
y = Symbol('y')
t = Symbol('t')
P = sympify('v_xx*x**2 + v_xy*x*y + v_yy*y**2 + v_x*x + v_y*y + v_0')
X = sympify('x0')
P = Poly(P.subs(x, X), y)
print(P)
return P
def horiz_line_bz_line():
x = Symbol('x')
y = Symbol('y')
t = Symbol('t')
P = sympify('v_x*x + v_y*y + v_0')
X = sympify('x0')
P = Poly(P.subs(x, X), y)
print(P)
return P
def circle_bz_cubic():
x = Symbol('x')
y = Symbol('y')
t = Symbol('t')
P = sympify('(x-cx)**2 + (y-cy)**2 - r**2')
X = sympify('a3*t**3 + a2*t**2 + a1*t + a0')
Y = sympify('b3*t**3 + b2*t**2 + b1*t + b0')
P = Poly(P.subs(x, X).subs(y, Y), t)
print(P)
def circle_bz_line():
x = Symbol('x')
y = Symbol('y')
t = Symbol('t')
P = sympify('(x-cx)**2 + (y-cy)**2 - r**2')
X = sympify('a1*t + a0')
Y = sympify('b1*t + b0')
P = Poly(P.subs(x, X).subs(y, Y), t)
print(P)
def horiz_line_bz_line():
x = Symbol('x')
y = Symbol('y')
t = Symbol('t')
P = sympify('v_x*x + v_y*y + v_0')
Y = sympify('y0')
P = Poly(P.subs(y, Y), x)
print(P)
return P
def horiz_line_bz_cubic():
x = Symbol('x')
y = Symbol('y')
t = Symbol('t')
P = sympify(
'v_xxx*x**3 + v_xxy*x**2*y + v_xyy*x*y**2 + v_yyy*y**3 + v_xx*x**2 + v_xy*x*y + v_yy*y**2 + v_x*x + v_y*y + v_0'
)
Y = sympify('y0')
P = Poly(P.subs(y, Y), x)
print(P)
return P
def ratint_ratpart(f, g, x):
"""Horowitz-Ostrogradsky algorithm.
Given a field K and polynomials f and g in K[x], such that f and g
are coprime and deg(f) < deg(g), returns fractions A and B in K(x),
such that f/g = A' + B and B has square-free denominator.
"""
f, g = Poly(f, x), Poly(g, x)
u = poly_gcd(g, g.diff())
v = poly_div(g, u)[0]
n = u.degree - 1
m = v.degree - 1
d = g.degree
A_coeff = [ Symbol('a' + str(n-i), dummy=True) for i in xrange(0, n+1) ]
B_coeff = [ Symbol('b' + str(m-i), dummy=True) for i in xrange(0, m+1) ]
symbols = A_coeff + B_coeff
A = Poly(zip(A_coeff, xrange(n, -1, -1)), x)
B = Poly(zip(B_coeff, xrange(m, -1, -1)), x)
H = f - A.diff()*v + A*poly_div(u.diff()*v, u)[0] - B*u
result = solve(H.coeffs, symbols)
A = A.subs(result)
B = B.subs(result)
rat_part = Poly.cancel((A, u), x)
log_part = Poly.cancel((B, v), x)
return rat_part, log_part
def ratint_ratpart(f, g, x):
"""Horowitz-Ostrogradsky algorithm.
Given a field K and polynomials f and g in K[x], such that f and g
are coprime and deg(f) < deg(g), returns fractions A and B in K(x),
such that f/g = A' + B and B has square-free denominator.
"""
f, g = Poly(f, x), Poly(g, x)
u = poly_gcd(g, g.diff())
v = poly_div(g, u)[0]
n = u.degree - 1
m = v.degree - 1
d = g.degree
A_coeff = [ Symbol('a' + str(n-i), dummy=True) for i in xrange(0, n+1) ]
B_coeff = [ Symbol('b' + str(m-i), dummy=True) for i in xrange(0, m+1) ]
symbols = A_coeff + B_coeff
A = Poly(zip(A_coeff, xrange(n, -1, -1)), x)
B = Poly(zip(B_coeff, xrange(m, -1, -1)), x)
H = f - A.diff()*v + A*poly_div(u.diff()*v, u)[0] - B*u
result = solve(H.coeffs, symbols)
A = A.subs(result)
B = B.subs(result)
rat_part = Poly.cancel((A, u), x)
log_part = Poly.cancel((B, v), x)
return rat_part, log_part
def mean_cooperation(self):
expr = self.__get_replicator_rhs()
if expr == 0:
return 0.0
p = Poly(expr, domain='RR')
roots = sorted([float(r) for r in p.nroots(n=15, maxsteps=300) if r.is_real and r >= 0.00 and r <= 1.00])
roots = [0.0] + roots + [1.0]
coop = 0
p = Poly(x * (1 - x) * expr, domain='RR')
for i in range(1, len(roots)):
difference = roots[i] - roots[i - 1]
poly_val = p.subs(x, roots[i - i] + difference / 2)
coop += roots[i - 1] * difference if poly_val < 0 else roots[i] * difference
return coop
def test_subs():
p = Poly(t*x*y**2 + x*y + t**2, x, y)
assert p.subs(x, 2) == \
Poly(((2*t, 2, t**2), ((2,), (1,), (0,))), y)
assert p.subs(y, 2) == \
Poly(((2 + 4*t, t**2), ((1,), (0,))), x)
assert p.subs(x, y) == \
Poly(((t, 1, t**2), ((3,), (2,), (0,))), y)
assert p.subs(y, x) == \
Poly(((t, 1, t**2), ((3,), (2,), (0,))), x)
assert p.subs(x, z) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), z, y)
assert p.subs(y, z) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), x, z)
assert p.subs(t, z) == \
Poly(((z, 1, z**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(z, t) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(t, x) == \
Poly(((1, 1, 1), ((2, 2), (2, 0), (1, 1))), x, y)
assert p.subs(t, y) == \
Poly(((1, 1, 1), ((1, 3), (1, 1), (0, 2))), x, y)
assert p.subs(t, sin(1)) == \
Poly(((sin(1), 1, sin(1)**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(t, sin(x)) == \
x*y**2*sin(x) + x*y + sin(x)**2
assert p.subs(x, sin(x)) == \
t*y**2*sin(x) + y*sin(x) + t**2
def inversionCubicBezierForm():
x3 = Symbol('x3')
y3 = Symbol('y3')
x2 = Symbol('x2')
y2 = Symbol('y2')
x1 = Symbol('x1')
y1 = Symbol('y1')
x0 = Symbol('x0')
y0 = Symbol('y0')
xi = Symbol('xi')
yi = Symbol('yi')
xj = Symbol('xj')
yj = Symbol('yj')
x = Symbol('x')
y = Symbol('y')
t = Symbol('t')
def lij():
M = Matrix([[x, y, 1], [xi, yi, 1], [xj, yj, 1]])
D = det(M)
return Poly(D)
def bin3(i, j):
return binomial(3, i) * binomial(3, j)
ps = [[0.5, 0.25], [1, 1], [2, -1], [3, 0]]
P32 = bin3(3, 2) * lij()
l32 = Poly(P32.subs(xi, x3).subs(xj, x2).subs(yi, y3).subs(yj, y2), x, y)
l32_ = l32.subs(x3,
ps[3][0]).subs(x2,
ps[2][0]).subs(y3,
ps[3][1]).subs(y2, ps[2][1])
P31 = bin3(3, 1) * lij()
l31 = Poly(P31.subs(xi, x3).subs(xj, x1).subs(yi, y3).subs(yj, y1), x, y)
l31_ = l31.subs(x3,
ps[3][0]).subs(x1,
ps[1][0]).subs(y3,
ps[3][1]).subs(y1, ps[1][1])
P30 = bin3(3, 0) * lij()
l30 = Poly(P30.subs(xi, x3).subs(xj, x0).subs(yi, y3).subs(yj, y0), x, y)
l30_ = l30.subs(x3,
ps[3][0]).subs(x0,
ps[0][0]).subs(y3,
ps[3][1]).subs(y0, ps[0][1])
P21 = bin3(2, 1) * lij()
l21 = Poly(P21.subs(xi, x2).subs(xj, x1).subs(yi, y2).subs(yj, y1), x, y)
l21_ = l21.subs(x2,
ps[2][0]).subs(x1,
ps[1][0]).subs(y2,
ps[2][1]).subs(y1, ps[1][1])
P20 = bin3(2, 0) * lij()
l20 = Poly(P20.subs(xi, x2).subs(xj, x0).subs(yi, y2).subs(yj, y0), x, y)
l20_ = l20.subs(x2,
ps[2][0]).subs(x0,
ps[0][0]).subs(y2,
ps[2][1]).subs(y0, ps[0][1])
P10 = bin3(1, 0) * lij()
l10 = Poly(P10.subs(xi, x1).subs(xj, x0).subs(yi, y1).subs(yj, y0), x, y)
l10_ = l10.subs(x1,
ps[1][0]).subs(x0,
ps[0][0]).subs(y1,
ps[1][1]).subs(y0, ps[0][1])
M = Matrix([[l32, l31, l30], [l31, l30 + l21, l20], [l30, l20, l10]])
M_ = Matrix([[l32_, l31_, l30_], [l31_, l30_ + l21_, l20_],
[l30_, l20_, l10_]])
T2 = sympify('t**2')
T1 = sympify('t*(1-t)')
T0 = sympify('(1-t)**2')
T = Matrix([[T2], [T1], [T0]])
INV1_ = expand(M_[0] * T2 + M_[1] * T1 + M_[2] * T0)
INV2_ = expand(M_[3] * T2 + M_[4] * T1 + M_[5] * T0)
INV3_ = expand(M_[6] * T2 + M_[7] * T1 + M_[8] * T0)
INV1 = Poly(expand(M[0] * T2 + M[1] * T1 + M[2] * T0), t)
INV2 = Poly(expand(M[3] * T2 + M[4] * T1 + M[5] * T0), t)
INV3 = Poly(expand(M[6] * T2 + M[7] * T1 + M[8] * T0), t)
p = [3, 0]
Pt1 = INV1_.subs(x, p[0]).subs(y, p[1])
Pt2 = INV2_.subs(x, p[0]).subs(y, p[1])
Pt3 = INV3_.subs(x, p[0]).subs(y, p[1])
t1 = solve(Pt1)
t2 = solve(Pt2)
t3 = solve(Pt3)
print('INV1', INV1)
print()
print('INV2', INV2)
print()
print('INV3', INV3)
print()
print('Pt1: ', Pt1)
print('Pt2: ', Pt2)
print('Pt3: ', Pt3)
print('t1: ', t1)
print('t2: ', t2)
print('t3: ', t3)
a = Symbol('a')
symbols = []
for symbol in polynom.free_symbols:
symbols.append(str(symbol))
symbols.sort()
replace_symbols = {}
j = 0
for symbol in symbols:
replace_symbols[symbol] = a**(d**j)
j += 1
for symbol in replace_symbols:
polynom = polynom.subs(symbol, replace_symbols[symbol])
p_new = (polynom._sorted_args)[0]._sorted_args
f = 0
for i in range(len(p_new) - 1, -1, -1):
if i == 0 and str(p_new[i]).find('a') == -1:
f += int(p_new[i])
else:
f += Poly(str(p_new[i]))
p_coef = f.all_coeffs()
for i in range(len(p_coef)):
p_coef[i] = int(p_coef[i])
kronecker(p_coef)
ans.sort(key=len)
def test_subs():
p = Poly(t*x*y**2 + x*y + t**2, x, y)
assert p.subs(x, 2) == \
Poly(((2*t, 2, t**2), ((2,), (1,), (0,))), y)
assert p.subs(y, 2) == \
Poly(((2 + 4*t, t**2), ((1,), (0,))), x)
assert p.subs(x, y) == \
Poly(((t, 1, t**2), ((3,), (2,), (0,))), y)
assert p.subs(y, x) == \
Poly(((t, 1, t**2), ((3,), (2,), (0,))), x)
assert p.subs(x, z) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), z, y)
assert p.subs(y, z) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), x, z)
assert p.subs(t, z) == \
Poly(((z, 1, z**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(z, t) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(t, x) == \
Poly(((1, 1, 1), ((2, 2), (2, 0), (1, 1))), x, y)
assert p.subs(t, y) == \
Poly(((1, 1, 1), ((1, 3), (1, 1), (0, 2))), x, y)
assert p.subs(t, sin(1)) == \
Poly(((sin(1), 1, sin(1)**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(t, sin(x)) == \
x*y**2*sin(x) + x*y + sin(x)**2
assert p.subs(x, sin(x)) == \
t*y**2*sin(x) + y*sin(x) + t**2
coeffs = [ Symbol('a' + str(i)) for i in [3,2,1,0] ]
values = [ 4, 0, 0, 1 ]
f = Poly(zip(coeffs, [3,2,1,0]), x)
assert f.subs(dict(zip(coeffs, values))) == Poly(4*x**3+1, x)
R = -R if R.degree() % 2 else R
return resultant(G, R, res)
anss = 1
for gs in g_zeros:
anss *= f_pol.eval(x, -gs)
anss = 1
for fs in f_zeros:
anss *= g_pol.eval(x, -fs)
# 나눠:
_, r_pol = reduction(f_pol, Poly(g_pol.subs(x, -x), x))
anss = 1
print(r_pol)
for gs in g_zeros:
anss *= r_pol.eval(-gs)
print(anss)
f, g, res = resultant(f_pol, g_pol, 1)
'''
f = invs(f.coeffs()[0])*f
f = Poly(f + pp, x, modulus = p)
g = invs(g.coeffs()[0])*g
g = Poly(g + pp, x, modulus = p)
'''
print(f, g, res)
def test_subs():
p = Poly(t*x*y**2 + x*y + t**2, x, y)
assert p.subs(x, 2) == \
Poly(((2*t, 2, t**2), ((2,), (1,), (0,))), y)
assert p.subs(y, 2) == \
Poly(((2 + 4*t, t**2), ((1,), (0,))), x)
assert p.subs(x, y) == \
Poly(((t, 1, t**2), ((3,), (2,), (0,))), y)
assert p.subs(y, x) == \
Poly(((t, 1, t**2), ((3,), (2,), (0,))), x)
assert p.subs(x, z) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), z, y)
assert p.subs(y, z) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), x, z)
assert p.subs(t, z) == \
Poly(((z, 1, z**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(z, t) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(t, x) == \
Poly(((1, 1, 1), ((2, 2), (2, 0), (1, 1))), x, y)
assert p.subs(t, y) == \
Poly(((1, 1, 1), ((1, 3), (1, 1), (0, 2))), x, y)
assert p.subs(t, sin(1)) == \
Poly(((sin(1), 1, sin(1)**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(t, sin(x)) == \
x*y**2*sin(x) + x*y + sin(x)**2
assert p.subs(x, sin(x)) == \
t*y**2*sin(x) + y*sin(x) + t**2
coeffs = [ Symbol('a' + str(i)) for i in [3,2,1,0] ]
values = [ 4, 0, 0, 1 ]
f = Poly(zip(coeffs, [3,2,1,0]), x)
assert f.subs(dict(zip(coeffs, values))) == Poly(4*x**3+1, x)
def test_subs():
p = Poly(t * x * y**2 + x * y + t**2, x, y)
assert p.subs(x, 2) == \
Poly(((2*t, 2, t**2), ((2,), (1,), (0,))), y)
assert p.subs(y, 2) == \
Poly(((2 + 4*t, t**2), ((1,), (0,))), x)
assert p.subs(x, y) == \
Poly(((t, 1, t**2), ((3,), (2,), (0,))), y)
assert p.subs(y, x) == \
Poly(((t, 1, t**2), ((3,), (2,), (0,))), x)
assert p.subs(x, z) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), z, y)
assert p.subs(y, z) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), x, z)
assert p.subs(t, z) == \
Poly(((z, 1, z**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(z, t) == \
Poly(((t, 1, t**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(t, x) == \
Poly(((1, 1, 1), ((2, 2), (2, 0), (1, 1))), x, y)
assert p.subs(t, y) == \
Poly(((1, 1, 1), ((1, 3), (1, 1), (0, 2))), x, y)
assert p.subs(t, sin(1)) == \
Poly(((sin(1), 1, sin(1)**2), ((1, 2), (1, 1), (0, 0))), x, y)
assert p.subs(t, sin(x)) == \
x*y**2*sin(x) + x*y + sin(x)**2
assert p.subs(x, sin(x)) == \
t*y**2*sin(x) + y*sin(x) + t**2
def inversionQuadraticBezierForm():
x2 = Symbol('x2')
y2 = Symbol('y2')
x1 = Symbol('x1')
y1 = Symbol('y1')
x0 = Symbol('x0')
y0 = Symbol('y0')
xi = Symbol('xi')
yi = Symbol('yi')
xj = Symbol('xj')
yj = Symbol('yj')
x = Symbol('x')
y = Symbol('y')
t = Symbol('t')
def lij():
M = Matrix([[x, y, 1], [xi, yi, 1], [xj, yj, 1]])
D = det(M)
return Poly(D)
def bin2(i, j):
return binomial(2, i) * binomial(2, j)
ps = [[0, -0.5], [0.25, 3], [2, -1]]
P21 = bin2(2, 1) * lij()
l21 = Poly(P21.subs(xi, x2).subs(xj, x1).subs(yi, y2).subs(yj, y1), x, y)
l21_ = l21.subs(x2,
ps[2][0]).subs(x1,
ps[1][0]).subs(y2,
ps[2][1]).subs(y1, ps[1][1])
P20 = bin2(2, 0) * lij()
l20 = Poly(P20.subs(xi, x2).subs(xj, x0).subs(yi, y2).subs(yj, y0), x, y)
l20_ = l20.subs(x2,
ps[2][0]).subs(x0,
ps[0][0]).subs(y2,
ps[2][1]).subs(y0, ps[0][1])
P10 = bin2(1, 0) * lij()
l10 = Poly(P10.subs(xi, x1).subs(xj, x0).subs(yi, y1).subs(yj, y0), x, y)
l10_ = l10.subs(x1,
ps[1][0]).subs(x0,
ps[0][0]).subs(y1,
ps[1][1]).subs(y0, ps[0][1])
M = Matrix([[l21, l20], [l20, l10]])
M_ = Matrix([[l21_, l20_], [l20_, l10_]])
T1 = sympify('t')
T0 = sympify('(1-t)')
T = Matrix([[T1], [T0]])
INV1_ = expand(M_[0] * T1 + M_[1] * T0)
INV2_ = expand(M_[2] * T1 + M_[3] * T0)
INV1 = Poly(expand(M[0] * T1 + M[1] * T0), t)
INV2 = Poly(expand(M[2] * T1 + M[3] * T0), t)
p = [2, -1]
Pt1 = INV1_.subs(x, p[0]).subs(y, p[1])
Pt2 = INV2_.subs(x, p[0]).subs(y, p[1])
t1 = solve(Pt1)
t2 = solve(Pt2)
print('INV1', INV1)
print()
print('INV2', INV2)
print()
print('Pt1: ', Pt1)
print('Pt2: ', Pt2)
print('t1: ', t1)
print('t2: ', t2)
list_grados.append(grado)
if np.sum(list_grados) <= order:
f_4 = f_4 + monos * coef1_2[k]
k = k + 1
return f_4
#%%
order = 4
K_x, coef = K_var_no_central([y, a], order)
eq1 = Poly(xpunto, x, y).subs(x, K_x)
eq1_filtrada = filtro_f(eq1, [x, y, a], order)
eq2 = Poly(diff(K_x, y) * ypunto, x, y, a)
eq2 = eq2.subs(x, K_x)
eq2_filtrada = filtro_f(eq2, [x, y, a], order)
eq_final = Poly(eq1_filtrada - eq2_filtrada, x, y, a)
eq_final_info = eq_final.as_expr().as_coefficients_dict()
monomios = eq_final_info.keys()
monomios2 = []
for monos in monomios:
monomios2.append(monos)
list_res = {}
for j in range(len(monomios2)):
monos = monomios2[j]
for k in range(len(coef)):
coeff = coef[k]
res = solve(monos, coeff)
