def rmnGreen_Taylor_Mmn_vec(n, k, R, rmnRgM, rnImM, rmnvecM): """ act on wave with radial representation Cpol(kr) by spherical Green's function this is for Arnoldi process with the regular M waves the leading asymptotice for vecM is r^n so rmnv_vecM stores Taylor series representation of (kr)^(-n) * vecM rmnRgM stores (kr)^(-n) * RgM, rnImM stores (kr)^(n+1) * ImM """ kR = mp.mpf(k * R) Mfact_prefactpow, Mfact = rmnMpol_dot(2 * n, rmnRgM, rmnvecM) Mfact = po.Polynomial(Mfact) RgMfact_intgd = rnImM * rmnvecM RgMfact_intgd = [0] + RgMfact_intgd.coef.tolist() RgMfact = po.polyint(RgMfact_intgd, lbnd=kR) RgMfact = po.Polynomial(RgMfact) ###first add on Asym(G) part MfactkR = kR**Mfact_prefactpow * po.polyval(kR, Mfact.coef) newrmnvecM = 1j * MfactkR * rmnRgM #newimag_rmnv_vecM = MfactkR * rmnRgM ###then deal with (kr)^(n+2*vecnum+2) part### newrmnvecM = newrmnvecM - rnImM * Mfact * po.Polynomial( [0, 0, 1]) + rmnRgM * RgMfact #return newreal_rmnv_vecM, newimag_rmnv_vecM #return the real and imaginary part separately return newrmnvecM
def test_pseudopoly_eval(r, rseed=42): rand = np.random.RandomState(rseed) x = rand.rand(10) p = rand.randint(-5, 5, 3) q = rand.randint(-5, 5, 2) rfac_p = (1 - x**2)**r rfac_q = (1 - x**2)**(r + 0.5) poly_p = pol.Polynomial(p) poly_q = pol.Polynomial(q) # empty poly = PseudoPolynomial(r=r) assert_allclose(poly(x), 0) # p only poly = PseudoPolynomial(p=p, r=r) assert_allclose(poly(x), rfac_p * poly_p(x)) # q only poly = PseudoPolynomial(q=q, r=r) assert_allclose(poly(x), rfac_q * poly_q(x)) # p and q poly = PseudoPolynomial(p=p, q=q, r=r) assert_allclose(poly(x), rfac_p * poly_p(x) + rfac_q * poly_q(x))
def B_1(N_1, z_k): r_k = z_k ret_value = poly.Polynomial([1]) for k in range(1, N_1 + 1): ret_value *= (poly.Polynomial([-r_k[k - 1], 1])) / np.sqrt( np.abs(r_k[k - 1])) return ret_value
def B_3(N_3, z_k): ret_value = poly.Polynomial([1]) for k in range(1, N_3 + 1): ret_value *= ( poly.Polynomial([np.abs(z_k[k - 1])**2, -2 * z_k[k - 1].real, 1]) / np.abs(z_k[k - 1])) return ret_value
def plot_spine_debug(pod, name): xs = [s.position.x for s in pod.slices] ys = [s.position.y for s in pod.slices] zs = [s.position.z for s in pod.slices] x_ffit = poly.Polynomial(pod.spine[0]) y_ffit = poly.Polynomial(pod.spine[1]) x_new = np.linspace(zs[0], zs[-1]) fig = plt.figure(figsize=[1, 4.8]) ax = fig.add_subplot(111, projection="3d") ax.plot(x_ffit(x_new), y_ffit(x_new), x_new) ax.plot(xs, ys, zs, linewidth=0.5) ax.plot( [s.position.x for s in pod.seeds], [s.position.y for s in pod.seeds], [s.position.z for s in pod.seeds], ms=3, linestyle="", markerfacecolor="None", markeredgecolor="green", alpha=0.6, marker="o", ) ax.view_init(10, 0) phi = np.linspace(0, 2 * np.pi, num=200) def update(phi): ax.view_init(10, phi * 180.0 / np.pi) ani = matplotlib.animation.FuncAnimation(fig, update, frames=phi) ani.save("plot_{}.gif".format(name), fps=18, dpi=196, writer="imagemagick")
def linFromPZ(poles=[], zeros=[], gain=1.0, wgain=0, ingain=None): """ @linFromPZ linFromPZ(poles,zeros,gain,ingain) Creates a system from the list of poles and zeros Parameters: poles : List of poles zeros : List of zeros Gain can be defined as: gain : Gain defined as the quotient of first num/den coef. wgain : Frequency where gain is defined igain : Gain defined at infinite freq. in high pass Returns a linblk object """ # Create new block s = linblk() s.den = P.Polynomial(P.polyfromroots(poles)) s.num = P.Polynomial(P.polyfromroots(zeros)) # Add gain if ingain == None: #curr = s.gain() curr = np.abs(s.eval(1j * wgain)) s.num = s.num * gain / curr else: curr = s.num.coef[-1] / s.den.coef[-1] s.num = s.num * gain / curr return s
def fit(self, xs, ys, ts=None): assert len(xs) == len(ys) if ts is None: ts = np.arange(len(xs)) coefs_x = poly.polyfit(ts, xs, self.degree) coefs_y = poly.polyfit(ts, ys, self.degree) self.poly_x = poly.Polynomial(coefs_x) self.poly_y = poly.Polynomial(coefs_y)
def set_coeff(self, new_coeff, index=None): # assume new coeff is just a new set of coefficients if index is None: self.coeffs = new_coeff self.degree = len(self.coeffs) - 1 self.polynomial = polynomial.Polynomial(new_coeff) else: self.coeffs[index] = new_coeff self.polynomial = polynomial.Polynomial(self.coeffs)
def __init__(self, num=[1.0], den=[1.0]): """ linblk Class constructor A new object can be created with: >> l1 = linblk() # H(s) = 1 block >> l2 = linblk([1],[1,1/p1]) # H(s) = 1 / ( 1 + s/p1 ) """ self.num = P.Polynomial(num) self.den = P.Polynomial(den)
def fit(self): xs = [s.position.x for s in self.slices] ys = [s.position.y for s in self.slices] zs = [s.position.z for s in self.slices] x_params = poly.polyfit(zs, xs, 3) y_params = poly.polyfit(zs, ys, 3) self.spine = (poly.Polynomial(x_params), poly.Polynomial(y_params))
def test_divmod(self): tquo = poly.Polynomial([1]) trem = poly.Polynomial([2]) quo, rem = divmod(self.p5, self.p1) assert_(quo == tquo and rem == trem) quo, rem = divmod(self.p5, [1, 2, 3]) assert_(quo == tquo and rem == trem) quo, rem = divmod([3, 2, 3], self.p1) assert_(quo == tquo and rem == trem)
def resample(self, trajs, poly_degree): """ :param trajs: list of demos :param poly_degree: degree of polynomal to smooth :return: """ t = [] alpha = 1.0 demos = [] # DWT distance function manhattan_distance = lambda x, y: np.abs(x - y) idx = np.argmax([l.shape[0] for l in trajs]) # get the decay term t.append(1.0) # for i in range(1, len(trajs[idx])): t.append(t[i - 1] - alpha * t[i - 1] * 0.01) # Update of decay term (ds/dt=-alpha s) ) t = np.array(t) # Smooth the data coefs = poly.polyfit(t, trajs[idx], 20) ffit = poly.Polynomial(coefs) # instead of np.poly1d x_fit = ffit(t) data = [] # scale all the data using DTW for ii, y in enumerate(trajs): dtw_data = {} d, cost_matrix, acc_cost_matrix, path = dtw( trajs[idx], y, dist=manhattan_distance) # d, cost_matrix, acc_cost_matrix, path = dtw(x_fit, y, dist=manhattan_distance) dtw_data["cost"] = d dtw_data["cost_matrix"] = cost_matrix dtw_data["acc_cost_matrix"] = acc_cost_matrix dtw_data["path"] = path data.append(dtw_data) #data_warp = [y[path[1]][:x_fit.shape[0]]] data_warp = [y[path[1]]] data_warp_rsp = signal.resample( data_warp[0], x_fit.shape[0]) # resample dtw output 188 points to 118 points #data_warp = [y[:][:x_fit.shape[0]]] #coefs = poly.polyfit(t, data_warp[0], 20) coefs = poly.polyfit(t, data_warp_rsp, 20) ffit = poly.Polynomial(coefs) # instead of np.poly1d y_fit = ffit(t) # y_fit = data_warp[0] y_fit = data_warp_rsp temp = [[np.array(ele)] for ele in y_fit.tolist()] temp = np.array(temp) demos.append(temp) return demos, data
def eval(self, x): """Evaluate the polynomial at the given value""" p, q = pol.Polynomial(self.p), pol.Polynomial(self.q) lmx2 = 1 - np.power(x, 2) num = p(x) + np.sqrt(lmx2) * q(x) denom = lmx2 ** self.r return num * denom
def __init__(self, xs=None, ys=None, ts=None, degree=None): if degree is None: self.degree = 1 else: self.degree = degree if xs is None and ys is None: self.poly_x = poly.Polynomial(np.zeros((self.degree + 1))) self.poly_y = poly.Polynomial(np.zeros((self.degree + 1))) else: self.fit(xs, ys, ts)
def rmnGreen_Taylor_Nmn_vec(n, k, R, rmnRgN_Bpol, rmnRgN_Ppol, rnImN_Bpol, rnImN_Ppol, rmnvecBpol, rmnvecPpol): """ act on the wave with radial representation Bpol(kr), Ppol(kr) by the spherical Green's fcn central subroutine for Arnoldi iteration starting from RgN rmnRgN_Bpol, rmnRgN_Ppol stores Taylor series representation of (kr)^{-(n-1)}*RgN(kr) with np polynomials rnImN_Bpol, rnImN_Ppol stores Taylor series representation of (kr)^{n+2} * Im{N(kr)} the real part of N(kr) is just RgN(kr) rmnvecBpol, rmnvecPpol store Taylor series representations of (kr)^{-(n-1)}*vec(kr), where vec is the current Arnoldi iterate the prefactors are there to efficiently use the numpy polynomial package, avoiding carrying a long list of zeros leading to large polynomials and slow running time N has radial dependence with negative powers so the prefactor lets use np polynomials just need to divide results after multiplication of N by (kr)^{n+2} """ kR = mp.mpf(k * R) ti = time.time() Nfact_prefactpow, Nfact = rmnNpol_dot(2 * n - 2, rmnRgN_Bpol, rmnRgN_Ppol, rmnvecBpol, rmnvecPpol) #Nfact_prefactpow should be 2*n+1 Nfact = po.Polynomial(Nfact) #Nfact = po.Polynomial(1j*Npol_dot(RgN_Bpol,RgN_Ppol, vecBpol,vecPpol)) RgNfact_intgd = rnImN_Bpol * rmnvecBpol + rnImN_Ppol * rmnvecPpol RgNfact_intgd = [0, 0] + RgNfact_intgd.coef.tolist() #print('1/r term size',RgNfact_intgd[2]) #check that the 1/r term of integrand is indeed 0 up to floating point error #print('r term size',RgNfact_intgd[4]) RgNfact_intgd = po.Polynomial( RgNfact_intgd[3:]) #n+2-(n-1) divide by (kr)^{3} to get true intgd #print(time.time()-ti,'in GTNv, 1') # print(len(RgNfact_intgd)) RgNfact = po.Polynomial(po.polyint(RgNfact_intgd.coef, lbnd=kR)) #print(time.time()-ti,'in GTNv, 2') ######first add on the Asym(G) part NfactkR = kR**Nfact_prefactpow * po.polyval(kR, Nfact.coef) newrmnBpol = 1j * NfactkR * rmnRgN_Bpol newrmnPpol = 1j * NfactkR * rmnRgN_Ppol #print(time.time()-ti,'in GTNv, 3') ######then add on the Sym(G) part newrmnBpol = newrmnBpol - Nfact * rnImN_Bpol newrmnPpol = newrmnPpol - Nfact * rnImN_Ppol newrmnBpol = newrmnBpol + RgNfact * rmnRgN_Bpol newrmnPpol = newrmnPpol + RgNfact * rmnRgN_Ppol - rmnvecPpol #the subtraction at end is delta fcn contribution #print(time.time()-ti,'in GTNv, 4') #print(len(newrmnBpol),len(newrmnPpol),len(RgNfact),len(Nfact),len(rmnRgN_Bpol),len(rmnRgN_Ppol),len(rnImN_Bpol), len(rnImN_Ppol)) return newrmnBpol, newrmnPpol
def GetHorizontalSmoothRecords(trackRecs, windowSize): """ This method uses the 11 points (for window size = 11) smoothing algorithm """ midSize = windowSize // 2 index = 0 numPoints = len(trackRecs) SmoothRecs = [rec for rec in trackRecs] while index <= numPoints - windowSize: xArray = [] yArray = [] for i in range(index, index + windowSize): xArray.append(trackRecs[i].x) yArray.append(trackRecs[i].y) coefs = poly.polyfit(xArray, yArray, 2) ffit = poly.Polynomial(coefs) SmoothRecs[index + midSize].y = ffit(xArray[midSize]) if index == 0: for j in range(1, midSize): SmoothRecs[j].y = ffit(xArray[j]) if index == numPoints - windowSize: for k in range(midSize + 1, len(xArray) - 1): SmoothRecs[index + k].y = ffit(xArray[k]) index +=1 return SmoothRecs
def GetVerticalSmoothRecords(trackRecs, windowSize): """ This method uses the 11 points (for window size = 11) smoothing algorithm """ midSize = windowSize // 2 index = 0 numPoints = len(trackRecs) SmoothedRecs = deepcopy(trackRecs) while index <= numPoints - windowSize: kpArray = [] zArray = [] for i in range(index, index + windowSize): kpArray.append(trackRecs[i].kp) zArray.append(trackRecs[i].z) coefs = poly.polyfit(kpArray, zArray, 2) ffit = poly.Polynomial(coefs) SmoothedRecs[index + midSize].z = ffit(kpArray[midSize]) if index == 0: for j in range(1, midSize): SmoothedRecs[j].z = ffit(kpArray[j]) if index == numPoints - windowSize: for k in range(midSize + 1, len(kpArray) - 1): SmoothedRecs[index + k].z = ffit(kpArray[k]) index +=1 return SmoothedRecs
def polycntm(x, y, deg, rtol=1e-3, fullout=False, maxiter=50): ''' Fits a polynomial continuum of degree deg to the data ''' #Initializing Variables p = npp.Polynomial([0] * (deg + 1)) keepgoing = True counter = 0 datalist, linelist, reslist, gpmslist = [y], [], [], [] #Iterations while keepgoing and counter < maxiter: pold, p = p, npp.Polynomial.fit(x, y, deg) test_result, test_bool = ct.midpnttest(pold.coef, p.coef, rtol) if np.all(test_bool): break linelist.append(p) y, res, params = yupdate(x, y, p) datalist.append(y) reslist.append(res) gpmslist.append(params) counter += 1 #legacy code used to create plots of each iteration of yupdate #if counter >= maxiter: # print("Exceeded maximum amount of itinerations") # print(test_result) #if fullout: # datalist.__delitem__(len(datalist)-1) # return p, datalist, linelist, reslist, gpmslist return p
def poly_lagrange(i, alldata: pd.DataFrame): if i < 3 or i > len(alldata): logging.warning('"outside fit interval"') data = alldata.iloc[i - 3:i + 5, :] mid = data.iloc[3, :] scale = data.iloc[7, :] - data.iloc[0, :] scaled_data = (data - mid) / scale polys_svid = {} vel_svid = {} time_col = scaled_data.iloc[:, 0] for dfcol in scaled_data.columns: if dfcol != 'UTC Time': coefs = (P.Polynomial( lagrange(np.array(time_col), np.array(scaled_data[dfcol]))).coef)[::-1] polys_svid[dfcol] = coefs vel_svid[dfcol] = P.polyder(coefs) return { i: { 'mid': mid, 'scale': scale, 'polys_svid': polys_svid, 'vel_svid': vel_svid } }
def calculate_imitation_metric(file_name): angles = get_data() demos = [angles["Lhip"], angles["Lknee"], angles["Lankle"]] runner = TPGMMRunner.TPGMMRunner(file_name) path = runner.run() print(path[:,0]) alpha = 1.0 manhattan_distance = lambda x, y: abs(x - y) costs = [] for i in range(3): imitation = path[:, i] T = len(imitation) M = len(demos[i]) metric = 0.0 t = [] t.append(1.0) for k in range(1, T): t.append(t[k - 1] - alpha * t[k - 1] * 0.01) # Update of decay term (ds/dt=-alpha s) ) t = np.array(t) for m in range(M): d, cost_matrix, acc_cost_matrix, path_im = dtw(imitation, demos[i][m], dist=manhattan_distance) data_warp = [demos[i][m][path_im[1]][:imitation.shape[0]]] coefs = poly.polyfit(t, data_warp[0], 20) ffit = poly.Polynomial(coefs) y_fit = ffit(t) metric += np.sum(abs(y_fit - imitation.flatten())) costs.append(metric / (M * T)) print("cost ") print(costs) return costs
def fitFunc(name, order, func, domain, fixed, inputName): (mn, mx) = domain x = mn + (mx - mn) * (np.arange(FIT_SAMPLES * 1.0) / (FIT_SAMPLES - 1)) y = func(x) # fit polynomial (with fixed points) coefs = polyfitWithFixedPoints(order, x, y, fixed, func(np.array(fixed))) fitted = poly.Polynomial(coefs) # compute max error ex = mn + (mx - mn) * (np.arange(ERR_SAMPLES * 1.0) / (ERR_SAMPLES - 1)) ey = func(ex) err = ey - fitted(ex) errmax = np.max(err) # print polynomial error and code print(f' order {order}: {-np.log2(errmax):0.4} bits') for ndx in range(len(coefs)): coef = coefs[ndx] if np.abs(coef) < 1e-12: coef = 0 print(f" const int C{ndx} = {int(coef * (1 << 30))}; // {coef}") print(f" int y = {genQmul(inputName, 1, order)} + C0;") print() return fitted
def getPixelToWavelength(self, npixels, pxs): """ Return the lookup table pixel number of the CCD -> wavelength observed. npixels (1 <= int): number of pixels on the CCD (horizontally), after binning. pxs (0 < float): pixel size in m (after binning) return (list of floats): pixel number -> wavelength in m """ pl = list(self._wlp) pl[0] = self.position.value["wavelength"] # This polynomial is from m (distance from centre) to m (wavelength), # but we need from px (pixel number on spectrum) to m (wavelength). So # we need to convert by using the density and quantity of pixels # wl = pn(x) # x = a + bx' = pn1(x') # wl = pn(pn1(x')) = pnc(x') # => composition of polynomials # with "a" the distance of the centre of the left-most pixel to the # centre of the image, and b the density in meters per pixel. # distance from the pixel 0 to the centre (in m) distance0 = -(npixels - 1) / 2 * pxs pnc = self.polycomp(pl, [distance0, pxs]) npn = polynomial.Polynomial( pnc, # pylint: disable=E1101 domain=[0, npixels - 1], window=[0, npixels - 1]) return npn.linspace(npixels)[1]
def calculate_imitation_metric_1(demos, imitation): M = len(demos) T = len(imitation) imitation = np.array(imitation) metric = 0.0 paths = [] t = [] t.append(1.0) alpha = 1.0 manhattan_distance = lambda x, y: np.abs(x - y) for i in range(1, T): t.append( t[i - 1] - alpha * t[i - 1] * 0.01) # Update of decay term (ds/dt=-alpha s) ) t = np.array(t) for m in range(M): d, cost_matrix, acc_cost_matrix, path = dtw(imitation, demos[m], dist=manhattan_distance) data_warp = [demos[m][path[1]][:imitation.shape[0]]] coefs = poly.polyfit(t, data_warp[0], 20) ffit = poly.Polynomial(coefs) y_fit = ffit(t) paths.append(y_fit) metric += np.sum(np.sqrt(np.power(y_fit - imitation.flatten(), 2))) return paths, metric / (M * T)
def embed_polynomials_l2(p1, p2, l=1.0, calc_score=False): """Find lambda for inclusion p1->p2, i.e., such that p1(t) ~ p2(t/lambda), |t|<l. Params: p1, p2 -- instances of polynomial.Polynomial class l -- defines embedding segment [-l,l] """ # we minimize S(mu) = int_{-l}^l |p1(t)-p2(mu t)|^2 dt # S(mu) is a polynomial in mu: sum_{i,j} (a_i - b_i*mu^i)(a_j - b_j*mu^j)int_{l}^l t^{i+j} a, b, d = p1.coef, p2.coef, p1.degree() assert p2.degree() == d s_coef = np.zeros(2 * d + 1) for i in range(d + 1): for j in range(d + 1): # (a_i - b_i*mu^i)(a_j - b_j*mu^j)int_{l}^l t^{i+j} # int t^k = t^{k+1)|_{-l}^l = 0 if k+1 is even else 2*l^{k+1}/(k+1) if (i + j + 1) % 2 == 0: continue int_t = 2 * l**(i + j + 1) / (i + j + 1) s_coef[0] += int_t * a[i] * a[j] s_coef[i] -= int_t * b[i] * a[j] s_coef[j] -= int_t * a[i] * b[j] s_coef[i + j] += int_t * b[i] * b[j] s_poly = polynomial.Polynomial(s_coef) min_value, min_mu = minimize_polynomial(s_poly, -1, 1) if not calc_score: return 1 / min_mu if min_value == 0: score = 10000 else: score = s_poly(0) / min_value return {'lambda': 1 / min_mu, 'score': score}
def __init__(self, information_length: int, polynomial: int): log.debug("Create cyclical _coder") self.lengthInformation = information_length self.lengthAdditional = int(math.log2(polynomial)) self.lengthTotal = self.lengthInformation + self.lengthAdditional self._polynomial = plm.Polynomial(int_to_bit_list(polynomial, rev=True))
def clean(self, ratio=1000.0): """ Eliminates poles and zeros that cancel each other A pole and a zero are considered equal if their distance is lower than 1/ratio its magnitude ratio : Ratio to cancel PZ (default = 1000) Return a new object """ gain = self.gain() poles = self.poles() zeros = self.zeros() # Return if there are no poles or zeros if len(poles) == 0: return if len(zeros) == 0: return outPoles = [] # Empty pole list for pole in poles: outZeros = [] # Empty zero list found = False for zero in zeros: if not found: distance = np.absolute(pole - zero) threshold = (np.absolute(pole) + np.absolute(zero)) / (2.0 * ratio) if distance > threshold: outZeros.append(zero) else: found = True else: outZeros.append(zero) if not found: outPoles.append(pole) zeros = outZeros poles = outPoles s = linblk() s.den = P.Polynomial(P.polyfromroots(poles)) s.num = P.Polynomial(P.polyfromroots(zeros)) # Add gain # curr = s.num.coef[0]/s.den.coef[0] curr = s.gain() s.num = s.num * gain / curr return s
def get_wavelength_per_pixel(da): """ Computes the wavelength for each pixel along the C dimension :param da: (model.DataArray of shape C...): the DataArray with metadata either MD_WL_POLYNOMIAL or MD_WL_LIST :return: (list of float of length C): the wavelength (in m) for each pixel in C :raises: AttributeError: if no metadata is present KeyError: if no metadata is available ValueError: if the metadata doesn't provide enough information """ if not hasattr(da, 'metadata'): raise AttributeError("No metadata found in data array") # check dimension of data dims = da.metadata.get(model.MD_DIMS, "CTZYX"[-da.ndim:]) if len(dims) == 3 and dims == "YXC" and da.shape[2] in (3, 4): # RGB? # This is a hack to handle RGB projections of CX (ie, line spectrum) # and CT (temporal spectrum) data. In theory the MD_DIMS should be # XCR and TCR (where the R is about the RGB channels). However, # this is confusing, and the GUI would not know how to display it. ci = 1 else: try: ci = dims.index("C") # get index of dimension C except ValueError: raise ValueError( "Dimension 'C' not in dimensions, so skip computing wavelength list." ) # MD_WL_LIST has priority if model.MD_WL_LIST in da.metadata: wl = da.metadata[model.MD_WL_LIST] if len(wl) != da.shape[ci]: raise ValueError( "Length of wavelength list does not match length of wavelength data." ) return wl elif model.MD_WL_POLYNOMIAL in da.metadata: pn = da.metadata[model.MD_WL_POLYNOMIAL] pn = polynomial.polytrim(pn) if len(pn) >= 2: npn = polynomial.Polynomial( pn, #pylint: disable=E1101 domain=[0, da.shape[ci] - 1], window=[0, da.shape[ci] - 1]) ret = npn.linspace(da.shape[ci])[1] return ret.tolist() else: # a polynomial of 0 or 1 value is useless raise ValueError("Wavelength polynomial has only %d degree" % len(pn)) raise KeyError("No MD_WL_* metadata available")
def plot_GNmn_image(n, k, R, rmnvecBpol, rmnvecPpol, klim=30, Taylor_tol=1e-4): kR = mp.mpf(k * R) pow_jndiv, coe_jndiv, pow_djn, coe_djn, pow_yndiv, coe_yndiv, pow_dyn, coe_dyn = get_Taylor_jndiv_djn_yndiv_dyn( n, kR, klim, tol=Taylor_tol) print(len(pow_jndiv)) nfac = mp.sqrt(n * (n + 1)) pow_jndiv = np.array(pow_jndiv) coe_jndiv = np.array(coe_jndiv) pow_djn = np.array(pow_djn) coe_djn = np.array(coe_djn) rmnRgN_Bpol = mp.one * np.zeros(pow_jndiv[-1] + 1 - (n - 1)) rmnRgN_Ppol = mp.one * np.zeros(pow_jndiv[-1] + 1 - (n - 1)) rmnRgN_Bpol[pow_jndiv - (n - 1)] += coe_jndiv rmnRgN_Bpol[pow_djn - (n - 1)] += coe_djn rmnRgN_Ppol[pow_jndiv - (n - 1)] += coe_jndiv rmnRgN_Ppol *= nfac rmnRgN_Bpol = po.Polynomial(rmnRgN_Bpol) rmnRgN_Ppol = po.Polynomial(rmnRgN_Ppol) rnImN_Bpol = mp.one * np.zeros(pow_yndiv[-1] + 1 + (n + 2), dtype=np.complex) rnImN_Ppol = mp.one * np.zeros(pow_yndiv[-1] + 1 + (n + 2), dtype=np.complex) pow_yndiv = np.array(pow_yndiv) pow_dyn = np.array(pow_dyn) rnImN_Bpol[(n + 2) + pow_yndiv] += coe_yndiv rnImN_Bpol[(n + 2) + pow_dyn] += coe_dyn rnImN_Ppol[(n + 2) + pow_yndiv] += coe_yndiv rnImN_Ppol *= nfac rnImN_Bpol = po.Polynomial(rnImN_Bpol) rnImN_Ppol = po.Polynomial(rnImN_Ppol) rmnBimage, rmnPimage = rmnGreen_Taylor_Nmn_vec(n, k, R, rmnRgN_Bpol, rmnRgN_Ppol, rnImN_Bpol, rnImN_Ppol, rmnvecBpol, rmnvecPpol) print('real part') plot_rmnNpol(n, mp_re(rmnBimage.coef), mp_re(rmnPimage.coef), kR * 0.01, kR) print('imag part') plot_rmnNpol(n, mp_im(rmnBimage.coef), mp_im(rmnPimage.coef), kR * 0.01, kR)
def main(): print("Лабораторная работа №6", "Приближенное вычисление интегралов при помощи КФ НАСТ", "-----------------------------------------------------", sep='\n', end='\n\n') print(f.__doc__) print(w.__doc__) print("[a, b] = [{0}, {1}]".format(a, b)) N = input_value("Введите N: ", value_type=int, check=lambda N: N > 0) m = input_value("Введите число шагов m составной КФ: ", value_type=int, check=lambda m: m > 0) print() J_gauss_ref = gauss_mult(lambda x: f(x) * w(x), a, b, N, m) print("J =", J_gauss_ref, end='\n\n') mu = [simpson(lambda x: w(x) * (x**k), a, b, 100000) for k in range(2 * N)] print("Моменты весовой функции:", mu) aval = np.linalg.solve([mu[i:i + N] for i in range(N)], [-x for x in mu[-N:]]) P = polynomial.Polynomial(aval) + polynomial.Polynomial( polynomial.polyx)**N print("Ортогональный w_n(x) =", print_polynomial(P)) xs = P.roots() print("Узлы КФ типа Гаусса:", xs) W = polynomial.Polynomial([1]) for x_i in xs: W *= polynomial.Polynomial([-x_i, 1]) W_prime = W.deriv() As = [ gauss_mult(lambda x: w(x) * W(x) / ((x - x_i) * W_prime(x_i)), a, b, N, m) for x_i in xs ] print("Коэффициенты КФ:", As) J_gauss = sum(A * f(x) for x, A in zip(xs, As)) print("J =", J_gauss)
def get_labeled_point(line): items = line.strip().split() y = items[0] x = items[1:] # return LabeledPoint(y, x) ## this explicitly maps each example to a higher dimensional space ## namely the space of a degree 2 polynomial kernel poly = npp.Polynomial([float(_) for _ in x]) return LabeledPoint(y, (poly * poly).coef)