def test_slow(): if False: a = load_merfish(fname) assert not is_sorted(a['cellID']) cell_order = np.argsort(a['cellID']) assert not is_sorted(cell_order) assert is_sorted(a['cellID'][cell_order])
def __init__(self, src_id, seed, change_times, rates): """Creates a broadcaster which tweets with the given rates.""" super(PiecewiseConst, self).__init__(src_id, seed) assert is_sorted(change_times) self.change_times = change_times self.rates = rates self.init = False self.times = None self.t_diff = None self.start_idx = None
def build(self): idx = np.array(self.included_nodes,dtype=np.int) assert is_sorted(idx) # Define matrix and block sizes block_size = idx.size # Use the included number block_num = self.num_actions+1 N = block_size*block_num # Total matrix size # First block of q is the state weight vector q = np.empty(N) q[:block_size] = -self.state_weights[idx] # Build the other blocks row = [] col = [] data = [] for block in xrange(1,block_num): shift = block*block_size action = block - 1 # Get the E block (I - g P) # Immediately slice off omitted nodes E = self.mdp.get_E_matrix(action) E = self.contract_sparse_square_matrix(E) # Add both E and -E.T to the growing COO structures row.extend([E.row,E.col + shift]) col.extend([E.col + shift,E.row]) data.extend([E.data,-E.data]) # Add included costs to the q block q[shift:(shift+block_size)] = self.mdp.costs[action][idx] # Add regularization row.append(np.arange(N)) col.append(np.arange(N)) data.extend([self.val_reg*np.ones(block_size), self.flow_reg*np.ones((block_num-1)*block_size)]) # Concat COO structures into single vectors row = np.concatenate(row) col = np.concatenate(col) data = np.concatenate(data) # Build the COO matrix M = sps.coo_matrix((data,(row,col)), shape=(N,N),dtype=np.double) # Assemble into LCP object; return return LCPObj(M,q)
def __call__(self, p): self.model.p = p[:-1] distances = list() for component in self.model._components: distances.append(np.sqrt(component.p[1] ** 2. + component.p[2] ** 2.)) if not is_sorted(distances): print "Components are not sorted:(" return -np.inf lnpr = list() for component in self.model._components: lnpr.append(component.lnpr) lnpr.append(sp.stats.uniform.logpdf(p[-1], 0, 2)) return sum(lnpr)
def __call__(self, p): self.model.p = p[:] distances = list() for component in self.model._components: distances.append(np.sqrt(component.p[1]**2. + component.p[2]**2.)) if not is_sorted(distances): print("Components are not sorted:(") return -np.inf lnpr = list() for component in self.model._components: # This is implemented in ``Model.p`` # component.p = p[:component.size] # p = p[component.size:] #print "Got lnprior for component : ", component.lnpr lnpr.append(component.lnpr) return sum(lnpr)
def load_cells(fname: str, cell_ids: List, verbose=True): cell_ids = [int(i) for i in cell_ids] if verbose: print("Analyzing", basename(fname)) df = load_merfish(fname) df_cell_ids = np.array(df["cellID"]) mask = df_cell_ids == cell_ids[0] for i in cell_ids[1:]: mask |= df_cell_ids == i df = df[mask] df.sort(order='cellID') if True: assert is_sorted(df['cellID']) if verbose: print(f"Selected {len(df):,d} points") return df
def __init__(self,node_lists): self.dim = len(node_lists) self.node_lists = np.array(node_lists) # List of np.ndarray cutpoint locations for nl in node_lists: assert nl.ndim == 1 # 1D array assert nl.size >= 2 # At least two nodes assert is_sorted(nl) # Number of cutpoints along each dimension desc = [(nl[0],nl[-1],nl.size) for nl in node_lists] (low,hi,num) = zip(*desc) self.lower_bound = np.array(low) self.upper_bound = np.array(hi) self.num_nodes = np.array(num) self.num_cells = self.num_nodes - 1 # Initialize the indexer self.indexer = Indexer(self.num_nodes) # Fuzz to convert [low,high) to [low,high] self.fuzz = 1e-12
def test_is_sorted(self): sorted_list = [2, 3, 6, 7] unsorted_list = [3, 2, 6, 7] self.assertTrue(utils.is_sorted(sorted_list)) self.assertFalse(utils.is_sorted(unsorted_list))
def test_sorting(self): """Tests if the list is sorted""" items = [21, 4, 1, 3, 9, 20, 25, 6, 21, 14] merge_sort.iterative(items) self.assertTrue(utils.is_sorted(items))
def get_user_data_for(user_id): hs = get_user_repository() try: user_tweet_times = hs.get_user_tweets(user_id) assert is_sorted(user_tweet_times), "User tweet times were not sorted." # TODO: This should ideally be the last 2 months instead of tweeting history of # the broadcaster. Or .... # Is 2 months now. first_tweet_time, last_tweet_time = user_tweet_times[ 0], user_tweet_times[-1] exp_times = get_start_end_time() start_time = exp_times.start_time # GMT: Wed, 01 Jul 2009 00:00:00 GMT end_time = exp_times.end_time # GMT: Tue, 01 Sep 2009 00:00:00 GMT if last_tweet_time < start_time: # This user did not tweet in the relevant period of time return (user_id, None) # user_intensity = calc_avg_user_intensity(user_tweet_times, # start_time, # end_time) # These are the ids of the sink user_followers = hs.get_user_followers(user_id) user_relevant_followers = [] log("Num followers of {} = {}".format(user_id, len(user_followers))) edge_list, sources = [], [] for idx, follower_id in enumerate(user_followers): followees_of_follower = len(hs.get_user_followees(follower_id)) if followees_of_follower < 500: # If the number of followees of the follower are > 500, then Do not # create their walls. This will discard about 30% of all users. user_relevant_followers.append(follower_id) wall = hs.get_user_wall(follower_id, excluded=user_id) follower_source = make_real_data_broadcaster( follower_id, wall, start_time, end_time) log("Wall of {} ({}/{}) has {} tweets, {} relevant".format( follower_id, idx + 1, len(user_followers), len(wall), follower_source.get_num_events())) # The source for follower_id has the same ID # There is one source per follower which produces the tweets sources.append(follower_source) edge_list.append((follower_id, follower_id)) # The source user_id broadcasts tweets to all its followers edge_list.extend([(user_id, follower_id) for follower_id in user_relevant_followers]) other_source_params = [('RealData', { 'src_id': x.src_id, 'times': x.times }) for x in sources] sim_opts = SimOpts(edge_list=edge_list, sink_ids=user_relevant_followers, src_id=user_id, q_vec=def_q_vec(len(user_relevant_followers)), s=1.0, other_sources=other_source_params, end_time=scaled_period) return (user_id, (sim_opts, scale_times(user_tweet_times, start_time, end_time, scaled_period))) except Exception as e: print('Encountered error', e, ' for user {}'.format(user_id)) return user_id, None finally: hs.close()
def test_sorting(self): """Tests if the items are sorted""" items = [21, 4, 1, 3, 9, 20, 25, 6, 21, 14] quick_sort.recursive(items) self.assertTrue(utils.is_sorted(items))
def test_is_sorted2(): a = np.array([0, 2, 2], dtype=np.uint8) assert is_sorted(a)
def test_is_sorted1(): a = np.array([1, 2, 0], dtype=np.uint8) assert not is_sorted(a)