def plot_separation(self, i, snp, sep, data): '''Plot separation of IBD clique at sample i, SNP snp.''' parents = [ self.ped.sample_id[self.ped.graph.predecessors(i)[a]] for a in im.constants.ALLELES ] print data print 'data[0]', data[0] print 'data[1]', data[1] (k00, k10, k01, k11), line = data[0:2] P.figure(1) P.clf() P.hold(True) # P.scatter([p], [q], color='k') P.scatter(k00, k10, color='r') P.scatter(k01, k11, color='b') if line is not None: a0, b0, a1, b1 = line t = linspace(0, max(k00)) P.plot(t, polyval([a0, b0], t), 'r') t = linspace(0, max(k01)) P.plot(t, polyval([a1, b1], t), 'b') P.title('Sample %d, SNP %d, inbreeding=%.4f, separation=%.2f' % (i, snp, self.params.kinship(parents[0], parents[1]), sep)) P.show() P.savefig(os.environ['OBER'] + '/doc/poo/sep-chr%d-%d-%d.png' % (self.chrom, i, snp))
def test_predict(self): # define some easy training data and predict predictive distribution circle1 = Ring(variance=1, radius=3) circle2 = Ring(variance=1, radius=10) n = 100 X = circle1.sample(n / 2).samples X = vstack((X, circle2.sample(n / 2).samples)) y = ones(n) y[:n / 2] = -1.0 # plot(X[:n/2,0], X[:n/2,1], 'ro') # hold(True) # plot(X[n/2:,0], X[n/2:,1], 'bo') # hold(False) # show() covariance = SquaredExponentialCovariance(1, 1) likelihood = LogitLikelihood() gp = GaussianProcess(y, X, covariance, likelihood) # predict on mesh n_test = 20 P = linspace(X[:, 0].min() - 1, X[:, 1].max() + 1, n_test) Q = linspace(X[:, 1].min() - 1, X[:, 1].max() + 1, n_test) X_test = asarray(list(itertools.product(P, Q))) # Y_test = exp(LaplaceApproximation(gp).predict(X_test).reshape(n_test, n_test)) Y_train = exp(LaplaceApproximation(gp).predict(X)) print Y_train print Y_train>0.5 print y
def main(): # b = loadroot("ntuples300w5.root") # b.loadfile() # # b.getwidthdata(0.1) # print(b.gethist()) bins = linspace(0, 1000, 20) plot_mass(300, bins) bins = linspace(0, 1000, 20) plot_mass(500, bins) bins = linspace(400, 1600, 20) plot_mass(1000, bins) bins = linspace(1000, 3000, 20) plot_mass(2000, bins)
def test_get_gaussian_2d(self): X = asarray([-1, 1]) X = reshape(X, (len(X), 1)) y = asarray([+1 if x >= 0 else -1 for x in X]) covariance = SquaredExponentialCovariance(sigma=1, scale=1) likelihood = LogitLikelihood() gp = GaussianProcess(y, X, covariance, likelihood) laplace = LaplaceApproximation(gp, newton_start=asarray([3, 3])) f_mode, L, steps = laplace.find_mode_newton(return_full=True) gaussian = laplace.get_gaussian(f_mode, L) F = linspace(-10, 10, 20) D = zeros((len(F), len(F))) Q = array(D, copy=True) for i in range(len(F)): for j in range(len(F)): f = asarray([F[i], F[j]]) D[i, j] = gp.log_posterior_unnormalised(f) Q[i, j] = gaussian.log_pdf(f.reshape(1, len(f))) subplot(1, 2, 1) pcolor(F, F, D) hold(True) plot(steps[:, 0], steps[:, 1]) plot(f_mode[1], f_mode[0], 'mo', markersize=10) hold(False) colorbar() subplot(1, 2, 2) pcolor(F, F, Q) hold(True) plot(f_mode[1], f_mode[0], 'mo', markersize=10) hold(False) colorbar() # show() clf()
def get_distance(x1, y1, x2, y2, points=10000, show_direction = False): y_max = 2000.0 y_min = -200.0 f1_inv = get_inverse_function(x1, y1) f2_inv = get_inverse_function(x2, y2) y = linspace(y_max, y_min, points) dist = list() dist_y = list() min_points = list() max_points = list() for y_n in y: if show_direction == False: d = abs(f1_inv(y_n) - f2_inv(y_n)) elif show_direction == True: d = f1_inv(y_n) - f2_inv(y_n) dist.append(d) max_y = y[dist.index(max(dist))] min_y = y[dist.index(min(dist))] dist = [max(dist), min(dist), sum(dist)/float(len(dist))] min_points = [[f1_inv(min_y), min_y],[f2_inv(min_y), min_y]] max_points = [[f1_inv(max_y), max_y],[f2_inv(max_y), max_y]] return dist, min_points, max_points
def resample_trajectory(self, trajectory: ip.VelocityTrajectory, n: int, k: int = 3): zeros = [id for id in np.argwhere(trajectory.velocity <= trajectory.velocity_stop)] if zeros and len(zeros) < len(trajectory.velocity) - 1: path = np.delete(trajectory.path, zeros, axis=0) velocity = np.delete(trajectory.velocity, zeros) heading = np.delete(trajectory.heading, zeros) timesteps = np.delete(trajectory.timesteps, zeros) else: path = trajectory.path velocity = trajectory.velocity heading = trajectory.heading timesteps = trajectory.timesteps trajectory_nostop = ip.VelocityTrajectory(path, velocity, heading, timesteps) u = trajectory_nostop.pathlength u_new = linspace(0, u[-1], n) k = min(k, len(velocity) - 1) if k != 0: tck, _ = splprep([path[:, 0], path[:, 1], velocity, heading], u=u, k=k, s=0) tck[0] = self.fix_points(tck[0]) path_new = np.empty((n, 2), float) path_new[:, 0], path_new[:, 1], velocity_new, heading_new = splev(u_new, tck) trajectory_resampled = ip.VelocityTrajectory(path_new, velocity_new, heading_new) else: trajectory_resampled = trajectory return trajectory_resampled
def plot(hist0, hist1, gaus0, gaus1): xvals = linspace(0.0, 1.0, linspace_size) plt.figure() if hist0 is not None and hist1 is not None: if gaus0 is not None and gaus1 is not None: plt.subplot(1, 2, 1) plt.hist([ hist1, hist0, ], 10, normed=False, histtype='bar', stacked=False, label=[u"pozitívne", u"negatívne"]) plt.xlabel(u'Výstup klasifikátora') plt.ylabel(u'Počet') plt.legend(loc=0) if gaus0 is not None and gaus1 is not None: if hist0 is not None and hist1 is not None: plt.subplot(1, 2, 2) plt.hold(True) plt.plot(xvals, gaus1(xvals), label=u"pozitívne", linewidth=line_width) plt.plot(xvals, gaus0(xvals), label=u"negatívne", linewidth=line_width) plt.xlabel(u'Výstup klasifikátora') plt.ylabel(u'Hustota') plt.legend(loc=9)
def solveSystem (t, y): # System: y = 1 - exp^(-t/T) ^ t: time[s] T: time constant[s] # Isolate T: # ln(1 - y) * T = -t for y < 1 # A[m x 1]: ln(1 - y_i) m equations # b[m x 1]: -t_i i index # Generate normal equations A^T * A * x = A^T * b A = [] b = [] for i in range(len(t)): A.append(math.log(1 - y[i])) b.append([-t[i]]) A = numpy.array(A) b = numpy.array(b) A_norm = numpy.dot(numpy.transpose(A), A) b_norm = numpy.dot(numpy.transpose(A), b) # Solve T = b_norm / A_norm # Setup output lMin = min(t) lMax = max(t) t = linspace(lMin, lMax, 10000) y = numpy.array([1 - math.exp(-i/T) for i in t]) return T, t, y
def test_mode_newton_2d(self): X = asarray([-1, 1]) X = reshape(X, (len(X), 1)) y = asarray([+1 if x >= 0 else -1 for x in X]) covariance = SquaredExponentialCovariance(sigma=1, scale=1) likelihood = LogitLikelihood() gp = GaussianProcess(y, X, covariance, likelihood) laplace = LaplaceApproximation(gp, newton_start=asarray([3, 3])) f_mode, _, steps = laplace.find_mode_newton(return_full=True) F = linspace(-10, 10, 20) D = zeros((len(F), len(F))) for i in range(len(F)): for j in range(len(F)): f = asarray([F[i], F[j]]) D[i, j] = gp.log_posterior_unnormalised(f) idx = unravel_index(D.argmax(), D.shape) empirical_max = asarray([F[idx[0]], F[idx[1]]]) pcolor(F, F, D) hold(True) plot(steps[:, 0], steps[:, 1]) plot(f_mode[1], f_mode[0], 'mo', markersize=10) hold(False) colorbar() clf() # show() self.assertLessEqual(norm(empirical_max - f_mode), 1)
def test_indexing_with_arrays_of_indices(self): a = arange(12) i = array([1,1,3,8,5]) numpy.testing.assert_array_equal(a[i], i) j = array([[3,4], [9,7]]) numpy.testing.assert_array_equal(a[j],array([[3,4], [9,7]])) palette = array([[0,0,0], [255,0,0], [0,255,0], [0,0,255], [255,255,255]]) image = array([[0,1,2,0],[0,3,4,0]]) colour_image = palette[image] numpy.testing.assert_array_equal(colour_image, array([[[0,0,0], [255,0,0], [0,255,0], [0,0,0]], [[0,0,0], [0,0,255], [255,255,255], [0,0,0]]])) a = arange(12).reshape(3,4) i = array([[0,1], [1,2]]) j = array([[2,1], [3,3]]) numpy.testing.assert_array_equal(a[i,j], array([[2,5], [7,11]])) numpy.testing.assert_array_equal(a[i,2], array([[2,6], [6,10]])) numpy.testing.assert_array_equal(a[i,:], array([[[0,1,2,3], [4,5,6,7]], [[4,5,6,7], [8,9,10,11]]])) numpy.testing.assert_array_equal(a[:,j], array([[[2,1], [3,3]], [[6,5], [7,7]], [[10,9], [11,11]]])) time = linspace(20,145,5) data = sin(arange(20).reshape(5,4)) ind = data.argmax(axis=0) time_max = time[ind] data_max = data[ind, xrange(data.shape[1])] numpy.testing.assert_array_equal(data_max, data.max(axis=0))
def get_proposal_points(self, n): """ Returns n points which lie on a uniform grid on the "center" of the banana """ if self.dimension == 2: (xmin, xmax), _ = self.get_plotting_bounds() x1 = linspace(xmin, xmax, n) x2 = self.bananicity * (x1 ** 2 - self.V) return array([x1, x2]).T else: return Distribution.get_proposal_points(self, n)
def get_proposal_points(self, n): """ Returns n points which lie on a uniform grid on the "center" of the banana """ if self.dimension == 2: (xmin, xmax), _ = self.get_plotting_bounds() x1 = linspace(xmin, xmax, n) x2 = self.bananicity * (x1**2 - self.V) return array([x1, x2]).T else: return Distribution.get_proposal_points(self, n)
def bezier_approximation_interp(Xo, Yo): Xp = [] Yp = [] Xp.append(Xo[0]) Yp.append(Yo[0]) for i in range(1, len(Xo) - 2): Xp.append(Xo[i]), Yp.append(Yo[i]) Xp.append((Xo[i] + Xo[i + 1]) / 2), Yp.append((Yo[i] + Yo[i + 1]) / 2) Xp.append(Xo[-2]) Yp.append(Yo[-2]) Xp.append(Xo[-1]) Yp.append(Yo[-1]) print(Xp) X = [] Y = [] for i in range(0, len(Xp) - 3, 2): distance = np.sqrt((Xp[i + 2] - Xp[i])**2 + (Yp[i + 2] - Yp[i])**2) distance = np.int(np.ceil(distance)) mt = 1 * (distance - 1) / distance for t in linspace(0, mt, distance): x0, y0 = line(Xp[i], Xp[i + 1], Yp[i], Yp[i + 1], t) x1, y1 = line(Xp[i + 1], Xp[i + 2], Yp[i + 1], Yp[i + 2], t) x, y = line(x0, x1, y0, y1, t) X.append(x) Y.append(y) distance = np.sqrt((Xp[-1] - Xp[-3])**2 + (Yp[-1] - Yp[-3])**2) distance = np.int(np.ceil(distance)) for t in linspace(0, 1, distance): x0, y0 = line(Xp[-3], Xp[-2], Yp[-3], Yp[-2], t) x1, y1 = line(Xp[-2], Xp[-1], Yp[-2], Yp[-1], t) x, y = line(x0, x1, y0, y1, t) X.append(x) Y.append(y) f = interp1d(X, Y, kind="cubic", fill_value="extrapolate", assume_sorted=True) return X, Y, f
def plot3(hist, gaus, hist2): xvals = linspace(0.0, 1.0, linspace_size) plt.figure() plt.subplot(1, 3, 1) plt.bar(range(len(hist)), hist) plt.legend(loc=0) plt.subplot(1, 3, 2) plt.plot(xvals, gaus(xvals), label="anotated 1", linewidth=line_width) plt.subplot(1, 3, 3) plt.bar(range(len(hist2)), hist2)
def calc_intervals_range(stream: list) -> dict: max_x = max(stream) intervals = {} for interval_end in linspace(0, max_x, 21)[1:]: # нулевой интервал следует выбросить intervals[interval_end] = [] for x in stream: for interval in intervals: if x <= interval: intervals[interval].append(x) break return intervals
def plot_separation(self, i, snp, sep, data): '''Plot separation of IBD clique at sample i, SNP snp.''' parents = [self.ped.sample_id[self.ped.graph.predecessors(i)[a]] for a in im.constants.ALLELES] print data print 'data[0]', data[0] print 'data[1]', data[1] (k00, k10, k01, k11), line = data[0:2] P.figure(1) P.clf() P.hold(True) # P.scatter([p], [q], color='k') P.scatter(k00, k10, color='r') P.scatter(k01, k11, color='b') if line is not None: a0, b0, a1, b1 = line t = linspace(0, max(k00)) P.plot(t, polyval([a0, b0], t), 'r') t = linspace(0, max(k01)) P.plot(t, polyval([a1, b1], t), 'b') P.title('Sample %d, SNP %d, inbreeding=%.4f, separation=%.2f' % (i, snp, self.params.kinship(parents[0], parents[1]), sep)) P.show() P.savefig(os.environ['OBER'] + '/doc/poo/sep-chr%d-%d-%d.png' % (self.chrom, i, snp))
def __init__(self, ONSET_SIGMA_IN_FRAMES): ''' Constructor ONSET_SIGMA_IN_FRAMES: the distance to onset, unit: number of frames, zero means at an onset frame ''' minVal = norm.ppf(0.01) maxVal = norm.ppf(0.5) quantileVals = linspace(maxVal, minVal, ONSET_SIGMA_IN_FRAMES + 1) self.liks = numpy.zeros((ONSET_SIGMA_IN_FRAMES + 1, 1)) for onsetDist in range(ONSET_SIGMA_IN_FRAMES + 1): self.liks[onsetDist] = norm.pdf(quantileVals[onsetDist])
def plot_fill_fraction(problem, color='b', zoom=None, ticks=None, label=None): '''Plot the filled fraction in each sample of a phased data set.''' data = problem.fill_fraction() # Sort by ascending fill % data = data[np.argsort(data[:, 1])] P.plot(range(1, data.shape[0] + 1), data[:, 1], color + '.-', label=label) min_y = data[0, 1] * 0.95 if zoom: max_x = np.where(data[:, 1] > zoom)[0][0] P.xlim([0, max_x + 1]) if ticks: yticks = linspace(min_y, 1.0, ticks) P.yticks(yticks, ['%.3f' % (t, ) for t in yticks]) P.xlabel('Sample') P.ylabel('Filled Haplotype %') P.grid(True) return data
def plot_fill_fraction(problem, color='b', zoom=None, ticks=None, label=None): '''Plot the filled fraction in each sample of a phased data set.''' data = problem.fill_fraction() # Sort by ascending fill % data = data[np.argsort(data[:, 1])] P.plot(range(1, data.shape[0] + 1), data[:, 1], color + '.-', label=label) min_y = data[0, 1] * 0.95 if zoom: max_x = np.where(data[:, 1] > zoom)[0][0] P.xlim([0, max_x + 1]) if ticks: yticks = linspace(min_y, 1.0, ticks) P.yticks(yticks, ['%.3f' % (t,) for t in yticks]) P.xlabel('Sample') P.ylabel('Filled Haplotype %') P.grid(True) return data
def Polinomios(a, b): x = Symbol('x') ylen = b.size yprom = 0 for i in range(ylen): yprom += b[i] yprom *= (1 / ylen) p1 = polyfit(a, b, 1) z1 = poly1d(p1) print("----------------------------------------") print("Polimonio 1: ") pprint(p1[0] * x + p1[1]) Sr1 = 0 St1 = 0 for i in range(ylen): Sr1 += (b[i] - z1(a[i]))**2 St1 += (b[i] - yprom)**2 r1 = sqrt((St1 - Sr1) / St1) print("Coeficiente =", r1) p2 = polyfit(a, b, 2) z2 = poly1d(p2) print("Polimonio 2: ") pprint(p2[0] * x**2 + p2[1] * x + p2[2]) Sr2 = 0 St2 = 0 for i in range(ylen): Sr2 += (b[i] - z2(a[i]))**2 St2 += (b[i] - yprom)**2 r2 = sqrt((St2 - Sr2) / St2) print("Coeficiente =", r2) xp = linspace(0, 2) _ = plt.plot(a, b, ".", xp, z1(xp), "-", xp, z2(xp), "--") plt.show() p3 = polyfit(a, b, 3) pprint(p3[0] * x**3 + p3[1] * x**2 + p3[2] * x + p3[3]) p4 = polyfit(a, b, 4) pprint(p4[0] * x**4 + p4[1] * x**3 + p4[2] * x**2 + p4[3] * x + p4[4]) p5 = polyfit(a, b, 5) pprint(p5[0] * x**5 + p5[1] * x**4 + p5[2] * x**3 + p5[3] * x**2 + p5[4] * x + p5[5]) p6 = polyfit(a, b, 6) pprint(p6[0] * x**6 + p6[1] * x**5 + p6[2] * x**4 + p6[3] * x**3 + p6[4] * x**2 + p6[5] * x + p6[6])
def newFunctor( env, _voltage_interpolation_values=voltage_interpolation_values): old_chl = chl_functor(env) assert isinstance( old_chl, (StdChlAlphaBeta, StdChlAlphaBetaBeta )) # or issubclass(StdChlAlphaBetaBeta, old_chl) # New Name if new_name is not None: chl_name = new_name else: chl_name = old_chl.name + clone_name_suffix # Interpolation voltages: # voltage_interpolation_values=voltage_interpolation_values if _voltage_interpolation_values is None: _voltage_interpolation_values = linspace(-80, 60, 10) * unit('mV') # Copy the state variables new_state_vars = {} for state_var in old_chl.get_state_variables(): alpha, beta = old_chl.get_alpha_beta_at_voltage( statevar=state_var, V=_voltage_interpolation_values) inf, tau = InfTauCalculator.alpha_beta_to_inf_tau(alpha, beta) V = _voltage_interpolation_values.rescale('mV').magnitude inf = inf.rescale(pq.dimensionless).magnitude tau = tau.rescale('ms').magnitude new_state_vars[state_var] = InfTauInterpolation(V=V, inf=inf, tau=tau) chl = env.Channel( MM_InfTauInterpolatedChannel, name=chl_name, ion=old_chl.ion, equation=old_chl.eqn, conductance=old_chl.conductance, reversalpotential=old_chl.reversalpotential, statevars_new=new_state_vars, ) return chl
def test0(): N = 10 dim = 1 NofThreads = 5 G = 6.67408 * numpy.power(10.0, -11) data = formData(N, dim) t = linspace(0, 10, 101) time0 = 0 time1 = 0 time2 = 0 time3 = 0 time4 = 0 time5 = 0 tmp_time = time.time() solution_test = test(data, N, dim, G, t) time0 = time.time() - tmp_time tmp_time = time.time() solution_Verlet = solve1(data, N, dim, G, t) time1 = time.time() - tmp_time tmp_time = time.time() solution_Verlet_threading = solve2(data, N, dim, NofThreads, G, t) time2 = time.time() - tmp_time tmp_time = time.time() solution_Verlet_multiproessing = solve3(data, N, dim, NofThreads, G, t) time3 = time.time() - tmp_time tmp_time = time.time() solution_Verlet_cython = Verlet1.solve4(data, N, dim, G, t) time4 = time.time() - tmp_time tmp_time = time.time() solution_Verlet_CUDA = solve5(data, N, dim, G, t) time5 = time.time() - tmp_time print('test: ' + str(solution_test) + '\n') print('Verlet: ' + str(solution_Verlet) + '\n') print('Verlet_threading: ' + str(solution_Verlet_threading) + '\n') print('Verlet_multiprocessing: ' + str(solution_Verlet_multiproessing) + '\n') print('Verlet_cython: ' + str(solution_Verlet_cython) + '\n') print('Verlet_CUDA: ' + str(solution_Verlet_CUDA) + '\n') print( str(time0) + ' ' + str(time1) + ' ' + str(time2) + ' ' + str(time3) + ' ' + str(time4) + ' ' + str(time5))
def sample_circle_data(n, noise_level=0.025, offset=0.05, seed_init=None): if seed_init is not None: seed(seed_init) # decision surface for sampled data thetas = linspace(0, pi / 2, n) X = sin(thetas) * (1 + randn(n) * noise_level) Y = cos(thetas) * (1 + randn(n) * noise_level) # randomly select labels and distinguish data labels = randint(0, 2, n) * 2 - 1 idx_a = labels > 0 idx_b = labels < 0 X[idx_a] *= (1. + offset) Y[idx_a] *= (1. + offset) X[idx_b] *= (1. - offset) Y[idx_b] *= (1. - offset) return asarray(zip(X, Y)), labels
def plot1(hist, gaus): xvals = linspace(0.0, 1.0, linspace_size) plt.figure() plt.subplot(1, 2, 1) # plt.hist( # [ # hist # ], # 10, # normed=False, # histtype='bar', # stacked=False, # ) plt.bar(range(len(hist)), hist) plt.legend(loc=0) plt.subplot(1, 2, 2) plt.plot(xvals, gaus(xvals), label="anotated 1", linewidth=line_width)
def get_avg_func(x, y, points=1000, mean='arithmetic'): y_max = 2000.0 y_min = -200.0 y_avg = linspace(y_max, y_min, points) x_avg = list() f = list() avg_dist = list() f_mean = get_mean_function(mean) #get inverse functions for all curves for i in range(0, len(x)): f.append(get_inverse_function(x[i], y[i])) for i in range(0, len(y_avg)):#for every point in the new average curve... x_avg.append(f_mean([f[j](y_avg[i]) for j in range(0, len(x))])) return lambda x: interp(x, x_avg, y_avg), x_avg
def plot_rac(df: DataFrame, graph): """Plots the RAC curve for the given DataFrame. Args: df (DataFrame): DataFrame with risk values. graph: Object to plot the graph on. """ # Set axes parameters graph.set_xlabel("Risk (%)", fontsize=10) graph.xaxis.set_major_formatter(PercentFormatter(xmax=1.00)) graph.set_ylabel("RAC (%)", fontsize=10) graph.yaxis.set_major_formatter(PercentFormatter(xmax=1.00)) # Equally-spaced points x = linspace(0, 1, 50) # Plot for each column in the dataframe for column in df.columns: y = [_risk_and_coverage(df[column], r) for r in x] graph.scatter(x, y, label=f"BK = {column}") graph.plot(x, y) graph.legend(fontsize=10)
def __init__(self, deviationInSec): ''' #@param deviationInSec: how much vocal can deviate from refDur ''' # normal distribution with 2 symmetric lobes self.numDurs = int(2* deviationInSec * NUMFRAMESPERSEC) if not self.numDurs % 2: self.numDurs += 1 self.minVal = norm.ppf(0.01) self.maxVal= norm.ppf(0.99) quantileVals = linspace(self.minVal, self.maxVal, self.numDurs ) self.liks = numpy.zeros((self.numDurs,1)) for d in range(0,self.numDurs): self.liks[d] = norm.pdf(quantileVals[d]) self.liks = numpy.log(self.liks)
def create_interpolated_attr(self, c_org, selected_attrs=None, max_val=5.0): """Generate target domain labels for debugging and testing: linearly sample attribute. Contains a list for each attr""" all_lists = [] for i in range(len(selected_attrs)): c_trg_list = [] #[c_org] alphas = [ -max_val, -((max_val - 1) / 2.0 + 1), -1, -0.5, 0, 0.5, 1, ((max_val - 1) / 2.0 + 1), max_val ] if max_val == 1: alphas = linspace(-1, 1, 9) #[-1,-0.75,-0.5,0,0.5,1,] #alphas = np.linspace(-max_val, max_val, 10) for alpha in alphas: c_trg = c_org.clone() c_trg[:, i] = torch.full_like(c_trg[:, i], alpha) c_trg_list.append(c_trg) all_lists.append(c_trg_list) return all_lists
def __init__(self, deviationInSec): ''' #@param deviationInSec: how much vocal can deviate from refDur deviationInSec = 0.07 ''' # normal distribution with 2 symmetric lobes self.numDurs = int(2* deviationInSec * NUMFRAMESPERSEC) if not self.numDurs % 2: self.numDurs += 1 self.minVal = norm.ppf(0.01) self.maxVal= norm.ppf(0.99) quantileVals = linspace(self.minVal, self.maxVal, self.numDurs ) self.liks = numpy.zeros((self.numDurs,1)) for d in range(0,self.numDurs): self.liks[d] = norm.pdf(quantileVals[d]) self.liks = numpy.log(self.liks)
def train(self, data, target): """ Uses KDE to estimate the best classification threshold (delta). :param data: shapelet transformed dataset :type data: np.array, shape = (len(dataset),) :param target: list of 0 (event has NOT occurred during in this time series) or 1 if it has :type target: np.array, shape = (len(dataset),) :return: information gain, delta, f_c(delta) :rtype: tuple(float, float, float) """ nin_class = data[target == 0] np_c = len(nin_class) / (len(target) + .0) in_class = data[target == 1] p_c = len(in_class) / (len(target) + .0) density = int(self.resolution * (max(data) - min(data))) dist_space = linspace(min(data), max(data), density) f_c = gaussian_kde(in_class)(dist_space) nf_c = gaussian_kde(nin_class)(dist_space) P_c = p_c * f_c / (np_c * nf_c + p_c * f_c) P_c[P_c > self.p] = -P_c[P_c > self.p] delta_candidates = argrelmax(P_c, order=3)[0] bsf_information_gain = 0 bsf_delta = 0 bsf_f_c_delta = 0 for i in delta_candidates: i = [i] delta = dist_space[i][0] d1 = target[data < delta] d2 = target[data >= delta] igain = information_gain(target, d1, d2) f_c_delta = nf_c[i][0] if igain > bsf_information_gain: bsf_information_gain = igain bsf_delta = delta bsf_f_c_delta = f_c_delta elif igain == bsf_information_gain and f_c_delta < bsf_f_c_delta: bsf_information_gain = igain bsf_delta = delta bsf_f_c_delta = f_c_delta return bsf_information_gain, bsf_delta, bsf_f_c_delta
def updateSignals(self, moneyManager, marketManager, estimateParameter, rates): # get current value for market V_tilde_M = marketManager.getFeedInfo('AE', 'QTE_CNT1') S_tilde_M = self.marketManager.getFeedInfo('AE', 'WTD_AVE1') # get current value for execution V_tilde_E = moneyManager.getStatistics() S_tilde_E = moneyManager.getExecQty() # get estimate parameters # market VWAP Exp_S_hat_M = estimateParameter['Exp_S_hat_M'] Var_S_hat_M = estimateParameter['Var_S_hat_M'] # market volume Exp_V_hat_M_E = estimateParameter['Exp_V_hat_M_E'] Var_V_hat_M_E = estimateParameter['Var_V_hat_M_E'] # slippage exp_slippage = estimateParameter['exp_slippage'] var_slippage = estimateParameter['var_slippage'] # compute the mean and variance of slippage self.additional_params['ref_rate'] = rates['ref_rate'] range_of_rates = linspace(rates['min_rate'], rates['max_rate'], rates['step_rate']) value_fct = [] for r in range_of_rates: mean_P = self.mean_P(r, V_tilde_E, V_tilde_M, S_tilde_E, S_tilde_M, Exp_S_hat_M, Exp_V_hat_M_E, exp_slippage) mean_Q = self.mean_Q(r, V_tilde_M, Exp_V_hat_M_E) cov_P_Q = self.cov_P_Q(r) var_P = self.var_P(r, V_tilde_E, V_tilde_M, Var_S_hat_M, Var_V_hat_M_E, var_slippage) var_Q = self.var_Q(r, Var_V_hat_M_E) mean_s = self.meanSlippage(mean_P, mean_Q, cov_P_Q, var_Q) var_s = self.varSlippage(mean_P, mean_Q, cov_P_Q, var_P, var_Q) value_fct = obj_function(mean_s, var_s, vec_r); [val_max idx_max] = max(value_fct); min_r = V_tilde_E/(V_tilde_M + Exp_V_hat_M_E); optimal_r(i_cp,i_cdv) = max(vec_r(idx_max), min_r);
def newFunctor(env, _voltage_interpolation_values=voltage_interpolation_values): old_chl = chl_functor(env) assert isinstance(old_chl, (StdChlAlphaBeta, StdChlAlphaBetaBeta)) # or issubclass(StdChlAlphaBetaBeta, old_chl) # New Name if new_name is not None: chl_name = new_name else: chl_name = old_chl.name + clone_name_suffix # Interpolation voltages: # voltage_interpolation_values=voltage_interpolation_values if _voltage_interpolation_values is None: _voltage_interpolation_values = linspace(-80, 60, 10) * unit('mV') # Copy the state variables new_state_vars = {} for state_var in old_chl.get_state_variables(): alpha, beta = old_chl.get_alpha_beta_at_voltage(statevar=state_var, V=_voltage_interpolation_values) inf, tau = InfTauCalculator.alpha_beta_to_inf_tau(alpha, beta) V = _voltage_interpolation_values.rescale('mV').magnitude inf = inf.rescale(pq.dimensionless).magnitude tau = tau.rescale('ms').magnitude new_state_vars[state_var] = InfTauInterpolation(V=V, inf=inf, tau=tau) chl = env.Channel( MM_InfTauInterpolatedChannel, name=chl_name, ion=old_chl.ion, equation=old_chl.eqn, conductance=old_chl.conductance, reversalpotential=old_chl.reversalpotential, statevars_new=new_state_vars, ) return chl
def dagDict(treine): dagtreine = {} # maak 'n dag se rooster vol van die basisuurpatroon en stoor dit in 'n CSV-formaat... nieBUPure = int(nieBUPseries.values()[0]/(60.0-nieBUPseries.values()[0])) for cp in linspace(0,24-nieBUPure*2,24.0/nieBUPure-1): # vir nieBUPure=3 (45 min periode): [0,3,6,9,12,15,18] # Stap deur die treine wat volgens treinnommer gesorteer is (begin dus by 0101 en eindig by 9999) for trein in sorted(treine): # Verwerk eers die treine wat nie volgens die BUP bedryf word nie if(nieBUPseries.has_key(trein[0:2])): # Die huidige trein moenie eindig met 01 nie en ook nie met 02 nie if(trein[2:4] != '01' and trein[2:4] != '02'): vorigeTreinInSerieNo = '{:0>4}'.format(str(int(trein)-2)) if(treine[trein]['tyd'][0] > treine[vorigeTreinInSerieNo]['tyd'][0]): # val nog in selfe uur, hoef niks te doen nie. treine[trein]['cp'] = treine[vorigeTreinInSerieNo]['cp'] tye = np.array(treine[trein]['tyd'])+treine[trein]['cp']/24.0 else: treine[trein]['cp'] = treine[vorigeTreinInSerieNo]['cp'] +1 tye = np.array(treine[trein]['tyd'])+(treine[trein]['cp'])/24.0 else: treine[trein]['cp'] = cp/3*3 tye = np.array(treine[trein]['tyd'])+treine[trein]['cp']/24.0 uniekeTreinno = '{:0>4}'.format(str(int(trein)+int(cp)/3*2*(nieBUPure+1))) dagtreine[uniekeTreinno] = {'stasieKode':treine[trein]['stasieKode'], 'tyd':tye.tolist(), 'kmPunt':treine[trein]['kmPunt'], 'trajek':treine[trein]['trajek']} # Verwerk dan die treine wat wel volgens die BUP werk elif(BUPseries.has_key(trein[0:2])): for cpa in [cp, cp+1, cp+2]: tye = np.array(treine[trein]['tyd'])+cpa/24.0 uniekeTreinno = '{:0>4}'.format(str(int(trein)+int(cpa)*2*(60/BUPseries[trein[0:2]]))) dagtreine[uniekeTreinno] = {'stasieKode':treine[trein]['stasieKode'], 'tyd':tye.tolist(), 'kmPunt':treine[trein]['kmPunt'], 'trajek':treine[trein]['trajek']} else: print 'FOUT: Treinserie ', trein, ' kom in die CPLEX-afvoer voor, maar die periode is nie bekend nie! \nGaan die leers BUPseries.csv en nieBUPseries.csv na.' with open("dagrooster.txt",'wb') as outfile: json.dump(dagtreine, outfile)
def main(): massset = set() for each in os.listdir("ntuples"): if ".root" in each: massset.add(int(each.split("w")[0])) i = 0 processes = [] for each_mass in sorted(massset): if each_mass < 300: continue maxv = int(each_mass * 2.5) if maxv > 3000: maxv = 3000 i += 1 # plot_mass_modified(each_mass, linspace(0, int(maxv), 25)) t = multiprocessing.Process(target=plot_mass_modified, args=(each_mass, linspace(0, int(maxv), 25))) processes.append(t) t.start() if (i + 1) % 8 == 0: for each in processes: each.join() processes = [] for each in processes: each.join() paras = {} allfiles = os.listdir("pickle") for each in allfiles: mass = int(each.replace("fitvalues", "").replace(".pickle", "")) with open("pickle/" + each, 'rb') as f: pvalues = pickle.load(f) paras[mass] = pvalues with open('fitvalues.pickle', 'wb') as f: pickle.dump(paras, f)
def _create_entity_connection_matrix( df_coordinates: pd.DataFrame, starts: List[Coordinate], ends: List[Coordinate], aquifer_starts: List[Coordinate], aquifer_ends: List[Coordinate], max_distance_fraction: float, max_distance: float, concave_hull_list: Optional[List[np.ndarray]] = None, n_non_reservoir_evaluation: Optional[int] = 10, ) -> pd.DataFrame: """ Converts the the coordinates given for starts and ends to the desired DataFrame format for simulation input. Args: df_coordinates: original DataFrame version of coordinates starts: List of coordinates for all the starting entities ends: List of coordinates of all the end entities aquifer_starts: List of coordinates for all aquifer starts aquifer_ends: List of coordinates of all aquifer ends max_distance_fraction: Fraction of longest connection distance to be removed max_distance: Maximum distance between nodes, removed otherwise concave_hull_list: List of boundingboxes per layer, i.e., numpy array with x, y, z min/max boundingboxes for each grid block n_non_reservoir_evaluation: Number of equally spaced points along a connection to check fornon-reservoir. Returns: Connection coordinate DataFrame on Flow desired format. """ print("Creating entity connection DataFrame...", end="") columns = [ "xstart", "ystart", "zstart", "xend", "yend", "zend", "start_entity", "end_entity", ] df_out = pd.DataFrame(columns=columns) for start, end in zip(starts, ends): str_start_entity = __get_entity_str(df_coordinates, start) str_end_entity = __get_entity_str(df_coordinates, end) if concave_hull_list is not None: tube_coordinates = linspace( start=start, stop=end, num=n_non_reservoir_evaluation, # type: ignore endpoint=False, dtype=float, axis=1, ).T if not any((all(check_in_hull(concave_hull, tube_coordinates)) for concave_hull in concave_hull_list)): continue df_out = df_out.append( { "xstart": start[0], "ystart": start[1], "zstart": start[2], "xend": end[0], "yend": end[1], "zend": end[2], "start_entity": str_start_entity, "end_entity": str_end_entity, }, ignore_index=True, ) for start, end in zip(aquifer_starts, aquifer_ends): str_start_entity = __get_entity_str(df_coordinates, start) df_out = df_out.append( { "xstart": start[0], "ystart": start[1], "zstart": start[2], "xend": end[0], "yend": end[1], "zend": end[2], "start_entity": str_start_entity, "end_entity": "aquifer", }, ignore_index=True, ) df_out = _remove_long_connections(df_out, max_distance_fraction, max_distance) print("done.") return df_out
i,j,k,l,=0,0,0,0 print(i) x= [2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015] y = [485709,486722,475887,469311,453618,447977,436867,426885,392470,370021,351340,335504,306387,273781,238761] p1= np.polyfit(x,y,1) p2= np.polyfit(x,y,2) p3= np.polyfit(x,y,3) from scipy.interpolate import * import matplotlib.pyplot as plt xp = linspace(2000,2020,100) fig,ax = plt.subplots() plt.plot(xp,polyval(p1,xp),'r-') plt.plot(xp,polyval(p2,xp),'m:') plt.plot(xp,polyval(p3,xp),'b--') ax.set_title("Prediction of Crime Data in Chicago") ax.set_ylabel('Count') ax.set_xlabel('Year') plt.plot(x,y,'o') #yfit = p1[0] * x + p1[1] #yresid = y - yfit #SSresid = sum(pow(yresid,2)) #SStotal = len(y) * np.var(y)
''' Created on Nov 26, 2013 @author: jurek ''' import matplotlib.pyplot as plt import numpy as np from numpy.core.function_base import linspace x = linspace(10, 100, 90) plt.plot(x, np.log(x)) plt.show()
# Calculate speed (load and terrain) # 30% is a guessstimate loss = 0.3 # Equals 30% loss speed_load = speed * (1.0 - loss) print "" print " At 30% loss due to load, friction and terrain: " + str(speed_load) + "m/s" # Plot down sampled data and slice print "" print " Plotting ..." plot.figure() plot.title("Full waveform (down sampled from 8kHz to 1kHz)") plot.xlabel("Time [min]") plot.ylabel("Amplitude") n = linspace(0, len(wData) - 1, len(wData))[::8] plot.plot((n / wRate) / 60, wDataDownSampled) plot.figure() plot.title("Time slice of full waveform") plot.xlabel("Time [s]") plot.ylabel("Amplitude") n = linspace(32000, 71999, len(wDataSlice)) plot.plot(n / wRate, wDataSlice) # Generate normal distribution with parameters speed and uncertainty plot.figure() plot.title("Normal distribution of speed with no load applied") plot.xlabel("Speed [m/s]") plot.ylabel("Probability density") x = linspace(speed - 4 * uncertainty, speed + 4 * uncertainty, 1000)
def test_linespace_method(self): a = linspace(0,2,9) # array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ]) x = linspace(0, 2*pi, 100) f = sin(x) self.assertEqual(len(a), 9)
@author: Oren Livne <*****@*****.**> ============================================================ ''' import impute as im, matplotlib.pyplot as P, numpy as np, os from numpy.core.function_base import linspace P.figure(1) P.clf() P.hold(True) p = im.hutt('hutt.phased.npz') d5 = im.plots.plot_fill_fraction(p, color='b', label='Stage 5') p = im.hutt('hutt.stage6.npz') d = im.plots.plot_fill_fraction(p, color='r', label='Stage 6') zoom = 0.96 ticks = 10 min_y = 0.95 * min(d[:, 1][0], d5[:, 1][0]) max_x = np.where(d[:, 1] > zoom)[0][0] P.xlim([0, max_x + 1]) P.ylim([min_y, 1.0]) yticks = linspace(min_y, 1.0, ticks) P.yticks(yticks, ['%.3f' % (t,) for t in yticks]) P.title('Hutterites Phasing Coverage, Chromosome 22') P.legend(loc='lower right', prop={'size': 12}) P.show() P.savefig(os.environ['OBER'] + '/doc/phasing/fill.png')
# coding=gbk # coding£ºutf-8 ''' @Created on 2018Äê1ÔÂ26ÈÕ ÏÂÎç2:43:08 @author: Administrator ''' from myFunc import mfft, mifft from math import * from numpy import * # import numpy as np from matplotlib import * import matplotlib.pyplot as plt from numpy.dual import fft from numpy.fft.helper import fftshift from numpy.core.function_base import linspace x = linspace(-pi, pi, 100) print(type(x)) print(shape(x)) y = random.random(size=(1, 10)) print(type(y)) print(type(shape(y))) print(type(shape(y))) f = sin(x) F = fftshift(fft(f)) #F = mfft(f) plt.subplot(121) plt.plot(abs(F)) plt.show()
# y1=sin(x) # y2=cos(x) # plt.plot(x,y1,'b.',x,y2,'r-') # plt.show() # import sys,random # def compute(n): # i=0;s=0 # while i<=n: # s+=random.random() # i+=1 # return s/n # n=500000 # print('average of %d random number is %g'%(n,compute(n))) x = linspace(-10, 10, 1000) y = x [X, Y] = meshgrid(x, y) w = 2 Gauss = exp(-(X**2 + Y**2) / pow(w, 2)) # plt.subplot(121) # plt.imshow(Gauss) # plt.subplot(122) D = 2 y1 = exp(-x**2 / D**2) plt.plot(x, y1) # y2=zeros((1,1000)) # y2[where(abs(x)<=D)]=1 # plt.plot(x,y2,'r') plt.show()
def test_upcasting_from_float_complex(self): b = linspace(0, pi, 3) c = exp(b*1j) self.assertEqual(c.dtype.name, 'complex128')
def test_upcasting_from_int_float(self): a = ones(3,dtype='int32') b = linspace(0, pi, 3) c = a+b self.assertEqual(type(c), type(b))
#!/usr/bin/env python ''' ============================================================ Plot our HMM IBD posterior probabilities for model cases. Created on December 19, 2012 @author: Oren Livne <*****@*****.**> ============================================================ ''' import matplotlib.pyplot as P, os, numpy as np from numpy.core.function_base import linspace from impute.dev import ibd_single N = 50 p = linspace(0, 1, N) + 1e-15 q = 1 - p colors = ['b', 'g', 'r', 'm', 'k'] def plot_shared_allele_inflation(f): '''Plot the phased-phased IBD posterior probability change when we use shared allele frequencies.''' P.clf() for f in [0.1, 0.5, 0.9]: OR = f / (1 - f) ibd1 = 1 / (1 + p / OR) ibd2 = 1 / (1 + (p**2 + q**2) / OR) P.plot(p, ibd1 / ibd2, label='$f=%.1f,\, OR=%.1f$' % (f, OR)) P.grid(True) P.xlim([0, 1]) P.ylim([0, 2])
def nplot(self, field, fname='', display=True, levels=21, gradient=False, gmult=1.0, max_val=None, min_val=None, title=''): """Plots nodal results. Args: field (str): results item to plot, examples: 'ux', 'ey', 'Seqv' fname (str): prefix of png file name, if writing an image display (bool): True = interactively show the plot levels (int): number of levels to use in the colorbar gradient (bool): True = results plotted with gradient False = results plotted with filled areas gmult (int): geometric multiplier on displacement of nodes displayed_node_loc = model_node_loc + gmult*node_displacement max_val (float or None): max value in the colorbar - None: max from selected data used - float: use the passed float min_val (float): min value in the colorbar - None: min from selected data used - float: use the passed float title (str): third line in the plot title """ # store the selected nodes and elements sel = {} sel['nodes'] = self.__problem.fea.view.nodes sel['elements'] = self.__problem.fea.view.elements sel['faces'] = self.__problem.fea.view.faces # sort nodes low to high so index is correct # we have index to id below so showing subsets works sel['nodes'] = list(sel['nodes']) sel['nodes'] = sorted(sel['nodes'], key=lambda k: k.id) # store results at nodes axials = [] radials = [] zvals = [] id_to_ind = {} for node in sel['nodes']: id_to_ind[node.id] = len(axials) axi = node.y + gmult*self.__results[self.__time]['node'][node.id]['uy'] rad = node.x + gmult*self.__results[self.__time]['node'][node.id]['ux'] axials.append(axi) radials.append(rad) zvals.append(self.__results[self.__time]['node'][node.id][field]) # make a list of triangles, given by indices, looping anticlockwise triangles = [] mylist = [] if len(sel['elements']) > 0: mylist = sel['elements'] elif len(sel['faces']) > 0: mylist = sel['faces'] for element in mylist: tris = element.get_tris() # list of triangle nodes for tri in tris: for ind, nid in enumerate(tri): tri[ind] = id_to_ind[nid] # convert id to index triangles += tris # check to see if selected nodes and elements are # in the parent model's nodes and elements fig = plt.figure() ax_ = fig.add_subplot(111) # need to set tick list here vmin = min(zvals) vmax = max(zvals) stop_plot = False if max_val != None and min_val == None: if max_val < vmin: stop_plot = True print('Error:') print(' Only max was passed but it is < the data min!') print(' Pass a max_val that is > the data min of %f' % vmin) else: vmax = max_val elif min_val != None and max_val == None: if min_val > vmax: stop_plot = True print('Error:') print(' Only min was passed but it is > the data max!') print(' Pass a min_val that is < the data max of %f' % vmax) else: vmin = min_val elif max_val != None and min_val != None: if max_val < min_val: stop_plot = True print('Error:') print(' Min and max passed, but min > max!') print(' Pass a min_val that is < max_val') else: vmax = max_val vmin = min_val # exit if stop plot flag is on if stop_plot: return None tick_list = [vmin] if vmax != vmin: # we have a range of values we're plotting tick_list = linspace(vmin, vmax, levels+1) # plot using a gradient(shaded) or levels # code required for the colorbar, needs to go before plotting for colormap cnorm = colors.Normalize(vmin=vmin, vmax=vmax) cmap = colors.ListedColormap(['b', 'b']) # default to plot one val if vmax != vmin: # we have a range of values we're plotting if gradient: cmap = plt.get_cmap(CMAP) else: cmap = plt.get_cmap('jet', levels) cmap.set_under('0.3', 0.8) cmap.set_over('0.7', 0.8) if gradient or len(tick_list) == 1: # This one is shaded plt.tripcolor(axials, radials, triangles, zvals, shading='gouraud', cmap=cmap, norm=cnorm) else: # this one is not shaded plt.tricontourf(axials, radials, triangles, zvals, levels=tick_list, cmap=cmap, norm=cnorm, extend='both') scalarmap = cmx.ScalarMappable(norm=cnorm, cmap=cmap) scalarmap.set_array([]) cbar = plt.colorbar(scalarmap, orientation='vertical', ticks=tick_list) scibool = False if field[0] == 'e': # strain plotting, use scientific numbering scibool = True met_max = self.__metric_num(max(zvals), sci=scibool) met_min = self.__metric_num(min(zvals), sci=scibool) label = 'Max: %s\nMin: %s' % (met_max, met_min) tick_list = [self.__metric_num(tick, sci=scibool) for tick in tick_list] cbar.ax.set_yticklabels(tick_list) cbar.ax.set_xlabel(label, labelpad=10, x=0, ha='left') cbar.ax.xaxis.set_label_position('top') # set the horizontal and vertical axes base_classes.plot_set_bounds(plt, axials, radials) # set units alist = self.__problem.fea.get_units(field, 'dist', 'time') [f_unit, d_unit, t_unit] = alist # set plot axes plot_title = ('Node %s%s\nTime=%f%s' % (field, f_unit, self.__time, t_unit)) if title != '': plot_title += '\n%s' % title plt.title(plot_title) plt.xlabel('axial, y'+d_unit) plt.ylabel('radial, x'+d_unit) ax_.set_aspect('equal') if gmult != 1: ax_.xaxis.set_ticklabels([]) ax_.yaxis.set_ticklabels([]) base_classes.plot_finish(plt, fname, display)
def measure_time(): #N dim = 1 NofThreads = 5 G = 6.67408 * numpy.power(10.0, -11) t = linspace(0, 10, 101) time1 = [0, 0, 0] time2 = [0, 0, 0] time3 = [0, 0, 0] time4 = [0, 0, 0] time5 = [0, 0, 0] myRange = [100, 200, 400] for i, N in enumerate(myRange): data = formData(N, dim) for j in range(3): tmp_time = time.time() solve1(data, N, dim, G, t) time1[i] += time.time() - tmp_time for j in range(3): tmp_time = time.time() solve2(data, N, dim, NofThreads, G, t) time2[i] += time.time() - tmp_time for j in range(3): tmp_time = time.time() solve3(data, N, dim, NofThreads, G, t) time3[i] += time.time() - tmp_time for j in range(3): tmp_time = time.time() Verlet1.solve4(data, N, dim, G, t) time4[i] += time.time() - tmp_time for j in range(3): tmp_time = time.time() solve5(data, N, dim, G, t) time5[i] += time.time() - tmp_time for i in range(3): time1[i] /= 3 time2[i] /= 3 time3[i] /= 3 time4[i] /= 3 time5[i] /= 3 plt.subplot(1, 3, 1) plt.plot(myRange, time1, label="default") plt.plot(myRange, time2, label="threading") plt.plot(myRange, time3, label="multiprocessing") plt.plot(myRange, time4, label="cython") plt.plot(myRange, time5, label="CUDA") plt.legend() plt.subplot(1, 3, 2) for i in range(3): time2[i] = time1[i] / time2[i] time3[i] = time1[i] / time3[i] time4[i] = time1[i] / time4[i] time5[i] = time1[i] / time5[i] plt.plot(myRange, time2, label="threading") plt.plot(myRange, time3, label="multiprocessing") plt.plot(myRange, time4, label="cython") plt.plot(myRange, time5, label="CUDA") plt.legend() plt.subplot(1, 3, 3) plt.plot(myRange, time2, label="threading") plt.plot(myRange, time3, label="multiprocessing") plt.plot(myRange, time4, label="cython") plt.legend() plt.show()
# python program to create an array with 5 equal points using linespace() method ''' Function Name : Create Array With 5 Equal Points Using linespace(). Function Date : 28 Aug 2020 Function Author : Prasad Dangare Input : Integer Output : Float ''' from numpy import* from numpy.core.function_base import linspace # divide 0 to 10 into 5 parts and take those points in the array a = linspace(0, 10, 5) print('a = ', a)
#!/usr/bin/env python """ ============================================================ Plot our HMM IBD posterior probabilities for model cases. Created on December 19, 2012 @author: Oren Livne <*****@*****.**> ============================================================ """ import matplotlib.pyplot as P, os, numpy as np from numpy.core.function_base import linspace from impute.dev import ibd_single N = 50 p = linspace(0, 1, N) + 1e-15 q = 1 - p colors = ["b", "g", "r", "m", "k"] def plot_shared_allele_inflation(f): """Plot the phased-phased IBD posterior probability change when we use shared allele frequencies.""" P.clf() for f in [0.1, 0.5, 0.9]: OR = f / (1 - f) ibd1 = 1 / (1 + p / OR) ibd2 = 1 / (1 + (p ** 2 + q ** 2) / OR) P.plot(p, ibd1 / ibd2, label="$f=%.1f,\, OR=%.1f$" % (f, OR)) P.grid(True) P.xlim([0, 1]) P.ylim([0, 2])