def gen_poly(self, n): self.order = n # zeroth polynomial self.poly = [nppoly.polyone] alpha = [self.get_alpha(self.poly[0])] beta = [1.] # first polynomial self.poly.append(nppoly.polymulx(self.poly[0])) self.poly[1] = nppoly.polyadd(self.poly[1], -alpha[0] * self.poly[0]) alpha.append(self.get_alpha(self.poly[1])) beta.append(self.get_beta(self.poly[1], self.poly[0])) # reccurence relation for other polynomials for i in range(2, n + 1): p_i = nppoly.polymulx(self.poly[i - 1]) p_i = nppoly.polyadd(p_i, -alpha[i - 1] * self.poly[i - 1]) p_i = nppoly.polyadd(p_i, -beta[i - 1] * self.poly[i - 2]) self.poly.append(p_i) alpha.append(self.get_alpha(self.poly[i])) beta.append(self.get_beta(self.poly[i], self.poly[i - 1])) # normalise polynomials for i in range(len(self.poly)): self.poly[i] = self.poly[i] / np.prod(beta[:i]) # create Jacobi matrix self.jacobi = (np.diag(np.sqrt(beta[1:]), -1) + np.diag(alpha, 0) + np.diag(np.sqrt(beta[1:]), 1))
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 poly_lagrange(px, py): tab_q = base_lagrange(px) rt = len(px) res = nppol.polyzero for h in range(rt): res = nppol.polyadd(res, py[h] * tab_q[h]) return res
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 hermit_interpol_polynomial(nodes, f): def divided_difference(row, col): # row = j, col = i # Если знаменатель не ноль if nodes[row + col] != nodes[row]: return (dif_matrix[row + 1, col - 1] - dif_matrix[row, col - 1]) / (nodes[row + col] - nodes[row]) # Если знаменатель ноль else: deriv = derivative(f, col) return deriv(nodes[row]) / factorial(col) n = len(nodes) dif_matrix = np.zeros((n, n)) for i in range(n): dif_matrix[i, 0] = f(nodes[i]) for i in range(1, n): for j in range(0, n - i): dif_matrix[j, i] = divided_difference(j, i) result = Polynomial(dif_matrix[0, 0]) for i in range(n - 1): result = pl.polyadd( result, Polynomial(np.poly(nodes[0:i + 1])[::-1]) * dif_matrix[0, i + 1])[0] return result, dif_matrix
def newton_interpol_polynomial(nodes, f): n = len(nodes) dif_matrix = np.zeros((n, n)) for i in range(n): dif_matrix[i, 0] = f(nodes[i]) # Считаем разделённые разности. Храним их в верхнетреугольной матрице for i in range(1, n): for j in range(0, n - i): dif_matrix[j, i] = (dif_matrix[j + 1, i - 1] - dif_matrix[j, i - 1]) / (nodes[j + i] - nodes[j]) # Строим интерпол. полином Ньютона, испоьзуя полученные разности result = Polynomial(dif_matrix[0, 0]) for i in range(n - 1): result = pl.polyadd( result, Polynomial(np.poly(nodes[0:i + 1])[::-1]) * dif_matrix[0, i + 1])[0] # Помимо полинома возвращаем ещё и матрицу разностей, т.к. её, вообще говоря, можно использовать, # если мы захотим добавить ещё узлов интерполяции return result, dif_matrix
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 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 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_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 reshare(PORT, n, t, secret, polynom): HOST = '' s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((HOST, PORT)) s.listen(n) i = 1 prime = 7103 coeffs = [] for j in range(t): coeffs.append(random.randint(1, prime)) coeffs.append(0) newpolynom = numpy.poly1d(polynomial.polyadd(polynom.c, coeffs)) print "Old polynomial is: {0}x + {1}".format(int(polynom.c[0]), int(polynom.c[1])) print "New polynomial is: {0}x + {1}".format( int(polynom.c[0]) + coeffs[0], int(polynom.c[1]) + coeffs[1]) while i <= n: conn, addr = s.accept() conn.sendall(str(i)) time.sleep(0.1) conn.sendall(str(int(newpolynom(i)))) time.sleep(0.1) conn.close() i = i + 1 s.close()
def polyadd(a, b): """ Add polynomial a by polynomial b. a and b are lists from highest order term to lowest. """ val = polynomial.polyadd(a[::-1], b[::-1]) val = val[::-1] return val
def lagrange(nodes): result = Polynomial([0]) w = Polynomial(np.poly(nodes)[::-1]) deriv = w.deriv(1) for i in range(len(nodes)): result = pl.polyadd(result, make_l_k(i, nodes, w, deriv) * f(nodes[i]))[0] return result
def polynomials_sum(x, y, mod, poly_mod): return np.int64( np.round( poly.polydiv( poly.polyadd(x, y) % mod, poly_mod )[1] % mod ) )
def test_polyadd(self) : for i in range(5) : for j in range(5) : msg = "At i=%d, j=%d" % (i,j) tgt = np.zeros(max(i,j) + 1) tgt[i] += 1 tgt[j] += 1 res = poly.polyadd([0]*i + [1], [0]*j + [1]) assert_equal(trim(res), trim(tgt), err_msg=msg)
def polyadd_wm(x, y, poly_mod): """Add two polynomials Args: x, y: two polynomials to be added. poly_mod: polynomial modulus. Returns: A polynomial in Z[X]/(poly_mod). """ return poly.polydiv(poly.polyadd(x, y), poly_mod)[1]
def test_polyadd(self): for i in range(5): for j in range(5): msg = "At i=%d, j=%d" % (i, j) tgt = np.zeros(max(i, j) + 1) tgt[i] += 1 tgt[j] += 1 res = poly.polyadd([0] * i + [1], [0] * j + [1]) assert_equal(trim(res), trim(tgt), err_msg=msg)
def interpolation_polynomial(xi, eta, e, field): coeflist = 0 for i in range(e): xi_j_list = [xi[j] for j in range(e) if j != i] xi_i = xi[i] xi_minus_xi_j = construct_polynomial(xi_j_list, field) lambnda_i = eta[i] * inv(evaluation(xi_minus_xi_j, xi_i, field), field) a = P.polymul(lambnda_i, xi_minus_xi_j) coeflist = P.polyadd(coeflist, a) % field return [int(i) for i in coeflist]
def add_poly_matrices(matrix_one, matrix_two): size = len(matrix_one) output_matrix = [] for i in range(size): row = [] for j in range(size): sum = P.polyadd(matrix_one[i][j], matrix_two[i][j]) row.append(sum) output_matrix.append(row) return output_matrix
def lagrange(nodes): result = Polynomial([0]) # np.poly строит полином по набору корней. Но порядок коэффициетов противоположный тому, который # принимает конструктор класса Polynomial w = Polynomial(np.poly(nodes)[::-1]) deriv = w.deriv(1) for i in range(len(nodes)): result = pl.polyadd(result, make_l_k(i, nodes, w, deriv) * f(nodes[i]))[0] # возвращается не только сумма return result
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 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 _polytustin(a, T): n = len(a) if sum(a[1:]) == 0: return a a_new = 0 num = [(T - 1) / (T + 1), 1] den = [1, (T - 1) / (T + 1)] for i in range(n): pnum = polypow(num, i) pden = polypow(den, n - 1 - i) a_new = polyadd(a_new, a[i] * polymul(pnum, pden)) return a_new
def polyadd(x, y, modulus, poly_mod): """Multiply two polynoms Args: x, y: two polynoms to be multiplied. modulus: coefficient modulus. poly_mod: polynomial modulus. Returns: A polynomial in Z_modulus[X]/(poly_mod). """ return np.int64( np.round( poly.polydiv(poly.polyadd(x, y) % modulus, poly_mod)[1] % modulus))
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 get_B(z, a): N = z.shape[0] left = np.array([1]) middle = np.array([1]) for i in range(1, N): c1 = np.array([-a[i] * z[i - 1], a[i]]) cc = P.polymul(c1, left) right = P.polyadd(middle, cc) left = middle middle = right return right
def Newton(self, L, M): # Newton function takes two lists as arguments # L contains the list of x values # M contains the list of f(x) values # e.g.- #L=[1,2,3] , M=[0,-1,0] # i.e., f(1)=0, f(2)=-1, f(3)=0 self.x_values = L self.fx_values = M n = len(self.x_values) # n=length of L, i.e., the number of points mat = [[0.0 for i in range(n)] for j in range(n)] # initialising an n*n matrix for i in range(n): # filling 1st column of matrix with f(x) values mat[i][0] = self.fx_values[i] for i in range(1, n): # calculating entries of matrix for j in range(n - i): mat[j][i] = (mat[j + 1][i - 1] - mat[j][i - 1]) / ( self.x_values[j + i] - self.x_values[j]) # The matrix is of the form (for 4 points - x,y,z,w) # f(x) f(x,y) f(x,y,z) f(x,y,z,w) # f(y) f(y,z) f(y,z,w) 0 # f(z) f(z,w) 0 0 # f(w) 0 0 0 result = array((mat[0][0], )) # initialising result array for i in range(1, n): prod = (-1 * self.x_values[0], 1 ) # initialising prod polynomial which is to be multiplied # with corresponding element of matrix mat for j in range(1, i): prod = P.polymul( prod, (-1 * self.x_values[j], 1)) # calculating prod result = P.polyadd(result, array(prod) * mat[0][i]) # calculating result result = list(result) # list of co-efficients self.polynomial = "" # string to store final polynomial for i in range(len(result) - 1, 0, -1): # building up the string if (result[i] != 0): if (result[i] > 0 and i != (len(result) - 1)): self.polynomial += " + " + str( result[i]) + "x^" + str(i) + " " elif (result[i] > 0 and i == (len(result) - 1)): self.polynomial += str(result[i]) + "x^" + str(i) + " " else: self.polynomial += " - " + str( -1 * result[i]) + "x^" + str(i) + " " if (result[0] != 0): self.polynomial += " + " + str( result[0]) if result[0] > 0 else " - " + str(-1 * result[0]) return (self.polynomial) # return 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), 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 add_poly(x, y, mod_coeff, mod_poly): """ Takes: x, y: the two polynoms to be multiplied. mod_coeff: coefficient modulus. mod_poly: polynomial modulus. Returns: A polynomial in Z_modulus[X]/(poly_mod). Adds the two polynoms x and y. """ return np.int64( np.round(poly.polydiv(poly.polyadd(x, y) % mod_coeff, mod_poly)[1] % mod_coeff) )
def funcionNewton( f, a ): Ai = 0 polyDef = [] for i in range( len(a) ): Ai = AiNewt( f, i, a, Ai) b = [] for j in range( len(a) ): b.append(a[i]) if j!=i lista = np.poly(b) pol = [ Ai*x for x in lista] polyDef = P.polyadd(poly, polyDef); return polyDef
def poly_coeff(n): if 0 <= n < len(polys_start_coeff): return polys_start_coeff[n] elif n >= len(polys_start_coeff): coeff = np.array([0.]) for i, func in recursive_poly_functions: if i < 0 or i >= n: raise ValueError( "Can't apply on not yet calculated polynomial! i={}, n={}" .format(i, n)) coeff = npoly.polyadd(coeff, func(n, poly_coeff(n - i - 1))) return coeff else: raise ValueError( "Illegal degree n={} for polynomial coefficients.".format(n))
def __init__(self, pol1, pol2): """ Composes two polynomials (i.e., `pol1'(`pol2')) with distinct covariance matrices. Considering we have polynomials f(x) = \\sum_i a_i x^i, g(x) = \\sum_j b_j x^j, with variances \\sigma_f and \\sigma_g when evaluated (see coll_dyn_activem.maths.Polynomial), we compute \\sigma_fg(x) = \\sigma_f(g(x)) + \\sigma_g(x) \\times [ \\sum_i i a_i g(x)^{i-1} ]^2, as the variance of the composed polynomial f(g) evaluated at x. We stress that this considers no correlations between the coefficients of the polynomials. (see https://en.wikipedia.org/wiki/Propagation_of_uncertainty#Non-linear_combinations) Parameters ---------- pol1 : coll_dyn_activem.maths.Polynomial First polynomial. pol2 : coll_dyn_activem.maths.Polynomial Second polynomial. Returns ------- pol : coll_dyn_activem.maths.Polynomial Composed polynomial. """ self._pol1, self._pol2 = pol1, pol2 self.deg = self._pol1.deg * self._pol2.deg # degree of composed polynomial # WARNING: numpy.polynomial.polynomial.polyadd and polypow considers # arrays as polynomials with lowest coefficient first, # contrarily to polyval and polyfit. _pol1, _pol2 = self._pol1.pol[::-1], self._pol2.pol[::-1] self.pol = np.zeros((1, )) # composed polynomial for i in range(pol1.deg + 1): self.pol = polyadd(self.pol, _pol1[i] * polypow(_pol2, i)) self.pol = self.pol[::-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)-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 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 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
ax2.set_ylabel('volume (ml)') ax2.grid(True) MAX = 300 data = data[numpy.all(data<MAX,axis=1)] length = data.shape[0] volumes = volumes[-length:] order = 3 sum = None for column_index in range(0,data.shape[1]): coefficients = polyfit(data[:,column_index],volumes,order) if sum is None: sum = coefficients else: sum = polyadd(sum,coefficients) average = sum/data.shape[1] round_digits = 8 average = [round(i,round_digits) for i in average] poly = Polynomial(average) ys = poly(data[:,-1]) ax2.plot(data[:,-1],ys,'r',linewidth=3) ax2.text(5,7.5,r'$v = c_0 + c_1s + c_2s^2 + c_3s^3$',fontsize=20) ax2.text(5,6.5,str(average),fontsize=18,color='r') plot.show()
flow = False else: op = int(entrada) if op == 1: print "Valor en un punto:\n" n = input("Grado del polinomio: ") p1 = obj.insertPol(n,p1) pto = input("Digite el punto a evaluar: ") print "El resultado es: "+str(obj.evalPto(p1,pto)) elif op == 2: print "Suma" gr1 = input("Grado del polinomio 1") p1 = obj.insertPol(gr1,p1) gr1 = input("Grado del polinomio 2") 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:
# marker = markers[column_index] # ax2.plot(data_oa[:,column_index],volumes_oa,marker=marker,linestyle='--',color=color) ax2.set_xlabel('volume (ml)') ax2.set_ylabel('offset mean signals (ADC units)') ax2.grid(True) order = 3 sum_va = None for column_index in range(0,data_va.shape[1]): coefficients_va = polyfit(volumes_va,data_va[:,column_index],order) if sum_va is None: sum_va = coefficients_va else: sum_va = polyadd(sum_va,coefficients_va) average_va = sum_va/data_va.shape[1] round_digits = 8 average_va = [round(i,round_digits) for i in average_va] with open('volume_to_adc_va.yaml', 'w') as f: yaml.dump(average_va, f, default_flow_style=False) poly_va = Polynomial(average_va) ys_va = poly_va(volumes_va) ax2.plot(volumes_va,ys_va,'r',linewidth=3) ax2.text(0.5,110,r'$s = c_0 + c_1v + c_2v^2 + c_3v^3$',fontsize=20) ax2.text(0.5,100,str(average_va),fontsize=18,color='r') plot.show()
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
adc_data_points.append(adc_data_point) print(adc_data_points) volume_array = numpy.array(volume_data_points,dtype='float64') adc_array = numpy.array(adc_data_points,dtype='int') adc_array = adc_array[volume_array<=6] volume_array = volume_array[volume_array<=6] ax2.plot(volume_array, adc_array, linestyle='--', linewidth=1, color=color) coefficients = polyfit(volume_array,adc_array,order) if coefficients_sum is None: coefficients_sum = coefficients else: coefficients_sum = polyadd(coefficients_sum,coefficients) coefficients_average = coefficients_sum/run_count poly_fit = Polynomial(coefficients_average) adc_fit = poly_fit(volume_array) ax2.plot(volume_array, adc_fit, linestyle='-', linewidth=2, label=cylinder, color=color) coefficients_list = [float(coefficient) for coefficient in coefficients_average] output_data[cylinder]['volume_to_adc_low'] = coefficients_list ax2.set_xlabel('volume (ml)') ax2.set_ylabel('adc low value (adc units)') ax2.legend(loc='best')
def __add__(self, other): result = polynomial.polyadd(self._poly, other._poly) result = self._normalizePoly(result, len(self._poly)) return Polynomial(poly=result)
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
rand.seed(2) print "TESING 10000 CASES..." for k in range(10000): order1=rand.randint(0,10) order2=rand.randint(0,10) c1=[0]*(order1+1) c2=[0]*(order2+1) for i in range(len(c1)): c1[i]=rand.randint(-5,5) for i in range(len(c2)): c2[i]=rand.randint(-5,5) # TESTING ADDITION FUNCTION a= P.polyadd(c1,c2).tolist() b= q.addPoly(c1,c2) if(a!=b): print "Failed on Case:" print "a add b" 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
def polyadd(c1, c2): from numpy.polynomial.polynomial import polyadd return polyadd(c1, c2)