def fightPossibilities(ell, minSize=0): fightNumbers = range(2**ell) fp = [ [ int(x) for x in scipy.binary_repr(fN,ell) ] \ for fN in fightNumbers ] if minSize > 0: fp = scipy.array(filter(lambda x: sum(x) >= minSize, fp)) return fp
def fightPossibilities(ell, minSize=0): fightNumbers = list(range(2**ell)) fp = [ [ int(x) for x in scipy.binary_repr(fN,ell) ] \ for fN in fightNumbers ] if minSize > 0: fp = scipy.array([x for x in fp if sum(x) >= minSize]) return fp
def modisread_day_of_year(folder): print ' ' print '____________Read Modis Day_of_Year_____________' print ' ' d = {} cs_clouds = 1000 granules = modis_granules(folder) #Chose one File k = granules.keys()[0] filename_doy = granules[k]['day_of_year'] print 'read day_of_year: ' + folder + filename_doy f_doy = SD(folder + filename_doy) print ' ' for key in ['day_of_year', 'Latitude', 'Longitude']: d[key] = sp.array(f_doy.select(key).get(), sp.int16) if key == 'day_of_year': day_of_year = [] for n in d[key][0].flatten(): #flag=convert_decimal_to_8bit(n) flag = sp.binary_repr(n, width=16) day_of_year.append(int(flag)) #0->cloudy, 1->clear doy = sp.array(day_of_year).reshape(d[key].shape[1:3]) d[key] = doy print ' done.' d['day_of_year'] = d['day_of_year'][:, :-1000 / cs_clouds] d['Latitude'] = d[ 'Latitude'][:, :-1000 / cs_clouds] #remove the right-hand-side edge pixels d['Longitude'] = d['Longitude'][:, :-1000 / cs_clouds] print 'image shape: ' + str(d['day_of_year'].shape) print ' ' return d['day_of_year'], d['Longitude'], d['Latitude']
def binaryRep(i, gen): """ given an integer and a generation, return the representation of that configuration i in the site basis, as a string of 0's and 1's Basically, at gen we should have numberOfNodes points in our binary rep of i. """ length = numberOfNodes(gen) b = scipy.binary_repr(i, length) return b
def spikes2indep_dict(spikes, npoints=None, fractions=[1,2,4]): """Return dictionary with distribution over states assuming independence. This function works like `states2dict`, but takes as input an array of spikes, and return a dictionary of states by removing all dependencies between channels. The distributions are *not* normalized, as required by other routines (e.g., KL estimation routines). Input arguments: spikes -- spikes trains: 2D binary array, each column a different unit, each row a time point nchannels -- total number of channels (used to determine the maximum number of states) npoints -- number of data points Default: None, meaning the full length of states fractions -- fractions of the data. For example, fractions=[1,2,4] will create 3 entries in the dictionary, based on the full data (N datapoints), half the data (2 x N/2 points), and one quarter of the data (4 x N/4 points). Default: [1,2,4] shuffle -- If True, data points are shuffled before computing the dictionaries to avoid trends in the data Output: Dictionary distr[fraction][distr_nr]. Keys are fractions (as given by input argument), values are lists of distributions. """ if npoints is None: npoints = spikes.shape[0] nchannels = spikes.shape[1] # p1[i] = p(channel_i = 1) p1 = spikes.sum(0).astype('d')/spikes.shape[0] # distribution over states given independence nbins = 2**nchannels indep_distr = zeros((nbins,)) # cycle over states for s in range(nbins): # get binary pattern s_bin = scipy.binary_repr(s, width=nchannels) if s>0 else '0'*nchannels # compute probability for independent case prob = [(p1[k] if s_bin[k]=='1' else 1.-p1[k]) for k in range(nchannels) ] indep_distr[s] = scipy.prod(prob) # construct dictionary as for normal case distr = {} for d in fractions: l = npoints/d distr[d] = [indep_distr*l] * d _check_dict_consistency(distr, npoints) return distr
def modisread_clouds(folder): print ' ' print '____________Read Modis Cloudmask - kann etwas dauern_____________' print ' ' d = {} cs_clouds = 1000 granules = modis_granules(folder) #Chose one File k = granules.keys()[0] # # Read Cloudmask # filename_clouds = granules[k]['clouds'] print 'read clouds: ' + folder + filename_clouds f_clouds = SD(folder + filename_clouds) print ' ' for key in ['Cloud_Mask', 'Latitude', 'Longitude']: d[key] = sp.array(f_clouds.select(key).get(), sp.int8) if key == 'Cloud_Mask': cloud_mask = [] land_mask = [] for n in d[key][0].flatten(): #flag=convert_decimal_to_8bit(n) flag = sp.binary_repr(n, width=8) cloud_mask.append(int(flag[5])) #0->cloudy, 1->clear land_mask.append(int(flag[0])) #0->water 1->coast,desert,land clouds = sp.array(cloud_mask, sp.int8).reshape(d[key].shape[1:3]) land = abs( sp.array(land_mask, sp.int8).reshape(d[key].shape[1:3]) - 1) #1->water 0->coast,desert,land d[key] = land * clouds print ' done.' d['Cloud_Mask'] = d['Cloud_Mask'][:, :-1000 / cs_clouds] d['Latitude'] = d[ 'Latitude'][:, :-1000 / cs_clouds] #remove the right-hand-side edge pixels d['Longitude'] = d['Longitude'][:, :-1000 / cs_clouds] print 'image shape: ' + str(d['Cloud_Mask'].shape) print ' ' return d['Cloud_Mask'], d['Longitude'], d['Latitude']
def number2fight(stateList, numIndividuals): """ Returns the 'base-2 fight' corresponding to the base-10 number. """ return [ [int(bit) for bit in scipy.binary_repr(state,numIndividuals)] \ for state in stateList ]