def _random_motion_blur(img, kernel_size=7): choice = np.random.choice([0, 1], replace=True, p=[0.666, 0.334]) kernel_size = int( halfnorm.rvs(loc=kernel_size, scale=kernel_size + 1, size=1)[0]) kernel_size = kernel_size if kernel_size % 2 else kernel_size - 1 if choice: # generating the kernel kernel_motion_blur = np.zeros((kernel_size, kernel_size)) kernel_motion_blur[int( (kernel_size - 1) / 2), :] = np.ones(kernel_size) kernel_motion_blur = kernel_motion_blur / kernel_size deg = np.random.uniform(0, 180) kernel_motion_blur_rotated = rotate(kernel_motion_blur, deg, reshape=False) kernel_motion_blur_rotated /= kernel_motion_blur_rotated.sum() # applying the kernel to the input image output = cv2.filter2D(img, -1, kernel_motion_blur_rotated) else: output = img return output.clip(0.0, 255.0)
def _setup(self, X): self.h, self.e, self.v = None, None, None if isinstance(X, np.ndarray): n, m = X.shape avg = np.sqrt(X.mean() / m) iterating = False else: x = next(X) m = len(x) avg = np.sqrt(x.mean() / m) X = chain([x], X) iterating = True self.n_features = m self.iterating = iterating self.W = np.abs( avg * halfnorm.rvs(size=(self.n_features, self.rank)) / np.sqrt(self.rank) ) self.H = [] if self.subspace_tracking: self.vnew = np.zeros_like(self.W) else: self.A = np.zeros((self.rank, self.rank)) self.B = np.zeros((self.n_features, self.rank)) return X
def _setup(self, X, normalize=False): self.h, self.r = None, None if isinstance(X, np.ndarray): n, m = X.shape if normalize: self.X_min = X.min() self.X_max = X.max() self.normalize = normalize # actually scale the data to be between 0 and 1, not just close # to it.. X = _normalize(X, ar_min=self.X_min, ar_max=self.X_max) # X = (X - self.X_min) / (self.X_max - self.X_min) avg = np.sqrt(X.mean() / m) else: if normalize: _logger.warning("Normalization with an iterator is not" " possible, option ignored.") x = next(X) m = len(x) avg = np.sqrt(x.mean() / m) X = chain([x], X) self.nfeatures = m self.W = np.abs(avg * halfnorm.rvs(size=(self.nfeatures, self.rank)) / np.sqrt(self.rank)) self.A = np.zeros((self.rank, self.rank)) self.B = np.zeros((self.nfeatures, self.rank)) return X
def _setup(self, corpus): """Infer info from the first document and initialize matrices. Parameters ---------- corpus : iterable of list(int, float) Training corpus. """ self._h, self._r = None, None first_doc_it = itertools.tee(corpus, 1) first_doc = next(first_doc_it[0]) first_doc = matutils.corpus2csc([first_doc], len(self.id2word)) self.w_std = np.sqrt(first_doc.mean() / (self.num_tokens * self.num_topics)) self._W = np.abs( self.w_std * halfnorm.rvs( size=(self.num_tokens, self.num_topics), random_state=self.random_state ) ) is_great_enough = self._W > self.w_std * self.sparse_coef self._W *= is_great_enough | ~is_great_enough.all(axis=0) self._W = scipy.sparse.csc_matrix(self._W) self.A = scipy.sparse.csr_matrix((self.num_topics, self.num_topics)) self.B = scipy.sparse.csc_matrix((self.num_tokens, self.num_topics))
def _setup(self, corpus): """Infer info from the first document and initialize matrices. Parameters ---------- corpus : iterable of list of (int, float), optional Training corpus. Can be either iterable of documents, which are lists of `(word_id, word_count)`, or a sparse csc matrix of BOWs for each document. If not specified, the model is left uninitialized (presumably, to be trained later with `self.train()`). """ self._h = None if isinstance(corpus, scipy.sparse.csc.csc_matrix): first_doc = corpus.getcol(0) else: first_doc_it = itertools.tee(corpus, 1) first_doc = next(first_doc_it[0]) first_doc = matutils.corpus2csc([first_doc], len(self.id2word)) self.w_std = np.sqrt(first_doc.mean() / (self.num_tokens * self.num_topics)) self._W = np.abs( self.w_std * halfnorm.rvs( size=(self.num_tokens, self.num_topics), random_state=self.random_state ) ) self.A = np.zeros((self.num_topics, self.num_topics)) self.B = np.zeros((self.num_tokens, self.num_topics))
def gen_sample_ret(): alpha = wald.rvs(loc=alpha_mean, scale=alpha_conc) beta = norm.rvs(loc=beta_mean, scale=beta_var) scale = np.random.exponential(scale=scale_rate) mean = halfnorm.rvs(loc=.1, scale=.08) ret = norminvgauss.rvs(alpha, beta, mean, scale) return ret
def __random_disturbance(self, sto_vol: bool, rd_mu: float, rd_sigma: float): if not sto_vol: return np.random.normal(size=(self.T, 1)) else: # error handling for scale < 0, because negative volatilities # doesnt makes sense. return np.random.normal( loc=rd_mu * self.h, scale=rd_sigma * halfnorm.rvs(1) * np.sqrt(self.h), size=(self.T, 1)) * 100 return
def _random_gaussian_blur(img, kernel_size=5): choice = np.random.choice([0, 1], replace=True, p=[0.666, 0.334]) kernel_size = int( halfnorm.rvs(loc=kernel_size, scale=kernel_size + 1, size=1)[0]) kernel_size = kernel_size if kernel_size % 2 else kernel_size - 1 if choice: output = cv2.blur(img, (kernel_size, kernel_size)) else: output = img return output.clip(0.0, 255.0)
def gen_sample_ret(period, size): alpha = wald.rvs(loc=alpha_mean, scale=alpha_conc) beta = norm.rvs(loc=beta_mean, scale=beta_var) scale = np.random.exponential(scale=scale_rate) scale = scale / period mean = halfnorm.rvs(loc=.1, scale=.1) mean = mean / period try: ret = norminvgauss.rvs(alpha, beta, mean, scale, size=size) except Exception as e: ret = norminvgauss.rvs(alpha, beta, mean, scale, size=size) return ret
def _setup(self, v): """Infer info from the first batch and initialize the matrices. Parameters ---------- v : `csc_matrix` with the shape (n_tokens, chunksize) Batch of bows. """ self.w_std = np.sqrt(v.mean() / (self.num_tokens * self.num_topics)) self._W = np.abs(self.w_std * halfnorm.rvs(size=(self.num_tokens, self.num_topics), random_state=self.random_state)) self.A = np.zeros((self.num_topics, self.num_topics)) self.B = np.zeros((self.num_tokens, self.num_topics))
def dg_from_dist(n_samples=25, offset=-10.0): """ Generate some fake results for MMGBSA then return mean and standard error as an uncertainty estimate. Parameters ---------- n_samples: integer Number of samples to draw offset: float Offset from 0 - generally MMGBSA results are more negative than experimental ones """ target = -1 * halfnorm.rvs(size=1)[0] + offset sample = np.random.randn(n_samples) + target return np.mean(sample), np.sd(sample)/np.sqrt(n_samples)
def _setup(self, v): """Infer info from the first batch and initialize the matrices. Parameters ---------- v : `csc_matrix` with the shape (n_tokens, chunksize) Batch of bows. """ self.w_std = np.sqrt(v.mean() / (self.num_tokens * self.num_topics)) self._W = np.abs( self.w_std * halfnorm.rvs( size=(self.num_tokens, self.num_topics), random_state=self.random_state ) ) self.A = np.zeros((self.num_topics, self.num_topics)) self.B = np.zeros((self.num_tokens, self.num_topics))
def generate_user(df): new_profile = pandas.DataFrame(columns=df.columns, index=[df.index[-1] + 1]) new_profile[ 'Bios'] = "Twitteraholic. Extreme web fanatic. Food buff. Infuriatingly humble entrepreneur." # Adding random values for new data for i in new_profile.columns[1:]: if i in ['Religion', 'Politics']: new_profile[i] = numpy.random.choice(combined[i], 1, p=p[i]) elif i == 'Age': new_profile[i] = halfnorm.rvs(loc=18, scale=8, size=1).astype(int) else: new_profile[i] = list( numpy.random.choice(combined[i], size=(1, 3), p=p[i])) new_profile[i] = new_profile[i].apply( lambda x: list(set(x.tolist()))) return new_profile
def rand_minibatch(self, size): ''' get a minibatch of random exp for training use simple memory decay, i.e. sample with a left tail distribution to draw more from latest memory then append with the most recent, untrained experience ''' memory_size = self.size() # increase to k if we skip training to every k time steps latest_batch_size = 1 new_memory_ind = max(0, memory_size - latest_batch_size) old_memory_ind = max(0, new_memory_ind - 1) latest_inds = np.arange(new_memory_ind, memory_size) random_batch_size = size - latest_batch_size rand_inds = ( old_memory_ind - halfnorm.rvs(size=random_batch_size, scale=float(old_memory_ind) * 0.37).astype(int)) inds = np.concatenate([latest_inds, rand_inds]).clip(0) minibatch = self.get_exp(inds) return minibatch
def rand_minibatch(self, size): ''' get a minibatch of random exp for training use simple memory decay, i.e. sample with a left tail distribution to draw more from latest memory then append with the most recent, untrained experience ''' memory_size = self.size() new_exp_size = self.agent.train_per_n_new_exp if memory_size <= size or memory_size <= new_exp_size: inds = np.random.randint(memory_size, size=size) else: new_memory_ind = max(0, memory_size - new_exp_size) old_memory_ind = max(0, new_memory_ind - 1) latest_inds = np.arange(new_memory_ind, memory_size) random_batch_size = size - new_exp_size rand_inds = (old_memory_ind - halfnorm.rvs( size=random_batch_size, scale=float(old_memory_ind)*0.80).astype(int)) inds = np.concatenate([rand_inds, latest_inds]).clip(0) minibatch = self.get_exp(inds) return minibatch
def rand_minibatch(self, size): ''' get a minibatch of random exp for training use simple memory decay, i.e. sample with a left tail distribution to draw more from latest memory then append with the most recent, untrained experience ''' memory_size = self.size() new_exp_size = self.agent.train_per_n_new_exp if memory_size <= size or memory_size <= new_exp_size: inds = np.random.randint(memory_size, size=size) else: new_memory_ind = max(0, memory_size - new_exp_size) old_memory_ind = max(0, new_memory_ind - 1) latest_inds = np.arange(new_memory_ind, memory_size) random_batch_size = size - new_exp_size rand_inds = ( old_memory_ind - halfnorm.rvs(size=random_batch_size, scale=float(old_memory_ind) * 0.80).astype(int)) inds = np.concatenate([rand_inds, latest_inds]).clip(0) minibatch = self.get_exp(inds) return minibatch
def half_normal_draw(sigma): return halfnorm.rvs(loc=0, scale=sigma)
# Expected value of outcome mu = alpha + beta[0] * X1 + beta[1] * X2 # Likelihood (sampling distribution) of observations Y_obs = pm.Normal("Y_obs", mu=mu, sigma=sigma, observed=Y) # maximum a posteriori (MAP) estimate: # map_estimate = pm.find_MAP(model=basic_model) # print(f"Map Estimate:{map_estimate}") times_consumed = [] N = 100 alphas = norm.rvs(size=N) betas = halfnorm.rvs(size=(N, 2)) sigmas = halfnorm.rvs(size=N) print("=========================================") print(f"Tuning NUTS") print("=========================================") n_chains = 4 init_trace = pm.sample(draws=1000, tune=1000, cores=n_chains) cov = np.atleast_1d(pm.trace_cov(init_trace)) start = list(np.random.choice(init_trace, n_chains)) potential = quadpotential.QuadPotentialFull(cov) step_size = init_trace.get_sampler_stats("step_size_bar")[-1] size = m.bijection.ordering.size step_scale = step_size * (size**0.25)
## Foreward array num_points_f = np.zeros(Tnum).astype(np.int64) correlation_f = np.zeros([num_redux, Tnum]) ## Output array CORRELATION = np.zeros([num_iterations * num_redux + 1, Tnum]) CORRELATION[0] = T for ip in range(0, num_iterations): ## New flux array for calculation F1 = np.zeros(tnum) - 100 for ii in range(0, tnum): if F[ii] != -100: if randint(0, 1) == 0: F1[ii] = F[ii] - halfnorm.rvs(scale=Fe_d[ii]) else: F1[ii] = F[ii] + halfnorm.rvs(scale=Fe_u[ii]) ## Forword for ii in range(0, Tnum): if ii == 0: arr_opt = F1 arr_gam = F1 else: arr_opt = F1[ii:] arr_gam = F1[:-ii] bool_arr = np.logical_and(arr_opt != -100, arr_gam != -100) ## Ignore bad points num_points_f[ii] = int(
F_GAM = np.zeros([num_iterations, TNUM]) F_OPT = np.zeros([num_iterations, TNUM]) F_RAT = np.zeros([num_iterations, TNUM]) for jj in range(0,num_iterations): F_gam = np.zeros(TNUM) F_opt = np.zeros(TNUM) ratio_arr = np.zeros(TNUM) rand_points_1 = np.zeros([TNUM,2]) rand_points_2 = np.zeros([TNUM,2]) for ii in range(0,TNUM): ## Gamma-ray if randint(0,1) == 0: F_gam[ii] = F_gam_ratio[ii] - halfnorm.rvs(scale=fe_d_gam_ratio[ii]) else: F_gam[ii] = F_gam_ratio[ii] + halfnorm.rvs(scale=fe_u_gam_ratio[ii]) ## Optical F_opt[ii] = np.random.normal(F_opt_ratio[ii], fe_opt_ratio[ii]) ## ratio if randint(0,1) == 0: ratio_arr[ii] = gam_opt_ratio[ii] - halfnorm.rvs(scale=ratio_err_d[ii]) else: ratio_arr[ii] = gam_opt_ratio[ii] + halfnorm.rvs(scale=ratio_err_u[ii]) F_GAM[jj,:] = F_gam F_OPT[jj,:] = F_opt F_RAT[jj,:] = ratio_arr
import matplotlib.pyplot as plt def const_arrival(): # Constant arrival distribution for generator 1 return 1.0 def const_arrival2(): return 2.0 def dist_size(): return 2.0 if __name__ == '__main__': numargs = halfnorm.numargs [] = [0.7, ] * numargs rv = halfnorm() print("RV : \n", rv) quantile = np.arange(0.01, 1, 0.1) # Random Variates R = halfnorm.rvs(scale=2, size=10) print("Random Variates : \n", R) distribution = np.linspace(0, np.minimum(rv.dist.b, 3)) print("Distribution : \n", distribution) plot = plt.plot(distribution, rv.pdf(distribution)) plt.show()
x = np.linspace(halfnorm.ppf(0.01), halfnorm.ppf(0.99), 100) ax.plot(x, halfnorm.pdf(x), 'r-', lw=5, alpha=0.6, label='halfnorm 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 = halfnorm() ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') # Check accuracy of ``cdf`` and ``ppf``: vals = halfnorm.ppf([0.001, 0.5, 0.999]) np.allclose([0.001, 0.5, 0.999], halfnorm.cdf(vals)) # True # Generate random numbers: r = halfnorm.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 generate_game_difficulty_data(players=100, levels=10, max_sessions=20, max_attempts=10): """ """ data = { 'player_id': [], 'level': [], 'session': [], 'num_success': [], 'num_attempts': [], } true_parameters = { 'player_id': [], 'levels_id': [], 'level_difficulty': [], 'player_ability': [], 'delta': [], 'probability_success': [] } players_ability = [] for player in range(players): player_ability = np.random.normal( np.random.normal(0, 0.5, 1)[0], halfnorm.rvs(loc=0, scale=1, size=1)[0], 1)[0] players_ability.append(player_ability) levels_difficulty = [] for level in range(levels): level_difficulty = np.random.normal( np.random.normal(0, 0.5, 1)[0], halfnorm.rvs(loc=0, scale=1, size=1)[0], 1)[0] levels_difficulty.append(level_difficulty) for player, ability in enumerate(players_ability): for level, difficulty in enumerate(levels_difficulty): delta = ability - difficulty p_success = compute_sigmoid(delta) true_parameters['player_id'].append(player) true_parameters['levels_id'].append(level) true_parameters['level_difficulty'].append(difficulty) true_parameters['player_ability'].append(ability) true_parameters['delta'].append(delta) true_parameters['probability_success'].append(p_success) n_sessions = np.random.randint(1, max_sessions, 1)[0] for session in range(n_sessions): attempts = np.random.randint(1, max_attempts, 1)[0] data['player_id'].append(player) data['level'].append(level) data['session'].append(session) data['num_success'].append(binom.rvs(n=attempts, p=p_success)) data['num_attempts'].append(attempts) true_parameters = pd.DataFrame(true_parameters) df = pd.DataFrame(data) return df, true_parameters
st.header("Finding a Partner with AI Using NaiveBayes, KNN and SVM") st.write("Use Machine Learning to Find the Top Dating Profile Matche") # st.write(combined) image = Image.open('roshan_graffiti.png') st.image(image, use_column_width=True) new_profile = pd.DataFrame(columns=df.columns, index=[df.index[-1] + 1]) random_vals = st.checkbox( "Check here if you would like random values for yourself instead") if random_vals: for i in new_profile.columns[1:]: if i in ['When it comes to love']: new_profile[i] = np.random.choice(combined[i], 1, p=p[i]) elif i == 'Age': new_profile[i] = halfnorm.rvs(loc=18, scale=8, size=1).astype(int) else: new_profile[i] = list( np.random.choice(combined[i], size=(1, 2), p=p[i])) new_profile[i] = new_profile[i].apply( lambda x: list(set(x.tolist()))) else: for i in new_profile.columns: new_profile[i] = st.selectbox(f"Enter your choice for {i}", combined) if i in ['When it comes to love']: new_profile[i] = st.selectbox(f"Enter your choice for {i}", combined[i])
# bool_arr = np.logical_and(bool_arr, arr_gam>0) num_points_f[ii] = int(np.sum(bool_arr)) if int(num_points_f[ii]) > 3: arr_opt = arr_opt[bool_arr] arr_opt_err_d = arr_opt_err_d[bool_arr] arr_opt_err_u = arr_opt_err_u[bool_arr] arr_gam = arr_gam[bool_arr] arr_gam_err_d = arr_gam_err_d[bool_arr] arr_gam_err_u = arr_gam_err_u[bool_arr] for ij in range(0, num_points_f[ii]): #Optical ray points are two half normal distributions # print(arr_opt[ij], arr_opt_err_d[ij], arr_opt_err_u[ij]) if randint(0, 1) == 0: point_opt = arr_opt[ij] - halfnorm.rvs( scale=arr_opt_err_d[ij]) else: point_opt = arr_opt[ij] + halfnorm.rvs( scale=arr_opt_err_u[ij]) #Gamma ray points are two half normal distributions if randint(0, 1) == 0: point_gam = arr_gam[ij] - halfnorm.rvs( scale=arr_gam_err_d[ij]) else: point_gam = arr_gam[ij] + halfnorm.rvs( scale=arr_gam_err_u[ij]) if ij == 0: all_points = np.array([[point_opt, point_gam]]) else:
CORRELATION = np.zeros([2 * num_iterations * num_redux + 1, 2 * Tnum - 1]) T_b = T[::-1] TT = np.concatenate((-T_b[:-1], T)) CORRELATION[0] = TT for ip in range(0, num_iterations): ## New flux arrays for calculation F1_gam = np.zeros(tnum) - 100 F1_opt = np.zeros(tnum) - 100 for ii in range(0, tnum): ## Gamma-ray if F_gam[ii] != -100: if randint(0, 1) == 0: F1_gam[ii] = F_gam[ii] - halfnorm.rvs(scale=fe_gam_d[ii]) else: F1_gam[ii] = F_gam[ii] + halfnorm.rvs(scale=fe_gam_u[ii]) ## Optical if F_opt[ii] != -100: F1_opt[ii] = np.random.normal(F_opt[ii], fe_opt[ii]) ## Forword for ii in range(0, Tnum): if ii == 0: arr_opt = F1_opt arr_gam = F1_gam else: arr_opt = F1_opt[ii:] arr_gam = F1_gam[:-ii]
def __call__(self, sample): out_size = sample['SignalWaterfalls'].shape noise = halfnorm.rvs(size=out_size) sample['Waterfalls'] = sample['SignalWaterfalls'] + noise return sample
def half_normal_draw(sigma): return halfnorm.rvs(loc=0,scale=sigma)
def refining_profile_data(df): # Removing the numerical data df = df[['Bios']] # Creating Lists for the Categories # Probability dictionary p = {} # Movie Genres movies = [ 'Adventure', 'Action', 'Drama', 'Comedy', 'Thriller', 'Horror', 'RomCom', 'Musical', 'Documentary' ] p['Movies'] = [0.28, 0.21, 0.16, 0.14, 0.09, 0.06, 0.04, 0.01, 0.01] # TV Genres tv = [ 'Comedy', 'Drama', 'Action/Adventure', 'Suspense/Thriller', 'Documentaries', 'Crime/Mystery', 'News', 'SciFi', 'History' ] p['TV'] = [0.30, 0.23, 0.12, 0.12, 0.09, 0.08, 0.03, 0.02, 0.01] # Religions (could potentially create a spectrum) religion = [ 'Catholic', 'Christian', 'Jewish', 'Muslim', 'Hindu', 'Buddhist', 'Spiritual', 'Other', 'Agnostic', 'Atheist' ] p['Religion'] = [ 0.16, 0.16, 0.01, 0.19, 0.11, 0.05, 0.10, 0.09, 0.07, 0.06 ] # Music music = [ 'Rock', 'HipHop', 'Pop', 'Country', 'Latin', 'EDM', 'Gospel', 'Jazz', 'Classical' ] p['Music'] = [0.30, 0.23, 0.20, 0.10, 0.06, 0.04, 0.03, 0.02, 0.02] # Sports sports = [ 'Football', 'Baseball', 'Basketball', 'Hockey', 'Soccer', 'Other' ] p['Sports'] = [0.34, 0.30, 0.16, 0.13, 0.04, 0.03] # Politics (could also put on a spectrum) politics = [ 'Liberal', 'Progressive', 'Centrist', 'Moderate', 'Conservative' ] p['Politics'] = [0.26, 0.11, 0.11, 0.15, 0.37] # Social Media social = [ 'Facebook', 'Youtube', 'Twitter', 'Reddit', 'Instagram', 'Pinterest', 'LinkedIn', 'SnapChat', 'TikTok' ] p['Social Media'] = [0.36, 0.27, 0.11, 0.09, 0.05, 0.03, 0.03, 0.03, 0.03] # Age (generating random numbers based on half normal distribution) age = halfnorm.rvs(loc=18, scale=8, size=df.shape[0]).astype(int) # Lists of Names and the list of the lists categories = [movies, tv, religion, music, politics, social, sports, age] names = [ 'Movies', 'TV', 'Religion', 'Music', 'Politics', 'Social Media', 'Sports', 'Age' ] combined = dict(zip(names, categories)) # Establishing random values for each category # Looping through and assigning random values for name, cats in combined.items(): if name in ['Religion', 'Politics']: # Picking only 1 from the list df[name] = numpy.random.choice(cats, df.shape[0], p=p[name]) elif name == 'Age': # Generating random ages based on a normal distribution df[name] = cats else: # Picking 3 from the list try: df[name] = list( numpy.random.choice(cats, size=(df.shape[0], 1, 3), p=p[name])) except Exception as ex: print(ex) df[name] = list( numpy.random.choice(cats, size=(df.shape[0], 1, 3))) df[name] = df[name].apply(lambda x: list(set(x[0].tolist()))) df['Religion'] = pandas.Categorical(df.Religion, ordered=True, categories=[ 'Catholic', 'Christian', 'Jewish', 'Muslim', 'Hindu', 'Buddhist', 'Spiritual', 'Other', 'Agnostic', 'Atheist' ]) df['Politics'] = pandas.Categorical(df.Politics, ordered=True, categories=[ 'Liberal', 'Progressive', 'Centrist', 'Moderate', 'Conservative' ]) return df
LNA = 0. LNA_low = 0. LNA_high = 0. # LNA_p = np.zeros(num_it) BETA = np.zeros(num_it) BETA_low = np.zeros(num_it) BETA_high = np.zeros(num_it) BETA_p = np.zeros(num_it) for kk in range(0, num_it): logflux_rand = np.zeros(len(lnE)) for jj in range(0, len(lnE)): if randint(0, 1) == 0: logflux_rand[jj] = logflux[jj] - halfnorm.rvs( scale=logflux_err_d[jj]) else: logflux_rand[jj] = logflux[jj] + halfnorm.rvs( scale=logflux_err_u[jj]) dlogflux_rand = (logflux_rand[1:] - logflux_rand[:-1]) / (lnE[1:] - lnE[:-1]) beta, lnA = np.linalg.lstsq(MAT, logflux_rand, rcond=None)[0] beta_low, lnA_low = np.linalg.lstsq(MAT_low, logflux_rand[ENERGY < 1.e4], rcond=None)[0] if len(lnE[ENERGY >= 1.e4]) > 1: beta_high, lnA_high = np.linalg.lstsq(MAT_high, logflux_rand[ENERGY >= 1.e4], rcond=None)[0]
def halfnormal(num_samples: int) -> npt.NDArray[np.float64]: return tp.cast( npt.NDArray[np.float64], halfnorm.rvs(scale=1, size=num_samples) )
def func(): return halfnorm.rvs(scale=np.sqrt(np.pi / 2), size=1)
def sample(self): X = halfnorm.rvs(size=self.size) return X