def get_immigration2(S, starting_age, ending_age, E): ''' Parameters: S - Number of age cohorts starting age - initial age of cohorts Returns: im_array - S x 1 array of immigration rates for each age cohort child_imm_rate - starting_age x 1 array of immigration rates for children ''' imm_rate_condensed1 = get_immigration1( S, starting_age, ending_age, pop_2010, pop_2011, E) imm_rate_condensed2 = get_immigration1( S, starting_age, ending_age, pop_2011, pop_2012, E) imm_rate_condensed3 = get_immigration1( S, starting_age, ending_age, pop_2012, pop_2013, E) im_array = ( imm_rate_condensed1 + imm_rate_condensed2 + imm_rate_condensed3) / 3.0 poly_imm = poly.polyfit(np.linspace( 1, ending_age, ending_age-1), im_array[:-1], deg=18) poly_imm_int = poly.polyint(poly_imm) child_imm_rate = poly.polyval(np.linspace( 0, starting_age, E+1), poly_imm_int) imm_rate = poly.polyval(np.linspace( starting_age, ending_age, S+1), poly_imm_int) child_imm_rate = np.diff(child_imm_rate) imm_rate = np.diff(imm_rate) imm_rate[-1] = 0.0 return imm_rate, child_imm_rate
def mobileye_callback(mobileye_pb): global nx, ny, local_seg_x, local_seg_y global left_marker_x, left_marker_y global right_marker_x, right_marker_y global local_smooth_seg_x, local_smooth_seg_y global local_smooth_seg_x2, local_smooth_seg_y2 mobileye_provider.update(mobileye_pb) mobileye_provider.process_obstacles() vx = localization_provider.localization_pb.pose.position.x vy = localization_provider.localization_pb.pose.position.y heading = localization_provider.localization_pb.pose.heading local_seg_x, local_seg_y = routing_provider.get_local_segment(vx, vy, heading) local_smooth_seg_x, local_smooth_seg_y = \ routing_provider.get_local_segment_spline(vx, vy, heading) left_marker_coef = mobileye_provider.left_lm_coef left_marker_x = [] left_marker_y = [] for x in range(int(mobileye_provider.left_lane_marker_range)): y = polyval(x, left_marker_coef) left_marker_x.append(x) left_marker_y.append(-y) right_marker_coef = mobileye_provider.right_lm_coef right_marker_x = [] right_marker_y = [] for x in range(int(mobileye_provider.right_lane_marker_range)): y = polyval(x, right_marker_coef) right_marker_x.append(x) right_marker_y.append(-y)
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 smoothing_poly_lnprior(poly, degree, xmin, xmax, gamma=1): """ A smoothing prior that suppresses higher order derivatives of a polynomial, poly = a + b x + c x*x + ..., described by a vector of its coefficients, [a, b, c, ...]. Functional form is: ln p(poly coeffs) = -gamma * integrate( (diff(poly(x), x, degree))^2, x, xmin, xmax) So it takes the `degree`th derivative of the polynomial, squares it, integrates that from xmin to xmax, and scales by -gamma. """ # Take the `degree`th derivative of the polynomial. poly_diff = P.polyder(poly, m=degree) # Square the polynomial. poly_diff_sq = P.polypow(poly_diff, 2) # Take the indefinite integral of the polynomial. poly_int_indef = P.polyint(poly_diff_sq) # Evaluate the integral at xmin and xmax to get the definite integral. poly_int_def = ( P.polyval(xmax, poly_int_indef) - P.polyval(xmin, poly_int_indef) ) # Scale by -gamma to get the log prior lnp = -gamma * poly_int_def return lnp
def _transform(self, m): # Set model parameters alpha = self.slope sig1,sig2 = m[0],m[1] c = m[2:] if self.logSigma: sig1, sig2 = np.exp(sig1), np.exp(sig2) #2D if self.mesh.dim == 2: X = self.mesh.gridCC[:,0] Y = self.mesh.gridCC[:,1] if self.normal =='X': f = polynomial.polyval(Y, c) - X elif self.normal =='Y': f = polynomial.polyval(X, c) - Y else: raise(Exception("Input for normal = X or Y or Z")) #3D elif self.mesh.dim == 3: X = self.mesh.gridCC[:,0] Y = self.mesh.gridCC[:,1] Z = self.mesh.gridCC[:,2] if self.normal =='X': f = polynomial.polyval2d(Y, Z, c.reshape((self.order[0]+1,self.order[1]+1))) - X elif self.normal =='Y': f = polynomial.polyval2d(X, Z, c.reshape((self.order[0]+1,self.order[1]+1))) - Y elif self.normal =='Z': f = polynomial.polyval2d(X, Y, c.reshape((self.order[0]+1,self.order[1]+1))) - Z else: raise(Exception("Input for normal = X or Y or Z")) else: raise(Exception("Only supports 2D")) return sig1+(sig2-sig1)*(np.arctan(alpha*f)/np.pi+0.5)
def fit_polynomial(data, ln_xray_property, deg, whatIsFit): """Fit a DEG-order polynomial in x, y space. numpy.polynomial.polinomial.polyfit() returns coefficients, from 0th order first to N-th order last (note that this is *opposite* from how np.polyfit behaves!). """ radiuspackage = extrapolate_radius(data) r = radiuspackage[0] ln_r = radiuspackage[1] r_fine = radiuspackage[2] ln_r_fine = radiuspackage[4] print("Now fitting |" + " " + make_number_ordinal(deg) + " order polynomial to " + whatIsFit) coeffs = poly.polyfit(ln_r, ln_xray_property, deg) # polyval() is used to assemble cubic fit: # $p(x) = c_0 + c_1 x + c_2 x^2 + c3 x^3$ # where c_n are the coeffs returned by polyfit() ln_fit = poly.polyval(ln_r, coeffs) fit = np.exp(ln_fit) # Now use these coefficients to extrapolate fit # across larger radius ln_fit_fine = poly.polyval(ln_r_fine, coeffs) fit_fine = np.exp(ln_fit_fine) fitpackage = (fit, r, fit_fine, r_fine, coeffs) return fitpackage
def polynomial(ny, nx, order=2, nz=None): coeffs = poly.polyfit(nx,ny,order) if nz is not None: continuum = poly.polyval(nz, coeffs) else: continuum = poly.polyval(nx, coeffs) return continuum
def poly_solve(poly, tau, line, terminate): # Derivative if poly.size > 3 and np.abs(poly[-1]) < np.finfo(float).eps: poly[-1] = 0.0 der = p.polyder(poly) # Stationary Points stat_x = p.polyroots(der) stat_f = p.polyval(stat_x, poly) stat_x_feasible = stat_x[terminate.feasible(line, stat_x, stat_f)] stat_f_feasible = stat_f[terminate.feasible(line, stat_x, stat_f)] # Bounds Extrema bound_x = tau bound_f = p.polyval(bound_x, poly) bound_x_feasible = bound_x[terminate.feasible(line, bound_x, bound_f)] bound_f_feasible = bound_f[terminate.feasible(line, bound_x, bound_f)] # Termination Extrema term_x = terminate.extrema(line, poly) if term_x.size > 0: term_f = p.polyval(term_x, poly) else: term_f = np.array([]) # Combine comb_x = np.concatenate((stat_x_feasible, bound_x_feasible, term_x)) comb_f = np.concatenate((stat_f_feasible, bound_f_feasible, term_f)) # Bounds Filter comb_final_x = comb_x[np.logical_and(bound_x[0] <= comb_x, comb_x <= bound_x[1])] comb_final_f = comb_f[np.logical_and(bound_x[0] <= comb_x, comb_x <= bound_x[1])] # Return Result if comb_final_x.size == 0: return None else: return comb_final_x[np.argmin(comb_final_f)]
def plot(x_values,y_values,polylist,result): fig=plt.figure() Color=["b","g","r","y","m"] Legend=[] for i in range(len(polylist)): x=list(arange(min(x_values)-1,max(x_values)+1,0.01)) y=list(map(lambda num:P.polyval(num,polylist[i]),x)) plt.plot(x,y,linewidth=2.0,color=Color[i%5]) Legend.append(mpatches.Patch(color=Color[i%5],label="Polynomial "+str(i+1))) x=list(arange(min(x_values)-1,max(x_values)+1,0.01)) y=list(map(lambda num:P.polyval(num,array(result)),x)) plt.plot(x,y,linewidth=3.0,color="k") Legend.append(mpatches.Patch(color="k",label="Final polynomial")) x=x_values y=list(map(lambda num:P.polyval(num,array(result)),x)) plt.plot(x,y,"o",color="c") plt.axvline(0,color="k") plt.axhline(0,color="k") plt.xlabel(" x values ") plt.ylabel("f(x) values") plt.legend(handles=Legend) dir=sys.path[0] dir+="\\app\\static\\graph.png" if os.path.exists(dir): os.remove(dir) plt.savefig(dir, format="png", dpi=fig.dpi) else: plt.savefig(dir, format="png", dpi=fig.dpi)
def integrate(func, points): params_guess = [1, 1] a, b = opt.fsolve(fit_exp_right, params_guess, args=([40, poly.polyval(40, func)], [49.5, .0007])) func_int = poly.polyint(func) integral = np.empty(points.shape) integral[points <= 40] = poly.polyval(points[points <= 40], func_int) integral[points > 40] = poly.polyval(40, func_int) + exp_int(points[points > 40], a, b) return np.diff(integral)
def test_spec_calib(self): """ Check that the calibration of the wavelength make _some_ sense It's not expected that the calibration is correct, but it should be at least some how logical. """ # the wavelength bandwidth across the CCD should be pretty much constant # independent of the resolution (not exactly, as the wavelength is for # the center of the pixel, so the bigger are the pixels, the closer are # the centers) # horizontal maximum res/min binning binning = (self.spectrometer.binning.range[0][0], # min self.spectrometer.binning.range[1][1]) # max self.spectrometer.binning.value = binning res = self.spectrometer.resolution.range[1] # max self.spectrometer.resolution.value = res res = self.spectrometer.resolution.value # actual value # read calibration data = self.spectrometer.data.get() pn = data.metadata[model.MD_WL_POLYNOMIAL] if len(pn) <= 1: logging.warning("Wavelength polynomial is of very low quality: length = %d", len(pn)) # pixel 0 to pixel N +1 => whole CCD wl_bw_max_res = polynomial.polyval(res[0], pn) - polynomial.polyval(0, pn) cwl_max_res = (polynomial.polyval(0, pn) + polynomial.polyval(res[0]-1, pn)) / 2 logging.info("Wl bw = %f nm, center = %f nm", wl_bw_max_res * 1e9, cwl_max_res * 1e9) cwl_max_res_s = (polynomial.polyval(res[0]//2, pn) + polynomial.polyval(math.ceil(res[0]/2), pn)) / 2 # do they make any sense? # should be a monotonic function self.assertTrue(cwl_max_res / 1.1 < cwl_max_res_s and cwl_max_res_s < cwl_max_res * 1.1) # centre wavelength should about (~30%) the same as the wavelength position exp_cwl = self.spectrograph.position.value["wavelength"] self.assertTrue(exp_cwl / 1.3 < cwl_max_res and cwl_max_res < exp_cwl * 1.3) # never heard of bandwidth higher than a few 1000 nm self.assertGreater(wl_bw_max_res, 0) self.assertLess(wl_bw_max_res, 10000e-9) # 8 times smaller resolution binning = (min(binning[0] * 8, self.spectrometer.binning.range[1][0]), binning[1]) self.spectrometer.binning.value = binning res = self.spectrometer.resolution.value # new resolution # read calibration data = self.spectrometer.data.get() pn = data.metadata[model.MD_WL_POLYNOMIAL] # pixel 0 to pixel N +1 => whole CCD wl_bw_low_res = polynomial.polyval(res[0], pn) - polynomial.polyval(0, pn) cwl_low_res = (polynomial.polyval(0, pn) + polynomial.polyval(res[0]-1, pn)) / 2 self.assertAlmostEqual(wl_bw_low_res, wl_bw_max_res, 2) self.assertAlmostEqual(cwl_low_res, cwl_max_res)
def current_latlon(): point = {} point['lat'] = lat point['lon'] = lon points = [point] utm_vehicle_x, utm_vehicle_y = projector(lon, lat) right_lane = [] left_lane = [] if mobileye_pb is not None: rc0 = mobileye_pb.lka_768.position rc1 = mobileye_pb.lka_769.heading_angle rc2 = mobileye_pb.lka_768.curvature rc3 = mobileye_pb.lka_768.curvature_derivative right_lane_marker_range = mobileye_pb.lka_769.view_range right_lane_marker_coef = [rc0, rc1, rc2, rc3] for x in range(int(right_lane_marker_range)): y = -1 * polyval(x, right_lane_marker_coef) newx = x * math.cos(heading) - y * math.sin(heading) newy = y * math.cos(heading) + x * math.sin(heading) plon, plat = projector(utm_vehicle_x + newx, utm_vehicle_y + newy, inverse=True) right_lane.append({'lat': plat, 'lng': plon}) # print right_lane lc0 = mobileye_pb.lka_766.position lc1 = mobileye_pb.lka_767.heading_angle lc2 = mobileye_pb.lka_766.curvature lc3 = mobileye_pb.lka_766.curvature_derivative left_lane_marker_range = mobileye_pb.lka_767.view_range left_lane_marker_coef = [lc0, lc1, lc2, lc3] for x in range(int(left_lane_marker_range)): y = -1 * polyval(x, left_lane_marker_coef) newx = x * math.cos(heading) - y * math.sin(heading) newy = y * math.cos(heading) + x * math.sin(heading) plon, plat = projector(utm_vehicle_x + newx, utm_vehicle_y + newy, inverse=True) left_lane.append({'lat': plat, 'lng': plon}) points.append(right_lane) points.append(left_lane) planned_path = [] if planning_pb is not None: for traj_point in planning_pb.trajectory_point: x = traj_point.path_point.x y = traj_point.path_point.y newx = x * math.cos(heading) - y * math.sin(heading) newy = y * math.cos(heading) + x * math.sin(heading) plon, plat = projector(utm_vehicle_x + newx, utm_vehicle_y + newy, inverse=True) planned_path.append({'lat': plat, 'lng': plon}) points.append(planned_path) return jsonify(points)
def mobileye_callback(mobileye_pb): global nx, ny, local_seg_x, local_seg_y global left_marker_x, left_marker_y global right_marker_x, right_marker_y global local_smooth_seg_x, local_smooth_seg_y global history_x, history_y mobileye_provider.update(mobileye_pb) mobileye_provider.process_obstacles() if localization_provider.localization_pb is None: return vx = localization_provider.localization_pb.pose.position.x vy = localization_provider.localization_pb.pose.position.y heading = localization_provider.localization_pb.pose.heading speed = chassis_provider.get_speed_mps() mobileye_provider.process_history(heading, speed) hist_x = [] hist_y = [] for line in mobileye_provider.history_left_lines: if line is None: continue x = [] y = [] for p in line.coords: x.append(p[0]) y.append(-p[1]) hist_x.append(x) hist_y.append(y) history_x = hist_x history_y = hist_y local_seg_x, local_seg_y = routing_provider.get_local_segment(vx, vy, heading) local_smooth_seg_x, local_smooth_seg_y = routing_provider.get_local_segment_spline( vx, vy, heading) left_marker_coef = mobileye_provider.left_lm_coef left_marker_x = [] left_marker_y = [] for x in range(int(mobileye_provider.left_lane_marker_range)): y = polyval(x, left_marker_coef) left_marker_x.append(x) left_marker_y.append(-y) right_marker_coef = mobileye_provider.right_lm_coef right_marker_x = [] right_marker_y = [] for x in range(int(mobileye_provider.right_lane_marker_range)): y = polyval(x, right_marker_coef) right_marker_x.append(x) right_marker_y.append(-y)
def deriv(self, m, v=None): alpha = self.slope sig1, sig2, c = m[0], m[1], m[2:] if self.logSigma: sig1, sig2 = np.exp(sig1), np.exp(sig2) # 2D if self.mesh.dim == 2: X = self.mesh.gridCC[self.actInd, 0] Y = self.mesh.gridCC[self.actInd, 1] if self.normal == 'X': f = polynomial.polyval(Y, c) - X V = polynomial.polyvander(Y, len(c)-1) elif self.normal == 'Y': f = polynomial.polyval(X, c) - Y V = polynomial.polyvander(X, len(c)-1) else: raise(Exception("Input for normal = X or Y or Z")) # 3D elif self.mesh.dim == 3: X = self.mesh.gridCC[self.actInd, 0] Y = self.mesh.gridCC[self.actInd, 1] Z = self.mesh.gridCC[self.actInd, 2] if self.normal == 'X': f = (polynomial.polyval2d(Y, Z, c.reshape((self.order[0]+1, self.order[1]+1))) - X) V = polynomial.polyvander2d(Y, Z, self.order) elif self.normal == 'Y': f = (polynomial.polyval2d(X, Z, c.reshape((self.order[0]+1, self.order[1]+1))) - Y) V = polynomial.polyvander2d(X, Z, self.order) elif self.normal == 'Z': f = (polynomial.polyval2d(X, Y, c.reshape((self.order[0]+1, self.order[1]+1))) - Z) V = polynomial.polyvander2d(X, Y, self.order) else: raise(Exception("Input for normal = X or Y or Z")) if self.logSigma: g1 = -(np.arctan(alpha*f)/np.pi + 0.5)*sig1 + sig1 g2 = (np.arctan(alpha*f)/np.pi + 0.5)*sig2 else: g1 = -(np.arctan(alpha*f)/np.pi + 0.5) + 1.0 g2 = (np.arctan(alpha*f)/np.pi + 0.5) g3 = Utils.sdiag(alpha*(sig2-sig1)/(1.+(alpha*f)**2)/np.pi)*V if v is not None: return sp.csr_matrix(np.c_[g1, g2, g3]) * v return sp.csr_matrix(np.c_[g1, g2, g3])
def __linfit(self,bottom,test): cv = 299792.458 fit = pol.polyfit(self.group.lmbd[self.idx[bottom]],self.data[:,bottom].T,2) a,b,c = fit[2,:],fit[1,:],fit[0,:] lmin = -b/(2*a) bot = pol.polyval(lmin,fit,tensor=False) pred = pol.polyval(self.group.lmbd[test],fit) vel = cv*(lmin-self.cent)/self.cent # Error of fit with extra error term to penalize fits # that gets wildly off center, with extra weight so it *hurts* err = np.sqrt( np.mean( (self.data[:,test]-pred)**2,axis=1) + 2*(lmin-self.cent)**2 ) return vel,bot,err
def integrate(func, points, j): params_guess = [1, 1] # fit_to = j/2.0 fit_to = poly.polyval(70, func) * .5 a, b = opt.fsolve(fit_exp_right, params_guess, args=( [70, poly.polyval(70, func)], [100, fit_to])) func_int = poly.polyint(func) integral = np.empty(points.shape) integral[points <= 70] = poly.polyval(points[points <= 70], func_int) integral[points > 70] = poly.polyval(70, func_int) + exp_int( points[points > 70], a, b) vals = np.diff(integral) # vals[50:] = np.ones(30) * vals[50] return vals
def test_polyvander(self) : # check for 1d x x = np.arange(3) v = poly.polyvander(x, 3) assert_(v.shape == (3,4)) for i in range(4) : coef = [0]*i + [1] assert_almost_equal(v[...,i], poly.polyval(x, coef)) # check for 2d x x = np.array([[1,2],[3,4],[5,6]]) v = poly.polyvander(x, 3) assert_(v.shape == (3,2,4)) for i in range(4) : coef = [0]*i + [1] assert_almost_equal(v[...,i], poly.polyval(x, coef))
def evalpolyfit(coefs, num_points=100, spacing=None, lengths=None): """ Evaluate the polynomial fit at discrete points. There are four options for constructing the spline: 1) Same number of points, variable lengths, variable spacing => must specify only num_points (default) 2) Variable number of points, variable lengths, same spacing => must specify only spacing 3) Same number of points, same lengths, same spacing => must specify length and either spacing or num_points args: coefs (dict): dict of coefficients (output of makepolyfit) kwargs: num_points (int): number of points in final midline spacing (int): spacing between points lengths (dict): dict of desired lengths of each midline returns: nosedist (dict): dict of uniformly-sampled distances from nose to tail nosetail (dict): dict of midlines evaluated using polynomial fit at each point in the output nosedist """ nosedist, nosetail = {}, {} for k, (cx, cy) in coefs.iteritems(): try: # Determine spacing, number of points and length based on inputs start, stop = 0.0, lengths[i] if spacing: uu = np.arange(start, stop, spacing) else: uu = np.linspace(start, stop, num_points) # Construct polynomial from its coefficients vx = polyval(uu, cx) vy = polyval(uu, cy) vv = np.asarray(zip(vx, vy)) nosedist[k] = uu nosetail[k] = vv except: pass return nosedist, nosetail
def __call__(self, i, x, p = 0): """ k is degree is 0+ 0 <= i < len(t) t[0] <= x <= t[-1] p < k """ t = self._t jj = np.where(np.logical_and(x >= t[:-1], x < t[1:]))[0] if len(jj) == 0: if x == t[-1]: j = self._n + self._k - 2 else: return 0 else: j = jj[0] if self._derivatives: k = self._k - p a = self._a[i, j, k, :k+1] else: a = self._a[i, j, -1] if p > 0: a = polyder(a, p) return polyval(x, a)
def density_kovacs82(d0, z): """Convert depth into firn density from Kovacs [1982] measurements over the brine of McMurdo Ice Shelf Arguments --------- d0 : float first polynom equals the surface density [kg^m{-3}] z : array of floats Depth [m] """ p = {'B': [d0, 2.79e1, 0, 0, 0, 0, 0], 'C': [d0, 2.21e1, -3.09e-1, 0, 0, 0, 0], 'D': [d0, 2.38e1, -5.11e-1, 4.62e-3, 0, 0, 0], 'E': [d0, 3.36e1, -1.89e00, 7.83e-2, -1.85e-3, 2.24e-5, -1.07e-7], 'F': [d0, 3.57e1, -2.15e00, 8.77e-2, -1.94e-3, 2.15e-5, -9.54e-8]} p = pd.DataFrame(p) # Density caclcuation dns = {'B': z*0, 'C': z*0, 'D': z*0, 'E': z*0, 'F': z*0} dns = pd.DataFrame(dns) for i, val in enumerate(z): dns.ix[i] = polyval(val,p.ix[:]) dns[dns > 917] = 917. return dns
def generateJSON(self, data, wlcalib, original_images): from numpy.polynomial.polynomial import polyval self.logger.info('start JSON generation') result = {} counter = 0 for image in data: name = original_images[counter].filename result[name] = {} for fiber, value in image.items(): result[name][fiber] = [] for arco in value: try: res = polyval(arco[0], wlcalib[fiber]) result[name][fiber].append( [arco[0], arco[1], arco[2], res]) except: self.logger.error('Error in JSON generation. Check later...') counter += 1 self.logger.info('end JSON generation') return result
def fit(xcoords_fit, ycoords_fit, dat_fit): #does fit heavy lifting x_fit = np.linspace(xcoords_fit[0], xcoords_fit[-1], 50) np.concatenate([xcoords_fit, x_fit]) dat_fit = int(dat_fit) coefs = ply.polyfit(xcoords_fit, ycoords_fit, dat_fit, w=np.divide(1, yerrors_no_ul)) y_fit = ply.polyval(x_fit, coefs) return (x_fit, y_fit, coefs)
def get_fert(S, starting_age, ending_age, E): ''' Parameters: S - Number of age cohorts starting age - initial age of cohorts Returns: fert_rate - Sx1 array of fertility rates for each age cohort children_fertrate - starting_age x 1 array of zeros, to be used in get_omega() ''' # Fit a polynomial to the fertility rates poly_fert = poly.polyfit(age_midpoint, fert_data, deg=4) fert_rate = integrate(poly_fert, np.linspace( starting_age, ending_age, S+1)) fert_rate /= 2.0 children_fertrate_int = poly.polyint(poly_fert) children_fertrate_int = poly.polyval(np.linspace( 0, starting_age, E + 1), children_fertrate_int) children_fertrate = np.diff(children_fertrate_int) children_fertrate /= 2.0 children_fertrate[children_fertrate < 0] = 0 children_fertrate[:int(10*S/float(ending_age-starting_age))] = 0 return fert_rate, children_fertrate
def generate_focus_wl(self, all_measures, wlcalib): self.logger.info('start result generation') result = {} wlfib = {} for s in wlcalib.contents: wlfib[s.fibid] = s.solution for focus, image in all_measures.items(): cresult = {} result[focus] = cresult for fiber, value in image.items(): cresult[fiber] = [] for arco in value: try: # FIXME: hardcoded sizes x = 2048 * 2 - arco[0] res = polynomial.polyval(x, wlfib[fiber].coeff) cresult[fiber].append([arco[0], arco[1], arco[2], res]) except KeyError: self.logger.warning("Fiber %d hasn't WL calibration, skipping", fiber) self.logger.info('end result generation') return result
def vary_gauss(a, sig=1, verbose=False): n = len(a) b = np.empty_like(a) if np.isscalar(sig): sig *= np.arange(n) elif isinstance(sig, tuple): sig = poly.polyval(np.arange(n), sig) elif callable(sig): sig = sig(np.arange(n)) elif hasattr(sig, '__getitem__'): assert len(a) == len(sig) else: raise TypeError('`sig` is neither callable nor arraylike') for i, s in enumerate(sig): # build the kernel: w = round(2*s) # kernel half-width, must be integer if s == 0: s = 1 k = np.arange(-w, w+1, dtype=float) k = np.exp(-.5 * k**2 / s**2) # slice the array (min/max prevent going past ends) al = max(i - w, 0) ar = min(i + w + 1, n) ao = a[al:ar] # and the kernel kl = max(w - i, 0) kr = min(w - i + n, 2*w+1) ko = k[kl:kr] b[i] = np.dot(ao, ko)/ko.sum() return b
def __init__(self, poly_degree=7, numPoints = 300, numTrain = None, h5=None): if h5 is not None: self.h5read(h5) return assert poly_degree > 0, "must have at least 1 root" if numTrain is None: numTrain = max(1,int(.1 * numPoints)) assert 3*numTrain < numPoints, "numTrain must be < 3*numPoints to produce test/train/cv sets" # make a polynomial with the given number of roots, but no root at 0 poly_roots = list(np.arange(poly_degree + 1) - int(poly_degree//2)) poly_roots.remove(0) poly_roots = np.array(poly_roots) poly_coeffs = polynomial.polyfromroots(poly_roots) self.x_all = vec2columnMat(np.linspace(start = poly_roots[0], stop = poly_roots[-1], num = 300)) self.y_all = polynomial.polyval(self.x_all[:], poly_coeffs) inds = range(len(self.x_all)) random.shuffle(inds) self.x_train = vec2columnMat(self.x_all[:][inds[0:numTrain]]) self.y_train = vec2columnMat(self.y_all[:][inds[0:numTrain]]) self.x_test = vec2columnMat(self.x_all[:][inds[numTrain:(2*numTrain)]]) self.y_test = vec2columnMat(self.y_all[:][inds[numTrain:(2*numTrain)]]) self.x_cv = vec2columnMat(self.x_all[:][inds[(2*numTrain):(3*numTrain)]]) self.y_cv = vec2columnMat(self.y_all[:][inds[(2*numTrain):(3*numTrain)]])
def work(self, fig=None, ax=None): """Draw the polynomial fit on matplotlib figure or axis Parameters: ----------- fig: matplotlib figure ax: matplotlib axis Returns: -------- a tuple with figure and axis objects """ if ax is None: if fig is None: return fig, ax else: ax = fig.gca() from numpy.polynomial.polynomial import polyfit from numpy.polynomial.polynomial import polyval x = self.data[self.aes['x']] y = self.data[self.aes['y']] min_x = min(x) max_x = max(x) c = polyfit(x, y, self.degree) x_ = np.linspace(min_x, max_x, len(x)) y_ = polyval(x_, c) ax.plot(x_, y_, lw=self.lw, c=self.colour) return fig, ax
def calc_freq(self, time): """ time: MJD object """ dt = float(MJD(time)-self.tmid)*1440. multy = np.arange(1, self.ncoeff, 1) return self.profile.f0 + (1./60.)*polyval(dt, multy*self.polycos[1:])
def fluxesFromIm(image, xstart=86., xend=540., ycoord=234., radius=1.5): ycents = np.concatenate((np.repeat(ycoord+1,50),np.repeat(ycoord,70))) xcents = np.linspace(xstart, xend, nWgsOP) xpx=range(len(image[0,:])) ypx=range(len(image[:,0])) xinds,yinds=np.meshgrid(xpx,ypx) #pdb.set_trace() image = np.squeeze(polyval(image, nonLinCoeffs)) #Non-linear correction if False: #showPlots: <- This is too slow. #if showPlots: #<- This is too slow. plt.figure(2) #plt.clf() plt.imshow(image, interpolation='nearest') plt.plot(xcents,ycents,'+r',linewidth=1) circles(xcents, ycents, radius, facecolor='none',edgecolor='r') plt.pause(0.01) fluxes = np.zeros(nWgsOP) for wg in range(nWgsOP): circleInds = np.sqrt( (xinds-xcents[wg])**2 + (yinds-ycents[wg])**2 ) < radius fluxes[wg]=np.average(image[circleInds]) return fluxes
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 eval_poly(x, coef): return polynomial.polyval(x, coef)
p_volt = p_data[:, 0] p_count = p_data[:, 1] h_volt = h_data[:, 0] h_height = h_data[:, 1] # get plateau region data p_region_v = [] p_region_r = [] for v, r in zip(p_volt, p_count): if 250 < r < 350: p_region_v += [v] p_region_r += [r] p_coeff = poly.polyfit(p_region_v, p_region_r, 1) p_v_fit = np.linspace(p_region_v[0], p_region_v[-1], 10) p_r_fit = poly.polyval(p_v_fit, p_coeff) v_f, v_i = p_v_fit[-1], p_v_fit[0] r_f, r_i = p_r_fit[-1], p_r_fit[0] operating_v = (v_f + v_i) / 2 p_slope = 100 * 100 * (r_f - r_i) / (r_i * (v_f - v_i)) # print((r_f-r_i)/r_i,r_i,r_f,operating_v, p_slope) plt.plot(p_volt, p_count, "o") plt.plot(p_v_fit, p_r_fit) plt.title("Plateau Characteristics of a G.M Counter") plt.xlabel("Baseline Voltage(Volt)$\longrightarrow$") plt.ylabel("Count /20s$\longrightarrow$") plt.text(v_i - 50, r_i, "($V_1,R_1$)") plt.annotate("($V_2,R_2$)", (v_f, r_f)) plt.text( 550,
def test_polyvalfromroots(self): # check exception for broadcasting x values over root array with # too few dimensions assert_raises(ValueError, poly.polyvalfromroots, [1], [1], tensor=False) # check empty input assert_equal(poly.polyvalfromroots([], [1]).size, 0) assert_(poly.polyvalfromroots([], [1]).shape == (0, )) # check empty input + multidimensional roots assert_equal(poly.polyvalfromroots([], [[1] * 5]).size, 0) assert_(poly.polyvalfromroots([], [[1] * 5]).shape == (5, 0)) # check scalar input assert_equal(poly.polyvalfromroots(1, 1), 0) assert_(poly.polyvalfromroots(1, np.ones((3, 3))).shape == (3, )) # check normal input) x = np.linspace(-1, 1) y = [x**i for i in range(5)] for i in range(1, 5): tgt = y[i] res = poly.polyvalfromroots(x, [0] * i) assert_almost_equal(res, tgt) tgt = x * (x - 1) * (x + 1) res = poly.polyvalfromroots(x, [-1, 0, 1]) assert_almost_equal(res, tgt) # check that shape is preserved for i in range(3): dims = [2] * i x = np.zeros(dims) assert_equal(poly.polyvalfromroots(x, [1]).shape, dims) assert_equal(poly.polyvalfromroots(x, [1, 0]).shape, dims) assert_equal(poly.polyvalfromroots(x, [1, 0, 0]).shape, dims) # check compatibility with factorization ptest = [15, 2, -16, -2, 1] r = poly.polyroots(ptest) x = np.linspace(-1, 1) assert_almost_equal(poly.polyval(x, ptest), poly.polyvalfromroots(x, r)) # check multidimensional arrays of roots and values # check tensor=False rshape = (3, 5) x = np.arange(-3, 2) r = np.random.randint(-5, 5, size=rshape) res = poly.polyvalfromroots(x, r, tensor=False) tgt = np.empty(r.shape[1:]) for ii in range(tgt.size): tgt[ii] = poly.polyvalfromroots(x[ii], r[:, ii]) assert_equal(res, tgt) # check tensor=True x = np.vstack([x, 2 * x]) res = poly.polyvalfromroots(x, r, tensor=True) tgt = np.empty(r.shape[1:] + x.shape) for ii in range(r.shape[1]): for jj in range(x.shape[0]): tgt[ii, jj, :] = poly.polyvalfromroots(x[jj], r[:, ii]) assert_equal(res, tgt)
def model(self, pars, mdata): mdata += npoly.polyval(self.x, pars)
print volumes, energies coefs = poly.polyfit(OPTIONS, energies, 3) C = coefs[2] / volumes[0] / kJ * 1.0e24 print C save(result, C) x_new = np.linspace(OPTIONS[0] - 0.01, OPTIONS[-1] + 0.01, num=len(OPTIONS) * 10) ffit = poly.polyval(x_new, coefs) plt.scatter(OPTIONS, energies) plt.plot(x_new, ffit) plt.savefig('{0}.png'.format(name)) os.system('mv {0}.png {1}/graph'.format(name, temp_dir)) save(result, OPTIONS) save(result, volumes) save(result, energies) save(result, '------------------------') save(result_sum, '{0}, {1}, {2}, {3}'.format(name, C, volumes, energies))
def towards_zero(z0, dz): return abs2(npp.polyval(z0 + dz, f_as_poly)) < abs2( npp.polyval(z0, f_as_poly))
def update_animation(self, frame_i): for i in range(len(self.nodes)): if i in self.locked: continue angle = poly.polyval(frame_i/self.n_frames, self.node_poly[i]) self.nodes[i].r = Rotation.from_euler('zxy', angle)
def create_rotations(rotation_table): """ Convert an ISIS rotation table into rotation objects. Parameters ---------- rotation_table : dict The rotation ISIS table as a dictionary Returns ------- : list A list of time dependent or constant rotation objects from the table. This list will always have either 1 or 2 elements. The first rotation will be time dependent and the second rotation will be constant. The rotations will be ordered such that the reference frame the first rotation rotates to is the reference frame the second rotation rotates from. """ rotations = [] root_frame = rotation_table['TimeDependentFrames'][-1] last_time_dep_frame = rotation_table['TimeDependentFrames'][0] # Case 1: It's a table of quaternions and times if 'J2000Q0' in rotation_table: # SPICE quaternions are (W, X, Y, Z) and ALE uses (X, Y, Z, W). quats = np.array([rotation_table['J2000Q1'], rotation_table['J2000Q2'], rotation_table['J2000Q3'], rotation_table['J2000Q0']]).T if 'AV1' in rotation_table: av = np.array([rotation_table['AV1'], rotation_table['AV2'], rotation_table['AV3']]).T else: av = None time_dep_rot = TimeDependentRotation(quats, rotation_table['ET'], root_frame, last_time_dep_frame, av=av) rotations.append(time_dep_rot) # Case 2: It's a table of Euler angle coefficients elif 'J2000Ang1' in rotation_table: ephemeris_times = np.linspace(rotation_table['CkTableStartTime'], rotation_table['CkTableEndTime'], rotation_table['CkTableOriginalSize']) base_time = rotation_table['J2000Ang1'][-1] time_scale = rotation_table['J2000Ang2'][-1] scaled_times = (ephemeris_times - base_time) / time_scale coeffs = np.array([rotation_table['J2000Ang1'][:-1], rotation_table['J2000Ang2'][:-1], rotation_table['J2000Ang3'][:-1]]).T angles = polyval(scaled_times, coeffs).T # ISIS is hard coded to ZXZ (313) Euler angle axis order. # SPICE also interprets Euler angle rotations as negative rotations, # so negate them before passing to scipy. time_dep_rot = TimeDependentRotation.from_euler('zxz', -angles, ephemeris_times, root_frame, last_time_dep_frame) rotations.append(time_dep_rot) if 'ConstantRotation' in rotation_table: last_constant_frame = rotation_table['ConstantFrames'][0] rot_mat = np.reshape(np.array(rotation_table['ConstantRotation']), (3, 3)) constant_rot = ConstantRotation.from_matrix(rot_mat, last_time_dep_frame, last_constant_frame) rotations.append(constant_rot) return rotations
#---------------------Runge function------------------------------------------ def f(x): return 1.0 / (1.0 + 25.0 * x**2) # Evenly spaced interpolation nodes: x_grid = [-1, 1] x1 = ny.linspace(x_grid[0], x_grid[1], 11) y = f(x1) xs = ny.linspace(x_grid[0], x_grid[1], 101) #Order 3: runge3_coef = poly.polyfit(x1, y, 3) runge3_f = poly.polyval(xs, runge3_coef) #Order 5: runge5_coef = poly.polyfit(x1, y, 5) runge5_f = poly.polyval(xs, runge5_coef) #Order 10: runge10_coef = poly.polyfit(x1, y, 10) runge10_f = poly.polyval(xs, runge10_coef) #------------------------Exponential Function---------------------------------- def g(x): with ny.errstate(divide='ignore', invalid='ignore'): return ny.exp(1 / x)
def h(s, b, a): z = polyval(s, b[::-1]) / polyval(s, a[::-1]) return z
def calc_moon(t): """ Lunar position model ELP2000-82 of (Chapront-Touze' and Chapront, 1983, 124, 50) This is the simplified version of Jean Meeus, Astronomical Algorithms, second edition, 1998, Willmann-Bell. Meeus claims approximate accuracy of 10" in longitude and 4" in latitude, with no specified time range. Tests against JPL ephemerides show accuracy of 10 arcseconds and 50 km over the date range CE 1950-2050. Parameters ----------- t : `~astropy.time.Time` Time of observation. Returns -------- skycoord : `~astropy.coordinates.SkyCoord` ICRS Coordinate for the body """ # number of centuries since J2000.0. # This should strictly speaking be in Ephemeris Time, but TDB or TT # will introduce error smaller than intrinsic accuracy of algorithm. T = (t.tdb.jyear-2000.0)/100. # constants that are needed for all calculations Lc = u.Quantity(polyval(T, _coLc), u.deg) D = u.Quantity(polyval(T, _coD), u.deg) M = u.Quantity(polyval(T, _coM), u.deg) Mc = u.Quantity(polyval(T, _coMc), u.deg) F = u.Quantity(polyval(T, _coF), u.deg) A1 = u.Quantity(polyval(T, _coA1), u.deg) A2 = u.Quantity(polyval(T, _coA2), u.deg) A3 = u.Quantity(polyval(T, _coA3), u.deg) E = polyval(T, _coE) suml = sumr = 0.0 for DNum, MNum, McNum, FNum, LFac, RFac in _MOON_L_R: corr = E ** abs(MNum) suml += LFac*corr*np.sin(D*DNum+M*MNum+Mc*McNum+F*FNum) sumr += RFac*corr*np.cos(D*DNum+M*MNum+Mc*McNum+F*FNum) sumb = 0.0 for DNum, MNum, McNum, FNum, BFac in _MOON_B: corr = E ** abs(MNum) sumb += BFac*corr*np.sin(D*DNum+M*MNum+Mc*McNum+F*FNum) suml += (3958*np.sin(A1) + 1962*np.sin(Lc-F) + 318*np.sin(A2)) sumb += (-2235*np.sin(Lc) + 382*np.sin(A3) + 175*np.sin(A1-F) + 175*np.sin(A1+F) + 127*np.sin(Lc-Mc) - 115*np.sin(Lc+Mc)) # ensure units suml = suml*u.microdegree sumb = sumb*u.microdegree # nutation of longitude jd1, jd2 = get_jd12(t, 'tt') nut, _ = erfa.nut06a(jd1, jd2) nut = nut*u.rad # calculate ecliptic coordinates lon = Lc + suml + nut lat = sumb dist = (385000.56+sumr/1000)*u.km # Meeus algorithm gives GeocentricTrueEcliptic coordinates ecliptic_coo = GeocentricTrueEcliptic(lon, lat, distance=dist, equinox=t) return SkyCoord(ecliptic_coo.transform_to(ICRS))
def compute_G(self, lbda, U): G = np.zeros((self.dim, self.dim)) G[0, 0] = U[0, 1] * P.polyval(lbda, self.p[0]) * P.polyval(lbda, P.polyder(self.p[1])) \ + U[0, 1] * P.polyval(lbda, self.p[1]) * P.polyval(lbda, P.polyder(self.p[0])) G[self.dim-1, self.dim-1] = - U[self.dim - 2, self.dim - 1] * P.polyval(lbda, self.p[self.dim - 2]) * P.polyval(lbda,P.polyder(self.p[self.dim - 1])) \ + 1*P.polyval(lbda, self.p[self.dim - 1]) * P.polyval(lbda, P.polyder(self.p_n)) \ - U[self.dim - 2, self.dim - 1] * P.polyval(lbda, self.p[self.dim - 1]) * P.polyval(lbda, P.polyder(self.p[self.dim - 2])) \ + 1*P.polyval(lbda, self.p_n) * P.polyval(lbda, P.polyder(self.p[self.dim - 1])) for k in range(1, self.dim-1): G[k, k] = - U[k, k-1] * P.polyval(lbda, self.p[k - 1]) * P.polyval(lbda, P.polyder(self.p[k])) \ + U[k, k+1] * P.polyval(lbda, self.p[k]) * P.polyval(lbda, P.polyder(self.p[k+1])) \ - U[k, k-1] * P.polyval(lbda, self.p[k]) * P.polyval(lbda, P.polyder(self.p[k-1])) \ + U[k, k+1] * P.polyval(lbda, self.p[k+1]) * P.polyval(lbda, P.polyder(self.p[k])) for l in range(0, self.dim-1): G[l+1, l] = -U[l, l+1] * (P.polyval(lbda, self.p[l-1]) * P.polyval(lbda, P.polyder(self.p[l-1])) - P.polyval(lbda, self.p[l]) * P.polyval(lbda, P.polyder(self.p[l]))) self.G = -(G + np.diag(np.diag(G, -1), +1)) return self.G
def SmoothPoly(x, y): coefs = poly.polyfit(x, y, 4) # no change with >4 return poly.polyval(x, coefs)
def _return(self): return polyval(self.x, self.coeff)
def compute_G_kl(self, k, l, U, eigenvalues): G_kl = np.zeros((self.dim, self.dim)) if k == l: G_kl[k,k] = 1 elif k == l+1: G_kl[k, l] = 1 G_kl[l, k] = 1 else: sum = 0 for i, eigenvalue in enumerate(eigenvalues): acc = - U[0,1]*P.polyval(eigenvalue, self.p[0])*self.compute_p_kl(k=1, l=l, lbda=eigenvalue, eigenvalues=eigenvalues)\ - U[0,1]*P.polyval(eigenvalue, self.p[1])*self.compute_p_kl(k=0, l=l, lbda=eigenvalue, eigenvalues=eigenvalues) sum += self.frozen_spectral_w[i]**2 * P.polyval(eigenvalue, self.p[k]) * acc G_kl[0,0] = 0.5 * sum for r in range(1, self.dim-1): sum = 0 for i, eigenvalue in enumerate(eigenvalues): acc = U[r, r-1] * P.polyval(eigenvalue, self.p[r-1]) * self.compute_p_kl(k=r, l=l, lbda=eigenvalue, eigenvalues=eigenvalues)\ - U[r, r+1] * P.polyval(eigenvalue, self.p[r]) * self.compute_p_kl(k=r+1, l=l, lbda=eigenvalue, eigenvalues=eigenvalues)\ + U[r, r-1] * P.polyval(eigenvalue, self.p[r]) * self.compute_p_kl(k=r-1, l=l, lbda=eigenvalue, eigenvalues=eigenvalues)\ - U[r, r+1] * P.polyval(eigenvalue, self.p[r+1]) * self.compute_p_kl(k=r, l=l, lbda=eigenvalue, eigenvalues=eigenvalues) sum += self.frozen_spectral_w[i]**2 * P.polyval(eigenvalue, self.p[k]) * acc G_kl[r, r] = 0.5 * sum for u in range(0, self.dim-2): sum=0 for i, eigenvalue in enumerate(eigenvalues): acc = U[r, r+1] * ( P.polyval(eigenvalue, self.p[r]) * self.compute_p_kl(k=r, l=l, lbda=eigenvalue, eigenvalues=eigenvalues) - P.polyval(eigenvalue, self.p[r+1]) * self.compute_p_kl(k=r+1, l=l, lbda=eigenvalue, eigenvalues=eigenvalues)) sum += self.frozen_spectral_w[i]**2 * P.polyval(eigenvalue, self.p[k]) * acc G_kl[u, u-1] = 0.5 * sum G_kl_tridiag = (G_kl+np.diag(np.diag(G_kl, -1), +1)) return G_kl_tridiag
class TestEvaluation: # coefficients of 1 + 2*x + 3*x**2 c1d = np.array([4., 2., 3.]) c2d = np.einsum('i,j->ij', c1d, c1d) c3d = np.einsum('i,j,k->ijk', c1d, c1d, c1d) # some random values in [-1, 1) x = np.random.random((3, 5)) * 2 - 1 y = polyval(x, [1., 2., 3.]) def test_hermeval(self): #check empty input assert_equal(herme.hermeval([], [1]).size, 0) #check normal input) x = np.linspace(-1, 1) y = [polyval(x, c) for c in Helist] for i in range(10): msg = f"At i={i}" tgt = y[i] res = herme.hermeval(x, [0] * i + [1]) assert_almost_equal(res, tgt, err_msg=msg) #check that shape is preserved for i in range(3): dims = [2] * i x = np.zeros(dims) assert_equal(herme.hermeval(x, [1]).shape, dims) assert_equal(herme.hermeval(x, [1, 0]).shape, dims) assert_equal(herme.hermeval(x, [1, 0, 0]).shape, dims) def test_hermeval2d(self): x1, x2, x3 = self.x y1, y2, y3 = self.y #test exceptions assert_raises(ValueError, herme.hermeval2d, x1, x2[:2], self.c2d) #test values tgt = y1 * y2 res = herme.hermeval2d(x1, x2, self.c2d) assert_almost_equal(res, tgt) #test shape z = np.ones((2, 3)) res = herme.hermeval2d(z, z, self.c2d) assert_(res.shape == (2, 3)) def test_hermeval3d(self): x1, x2, x3 = self.x y1, y2, y3 = self.y #test exceptions assert_raises(ValueError, herme.hermeval3d, x1, x2, x3[:2], self.c3d) #test values tgt = y1 * y2 * y3 res = herme.hermeval3d(x1, x2, x3, self.c3d) assert_almost_equal(res, tgt) #test shape z = np.ones((2, 3)) res = herme.hermeval3d(z, z, z, self.c3d) assert_(res.shape == (2, 3)) def test_hermegrid2d(self): x1, x2, x3 = self.x y1, y2, y3 = self.y #test values tgt = np.einsum('i,j->ij', y1, y2) res = herme.hermegrid2d(x1, x2, self.c2d) assert_almost_equal(res, tgt) #test shape z = np.ones((2, 3)) res = herme.hermegrid2d(z, z, self.c2d) assert_(res.shape == (2, 3) * 2) def test_hermegrid3d(self): x1, x2, x3 = self.x y1, y2, y3 = self.y #test values tgt = np.einsum('i,j,k->ijk', y1, y2, y3) res = herme.hermegrid3d(x1, x2, x3, self.c3d) assert_almost_equal(res, tgt) #test shape z = np.ones((2, 3)) res = herme.hermegrid3d(z, z, z, self.c3d) assert_(res.shape == (2, 3) * 3)
X_wmd = [] Y_test = [] for i in range(len(testA)): s1 = vect.transform([testA[i]]).toarray().ravel() s2 = vect.transform([testB[i]]).toarray().ravel() # cosine similarity between bag of words d_cos = np.cos(np.dot(s1, s2)) X_cos.append(d_cos) # WMD s1 = s1.astype(np.float) / np.sum(s1) s2 = s2.astype(np.float) / np.sum(s2) d_wmd = ot.emd2(s1, s2, D) X_wmd.append(d_wmd) Y_test.append(scores_test[i]) Y_cos = poly.polyval(X_cos, k_cos) Y_wmd = poly.polyval(X_wmd, k_wmd) # We will use MSE, Spearman's rho and Pearson coefficients to measure the quality of our regression model # In[15]: from sklearn.metrics import mean_squared_error as mse from scipy.stats import pearsonr from scipy.stats import spearmanr # Estimate the quality of your regression model for both Cosine and WMD dissimilarities # In[16]: print('-------- Cosine')
def _accum_mfunc(res, x): res += npoly.polyval(x, pars)
def spectral_weight(self, lbda): q_i = 1 / np.linalg.norm([P.polyval(lbda, self.p[j]) for j in range(self.dim)]) return q_i
def __call__(self, t): #assert t <= self.time_intervals[-1][1], "t must be lower than the final time tf={}".format(self.time_intervals[-1][1]) index = len(self.t0_l) - 1 if t > self.time_intervals[-1][1]: t = self.time_intervals[-1][1] elif t < self.time_intervals[0][0]: t = self.time_intervals[0][0] index = 0 else: for k in range(len(self.t0_l)): if self.t0_l[k] > t: index = k - 1 break xyz_polycoeff = self.polycoeff_l[index] dxyz_polycoeff = self.dpolycoeff_l[index] ddxyz_polycoeff = self.ddpolycoeff_l[index] t0 = self.time_intervals[index][0] t1 = self.time_intervals[index][1] if t0 == t1: tau = 0. dtau_dt = 0. else: tau = (t - t0) / (t1 - t0) dtau_dt = 1. # Evaluate X x = polyval(tau, xyz_polycoeff[0]) if len(dxyz_polycoeff[0]): x_dot = polyval(tau, dxyz_polycoeff[0]) * dtau_dt else: x_dot = 0. if len(ddxyz_polycoeff[0]): x_dotdot = polyval(tau, ddxyz_polycoeff[0]) * dtau_dt**2 else: x_dotdot = 0. # Evaluate Y y = polyval(tau, xyz_polycoeff[1]) if len(dxyz_polycoeff[1]): y_dot = polyval(tau, dxyz_polycoeff[1]) * dtau_dt else: y_dot = 0. if len(ddxyz_polycoeff[1]): y_dotdot = polyval(tau, ddxyz_polycoeff[1]) * dtau_dt**2 else: y_dotdot = 0. # Evaluate Z x0 = polyval(0., xyz_polycoeff[0]) x1 = polyval(1., xyz_polycoeff[0]) if x0 == x1: tau_x = 0. dtau_x_dt = 0. else: tau_x = (x - x0) / (x1 - x0) dtau_x_dt = x_dot z = polyval(tau_x, xyz_polycoeff[2]) if len(dxyz_polycoeff[2]): z_dot = polyval(tau_x, dxyz_polycoeff[2]) * x_dot else: z_dot = 0. if len(ddxyz_polycoeff[2]): z_dotdot = polyval(tau_x, ddxyz_polycoeff[2]) * x_dot**2 + polyval( tau_x, dxyz_polycoeff[2]) * x_dotdot else: z_dotdot = 0. M = SE3.Identity() v = Motion.Zero() a = Motion.Zero() M.translation = np.matrix([x, y, z]).T M.rotation = self._R v.linear = np.matrix([x_dot, y_dot, z_dot]).T a.linear = np.matrix([x_dotdot, y_dotdot, z_dotdot]).T return M, v, a
def predict_dim(dim): n = ['x', 'y', 'z'].index(dim) + 1 return P.polyval(scaled_time, poly_dict[dim]) * poly_dict[ 'scale'][n] + poly_dict['mid'][n]
def test_polyfit(self): def f(x): return x * (x - 1) * (x - 2) def f2(x): return x**4 + x**2 + 1 # Test exceptions assert_raises(ValueError, poly.polyfit, [1], [1], -1) assert_raises(TypeError, poly.polyfit, [[1]], [1], 0) assert_raises(TypeError, poly.polyfit, [], [1], 0) assert_raises(TypeError, poly.polyfit, [1], [[[1]]], 0) assert_raises(TypeError, poly.polyfit, [1, 2], [1], 0) assert_raises(TypeError, poly.polyfit, [1], [1, 2], 0) assert_raises(TypeError, poly.polyfit, [1], [1], 0, w=[[1]]) assert_raises(TypeError, poly.polyfit, [1], [1], 0, w=[1, 1]) assert_raises(ValueError, poly.polyfit, [1], [1], [ -1, ]) assert_raises(ValueError, poly.polyfit, [1], [1], [2, -1, 6]) assert_raises(TypeError, poly.polyfit, [1], [1], []) # Test fit x = np.linspace(0, 2) y = f(x) # coef3 = poly.polyfit(x, y, 3) assert_equal(len(coef3), 4) assert_almost_equal(poly.polyval(x, coef3), y) coef3 = poly.polyfit(x, y, [0, 1, 2, 3]) assert_equal(len(coef3), 4) assert_almost_equal(poly.polyval(x, coef3), y) # coef4 = poly.polyfit(x, y, 4) assert_equal(len(coef4), 5) assert_almost_equal(poly.polyval(x, coef4), y) coef4 = poly.polyfit(x, y, [0, 1, 2, 3, 4]) assert_equal(len(coef4), 5) assert_almost_equal(poly.polyval(x, coef4), y) # coef2d = poly.polyfit(x, np.array([y, y]).T, 3) assert_almost_equal(coef2d, np.array([coef3, coef3]).T) coef2d = poly.polyfit(x, np.array([y, y]).T, [0, 1, 2, 3]) assert_almost_equal(coef2d, np.array([coef3, coef3]).T) # test weighting w = np.zeros_like(x) yw = y.copy() w[1::2] = 1 yw[0::2] = 0 wcoef3 = poly.polyfit(x, yw, 3, w=w) assert_almost_equal(wcoef3, coef3) wcoef3 = poly.polyfit(x, yw, [0, 1, 2, 3], w=w) assert_almost_equal(wcoef3, coef3) # wcoef2d = poly.polyfit(x, np.array([yw, yw]).T, 3, w=w) assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T) wcoef2d = poly.polyfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w) assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T) # test scaling with complex values x points whose square # is zero when summed. x = [1, 1j, -1, -1j] assert_almost_equal(poly.polyfit(x, x, 1), [0, 1]) assert_almost_equal(poly.polyfit(x, x, [0, 1]), [0, 1]) # test fitting only even Polyendre polynomials x = np.linspace(-1, 1) y = f2(x) coef1 = poly.polyfit(x, y, 4) assert_almost_equal(poly.polyval(x, coef1), y) coef2 = poly.polyfit(x, y, [0, 2, 4]) assert_almost_equal(poly.polyval(x, coef2), y) assert_almost_equal(coef1, coef2)
def velocity_at(self, t): vel_coef_x = poly.polyder(self.coef_x) vel_coef_y = poly.polyder(self.coef_y) vel_x = poly.polyval(t, vel_coef_x) vel_y = poly.polyval(t, vel_coef_y) return (vel_x, vel_y)
def mf_to_wp(MF): return P.polyval(MF, MF_to_WP)
def MFDFA(timeseries: np.ndarray, lag: np.ndarray = None, order: int = 1, q: np.ndarray = 2, modified: bool = False) -> np.ndarray: """ Multi-Fractal Detrended Fluctuation Analysis of timeseries. MFDFA generates a fluctuation function F²(q,s), with s the segment size and q the q-powers, Take a timeseries Xₜ, find the integral Yₜ = cumsum(Xₜ), and segment the timeseries into Nₛ segments of size s. ₛ Fᵥ²(s) = ¹/ₛ∑[Yᵥᵢ - yᵥᵢ]² ⁱ with yᵥᵢ the polynomial fittings of order m. Having obtained the variances of each (detrended) segment, average over s and increase s, to obtain the fluctuation function Fₚ²(s) depending on the segment lenght. F²(q,s) = {1/Nₛ∑[Fᵥ²(s)]^q/2}^1/q, ᵛ The fluctuation function F²(q,s) can now be plotted in a log-log scale, the slope of the fluctuation function F²(q,s) vs the s-segment size is the self-similarity scaling h(q) F²(q,s) ~ sʰ. If H ≈ 0 in a monofractal series, use a second integration step by setting 'modified' = True. Parameters ---------- timeseries: np.ndarray A 1-dimensional timeseries (N, 1). The timeseries of length N. lag: np.ndarray of ints An array with the window sizes to calculate (ints). Notice min(lag) > order + 1 because to fit a polynomial of order m one needs at least m points. The results are meaningless for 'order = m' and for lag > size of data / 4 since there is low statistics with < 4 windows to divide the timeseries. order: int The order of the polynomials to approximate. 'order = 1' is the DFA1, which is a least-square fit of the data with a first order polynomial (a line), 'order = 2' is a second-order polynomial, etc.. q: np.ndarray Fractal exponent to calculate. Array in [-10,10]. The values = 0 will be removed, since the code does not converge there. q = 2 is the standard Detrended Fluctuation Analysis as is set a default. modified: bool For data with the Hurst exponent ≈ 0, i.e., strongly anticorrelated, a standard MFDFA will result in inacurate results, thus a further integration of the timeseries yields a modified scaling coefficient. Returns ------- lag: np.ndarray of ints Array of lags, realigned, preserving only different lags and with entries > order + 1 f: np.ndarray A array of shape (size(lag),size(q)) of variances over the indicated lag windows and the indicated q-fractal powers. """ # Force lag to be ints, ensure lag > order + 1 lag = lag[lag > order + 1] lag = np.round(lag).astype(int) # Assert if timeseries is 1 dimensional if timeseries.ndim > 1: assert timeseries.shape[1] == 1, "Timeseries needs to be 1 dimensional" timeseries = timeseries.reshape(-1, 1) # Size of array N = timeseries.shape[0] # Fractal powers as floats q = np.asarray_chkfinite(q, dtype=float) # Ensure q≈0 is removed, since it does not converge. Limit set at |q| < 0.1 q = q[(q < -.1) + (q > .1)] # Reshape q to perform np.float_power q = q.reshape(-1, 1) # x-axis X = np.linspace(1, lag.max(), lag.max()) # "Profile" of the series Y = np.cumsum(timeseries - np.mean(timeseries)) # Cumulative "profile" for strongly anticorrelated data: if modified == True: Y = np.cumsum(Y - np.mean(Y)) # Return f of (fractal)-variances f = np.empty((0, q.size)) # Loop over elements in lag # Notice that given one has to slip the timeseries into diferent segments of # length lag(), so some elements at the end of the array might be missing. # The same procedure it run in reverse, were elements at the begining of the # series are discared instead for i in lag: # Reshape into (N/lag, lag) Y_ = Y[:N - N % i].reshape((N - N % i) // i, i) Y_r = Y[N % i:].reshape((N - N % i) // i, i) # Perform a polynomial fit to each segments p = polyfit(X[:i], Y_.T, order) p_r = polyfit(X[:i], Y_r.T, order) # Subtract the trend from the fit and calculate the variance F = np.var(Y_ - polyval(X[:i], p), axis=1) F_r = np.var(Y_r - polyval(X[:i], p_r), axis=1) # Caculate the Multi-Fractal Detrended Fluctuation Analysis f = np.append( f, np.float_power( np.mean(np.float_power(F, q / 2), axis=1) / 2, 1 / q.T) + np.float_power( np.mean(np.float_power(F_r, q / 2), axis=1) / 2, 1 / q.T), axis=0) return lag, f
def test_polyint(self): # check exceptions assert_raises(TypeError, poly.polyint, [0], .5) assert_raises(ValueError, poly.polyint, [0], -1) assert_raises(ValueError, poly.polyint, [0], 1, [0, 0]) assert_raises(ValueError, poly.polyint, [0], lbnd=[0]) assert_raises(ValueError, poly.polyint, [0], scl=[0]) assert_raises(TypeError, poly.polyint, [0], axis=.5) with assert_warns(DeprecationWarning): poly.polyint([1, 1], 1.) # test integration of zero polynomial for i in range(2, 5): k = [0] * (i - 2) + [1] res = poly.polyint([0], m=i, k=k) assert_almost_equal(res, [0, 1]) # check single integration with integration constant for i in range(5): scl = i + 1 pol = [0] * i + [1] tgt = [i] + [0] * i + [1 / scl] res = poly.polyint(pol, m=1, k=[i]) assert_almost_equal(trim(res), trim(tgt)) # check single integration with integration constant and lbnd for i in range(5): scl = i + 1 pol = [0] * i + [1] res = poly.polyint(pol, m=1, k=[i], lbnd=-1) assert_almost_equal(poly.polyval(-1, res), i) # check single integration with integration constant and scaling for i in range(5): scl = i + 1 pol = [0] * i + [1] tgt = [i] + [0] * i + [2 / scl] res = poly.polyint(pol, m=1, k=[i], scl=2) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with default k for i in range(5): for j in range(2, 5): pol = [0] * i + [1] tgt = pol[:] for k in range(j): tgt = poly.polyint(tgt, m=1) res = poly.polyint(pol, m=j) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with defined k for i in range(5): for j in range(2, 5): pol = [0] * i + [1] tgt = pol[:] for k in range(j): tgt = poly.polyint(tgt, m=1, k=[k]) res = poly.polyint(pol, m=j, k=list(range(j))) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with lbnd for i in range(5): for j in range(2, 5): pol = [0] * i + [1] tgt = pol[:] for k in range(j): tgt = poly.polyint(tgt, m=1, k=[k], lbnd=-1) res = poly.polyint(pol, m=j, k=list(range(j)), lbnd=-1) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with scaling for i in range(5): for j in range(2, 5): pol = [0] * i + [1] tgt = pol[:] for k in range(j): tgt = poly.polyint(tgt, m=1, k=[k], scl=2) res = poly.polyint(pol, m=j, k=list(range(j)), scl=2) assert_almost_equal(trim(res), trim(tgt))
def coord_at(self, t): x = poly.polyval(t, self.coef_x) y = poly.polyval(t, self.coef_y) return (x, y)
PRC110r1['pos'] = (((np.sign(PRC110r1['voltage'].diff()) + 1) / 2)).astype('bool') plt.ion() with plt.style.context('prl'): #first plot at 108 fig, ax = plt.subplots() pos108 = PRC108r1[[ 'voltage', 'current' ]][1::][PRC108r1['pos'][1::]].sort_values(by=['voltage']) t0 = pos108['voltage'].iloc[0] t1 = pos108['voltage'].iloc[-1] coeffs = poly.polyfit( [t0, t1], [pos108['current'].iloc[0], pos108['current'].iloc[-1]], 1) pos108['normC'] = pos108['current'] - poly.polyval(pos108['voltage'], coeffs) ax.plot(pos108['voltage'], pos108['normC'], '.') ax2 = ax.twinx() ax2.plot(tilt108['E'][1::][tilt108['pos'][1::]], tilt108['Theta mean'][1::][tilt108['pos'][1::]], '.', c='C1') # fig,ax =plt.subplots() # ax.plot(PRC108r1['voltage'][1::][~PRC108r1['pos'][1::]],PRC108r1['current'][1::][~PRC108r1['pos'][1::]],'.') # ax2 = ax.twinx() # ax2.plot(tilt108['E'][1::][~tilt108['pos'][1::]], tilt108['Theta mean'][1::][~tilt108['pos'][1::]], '.',c='C1') fig, ax = plt.subplots() ax.plot(pos108['voltage'], np.cumsum(pos108['normC']), '.') ax2 = ax.twinx() ax2.plot(tilt108['E'][1::][tilt108['pos'][1::]],
#!/usr/bin/python ##################################################################### # Author: Alberto Albz Marocchino # Date: 26-02-2017 # Purpose: comparison between python and R :: polinomail fit regression # Source: python ##################################################################### import numpy as np import pylab as pyl from scipy import stats import numpy.polynomial.polynomial as poly #--- generate sample---# x = np.linspace(-5, 5, 500) y_therory = -1 * x**3 + 5 * x**2 + x y = y_therory + np.random.normal(0, 25, 500) #---linear interpolation---# coefficients = poly.polyfit(x, y, 3) y_reconstructed = poly.polyval(x, coefficients) #%matplotlib inline pyl.plot(x, y, '.', label='scattered data') pyl.plot(x, y_therory, 'x', label='original data') pyl.plot(x, y_reconstructed, '-', label='fit', lw=3) pyl.legend()
class TestEvaluation: # coefficients of 1 + 2*x + 3*x**2 c1d = np.array([1., 2., 3.]) c2d = np.einsum('i,j->ij', c1d, c1d) c3d = np.einsum('i,j,k->ijk', c1d, c1d, c1d) # some random values in [-1, 1) x = np.random.random((3, 5)) * 2 - 1 y = poly.polyval(x, [1., 2., 3.]) def test_polyval(self): #check empty input assert_equal(poly.polyval([], [1]).size, 0) #check normal input) x = np.linspace(-1, 1) y = [x**i for i in range(5)] for i in range(5): tgt = y[i] res = poly.polyval(x, [0] * i + [1]) assert_almost_equal(res, tgt) tgt = x * (x**2 - 1) res = poly.polyval(x, [0, -1, 0, 1]) assert_almost_equal(res, tgt) #check that shape is preserved for i in range(3): dims = [2] * i x = np.zeros(dims) assert_equal(poly.polyval(x, [1]).shape, dims) assert_equal(poly.polyval(x, [1, 0]).shape, dims) assert_equal(poly.polyval(x, [1, 0, 0]).shape, dims) #check masked arrays are processed correctly mask = [False, True, False] mx = np.ma.array([1, 2, 3], mask=mask) res = np.polyval([7, 5, 3], mx) assert_array_equal(res.mask, mask) #check subtypes of ndarray are preserved class C(np.ndarray): pass cx = np.array([1, 2, 3]).view(C) assert_equal(type(np.polyval([2, 3, 4], cx)), C) def test_polyvalfromroots(self): # check exception for broadcasting x values over root array with # too few dimensions assert_raises(ValueError, poly.polyvalfromroots, [1], [1], tensor=False) # check empty input assert_equal(poly.polyvalfromroots([], [1]).size, 0) assert_(poly.polyvalfromroots([], [1]).shape == (0, )) # check empty input + multidimensional roots assert_equal(poly.polyvalfromroots([], [[1] * 5]).size, 0) assert_(poly.polyvalfromroots([], [[1] * 5]).shape == (5, 0)) # check scalar input assert_equal(poly.polyvalfromroots(1, 1), 0) assert_(poly.polyvalfromroots(1, np.ones((3, 3))).shape == (3, )) # check normal input) x = np.linspace(-1, 1) y = [x**i for i in range(5)] for i in range(1, 5): tgt = y[i] res = poly.polyvalfromroots(x, [0] * i) assert_almost_equal(res, tgt) tgt = x * (x - 1) * (x + 1) res = poly.polyvalfromroots(x, [-1, 0, 1]) assert_almost_equal(res, tgt) # check that shape is preserved for i in range(3): dims = [2] * i x = np.zeros(dims) assert_equal(poly.polyvalfromroots(x, [1]).shape, dims) assert_equal(poly.polyvalfromroots(x, [1, 0]).shape, dims) assert_equal(poly.polyvalfromroots(x, [1, 0, 0]).shape, dims) # check compatibility with factorization ptest = [15, 2, -16, -2, 1] r = poly.polyroots(ptest) x = np.linspace(-1, 1) assert_almost_equal(poly.polyval(x, ptest), poly.polyvalfromroots(x, r)) # check multidimensional arrays of roots and values # check tensor=False rshape = (3, 5) x = np.arange(-3, 2) r = np.random.randint(-5, 5, size=rshape) res = poly.polyvalfromroots(x, r, tensor=False) tgt = np.empty(r.shape[1:]) for ii in range(tgt.size): tgt[ii] = poly.polyvalfromroots(x[ii], r[:, ii]) assert_equal(res, tgt) # check tensor=True x = np.vstack([x, 2 * x]) res = poly.polyvalfromroots(x, r, tensor=True) tgt = np.empty(r.shape[1:] + x.shape) for ii in range(r.shape[1]): for jj in range(x.shape[0]): tgt[ii, jj, :] = poly.polyvalfromroots(x[jj], r[:, ii]) assert_equal(res, tgt) def test_polyval2d(self): x1, x2, x3 = self.x y1, y2, y3 = self.y #test exceptions assert_raises_regex(ValueError, 'incompatible', poly.polyval2d, x1, x2[:2], self.c2d) #test values tgt = y1 * y2 res = poly.polyval2d(x1, x2, self.c2d) assert_almost_equal(res, tgt) #test shape z = np.ones((2, 3)) res = poly.polyval2d(z, z, self.c2d) assert_(res.shape == (2, 3)) def test_polyval3d(self): x1, x2, x3 = self.x y1, y2, y3 = self.y #test exceptions assert_raises_regex(ValueError, 'incompatible', poly.polyval3d, x1, x2, x3[:2], self.c3d) #test values tgt = y1 * y2 * y3 res = poly.polyval3d(x1, x2, x3, self.c3d) assert_almost_equal(res, tgt) #test shape z = np.ones((2, 3)) res = poly.polyval3d(z, z, z, self.c3d) assert_(res.shape == (2, 3)) def test_polygrid2d(self): x1, x2, x3 = self.x y1, y2, y3 = self.y #test values tgt = np.einsum('i,j->ij', y1, y2) res = poly.polygrid2d(x1, x2, self.c2d) assert_almost_equal(res, tgt) #test shape z = np.ones((2, 3)) res = poly.polygrid2d(z, z, self.c2d) assert_(res.shape == (2, 3) * 2) def test_polygrid3d(self): x1, x2, x3 = self.x y1, y2, y3 = self.y #test values tgt = np.einsum('i,j,k->ijk', y1, y2, y3) res = poly.polygrid3d(x1, x2, x3, self.c3d) assert_almost_equal(res, tgt) #test shape z = np.ones((2, 3)) res = poly.polygrid3d(z, z, z, self.c3d) assert_(res.shape == (2, 3) * 3)