def plot(self, U, V, ctr):
X1 = arange(min(U) - 2, max(U) + 2, 0.1)
x = [1]
for i in range(len(U)):
x = P.polymul(x, [-1 * U[i], 1])
plt.axis([-10, 10, min(V) - 1, max(V) + 1])
b = [0]
for i in range(len(U)):
a = P.polydiv(x, [-1 * U[i], 1])
b = P.polyadd(
P.polymul((P.polydiv(a[0], P.polyval(U[i], a[0])))[0], [V[i]]),
b)
Y = P.polyval(
X1,
P.polymul((P.polydiv(a[0], P.polyval(U[i], a[0])))[0], [V[i]]))
plt.plot(X1, Y, 'y')
plt.plot(U, V, 'ro')
X1 = arange(-5, 5, 0.1)
Y = P.polyval(X1, b)
plt.plot(X1, Y, 'b', label='Required Polynomial')
plt.plot((-8, 8), (0, 0), 'k')
plt.grid(b=True, which='both', color='0.65', linestyle='-')
Y = list(Y)
plt.plot((0, 0), (-max(Y) - 5, max(Y) + 5), 'k')
plt.xlabel('x-axis')
plt.ylabel('y-axis')
plt.legend(loc=1)
filename = "this_plot" + str(ctr) + ".png"
path = "C:\\Users\HP\Anaconda3\static"
fullpath = os.path.join(path, filename)
plt.savefig(fullpath)
def chuck(samplerate, sig, shift_hz=1000):
rc_imag = [
allpass(samplerate, rc)
for rc in [5.49e-06, 4.75e-05, 2.37e-04, 1.27e-03]
]
rc_real = [
allpass(samplerate, rc)
for rc in [2.00e-05, 1.07e-04, 5.36e-04, 4.64e-03]
]
sos_imag = [
signal.tf2sos(
polynomial.polymul(rc1[0], rc2[0]),
polynomial.polymul(rc1[1], rc2[1]),
)[0] for rc1, rc2 in zip(rc_imag[::2], rc_imag[1::2])
]
sos_real = [
signal.tf2sos(
polynomial.polymul(rc1[0], rc2[0]),
polynomial.polymul(rc1[1], rc2[1]),
)[0] for rc1, rc2 in zip(rc_real[::2], rc_real[1::2])
]
# plot_response(sys._getframe().f_code.co_name, sos_real, sos_imag)
real = signal.sosfilt(sos_real, sig)
imag = signal.sosfilt(sos_imag, sig)
analytic = 0.5 * (real - 1j * imag)
return pitch_shift(samplerate, analytic, shift_hz)
def getEpsrNumDen(Mat_pol, N_true_poles):
## create num and den
list_num, list_den = [], []
for k in range(2 * N_true_poles):
list_num.append((Mat_pol[1, k]))
list_den.append((-Mat_pol[2, k], 1.))
den = (1)
for k in range(2 * N_true_poles):
den = poly.polymul(den, list_den[k])
inter = []
pinter = (1)
for k1 in range(2 * N_true_poles):
pinter = list_num[k1]
for k2 in range(2 * N_true_poles):
if (k1 != k2):
pinter = poly.polymul(pinter, list_den[k2])
inter.append(pinter)
num = inter[0]
for k in range(1, 2 * N_true_poles):
num = poly.polyadd(num, inter[k])
for k in range(len(num)):
num[k] /= (1j)**k
for k in range(len(den)):
den[k] /= (1j)**k
num, den = num.real, den.real
# np.savetxt('text_num.out', num, delimiter=',')
# np.savetxt('text_den.out', den, delimiter=',')
num = poly.polyadd(num, den)
w2 = (0., 0., -1.)
num2 = poly.polymul(w2, num)
# print_w2_chi(num2,den)
# dnum2, dden = get_der_rational(num2,den)
return (num, den, num2)
def get_extended_cycle(p, n, extender):
newp = p**n - 1
a = [0, 1]
curr = [0, 1]
alphas = {0: [1], 1: a}
for x in range(2, n):
curr = pol.polymul(curr, a)
alphas[x] = list(map(int, curr))
curr = list(map(lambda x: -x % p, extender[:-1]))
curr = trim(curr)
alphas[n] = curr
for x in range(n + 1, newp):
curr = pol.polymul(curr, a)
while (len(curr) > n):
nam = int(curr[-1] % p)
curr = list(
map(
lambda x: int(x) % p,
pol.polyadd(
list(map(lambda x: x * nam, alphas[len(curr) - 1])),
curr[:-1])))
curr = list(map(lambda x: int(x) % p, curr))
alphas[x] = list(map(int, curr))
return (alphas)
def plot(self,U,V,ctr):
X1=arange(min(U)-2,max(U)+2,0.1)
x=[1]
for i in range(len(U)):
x=P.polymul(x,[-1*U[i],1])
plt.axis([-10,10,min(V)-1,max(V)+1])
b=[0]
for i in range(len(U)):
a=P.polydiv(x,[-1*U[i],1])
b=P.polyadd(P.polymul((P.polydiv(a[0],P.polyval(U[i],a[0])))[0],[V[i]]),b)
Y=P.polyval(X1,P.polymul((P.polydiv(a[0],P.polyval(U[i],a[0])))[0],[V[i]]))
plt.plot(X1,Y,'y')
plt.plot(U,V,'ro')
X1=arange(-5,5,0.1)
Y=P.polyval(X1,b)
plt.plot(X1,Y,'b',label='Required Polynomial')
plt.plot((-8,8),(0,0),'k')
plt.grid(b=True, which='both', color='0.65',linestyle='-')
Y=list(Y)
plt.plot((0,0),(-max(Y)-5,max(Y)+5),'k')
plt.xlabel('x-axis')
plt.ylabel('y-axis')
plt.legend(loc=1)
filename = "this_plot"+str(ctr)+".png"
path = "C:\\Users\HP\Anaconda3\static"
fullpath = os.path.join(path, filename)
plt.savefig(fullpath)
def get_der_rational(num, den):
dnum = poly.polyder(num)
dden = poly.polyder(den)
dnum_den = poly.polymul(dnum, den)
dden_num = poly.polymul(num, dden)
num_new = poly.polysub(dnum_den, dden_num)
den_new = poly.polymul(den, den)
return (num_new, den_new)
def gram_schmidt(A):
n = A.shape[1] # numero de vectores columna
for j in range(n):
for k in range(j):
#A[:, j] -= np.dot(A[:, k], A[:, j]) * A[:, k]
A[:, j] -= quad(P.polymul(A[:, k], A[:, j]), -1, 1) * A[:, k]
A[:, j] = A[:, j] / quad(P.polymul(A[:, j], A[:, j]), -1, 1)
return A
def test_coeff_convert():
"""Test the function convertion from factored coeffs to end coeffs."""
assert np.allclose(fcoeffs2coeffs(np.array([1.0, 2, 1, 1])),
P.polymul([1, 1, 2], [1, 1]))
assert np.allclose(fcoeffs2coeffs(np.array([1.0, 2, 1.2])),
P.polymul([1, 1, 2], 1.2))
assert np.allclose(fcoeffs2coeffs(np.array([1.0, 2])), P.polymul([1, 1],
2))
def egcd(a, b, p):
x,y, u,v = np.array([0]),np.array([1]), np.array([1]),np.array([0])
while not np.all(a == 0):
q, r = P.polydiv(b,a)[0]%p, P.polydiv(b, a)[1]%p
print(q,r)
m, n = (x-P.polymul(u, q))%p, (y-P.polymul(v,q))%p
b,a, x,y, u,v = a,r, u,v, m,n
gcd = b
return gcd, x, y
def test_fcoeffs2coeffs():
"""Test the function expanding factored polynomials"""
assert np.allclose(
fcoeffs2coeffs(np.array([1.0, 2, 1, 1])), P.polymul([1, 1, 2], [1, 1])
)
assert np.allclose(
fcoeffs2coeffs(np.array([1.0, 2, 1.2])), P.polymul([1, 1, 2], 1.2)
)
assert np.allclose(fcoeffs2coeffs(np.array([1.0, 2])), P.polymul([1, 1], 2))
def ButterworthD2(N, w, Ts):
Nr = int(N / 2)
a = np.array(myPoli.num(2 * Nr)) * Ts**(2 * Nr) * w**N
b = np.array(myPoli.polynomialMultiplier(N, Nr))
if N % 2 == 1:
n = [w * Ts + 2, w * Ts - 2]
d = [w * Ts, w * Ts]
b = poly.polymul(b, n)
a = poly.polymul(a, d)
print a, b
def d2d(b, a, T):
nb = len(b)
na = len(a)
b_new = _polytustin(b, T)
a_new = _polytustin(a, T)
if nb > na:
a_new = polymul(a_new, polypow([1, (T - 1) / (T + 1)], nb - na))
elif na > nb:
b_new = polymul(b_new, polypow([1, (T - 1) / (T + 1)], na - nb))
return b_new / a_new[0], a_new / a_new[0]
def calculate_rst(b_minus,
b_plus,
a_minus,
a_plus,
a_m,
a0=np.ones(1),
d=1,
p=0,
r_e=0):
"""Calculate the coefficient of the rst"""
perturbation = P.polypow(zero(1), p)
s2, r0 = solve_diophantine(P.polymul(perturbation, a_minus),
P.polymul(delay(d), b_minus),
P.polymul(a_m, a0))
b_m_plus, _ = solve_diophantine(P.polymul(delay(d), b_minus),
P.polypow(zero(1), r_e + 1), a_m)
t0 = P.polymul(a0, b_m_plus)
r = P.polymul(r0, a_plus)
s = P.polymul(s2, P.polymul(b_plus, perturbation))
t = P.polymul(t0, a_plus)
print("R = ", ", ".join(map(str, r)))
print("S = ", ", ".join(map(str, s)))
print("T = ", ", ".join(map(str, t)))
return r, s, t
def PolyGCD(a: numpy.array, b: numpy.array):
"""Iterative Greatest Common Divisor for polynomial"""
# if len(a) < len(b):
# a, b = b, a
x, xt, y, yt = (1, ), (0, ), (0, ), (1, )
while any(num != 0.0 for num in b):
q = polydiv(a, b)[0]
a, b = b, polydiv(a, b)[1]
x, xt = xt, polysub(x, polymul(xt, q))
y, yt = yt, polysub(y, polymul(yt, q))
return a, x, y
def ButterworthC(N, w, Ts):
Nr = int(N / 2)
i = 1j
a = [w**N]
b = [1]
# print poly.polymul(a,b)
for k in range(1, Nr + 1):
rad = np.pi * (2 * k - 1) / (2 * N)
n = [1, 2 * w * np.sin(rad), w**2]
b = poly.polymul(b, n)
if N % 2 == 1:
b = poly.polymul(b, [1, w])
print a, b
def root_finding_poly(self):
"""
R = p^2 - (1 - x^2) * q^2
Returns
-------
coef : np.ndarray
Coefficients of a root-finding polynomial `R(x)`. Every zero of
the `PseudoPolynomial` is also a zero of `R(x)`.
"""
return remove_zeros(pol.polysub(pol.polymul(self.p, self.p),
pol.polymul(pol.polymul(self.q, self.q),
(1, 0, -1))))
def plot(points):
s, X, F = points[:], [], []
while (s != ''):
i = s.index('(')
j = s.index(',', i)
X.append(float(s[i + 1:j]))
k = s.index(')', j)
F.append(float(s[j + 1:k]))
s = s[k + 2:]
fig = plt.figure()
plt.clf()
sub = fig.add_subplot(111)
X1 = np.arange(min(X) - 2, max(X) + 2, 0.1)
num_plots = len(X)
colormap = plt.cm.gist_ncar
plt.gca().set_color_cycle(
[colormap(i) for i in np.linspace(0.2, 0.9, num_plots)])
x = [1.0]
for i in range(len(X)):
x = P.polymul(x, [-1 * X[i], 1])
b = [0.0]
for i in range(len(X)):
a = P.polydiv(x, [-1 * X[i], 1])
b = P.polyadd(
P.polymul((P.polydiv(a[0], P.polyval(X[i], a[0])))[0], [F[i]]), b)
Y = P.polyval(
X1, P.polymul((P.polydiv(a[0], P.polyval(X[i], a[0])))[0], [F[i]]))
sub.plot(X1, Y)
Y = P.polyval(X1, b)
Y1 = P.polyval(np.arange(min(X), max(X) + 0.1, 0.1), b)
interpol_obj = sub.plot(X1, Y, 'k', linewidth=2)
sub.plot(X, F, 'ro', markersize=8)
plt.grid(True)
fig.legend(interpol_obj, ['Interpolating Polynomial'],
fancybox=True,
shadow=True,
loc='upper left')
plt.axis([min(X) - 3, max(X) + 3, min(Y1) - 2, max(Y1) + 2])
plt.xlabel('x axis')
plt.ylabel('y axis')
plt.title('Interpolate')
canvas = FigureCanvas(fig)
output = StringIO.StringIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def get_poly(n):
if n > len(Bessel.polynomials):
if n == 1:
Bessel.polynomials.append(Polynomial(coef=[1, 1]))
elif n == 2:
Bessel.polynomials.append(Polynomial(coef=[3, 3, 1]))
else:
b_n_2 = poly.polymul(Polynomial(coef=[0, 0, 1]),
Bessel.get_poly(n - 2))
b_n_1 = poly.polymul(Polynomial(coef=[2 * n - 1]),
Bessel.get_poly(n - 1))
b_n = poly.polyadd(b_n_1, b_n_2)
Bessel.polynomials.append(b_n[0])
return Bessel.polynomials[n - 1]
def test_pseudopoly_multiplication(A, r, rseed=42):
# float * polynomial
poly = random_polynomial(2, 3, r=r, rseed=rseed)
poly2 = PseudoPolynomial(A * poly.p, A * poly.q, r=r)
assert A * poly == poly2
assert poly * A == poly2
# polynomial * pseudopoly
A = [1, 3, 2, 4]
result = PseudoPolynomial(p=pol.polymul(A, poly.p),
q=pol.polymul(A, poly.q),
r=poly.r)
assert A * poly == result
assert poly * A == result
def fast_power_poly(base, power, r, Z_n):
result = 1
while power > 0:
# If power is even
if power % 2 == 0:
# Divide the power by 2
power = power / 2
# Multiply base to itself
base = P.polymul(base, base)
#base = P.polydiv(square, modulus)[1]
# base = base mod (x^r-1)
x = np.nonzero(result)[0]
for i in x[x>=r]:
if base[i] != 0:
base[i % r] += base[i]
base[i] = 0
# Keep the coefficients in Z_n
base = base % Z_n
else:
# Decrement the power by 1 and make it even
power = power - 1
# Take care of the extra value that we took out
# We will store it directly in result
result = P.polymul(result, base)
#result = P.polydiv(mult, modulus)[1]
#print(np.nonzero(result))
x = np.nonzero(result)[0]
for i in x[x>=r]:
#print(i)
if result[i] != 0:
result[i % r] += result[i]
result[i] = 0
# Keep the coefficients in Z_n
result = result % Z_n
# Now power is even, so we can follow our previous procedure
power = power / 2
base = P.polymul(base, base)
#base = P.polydiv(square, modulus)[1]
x = np.nonzero(result)[0]
for i in x[x>=r]:
if base[i] != 0:
base[i % r] += base[i]
base[i] = 0
# Keep the coefficients in Z_n
base = base % Z_n
return result
def negPNX(n):
if n == 1:
return (1)
if n < 1:
return
if n in negPNXDict:
return negPNXDict[n]
first = P.polymul((3, 2 * n - 4), negPNX(n - 1))
second = P.polymul((0, 4), (1, -1))
deriv = P.polyder(negPNX(n - 1))
second = P.polymul(second, deriv)
third = posPNX(n - 1)
ret = P.polyadd(first, second)
ret = P.polyadd(ret, third)
negPNXDict[n] = ret
return ret
def polynomials_mult(x, y, mod, poly_mod):
return np.int64(
np.round(
poly.polydiv(
poly.polymul(x, y) % mod,
poly_mod
)[1] % mod))
def evaluate_keygen_v1(sk, size, modulus, T, poly_mod, std2):
"""Generate a relinearization key using version 1.
Args:
sk: secret key.
size: size of the polynomials.
modulus: coefficient modulus.
T: base.
poly_mod: polynomial modulus.
std2: standard deviation for the error distribution.
Returns:
rlk0, rlk1: relinearization key.
"""
n = len(poly_mod) - 1
l = np.int(np.log(modulus) / np.log(T))
rlk0 = np.zeros((l + 1, n), dtype=np.int64)
rlk1 = np.zeros((l + 1, n), dtype=np.int64)
for i in range(l + 1):
a = gen_uniform_poly(size, modulus)
e = gen_normal_poly(size, 0, std2)
secret_part = T**i * poly.polymul(sk, sk)
b = np.int64(
polyadd(polymul_wm(-a, sk, poly_mod),
polyadd_wm(-e, secret_part, poly_mod), modulus, poly_mod))
b = np.int64(np.concatenate((b, [0] * (n - len(b))))) # pad b
a = np.int64(np.concatenate((a, [0] * (n - len(a))))) # pad a
rlk0[i] = b
rlk1[i] = a
return rlk0, rlk1
def posPNX(n):
if n == 1:
return (1)
if n < 1:
return
if n in posPNXDict:
return posPNXDict[n]
first = P.polymul((1, 2 * n - 2), posPNX(n - 1))
second = P.polymul((0, 4), (1, -1))
deriv = P.polyder(posPNX(n - 1))
second = P.polymul(second, deriv)
third = P.polymul((0, 1), (negPNX(n - 1)))
ret = P.polyadd(first, second)
ret = P.polyadd(ret, third)
posPNXDict[n] = ret
return ret
def Lagrange(L,M):
polylist=[]
n=len(L)
w=(-1*L[0],1)
for i in range(1,n):
w=P.polymul(w,(-1*L[i],1))
result=array([0.0 for i in range(len(w)-1)])
derivative=P.polyder(w)
for i in range(n):
polylist.append((P.polydiv(w,(-1*L[i],1))[0]*M[i])/P.polyval(L[i],derivative))
result+=polylist[-1]
polynomial=""
for i in range(len(result)-1,0,-1):
if(result[i]!=0):
if(result[i]>0 and i!=(len(result)-1)):
polynomial+=" + "+str(result[i])+"x^"+str(i)+" "
elif(result[i]>0 and i==(len(result)-1)):
polynomial+=str(result[i])+"x^"+str(i)+" "
else:
polynomial+=" - "+str(-1*result[i])+"x^"+str(i)+" "
if(result[0]!=0):
polynomial+=" + "+str(result[0]) if result[0]>0 else " - "+str(-1*result[0])
plot(L,M,polylist,result)
return (polynomial)
def poly_mul_mod(op1, op2, coeff_mod, poly_mod):
"""Multiply two polynomials and modulo every coefficient with coeff_mod.
Args:
op1 (list): First Polynomail (Multiplicand).
op2 (list): Second Polynomail (Multiplier).
Returns:
A list with polynomial coefficients.
"""
# For non same size polynomials we have to shift the polynomials because numpy consider right
# side as lower order of polynomial and we consider right side as heigher order.
if len(op1) != poly_mod:
op1 += [0] * (poly_mod - len(op1))
if len(op2) != poly_mod:
op2 += [0] * (poly_mod - len(op2))
poly_len = poly_mod
poly_mod = np.array([1] + [0] * (poly_len - 1) + [1])
result = (
poly.polydiv(
poly.polymul(np.array(op1, dtype="object"), np.array(op2, dtype="object")) % coeff_mod,
poly_mod,
)[1]
% coeff_mod
).tolist()
if len(result) != poly_len:
result += [0] * (poly_len - len(result))
return [round(x) for x in result]
def plot(points):
s,X,F=points[:],[],[]
while(s!=''):
i=s.index('(')
j=s.index(',',i)
X.append(float(s[i+1:j]))
k=s.index(')',j)
F.append(float(s[j+1:k]))
s=s[k+2:]
fig=plt.figure()
plt.clf()
sub=fig.add_subplot(111)
X1=np.arange(min(X)-2,max(X)+2,0.1)
num_plots=len(X)
colormap = plt.cm.gist_ncar
plt.gca().set_color_cycle([colormap(i) for i in np.linspace(0.2, 0.9, num_plots)])
x=[1.0]
for i in range(len(X)):
x=P.polymul(x,[-1*X[i],1])
b=[0.0]
for i in range(len(X)):
a=P.polydiv(x,[-1*X[i],1])
b=P.polyadd(P.polymul((P.polydiv(a[0],P.polyval(X[i],a[0])))[0],[F[i]]),b)
Y=P.polyval(X1,P.polymul((P.polydiv(a[0],P.polyval(X[i],a[0])))[0],[F[i]]))
sub.plot(X1,Y)
Y=P.polyval(X1,b)
Y1=P.polyval(np.arange(min(X)-0.1,max(X)+0.1,0.1),b)
interpol_obj=sub.plot(X1,Y,'k',linewidth=2)
sub.plot(X,F,'ro',markersize=8)
plt.grid(True)
fig.legend(interpol_obj,['Interpolating Polynomial'],fancybox=True,shadow=True,loc='upper left')
plt.axis([min(X)-3,max(X)+3,min(Y1)-2,max(Y1)+2])
plt.xlabel('x axis')
plt.ylabel('y axis')
plt.title('Interpolate')
#plt.show()
canvas = FigureCanvas(fig)
output = StringIO.StringIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def extended_euclid_poly(a, b, p):
""" Повертає d=НСД(x,y) і x, y такі, що ax + by = d """
if np.all(b == 0):
print ("b=0", a, b)
return a, np.array([1]), np.array([0])
d, x, y = extended_euclid_poly(b, P.polydiv(a, b)[1] % p, p)
print (d, x, y)
return d, y, (x - P.polymul(P.polydiv(a,b)[0], y)) % p
def test_polymul(self):
for i in range(5):
for j in range(5):
msg = "At i=%d, j=%d" % (i, j)
tgt = np.zeros(i + j + 1)
tgt[i + j] += 1
res = poly.polymul([0] * i + [1], [0] * j + [1])
assert_equal(trim(res), trim(tgt), err_msg=msg)
def n_k(order, coef_func):
if order < 0:
raise ValueError()
if order == 0:
return Polynomial([0, 1])
elif order > 0:
return pl.polymul(n_k(order - 1, coef_func),
Polynomial([coef_func(order), 1]))[0] / (order + 1)
def mult(a, b, type=1):
kex_start = timeit.default_timer()
if type == 1:
c = p.polymul(a, b)
else:
c = np.fft.irfft(np.fft.rfft(a, 2 * n) * np.fft.rfft(b, 2 * n), 2 * n)
kex_end = timeit.default_timer()
return c, kex_end - kex_start
def polymul(a, b):
"""
Multiply polynomial a by polynomial b.
a and b are lists from highest order term to lowest.
"""
val = polynomial.polymul(a[::-1], b[::-1])
val = val[::-1]
return val
def test_polymul(self) :
for i in range(5) :
for j in range(5) :
msg = "At i=%d, j=%d" % (i,j)
tgt = np.zeros(i + j + 1)
tgt[i + j] += 1
res = poly.polymul([0]*i + [1], [0]*j + [1])
assert_equal(trim(res), trim(tgt), err_msg=msg)
def generalized_hankel_matrices(self, phis, pols):
G = np.zeros((len(phis), len(phis)), dtype=complex)
G1 = np.zeros((len(phis), len(phis)), dtype=complex)
prow = [monicPolynomial(npol.polymul(pols[1].coef, pols[j].coef), coef_type='normal').f_polynomial() for j in range(len(phis))]
for i,j in itertools.product(range(len(phis)), range(len(phis))):
G [i,j] = self.inner_prod(phis[i], phis[j])
G1[i,j] = self.inner_prod(phis[i], prow[j])
return G, G1
def interpolate(pointList):
size = len(pointList)
if len(pointList) == 1:
return (fr(pointList[0][1]),)
result = [fr(0)]
for index_i in range(0, size):
x_i = fr(pointList[index_i][0])
y_i = fr(pointList[index_i][1])
member = [y_i]
for index_j in range(0, size):
if index_i == index_j:
continue
x_j = fr(pointList[index_j][0])
member = polymul(member, [-x_j, fr(1)])
multiplier = [fr(1, x_i - x_j)]
member = polymul(member, multiplier)
result = polyadd(result, member)
return result
def polymul_wm(x, y, poly_mod):
"""Multiply two polynomials
Args:
x, y: two polynomials to be multiplied.
poly_mod: polynomial modulus.
Returns:
A polynomial in Z[X]/(poly_mod).
"""
return poly.polydiv(poly.polymul(x, y), poly_mod)[1]
def mul(a, b, prime, exp, min0):
a.reverse()
b.reverse()
min0.reverse()
ans = []
mul0 = poly.polymul(a, b)
ans = poly.polydiv(mul0, min0)[1]
ans = list(map(int, ans))
ans.reverse()
return ans
def polycomp(c1, c2):
"""
Compose two polynomials : c1 o c2 = c1(c2(x))
The arguments are sequences of coefficients, from lowest order term to highest, e.g., [1,2,3] represents the polynomial 1 + 2*x + 3*x**2.
"""
# TODO: Polynomial(Polynomial()) seems to do just that?
# using Horner's method to compute the result of a polynomial
cr = [c1[-1]]
for a in reversed(c1[:-1]):
# cr = cr * c2 + a
cr = polynomial.polyadd(polynomial.polymul(cr, c2), [a])
return cr
def evaluate(self, nodes, interval=None):
"""Computes weights for stored polynomial and given nodes.
The weights are calculated with help of the Lagrange polynomials
.. math::
\\alpha_i = \\int_a^b\\omega (x) \\prod_{j=1,j \\neq i}^{n} \\frac{x-x_j}{x_i-x_j} \\mathrm{d}x
See Also
--------
:py:meth:`.IWeightFunction.evaluate` : overridden method
"""
super(PolynomialWeightFunction, self).evaluate(nodes, interval)
a = self._interval[0]
b = self._interval[1]
n_nodes = nodes.size
alpha = np.zeros(n_nodes)
for j in range(n_nodes):
selection = list(range(j))
selection.extend(list(range(j + 1, n_nodes)))
poly = [1.0]
for ais in nodes[selection]:
# builds Lagrange polynomial p_i
poly = pol.polymul(poly, [ais / (ais - nodes[j]), 1 / (nodes[j] - ais)])
# computes \int w(x)p_i dx
poly = pol.polyint(pol.polymul(poly, self._coefficients))
alpha[j] = pol.polyval(b, poly) - pol.polyval(a, poly)
#LOG.debug("Computed polynomial weights for nodes {:s} in {:s}."
# .format(nodes, self._interval))
del self._interval
self._weights = alpha
def Lagrange(self,A,B):
from numpy import array
from numpy.polynomial import polynomial as P
n=len(A)
w=(-1*A[0],1)
for i in range(1,n):
w=P.polymul(w,(-1*A[i],1))
result=array([0.0 for i in range(len(w)-1)])
derivative=P.polyder(w)
for i in range(n):
result+=(P.polydiv(w,(-1*A[i],1))[0]*B[i])/P.polyval(A[i],derivative)
s=self.plot(list(result),A,B)
return s
def test_polydiv(self) :
# check zero division
assert_raises(ZeroDivisionError, poly.polydiv, [1], [0])
# check scalar division
quo, rem = poly.polydiv([2],[2])
assert_equal((quo, rem), (1, 0))
quo, rem = poly.polydiv([2,2],[2])
assert_equal((quo, rem), ((1,1), 0))
# check rest.
for i in range(5) :
for j in range(5) :
msg = "At i=%d, j=%d" % (i,j)
ci = [0]*i + [1,2]
cj = [0]*j + [1,2]
tgt = poly.polyadd(ci, cj)
quo, rem = poly.polydiv(tgt, ci)
res = poly.polyadd(poly.polymul(quo, ci), rem)
assert_equal(res, tgt, err_msg=msg)
def Newton(self,A,B):
from numpy import array
from numpy.polynomial import polynomial as P
n=len(A)
mat=[[0.0 for i in range(n)] for j in range(n)]
for i in range(n):
mat[i][0]=B[i]
for i in range(1,n):
for j in range(n-i):
mat[j][i]=(mat[j+1][i-1]-mat[j][i-1])/(A[j+i]-A[j])
res=array((mat[0][0],))
for i in range(1,n):
prod=(-1*A[0],1)
for j in range(1,i):
prod=P.polymul(prod,(-1*A[j],1))
res=P.polyadd(res,array(prod)*mat[0][i])
s=self.plot(list(res),A,B)
return s
def Lagrange(self,U,V):
n=len(U)
w=(-1*U[0],1)
for i in range(1,n):
w=P.polymul(w,(-1*U[i],1))
result=array([0.0 for i in range(len(w)-1)])
derivative=P.polyder(w)
for i in range(n):
result+=(P.polydiv(w,(-1*U[i],1))[0]*V[i])/P.polyval(U[i],derivative)
temp=list(result);
cofficient=temp
l=len(cofficient);
temp=[];
for i in range(l-1):
temp.append(str(cofficient[l-(i+1)])+'x^'+str(l-(i+1))+str('+'))
temp.append(str(cofficient[0])+'x^'+str(0));
str1=''.join(temp)
return(str1)
def p389(dice):
t=time.clock()
probs={n:1/dice[0] for n in range (1,dice[0]+1)}
ks=[n for n in range(1,dice[0]+1)]
for n in dice[1:]:
newWays={}
p0=np.array([0.]+[1. for i in range(n)])/n
pks=np.copy(p0)
for k in ks:
if k>1:
pks=P.polymul(p0,pks)
for s in range(k,len(pks)):
newWays[s]=newWays.get(s,0)+probs[k]*pks[s]
probs.update(newWays)
ks=sorted([k for k,v in probs.items()])
EX=sum([k*prob for k,prob in probs.items()])
EX2=sum([k**2*prob for k,prob in probs.items()])
var=EX2-EX**2
print(EX,var)
print(time.clock()-t)
def __mul__(self, other):
if isinstance(other, Polynomial):
result = polynomial.polymul(self._poly, other._poly)
else:
result = [0] * other + self._poly
return Polynomial(poly=result)
def longitudinal(velocity, density, S_gross_w, mac, Cm_q, Cz_alpha, mass, Cm_alpha, Iy, Cm_alpha_dot, Cz_u, Cz_alpha_dot, Cz_q, Cw, Theta, Cx_u, Cx_alpha):
""" output = SUAVE.Methods.Flight_Dynamics.Dynamic_Stablity.Full_Linearized_Equations.longitudinal(velocity, density, S_gross_w, mac, Cm_q, Cz_alpha, mass, Cm_alpha, Iy, Cm_alpha_dot, Cz_u, Cz_alpha_dot, Cz_q, Cw, Theta, Cx_u, Cx_alpha)
Calculate the natural frequency and damping ratio for the full linearized short period and phugoid modes
Inputs:
velocity - flight velocity at the condition being considered [meters/seconds]
density - flight density at condition being considered [kg/meters**3]
S_gross_w - area of the wing [meters**2]
mac - mean aerodynamic chord of the wing [meters]
Cm_q - coefficient for the change in pitching moment due to pitch rate [dimensionless] (2 * K * dC_m/di * lt/c where K is approximately 1.1)
Cz_alpha - coefficient for the change in Z force due to the angle of attack [dimensionless] (-C_D - dC_L/dalpha)
mass - mass of the aircraft [kilograms]
Cm_alpha - coefficient for the change in pitching moment due to angle of attack [dimensionless] (dC_m/dC_L * dCL/dalpha)
Iy - moment of interia about the body y axis [kg * meters**2]
Cm_alpha_dot - coefficient for the change in pitching moment due to rate of change of angle of attack [dimensionless] (2 * dC_m/di * depsilon/dalpha * lt/mac)
Cz_u - coefficient for the change in force in the Z direction due to change in forward velocity [dimensionless] (usually -2 C_L or -2C_L - U dC_L/du)
Cz_alpha_dot - coefficient for the change of angle of attack caused by w_dot on the Z force [dimensionless] (2 * dC_m/di * depsilon/dalpha)
Cz_q - coefficient for the change in Z force due to pitching velocity [dimensionless] (2 * K * dC_m/di where K is approximately 1.1)
Cw - coefficient to account for gravity [dimensionless] (-C_L)
Theta - angle between the horizontal axis and the body axis measured in the vertical plane [radians]
Cx_u - coefficient for the change in force in the X direction due to change in the forward velocity [dimensionless] (-2C_D)
Cx_alpha - coefficient for the change in force in the X direction due to the change in angle of attack caused by w [dimensionless] (C_L-dC_L/dalpha)
Outputs:
output - a data dictionary with fields:
short_w_n - natural frequency of the short period mode [radian/second]
short_zeta - damping ratio of the short period mode [dimensionless]
phugoid_w_n - natural frequency of the short period mode [radian/second]
phugoid_zeta - damping ratio of the short period mode [dimensionless]
Assumptions:
X-Z axis is plane of symmetry
Constant mass of aircraft
Origin of axis system at c.g. of aircraft
Aircraft is a rigid body
Earth is inertial reference frame
Perturbations from equilibrium are small
Flow is Quasisteady
Zero initial conditions
Cm_a = CF_z_a = CF_x_a = 0
Neglect Cx_alpha_dot, Cx_q and Cm_u
Source:
J.H. Blakelock, "Automatic Control of Aircraft and Missiles" Wiley & Sons, Inc. New York, 1991, p 26-41.
"""
#process
# constructing matrix of coefficients
A = (- Cx_u, mass * velocity / S_gross_w / (0.5*density*velocity**2.)) # X force U term
B = (-Cx_alpha) # X force alpha term
C = (-Cw * np.cos(Theta)) # X force theta term
D = (-Cz_u) # Z force U term
E = (-Cz_alpha, (mass*velocity/S_gross_w/(0.5*density*velocity**2.)-mac*0.5/velocity*Cz_alpha_dot)) # Z force alpha term
F = (- Cw * np.sin(Theta), (-mass*velocity/S_gross_w/(0.5*density*velocity**2.)-mac*0.5/velocity*Cz_q))# Z force theta term
G = (0.) # M moment U term
H = (-Cm_alpha, -mac*0.5/velocity*Cm_alpha_dot) # M moment alpha term
I = (0., - mac*0.5/velocity*Cm_q, Iy/S_gross_w/(0.5*density*velocity**2)/mac) # M moment theta term
# Taking the determinant of the matrix ([A, B, C],[D, E, F],[G, H, I])
EI = P.polymul(E,I)
FH = P.polymul(F,H)
part1 = P.polymul(A,P.polysub(EI,FH))
DI = P.polymul(D,I)
FG = P.polymul(F,G)
part2 = P.polymul(B,P.polysub(FG,DI))
DH = P.polymul(D,H)
GE = P.polymul(G,E)
part3 = P.polymul(C,P.polysub(DH,GE))
total = P.polyadd(part1,P.polyadd(part2,part3))
# Use Synthetic division to split polynomial into two quadratic factors
poly = total / total[4]
poly1 = poly * 1.
poly2 = poly * 1.
poly3 = poly * 1.
poly4 = poly * 1.
poly1[4] = poly[4] - poly[2]/poly[2]
poly1[3] = poly[3] - poly[1]/poly[2]
poly1[2] = poly[2] - poly[0]/poly[2]
poly2[4] = 0
poly2[3] = poly1[3] - poly[2]*poly1[3]/poly[2]
poly2[2] = poly1[2] - poly[1]*poly1[3]/poly[2]
poly2[1] = poly1[1] - poly[0]*poly1[3]/poly[2]
poly3[4] = poly[4] - poly2[2]/poly2[2]
poly3[3] = poly[3] - poly2[1]/poly2[2]
poly3[2] = poly[2] - poly2[0]/poly2[2]
poly4[3] = poly3[3] - poly2[2]*poly3[3]/poly2[2]
poly4[2] = poly3[2] - poly2[1]*poly3[3]/poly2[2]
poly4[1] = poly3[1] - poly2[0]*poly3[3]/poly2[2]
# Generate natural frequency and damping for Short Period and Phugoid modes
short_w_n = (poly4[2])**0.5
short_zeta = poly3[3]*0.5/short_w_n
phugoid_w_n = (poly2[0]/poly2[2])**0.5
phugoid_zeta = poly2[1]/poly2[2]*0.5/phugoid_w_n
output = Data()
output.short_natural_frequency = short_w_n
output.short_damping_ratio = short_zeta
output.phugoid_natural_frequency = phugoid_w_n
output.phugoid_damping_ratio = phugoid_zeta
return output
def lateral_directional(velocity, Cn_Beta, S_gross_w, density, span, I_z, Cn_r, I_x, Cl_p, J_xz, Cl_r, Cl_Beta, Cn_p, Cy_phi, Cy_psi, Cy_Beta, mass):
""" output = SUAVE.Methods.Flight_Dynamics.Dynamic_Stablity.Full_Linearized_Equations.lateral_directional(velocity, Cn_Beta, S_gross_w, density, span, I_z, Cn_r, I_x, Cl_p, J_xz, Cl_r, Cl_Beta, Cn_p, Cy_phi, Cy_psi, Cy_Beta)
Calculate the natural frequency and damping ratio for the full linearized dutch roll mode along with the time constants for the roll and spiral modes
Inputs:
velocity - flight velocity at the condition being considered [meters/seconds]
Cn_Beta - coefficient for change in yawing moment due to sideslip [dimensionless] (no simple relation)
S_gross_w - area of the wing [meters**2]
density - flight density at condition being considered [kg/meters**3]
span - wing span of the aircraft [meters]
I_z - moment of interia about the body z axis [kg * meters**2]
Cn_r - coefficient for change in yawing moment due to yawing velocity [dimensionless] ( - C_D(wing)/4 - 2 * Sv/S * (l_v/b)**2 * (dC_L/dalpha)(vert) * eta(vert))
I_x - moment of interia about the body x axis [kg * meters**2]
Cl_p - change in rolling moment due to the rolling velocity [dimensionless] (no simple relation for calculation)
J_xz - products of inertia in the x-z direction [kg * meters**2] (if X and Z lie in a plane of symmetry then equal to zero)
Cl_r - coefficient for change in rolling moment due to yawing velocity [dimensionless] (Usually equals C_L(wing)/4)
Cl_Beta - coefficient for change in rolling moment due to sideslip [dimensionless]
Cn_p - coefficient for the change in yawing moment due to rolling velocity [dimensionless] (-C_L(wing)/8*(1 - depsilon/dalpha)) (depsilon/dalpha = 2/pi/e/AspectRatio dC_L(wing)/dalpha)
Cy_phi - coefficient for change in sideforce due to aircraft roll [dimensionless] (Usually equals C_L)
Cy_psi - coefficient to account for gravity [dimensionless] (C_L * tan(Theta))
Cy_Beta - coefficient for change in Y force due to sideslip [dimensionless] (no simple relation)
mass - mass of the aircraft [kilograms]
Outputs:
output - a data dictionary with fields:
dutch_w_n - natural frequency of the dutch roll mode [radian/second]
dutch_zeta - damping ratio of the dutch roll mode [dimensionless]
roll_tau - approximation of the time constant of the roll mode of an aircraft [seconds] (positive values are bad)
spiral_tau - time constant for the spiral mode [seconds] (positive values are bad)
Assumptions:
X-Z axis is plane of symmetry
Constant mass of aircraft
Origin of axis system at c.g. of aircraft
Aircraft is a rigid body
Earth is inertial reference frame
Perturbations from equilibrium are small
Flow is Quasisteady
Zero initial conditions
Neglect Cy_p and Cy_r
Source:
J.H. Blakelock, "Automatic Control of Aircraft and Missiles" Wiley & Sons, Inc. New York, 1991, p 118-124.
"""
#process
# constructing matrix of coefficients
A = (0, -span * 0.5 / velocity * Cl_p, I_x/S_gross_w/(0.5*density*velocity**2)/span ) # L moment phi term
B = (0, -span * 0.5 / velocity * Cl_r, -J_xz / S_gross_w / (0.5 * density * velocity ** 2.) / span) # L moment psi term
C = (-Cl_Beta) # L moment Beta term
D = (0, - span * 0.5 / velocity * Cn_p, -J_xz / S_gross_w / (0.5 * density * velocity ** 2.) / span ) # N moment phi term
E = (0, - span * 0.5 / velocity * Cn_r, I_z / S_gross_w / (0.5 * density * velocity ** 2.) / span ) # N moment psi term
F = (-Cn_Beta) # N moment Beta term
G = (-Cy_phi) # Y force phi term
H = (-Cy_psi, mass * velocity / S_gross_w / (0.5 * density * velocity ** 2.))
I = (-Cy_Beta, mass * velocity / S_gross_w / (0.5 * density * velocity ** 2.))
# Taking the determinant of the matrix ([A, B, C],[D, E, F],[G, H, I])
EI = P.polymul(E,I)
FH = P.polymul(F,H)
part1 = P.polymul(A,P.polysub(EI,FH))
DI = P.polymul(D,I)
FG = P.polymul(F,G)
part2 = P.polymul(B,P.polysub(FG,DI))
DH = P.polymul(D,H)
GE = P.polymul(G,E)
part3 = P.polymul(C,P.polysub(DH,GE))
total = P.polyadd(part1,P.polyadd(part2,part3))
poly = total / total[5]
# Generate the time constant for the spiral and roll modes along with the damping and natural frequency for the dutch roll mode
root = np.roots(poly)
root = sorted(root,reverse=True)
spiral_tau = 1 * root[0].real
w_n = (root[1].imag**2 + root[1].real**2)**(-0.5)
zeta = -2*root[1].real/w_n
roll_tau = 1 * root [3].real
output = Data()
output.dutch_natural_frequency = w_n
output.dutch_damping_ratio = zeta
output.spiral_tau = spiral_tau
output.roll_tau = roll_tau
return output
p2 = obj.insertPol(gr1,p2)
print "La suma es:"+str(npy.polyadd(p1,p2))
elif op == 3:
print "Resta"
gr1 = input("Grado del polinomio 1")
p1 = obj.insertPol(gr1,p1)
gr1 = input("Grado del polinomio 2")
p2 = obj.insertPol(gr1,p2)
print "La resta es:"+str(npy.polysub(p1,p2))
elif op == 4:
print "Multiplicacion"
gr1 = input("Grado del polinomio 1")
p1 = obj.insertPol(gr1,p1)
gr1 = input("Grado del polinomio 2")
p2 = obj.insertPol(gr1,p2)
print "La multiplicacion es:"+str(npy.polymul(p1,p2))
elif op == 5:
print "Igualdad"
gr1 = input("Grado del polinomio 1")
p1 = obj.insertPol(gr1,p1)
gr1 = input("Grado del polinomio 2")
p2 = obj.insertPol(gr1,p2)
elif op == 6:
print "Polinomio Opuesto"
gr1 = input("Ingresa el grado del polinomio")
p1 = obj.insertPol(gr1,p1)
for i in range (0,len(p1)):
p1[i]=-p1[i]
print p1
else:
print "No es una opcion valida"
def polymul(c1, c2):
from numpy.polynomial.polynomial import polymul
return polymul(c1, c2)
print "a",a
print "b",b
break
# TESTING SUBTRACTION FUNCTION
a=P.polysub(c1,c2).tolist()
b=q.subPoly(c1,c2)
if(a!=b):
print "Failed on Case:"
print "a subtract b"
print "a",a
print "b",b
break
# TESTING MULTIPLICATION FUNCTION
a=P.polymul(c1,c2).tolist()
b=q.multPoly(c1,c2)
if(a!=b):
print "Failed on Case:"
print "a * b"
print "a",a
print "b",b
break
# TESINGING DIVISION FUNCTION
if q.trim(c2)==[0]:
continue
try:
[a1,a2]=P.polydiv(c1,c2)
a1=q.trim(a1.tolist())
a2=q.trim(a2.tolist())
