def init_orbit(randomstat=1): #initial the basic param array for a system mass_pl=np.zeros(N_pl) a_pl=np.zeros(N_pl) r_pl=np.zeros(N_pl) #changed to radius rather than density #initial semi-major axis and masses of gas giant, #in solar units gpmass=3 sesemi=1 semass=2 #fixed if gpmass==1: mass_pl[0]=1.e-3 mass_pl[1]=1.e-3 mass_pl[2]=1.e-3 elif gpmass==2: #uniform in a mass range mass_pl[:3]=(0.5+np.random.random(3)*1.5)*1.e-3 elif gpmass==3: mass_pl[:3]=(0.3+np.random.random(3)*2.7)*1.e-3 a_inner,a_pl[:3]=set_hill(mass_pl[:3]) ##need to move to setting file in the future if sesemi==1: a_pl[3]=0.1 a_pl[4]=0.25 a_pl[5]=0.5 elif sesemi==2: a_pl[3:]=semi_major() #initial semi-major axis and masses of super earths, #in solar units M_earth=1./300./1000. if semass==1: mass_pl[3]=5*M_earth mass_pl[4]=10*M_earth mass_pl[5]=15*M_earth elif semass==2: marr=np.array([5.,10.,15.]) sortindex=np.random.choice(3,3,False) print sortindex for i in xrange(3): mass_pl[3+i]=marr[sortindex[i]]*M_earth r_pl[:3]=5e-4 r_pl[3:]=1e-4 #set up other orbital elements e_pl=rayleigh.rvs(scale=sigma_e,size=N_pl,random_state=randomstat) i_pl=rayleigh.rvs(scale=sigma_i,size=N_pl,random_state=randomstat+1000) np.random.seed(randomstat+2000) omega_pl=2.*np.pi*np.random.rand(N_pl) Omega_pl=2.*np.pi*np.random.rand(N_pl) M_pl=2.*np.pi*np.random.rand(N_pl) return [mass_pl,a_pl,r_pl,e_pl,i_pl,omega_pl,Omega_pl,M_pl]
def main(): for i in xrange(1,max_runs+1): rundir="run%d" % i os.system("mkdir %s" % rundir) for ex in excutable: os.system("cp %s %s/" % (ex,rundir)) for infile in inlist: os.system("cp %s %s/" % (infile,rundir)) #initial the basic param array for a system mass_pl=np.zeros(N_pl) a_pl=np.zeros(N_pl) d_pl=np.zeros(N_pl) #initial semi-major axis and masses of gas giant, #in solar units mass_pl[0]=1.e-3 mass_pl[1]=1.e-3 mass_pl[2]=1.e-3 a_inner,a_pl[:3]=set_hill(mass_pl[:3]) #initial semi-major axis and masses of super earths, #in solar units M_earth=1./300./1000. mass_pl[3]=5*M_earth mass_pl[4]=10*M_earth mass_pl[5]=15*M_earth #need to move to setting file in the future a_pl[3]=0.1 a_pl[4]=0.25 a_pl[5]=0.5 #need to modify in the future how this is set up d_pl[:2]=1.3 d_pl[3:]=4. #set up other orbital elements e_pl=rayleigh.rvs(scale=sigma_e,size=6) i_pl=rayleigh.rvs(scale=sigma_i,size=6) g_pl=360.*np.random.randn(N_pl) n_pl=360.*np.random.randn(N_pl) M_pl=360.*np.random.randn(N_pl) t_max=t_orb*365.25*(a_inner)**1.5 t_dump=t_max/1000. #write to big.in outfile = rundir+"/big.in" writetobig(mass_pl,a_pl,d_pl,e_pl,i_pl,g_pl,n_pl,M_pl,outfile) abspath=basename+rundir+"/" subfile=basename+rundir+"/submit_mercury" #subfile=rundir+"/submit_mercury" submit(abspath,subfile) return
def select_transmitting_users(self): transmitting_users = [] for user in self.users: user.csi = rayleigh.rvs() if user.csi >= self.communication_thresh: transmitting_users.append(user) return transmitting_users
def system_noise(nscan=200, noise_dist='gaussian', sigma=1, dim=None): """ Generate system noise Args: nscan (int): Total time of design (in scans) noise_dist (string): Noise distribution, one of: "gaussian", "rayleigh" sigma (float): Sigma of noise distribution dim (list): XYZ Dimensions of output Returns: A ndarray [dim, nscan] with the noise timeseries Raises: Exception """ # Handle the dim parameter mydim = _handle_dim(dim) mydim.append(nscan) if noise_dist == 'gaussian': return norm.rvs(scale=sigma, size=mydim) elif noise_dist == 'rayleigh': return rayleigh.rvs(scale=sigma, size=mydim) else: raise Exception('Unknown noise distribution provided: {}'.format( noise_dist))
def system_noise(nscan=200, noise_dist='gaussian', sigma=1, dim=None): """ Generate system noise Args: nscan (int): Total time of design (in scans) noise_dist (string): Noise distribution, one of: "gaussian", "rayleigh" sigma (float): Sigma of noise distribution dim (list): XYZ Dimensions of output Returns: A ndarray [dim, nscan] with the noise timeseries Raises: Exception """ # Handle the dim parameter mydim = _handle_dim(dim) mydim.append(nscan) if noise_dist == 'gaussian': return norm.rvs(scale=sigma, size=mydim) elif noise_dist == 'rayleigh': return rayleigh.rvs(scale=sigma, size=mydim) else: raise Exception( 'Unknown noise distribution provided: {}'.format(noise_dist))
def user_dist_kstest(sim_dist_vec, diff_dist_vec, fit_rayleigh=False, _n=100): """ Test the goodness of a given weights to defferentiate friend distance distributions and non-friend distance distributions of a given user. The distance distribution can be assumed to follow Rayleigh distribution. Parameters: ---------- sim_dist_vec: {vector-like (list), float}, distances between friends and the user diff_dist_vec: {vector-like (list), float}, distances between non-fri -ends and the user fit_rayleigh: {boolean}, determine if fit data into Rayleigth distri -bution _n: {integer}, number of random samples generated from estimated distribution Returns: ------- * res: {float}: p-value of ks-tests with assumption that distances follow Rayleigh distribution. Examples: --------- pval = user_dist_kstest(sim_dist_vec, diff_dist_vec) """ # convert list to numpy.arrray, which can be # automatice transfer to R readable objects # for R-function, if the proper setting is # configured sim_dist_vec = np.array(sim_dist_vec) diff_dist_vec = np.array(diff_dist_vec) if fit_rayleigh: friend_param = rayleigh.fit(sim_dist_vec) nonfriend_param = rayleigh.fit(diff_dist_vec) samp_friend = rayleigh.rvs(friend_param[0], friend_param[1], _n) samp_nonfriend = rayleigh.rvs(nonfriend_param[0], nonfriend_param[1], _n) # ouput p-value of ks-tests test_stat, pval = kstest_2samp_greater(samp_friend, samp_nonfriend) else: test_stat, pval = kstest_2samp_greater(sim_dist_vec, diff_dist_vec) return pval
def user_dist_kstest(sim_dist_vec, diff_dist_vec, fit_rayleigh=False, min_nobs=10, _n=100): """ Test the goodness of a given weights to defferentiate friend distance distributions and non-friend distance distributions of a given user. The distance distribution is considered to follow Rayleigh distribution. Parameters: ---------- sim_dist_vec: {vector-like (list), float}, distances between friends and the user diff_dist_vec: {vector-like (list), float}, distances between non-fri -ends and the user fit_rayleigh: {boolean}, determine if fit data into Rayleigth distri -bution min_nobs: {integer}, minmum number of observations required for compar -ing _n: {integer}, number of random samples generated from estimated distribution Returns: ------- * res: {float}: p-value of ks-test with assumption that distances follow Rayleigh distribution. Examples: --------- pval = user_dist_kstest(sim_dist_vec, diff_dist_vec) """ # is_valid = (len(sim_dist_vec) >= min_nobs) & \ # (len(diff_dist_vec) >= min_nobs) # not used yet if fit_rayleigh: friend_param = rayleigh.fit(sim_dist_vec) nonfriend_param = rayleigh.fit(diff_dist_vec) samp_friend = rayleigh.rvs(friend_param[0], friend_param[1], _n) samp_nonfriend = rayleigh.rvs(nonfriend_param[0], nonfriend_param[1], _n) # ouput p-value of ks-test res = ks_2samp(samp_friend, samp_nonfriend)[1] else: res = ks_2samp(sim_dist_vec, diff_dist_vec)[1] return res
def AudioSpectrumData(t, Nbands): # Nbands = # of frequency bands npts = len(t) blms = np.zeros((npts, Nbands)) for jj in range(Nbands): blms[:,jj] = rayleigh.rvs(size = npts) return blms
def ProximityData(t, d_0, dx, N): # average distance = d_0 # movement scale is dx # number of prox sensors = N d = d_0 * np.ones((len(t), N)) # average distance is d_0 [m] for ii in range(len(t)): for jj in range(N): deltaX = rayleigh.rvs() - 1 d[ii, jj] = d[ii - 1, jj] + deltaX return d
def init_orbit3(randomstat=1): M_earth=1./300./1000. R_earth = 6371./1.49e8 density = 3*M_earth/(4*np.pi*R_earth**3) mass_pl = np.ones(N_pl)*M_earth*5 r_pl = (3*mass_pl/(4*np.pi*density))**(1./3.) a_pl = np.zeros(N_pl) e_pl = np.zeros(N_pl) i_pl=rayleigh.rvs(scale=sigma_i,size=N_pl,random_state=randomstat+1000) omega_pl=2.*np.pi*np.random.rand(N_pl) Omega_pl=2.*np.pi*np.random.rand(N_pl) M_pl=2.*np.pi*np.random.rand(N_pl) a_pl[0] = 0.15 e_pl = rayleigh.rvs(scale=0.15,size=N_pl,random_state=randomstat+1000) peri = a_pl[0]*(1+e_pl[0])*(1 - np.random.rand()/10.) a_pl[1] = peri/(1.-e_pl[1]) accreting_planet = np.random.choice([0,1]) mass_pl[accreting_planet]=12*M_earth r_pl[accreting_planet]=a_pl[accreting_planet]*(1-e_pl[accreting_planet])*(mass_pl[accreting_planet]/3)**(1./3.) return [mass_pl,a_pl,r_pl,e_pl,i_pl,omega_pl,Omega_pl,M_pl]
def initialize(self, method='cauchy'): if method.lower() == 'student': self.scales = 1. / sqrt(gamma.rvs(1, 0, 1, size=self.num_scales)) elif method.lower() == 'cauchy': self.scales = 1. / sqrt(gamma.rvs(0.5, 0, 2, size=self.num_scales)) elif method.lower() == 'laplace': self.scales = rayleigh.rvs(size=self.num_scales) else: raise ValueError( 'Unknown initialization method \'{0}\'.'.format(method)) self.normalize()
def getSamples(self, m=None): """ Generates samples from the Rayleigh distribution. :param rayleigh self: An instance of the Rayleigh class. :param integer m: Number of random samples. If no value is provided, a default of 5e5 is assumed. :return: A N-by-1 vector that contains the samples. """ if m is not None: number = m else: number = 500000 return rayleigh.rvs(loc=0.0, scale=self.scale, size=number, random_state=None)
def get_samples(self, m=None): """ Generates samples from the Rayleigh distribution. :param rayleigh self: An instance of the Rayleigh class. :param integer m: Number of random samples. If no value is provided, a default of 5e5 is assumed. :return: A N-by-1 vector that contains the samples. """ if m is not None: number = m else: number = 500000 return rayleigh.rvs(loc=0.0, scale=self.scale, size=number, random_state=None)
def initialize(self, method='student'): """ Randomly initializes parameters. """ if method.lower() == 'student': self.scales = 1. / sqrt(gamma.rvs(1, 0, 1, size=self.num_components)) self.means *= 0. elif method.lower() == 'cauchy': self.scales = 1. / sqrt(gamma.rvs(0.5, 0, 2, size=self.num_components)) self.means *= 0. elif method.lower() == 'laplace': self.scales = rayleigh.rvs(size=self.num_components) self.means *= 0. else: raise ValueError('Unknown initialization method \'{0}\'.'.format(method))
def set_fake_counterparts(self, candidates): from scipy.stats import rayleigh # Assign fake counterparts idx_fake = np.random.choice(len(candidates), len(self)) cat_fake = candidates[idx_fake] # Calculate coordinates for fake candidates # We randomize the positions of the fake counterpart around the # positions of the primary sources using a Rayleigh distribution mean_ra_fake = self.coords.ra.deg mean_dec_fake = self.coords.dec.deg # To estimate the variance for the Rayleigh distribution, we # circularize the errors of both catalogues: pcat_poserr_circ = self.poserr.transform_to('circle') cat_fake_poserr_circ = cat_fake.poserr.transform_to('circle') sig_fake = np.sqrt( (pcat_poserr_circ.components.columns[0].to(u.deg))**2 + (cat_fake_poserr_circ.components.columns[0].to(u.deg))**2 ) dr = rayleigh.rvs(loc=0.0, scale=sig_fake.value) theta = 2 * np.pi * np.random.random_sample(size=len(cat_fake)) coords_ra_fake = mean_ra_fake + dr * np.cos(theta) coords_dec_fake = mean_dec_fake + dr * np.sin(theta) cat_fake.coords = SkyCoord(coords_ra_fake, coords_dec_fake, unit="deg") cat_fake.moc = self.moc cat_fake.area = self.area # We set the ids of the fake counterparts as the ids of this catalogue # for an easy identification of true counterparts cat_fake.ids = self.ids return cat_fake
def next_ttr(final_downtime_model, CRN=None): dist = final_downtime_model[0] params = final_downtime_model[1] if dist == "uniform": return uniform.rvs(*params, random_state=CRN) elif dist == "expon": return expon.rvs(*params, random_state=CRN) elif dist == "rayleigh": return rayleigh.rvs(*params, random_state=CRN) elif dist == "weibull_min": return weibull_min.rvs(*params, random_state=CRN) elif dist == "gamma": return gamma.rvs(*params, random_state=CRN) elif dist == "gengamma": return gengamma.rvs(*params, random_state=CRN) elif dist == "invgamma": return invgamma.rvs(*params, random_state=CRN) elif dist == "gompertz": return gompertz.rvs(*params, random_state=CRN) elif dist == "lognorm": return lognorm.rvs(*params, random_state=CRN) elif dist == "exponweib": return exponweib.rvs(*params, random_state=CRN)
from scipy.stats import norm, rayleigh from numpy import linspace from pylab import plot, show, hist, figure, title """ here we try to fit rayleigh distribution to data reference: glowingpython.blogspot.it""" #generate 150 samples from a rayleigh distribution of mean 5 and std dev 2 samp = rayleigh.rvs(loc=5, scale=2, size=150) #fit rayleigh distibution to generated samples #param[0] & param[1] are mean and std. dev of fitted distribution param = rayleigh.fit(samp) #generate points on x-axis to plot x = linspace(5, 13, 100) #get the points on y-axis for fitted distribution pdf_fitted = rayleigh.pdf(x, loc=param[0], scale=param[1]) #get the points on y-axis for original distribution pdf = rayleigh.pdf(x, loc=5, scale=2) title('Rayleigh distribution') #plot the fitted distribution and original distribution plot(x, pdf_fitted, 'r-', x, pdf, 'b-') #histogram of normalized samples generated from rayleigh distribution hist(samp, normed=1, alpha=0.3) show()
# Display the probability density function (``pdf``): x = np.linspace(rayleigh.ppf(0.01), rayleigh.ppf(0.99), 100) ax.plot(x, rayleigh.pdf(x), 'r-', lw=5, alpha=0.6, label='rayleigh pdf') # Alternatively, the distribution object can be called (as a function) # to fix the shape, location and scale parameters. This returns a "frozen" # RV object holding the given parameters fixed. # Freeze the distribution and display the frozen ``pdf``: rv = rayleigh() ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') # Check accuracy of ``cdf`` and ``ppf``: vals = rayleigh.ppf([0.001, 0.5, 0.999]) np.allclose([0.001, 0.5, 0.999], rayleigh.cdf(vals)) # True # Generate random numbers: r = rayleigh.rvs(size=1000) # And compare the histogram: ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) ax.legend(loc='best', frameon=False) plt.show()
def init_orbit(runnumber, small_WJ_radius = True): #initial the basic param array for a system mass_pl=np.zeros(N_pl) a_pl=np.zeros(N_pl) r_pl=np.zeros(N_pl) #changed to radius rather than density #a_inner,a_pl[:3]=set_hill(mass_pl[:3]) #initial semi-major axis and masses of super earths, #in solar units M_earth=1./300./1000. R_earth = 6371./1.49e8 density = 3*M_earth/(4*np.pi*R_earth**3) loop = True seeds=(np.random.rand(500)*1000).astype(int) # this serie is likely to be the same for your paralleal runs (at least for those in the same node, but will be different between different trials [today's run and next week's run]) newseed = seeds[runnumber] # this operation ensure the seed between the runs are different. np.random.seed(newseed) #use the new seed #draw orbital element below without randomstat argument while (loop==True): #set up other orbital elements e_pl=rayleigh.rvs(scale=sigma_e,size=N_pl) i_pl=rayleigh.rvs(scale=sigma_i,size=N_pl) omega_pl=2.*np.pi*np.random.rand(N_pl) Omega_pl=2.*np.pi*np.random.rand(N_pl) M_pl=2.*np.pi*np.random.rand(N_pl) mass_pl = np.random.normal(loc=5*M_earth,scale = 2*M_earth,size=N_pl) if any(mass_pl<0.5*M_earth) or any(mass_pl>10*M_earth): #ensures mass is between 0.5 and 10 Earth Masses continue r_pl =(3*mass_pl/(4*np.pi*density))**(1./3.) K = np.random.normal(loc=k_Hill,scale=2) if K <=0: #ensures seperation between planets is positive continue P_min =rayleigh.rvs(scale=P_inner/(365.)) a_min = P_min**(2./3.) in_range=[] a_pl[0] = a_min for i in range(1,N_pl): #set up ladder of planets m_ratio = 2*(3/(mass_pl[i-1]+mass_pl[i]))**(1./3.) a_pl[i] =(K/m_ratio + 1)/(1 - K/m_ratio)*a_pl[i-1] if a_pl[i]>0.1 and a_pl[i]<0.4: in_range.append(i) if len(in_range)>0: #ensures there is always at least 1 planet in the WJ range accreting_planet = np.random.choice(in_range) if accreting_planet > N_pl-2: #ensures each WJ has at least 2 outer neighbors continue mass_pl[accreting_planet]=12*M_earth loop=False if small_WJ_radius: #settings for different Warm Jupiter radii r_pl[accreting_planet]=a_pl[accreting_planet]*(1-e_pl[accreting_planet])*(mass_pl[accreting_planet]/3)**(1./3.)/10. else: r_pl[accreting_planet]=a_pl[accreting_planet]*(1-e_pl[accreting_planet])*(mass_pl[accreting_planet]/3)**(1./3.) for i in range(accreting_planet,N_pl): #adjust ladder of planets for WJ if i>0: m_ratio = 2*(3/(mass_pl[i-1]+mass_pl[i]))**(1./3.) a_pl[i] =(K/m_ratio + 1)/(1 - K/m_ratio)*a_pl[i-1] #print mass_pl, a_pl, r_pl, e_pl, i_pl, omega_pl, Omega_pl, M_pl return [mass_pl,a_pl,r_pl,e_pl,i_pl,omega_pl,Omega_pl,M_pl]
from scipy.stats import rayleigh import seaborn as sb import matplotlib.pyplot as plt c = rayleigh.rvs(0.5,size=10000) ax = sb.distplot(c,kde=True,color='crimson',hist_kws={"linewidth": 25,'alpha':1}) ax.set(xlabel='Rayleigh', ylabel='Frequency') plt.show()
from scipy.stats import norm, rayleigh from numpy import linspace from pylab import plot, show, hist, figure, title # 依照 rayleigh 分布產生數據 y = rayleigh.rvs(loc=5, scale=2, size=150) # fitting param = rayleigh.fit(y) # 畫圖 x = linspace(5, 13, 100) # fitted distribution pdf_fitted = rayleigh.pdf(x, loc=param[0], scale=param[1]) # original distribution pdf = rayleigh.pdf(x, loc=5, scale=2) title('Rayleigh distribution') plot(x, pdf_fitted, 'r-', x, pdf, 'b-') # hist(y, normed=1, alpha=.3) hist(y, density=1, alpha=.3) show()
def gen_sample(self, n): return rayleigh.rvs(loc=self.mu, scale=self.sigma, size=n)
def rayleigh_ch(self): rch=rayleigh.rvs(size=len(self.modulated)) self.rch_mod=self.modulated+rch return self.rch_mod
def f(x): return rayleigh.rvs(1000)
from scipy.stats import rayleigh import numpy as np import matplotlib.pyplot as plt a = rayleigh.rvs(2, size=100) print(float(np.mean(a))) print(np.std(a)) plt.hist(a, bins=10, density=True, color='green') plt.xlabel('$x$') plt.ylabel('$y$') plt.show()
from scipy.stats import norm, rayleigh import matplotlib.pyplot as plt import matplotlib.mlab as mlab import numpy as np samp = rayleigh.rvs(loc=5, scale=2, size=150) # samples generation print(samp) param = rayleigh.fit(samp) # distribution fitting x = np.linspace(5, 13, 100) # fitted distribution pdf_fitted = rayleigh.pdf(x, loc=param[0], scale=param[1]) # original distribution pdf = rayleigh.pdf(x, loc=5, scale=2) plt.title('Rayleigh distribution') plt.plot(x, pdf_fitted, 'r-', x, pdf, 'b-') plt.hist(samp, normed=1, alpha=.3) plt.show()
def rf1(): return rayleigh.rvs(sigma_rayleigh, size = n)