def LandscapePnorm(ts, p, ts2=None, dim=1, maxrad=1, t_min=None, t_max=None, n_points=100): # compute L^p norm of all landscapes from multidimensional timeseries (or just set of points) # input: # ts - m x d numpy array, one timeseries (or just point coordinates) per column (d series), m samples per series # p - integer (type of L^p norm to compute) # ts2 - m x d numpy array, one timeseries (or just point coordinates) per column (d series), m samples per series # if this is set, then the L^p distance will be returned # dim - dimension of the persistence diagram from which to derive the landscape # maxrad - max distance between pairwise points to consider for the Rips complex # t_min, t_max (int or None) - same as inputs to dgm2landscape; if universal start/stop radii are desired for computing landscapes # setting these to fixed values might reduce computation time a little bit # n_points (int) - same as input to dgm2landscape; number of data points for landscape functions # output: # float32 - the L^p norm of the landscapes or difference # need to go one dim up, above the one we want, as otherwise get free hom group at the top of the chains. frips = d.fill_rips(np.array(ts, dtype='float32'), dim + 1, maxrad) mrips = d.homology_persistence(frips) dgms = d.init_diagrams(mrips, frips) # acquire birth/death pairs if len(dgms) <= dim: # set the only birth/death pair to (0.0,0.0) if no gens found bd = np.zeros((1, 2)) else: bd = dgm2array(dgms[dim]) # acquire landscape functions landscapes, rstart, rend = dgm2landscape(bd, t_min=t_min, t_max=t_max, n_points=n_points) if ts2 is not None: frips2 = d.fill_rips(np.array(ts2, dtype='float32'), dim + 1, maxrad) mrips2 = d.homology_persistence(frips2) dgms2 = d.init_diagrams(mrips2, frips2) if len(dgms2) <= dim: # set the only birth/death pair to (0.0,0.0) if no gens found bd2 = np.zeros((1, 2)) else: bd2 = dgm2array(dgms2[dim]) landscapes2, rstart2, rend2 = dgm2landscape(bd2, t_min=t_min, t_max=t_max, n_points=n_points) # compute L^p distances lpnorms = LpNorms(landscapes, min(rstart, rstart2), max(rend, rend2), landscapes2=landscapes2, p=p) else: # compute L^p norms lpnorms = LpNorms(landscapes, rstart, rend, p=p) normie = LandscapeLpNorm(lpnorms, p=p) return (normie)
def fit(self, data): """ Generate Rips filtration and cycles for data. """ # Generate rips filtration maxeps = np.max(data.std(axis=0)) # TODO: is this the best choice? cpx = dionysus.fill_rips(data, self.order+1, maxeps) # Add cone point to force homology to finite length; Dionysus only gives out cycles of finite intervals spxs = [dionysus.Simplex([-1])] + [c.join(-1) for c in cpx] for spx in spxs: spx.data = 1 cpx.append(spx) # Compute persistence diagram persistence = dionysus.homology_persistence(cpx) diagrams = dionysus.init_diagrams(persistence, cpx) # Set all the results self._filtration = cpx self._diagram = diagrams[self.order] self._persistence = persistence self.barcode = np.array([(d.birth, d.death) for d in self._diagram]) self._build_cycles()
def computePD(i): # print('Process %s' % i) # np.random.seed(42) f1 = d.fill_rips(np.random.random((i + 10, 2)), 2, 1) m1 = d.homology_persistence(f1) dgms1 = d.init_diagrams(m1, f1) # return [(p.birth, p.death) for p in dgms1[1]] # advice from Dmitriy return dgms1[1]
def get_rips_diagram(pcpds_obj): f = d.fill_rips(pcpds_obj.get_point_cloud().astype('f4'), pcpds_obj.get_skeleton(), pcpds_obj.get_distance()) m = d.homology_persistence(f) diagram = d.init_diagrams(m, f) pcpds_obj.set_persistance_diagram(diagram) pcpds_obj.set_filtration_used(Filtration.get_rips_diagram, "rips") return pcpds_obj
def generate_rv_complex(PointsArray, Dimension): dists = pdist(PointsArray) # adjacentDist = [norm(PointsArray[i,:] - PointsArray[i+1,:]) for i in range(len(PointsArray)-1)] Alpha = max(dists) rips = d.fill_rips(dists, Dimension, Alpha) m = d.homology_persistence(rips) dgms = d.init_diagrams(m, rips) return rips, m, dgms
def PersistentDiagram(nparray,dim=1,skeletondim=2): stime=timer() DisM=distance.pdist(nparray,'euclidean') M=DisM.max() VRC=d.fill_rips(nparray,skeletondim,M) ph=d.homology_persistence(VRC) dgms=d.init_diagrams(ph,VRC) timer(stime) return dgms[dim]
def fit(self, data): """ Generate Rips filtration and cycles for data. """ # Generate rips filtration maxeps = np.max(data.std(axis=0)) # TODO: is this the best choice? simplices = dionysus.fill_rips(data, self.order+1 , maxeps) self.from_simplices(simplices)
def test_rips(n=100, dim=2): # dionysus version t0 = time.time() points = np.random.random((n, dim)) f = d.fill_rips(points, 2, 0.3) print(f) # for s in f: # print(s) print('Computing rips of %s nodes at dim %s takes %s' % (n, dim, pf(time.time() - t0)))
def get_tris(A, labels): A_u = make_undirected(A) A_u[A_u != 0] = 0.1 A_u[A_u == 0] = 10 np.fill_diagonal(A_u, 0) f = dio.fill_rips(squareform(A_u), k=2, r=1) tris = [fix_vert_nums(i, labels) for i in f if i.dimension() == 2] return tris
def compute_diagrams(data, k_filt=3, to_return=2): diagrams = [] for i in range(len(data)): # print("Processing data: " + str(i) + "\n") filtration = dion.fill_rips(data[i], k_filt, 3.0) homology = dion.homology_persistence(filtration) diagram = dion.init_diagrams(homology, filtration) diagrams.append(diagram[to_return]) return diagrams
def geomill(arr,dim=1,cutoff=2,elevation=45,azimuth=30): #E3view(arr,elevation,azimuth) #VR complex stime=timer() skeletondim=dim+1 filtration = d.fill_rips(arr, skeletondim, cutoff) #persistent homology ph = d.homology_persistence(filtration) dgms = d.init_diagrams(ph, filtration) d.plot.plot_bars(dgms[dim], show = True) timer(stime) return dgms
def compute_diagrams(data): diagrams = [] for i in range(len(data)): # print("Processing data: " + str(i)) filtration = dion.fill_rips(data[i], 2, 3.0) homology = dion.homology_persistence(filtration) diagram = dion.init_diagrams(homology, filtration) diagrams.append(diagram[1]) # print() return diagrams
def geomill(arr, skeletondim=2, elevation=45, azimuth=30): #3D illustration fig = pyplot.figure() ax = Axes3D(fig) ax.view_init(elev=elevation, azim=azimuth) ax.scatter(arr[:, 0], arr[:, 1], arr[:, 2]) pyplot.show() #VR complex filtration = d.fill_rips(circ, skeletondim, 2) #persistent homology ph = d.homology_persistence(filtration) dgms = d.init_diagrams(ph, filtration) d.plot.plot_bars(dgms[1], show=True) return ax, dgms
def RipsFiltration(neuron_file, k=2, r=.5): """ Compute the rips filtration of a neuron with dionysus. Requires dionysus library :param neuron_file: :param k: max skeleton dimension :param r: compute the Ribs Filtration with max value = r * max distance between points, r \in [0, 1] :return: """ nrn = tmd.io.load_neuron(neuron_file) points = np.concatenate( [[np.array([x, y, z]) for x, y, z in zip(t.x, t.y, t.z)] for t in nrn.neurites]) D = pdist(points) return di.fill_rips(squareform(D), k, r * D.max())
def forward(ctx, x, saturation=None, maxdim=1, verbose=False): MAX_DIMENSION = maxdim + 1 # maximal simplex dimension if verbose: print("*** dgm start") if saturation == None: SATURATION_VALUE = 3.1 print("==== WARNING: NO SATURATION VALUE GIVEN, {}".format( SATURATION_VALUE)) else: SATURATION_VALUE = saturation start_time = time.time() function_values = x # list of function values on vertices, and maximal dimension it will return 0,1,2,3 function_useable = function_values.data.numpy() ''' 2 is max homology dimension ''' ''' returns (sorted) filtration filled with the k-skeleton of the clique complex built on the points at distance at most r from each other ''' F = d.fill_rips(function_useable, MAX_DIMENSION, SATURATION_VALUE) # F.sort() # this is done in computePersistence dgms, Tbl = computePersistence(F) max_pts = np.max([len(dgms[i]) for i in range(maxdim + 1)]) num_dgm_pts = max_pts ''' -1 is used later ''' dgms_inds = -1 * np.ones([maxdim + 1, num_dgm_pts, 4]) dgms_values = -np.inf * np.ones([ maxdim + 1, num_dgm_pts, 2 ]) # -1.0 * np.ones([3, num_dgm_pts, 2]) for dim in range(maxdim + 1): if len(dgms[dim]) > 0: dgm = np.array(dgms[dim]) dgm[dgm == np.inf] = SATURATION_VALUE l = np.min([num_dgm_pts, len(dgm)]) arg_sort = np.argsort(np.abs(dgm[:, 1] - dgm[:, 0]))[::-1] dgms_inds[dim][:l] = dgm[arg_sort[:l], 2:6] dgms_values[dim][:l] = dgm[arg_sort[:l], 0:2] dgms_inds = dgms_inds.reshape([maxdim + 1, num_dgm_pts, 2, 2]) #print dgms_values #dgms_values[dgms_values == np.inf] = SATURATION_VALUE #-1.0, Won't show up as inifinite, but good enough output = torch.tensor(dgms_values).type(dtype) ctx.save_for_backward(x, torch.tensor(dgms_inds).type(dtype), output, torch.tensor(verbose)) if verbose: print("*** dgm done", time.time() - start_time) return output
def fpd_cluster(data, c, verbose=False, max_iter=5, p=1, max_range=10, T=100): # Compute topological fuzzy clusters of a collection of point clouds # # inputs: list of datasets data, number of cluster centres c, # verbose True/False, maximum iterations max_iter, # dimension p-PH p, Rips parameter max_range, hyper-parameter T # (if unsure of value for max_range or T, set as the furthest distance between two points) # outputs: membership values r, cluster centres M diagrams = [] for i in range(len(data)): filtration = dion.fill_rips(data[i], p + 1, max_range) homology = dion.homology_persistence(filtration) diagram = dion.init_diagrams(homology, filtration) diagrams.append(diagram[p]) diagrams = reformat_diagrams(diagrams, T) r, M = pd_fuzzy(diagrams, c, verbose, max_iter) return r, M
def compute_persistence(self, max_epsilon): ''' Computes persistence of self.points up to max_epsilon and returns persistence diagrams :param max_epsilon: max epsilon for persistence :return: class Diagram ''' # fill rips complex up to distance max_epsilon using self.points filtration = d.fill_rips(self.points, self.k_skeleton, max_epsilon) # before computing persistence we sort the filtration filtration.sort() # compute persistence and return ReducedMatrix matrix = d.homology_persistence(filtration, prime = 2) # initialize diagrams with ReducedMatrix and filtration diagrams = d.init_diagrams(matrix, filtration) return diagrams
def __init__(self, Win_or_Lose_kihus, dim=2, radius=2 * np.sqrt(2), step=10): ##initializing parameter self.radius = radius self.dim = dim self.step = step self.kihus = Win_or_Lose_kihus ##making filltration self.dim2_fill_list = [] for kihu in self.kihus: remainder = len(kihu) % step turns = np.arange(step, len(kihu), step) if remainder >= step / 2: turns = np.append(turns, len(kihu)) else: turns[-1] = len(kihu) self.dim2_fill_list.append( [d.fill_rips(pdist(kihu[:t]), dim, radius) for t in turns])
dgm_denoise_0 = bars_0 dgm_denoise_1 = bars_1 #print(type(dgm_denoise_0)) #dionysus.plot.plot_diagram(dgm_denoise_0, show=False) #dionysus.plot.plot_diagram(dgm_denoise_1, show=False) return ([dgm_denoise_0, dgm_denoise_1]) #Let us compute the bottle-neck distance between full dataset and k-PCA dataset. k denotes the number of principal components. prime = 23 D = 20 #Here is the data insertion part mean = np.repeat(0, D) cov = np.identity(D) dat1 = np.random.multivariate_normal(mean, cov, 100) vr = dionysus.fill_rips(dat1, 2, 10) #Vietoris-Rips complex cp = dionysus.cohomology_persistence(vr, prime, True) #Create the persistent cohomology dgms = dionysus.init_diagrams( cp, vr ) #Calculate the persistent diagram using the designated coefficient field. #record for plottings.. A = np.array([0, 0, 1, 1]) for thres in [0, 0.025, 0.05, 0.1, 0.2]: #######Thresholding the features on the persistent diagrams describing persistent cohomology of VR complex(CC) dgms_tmp = denoise_dgm(dgms, thres) #thresholding CC diagrams dgms_base_0 = dionysus._dionysus.Diagram( ) #take persistent points of dim 0 dgms_base_1 = dionysus._dionysus.Diagram( ) #take persistent points of dim 1
plt.gca().set_aspect('equal', 'datalim') ax = fig.add_subplot(111, projection='3d') ax.set_xlim([-2, 2]) ax.set_ylim([-2, 2]) ax.set_zlim([-2, 2]) ax.scatter(xs=X[:, 0], ys=X[:, 1], zs=X[:, 2], s=10, c='b') plt.title('Scatter plot of data points') pdf.savefig(fig) # The persistent cohomology of $X$ is in the plot. As expected from the dataset, the $1$-dimensional persistent cohomology # of $X$ has one prominent topological feature. # In[5]: prime = 23 #choose the prime base for the coefficient field that we use to construct the persistence cohomology. vr = dionysus.fill_rips(X, 2, 2.) #Vietoris-Rips complex cp = dionysus.cohomology_persistence( vr, prime, True) #Create the persistent cohomology based on the chosen parameters. dgms = dionysus.init_diagrams( cp, vr ) #Calculate the persistent diagram using␣ the designated coefficient field and complex. # In[6]: with PdfPages('fig_cc-pca_dataset_ph.pdf') as pdf: fig = plt.figure(figsize=(4, 4), dpi=100) plt.xlim([0, 2]) plt.yticks([]) plt.title('Barcode(dim 1) of data points') dionysus.plot.plot_bars(dgms[1], show=True)
import scipy.io # The followings are input data filename = "Point.txt" # input a point cloud dataset; data = np.genfromtxt(filename, delimiter=' ') tK = 1 # threshold for simplicial complex K tL = 1.5 # threshold for simplicial complex L end = 1.5 # largest threshold for building the Vietoris-Rips complex q = 2 # dimension for the persistent Laplacian # Building a Vietoris-Rips complex f = d.fill_rips(data, q + 1, end) print(f) count = 0 for s in f: count = count + 1 print(count) shape = (count, count) Bw = np.zeros(shape, dtype=int) if q == 0: # If q=0, returns only the 1-boundary matrix of L q1_column_index = [] q1_row_index = [] Kind = 0 for s in f:
fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.set_xlim(dims[0][0],dims[0][1]) ax.set_ylim(dims[1][0],dims[1][1]) ax.set_zlim(dims[2][0],dims[2][1]) ax.scatter(sphere_data[:,0],sphere_data[:,1],sphere_data[:,2]) ax.set_aspect("equal") plt.show() """ computing homology """ #VR filtration TDA test_f = d.fill_rips(TDA_data, 2, 10.) p = d.homology_persistence(test_f) dgms = d.init_diagrams(p, test_f) #scatters d.plot.plot_diagram(dgms[0]) d.plot.plot_diagram(dgms[1]) plt.show() #bars d.plot.plot_bars(dgms[0]) plt.show() d.plot.plot_bars(dgms[1]) plt.show()
import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from sklearn import manifold, datasets n_points = 100 Y, color = datasets.make_circles(n_points, random_state=1, factor=0.5, noise=0) fig, ax = plt.subplots() ax.scatter(Y[:,0], Y[:,1], c=color, cmap=plt.cm.Spectral) # plt.show() import dionysus as d max_epsilon = 1 k_skeleton = 3 f = d.fill_rips(Y, k_skeleton, max_epsilon) p = d.homology_persistence(f) dgms = d.init_diagrams(p, f) fig, axes = plt.subplots(nrows=2, ncols=2) d.plot.plot_diagram(dgms[0], ax=axes[0,0], show=False) d.plot.plot_diagram(dgms[1], ax=axes[0,1], show=False) d.plot.plot_bars(dgms[0], ax=axes[1,0], show=False) d.plot.plot_bars(dgms[1], ax=axes[1,1], show=False) axes[0,0].set_title("Dimension 0") axes[0,1].set_title("Dimension 1") plt.show()
plt.ylabel('Y') plt.gca().set_aspect('equal', 'datalim') plt.scatter(X[:, 0], X[:, 1], s=10, c='b') plt.axis('equal') plt.title('Scatter plot of data points') pdf.savefig(fig) # The persistent cohomology of $X$ is in the plot. As expected from the dataset, the $1$-dimensional persistent cohomology # of $X$ has one prominent topological feature. # In[13]: prime = 23 #choose the prime base for the coefficient field that we use to construct the persistence cohomology. vr = dionysus.fill_rips(X, 2, 2.) #Vietoris-Rips complex cp = dionysus.cohomology_persistence(vr, prime, True) #Create the persistent cohomology based on the chosen parameters. dgms = dionysus.init_diagrams(cp, vr) #Calculate the persistent diagram using␣ the designated coefficient field and complex. # In[14]: with PdfPages('fig_cp-cp_dataset_ph.pdf') as pdf: fig = plt.figure(figsize=(4,4), dpi=100) plt.xlim([0, 2]) plt.yticks([]) plt.title('Barcode(dim 1) of data points') dionysus.plot.plot_bars(dgms[1], show=True) #dionysus.plot.plot_diagram(dgms[1], show=True) #dionysus.plot.plot_diagram(dgms[0], show=True)
def setup_Zigzag_fixed(self, r, k=2, verbose=False): ''' Helper function for ``run_Zigzag`` that sets up inputs needed for Dionysus' zigzag persistence function. This only works for a fixed radius r. Parameters ---------- r: float Radius for rips complex k: int, optional Max dimension for rips complex (default is 2) verbose: bool, optional If true, prints updates when running code Returns ------- filtration: dio.Filtration Dionysis filtration containing all simplices that exist in zigzag sequence times: list List of times, where times[i] is a list containing [a,b] where simplex i appears at time a, and disappears at time b ''' lst = list(self.ptclouds['PtCloud']) # simps_df = pd.DataFrame(columns = ['Simp','B,D']) simps_list = [] times_list = [] # Vertex counter vertind = 0 init_st = time.time() # Initialize A with R(X_0) rips = dio.fill_rips(lst[0], k=2, r=r) rips.sort() rips_set = set(rips) # Initialize A with set of simplices with verts in X_0 A = rips_set # # Add all simps to the list with birth,death=[0,1] simps_list = simps_list + [s for s in A] times_list = times_list + [[0, 1] for j in range(len(A))] # Initialize with vertices for X_0 verts = set( [dio.Simplex([j + vertind], 0) for j, pc in enumerate(lst[0])]) init_end = time.time() if verbose: print(f'Initializing done in {init_end-init_st} seconds...') loop_st = time.time() # Loop over the rest of the point clouds for i in range(1, len(lst)): # Calculate rips of X_{i-1} \cup X_i rips = dio.fill_rips(np.vstack([lst[i - 1], lst[i]]), k=2, r=r) # Adjust vertex numbers, sort, and make into a set rips = fix_dio_vert_nums(rips, vertind) rips.sort() rips_set = set(rips) # Increment vertex counter vertind = vertind + len(verts) # Set of vertices in R(X_i) verts_next = set( [dio.Simplex([j + vertind], 0) for j, pc in enumerate(lst[i])]) # Set of simplices with verts in X_{i} B = set(verts_next.intersection(rips_set)) # Set of simplices with verts in X_{i-1} AND X_{i} M = set() # Loop over vertices in R(X_{i-1} \cup R_i) for simp in rips: # Get list of vertices of simp bdy = get_verts(simp) # If it has no boundary and its in B, its a vertex in B and has been handled if not bdy: continue # If all of its verts are in A, it's been handled in the initialization or the previous iteration if bdy.intersection(A) == bdy: continue # If all of its verts are in B, add it to B elif bdy.intersection(B) == bdy: B.add(simp) # If it has some verts in A and some in B, it only exists in the union # Add it to M else: M.add(simp) # Add simplices in B with the corresponding birth,death times simps_list = simps_list + [s for s in B] times_list = times_list + [[i - 0.5, i + 1] for j in range(len(B))] # Add simplicies in M with corresponding birth,death times simps_list = simps_list + [s for s in M] times_list = times_list + [[i - 0.5, i] for j in range(len(M))] # Reinitialize for next iteration verts = verts_next A = B loop_end = time.time() if verbose: print(f'Preprocessing done in {loop_end-loop_st} seconds...') f_st = time.time() filtration = dio.Filtration(simps_list) f_end = time.time() return filtration, times_list
def setup_Zigzag_changing(self, r, k=2, verbose=False): ''' Helper function for ``run_Zigzag`` that sets up inputs needed for Dionysus' zigzag persistence function. This one allows r to be a list of radii, rather than one fixed value Parameters ---------- r: list List of radii for rips complex of each X_i k: int, optional Max dimension for rips complex (default is 2) verbose: bool, optional If true, prints updates when running code Returns ------- filtration: dio.Filtration Dionysis filtration containing all simplices that exist in zigzag sequence times: list List of times, where times[i] is a list containing [a,b] where simplex i appears at time a, and disappears at time b ''' lst = list(self.ptclouds['PtCloud']) # If you haven't input enough r values, just append extra of the last # list entry to make it the right number if len(r) < len(lst): if verbose: print('Warning: too few radii given, duplicating last entry') r = r + ([r[-1]] * (len(lst) - len(r))) elif len(r) > len(lst): if verbose: print('Warning: too many radii given, only using first ', len(lst)) r = r[:len(lst)] self.r = r # simps_df = pd.DataFrame(columns = ['Simp','B,D']) simps_list = [] times_list = [] # Vertex counter vertind = 0 init_st = time.time() # Initialize A with R(X_0) rips = dio.fill_rips(lst[0], k=2, r=r[0]) rips.sort() rips_set = set(rips) # Initialize A with set of simplices with verts in X_0 # In the loop, this will store simplices with verts in X_{i-1} A = rips_set # Add all simps to the list with birth,death=[0,1] simps_list = simps_list + [s for s in A] times_list = times_list + [[0, 1] for j in range(len(A))] # Initialize with vertices for X_0 # In the loop, this will store vertices in X_{i-1} verts = set( [dio.Simplex([j + vertind], 0) for j, pc in enumerate(lst[0])]) init_end = time.time() if verbose: print(f'Initializing done in {init_end-init_st} seconds...') loop_st = time.time() # Loop over the rest of the point clouds for i in range(1, len(lst)): # Calculate rips of X_{i-1} \cup X_i rips = dio.fill_rips(np.vstack([lst[i - 1], lst[i]]), k=2, r=max(r[i - 1], r[i])) # Adjust vertex numbers, sort, and make into a set rips = fix_dio_vert_nums(rips, vertind) rips.sort() rips_set = set(rips) # Increment vertex counter vertind = vertind + len(verts) # Set of vertices in X_{i} verts_next = set( [dio.Simplex([j + vertind], 0) for j, pc in enumerate(lst[i])]) # Set of simplices with verts in X_{i} B = set(verts_next.intersection(rips_set)) # Set of simplices with verts in X_{i-1} AND X_{i} # And simplicies in X_{i-1} \cup X_{i} that are not in X_{i-1} or X_i M = set() # Loop over vertices in R(X_{i-1} \cup R_i) for simp in rips: # Get list of vertices of simp bdy = get_verts(simp) #set([s for s in simp.boundary()]) # If it has no boundary and its in B, its a vertex in B and has been handled if not bdy: continue # If all of its verts are in A, it's been handled in the initialization or the previous iteration if bdy.intersection(A) == bdy: if r[i - 1] < r[i]: if simp.data > r[i - 1]: # If we haven't seen it before, add it to M if simp not in simps_list: M.add(simp) # If we've already added it to the list... else: # Edit the lists to include new birth,death times simps_list, times_list = edit_Simp_Times( simp, [i - 0.5, i], simps_list, times_list) # If all of its verts are in B... elif bdy.intersection(B) == bdy: # If r[i-1] <= r[i], anything with verts in B should also be in B if r[i - 1] <= r[i]: B.add(simp) # If r[i-1] > r[i], we need to check if it should go in M or B else: # If simplex's birth time is greater than the radius, it goes in M if simp.data > r[i]: M.add(simp) # If it's <= then it goes in B else: B.add(simp) # If it has some verts in A and some in B, it only exists in the union else: # If we haven't seen it before, add it to M if simp not in simps_list: M.add(simp) # If we've already added it to the list... else: # Edit the lists to include new birth,death times simps_list, times_list = edit_Simp_Times( simp, [i - 0.5, i], simps_list, times_list) # Add simps and times that are in B simps_list = simps_list + [simp for simp in B] times_list = times_list + [[i - 0.5, i + 1] for j in range(len(B))] # Add simps and times that are in M simps_list = simps_list + [simp for simp in M] times_list = times_list + [[i - 0.5, i] for j in range(len(M))] # Reinitialize for next iteration verts = verts_next A = B loop_end = time.time() if verbose: print(f'Preprocessing done in {loop_end-loop_st} seconds...') # Put list of simplices into Filtration format filtration = dio.Filtration(simps_list) return filtration, times_list
def get_dgms(dists): f = d.fill_rips(dists, 1, np.amax(dists) + 1) m = d.homology_persistence(f) dgms = d.init_diagrams(m, f) return dgms[0]
plt.axis('equal') plt.title('Scatter plot of data points') pdf.savefig(fig) # # ############################## ############################## #Compute Persistence Diagrams# prime = 23 maxscale = float(sys.argv[3]) #Choose the prime base for the coefficient field that we use to construct the persistence cohomology. threshold = float(sys.argv[2]) print('Base coefficient field: Z/', prime ,'Z',sep='') print('Maximal scale:', float(sys.argv[3])) print('Persistence threshold for selecting significant cocycles:',threshold) vr = dionysus.fill_rips(dataset, 2, float(sys.argv[3])) #Vietoris-Rips complex cp = dionysus.cohomology_persistence(vr, prime, True) #Create the persistent cohomology based on the chosen parameters. dgms = dionysus.init_diagrams(cp, vr) #Calculate the persistent diagram using the designated coefficient field and complex. now = datetime.datetime.now() print('>>>>>>End Time (VR-computation):',now.strftime("%Y-%m-%d %H:%M:%S")) ###Plot the barcode and diagrams using matplotlib incarnation within Dionysus2. This mechanism is different in Dionysus. #Plots of persistence barcodes of Vietoris-Rips complex for dimension 0 and 1. fig = plt.figure(figsize=(5,5), dpi=100) plt.title('Persistence Barcode for dim 0') dionysus.plot.plot_bars(dgms[0], show=True) pdf.savefig(fig) fig = plt.figure(figsize=(5,5), dpi=100) plt.title('Persistence Barcode for dim 1')
[3 * i + 1 | 1 for i in range(1, n // 3 - correction) if sieve[i]]) n_max = 10**3 n_list = rwh_primes(n_max) print(n_max) m_list = np.sqrt(n_list).astype(int) k_list = n_list - m_list**2 zero_list = 0 * n_list a_list = np.maximum(zero_list, k_list - m_list) b_list = np.minimum(k_list, m_list) odd_m_indices = np.where(m_list % 2 == 1) even_m_indices = np.where(m_list % 2 == 0) Ux_odd_m = (m_list[odd_m_indices] + 1) // 2 - a_list[odd_m_indices] Uy_odd_m = (-m_list[odd_m_indices] + 1) // 2 + b_list[odd_m_indices] U_odd_m = np.array((Ux_odd_m, Uy_odd_m)).T #, n_list[odd_m_indices])).T Ux_even_m = -m_list[even_m_indices] // 2 + a_list[even_m_indices] Uy_even_m = m_list[even_m_indices] // 2 - b_list[even_m_indices] U_even_m = np.array((Ux_even_m, Uy_even_m)).T #, n_list[even_m_indices])).T U_all = np.vstack((U_odd_m, U_even_m)).astype(float) f = d.fill_rips(U_all, 2, 20.) p = d.homology_persistence(f) dgms = d.init_diagrams(p, f) d.plot.plot_diagram_density(dgms[1], show=True)
vertex1 = 0 vertex2 = 1 vertex3 = 2 print('Making simplex from verts: ', vertex1, vertex2, vertex3) s=d.Simplex([vertex1,vertex2,vertex3]) print("Here is the simplex: ", s) print("Its dimension is: ", s.dimension()) print("And its boundary...") for sb in s.boundary(): print(sb) print("Great - So we can work with simplecies, but we can also work with points") print("Here is an array (Must be numpy)") points = np.array([[0.0,1.0],[2.0,0.0],[0.0,0.0]]) print(points) #Computes rips filtration up to 2 skeleton and up to radius 5 f = d.fill_rips(points, 2, 5) print("Here is the Rips filtration of the points: ", f) for x in f: print("Simplex :", x)