def _correlation_es_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op): """ Internal function for calculating the three-operator two-time correlation function: <A(t)B(t+tau)C(t)> using an exponential series solver. """ # the solvers only work for positive time differences and the correlators # require positive tau if state0 is None: rho0 = steadystate(H, c_ops) tlist = [0] elif isket(state0): rho0 = ket2dm(state0) else: rho0 = state0 if debug: print(inspect.stack()[0][3]) # contruct the Liouvillian L = liouvillian(H, c_ops) corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex) solES_t = ode2es(L, rho0) # evaluate the correlation function for t_idx in range(len(tlist)): rho_t = esval(solES_t, [tlist[t_idx]]) solES_tau = ode2es(L, c_op * rho_t * a_op) corr_mat[t_idx, :] = esval(expect(b_op, solES_tau), taulist) return corr_mat
def test_emcee_PT_output(self): # test mcmc output when using parallel tempering if not HAS_EMCEE: return True try: from pandas import DataFrame except ImportError: return True out = self.mini.emcee(ntemps=6, nwalkers=10, steps=20, burn=5, thin=2) assert_(isinstance(out, MinimizerResult)) assert_(isinstance(out.flatchain, DataFrame)) # check that we can access the chains via parameter name assert_(out.flatchain['amp'].shape[0] == 80) assert out.errorbars assert_(np.isfinite(out.params['amp'].correl['period'])) # the lnprob array should be the same as the chain size assert_(np.size(out.chain)//out.nvarys == np.size(out.lnprob)) # test chain output shapes assert_(out.lnprob.shape == (6, 10, (20-5+1)/2)) assert_(out.chain.shape == (6, 10, (20-5+1)/2, out.nvarys)) # Only the 0th temperature is returned assert_(out.flatchain.shape == (10*(20-5+1)/2, out.nvarys))
def getStripStatistics(self, yKey='vPhi', nMin=10): """For each of the strips, get the strip statistics""" if np.size(self.stripsFeH) < 1: self.buildStripsFeH() # may as well loop through!! # View of what we're using for our vertical quantity x = self.tSim['FeHObs'] y = self.tSim[yKey] nStrips = np.size(self.stripsFeH) - 1 self.stripCounts = np.zeros(nStrips, dtype='int') self.stripMeans = np.zeros(nStrips) self.stripMedns = np.zeros(nStrips) self.stripStdds = np.zeros(nStrips) self.stripFeHs = np.zeros(nStrips) # central point for sample for iStrip in range(nStrips): xLo = self.stripsFeH[iStrip] xHi = self.stripsFeH[iStrip+1] bStrip = (self.bSel) & (x >= xLo) & (x < xHi) self.stripCounts[iStrip] = np.sum(bStrip) if self.stripCounts[iStrip] < nMin: continue self.stripMeans[iStrip] = np.mean(y[bStrip]) self.stripMedns[iStrip] = np.median(y[bStrip]) self.stripStdds[iStrip] = np.std(y[bStrip]) self.stripFeHs[iStrip] = np.median(x[bStrip])
def set_feature(self, feature, fid): """ self.set_feature(feature,fid): Add a feature to the feature list of the structure Parameters ---------- feature: array of shape(self.nb_subj,self.k,fdim), where fdim is the feature dimension fid, string, the feature id """ # 1. test that the feature does not exist yet i = np.array([fid == f for f in self.fids]) i = np.nonzero(i) i = np.reshape(i, np.size(i)) if np.size(i) > 0: raise ValueError, "Existing feature id" # 2. if no, add the new one if np.size(feature) == self.nbsubj * self.k: feature = np.reshape(feature, (self.nbsub, self.k)) if (feature.shape[0]) == self.nb_subj: if (feature.shape[1]) == self.k: self.features.append(feature) self.fids.append(fid) else: raise ValueError, "incoherent size" else: raise ValueError, "incoherent size"
def subdomain_from_balls(domain, positions, radii): """Create discrete ROIs as a set of balls within a certain coordinate systems. Parameters ---------- domain: StructuredDomain instance, the description of a discrete domain positions: array of shape(k, dim): the positions of the balls radii: array of shape(k): the sphere radii """ # checks if np.size(positions) == positions.shape[0]: positions = np.reshape(positions, (positions.size), 1) if positions.shape[1] != domain.em_dim: raise ValueError('incompatible dimensions for domain and positions') if positions.shape[0] != np.size(radii): raise ValueError('incompatible positions and radii provided') label = - np.ones(domain.size) for k in range(radii.size): supp = np.sum((domain.coord - positions[k]) ** 2, 1) < radii[k] ** 2 label[supp] = k return SubDomains(domain, label)
def __init__(self, vs, dz, ratio_vp_vs, ratio_rho_vs, name='', store_vg_at_periods=None): """ Initializes model with layers' Vs (vs), layers' thickness (dz), and layers' ratio Vp/Vs and rho/Vs (ratio_vp_vs, ratio_rho_vs). """ # checking shapes nlayers = np.size(vs) if np.size(dz) != nlayers - 1: raise Exception("Size of dz should be nb of layers minus 1") if not np.size(ratio_vp_vs) in [1, nlayers]: raise Exception("Size of ratio_vp_vs should be nb of layers or 1") if not np.size(ratio_rho_vs) in [1, nlayers]: raise Exception("Size of ratio_rho_vs should be nb of layers or 1") self.name = name self.vs = np.array(vs) self.dz = np.array(dz) self.ratio_vp_vs = np.array(ratio_vp_vs) self.ratio_rho_vs = np.array(ratio_rho_vs) # storing vg model at selected periods if required self.stored_vgperiods = store_vg_at_periods if not store_vg_at_periods is None: self.stored_vg = self.vg_model(store_vg_at_periods) else: self.stored_vg = None
def _total_to_compress_renum(mask, n=None): """ Parameters ---------- mask : 1d boolean array or None mask n : integer length of the mask. Useful only id mask can be None Returns ------- renum : integer array array so that (`valid_array` being a compressed array based on a `masked_array` with mask *mask*) : - For all i such as mask[i] = False: valid_array[renum[i]] = masked_array[i] - For all i such as mask[i] = True: renum[i] = -1 (invalid value) """ if n is None: n = np.size(mask) if mask is not None: renum = -np.ones(n, dtype=np.int32) # Default num is -1 valid = np.arange(n, dtype=np.int32).compress(~mask, axis=0) renum[valid] = np.arange(np.size(valid, 0), dtype=np.int32) return renum else: return np.arange(n, dtype=np.int32)
def arraySlidingWindow(result_array, sliding_window_size, filter_ratio): array_length = np.size(result_array) buffer_array = np.zeros((1), dtype = np.int) for index in range(0, array_length - sliding_window_size): window_score = np.sum(result_array[index: index + sliding_window_size]) if window_score > (sliding_window_size * filter_ratio): buffer_array = np.append(buffer_array, 1) else: buffer_array = np.append(buffer_array, 0) buffer_array= np.delete(buffer_array, 0) # print buffer_array length = np.size(buffer_array) flag_array = np.zeros((length), dtype = np.int) pre_value = 0 for buffer_index , value in enumerate(buffer_array): if (pre_value - value) == -1: flag_array[buffer_index] = 1 elif(pre_value - value) == 1: flag_array[buffer_index] = -1 else: pass pre_value = value return flag_array
def randmeanfor(R): mean_p = 0 count_p = 0 mean_n = 0 count_n = 0 shape = np.shape(R) R = np.reshape(R, np.size(R)) for k in np.arange(np.size(R)): if R[k] > 0: mean_p = mean_p + R[k] count_p = count_p + 1 elif R[k] < 0: mean_n = mean_n + R[k] count_n = count_n + 1 mean_p = mean_p / count_p mean_n = mean_n / count_n for k in np.arange(size(R)): if R[k] > 0: R[k] = mean_p elif R[k] < 0: R[k] = mean_n R = np.reshape(R, shape) return R
def explore_city_data(city_data): """Calculate the Boston housing statistics.""" # Get the labels and features from the housing data housing_prices = city_data.target housing_features = city_data.data ################################### ### Step 1. YOUR CODE GOES HERE ### ################################### # Please calculate the following values using the Numpy library print "Size of data (number of houses)" print np.size(housing_prices) print "Number of features" print np.size(housing_features, 1) print "Minimum price" print np.min(housing_prices) print "Maximum price" print np.max(housing_prices) print "Calculate mean price" print np.mean(housing_prices) print "Calculate median price" print np.median(housing_prices) print "Calculate standard deviation" print np.std(housing_prices)
def LeaveOneOut(assets, fund, lam, dynamicmodel, band=1): n = np.size(assets,1) T = np.size(assets,0) outPoint = np.zeros([T,1]) arrR2 = np.zeros([T,1]) fund_est = np.zeros([T,1]) for t in range(band,T-band): # if t == 26 or t == 39 or t== 41 or t == 47 or t==49: # continue # Model # import ipdb; ipdb.set_trace() outPoint = np.zeros([T,1]) outPoint[t] = 1 assets_t = assets[t,:] beta, fund_est = nonstatRegress(assets, fund, lam, outPoint, dynamicmodel) beta_t = beta[t,:] fund_t = fund[t,0] # import ipdb; ipdb.set_trace() fund_t_est = np.dot(beta_t,assets_t.T) fund_est[t,0] = fund_t_est arrR2[t,0] = (fund_t-fund_t_est)*(fund_t-fund_t_est) r2 = np.mean(arrR2) return arrR2,r2,fund_est
def get_list_of_stimulus_name(Working_Directory): ## To find num z planes in each trial directory num_z_planes = [] Name_stimulus = list() Stimulus_Directories = [f for f in os.listdir(Working_Directory) if os.path.isdir(os.path.join(Working_Directory, f)) and f.find('Figures')<0] for ii in xrange(0, size(Stimulus_Directories, axis = 0)): Trial_Directories = [f for f in os.listdir(os.path.join(Working_Directory, Stimulus_Directories[ii]))\ if os.path.isdir(os.path.join(Working_Directory, Stimulus_Directories[ii], f)) and f.find('Figures')<0] #Get only directories temp_num_z_planes = zeros((size(Trial_Directories)), dtype=int) for jj in xrange(0, size(Trial_Directories, axis = 0)): Image_Directory = os.path.join(Working_Directory, Stimulus_Directories[ii], Trial_Directories[jj], 'C=1')+filesep tif = TIFF.open(Image_Directory +'T=1.tif', mode='r') #Open multitiff count = 1 for image in tif.iter_images(): temp_num_z_planes[jj] = count count = count+1 num_z_planes.append(temp_num_z_planes) for ii in xrange(0, size(Stimulus_Directories, axis = 0)): Trial_Directories = [f for f in os.listdir(os.path.join(Working_Directory, Stimulus_Directories[ii]))\ if os.path.isdir(os.path.join(Working_Directory, Stimulus_Directories[ii], f)) and f.find('Figures')<0] #Get only directories for jj in xrange(0, size(Trial_Directories, axis = 0)): for kk in xrange(0, num_z_planes[ii][jj]): name_for_saving_figures = Stimulus_Directories[ii] + ' ' + Trial_Directories[jj] + ' Z=' + str(kk+1) Name_stimulus.append(name_for_saving_figures) return Name_stimulus
def get_pixels_OFF(matched_pixels_kmeans, newclrs_rgb_OFF, unique_clrs_kmeans): matched_pixels_OFF = zeros((size(newclrs_rgb_OFF), size(matched_pixels_kmeans,1))) for ii in xrange(0,size(newclrs_rgb_OFF,0)): index = unique_clrs_kmeans.index(newclrs_rgb_OFF[ii]) print index, newclrs_rgb_OFF[ii] matched_pixels_OFF[ii,:] = matched_pixels_kmeans[index,:] return matched_pixels_OFF
def reprodution( self ): i, j, soma, sizeRoleta, classe = 0, 0, 0, 0, None qtdPrototipos = np.size( self.R, 0 ) while( i < qtdPrototipos ): sizeRoleta, j = 0, 0 while( j < self.qtdClasses ): sizeRoleta = sizeRoleta + np.size( self.V[i][j] ) j = j + 1 roleta = rd.randrange(0, sizeRoleta) j, soma = 0, 0 while( j < self.qtdClasses ): soma = soma + np.size( self.V[i][j] ) if( roleta < soma ): classe = j + 1 break j = j + 1 j = classe - 1 if( classe != self.Rclasses[i] ): newPrototipo = self.centroide( self.V[i][j] ) self.R = np.concatenate( (self.R, [newPrototipo]), 0 ) self.Rclasses = np.concatenate( ( self.Rclasses, [classe] ), 0 ) i = i + 1
def show(self, x): """ vizualisation of the mm based on the empirical histogram of x Parameters ---------- x: array of shape(nbitems): the data to be processed """ step = 3.5*np.std(x)/np.exp(np.log(np.size(x))/3) bins = max(10,int((x.max()-x.min())/step)) h,c = np.histogram(x, bins) h = h.astype(np.float)/np.size(x) p = self.mixt dc = c[1]-c[0] y = (1-p)*_gaus_dens(self.mean,self.var,c)*dc z = np.zeros(np.size(c)) i = np.ravel(np.nonzero(c>0)) z = _gam_dens(self.shape,self.scale,c)*p*dc import matplotlib.pylab as mp mp.figure() mp.plot(0.5 *(c[1:] + c[:-1]),h) mp.plot(c,y,'r') mp.plot(c,z,'g') mp.plot(c,z+y,'k') mp.title('Fit of the density with a Gamma-Gaussians mixture') mp.legend(('data','gaussian acomponent','gamma component', 'mixture distribution'))
def __init__(self, mesh, elPos, exMtx=None, step=1, perm=1., parser='et3', p=0.20, lamb=0.001, method='kotre'): """ JAC, default file parser is 'std' Parameters ---------- mesh : dict mesh structure elPos : array_like position (numbering) of electrodes exMtx : array_like, optional 2D array, each row is one excitation pattern step : int, optional measurement method perm : array_like, optional initial permitivities in generating Jacobian parser : str, optional parsing file format p,lamb : float JAC parameters method : str regularization methods """ # store configuration values self.no2xy = mesh['node'] self.el2no = mesh['element'] self.elPos = elPos # generate excitation patterns if exMtx is None: self.exMtx = eit_scan_lines(16, 8) else: self.exMtx = exMtx self.step = step # background (init, x0) perm n_e = np.size(self.el2no, 0) if np.size(perm) == n_e: perm_init = perm else: perm_init = perm * np.ones(n_e) # generate Jacobian self.fwd = forward(mesh, elPos) fs = self.fwd.solve(exMtx=self.exMtx, step=self.step, perm=perm_init, parser=parser) self.Jac = fs.Jac self.v = fs.v self.normv = la.norm(self.v) self.x0 = perm_init self.parser = parser # pre-compute H0 for dynamical imaging # H = (J.T*J + R)^(-1) * J.T self.H = h_matrix(self.Jac, p, lamb, method) self.p = p self.lamb = lamb self.method = method
def mutation( self ): i, j, qtd, qtdMax = 0, 0, 0, 0 classe = -1 qtdPrototipos = np.size( self.R, 0 ) while( i < qtdPrototipos ): j, qtdMax = 0, -float("inf") while( j < self.qtdClasses ): qtd = np.size( self.V[i][j] ) if( qtd > qtdMax ): classe = j+1 qtdMax = qtd j = j + 1 if( qtdMax != np.size( self.V[i][self.Rclasses[i]-1], 0 ) ): self.Rclasses[i] = classe i = i + 1
def convolve(self, signal, mode='full'): """ Convolve series data against another signal. Parameters ---------- signal : array Signal to convolve with (must be 1D) mode : str, optional, default='full' Mode of convolution, options are 'full', 'same', and 'valid' """ from numpy import convolve s = asarray(signal) n = size(self.index) m = size(s) # use expected lengths to make a new index if mode == 'same': newmax = max(n, m) elif mode == 'valid': newmax = max(m, n) - min(m, n) + 1 else: newmax = n+m-1 newindex = arange(0, newmax) return self.map(lambda x: convolve(x, signal, mode), index=newindex)
def trace_fracture_through_grid(m, start_yx, spacing): """Create a 2D fracture in a grid. Creates a "fracture" in a 2D grid, m, by setting cell values to unity along the trace of the fracture (i.e., "drawing" a line throuh the grid). Parameters ---------- m : 2D Numpy array Array that represents the grid start_yx : tuple of int Starting grid coordinates for fracture spacing : tuple of float Step sizes in y and x directions Returns ------- None, but changes contents of m """ y0, x0 = start_yx dy, dx = spacing x = x0 y = y0 while round(x) < size(m, 1) and round(y) < size(m, 0) \ and round(x) >= 0 and round(y) >= 0: m[int(y + 0.5)][int(x + 0.5)] = 1 x += dx y += dy
def _ringb(sino, m, n, step): mysino = np.transpose(sino) R = np.size(mysino, 0) N = np.size(mysino, 1) # Remove NaN. pos = np.where(np.isnan(mysino) is True) mysino[pos] = 0 # Kernel & regularization parameter. h = _kernel(m, n) # Mathematical correction by blocks. nblock = int(N / step) new = np.ones((R, N)) for k in range(0, nblock): sino_block = mysino[:, k * step:(k + 1) * step] alpha = _get_parameter(sino_block) pp = sino_block.mean(1) f = -_ringMatXvec(h, pp) q = _ringCGM(h, alpha, f) # Update sinogram. q.shape = (R, 1) K = np.kron(q, np.ones((1, step))) new[:, k * step:(k + 1) * step] = np.add(sino_block, K) newsino = new.astype(np.float32) return np.transpose(newsino)
def correlate(self, signal): """ Correlate records against one or many one-dimensional arrays. Parameters ---------- signal : array-like One or more signals to correlate against. """ s = asarray(signal) if s.ndim == 1: if size(s) != self.shape[-1]: raise ValueError("Length of signal '%g' does not match record length '%g'" % (size(s), self.shape[-1])) return self.map(lambda x: corrcoef(x, s)[0, 1], index=[1]) elif s.ndim == 2: if s.shape[1] != self.shape[-1]: raise ValueError("Length of signal '%g' does not match record length '%g'" % (s.shape[1], self.shape[-1])) newindex = arange(0, s.shape[0]) return self.map(lambda x: array([corrcoef(x, y)[0, 1] for y in s]), index=newindex) else: raise Exception('Signal to correlate with must have 1 or 2 dimensions')
def _exclusion_map(i, ref, target, targeti): """Ancillary function to determin admissible values of some position within some predefined values Parameters ---------- i (int): index of the structure under consideration ref: Field that represent the topological structure of parcels and their standard position target= array of shape (ref.V,3): current posistion of the parcels targeti array of shape (n,3): possible new positions for the ith item Results ------- emap: aray of shape (n): a potential that yields the fitness of the proposed positions given the current configuration rmin (double): ancillary parameter """ xyz = ref.field fd = target.shape[1] ln = ref.list_of_neighbors() j = ln[i] j = np.reshape(j, np.size(j)) rmin = 0 if np.size(j) > 0: dx = np.reshape(xyz[j] - xyz[i], (np.size(j), fd)) rmin = np.mean(np.sum(dx ** 2, 1)) / 4 u0 = xyz[i] + np.mean(target[j] - xyz[j], 0) emap = rmin - np.sum((targeti - u0) ** 2, 1) for k in j: amap = np.sum((targeti - target[k]) ** 2, 1) - rmin / 4 emap[amap < 0] = amap[amap < 0] else: emap = np.zeros(targeti.shape[0]) return emap, rmin
def XTCwrite(coords, box, filename, time=None, step=None): nframes = np.size(coords, 2) if np.size(time) != nframes: time = np.zeros(nframes) if np.size(step) != nframes: step = np.zeros(nframes, dtype=int) if os.path.isfile(filename): os.unlink(filename) lib = xtc_lib() bbox = (c_float * 3)() natoms = c_int(coords.shape[0]) cstep = c_int() # print(coords.shape) for f in range(coords.shape[2]): cstep = c_int(step[f]) ctime = c_float(time[f]) # TODO FIXME # print ( step ) # print ( time ) bbox[0] = box[0, f] * 0.1 bbox[1] = box[1, f] * 0.1 bbox[2] = box[2, f] * 0.1 data = coords[:, :, f].astype(numpy.float32) * 0.1 # Convert from A to nm pos = data.ctypes.data_as(POINTER(c_float)) lib['libxtc'].xtc_write( c_char_p(filename.encode("ascii")), natoms, cstep, ctime, pos, bbox) pass
def roll_run(CR,sx=None): """ Roll every variable in a simulation (CR) in the x direction by length in indexspace (sx) """ klst = ['rho','jx','jy','jz','bx','by','bz', 'ex','ey','ez','ne','jex','jey','jez', 'pexx','peyy','pezz','pexy','peyz','pexz', 'ni','jix','jiy','j*z','vix','viy','viz', 'vex','vey','vez','dene','deni', 'pixx','piyy','pizz','pixy','piyz','pixz', 'tepar','teperp1','tipar','tiperp1'] kavlst = [k+'av' for k in klst] if sx is None: if CR['yy'][0] < 1.0: print 'Gonna roll RIGHT!!!!!!!!!!!!' sx = -1*np.size(CR['xx'])/4 else: print 'Gonna roll LEFT!!!!!!!!!!!!' sx = np.size(CR['xx'])/4 for key in CR.keys(): # Old way not super smart # if key.rfind('av') == len(key)-2 and len(key) > 2: # print 'Rolling ',key # CR[key] = np.roll(CR[key],sx,axis=1) # New way a little bit smarter if key in klst or key in kavlst: print 'Rolling ',key CR[key] = np.roll(CR[key],sx,axis=1)
def get_heatmap(data_mat, name_for_saving_files, pp,stimulus_on_time, stimulus_off_time,delta_ff, f0_start, f0_end): #Plot heatmap for validation A1 = np.reshape(data_mat, (np.size(data_mat,0)*np.size(data_mat,1), np.size(data_mat,2))) if delta_ff == 1: delta_ff_A1 = np.zeros(np.shape(A1)) for ii in xrange(0,np.size(A1,0)): delta_ff_A1[ii,:] = (A1[ii,:]-np.mean(A1[ii,f0_start:f0_end]))/(np.std(A1[ii,f0_start:f0_end])+0.1) B = np.argsort(np.mean(delta_ff_A1, axis=1)) print np.max(delta_ff_A1) else: B = np.argsort(np.mean(A1, axis=1)) print np.max(A1) with sns.axes_style("white"): C = A1[B,:][-2000:,:] fig2 = plt.imshow(C,aspect='auto', cmap='jet', vmin = np.min(C), vmax = np.max(C)) plot_vertical_lines_onset(stimulus_on_time) plot_vertical_lines_offset(stimulus_off_time) plt.title(name_for_saving_files) plt.colorbar() fig2 = plt.gcf() pp.savefig(fig2) plt.close()
def write_to_csv(self, csv_file, session="0"): """ Write the paradigm to a csv file Parameters ---------- csv_file: string, path of the csv file session: string, optional, session identifier """ import csv with open4csv(csv_file, "w") as fid: writer = csv.writer(fid, delimiter=" ") n_pres = np.size(self.con_id) sess = np.repeat(session, n_pres) pdata = np.vstack((sess, self.con_id, self.onset)).T # add the duration information if self.type == "event": duration = np.zeros(np.size(self.con_id)) else: duration = self.duration pdata = np.hstack((pdata, np.reshape(duration, (n_pres, 1)))) # add the amplitude information if self.amplitude is not None: amplitude = np.reshape(self.amplitude, (n_pres, 1)) pdata = np.hstack((pdata, amplitude)) # write pdata for row in pdata: writer.writerow(row)
def get_candidate_loc( self, low, high ): """ find the candidate location of subvolume Parameters ---------- low : vector with length of 3, low value of deviation range high : vector with length of 3, high value of deviation range Returns: -------- ret : a tuple, the coordinate of nonzero elements, format is the same with return of numpy.nonzero. """ if np.size(self.msk) == 0: mask = np.ones(self.data.shape[1:4], dtype=self.data.dtype) else: mask = np.copy(self.msk[0,:,:,:]) # erase outside region of deviation range. ct = self.center mask[:ct[0]+low[0], :, : ] = 0 mask[:, :ct[1]+low[1], : ] = 0 mask[:, :, :ct[2]+low[2] ] = 0 mask[ct[0]+high[0]+1:, :, :] = 0 mask[:, ct[1]+high[1]+1:, :] = 0 mask[:, :, ct[2]+high[2]+1:] = 0 locs = np.nonzero(mask) if np.size(locs[0])==0: raise NameError('no candidate location!') return locs
def test_ward_clustering(): """ Check that we obtain the correct number of clusters with Ward clustering. """ rnd = np.random.RandomState(0) mask = np.ones([10, 10], dtype=np.bool) X = rnd.randn(100, 50) connectivity = grid_to_graph(*mask.shape) clustering = Ward(n_clusters=10, connectivity=connectivity) clustering.fit(X) # test caching clustering = Ward(n_clusters=10, connectivity=connectivity, memory=mkdtemp()) clustering.fit(X) labels = clustering.labels_ assert_true(np.size(np.unique(labels)) == 10) # Turn caching off now clustering = Ward(n_clusters=10, connectivity=connectivity) # Check that we obtain the same solution with early-stopping of the # tree building clustering.compute_full_tree = False clustering.fit(X) np.testing.assert_array_equal(clustering.labels_, labels) clustering.connectivity = None clustering.fit(X) assert_true(np.size(np.unique(clustering.labels_)) == 10) # Check that we raise a TypeError on dense matrices clustering = Ward(n_clusters=10, connectivity=connectivity.todense()) assert_raises(TypeError, clustering.fit, X) clustering = Ward(n_clusters=10, connectivity=sparse.lil_matrix( connectivity.todense()[:10, :10])) assert_raises(ValueError, clustering.fit, X)
def __init__(self, k, ijk, label, group_labels=None, referential=None, subjects=[]): """ Constructor """ self.k = k self.ijk = ijk.astype(np.int) self.nbvox = ijk.shape[0] if np.size(ijk) == self.nbvox: ijk = np.reshape(ijk, (self.nbvox, 1)) self.anatdim = ijk.shape[1] self.label = label.astype(np.int) if np.size(label) == self.nbvox: label = np.reshape(label, (self.nbvox, 1)) self.nb_subj = label.shape[1] if group_labels == None: self.group_labels = np.zeros(self.nbvox).astype(np.int) else: self.group_labels = group_labels if subjects == []: self.subjects = range(self.nb_subj) else: self.subjects = subjects self.referential = referential self.features = [] self.fids = [] self.check()
def create_class_vec(new_name): cfa_dir=PLS_code_dir+"data/cfaspec_snIa/" SNe_data=np.loadtxt(cfa_dir+'/cfasnIa_param_mod.dat', dtype={'names': ('SN_name', 'zhel', 'tMaxB', 'err_tMaxB', 'ref', 'Dm15', 'err_Dm15', 'ref2', 'M_B', 'err_M_B', "BmV", "err_BmV", "BmmVm", "err_BmmVm", "Phot_ref"),'formats': ('S15', "f8", "f8","f8", "S15", "f8", "f8","S15","f8" , "f8","f8", "f8","f8", "f8","S15")}) spectra_data=np.loadtxt(cfa_dir+'/cfasnIa_mjdspec.dat', dtype={'names': ('spectrum_name', 'time'),'formats': ('S40', "f8")}) SNe_BranchWang_class=np.loadtxt(cfa_dir+'/branchwangclass_mod.dat', dtype={'names': ('SN_name', 'pEW5972', 'pEW6355', 'vabs6355', 'phase', 'Branch', 'Wang'),'formats': ('S15', "f8", "f8","f8", "f8","S15","S15")}) name_regex = re.compile('(.+)\-\d+\.\d+') name_vector=[] for spectrum_name in enumerate(spectra_data["spectrum_name"]): name_vector.append(name_regex.search(spectrum_name[1]).group(1)) #It creates the vectors of the classification of Branch and Wang #SN_name_vec=[] pEW5972_vec=[] pEW6355_vec=[] vabs6355_vec=[] Branch_vec=[] Wang_vec=[] for i, supernova in enumerate(new_name): pEW5972_tmp=np.nan pEW6355_tmp=np.nan vabs6355_tmp=np.nan Branch_tmp=np.nan Wang_tmp=np.nan for name_sn in enumerate(SNe_BranchWang_class["SN_name"]): if name_sn[1] == supernova: SN_name_tmp, pEW5972_tmp, pEW6355_tmp, vabs6355_tmp, phase_tmp, Branch_tmp, Wang_tmp= SNe_BranchWang_class[name_sn[0]] #SN_name_vec.append(SN_name_tmp) pEW5972_vec.append(pEW5972_tmp) pEW6355_vec.append(pEW6355_tmp) vabs6355_vec.append(vabs6355_tmp) Branch_vec.append(Branch_tmp) Wang_vec.append(Wang_tmp) #color plot for Branch color_plot_Branch=[] for i in range(0,np.size(new_name)): if Branch_vec[i]=="CN": color_plot_Branch.append('r') elif Branch_vec[i]=="SS": color_plot_Branch.append('g') elif Branch_vec[i]=="BL": color_plot_Branch.append('b') elif Branch_vec[i]=="CL": color_plot_Branch.append('y') else: color_plot_Branch.append('w') #color plot for Wang color_plot_Wang=[] for i in range(0,np.size(new_name)): if Wang_vec[i]=="91T": color_plot_Wang.append('r') elif Wang_vec[i]=="N" : color_plot_Wang.append('g') elif Wang_vec[i]=="pec": color_plot_Wang.append('b') elif Wang_vec[i]=="HV": color_plot_Wang.append('y') elif Wang_vec[i]=="91bg": color_plot_Wang.append('c') else: color_plot_Wang.append('w') return color_plot_Wang, color_plot_Branch
def kkrelation(ref_spectral_data, cri_spectral_data, phase_offset=0.0, norm_by_ref_flag=True): """ Retrieve the real and imaginary components of a CRI spectra(um) via the Kramers-Kronig (KK) relation. Parameters ---------- ref_spectral_data : ndarray NRB reference spectra(um) array that can be one-, two-, or three-dimensional cri_spectral_data : ndarray CRI spectra(um) array that can be one-,two-,or three-dimensional (phase_offset) : int, float, or ndarray, optional Global phase offset applied to the KK, which effecively controls the real-to-imaginary components relationship (norm_by_ref_flag) : bool Should the output be normalized by the square-root of the reference NRB spectrum(a) Returns ------- out : complex ndarray The real and imaginary components of KK. Note ---- (1) The imaginary components provides the sponatenous Raman-like spectra(um). (2) This module assumes the spectra are oriented as such that the frequency (wavenumber) increases with increasing index. If this is not the case for your spectra(um), apply a phase_offset of _np.pi (3) This is the first attempt at converting MATLAB (Mathworks, Inc) scripts into Python code; thus, there will be bugs, the efficiency will be low(-ish), and I appreciate any useful suggestions or bug-finds. References ---------- Y. Liu, Y. J. Lee, and M. T. Cicerone, "Broadband CARS spectral phase retrieval using a time-domain Kramers-Kronig transform," Opt. Lett. 34, 1363-1365 (2009). C. H. Camp Jr, Y. J. Lee, and M. T. Cicerone, "Quantitative, Comparable Coherent Anti-Stokes Raman Scattering (CARS) Spectroscopy: Correcting Errors in Phase Retrieval" =================================== Original Python branch: Feb 16 2015 @author: ("Charles H Camp Jr")\n @email: ("*****@*****.**")\n @date: ("Jun 28 2015")\n @version: ("0.1.1")\n """ #import numpy as np # Ensure the shape of phase_offset is compatible # with cri_spectral_data if _np.size(phase_offset) == 1 or \ phase_offset.shape == cri_spectral_data.shape: pass else: phase_offset = _matchsize(cri_spectral_data, phase_offset) # Ensure the shape of ref_spectral_data is compatible # with cri_spectral_data if ref_spectral_data.shape == cri_spectral_data.shape: pass else: ref_spectral_data = _matchsize(cri_spectral_data, ref_spectral_data) # Return the complex KK relation using the Hilbert transform. if norm_by_ref_flag is True: # Norm the Amp by ref)spectral_data return _np.sqrt(cri_spectral_data/ref_spectral_data)*\ _np.exp(1j*phase_offset+1j*\ _np.imag(hilbertfft(0.5*_np.log(cri_spectral_data/\ ref_spectral_data)))) else: # Do NOT norm the Amp by ref)spectral_data return _np.sqrt(cri_spectral_data)*_np.exp(1j*phase_offset+1j*\ _np.imag(hilbertfft(0.5*_np.log(cri_spectral_data/\ ref_spectral_data))))
if lon_eddy[i]>=357.5 and lon_eddy[i]<=360: it_near = (np.where( ( lat_eddy > lat_eddy[i]-2.5 ) & ( lat_eddy < lat_eddy[i]+2.5 ) & ( lon_eddy < lon_eddy[i]+2.5-360 ) & ( lon_eddy > lon_eddy[i]-2.5 ) & (j1 == j1[i]) )[0]) elif lon_eddy[i]>=0 and lon_eddy[i]<=2.5: it_near = (np.where( ( lat_eddy > lat_eddy[i]-2.5 ) & ( lat_eddy < lat_eddy[i]+2.5 ) & ( lon_eddy < lon_eddy[i]+2.5 ) & ( lon_eddy > lon_eddy[i]+360-2.5 ) & (j1 == j1[i]) )[0]) else: it_near = (np.where( ( lat_eddy > lat_eddy[i]-2.5) & (lat_eddy < lat_eddy[i]+2.5 ) & ( lon_eddy < lon_eddy[i]+2.5 ) & ( lon_eddy > lon_eddy[i]-2.5 ) & (j1 == j1[i]) )[0] ) it_self = np.where(it_near == i)[0] it_near_noself = np.delete(it_near,it_self) xx = lat_eddy[it_near_noself] yy = lon_eddy[it_near_noself] it_usenum = np.size(it_near_noself) match_use_cache = (points2dist.points2dist(it_usenum, lat_eddy[i], xx, lon_eddy[i], yy , R[i], R[it_near_noself] )) it_useful = np.where(match_use_cache>0)[0] if len(it_useful)>0: ####### 有配对结果 match_cache = match_num[it_near_noself[it_useful]] ####### 配对序列筛出 it_match_never = np.where(match_cache<0)[0] ####### 配对结果未被配过部分 it_match_ever = np.where(match_cache>=0)[0] ####### 配对结果曾被配过部分 if match_num[i]<0 and len(it_match_never)==len(match_cache): ####### 本体未配 & 配对都未配 match_num[i] = i match_num[it_near_noself[it_useful]] = i elif match_num[i]<0 and len(it_match_never)<len(match_cache): ####### 本体未配 & 配对部分未配或已全配 min_match_num = min(match_cache[it_match_ever])
def functionStabilityPolynomial(self, A, b, c): s = np.size(b) e = np.ones((s, )) R = lambda z: 1 + z * np.dot(b, np.linalg.inv(np.eye(s) - z * A).dot(e)) return np.vectorize(R)
def process_mann_turb_spectra(self, casedir): ncbox={} with nc.Dataset(casedir+'/turbulence.nc') as d: #print(d.variables) ncbox['ndim'] = d.dimensions['ndim'].size ncbox['nx'] = d.dimensions['nx'].size ncbox['ny'] = d.dimensions['ny'].size ncbox['nz'] = d.dimensions['nz'].size ncbox['L'] = d.variables['box_lengths'][:] ncbox['dx'] = d.variables['dx'][:] ncbox['uvel'] = d.variables['uvel'][:,:,:] ncbox['vvel'] = d.variables['vvel'][:,:,:] ncbox['wvel'] = d.variables['wvel'][:,:,:] # Get the timei vector Uavg = 10.0 tvec = ncbox['dx'][0]/Uavg*np.arange(ncbox['nx']) # Set the scaling factors ds=5.0 eps=2.5 #2*ds gaussScale = np.sqrt(1.0/(eps*np.sqrt(np.pi)*ds)) # Average over the entire inlet plane of turbulence Suu = [] Svv = [] Sww = [] itotal = 0 print("Working...") for i in range(ncbox['ny']): sys.stdout.write("\r%d%%" % int(i*100.0/ncbox['ny'])) sys.stdout.flush() for j in range(ncbox['nz']): f, tSuu = windspectra.getWindSpectra(tvec, ncbox['uvel'][:,i,j]) f, tSvv = windspectra.getWindSpectra(tvec, ncbox['vvel'][:,i,j]) f, tSww = windspectra.getWindSpectra(tvec, ncbox['wvel'][:,i,j]) Suu = tSuu if len(Suu) == 0 else Suu + tSuu Svv = tSuu if len(Svv) == 0 else Svv + tSvv Sww = tSuu if len(Sww) == 0 else Sww + tSww itotal += 1 Suu = Suu/float(itotal) Svv = Svv/float(itotal) Sww = Sww/float(itotal) print("") print("Done.") # Octave band average Nband=3 Mannf, MannSuu = windspectra.NarrowToOctaveBand(f, Suu, Nband) Mannf, MannSvv = windspectra.NarrowToOctaveBand(f, Svv, Nband) Mannf, MannSww = windspectra.NarrowToOctaveBand(f, Sww, Nband) with nc.Dataset(casedir+'/avg_spectra.nc',mode='w',format='NETCDF3_CLASSIC') as d: d.createDimension("nfreq",np.size(Mannf)) nc_f = d.createVariable("f","f8",("nfreq")) nc_suu = d.createVariable("suu","f8",("nfreq")) nc_svv = d.createVariable("svv","f8",("nfreq")) nc_sww = d.createVariable("sww","f8",("nfreq")) nc_f[:] = Mannf nc_suu[:] = MannSuu nc_svv[:] = MannSvv nc_sww[:] = MannSww
N_ell_P_LA = np.array([ N_ell_P_27, N_ell_P_39, N_ell_P_93, N_ell_P_145, N_ell_P_225, N_ell_P_280, N_ell_P_27x39, N_ell_P_93x145, N_ell_P_225x280 ]) #################################################################### return (ell, N_ell_T_LA, N_ell_P_LA, Map_white_noise_levels) #################################################################### #################################################################### ## demonstration of the code #################################################################### print("band centers: ", Simons_Observatory_V3_LA_bands(), "[GHz]") print("beam sizes: ", Simons_Observatory_V3_LA_beams(), "[arcmin]") N_bands = np.size(Simons_Observatory_V3_LA_bands()) beams = Simons_Observatory_V3_LA_beams() beams_sigma_rad = beams / np.sqrt(8. * np.log(2)) / 60. * np.pi / 180. ## run the code to generate noise curves fsky = 0.4 N_LF = 1. N_MF = 1. N_UHF = 1. ellmax = 1e4 survey_time = 1. mode = 1 # baseline sensitivity ell, N_ell_LA_T, N_ell_LA_Pol, WN_levels = Simons_Observatory_V3_LA_noise( mode, fsky, ellmax, 1, N_LF, N_MF, N_UHF, survey_time) np.save('LAT_pertube_peryear_T_noise_baseline.npy', [ell, N_ell_LA_T])
import numpy as np import scipy as sp import pandas import matplotlib.pyplot as plt import csv as csv csv_file_object = csv.reader(open('train.csv',newline='')) header = csv_file_object.__next__() data = [] for row in csv_file_object: data.append(row) data = np.array(data) # print(data[0]) number_passengers = np.size(data[0::, 1].astype(np.int)) number_survived = np.sum(data[0::, 1].astype(np.int)) proportion_survivors = number_survived / number_passengers print("Proportion Survived: ", proportion_survivors) women_only_stats = data[0::, 4] == "female" men_only_stats = data[0::, 4] != "female" women_onboard = data[women_only_stats, 1].astype(np.float) men_onboard = data[men_only_stats, 1].astype(np.float) num_women = len(women_onboard) num_men = len(men_onboard) # print("women_only_stats: ", women_only_stats) # print("women_onboard: ", women_onboard)
import numpy as np from scipy.sparse import spdiags import matplotlib.pyplot as plt import numpy.linalg as LA x = np.arange(0,5, 0.01) n = np.size(x) one = int(n / 5) f = np.zeros(x.shape) f[0:one] = 0.0 + 0.5*x[0:one] f[one:2 * one] = 0.8 - 0.2 * np.log(x[100:200]); f[(2*one):3*one] = 0.7 - 0.2*x[(2*one):3*one]; f[(3*one):4*one] = 0.3 f[(4*one):(5*one)] = 0.5 - 0.1*x[(4*one):(5*one)]; G = spdiags([-np.ones(n), np.ones(n)], np.array([0,1]), n-1,n).toarray() etta = 0.1*np.random.randn(np.size(x)); y = f + etta # plt.figure(); plt.plot(x,y, label = "noisy"); plt.plot(x,f, label = "clean"); plt.legend() ;plt.show() # -------------------------------(a)------------------------------------------------- # argmin ||x-y||+lambda/2||Gx|| --------- x = (I+lambda/2*G^T*G)*y lam = 100 GTG = np.transpose(G) @ G M = np.eye(n) + lam/2 * GTG x_min = LA.inv(M) @ y plt.figure(); plt.plot(x,x_min, label = r'recover using ${{\scrl}_2 } norm,\lambda=100$'); plt.plot(x,f, label = "clean"); plt.legend() ;plt.show()
def checkAboutSame(i1,i2): assert(i1.shape==i2.shape) difference=np.sum(np.abs(i1-i2))/float(np.size(i1)) assert(difference<5)
j1, j2 = np.mgrid[0:img_px,0:img_px] x1 = -extent_img + j2 * xs # x2 = -extent_img + j1 * xs y1, y2 = aux.pt_lens(x1, x2, xlens+0.1, ylens, mlens) i2 = np.round((y1 + extent_src) / ys) i1 = np.round((y2 + extent_src) / ys) ind = (i1 >= 0) & (i1 < src_px) & (i2 >= 0) & (i2 < src_px) i1n = i1[ind] i2n = i2[ind] j1n = j1[ind] j2n = j2[ind] for i in np.arange(np.size(i1n)): b[int(j1n[i]),int(j2n[i])] = src[int(i1n[i]),int(i2n[i])] c += 1 fov = float(c / (src_px * src_px))*100.0 ### PLOT ### fig = plt.figure(1) ax = plt.subplot(121) ax.imshow(aux.cgs(src_px,rpix,jpos,ipos), extent = (-extent_src,extent_src,-extent_src,extent_src),cmap='hot') ax.set_title('Mag = 0') ax = plt.subplot(122)
dcn2 = np.convolve(normalized_cases, np.ones(days2) / days2, mode='same') plt.plot(date, dco, color='blue') plt.plot(date, dcn, color='red') plt.bar(date, cases, width=1, alpha=0.5, color='blue', label="cases") plt.bar(date, normalized_cases, width=0.5, alpha=0.5, color='red', label="Normalized for 300 000 tests") plt.bar(free_test_date, free_test_case, width=1, alpha=0.8, color="green", label="Start of free testing") xt = ax.get_xticks() ax.set_xticks(np.arange(xt[0], xt[np.size(xt) - 1], 30)) plt.ylim(0, 10000) plt.legend() plt.grid() plt.xlabel("Date") plt.ylabel("number of positive tests") plt.title("Number of positive corona tests in Sweden") plt.savefig("cases.png") plt.show()
def partidos_expressivos(N=1, data_inicial='2011-01-01', data_final='2011-12-31', tipos_proposicao=[]): """Retorna uma lista com os partidos com pelo menos N deputados diferentes que tenham vindo em votações entre as datas data_inicial e data_final. Consideram-se as proposições em tipos_proposição, ou todas se tipos_proposicao=[].""" # Criar dicionario com id dos partidos: con = lite.connect(Analise.db) tabela_partidos = con.execute( 'select numero,nome from partidos').fetchall() idPartido = {} for tp in tabela_partidos: idPartido[tp[1]] = tp[0] # Criar lista de todos os partidos: lista_todos_partidos = con.execute('SELECT nome FROM PARTIDOS').fetchall() con.close() # Pegar votacoes no bd: a = Analise(data_inicial, data_final, tipos_proposicao) votacoes = a._buscaVotacoes() # Inicializar variáveis tamanho_partidos = [0] * len(lista_todos_partidos) vetores_tamanho = numpy.zeros((len(lista_todos_partidos), a.num_votacoes)) #Transformar lista de tuplas em lista de strings: i = 0 for lp in lista_todos_partidos: lista_todos_partidos[i] = lp[0] i += 1 # Calcular tamanho dos partidos: ip = -1 for p in lista_todos_partidos: ip += 1 num_deputados = set( ) # Número de deputados diferentes de um partido que apareceram em pelo menos uma votação no período. iv = -1 for v in votacoes: iv += 1 # Contar deputados presentes: deps_presentes_list = [ list( numpy.array(eval(v[3]))[numpy.where( numpy.array(eval(v[3])) / 100000 == idPartido[p])]) + list( numpy.array(eval(v[4]))[numpy.where( numpy.array(eval(v[4])) / 100000 == idPartido[p])]) + list( numpy.array(eval(v[5]))[numpy.where( numpy.array(eval(v[5])) / 100000 == idPartido[p])]) + list( numpy.array(eval(v[6]))[numpy.where( numpy.array(eval(v[6])) / 100000 == idPartido[p])]) ] vetores_tamanho[ip][iv] = numpy.size(deps_presentes_list) for d in deps_presentes_list[0]: num_deputados.add( d ) # repetidos não entrarão duas vezes no set, permitindo calcular tamanho_partidos. tamanho_partidos[ip] = len(num_deputados) # Fazer lista de partidos maiores do que N: expressivos = [] ip = -1 for p in lista_todos_partidos: ip += 1 if tamanho_partidos[ip] >= N: expressivos.append(p) return expressivos
def plot_solution(sol, var, vp, x_n, y_n, x_m, y_m, n, m, r, s, I, K, T, L, fig_name, problem): x_val = sol.get_value_dict(var["x"]) y_val = sol.get_value_dict(var["y"]) w_val = sol.get_value_dict(var["w"]) if problem == "dynamic": v_val = sol.get_value_dict(var["v"]) elif problem == "static": v_val = vp else: print("Error: problem must be static or dynamic") sys.exit(1) plt.figure(figsize=(10, 5)) # breakpoint() plt.scatter(x_n[1:], y_n[1:], c='b', marker='s', label="user") plt.scatter(x_m[1:], y_m[1:], c='r', marker='s', label="CS") for i in K: plt.annotate('$%d$' % i, (x_m[i] - 0.02, y_m[i] + 0.025)) plt.legend(loc="best") plt.axis('equal') for i in I: v_it = np.zeros((2, s + 1)) for l in L: vi = np.zeros((m + 1, r + 1)) wi = np.zeros((m + 1, r + 1)) for k in K: for t in T: vi[k, t] = v_val[i, k, t, l] wi[k, t] = w_val[i, k, t, l] print((i)) print((vi[1:, 1:])) print((wi[1:, 1:])) tm = np.nonzero(wi) print(tm) if np.size(tm) != 0: v_it[0, l] = tm[0] v_it[1, l] = tm[1] else: v_it[0, l] = 0 v_it[1, l] = 0 # print(v_it) plt.annotate('$%d$' % i, (x_n[i] - .02, y_n[i] + 0.025)) v1 = v_it[0, 1:] v2 = v_it[1, 1:] # plt.annotate(str(list(v1.astype(np.int))), (x_n[i] + 0.02, y_n[i] - 0.01)) plt.annotate( str(list(v1.astype(np.int))) + '\n' + str(list(v2.astype(np.int))), (x_n[i] + 0.02, y_n[i] - 0.01)) [ plt.annotate("x_{0}_{1}_{2}".format(i, k, t), (x_n[i] - 0.002, y_n[i] - 0.04)) for i in I for k in K for t in T if x_val[i, k, t] == 1 ] [ plt.annotate("y_{0} = %d".format(k) % y_val[k], (x_m[k] - 0.002, y_m[k] - 0.04), c='r') for k in K if y_val[k] != 0 ] # plt.axis('equal') plt.savefig(fig_name, bbox_inches='tight') plt.show(block=False) plt.close(fig_name)
def finder(file_name,lower_limit,upper_limit, Ganesha=False,DLS=False,plot=False,savefig=False,savedir=os.path.dirname(os.path.realpath(__file__))): try: if Ganesha==True: delim_str=',' ht_threshold=0.0001 if DLS==True: delim_str='\t' ht_threshold=0.1 #get the data from the file table=np.genfromtxt(file_name,delimiter=delim_str,skip_header=10) #cut out the x and y data defined by the q range. x_data=table[np.intersect1d(np.where(table[0:,0]>lower_limit),np.where(table[0:,0]<upper_limit)),0] y_data=table[np.intersect1d(np.where(table[0:,0]>lower_limit),np.where(table[0:,0]<upper_limit)),1] #the number of data points to trial fits across fitting_range=10 #attempt to fit the data across a moving window of the q range of interest. This will find peaks multiple times over. peaks=np.zeros(0) for i in range(0,(np.where(table[0:,0]<upper_limit)[-1][-1]-np.where(table[0:,0]>lower_limit)[0][0]-fitting_range)): x=x_data[i:(i+fitting_range)] y=y_data[i:(i+fitting_range)] result=fitting(x,y,np.mean(x),height_threshold=ht_threshold) if result != 0: peaks=np.append(peaks, result[0]) if len(peaks)>0: #define the minimum separation between peaks - otherwise the binning of the data will put separate peaks into one bin. #bin the peaks found during the fitting procedure hist, bin_edges=np.histogram(peaks,bins=np.arange(min(peaks), max(peaks) + 0.005, 0.005)) inds=np.digitize(peaks,bin_edges) returning_peaks=np.zeros(0) for i in range(0, np.size(np.arange(min(peaks), max(peaks) + 0.005, 0.005))): try: #look forwards and backward to catch each bin incase the values have leaked between boundaries previous_bin=peaks[np.where(inds==(i-1))] this_bin=peaks[np.where(inds==i)] next_bin=peaks[np.where(inds==(i+1))] #if two bins are next to each other, group them together and average those values to return if len(this_bin)>0 and len(previous_bin)>0 and len(next_bin)==0: conc_bin=np.concatenate((this_bin,previous_bin)) returning_peaks=np.append(returning_peaks,np.mean(conc_bin)) #otherwise just average the bin and return it as the peak. elif len(this_bin)>0 and len(previous_bin)==0 and len(next_bin)==0: returning_peaks=np.append(returning_peaks,np.mean(this_bin)) except IndexError: pass if plot==True: plt.plot(x_data,y_data) for i in returning_peaks: plt.axvline(i,c='r') plt.xlabel('$q$ (Å$^{-1}$)') plt.ylabel('Intensity (A.U.)') if savefig==True: name=file_name.split('\\')[-1][:-4] plt.savefig(savedir+'/'+name+'.png',dpi=200) plt.show() plt.clf() return returning_peaks else: return 0 except UnboundLocalError: print('Error! You must tell the programme where the data was collected in order to use the peak finder.')
def __init__(self, dataset, normalizer, theta_generator): self.__dataset = dataset self.__normalizer = normalizer self.__theta_generator = theta_generator self.__theta = np.zeros((np.size(self.__dataset, 1), 1))
def Cost(parameters, Y_desired, A, X_init, Q, var_Q, alpha=1.0, specified_time=None, beta=5.0, gamma=1.0, nu=1.0, mode=QUADRATIC_EXACT, margin=None): # Sanity checks. assert alpha >= 0.0 and beta >= 0.0 assert (alpha == 0.0) == (specified_time is not None) assert (beta == 0.0) == (nu is None) assert (mode in (QUADRATIC_EXACT, ABSOLUTE_EXACT)) == (margin is None) # Prepare variable depending on whether t part of the parameters. num_nodes = A.shape[0] num_species = X_init.shape[1] num_traits = Q.shape[1] if specified_time is None: t = parameters[-1] num_parameters_i = int((np.size(parameters) - 1) / num_species) grad_all = np.zeros(np.size(parameters)) else: t = specified_time num_parameters_i = int(np.size(parameters) / num_species) grad_all = np.zeros(np.size(parameters)) # Reshape adjacency matrix to make sure. Adj = A.astype(float).reshape((num_nodes, num_nodes)) Adj_flatten = Adj.flatten().astype(bool) # Flatten boolean version. # Loop through the species to compute the cost value. # At the same time, prepare the different matrices. Ks = [] # K_s Z_0 = [] # Z^{(s)}(0) eigenvalues = [] # w eigenvectors = [] # V.T eigenvectors_inverse = [] # U.T exponential_wt = [] # exp(eigenvalues * t). x_matrix = [] # Pre-computed X matrices. x0s = [] # Avoids reshaping. qs = [] # Avoids reshaping. xts = [] # Keeps x_s(t). inside_norm = np.zeros( (num_nodes, num_traits)) # Will hold the value prior to using the norm. for s in range(num_species): x0 = X_init[:, s].reshape((num_nodes, 1)) z_0 = np.zeros(X_init.shape) z_0[:, s] = x0.reshape(num_nodes) Z_0.append(z_0) q = Q[s, :].reshape((1, num_traits)) x0s.append(x0) qs.append(q) k_ij = parameters[s * num_parameters_i:(s + 1) * num_parameters_i] # Create K from individual k_{ij}. K = np.zeros(Adj_flatten.shape) K[Adj_flatten] = k_ij K = K.reshape((num_nodes, num_nodes)) np.fill_diagonal(K, -np.sum(K, axis=0)) # Store K. Ks.append(K) # Perform eigen-decomposition to compute matrix exponential. w, V = scipy.linalg.eig(K, right=True) U = scipy.linalg.inv(V) wt = w * t exp_wt = np.exp(wt) xt = Expm(V, exp_wt, U).dot(x0) inside_norm += xt.dot(q) # Store the transpose of these matrices for later use. eigenvalues.append(w) eigenvectors.append(V.T) eigenvectors_inverse.append(U.T) exponential_wt.append(exp_wt) xts.append(xt) # Pre-build X matrix. with warnings.catch_warnings(): warnings.simplefilter( 'ignore', RuntimeWarning) # We don't care about 0/0 on the diagonal. X = np.subtract.outer(exp_wt, exp_wt) / (np.subtract.outer(wt, wt) + 1e-10) np.fill_diagonal(X, exp_wt) x_matrix.append(X) inside_norm -= Y_desired # Compute the trait mismatch cost depending on mode. derivative_outer_norm = None # Holds the derivative of inside_norm (except the multiplication by (x0 * q)^T). if mode == ABSOLUTE_AT_LEAST: derivative_outer_norm = -inside_norm + margin value = np.sum(np.maximum(derivative_outer_norm, 0)) derivative_outer_norm = -(derivative_outer_norm > 0).astype( float) # Keep only 1s for when it's larger than margin. elif mode == ABSOLUTE_EXACT: abs_inside_norm = np.abs(inside_norm) index_zeros = abs_inside_norm < 1e-10 value = np.sum(np.abs(inside_norm)) with warnings.catch_warnings(): warnings.simplefilter('ignore', RuntimeWarning) # We don't care about 0/0. derivative_outer_norm = inside_norm / abs_inside_norm # Keep only 1s for when it's larger than 0 and -1s for when it's lower. derivative_outer_norm[index_zeros] = 0 # Make sure we set 0/0 to 0. elif mode == QUADRATIC_AT_LEAST: derivative_outer_norm = -inside_norm + margin value = np.sum(np.square(np.maximum(derivative_outer_norm, 0))) index_negatives = derivative_outer_norm < 0 derivative_outer_norm *= -2.0 derivative_outer_norm[ index_negatives] = 0 # Don't propagate gradient on negative values. elif mode == QUADRATIC_EXACT: value = np.sum(np.square(inside_norm)) derivative_outer_norm = 2.0 * inside_norm # compute cost to minimize time (if desired) value += alpha * (t**2) # Calculate gradient w.r.t. the transition matrix for each species for s in range(num_species): # Build gradient w.r.t. inside_norm of cost. top_grad = np.dot(derivative_outer_norm, np.dot(x0s[s], qs[s]).T) # Build gradient w.r.t. Exp(K * t). middle_grad = eigenvectors_inverse[s].dot( eigenvectors[s].dot(top_grad).dot(eigenvectors_inverse[s]) * x_matrix[s]).dot(eigenvectors[s]) # Build gradient w.r.t. K bottom_grad = middle_grad * t # Finally, propagate gradient to individual k_ij. grad = bottom_grad - np.diag(bottom_grad) grad = grad.flatten()[Adj_flatten] # Reshape. grad_all[s * num_parameters_i:(s + 1) * num_parameters_i] += np.array( np.real(grad)) # Build gradient w.r.t. t (if desired) if specified_time is None: grad_all[-1] += np.real(np.sum(Ks[s] * middle_grad)) # Gradient of alpha * t^2 w.r.t. t if specified_time is None: grad_all[-1] += 2.0 * t * alpha # Forcing the steady state. # We add a cost for keeping X(t) and X(t + nu) the same. We use the quadratic norm for this sub-cost. # The larger beta and the larger nu, the closer to steady state. if beta > 0.0: for s in range(num_species): # Compute exp of the eigenvalues of K * (t + nu). wtdt = eigenvalues[s] * (t + nu) exp_wtdt = np.exp(wtdt) # Compute x_s(t) - x_s(t + nu) for that species. # Note that since we store V.T and U.T, we do (U.T * D * V.T).T == V * D * U inside_norm = xts[s] - Expm(eigenvectors_inverse[s], exp_wtdt, eigenvectors[s]).T.dot(x0s[s]) # Increment value. value += beta * np.sum(np.square(inside_norm)) # Compute gradient on the first part of the cost: e^{Kt} x0 (we use the same chain rule as before). top_grad = 2.0 * beta * np.dot(inside_norm, x0s[s].T) store_inner_product = eigenvectors[s].dot(top_grad).dot( eigenvectors_inverse[s]) # Store to re-use. middle_grad = eigenvectors_inverse[s].dot( store_inner_product * x_matrix[s]).dot(eigenvectors[s]) bottom_grad = middle_grad * t grad = bottom_grad - np.diag(bottom_grad) grad = grad.flatten()[Adj_flatten] # Reshape. grad_all[s * num_parameters_i:(s + 1) * num_parameters_i] += np.array(np.real(grad)) if specified_time is None: grad_all[-1] += np.real(np.sum(Ks[s] * middle_grad)) # Compute gradient on the second part of the cost: e^{K(t + nu)} x0 (we use the same chain rule as before). # Compute X for e^{K(t + nu)}. with warnings.catch_warnings(): warnings.simplefilter( 'ignore', RuntimeWarning) # We don't care about 0/0 on the diagonal. X = np.subtract.outer(exp_wtdt, exp_wtdt) / ( np.subtract.outer(wtdt, wtdt) + 1e-10) np.fill_diagonal(X, exp_wtdt) # top_grad = 2.0 * beta * np.dot(inside_norm, x0s[s].T) [same as before but needs to be negated]. middle_grad = -eigenvectors_inverse[s].dot( store_inner_product * X).dot(eigenvectors[s]) bottom_grad = middle_grad * (t + nu) grad = bottom_grad - np.diag(bottom_grad) grad = grad.flatten()[Adj_flatten] # Reshape. grad_all[s * num_parameters_i:(s + 1) * num_parameters_i] += np.array(np.real(grad)) if specified_time is None: grad_all[-1] += np.real(np.sum(Ks[s] * middle_grad)) # Minimize variance if gamma > 0.0: # Compute the variance cost X_t = np.squeeze(np.asarray(xts)).T # convert the list to an array var_Y = np.dot(np.multiply(X_t, X_t), var_Q) # compute Var(Y) value += gamma * np.sum( np.square(var_Y) ) # add the square of the Frobenious norm of Var(Y) to the cost # derivative_outer_norm = 2.0 * gamma * var_Y # Calculate gradient of third part of the cost w.r.t. the transition matrix for each species for s in range(num_species): # Build gradient w.r.t. inside_norm of variance. # top_grad = 2.0 * np.dot(derivative_outer_norm, np.dot(np.multiply(Z_0[s], X_t), var_Q).T) top_grad = 4 * gamma * np.dot( np.multiply(np.dot(var_Y, var_Q.T), X_t), Z_0[s].T) # Build gradient w.r.t. Exp(K * t). middle_grad = eigenvectors_inverse[s].dot( eigenvectors[s].dot(top_grad).dot(eigenvectors_inverse[s]) * x_matrix[s]).dot(eigenvectors[s]) # Build gradient w.r.t. K bottom_grad = middle_grad * t # Finally, propagate gradient to individual k_ij. grad = bottom_grad - np.diag(bottom_grad) grad = grad.flatten()[Adj_flatten] # Reshape. grad_all[s * num_parameters_i:(s + 1) * num_parameters_i] += np.array(np.real(grad)) # Build gradient w.r.t. t (if desired) if specified_time is None: grad_all[-1] += np.real(np.sum(Ks[s] * middle_grad)) """ # BEGIN OLD CODE grad_xts_t = np.zeros(np.shape(X_t)) for s in range(num_species): # Compute gradients of variance cost w.r.t. each transition rate wt = eigenvalues[s].real * t exp_wt = np.exp(wt) mat_1 = np.diag(exp_wt) * t temp_mat_2 = np.tile(exp_wt, [num_nodes, 1]) temp_mat_3 = np.tile(eigenvalues[s].real, [num_nodes, 1]) mat_2 = temp_mat_2.T - temp_mat_2 mat_3 = (temp_mat_3.T - temp_mat_3) np.fill_diagonal(mat_3, np.ones(num_nodes)) temp_idx = mat_3[mat_3 == 0] if temp_idx.size: flag = 1 mat_3 = 1 / mat_3 np.fill_diagonal(mat_3, np.zeros(num_nodes)) grad_norm_varY_K = np.zeros((num_nodes, num_nodes)) for i in range(num_nodes): for j in range(num_nodes): if Adj[i][j]: G_ij = np.outer(eigenvectors_inverse[s][i].real, eigenvectors[s].T[j].real) V_ij = np.multiply(G_ij, (mat_1 + np.multiply(mat_2, mat_3))) grad_xts_K_ij = np.dot(np.dot(np.dot(eigenvectors[s].T.real, V_ij), eigenvectors_inverse[s].T.real), Z_0[s]) grad_varY_K_ij = 2 * np.dot(np.multiply(grad_xts_K_ij, X_t), var_Q) grad_norm_varY_K[i][j] = 2 * gamma * np.trace(np.dot(var_Y.T, grad_varY_K_ij)).real grad_norm_varY_K = grad_norm_varY_K.flatten()[Adj_flatten] # Reshape. grad_all[s * num_parameters_i:(s + 1) * num_parameters_i] += np.array(np.real(grad_norm_varY_K)) # Compute the gradient each species' distribution of w.r.t. time if specified_time is None: grad_xts_t += np.dot(np.multiply(Expm(eigenvectors_inverse[s].real, exp_wt, eigenvectors[s].real).T, Ks[s]), Z_0[s]) # Compute gradients of variance cost w.r.t. time if specified_time is None: grad_varY_t = 2 * np.dot(np.multiply(grad_xts_t, X_t), var_Q) grad_all[-1] += 2 * gamma * np.trace(np.dot(var_Y.T, grad_varY_t)) # END OLD CODE """ return [value, grad_all]
def _inicializa_vetores(self): """Cria os 'vetores' e 'quadrivetores' votação agregados por partido. Aproveita para calcular o tamanho dos partidos, presença dos deputados, etc. O 'vetor' usa um número entre -1 (não) e 1 (sim) para representar a posição global do partido em cada votação, sendo o vetor em si um de dimensão N formado pelas N votações. O 'quadrivetor' usa uma tupla de 4 inteiros para representar a posição do partido em cada votação, os inteiros são o número de deputados que votaram sim, não, abstenção e obstrução. O quadrivetor em si é um vetor com N destas tuplas.""" # Pegar votações no BD: votacoes = self._buscaVotacoes() # Criar dicionario com id dos partidos con = lite.connect(Analise.db) tabela_partidos = con.execute( 'select numero,nome from partidos').fetchall() idPartido = {} for tp in tabela_partidos: idPartido[tp[1]] = tp[0] self.vetores_votacao = numpy.zeros( (len(self.lista_partidos), self.num_votacoes)) self.quadrivet_vot = numpy.empty( (len(self.lista_partidos), self.num_votacoes), dtype=object) self.vetores_tamanho = numpy.zeros( (len(self.lista_partidos), self.num_votacoes)) self.vetores_presenca = numpy.zeros( (len(self.lista_partidos), self.num_votacoes)) self.tamanho_partidos = [0] * len(self.lista_partidos) ip = -1 for p in self.lista_partidos: ip += 1 num_deputados = set( ) # Número de deputados diferentes de um partido que apareceram em pelo menos uma votação no período. iv = -1 for v in votacoes: iv += 1 nsim = numpy.where((numpy.array(eval(v[3])) / 100000) == idPartido[p])[0].size nnao = numpy.where((numpy.array(eval(v[4])) / 100000) == idPartido[p])[0].size nabs = numpy.where((numpy.array(eval(v[5])) / 100000) == idPartido[p])[0].size nobs = numpy.where((numpy.array(eval(v[6])) / 100000) == idPartido[p])[0].size ntot = nsim + nnao + nabs + nobs self.quadrivet_vot[ip][iv] = (nsim, nnao, nabs, nobs) if ntot != 0: self.vetores_votacao[ip][iv] = (float(nsim) - float(nnao)) / float(ntot) else: self.vetores_votacao[ip][iv] = 0 # Contar deputados presentes: deps_presentes_list = [ list( numpy.array(eval(v[3]))[numpy.where( numpy.array(eval(v[3])) / 100000 == idPartido[p])]) + list( numpy.array(eval(v[4]))[numpy.where( numpy.array(eval(v[4])) / 100000 == idPartido[p])]) + list( numpy.array(eval(v[5]))[numpy.where( numpy.array(eval(v[5])) / 100000 == idPartido[p])]) + list( numpy.array(eval(v[6]))[numpy.where( numpy.array(eval(v[6])) / 100000 == idPartido[p])]) ] # deps_presentes_list = numpy.reshape(deps_presentes_list,(1,numpy.size(deps_presentes_list))) self.vetores_tamanho[ip][iv] = numpy.size(deps_presentes_list) for d in deps_presentes_list[0]: num_deputados.add( d ) # repetidos não entrarão duas vezes no set, permitindo calcular tamanho_partidos. self.tamanho_partidos[ip] = len(num_deputados) # Calcular vetores_presenca: ivv = -1 for v in votacoes: ivv += 1 self.vetores_presenca[ip][ivv] = self.vetores_tamanho[ip][ ivv] / self.tamanho_partidos[ip] return
font_size = 25 #weight_photon = gamma # the histogram of the data #E_s=4.1e5 #gg = 100. eta_list = np.logspace(-5, 1, 100) #chi_min = np.logspace(-19,-7,100) chi_min = np.logspace(np.log10(5e-18), np.log10(5e-7), 100) print(chi_min) f_qed = open('ksi_sokolov.qed', 'w') f_qed.write('100\t 100\t -5\t 1\n') # python will convert \n to os.linesep for i in range(np.size(eta_list)): eta = eta_list[i] # bin_chi = np.logspace(np.log10(1e-8*eta),np.log10(0.499999999*eta),2000) # grid_chi = np.logspace(np.log10(1e-8*eta),np.log10(0.499999999*eta),2001) chi_min_i = chi_min[i] bin_chi = np.logspace(np.log10(chi_min_i), np.log10(0.499999999 * eta), 2000) grid_chi = np.logspace(np.log10(chi_min_i), np.log10(0.499999999 * eta), 2001) chi = bin_chi y = 4 * chi / (3 * eta * (eta - 2 * chi)) F_chi = np.zeros_like(chi) for j in range(np.size(chi)): result = integrate.quad(lambda x: kv(5. / 3., x), y[j], 1e3 * y[j]) F_chi[j] = 4 * chi[j]**2 / eta**2 * y[j] * kv( 2. / 3., y[j]) + (1 - 2 * chi[j] / eta) * y[j] * result[0]
import numpy as np horizontal = 10*[0.0] + 5*[1.0] + 10*[0.0] vertical = 5*[0.0, 0.0, 1.0, 0.0, 0.0] leftdiag = [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0] rightdiag = [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0] horizontal_2d = np.reshape(horizontal,(-1,int(np.size(horizontal)**(1/2)))) vertical_2d = np.reshape(vertical,(-1,int(np.size(vertical)**(1/2)))) leftdiag_2d = np.reshape(leftdiag,(-1,int(np.size(leftdiag)**(1/2)))) rightdiag_2d = np.reshape(rightdiag,(-1,int(np.size(rightdiag)**(1/2))))
def getCost(X, y, weights): m = np.size(X,0) hx = X.dot(weights) cost = (1/(2*m)) * np.sum((hx[:,0] - y)**2) return cost
def cost_without_grad(parameters, Y_desired, A, X_init, Q, var_Q, alpha=1.0, specified_time=None, beta=5.0, gamma=1.0, nu=1.0, mode=QUADRATIC_EXACT, margin=None): # Sanity checks.f assert alpha >= 0.0 and beta >= 0.0 assert (alpha == 0.0) == (specified_time is not None) assert (beta == 0.0) == (nu is None) assert (mode in (QUADRATIC_EXACT, ABSOLUTE_EXACT)) == (margin is None) # Prepare variable depending on whether t part of the parameters. num_nodes = A.shape[0] num_species = X_init.shape[1] num_traits = Q.shape[1] if specified_time is None: t = parameters[-1] num_parameters_i = int((np.size(parameters) - 1) / num_species) grad_all = np.zeros(np.size(parameters)) else: t = specified_time num_parameters_i = int(np.size(parameters) / num_species) grad_all = np.zeros(np.size(parameters)) # Reshape adjacency matrix to make sure. Adj = A.astype(float).reshape((num_nodes, num_nodes)) Adj_flatten = Adj.flatten().astype(bool) # Flatten boolean version. # Loop through the species to compute the cost value. # At the same time, prepare the different matrices. Ks = [] # K_s Z_0 = [] # Z^{(s)}(0) eigenvalues = [] # w eigenvectors = [] # V.T eigenvectors_inverse = [] # U.T exponential_wt = [] # exp(eigenvalues * t). x_matrix = [] # Pre-computed X matrices. x0s = [] # Avoids reshaping. qs = [] # Avoids reshaping. xts = [] # Keeps x_s(t). inside_norm = np.zeros( (num_nodes, num_traits)) # Will hold the value prior to using the norm. for s in range(num_species): x0 = X_init[:, s].reshape((num_nodes, 1)) z_0 = np.zeros(X_init.shape) z_0[:, s] = x0.reshape(num_nodes) Z_0.append(z_0) q = Q[s, :].reshape((1, num_traits)) x0s.append(x0) qs.append(q) k_ij = parameters[s * num_parameters_i:(s + 1) * num_parameters_i] # Create K from individual k_{ij}. K = np.zeros(Adj_flatten.shape) K[Adj_flatten] = k_ij K = K.reshape((num_nodes, num_nodes)) np.fill_diagonal(K, -np.sum(K, axis=0)) # Store K. Ks.append(K) # Perform eigen-decomposition to compute matrix exponential. w, V = scipy.linalg.eig(K, right=True) U = scipy.linalg.inv(V) wt = w * t exp_wt = np.exp(wt) xt = Expm(V, exp_wt, U).dot(x0) inside_norm += xt.dot(q) # Store the transpose of these matrices for later use. eigenvalues.append(w) eigenvectors.append(V.T) eigenvectors_inverse.append(U.T) exponential_wt.append(exp_wt) xts.append(xt) # Pre-build X matrix. with warnings.catch_warnings(): warnings.simplefilter( 'ignore', RuntimeWarning) # We don't care about 0/0 on the diagonal. X = np.subtract.outer(exp_wt, exp_wt) / (np.subtract.outer(wt, wt) + 1e-10) np.fill_diagonal(X, exp_wt) x_matrix.append(X) inside_norm -= Y_desired # Compute the final cost value depending on mode. derivative_outer_norm = None # Holds the derivative of inside_norm (except the multiplication by (x0 * q)^T). if mode == ABSOLUTE_AT_LEAST: derivative_outer_norm = -inside_norm + margin value = np.sum(np.maximum(derivative_outer_norm, 0)) derivative_outer_norm = -(derivative_outer_norm > 0).astype( float) # Keep only 1s for when it's larger than margin. elif mode == ABSOLUTE_EXACT: abs_inside_norm = np.abs(inside_norm) index_zeros = abs_inside_norm < 1e-10 value = np.sum(np.abs(inside_norm)) with warnings.catch_warnings(): warnings.simplefilter('ignore', RuntimeWarning) # We don't care about 0/0. derivative_outer_norm = inside_norm / abs_inside_norm # Keep only 1s for when it's larger than 0 and -1s for when it's lower. derivative_outer_norm[index_zeros] = 0 # Make sure we set 0/0 to 0. elif mode == QUADRATIC_AT_LEAST: derivative_outer_norm = -inside_norm + margin value = np.sum(np.square(np.maximum(derivative_outer_norm, 0))) index_negatives = derivative_outer_norm < 0 derivative_outer_norm *= -2.0 derivative_outer_norm[ index_negatives] = 0 # Don't propagate gradient on negative values. elif mode == QUADRATIC_EXACT: value = np.sum(np.square(inside_norm)) derivative_outer_norm = 2.0 * inside_norm value += alpha * (t**2) # Forcing the steady state. # We add a cost for keeping X(t) and X(t + nu) the same. We use the quadratic norm for this sub-cost. # The larger beta and the larger nu, the closer to steady state. if beta > 0.0: for s in range(num_species): # Compute exp of the eigenvalues of K * (t + nu). wtdt = eigenvalues[s] * (t + nu) exp_wtdt = np.exp(wtdt) # Compute x_s(t) - x_s(t + nu) for that species. # Note that since we store V.T and U.T, we do (U.T * D * V.T).T == V * D * U inside_norm = xts[s] - Expm(eigenvectors_inverse[s], exp_wtdt, eigenvectors[s]).T.dot(x0s[s]) # Increment value. value += beta * np.sum(np.square(inside_norm)) # Minimize the variance of trait distribution if gamma > 0.0: # Compute the cost X_t = np.squeeze(np.asarray(xts)).T # convert the list to an array var_Y = np.dot(np.multiply(X_t, X_t), var_Q) # compute Var(Y) value += gamma * np.sum( np.square(var_Y) ) # add the square of the Frobenious norm of Var(Y) to the cost return value
#Need to make it so that it runs over a certain array of sizes: #Length of the edge of a box length_variable = np.array([10, 5, 2.5, 1.25, 0.625], dtype=np.int64) #Total Number of Sub regions array_split_size_sub = [1, 4, 16, 64, 256] for n in length_variable: array_split_size = length_variable[n] * 25.6 #Value for blocks array_split_size_sub = array_split_size_sub[n] array_split_size_sub_tot = array_split_size // array_split_size_sub arr_reshape = blockshaped(arr, array_split_size, array_split_size) #Callable Sizing Value array_size = np.size(arr_reshape[0]) #Plane Fitting Process #Creating x,y coordintes for blocks of data xvalues = np.arange(0, data_length) yvalues = np.arange(0, data_length) xx, yy = np.meshgrid(xvalues, yvalues) xx = blockshaped(xx, array_split_size, array_split_size) yy = blockshaped(yy, array_split_size, array_split_size) #Importing Plane Fit Script here. from plane_fit import plane_fit #Making z of zeros for plane fit script
p = np.array([a, r, b]) dt = 0.01 # Paso de tiempo para la integracion del modelo de Lorenz x0 = np.array([ 8.0, 0.0, 30.0 ]) # Condiciones iniciales para el spin-up del nature run (no cambiar) numtrans = 600 # Tiempo de spin-up para generar el nature run (no cambiar) #------------------------------------------------------------ # Configuracion del sistema de asimilacion #------------------------------------------------------------ dx0 = 1.0 * np.array([5.0, 5.0, 5.0]) # Error inicial de la estimacion. R0 = 8.0 # Varianza del error de las observaciones. nvars = 3 EnsSize = 30 #Numero de miembros en el ensamble. nobs = np.size(forward_operator(np.array([0, 0, 0]))) #Definimos una matriz de error de las observaciones R = R0 * np.identity(nobs) #En esta formulacion asumimos que los errores #en diferentes observaciones son todos iguales y P0 = 10.0 * np.array([[0.6, 0.5, 0.0], [0.5, 0.6, 0.0], [0.0, 0.0, 1.0]]) lam = 40.0 x = np.copy(x0) for i in range(numtrans): x = model.forward_model(x, p, dt) # Integramos la simulacion verdad # El resultado es almacenado en un array de numpy "state" con dimension (numstep,3)
def function(self, lamb, Av=1, Rv=2.74, Alambda=True, draine_extend=False, **kwargs): """ Gordon03_SMCBar extinction law Parameters ---------- lamb: float or ndarray(dtype=float) wavelength [in Angstroms] at which evaluate the law. Av: float desired A(V) (default 1.0) Rv: float desired R(V) (default 2.74) Alambda: bool if set returns +2.5*1./log(10.)*tau, tau otherwise Returns ------- r: float or ndarray(dtype=float) attenuation as a function of wavelength depending on Alambda option +2.5*1./log(10.)*tau, or tau """ # ensure the units are in angstrom _lamb = units.Quantity(lamb, units.angstrom).value #_lamb = val_in_unit('lamb', lamb, 'angstrom').magnitude if isinstance(_lamb, float) or isinstance(_lamb, np.float_): _lamb = np.asarray([lamb]) else: _lamb = lamb[:] # set Rv explicitly to the fixed value Rv = self.Rv c1 = -4.959 / Rv c2 = 2.264 / Rv c3 = 0.389 / Rv c4 = 0.461 / Rv x0 = 4.6 gamma = 1.0 x = 1.e4 / _lamb k = np.zeros(np.size(x)) # UV part xcutuv = 10000.0 / 2700. xspluv = 10000.0 / np.array([2700., 2600.]) ind = np.where(x >= xcutuv) if np.size(ind) > 0: k[ind] = 1.0 + c1 + (c2 * x[ind]) + c3 * ((x[ind]) ** 2) / \ ( ((x[ind]) ** 2 - (x0 ** 2)) ** 2 + (gamma ** 2) * ((x[ind]) ** 2 )) yspluv = 1.0 + c1 + (c2 * xspluv) + c3 * ((xspluv) ** 2) / \ ( ((xspluv) ** 2 - (x0 ** 2)) ** 2 + (gamma ** 2) * ((xspluv) ** 2 )) # FUV portion ind = np.where(x >= 5.9) if np.size(ind) > 0: if draine_extend: dfname = libdir+'SMC_Rv2.74_norm.txt' l_draine, k_draine = np.loadtxt(dfname,usecols=(0,1),unpack=True) dind = np.where((1./l_draine) >= 5.9) k[ind] = interp(x[ind],1./l_draine[dind][::-1], k_draine[dind][::-1]) else: k[ind] += c4 * (0.5392 * ((x[ind] - 5.9) ** 2) + 0.05644 * ((x[ind] - 5.9) ** 3)) # Opt/NIR part ind = np.where(x < xcutuv) if np.size(ind) > 0: xsplopir = np.zeros(9) xsplopir[0] = 0.0 xsplopir[1: 10] = 1.0 / np.array([2.198, 1.65, 1.25, 0.81, 0.65, 0.55, 0.44, 0.37]) # Values directly from Gordon et al. (2003) #ysplopir = np.array([0.0,0.016,0.169,0.131,0.567,0.801, # 1.00,1.374,1.672]) # K & J values adjusted to provide a smooth, # non-negative cubic spline interpolation ysplopir = np.array([0.0, 0.11, 0.169, 0.25, 0.567, 0.801, 1.00, 1.374, 1.672]) tck = interpolate.splrep(np.hstack([xsplopir, xspluv]), np.hstack([ysplopir, yspluv]), k=3) k[ind] = interpolate.splev(x[ind], tck) if (Alambda): return(k * Av) else: return(k * Av * (np.log(10.) * 0.4 ))
# Create barrier certificates to avoid collision si_barrier_cert = create_single_integrator_barrier_certificate(N) # define x initially x = r.get_poses() #print(x) r.step() # While the number of robots at the required poses is less # than N... robot1_goal = np.array([[0.0], [0.0], [0.0]]) robot2_goal = np.array([[-0.9], [0.9], [0.0]]) goal_points = np.concatenate((robot1_goal, robot2_goal), axis=1) while(np.size(at_pose(x, goal_points, rotation_error=5)) != N): # Get poses of agents x = r.get_poses() x_si = x[:2, :] # Create single-integrator control inputs dxi = single_integrator_position_controller(x_si, goal_points[:2, :], magnitude_limit=0.08) # Create safe control inputs (i.e., no collisions) dxi = si_barrier_cert(dxi, x_si) # Set the velocities by mapping the single-integrator inputs to unciycle inputs r.set_velocities(np.arange(N), single_integrator_to_unicycle2(dxi, x)) # Iterate the simulation r.step()
def function(self, lamb, Av=1., Rv=3.1, Alambda=True, **kwargs): """ Cardelli89 extinction Law Parameters ---------- lamb: float or ndarray(dtype=float) wavelength [in Angstroms] at which evaluate the law. Av: float desired A(V) (default: 1.0) Rv: float desired R(V) (default: 3.1) Alambda: bool if set returns +2.5*1./log(10.)*tau, tau otherwise Returns ------- r: float or ndarray(dtype=float) attenuation as a function of wavelength depending on Alambda option +2.5*1./log(10.)*tau, or tau """ # ensure the units are in angstrom _lamb = units.Quantity(lamb, units.angstrom).value #_lamb = val_in_unit('lamb', lamb, 'angstrom').magnitude if isinstance(_lamb, float) or isinstance(_lamb, np.float_): _lamb = np.asarray([lamb]) else: _lamb = lamb[:] # init variables x = 1.e4 / _lamb # wavenumber in um^-1 a = np.zeros(np.size(x)) b = np.zeros(np.size(x)) # Infrared (Eq 2a,2b) ind = np.where((x >= 0.3) & (x < 1.1)) a[ind] = 0.574 * x[ind] ** 1.61 b[ind] = -0.527 * x[ind] ** 1.61 # Optical & Near IR # Eq 3a, 3b ind = np.where((x >= 1.1) & (x < 3.3)) y = x[ind] - 1.82 a[ind] = 1. + 0.17699 * y - 0.50447 * y ** 2 - 0.02427 * y ** 3 + \ 0.72085 * y ** 4 + 0.01979 * y ** 5 - 0.77530 * y ** 6 + \ 0.32999 * y ** 7 b[ind] = 1.41338 * y + 2.28305 * y ** 2 + 1.07233 * y ** 3 - \ 5.38434 * y ** 4 - 0.62251 * y ** 5 + 5.30260 * y ** 6 - \ 2.09002 * y ** 7 # UV # Eq 4a, 4b ind = np.where((x >= 3.3) & (x <= 8.0)) a[ind] = 1.752 - 0.316 * x[ind] - 0.104 / ((x[ind] - 4.67) ** 2 + 0.341) b[ind] = -3.090 + 1.825 * x[ind] + 1.206 / ((x[ind] - 4.62) ** 2 + 0.263) ind = np.where((x >= 5.9) & (x <= 8.0)) y = x[ind] - 5.9 Fa = -0.04473 * y ** 2 - 0.009779 * y ** 3 Fb = 0.21300 * y ** 2 + 0.120700 * y ** 3 a[ind] = a[ind] + Fa b[ind] = b[ind] + Fb # Far UV # Eq 5a, 5b ind = np.where((x > 8.0) & (x <= 10.0)) # Fa = Fb = 0 y = x[ind] - 8. a[ind] = -1.073 - 0.628 * y + 0.137 * y ** 2 - 0.070 * y ** 3 b[ind] = 13.670 + 4.257 * y - 0.420 * y ** 2 + 0.374 * y ** 3 # Case of -values x out of range [0.289,10.0] ind = np.where((x > 10.0) | (x < 0.3)) a[ind] = 0.0 b[ind] = 0.0 # Return Extinction vector # Eq 1 if (Alambda): return( ( a + b / Rv ) * Av) else: # return( 1./(2.5 * 1. / np.log(10.)) * ( a + b / Rv ) * Av) return( 0.4 * np.log(10.) * ( a + b / Rv ) * Av)
def make_full_table(caption, label, source_table, stacking=np.array([]), units=None): # Vorgeplänkel Output = """\\begin{table} \\centering \\caption{""" + caption + """} \\label{""" + label + """} \\sisetup{parse-numbers=false} \\begin{tabular}{\n""" # Kerngeschäft : source_table einlesen und verarbeiten, dh. Vor und Nachkommastellen rausfinden counter_columns = 0 counter_lines = 0 with open(source_table, 'r') as f: Text = f.read() for buchstabe in Text: if (buchstabe == '&'): counter_columns += 1 elif (buchstabe == '\\'): counter_lines += 1 NumberOfLines = counter_lines / 2 NumberOfColumns = counter_columns / counter_lines * 2 + 1 counter_digits_preDot = np.zeros((NumberOfLines, NumberOfColumns), dtype=np.int) counter_digits_postDot = np.zeros((NumberOfLines, NumberOfColumns), dtype=np.int) dot_reached = False counter_columns = 0 counter_lines = 0 with open(source_table, 'r') as f: Text = f.read() # 'Vor und Nachkommastellen rausfinden' beginnt hier for buchstabe in Text: if (buchstabe == '&'): counter_columns += 1 dot_reached = False elif (buchstabe == '.'): dot_reached = True elif (buchstabe == '\\'): counter_lines += 1 counter_columns = counter_columns % (NumberOfColumns - 1) dot_reached = False elif (buchstabe != ' ') & (buchstabe != '\n'): if (counter_lines / 2 <= (NumberOfLines - 1)): if dot_reached == False: counter_digits_preDot[counter_lines / 2][counter_columns] += 1 else: counter_digits_postDot[counter_lines / 2][counter_columns] += 1 # jetzt ermittle maximale Anzahl an Stellen und speichere sie in MaxDigitsPreDot und MaxDigitsPostDot MaxDigitsPreDot = [] counter_digits_preDot_np = np.array(counter_digits_preDot) for x in counter_digits_preDot_np.T: MaxDigitsPreDot.append(max(x)) MaxDigitsPostDot = [] counter_digits_postDot_np = np.array(counter_digits_postDot) for x in counter_digits_postDot_np.T: MaxDigitsPostDot.append(max(x)) # --------------------Ende der Stellensuche # Die Liste stacking in ein angepasstes Array umwandeln mit den tatsächlich betroffenen Spalten stacking_list = np.array(stacking) i = 0 for x in stacking_list: stacking_list[i] += i i += 1 # Schreiben der Tabellenformatierung if np.size(stacking) == 0: for digits_preDot, digits_postDot in zip(MaxDigitsPreDot, MaxDigitsPostDot): Output += '\tS[table-format=' + str(digits_preDot) + '.' + str(digits_postDot) + ']\n' else: # es wurden fehlerbehaftete Werte übergeben, daher muss +- zwischen die entsprechenden Spalten i = 0.0 for digits_preDot, digits_postDot in zip(MaxDigitsPreDot, MaxDigitsPostDot): if i in stacking_list: Output += '\tS[table-format=' + str(digits_preDot) + '.' + str(digits_postDot) + ']\n' Output += '\t@{${}\\pm{}$}\n' elif i - 1 in stacking_list: Output += '\tS[table-format=' + str(digits_preDot) + '.' + str(digits_postDot) + ', table-number-alignment = left]\n' # wir wollen hier linksbündige Zahlen else: Output += '\tS[table-format=' + str(digits_preDot) + '.' + str(digits_postDot) + ']\n' i += 1 # Zwischengeplänkel Output += '\t}\n\t\\toprule\n\t' # Einheitenzeile i = 0 stacking_list = np.array(stacking) for Spaltenkopf in units: if i in stacking_list: Output += '\\multicolumn{2}{c}' Output += '{' + str(Spaltenkopf) + '}\t\t' i += 1 if i == np.size(units): Output += '\\\\ \n\t' elif i % 2 == 0: Output += '& \n\t' else: Output += '& ' # Schlussgeplänkel Output += """\\midrule \\input{""" + source_table + """} \\bottomrule \\end{tabular} \\end{table}""" return Output
def date2dec(calendar = 'standard', units=None, excelerr = True, yr=1, mo=1, dy=1, hr=0, mi=0, sc=0, ascii=None, en=None, eng=None): """ Convert scalar and array_like with calendar dates into decimal dates. Supported calendar formats are standard, gregorian, julian, proleptic_gregorian, excel1900, excel1904, 365_day, noleap, 366_day, all_leap, 360_day, decimal, or decimal360. Input is year, month day, hour, minute, second or a combination of them. Input as date string is possible. Output is decimal date with day as unit. Parameters ---------- yr : array_like, optional years (default: 1) mo : array_like, optional month (default: 1) dy : array_like, optional days (default: 1) hr : array_like, optional hours (default: 0) mi : array_like, optional minutes (default: 0) sc : array_like, optional seconds (default: 0) ascii : array_like, optional strings of the format 'dd.mm.yyyy hh:mm:ss'. Missing hour, minutes and/or seconds are set to their default values (0). `ascii` overwrites all other keywords. `ascii` and `eng` are mutually exclusive. en : array_like, optional strings of the format 'yyyy-mm-dd hh:mm:ss'. Missing hour, minutes and/or seconds are set to their default values (0). `en` overwrites all other keywords. `en` and `ascii` are mutually exclusive. eng : array_like, optional Same as en: obsolete. calendar : str, optional Calendar of output dates (default: 'standard'). Possible values are: 'standard', 'gregorian' = julian calendar from 01.01.-4712 12:00:00 (BC) until 05.03.1583 00:00:00 and gregorian calendar from 15.03.1583 00:00:00 until now. Missing 10 days do not exsist. 'julian' = julian calendar from 01.01.-4712 12:00:00 (BC) until now. 'proleptic_gregorian' = gregorian calendar from 01.01.0001 00:00:00 until now. 'excel1900' = Excel dates with origin at 01.01.1900 00:00:00. 'excel1904' = Excel 1904 (Lotus) format. Same as excel1904 but with origin at 01.01.1904 00:00:00. '365_day', 'noleap' = 365 days format, i.e. common years only (no leap years) with origin at 01.01.0001 00:00:00. '366_day', 'all_leap' = 366 days format, i.e. leap years only (no common years) with origin at 01.01.0001 00:00:00. '360_day' = 360 days format, i.e. years with only 360 days (30 days per month) with origin at 01.01.0001 00:00:00. 'decimal' = decimal year instead of decimal days. 'decimal360' = decimal year with a year of 360 days, i.e. 12 month with 30 days each. units : str, optional User set units of output dates. Must be a string in the format 'days since yyyy-mm-dd hh:mm:ss'. Default values are set automatically depending on `calendar`. excelerr : bool, optional In Excel, the year 1900 is normally considered a leap year, which it was not. By default, this error is taken into account if `calendar=='excel1900'` (default: True). 1900 is not considered a leap year if `excelerr==False`. Returns ------- array_like array_like with decimal dates. The type of output will be the same as the input type. Notes ----- Most versions of `datetime` do not support negative years, i.e. Julian days < 1721423.5 = 01.01.0001 00:00:00. There is an issue in `netcdftime` version < 0.9.5 in proleptic_gregorian for dates before year 301: dec2date(date2dec(ascii='01.01.0300 00:00:00', calendar='proleptic_gregorian'), calendar='proleptic_gregorian') [300, 1, 2, 0, 0, 0] dec2date(date2dec(ascii='01.01.0301 00:00:00', calendar='proleptic_gregorian'), calendar='proleptic_gregorian') [301, 1, 1, 0, 0, 0] List input is only supported up to 2 dimensions. Requires `netcdftime.py` from module `netcdftime` available at: http://netcdf4-python.googlecode.com Examples -------- # Some implementations of datetime do not support negative years >>> import datetime >>> if datetime.MINYEAR > 0: ... print('The minimum year in your datetime implementation is ', datetime.MINYEAR) ... print('i.e. it does not support negative years (BC).') The minimum year in your datetime implementation is 1 i.e. it does not support negative years (BC). >>> if datetime.MINYEAR > 0: ... year = np.array([2000, 1810, 1630, 1510, 1271, 619, 2, 1]) ... else: ... year = np.array([2000, 1810, 1630, 1510, 1271, 619, -1579, -4712]) >>> month = np.array([1, 4, 7, 9, 3, 8, 8, 1]) >>> day = np.array([5, 24, 15, 20, 18, 27, 23, 1]) >>> hour = np.array([12, 16, 10, 14, 19, 11, 20, 12]) >>> minute = np.array([30, 15, 20, 35, 41, 8, 3, 0]) >>> second = np.array([15, 10, 40, 50, 34, 37, 41, 0]) >>> decimal = date2dec(calendar = 'standard', yr=year, mo=month, dy=day, hr=hour, mi=minute, sc=second) >>> nn = year.size >>> print('{:.14e} {:.14e} {:.14e} {:.14e}'.format(*decimal[:nn//2])) 2.45154902100694e+06 2.38226217719907e+06 2.31660093101852e+06 2.27284810821759e+06 >>> print('{:.14e} {:.14e}'.format(*decimal[nn//2:nn-2])) 2.18536732053241e+06 1.94738596431713e+06 >>> decimal = date2dec(calendar='standard', yr=year, mo=6, dy=15, hr=12, mi=minute, sc=second) >>> print('{:.14e} {:.14e} {:.14e} {:.14e}'.format(*decimal[:nn//2])) 2.45171102100694e+06 2.38231401053241e+06 2.31657101435185e+06 2.27275102488426e+06 >>> print('{:.14e} {:.14e}'.format(*decimal[nn//2:nn-2])) 2.18545602886574e+06 1.94731300598380e+06 # ascii input >>> if datetime.MINYEAR > 0: ... a = np.array(['05.01.2000 12:30:15', '24.04.1810 16:15:10', '15.07.1630 10:20:40', '20.09.1510 14:35:50', ... '18.03.1271 19:41:34', '27.08. 619 11:08:37', '23.08.0002 20:03:41', '01.01.0001 12:00:00']) ... else: ... a = np.array(['05.01.2000 12:30:15', '24.04.1810 16:15:10', '15.07.1630 10:20:40', '20.09.1510 14:35:50', ... '18.03.1271 19:41:34', '27.08. 619 11:08:37', '23.08.-1579 20:03:41', '01.01.-4712 12:00:00']) >>> decimal = date2dec(calendar='standard', ascii=a) >>> nn = a.size >>> print('{:.14e} {:.14e} {:.14e} {:.14e}'.format(*decimal[:nn//2])) 2.45154902100694e+06 2.38226217719907e+06 2.31660093101852e+06 2.27284810821759e+06 >>> print('{:.14e} {:.14e}'.format(*decimal[nn//2:nn-2])) 2.18536732053241e+06 1.94738596431713e+06 # calendar = 'julian' >>> decimal = date2dec(calendar='julian', ascii=a) >>> print('{:.14e} {:.14e} {:.14e} {:.14e}'.format(*decimal[:nn//2])) 2.45156202100694e+06 2.38227417719907e+06 2.31661093101852e+06 2.27284810821759e+06 >>> print('{:.14e} {:.14e}'.format(*decimal[nn//2:nn-2])) 2.18536732053241e+06 1.94738596431713e+06 # calendar = 'proleptic_gregorian' >>> decimal = date2dec(calendar='proleptic_gregorian', ascii=a) >>> print('{:.7f} {:.7f} {:.7f} {:.7f}'.format(*decimal[:nn//2])) 730123.5210069 660836.6771991 595175.4310185 551412.6082176 >>> print('{:.7f} {:.7f}'.format(*decimal[nn//2:nn-2])) 463934.8205324 225957.4643171 # calendar = 'excel1900' WITH excelerr=True -> 1900 considered as leap year >>> d = np.array(['05.01.2000 12:30:15', '27.05.1950 16:25:10', '13.08.1910 10:40:55', ... '01.03.1900 00:00:00', '29.02.1900 00:00:00', '28.02.1900 00:00:00', ... '01.01.1900 00:00:00']) >>> decimal = date2dec(calendar='excel1900', ascii=d) >>> nn = d.size >>> print('{:.7f} {:.7f} {:.7f}'.format(*decimal[:nn//2])) 36530.5210069 18410.6841435 3878.4450810 >>> print('{:.1f} {:.1f} {:.1f} {:.1f}'.format(*decimal[nn//2:])) 61.0 60.0 59.0 1.0 # calendar = 'excel1900' WITH excelerr = False -> 1900 is NO leap year >>> decimal = date2dec(calendar='excel1900', ascii=d, excelerr=False) >>> print('{:.7f} {:.7f} {:.7f}'.format(*decimal[:nn//2])) 36529.5210069 18409.6841435 3877.4450810 >>> print('{:.1f} {:.1f} {:.1f} {:.1f}'.format(*decimal[nn//2:])) 60.0 60.0 59.0 1.0 # calendar = 'excel1904' >>> decimal = date2dec(calendar='excel1904', ascii=d[:nn//2]) >>> print('{:.7f} {:.7f} {:.7f}'.format(*decimal[:nn//2])) 35069.5210069 16949.6841435 2417.4450810 # calendar = '365_day' >>> g = np.array(['18.08.1972 12:30:15', '25.10.0986 12:30:15', '28.11.0493 22:20:40', '01.01.0001 00:00:00']) >>> decimal = date2dec(calendar='365_day', ascii=g) >>> nn = g.size >>> print('{:.7f} {:.7f} {:.7f} {:.7f}'.format(*decimal[:nn])) 719644.5210069 359822.5210069 179911.9310185 0.0000000 # calendar = '366_day' >>> decimal = date2dec(calendar='366_day', ascii=g) >>> print('{:.7f} {:.7f} {:.7f} {:.7f}'.format(*decimal[:nn])) 721616.5210069 360808.5210069 180404.9310185 0.0000000 # 360_day does not work with netcdftime.py version equal or below 0.9.2 # calendar = '360_day' >>> decimal = date2dec(calendar='360_day', ascii=g) >>> print('{:.7f} {:.7f} {:.7f} {:.7f}'.format(*decimal[:nn])) 709787.5210069 354894.5210069 177447.9310185 0.0000000 >>> print('{:.7f}'.format(date2dec(yr=1992, mo=1, dy=26, hr=2, mi=0, sc=0, calendar='decimal'))) 1992.0685337 >>> print('{:.7f}'.format(date2dec(ascii='26.01.1992 02:00', calendar='decimal360'))) 1992.0696759 >>> print('{:.7f} {:.7f}'.format(*date2dec(ascii=['26.01.1992 02:00','26.01.1992 02:00'], calendar='decimal360'))) 1992.0696759 1992.0696759 >>> print('{:.7f} {:.7f}'.format(*date2dec(yr=[1992,1992], mo=1, dy=26, hr=2, mi=0, sc=0, calendar='decimal360'))) 1992.0696759 1992.0696759 >>> print('{:.7f} {:.7f}'.format(*date2dec(yr=np.array([1992,1992]), mo=1, dy=26, hr=2, mi=0, sc=0, calendar='decimal360'))) 1992.0696759 1992.0696759 >>> decimal = date2dec(ascii=[['26.01.1992 02:00','26.01.1992 02:00'], ... ['26.01.1992 02:00','26.01.1992 02:00'], ... ['26.01.1992 02:00','26.01.1992 02:00']], ... calendar='decimal360') >>> print('{:.7f} {:.7f}'.format(*decimal[0])) 1992.0696759 1992.0696759 >>> print('{:.7f} {:.7f}'.format(*decimal[2])) 1992.0696759 1992.0696759 >>> print((date2dec(ascii='01.03.2003 00:00:00') - date2dec(ascii='01.03.2003')) == 0.) True # en >>> decimal = date2dec(en='1992-01-26 02:00', calendar='decimal360') >>> print('{:.7f}'.format(decimal)) 1992.0696759 >>> decimal = date2dec(eng='1992-01-26 02:00', calendar='decimal360') >>> print('{:.7f}'.format(decimal)) 1992.0696759 History ------- Written Arndt Piayda, Jun 2010 Modified Matthias Cuntz, Feb 2012 - All input can be scalar, list or array, also a mix - Changed checks for easier extension - decimal, decimal360 Matthias Cuntz, Dec 2012 - change unit of proleptic_gregorian from 'days since 0001-01-01 00:00:00' to 'days since 0001-01-00 00:00:00' Matthias Cuntz, Feb 2013 - solved Excel leap year problem. Matthias Cuntz, Feb 2013 - ported to Python 3 Matthias Cuntz, Jul 2013 - ascii/eng without time defaults to 00:00:00 Matthias Cuntz, Oct 2013 - Excel starts at 1 not at 0 Matthias Cuntz, Oct 2013 - units bugs, e.g. 01.01.0001 was substracted if Julian calendar even with units Matthias Cuntz, Nov 2013 - removed remnant of time treatment before time check in eng keyword Matthias Cuntz, Jun 2015 - adapted to new netCDF4/netcdftime (>= v1.0) and datetime (>= Python v2.7.9) Matthias Cuntz, Oct 2015 - call date2num with list instead of single netCDF4.datetime objects Matthias Cuntz, Oct 2016 - netcdftime provided even with netCDF4 > 1.0.0; make mo for months always integer Matthias Cuntz, Nov 2016 - 00, 01, etc. for integers not accepted by Python3 Matthias Cuntz, May 2020 - numpy docstring format Matthias Cuntz, Jul 2020 - en for eng Matthias Cuntz, Jul 2020 - use proleptic_gregorian for Excel dates """ # # Checks calendars = ['standard', 'gregorian', 'julian', 'proleptic_gregorian', 'excel1900', 'excel1904', '365_day', 'noleap', '366_day', 'all_leap', '360_day', 'decimal', 'decimal360'] import netCDF4 as nt try: tst = nt.date2num tst = nt.datetime except: try: import netcdftime as nt if ((nt.__version__ <= '0.9.2') & (calendar == '360_day')): raise ValueError("date2dec error: Your version of netcdftime.py is equal" " or below 0.9.2. The 360_day calendar does not work with" " arrays here. Please download a newer one.") except: import cftime as nt # calendar = calendar.lower() if (calendar not in calendars): raise ValueError("date2dec error: Wrong calendar!" " Choose: "+''.join([i+' ' for i in calendars])) # obsolete eng if (eng is not None): if (en is not None): raise ValueError("date2dec error: 'eng' was succeeded by 'en'. Only one can be given.") else: en = eng # if ascii input is given by user, other input will be neglected # calculation of input size and shape if (ascii is not None) and (en is not None): raise ValueError("date2dec error: 'ascii' and 'en' mutually exclusive") if (ascii is not None): islist = type(ascii) != type(np.array(ascii)) isarr = np.ndim(ascii) if (islist & (isarr > 2)): raise ValueError("date2dec error: ascii input is list > 2D; Use array input") if isarr == 0: ascii = np.array([ascii]) else: ascii = np.array(ascii) insize = ascii.size outsize = insize outshape = ascii.shape asciifl = ascii.flatten() timeobj = np.zeros(insize, dtype=object) # slicing of ascii strings to implement in datetime object. missing times # will be set to 0. yr = np.zeros(insize, dtype=np.int) mo = np.zeros(insize, dtype=np.int) dy = np.zeros(insize, dtype=np.int) hr = np.zeros(insize, dtype=np.int) mi = np.zeros(insize, dtype=np.int) sc = np.zeros(insize, dtype=np.int) for i in range(insize): aa = asciifl[i].split('.') dy[i] = int(aa[0]) mo[i] = int(aa[1]) tail = aa[2].split() yr[i] = int(tail[0]) if len(tail) > 1: tim = tail[1].split(':') hr[i] = int(tim[0]) if len(tim) > 1: mi[i] = int(tim[1]) else: mi[i] = 0 if len(tim) > 2: sc[i] = int(tim[2]) else: sc[i] = 0 else: hr[i] = 0 mi[i] = 0 sc[i] = 0 if ((yr[i]==1900) & (mo[i]==2) & (dy[i]==29)): timeobj[i] = nt.datetime(yr[i], 3, 1, hr[i], mi[i], sc[i]) else: timeobj[i] = nt.datetime(yr[i], mo[i], dy[i], hr[i], mi[i], sc[i]) if (en is not None): islist = type(en) != type(np.array(en)) isarr = np.ndim(en) if isarr == 0: en = np.array([en]) else: en = np.array(en) if (islist & (isarr > 2)): raise ValueError("date2dec error: en input is list > 2D; Use array input") en = np.array(en) insize = en.size outsize = insize outshape = en.shape enfl = en.flatten() timeobj = np.zeros(insize, dtype=object) # slicing of en strings to implement in datetime object. missing times # will be set to 0. yr = np.zeros(insize, dtype=np.int) mo = np.zeros(insize, dtype=np.int) dy = np.zeros(insize, dtype=np.int) hr = np.zeros(insize, dtype=np.int) mi = np.zeros(insize, dtype=np.int) sc = np.zeros(insize, dtype=np.int) for i in range(insize): ee = enfl[i].split('-') yr[i] = int(ee[0]) mo[i] = int(ee[1]) tail = ee[2].split() dy[i] = int(tail[0]) if len(tail) > 1: tim = tail[1].split(':') hr[i] = int(tim[0]) if len(tim) > 1: mi[i] = int(tim[1]) else: mi[i] = 0 if len(tim) > 2: sc[i] = int(tim[2]) else: sc[i] = 0 else: hr[i] = 0 mi[i] = 0 sc[i] = 0 if ((yr[i]==1900) & (mo[i]==2) & (dy[i]==29)): timeobj[i] = nt.datetime(yr[i], 3, 1, hr[i], mi[i], sc[i]) else: timeobj[i] = nt.datetime(yr[i], mo[i], dy[i], hr[i], mi[i], sc[i]) # if no ascii input, other inputs will be concidered # calculation of input sizes, shapes and number of axis if (ascii is None) and (en is None): isnlist1 = type(yr) == type(np.array(yr)) isarr1 = np.ndim(yr) if isarr1 == 0: yr = np.array([yr]) else: yr = np.array(yr) isnlist2 = type(mo) == type(np.array(mo)) isarr2 = np.ndim(mo) if isarr2 == 0: mo = np.array([mo], dtype=np.int) else: mo = np.array(mo, dtype=np.int) isnlist3 = type(dy) == type(np.array(dy)) isarr3 = np.ndim(dy) if isarr3 == 0: dy = np.array([dy]) else: dy = np.array(dy) isnlist4 = type(hr) == type(np.array(hr)) isarr4 = np.ndim(hr) if isarr4 == 0: hr = np.array([hr]) else: hr = np.array(hr) isnlist5 = type(mi) == type(np.array(mi)) isarr5 = np.ndim(mi) if isarr5 == 0: mi = np.array([mi]) else: mi = np.array(mi) isnlist6 = type(sc) == type(np.array(sc)) isarr6 = np.ndim(sc) if isarr6 == 0: sc = np.array([sc]) else: sc = np.array(sc) islist = not (isnlist1 | isnlist2 | isnlist3 | isnlist4 | isnlist5 | isnlist6) isarr = isarr1 + isarr2 + isarr3 + isarr4 + isarr5 + isarr6 shapes = [np.shape(yr), np.shape(mo), np.shape(dy), np.shape(hr), np.shape(mi), np.shape(sc)] nyr = np.size(yr) nmo = np.size(mo) ndy = np.size(dy) nhr = np.size(hr) nmi = np.size(mi) nsc = np.size(sc) sizes = [nyr,nmo,ndy,nhr,nmi,nsc] nmax = np.amax(sizes) ii = np.argmax(sizes) outshape = shapes[ii] if (islist & (np.size(outshape) > 2)): raise ValueError("date2dec error: input is list > 2D; Use array input.") if nyr < nmax: if nyr == 1: yr = np.ones(outshape,)*yr else: raise ValueError("date2dec error: size of yr != max input or 1.") if nmo < nmax: if nmo == 1: mo = np.ones(outshape, dtype=np.int)*mo else: raise ValueError("date2dec error: size of mo != max input or 1.") if ndy < nmax: if ndy == 1: dy = np.ones(outshape)*dy else: raise ValueError("date2dec error: size of dy != max input or 1.") if nhr < nmax: if nhr == 1: hr = np.ones(outshape)*hr else: raise ValueError("date2dec error: size of hr != max input or 1.") if nmi < nmax: if nmi == 1: mi = np.ones(outshape)*mi else: raise ValueError("date2dec error: size of mi != max input or 1.") if nsc < nmax: if nsc == 1: sc = np.ones(outshape)*sc else: raise ValueError("date2dec error: size of sc != max input or 1.") indate = [yr, mo, dy, hr, mi, sc] insize = [np.size(i) for i in indate] inshape = [np.shape(i) for i in indate] dimnum = [len(i) for i in inshape] # calculation of maximum input size and maximum number of axis for # reshaping the output indate = [i.flatten() for i in indate] outsize = max(insize) timeobj = np.zeros(outsize, dtype=object) # datetime object is constructed for i in range(outsize): iyr = int(indate[0][i]) imo = int(indate[1][i]) idy = int(indate[2][i]) ihr = int(indate[3][i]) imi = int(indate[4][i]) isc = int(indate[5][i]) if ((iyr==1900) & (imo==2) & (idy==29)): timeobj[i] = nt.datetime(iyr, 3, 1, ihr, imi, isc) else: timeobj[i] = nt.datetime(iyr, imo, idy, ihr, imi, isc) # depending on chosen calendar and optional set of the time units # decimal date is calculated output = np.zeros(outsize) t0 = nt.datetime(1582, 10, 5, 0, 0, 0) t1 = nt.datetime(1582, 10, 15, 0, 0, 0) is121 = True if (min(timeobj)<t0) and (max(timeobj)>=t1) else False if (calendar == 'standard') or (calendar == 'gregorian'): if not units: units = 'days since 0001-01-01 12:00:00' dec0 = 1721424 else: dec0 = 0 if is121 and (nt.__version__ < '1.2.2'): for ii, tt in enumerate(timeobj): output[ii] = nt.date2num(tt, units, calendar='gregorian')+dec0 else: output = nt.date2num(timeobj, units, calendar='gregorian')+dec0 elif calendar == 'julian': if not units: units = 'days since 0001-01-01 12:00:00' dec0 = 1721424 else: dec0 = 0 if is121 and (nt.__version__ < '1.2.2'): for ii, tt in enumerate(timeobj): output[ii] = nt.date2num(tt, units, calendar='julian')+dec0 else: output = nt.date2num(timeobj, units, calendar='julian')+dec0 elif calendar == 'proleptic_gregorian': if not units: units = 'days since 0001-01-01 00:00:00' if is121 and (nt.__version__ < '1.2.2'): for ii, tt in enumerate(timeobj): output[ii] = nt.date2num(tt, units, calendar='proleptic_gregorian') else: output = nt.date2num(timeobj, units, calendar='proleptic_gregorian') elif calendar == 'excel1900': doerr = False if not units: units = 'days since 1899-12-31 00:00:00' if excelerr: doerr = True if is121 and (nt.__version__ < '1.2.2'): for ii, tt in enumerate(timeobj): output[ii] = nt.date2num(tt, units, calendar='proleptic_gregorian') else: output = nt.date2num(timeobj, units, calendar='proleptic_gregorian') if doerr: output = np.where(output >= 60., output+1., output) # date2num treats 29.02.1900 as 01.03.1990, i.e. is the same decimal number if np.any((output >= 61.) & (output < 62.)): for i in range(outsize): # if (timeobj[i].year==1900) & (timeobj[i].month==2) & (timeobj[i].day==29): # output[i] -= 1. if (yr[i]==1900) & (mo[i]==2) & (dy[i]==29): output[i] -= 1. elif calendar == 'excel1904': if not units: units = 'days since 1903-12-31 00:00:00' if is121 and (nt.__version__ < '1.2.2'): for ii, tt in enumerate(timeobj): output[ii] = nt.date2num(tt, units, calendar='proleptic_gregorian') else: output = nt.date2num(timeobj, units, calendar='proleptic_gregorian') elif (calendar == '365_day') or (calendar == 'noleap'): if not units: units = 'days since 0001-01-01 00:00:00' if is121 and (nt.__version__ < '1.2.2'): for ii, tt in enumerate(timeobj): output[ii] = nt.date2num(tt, units, calendar='365_day') else: output = nt.date2num(timeobj, units, calendar='365_day') elif (calendar == '366_day') or (calendar == 'all_leap'): if not units: units = 'days since 0001-01-01 00:00:00' if is121 and (nt.__version__ < '1.2.2'): for ii, tt in enumerate(timeobj): output[ii] = nt.date2num(tt, units, calendar='366_day') else: output = nt.date2num(timeobj, units, calendar='366_day') elif calendar == '360_day': if not units: units = 'days since 0001-01-01 00:00:00' if is121 and (nt.__version__ < '1.2.2'): for ii, tt in enumerate(timeobj): output[ii] = nt.date2num(tt, units, calendar='360_day') else: output = nt.date2num(timeobj, units, calendar='360_day') elif calendar == 'decimal': ntime = np.size(yr) leap = np.array((((yr%4)==0) & ((yr%100)!=0)) | ((yr%400)==0)).astype(np.int) tdy = np.array(dy, dtype=np.float) diy = np.array([ [-9,0, 31, 59, 90,120,151,181,212,243,273,304,334,365], [-9,0, 31, 60, 91,121,152,182,213,244,274,305,335,366] ]) for i in range(ntime): tdy[i] = tdy[i] + np.array(diy[leap[i],mo[i]], dtype=np.float) days_year = 365. output = ( np.array(yr, dtype=np.float) + ((tdy-1.)*24. + np.array(hr, dtype=np.float) + np.array(mi, dtype=np.float)/60. + np.array(sc, dtype=np.float)/3600.) / ((days_year+np.array(leap, dtype=np.float))*24.) ) # for numerical stability, i.e. back and forth transforms output += 1e-08 # 1/3 sec elif calendar == 'decimal360': ntime = np.size(yr) tdy = np.array(dy, dtype=np.float) diy = np.array([-9, 0, 30, 60, 90,120,150,180,210,240,270,300,330,360]) for i in range(ntime): tdy[i] = tdy[i] + np.array(diy[mo[i]], dtype=np.float) days_year = 360. output = ( np.array(yr, dtype=np.float) + ((tdy-1.)*24. + np.array(hr, dtype=np.float) + np.array(mi, dtype=np.float)/60. + np.array(sc, dtype=np.float)/3600.) / (days_year*24.) ) # for numerical stability, i.e. back and forth transforms output += 1e-08 # 1/3 sec else: raise ValueError("date2dec error: calendar not implemented; should have been catched before.") # return of reshaped output output = np.reshape(output, outshape) if isarr == 0: output = np.float(output) else: if islist: ns = np.size(outshape) if ns == 1: output = [i for i in output] else: loutput = [ i for i in output[:,0]] for i in range(np.size(output[:,0])): loutput[i] = list(np.squeeze(output[i,:])) output = loutput return output
def function(self, lamb, Av=1, Rv=3.1, Alambda=True, draine_extend=False, **kwargs): """ Fitzpatrick99 extinction Law Parameters ---------- lamb: float or ndarray(dtype=float) wavelength [in Angstroms] at which evaluate the law. Av: float desired A(V) (default 1.0) Rv: float desired R(V) (default 3.1) Alambda: bool if set returns +2.5*1./log(10.)*tau, tau otherwise draine_extend: bool if set extends the extinction curve to below 912 A Returns ------- r: float or ndarray(dtype=float) attenuation as a function of wavelength depending on Alambda option +2.5*1./log(10.)*tau, or tau """ # ensure the units are in angstrom _lamb = units.Quantity(lamb, units.angstrom).value #_lamb = val_in_unit('lamb', lamb, 'angstrom').magnitude if isinstance(_lamb, float) or isinstance(_lamb, np.float_): _lamb = np.asarray([lamb]) else: _lamb = lamb[:] c2 = -0.824 + 4.717 / Rv c1 = 2.030 - 3.007 * c2 c3 = 3.23 c4 = 0.41 x0 = 4.596 gamma = 0.99 x = 1.e4 / _lamb k = np.zeros(np.size(x)) # compute the UV portion of A(lambda)/E(B-V) xcutuv = 10000.0 / 2700. xspluv = 10000.0 / np.array([2700., 2600.]) ind = np.where(x >= xcutuv) if np.size(ind) > 0: k[ind] = c1 + (c2 * x[ind]) + \ c3 * ((x[ind]) ** 2) / ( ((x[ind]) ** 2 - (x0 ** 2)) ** 2 + (gamma ** 2) * ((x[ind]) ** 2 )) yspluv = c1 + (c2 * xspluv) + c3 * ((xspluv) ** 2) / \ ( ((xspluv) ** 2 - (x0 ** 2)) ** 2 + (gamma ** 2) * ((xspluv) ** 2 )) # FUV portion if not draine_extend: fuvind = np.where(x >= 5.9) k[fuvind] += c4 * (0.5392 * ((x[fuvind] - 5.9) ** 2) + 0.05644 * ((x[fuvind] - 5.9) ** 3)) k[ind] += Rv yspluv += Rv # Optical/NIR portion ind = np.where(x < xcutuv) if np.size(ind) > 0: xsplopir = np.zeros(7) xsplopir[0] = 0.0 xsplopir[1: 7] = 10000.0 / np.array([26500.0, 12200.0, 6000.0, 5470.0, 4670.0, 4110.0]) ysplopir = np.zeros(7) ysplopir[0: 3] = np.array([0.0, 0.26469, 0.82925]) * Rv / 3.1 ysplopir[3: 7] = np.array([np.poly1d([2.13572e-04, 1.00270, -4.22809e-01])(Rv), np.poly1d([-7.35778e-05, 1.00216, -5.13540e-02])(Rv), np.poly1d([-3.32598e-05, 1.00184, 7.00127e-01])(Rv), np.poly1d([ 1.19456, 1.01707, -5.46959e-03, 7.97809e-04, -4.45636e-05][::-1])(Rv)]) tck = interpolate.splrep(np.hstack([xsplopir, xspluv]), np.hstack([ysplopir, yspluv]), k=3) k[ind] = interpolate.splev(x[ind], tck) # convert from A(lambda)/E(B-V) to A(lambda)/A(V) k /= Rv # FUV portion from Draine curves if draine_extend: fuvind = np.where(x >= 5.9) tmprvs = np.arange(2.,6.1,0.1) diffRv = Rv - tmprvs if min(abs(diffRv)) < 1e-8: dfname = libdir+'MW_Rv%s_ext.txt' % ("{0:.1f}".format(Rv)) l_draine, k_draine = np.loadtxt(dfname, usecols=(0,1), unpack=True) else: add, = np.where(diffRv < 0.) Rv1 = tmprvs[add[0]-1] Rv2 = tmprvs[add[0]] dfname = libdir+'MW_Rv%s_ext.txt' % ("{0:.1f}".format(Rv1)) l_draine, k_draine1 = np.loadtxt(dfname, usecols=(0,1), unpack=True) dfname = libdir+'MW_Rv%s_ext.txt' % ("{0:.1f}".format(Rv2)) l_draine, k_draine2 = np.loadtxt(dfname, usecols=(0,1), unpack=True) frac = diffRv[add[0]-1]/(Rv2-Rv1) k_draine = (1. - frac)*k_draine1 + frac*k_draine2 dind = np.where((1./l_draine) >= 5.9) k[fuvind] = interp(x[fuvind],1./l_draine[dind][::-1], k_draine[dind][::-1]) # setup the output if (Alambda): return(k * Av) else: return(k * Av * (np.log(10.) * 0.4))
def compute_bit_error_rate(source, received): ''' Calculates the bit error rate ''' number_of_bits = np.size(source) return np.sum(np.bitwise_xor(bits, received_bits))/number_of_bits
(PI,A,B) = initialize(chroma, templates, nested_cof) (path, states) = viterbi(PI,A,B) #normalize path for i in range(nFrames): path[:,i] /= sum(path[:,i]) #choose most likely chord - with max value in 'path' final_chords = [] indices = np.argmax(path,axis=0) final_states = np.zeros(nFrames) #find no chord zone set_zero = np.where(np.max(path,axis=0) < 0.3*np.max(path))[0] if np.size(set_zero) is not 0: indices[set_zero] = -1 #identify chords for i in range(nFrames): if indices[i] == -1: final_chords.append('NC') else: final_states[i] = states[indices[i],i] final_chords.append(chords[int(final_states[i])]) print 'Time(s)','Chords' for i in range(nFrames): print timestamp[i], final_chords[i]