def updateweights(n1, n2): #Initialising a random number and if that number exceeds the crossingover rate then proceeding ahead for crossing over #else returning the 2 NeuralNets as it is a= random.random() if a < crossingoverrate: #Creating a list of weights of both the NeuralNets for easy processing ahead weightslist1 = np.array(n1.nettolist()) weightslist2 = np.array(n2.nettolist()) #Main Crossing over step- We take an element-wise average of the weights of #both the NeuralNets . This incorporates the weights of both the NeuralNets #in equal proportion. We make 2 such lists , this is the crossing over step #since we are taking characters from both the NeuralNets that too equally. child1 = [i * 0.5 for i in np.add(weightslist1, weightslist2)] child2 = [i * 0.5 for i in np.add(weightslist1, weightslist2)] #Initialising a random number and if that number exceeds the mutation rate then proceeding ahead for mutation #else the child remains as it is b= random.random() c= random.random() if b < mutationrate: print "Hi" #Randomly picking any one index of the list to be mutated index = random.randint(0, len(child1) - 1) #perturbing the value slightly by adding a small component proportional to the original value of the weight #for that index (it is being multiplied by a random number generated from a triangular distribution) #This step is similar to mutation in genetics, where the genome gets randomly perturbed by external mutagens. child1[index] += random.triangular(-1, 1) * child1[index] if c < mutationrate: print "Hello" index = random.randint(0, len(child2) - 1) child2[index] += random.triangular(-1, 1) * child2[index] #After the crossing over and mutation (if any), the list of weights is converted back to weights for the NeuralNets. n1.listtonet(child1) n2.listtonet(child2) return (n1, n2)
def specimen_generator(): global random_specimen global mated_specimen while True: r = get_results() result_count = len(r) if result_count < 10 or mated_specimen > 10*random_specimen: dna = map(lambda x: x+97, range(26)) dna = map(chr, dna) shuffle(dna) dna = "".join(dna) #print "random: %s" % dna with random_specimen_lock: random_specimen += 1 yield {"dna" : dna, "parents" : [], "id" : next_id(), "guesses" : None, "wrong" : None, "winrate" : None} else: dna_i = int(triangular(0, len(r), 0)) dnb_i = int(triangular(0, len(r), 0)) dna = r[dna_i] dnb = r[dnb_i] dnc = merge_dna(dna["dna"], dnb["dna"]) print "mated %s & %s -> %s\n" % (dna["dna"], dnb["dna"], dnc) with mated_specimen_lock: mated_specimen += 1 yield {"dna" : dnc, "parents" : ["%s (%s)" % (dna_link(dna["dna"]), dna["winrate"]), "%s (%s)" % (dna_link(dnb["dna"]), dnb["winrate"])], "id" : next_id(), "guesses" : None, "wrong" : None, "winrate" : None}
def tickle_bids(low, high, amountlow=.02, amounthigh=.09, concurrent=4, pause=33.5): try: while True: time.sleep(pause) clear_all_bids() amount_midpoint = amounthigh - ((amounthigh - amountlow) / 2) bid_amounts = [] for i in range(concurrent): bid_btc_amount = float("{0:.4f}".format(random.triangular(amountlow, amounthigh, amount_midpoint))) bid_amounts.append(bid_btc_amount) bid_price_midpoint = float(high) - ((float(high) - float(low)) / 2) print 'Bid price midpoint: %f' % bid_price_midpoint for bid_btc_amount in bid_amounts: bid = float("{0:.2f}".format(random.triangular(low, high, bid_price_midpoint))) print 'Bid: %f [%f]' % (bid, bid_btc_amount) total_btc_int = int(bid_btc_amount * BTC_INT_FACTOR) buy_price_int = int(bid * USD_INT_FACTOR) res = API.add_order('bid', total_btc_int, buy_price_int) print res except KeyboardInterrupt: print '\nStopping...' clear_all_bids()
def advance_epoch(self): """Pass the time.""" # Sort ascending because this is cost rather than fitness. self.population.sort(key=fitness, reverse=True) new_population = [] # Clone our best people. iters = int(Pool.population_size * 0.4) for counter in range(iters): new_individual = self.population[counter].copy() new_population.append(new_individual) # Breed our best people, producing four offspring for each couple. iters = int(Pool.population_size * 0.6) for counter in range(0, iters, 2): # Perform rank roulette selection. father = self.population[int(triangular(0, iters, 0))] mother = self.population[int(triangular(0, iters, 0))] children = self.crossover(father, mother) children[0].mutate() new_population += children self.population = new_population for person in self.population: person.update_fitness() self.epoch += 1
def create_expression(): """This function takes no arguments and returns an expression that generates a number between -1.0 and 1.0, given x and y coordinates.""" # expr = lambda x, y: (random.random() - 2 * 81) - 1 # expr_dict= {'A': lambda x, y: sin(sin(sin(cos(x * y)))), # 'B': lambda x, y: sin(pi) * 2, # 'C': lambda x, y: sin(3 * pi(sin(21))), # 'D': lambda x, y: (cos(sin((pi * 8)))), # 'E': lambda x, y: cos(cos(sin(7))) # } # expr_dict = {'sure': lambda x, y: sin(sin(sin(cos(pi)))), # 'the': lambda x, y: random.triangular(0.2, 0.9), # 'dang': lambda x, y: sin(pi(sin(pi(sin(cos(-1)))))), # 'should': lambda x, y: cos(x * cos(sin(pi))), # 'make': lambda x, y: random.uniform(1278, 900000), # 'art': lambda x, y: random.gauss(x, y)} expr_list = [lambda x, y: (random.random() * 21) - 1 / 3, lambda x, y: (random.triangular(0, 1) * 2) - 1, lambda x, y: (random.uniform(x, y) * 2) - 1, lambda x, y: ((x**3) - sin(3)), lambda x, y: (random.triangular(0.2, 0.8) / 2) - 1, lambda x, y: sin(pi * 2) - 3 / 4, lambda x, y: sqrt(sin(pi / 2) * cos(x)), lambda x, y: sin(cos(sin(cos(sin(cos(sin(cos(pi)))))))), lambda x, y: 7 + sin(pi) / sqrt(2**4), lambda x, y: sqrt(3) * sin(sin(sin(pi) - 1)), lambda x, y: (random.random() * 8) + sqrt(66) / 2, lambda x, y: sin(sin(sin(sin(sin(sin(sin(sin(sin(7 * x - y))))))))), lambda x, y: random.uniform(sin(1), pi) **8 / 2] return random.choice(expr_list)
def simulation_per_month_model(input_model): """ Model to solve the problem """ # Static model data cold_start_initial_users = 400 cost_per_request = 0.01 request_per_user = 4 # Model # Select randomly input parameters events = random.triangular(input_model[1][0], input_model[1][1], input_model[1][2]) # Calculate the cost cost = 0 # For each event in the month for event in range(0, round(events)): event_duration = random.triangular(input_model[2][0], input_model[2][1], input_model[2][2]) # For each day of the event for day in range(0, round(event_duration)): # Get users to track users_to_track = random.triangular(input_model[0][0], input_model[0][1], input_model[0][2]) cost += event_duration * users_to_track * request_per_user * cost_per_request cost += cold_start_initial_users * request_per_user * cost_per_request return cost
def random_position(a, b): """Draw from a bimodal distribution with support in (a,b). This is just two triangular distributions glued together. Empirically it's a nice way to build the word clouds, but it should be replaced at some point with something more sophisticated. See the note below. Here's the idea behind the crazy bimodal distribution: * If we drop the words too close to the axes they'll just stack up and we get something that looks like a plus * If we drop a word at the corner of the region it'll stack right above the previous word dropped from that direction, then get shoved left. The result looks like a square. * Dropping halfway between the axis and the corner will result in something halfway in-between (usually a hexagon) I think that what this method is `approximating' is the following: * Divide the area into quadrants * Keep track of the area covered in each quadrant * Drop the new word in a random position on the edge of the quadrant with the least coverage """ if random.choice([ 0, 1 ]): return random.triangular(a, 0.5*(a+b)) else: return random.triangular(0.5*(a+b), b)
def randomize(self, random_state=1): """Randomize.""" self.random_state = random_state random.seed(self.random_state) self.nearest_neighbors_threshold = \ int(random.triangular(0, 2 * self.nearest_neighbors_threshold, self.nearest_neighbors_threshold)) self.true_class_bias = \ random.triangular(0, 2 * self.true_class_bias, self.true_class_bias) self.multi_class_bias = \ random.triangular(0, 2 * self.multi_class_bias, self.multi_class_bias) self.multi_class_threshold = \ random.triangular(0, 2 * self.multi_class_threshold, self.multi_class_threshold) self.true_class_threshold = \ random.triangular(0, 2 * self.true_class_threshold, self.true_class_threshold) logger.debug(self.__str__())
def impulse(self): for body in self.group.dynamicBodies(): if body.acc.z == 0: body.vel.x = round(random.triangular(-.5,.5), self.group.precision) body.vel.y = round(random.triangular(-.5,.5), self.group.precision) body.vel.z = round(random.triangular(0,1.5), self.group.precision) self.group.wakeBody(body)
def create_fake_financial_support(): semesters = list(Semester.objects.all()) for _ in range(50): s = Scholarship( scholarship_type=random.choice(ScholarshipType.objects.all()), student=random.choice(all_gradstudents.values()), amount=random.triangular(100.0, 20000.0, 5000.0), start_semester=random.choice(semesters), end_semester=random.choice(semesters), ) s.save() all_financial_support.append(s) for _ in range(20): of = OtherFunding( student=random.choice(all_gradstudents.values()), semester=random.choice(semesters), description=randdesc(40), amount=random.triangular(100.0, 20000.0, 5000.0), eligible=randbool()) of.save() all_financial_support.append(of) for _ in range(40): p = Promise( student=random.choice(all_gradstudents.values()), amount=random.triangular(100.0, 40000.0, 20000.0), start_semester=random.choice(semesters), end_semester=random.choice(semesters), ) p.save() all_financial_support.append(p)
def step(self, prev_xy): if self.map.player_xy in self.map.objs: for obj in self.map.objs[self.map.player_xy]: if isinstance(obj, StairUp) and prev_xy != self.map.player_xy: self.map = self.map.prev elif isinstance(obj, StairDown) and prev_xy != self.map.player_xy: if not self.map.next: t = copy.copy(self.map.type) t.stairup = True t.stairdown = True t.size = random.choice((t.tiny, t.small, t.medium)) t.treasure_level = int(random.triangular(0.0, 9.9, math.sqrt(self.map.level))) t.monster_level = int(random.triangular(0.0, 9.9, math.sqrt(self.map.level))) self.map.next = Map(t) self.map.next.prev = self.map self.map = self.map.next return obj.on_player(self.player) self.map.objs[self.map.player_xy][:] = [x for x in self.map.objs[self.map.player_xy] if x.delete == False] self.map.objs_lock = True for pos, objs in self.map.objs.items(): for obj in objs: obj.step(pos, self.map, self.player) self.map.objs = {k: [x for x in self.map.objs[k] if x.delete == False] for k in self.map.objs.keys()} self.map.objs_lock = False self.player.lust += 1
def modify_surface(): perlin = True sel = mc.ls(selection=True,long=True) for verts in sel: totalVerts = mc.polyEvaluate(verts, vertex=True) for number in xrange(totalVerts): if perlin == True: frequency = 1.0 amplitude = 1.5 octaves = 8 for o in xrange(octaves): randX = random.triangular(-0.2 , 0.0, 0.2) posX = perlinNoise(randX ,0,0) randY = random.triangular(-0.4 , 0.0, 0.6) posY = perlinNoise(0,randY,0) randZ = random.triangular(-0.2 , 0.0, 0.2) posZ = perlinNoise(0,0,randZ) posX *= frequency posY *= frequency posZ *= frequency mc.select(verts+'.vtx[{number}]'.format(number=number)) mc.move(posX,posY*amplitude,posZ,relative=True) mc.rotate(posY*amplitude,y=True) mc.select(sel, replace=True) mc.makeIdentity(s=True, a=True, t=True,r=True)
def create_noble(self, mode = "manual"): if mode == "manual": intel = self.Controller.get_input("What is the Nobles intelligence? (0 - 10)", "int") ambition = self.Controller.get_input("What is the Nobles ambition? (0 - 10)", "int") network = self.Controller.get_input("How strong is the Nobles network? (0 - 10)", "int") wealth = self.Controller.get_input("How wealthy is the Noble? (0 - 10)", "int") while True: gender = str(input("Male or Female? (m/f)")) gender = gender.lower() if gender == "m" or gender == "f": break print("Sorry, I don't have enough programming skill to deal with non-binary genders") elif mode == "random": intel = int(round(random.triangular(0, 10))) ambition = int(round(random.triangular(0, 10))) network = int(round(random.triangular(0, 10))) wealth = int(round(random.triangular(0, 10))) gender = random.choice(["m", "f"]) nobility = (network + wealth) / 2 names = self.create_noble_name(gender, nobility) egg = self.egg_checker(names[0]) if egg: names = egg stats = egg[3] intel = stats[0] ambition = stats[1] network = stats[2] wealth = stats[3] gender = stats[4] full_name = names[0] full_title = names[1] extended_title = title = names[2] stats = { "full_name": full_name, "full_title": full_title, "extended_title": extended_title, "intel": intel, "ambition": ambition, "network": network, "wealth": wealth, "gender": gender, "employed": False #Adding an "employed" stat here } self.nobles[full_name] = stats self.save_file() print("") print("New noble added!\nName: %s\nIntelligence: %d\nAmbition: %d\nNetwork: %d\nWealth: %s" % ( extended_title, intel, ambition, network, wealth )) print("")
def pytest_generate_tests(metafunc): """ Generate the arguments for test functions. """ if "graph" in metafunc.funcargnames: wgraphs = [] # 100 vertex random graph a = nx.gnp_random_graph(100, 0.1) for e in a.edges_iter(data = True): e[2]['weight'] = triangular(-2, 2, 0) deg = sg.wgraph.make_deg(a.order(), create_iter(a.edges_iter(data = True))) b = sg.wgraph.make(a.order(), a.size(), create_iter(a.edges_iter(data = True)), deg) wgraphs.append((a, b)) # 100 vertex random graph with parallel edges a = nx.gnp_random_graph(100, 0.1) for e in a.edges_iter(data = True): e[2]['weight'] = triangular(-2, 2, 0) deg = sg.wgraph.make_deg(a.order(), chain(create_iter(a.edges_iter(data = True)), create_iter(a.edges_iter(data = True)))) b = sg.wgraph.make(a.order(), 2 * a.size(), chain(create_iter(a.edges_iter(data = True)), create_iter(a.edges_iter(data = True))), deg) wgraphs.append((a, b)) # 100 vertex random graph with overestimated edge count a = nx.gnp_random_graph(100, 0.1) for e in a.edges_iter(data = True): e[2]['weight'] = triangular(-2, 2, 0) deg = sg.wgraph.make_deg(a.order(), create_iter(a.edges_iter(data = True))) b = sg.wgraph.make(a.order(), 2 * a.size(), create_iter(a.edges_iter(data = True)), deg) wgraphs.append((a, b)) metafunc.parametrize("graph", wgraphs)
def __init__(self, n_cols=MAP_COL_COUNT, n_rows=MAP_ROW_COUNT): self.size = (n_cols, n_rows) self.columns = list() #generate the tiles for the map for col in range(n_cols): column = list() for row in range(n_rows): column.append(Tile([col, row])) self.columns.append(column) #select starting location for town start_loc = [ int(random.triangular(0,n_cols)), int(random.triangular(0,n_rows))] self.start_tile = self.tileAt(start_loc) self.generateLandmassAround(start_loc) self.generateForests() self.generateMountains() self.start_tile.setTerrain(Terrain.GRASS) self.start_tile.addNewUnit(UnitType.SETTLER) self.selected_tile = None
def assign_carbs(sugar, last_carbs, sugar_in_range): """ Assign next 'meal' event based on: sugar -- the current glucose level last_carb -- the previous carb value sugar_in_range -- list of previous consecutive 'in range' sugar events """ if sugar >= 240: carbs = random.uniform(-300, -290) elif sugar >= 200: carbs = random.triangular(-250, -180, -220) elif len(sugar_in_range) >= 3: high_or_low = random.randint(0,1) #if sugar in range, randomley generate high or low event if high_or_low == 0: carbs = random.uniform(230, 250) else: carbs = random.uniform(-250, 250) elif sugar <= 50: carbs = random.triangular(270, 300, 290) elif sugar <= 80: carbs = random.triangular(200, 250, 230) elif last_carbs > 50: carbs = random.uniform(-190, -170) else: carbs = random.triangular(-50, 100, 60) return carbs
def generate_random_data(start_date, end_date, imei, name, lat, lon): try: start_time = datetime(*[int(i) for i in start_date.split("-")]) end_time = datetime(*[int(i) for i in end_date.split("-")]) #assert (imei=="" or imei== None), "IMEI cannot be blank" #assert (name=="" or name== None), "Name cannot be blank" #assert (lat=="" or lat== None), "Lat cannot be blank" #assert (lon=="" or lon== None), "Long cannot be blank" for ts in datespan(start_time, end_time, delta=timedelta(minutes=5)): aqf = AQFeed() aqf.imei=imei aqf.name=name aqf.humidity = random.random(1,100) + random.random() aqf.temperature = random.random(15,45) + random.random() aqf.pm10 = random.random(1,500) + random.random() aqf.pm25 = random.random(1,1000) + random.random() aqf.count_large = random.triangular(1,500) + random.random() aqf.count_small = random.triangular(1,900) + random.random() aqf.lat = lat aqf.lon = lon aqf.created_on=ts aqf.save() except: print "Usage::" print "generate_random_data(start_date, end_date, imei, name, lat, lon)" print "Format of dates must be as :: YYYY-MM-DD-HH-MM " return
def genetic(n, popsize=None, rate=0.5): if popsize is None: popsize = 2 * n if rate is None: rate = random.random() m = int(rate * popsize) population = [] for i in range(popsize): population.append(Chromosome(n)) population.sort() generations = 0 while not is_solution(population[0]): del population[-m:] for i in range(math.floor(m / 2) if len(population) > 1 else 0): j = int(random.triangular(0, len(population) - 1, 0)) k = int(random.triangular(j + 1, len(population), j + 1)) # triangular distribution is biased toward low end chrom1, chrom2 = crossover(population[j], population[k]) bisect.insort(population, chrom1) bisect.insort(population, chrom2) for i in range(math.ceil(m / 2) if len(population) > 1 else m): j = int(random.triangular(0, len(population), 0)) bisect.insort(population, mutate(population[j])) generations += 1 return True, population[0]
def create_sub_strands(splines, points=None): new_splines = [] if not points: resolution_points = [curve_tools.get_nurbs_points(spline) for spline in splines] else: resolution_points = points for _ in range(0, len(resolution_points), 2): # Pick a random spline to start from spline1 = random.choice(resolution_points) # Pick a random spline to end which is not the start spline for _ in range(9999): spline2 = random.choice(resolution_points) if not spline2 == spline1: break # Pick a random start point from spline1 start_index = int(random.triangular(0, len(spline1))) start_point = spline1[start_index] # Pick a ranomd end point from spline2 end_index = int(random.triangular(0, len(spline2))) end_point = spline2[end_index] # Create the mid point mid_point = start_point + (end_point - start_point) * 0.5 new_spline = (start_point, mid_point, end_point) # Drape the spline new_spline = drape_spline(new_spline) new_splines.append(new_spline) splines.append(new_spline) return new_splines
def partially_matched(parent1, parent2): """Return a new chromosome created via partially matched crossover (PMX). This is suitable for permutation encoded GAs. Partially matched crossover respects the absolute position of alleles. """ third = len(parent1) // 3 l1 = int(random.triangular(1, third, third * 2)) l2 = int(random.triangular(third, third * 2, len(parent1) - 1)) if l2 < l1: l1, l2 = l2, l1 matching = parent2[l1:l2] displaced = parent1[l1:l2] child = parent1[0:l1] + matching + parent1[l2:] tofind = [item for item in displaced if item not in matching] tomatch = [item for item in matching if item not in displaced] for k, v in enumerate(tofind): subj = tomatch[k] locus = parent1.index(subj) child[locus] = v return child
def write_songs(artist, song_list, parsed_url): length = len(song_list) count = 0 selected_indices = [] while count < length: # Find a random index from the song_list and ensure it is new. rand_idx = random.randint(0, length - 1) while rand_idx in selected_indices: rand_idx = random.randint(0, length - 1) song = song_list[rand_idx] song_path = os.path.join(DATA_PATH, artist) song_file_name = filey.scrub_file_name(song.name + SONG_EXT) if filey.already_exists(song_path, song_file_name): print "%s already exists. Continuing." % (song_file_name) else: # Be like human. sleep(random.triangular(4.8, 7.23, 12.4)) rand_int = random.randint(0, 10) if rand_int == 9: sleep(random.triangular(2.6, 10, 7)) song_data = get_song_lyrics(parsed_url, song.url) filey.write_to_file(song_path, song_file_name, song_data) selected_indices.append(rand_idx) count += 1
def _generate(self): self.card_list = [1] while sum(self.card_list) >= -150: bad_cards = [int(random.triangular(-1250, -450, -600)) for i in range(self.NUM_CARDS / 2)] good_cards = [int(random.triangular(250, 900, 300)) for i in range(self.NUM_CARDS / 2)] self.card_list = good_cards + bad_cards self.save()
def generate(self): y = int(random.triangular(100, self.height-300, self.height/2-100)) yield y dy = 0 for _ in range(self.width): dy += 1 if random.triangular(-3, 3, 0) > dy else -1 y = max(100, min(self.height-300, y+dy)) yield y
def updateActor(self, interval, world): """Update this smoke""" super(Smoke, self).updateActor(interval, world) # dx = random.triangular(*self.vx_range)*interval/1000.0 dy = random.triangular(*self.vy_range)*interval/1000.0 # self.move(dx, dy)
def get_location(radius=90): lng_min = longitude - radius / abs(math.cos(math.radians(latitude)) * 69) lng_max = longitude + radius / abs(math.cos(math.radians(latitude)) * 69) lat_min = latitude - (radius / 69) lat_max = latitude + (radius / 69) lng = random.triangular(lng_min, lng_max) lat = random.triangular(lat_min, lat_max) return [lng, lat]
def addRandomSpacesToString(self,maxNumSpaces,str): import random,math numSpaces=math.ceil(random.triangular(1,maxNumSpaces)) i = 0 while(i<numSpaces): pos = math.ceil(random.triangular(1,len(str))) str = str[:pos] + " " + str[pos:] i+=1 return str
def render(self): glClear(GL_COLOR_BUFFER_BIT) glLoadIdentity() with engine_lock: self.scope.request_update() for note in midi_engine.notes.itervalues(): if not hasattr(note, 'firefly'): note.firefly = { 'pos': [note.midipitch - 21, 0, 0], 'xvel': random.triangular(-1, 1), 'yvel': random.triangular(-1, 1), 'size': 8 * note.volume**2.5 + 0.5, } self.notes.append(note) prev_notes = self.notes_by_midipitch[note.midipitch] if prev_notes: for n in prev_notes[1:]: n.weight *= prev_notes[0].weight prev_notes.insert(0, note) self.note_density += 1 for n in reversed(self.notes): (color, norm_weight) = self.scope.get_note_color(n) pressed_note = self.notes_by_midipitch[n.midipitch][0] if n is pressed_note: if norm_weight > 1: color = apply_whitening_bonus(color, norm_weight) alpha = min(norm_weight, 1.0) else: alpha = n.weight * pressed_note.weight for i in range(3): self.colors.data[:38,i].fill(color[i]) remaining = max(0.001, 1 - n.firefly['pos'][1] / self.height) self.colors.data[:19,3].fill(alpha**0.33/3)#(alpha ** 0.33 + remaining) / 2) #self.colors.data[19:38,3].fill(0)#(alpha ** 0.5 * 0.1 + remaining**3) / 5) self.colors.data[38,3] = alpha ** 0.33 * 0.25 + 0.75 self.colors.set_array(self.colors.data) with translated(*n.firefly['pos']): with scaled(n.firefly['size'] * (remaining * max(0.05, alpha))**0.1): with self.verts: glVertexPointer(3, GL_FLOAT, 0, self.verts) with self.colors: glColorPointer(4, GL_FLOAT, 0, self.colors) with self.indices: glDrawElements(GL_TRIANGLES, 3*3*19, GL_UNSIGNED_INT, None) elapsed = self.scope.frame_elapsed self.note_density *= math.exp(-elapsed) # ranges from 0 to 20 for n in self.notes: n.firefly['xvel'] += random.triangular(-0.5, 0.5) * elapsed n.firefly['xvel'] = min(5, max(-5, n.firefly['xvel'])) n.firefly['yvel'] += random.triangular(-0.5, 0.5) * elapsed n.firefly['yvel'] = min(5, max(-5, n.firefly['yvel'])) n.firefly['pos'][0] += n.firefly['xvel'] * elapsed n.firefly['pos'][1] += (4 + 2.5*math.log1p(self.note_density) + n.firefly['yvel']) * elapsed remove = [n for n in self.notes if n.firefly['pos'][1] - n.firefly['size'] > self.height] for n in remove: self.notes.remove(n) self.notes_by_midipitch[n.midipitch].remove(n)
def do_damage(self,Enemy): if self.sword==True: damage_player=int(random.triangular(7,10)) #random.triangular c'est fantastique, la proba du médian est supérieur à la proba des extrémités Enemy.hp -= damage_player return Enemy.hp else: damage_player=int(random.triangular(3,7)) Enemy.hp -= damage_player return Enemy.hp
def getRandomPosition(self): """ Return a random position inside the room. returns: a Position object. """ x = random.triangular(0, self.width - 1) y = random.triangular(0, self.height - 1) return Position(x, y)
def generateNextTarget(self): tgtID=self.count tgtIntelValue=random.triangular(1,100,60) tgtIntelPriority=tgtIntelValue if(self.Tartype==0): #want all Pedestrians tgtType='Pedestrian' tgtStealth=random.triangular(0.1, 0.9, 0.5) tgtSpeed=random.normalvariate(1.44, 0.288)#based on project 1 data elif(self.Tartype==1): #want all Vehicles tgtType='Vehicle' tgtStealth=random.triangular(0.5, 0.95, 0.8) tgtSpeed=random.triangular(11.11, 19.44, 15.28)#based on average urban speed for several countries else: r=random.random() if r<0.5: tgtType='Vehicle' tgtStealth=random.triangular(0.5, 0.95, 0.8) tgtSpeed=random.triangular(11.11, 19.44, 15.28)#based on average urban speed for several countries else: tgtType='Pedestrian' tgtStealth=random.triangular(0.1, 0.9, 0.5) tgtSpeed=random.normalvariate(1.44, 0.288)#based on project 1 data tgtPredLoc=self.randNodes[self.count] tgtGoalTrackTime=random.triangular(60,600,300) tgtActualTrackTime=0 tgtTrackAttempts=0 self.currTargetTimestamp=self.currTargetTimestamp+random.triangular(1380,4200,2100) tgtData = [tgtID,tgtIntelValue,tgtIntelPriority,tgtType,tgtStealth,tgtSpeed,tgtPredLoc,tgtGoalTrackTime,tgtActualTrackTime,tgtTrackAttempts] self.targetTimestamps.append(self.currTargetTimestamp) self.targets[self.currTargetTimestamp] = tgtData self.count = self.count + 1
# The end-point value b may or may not be included in the range depending on floating-point rounding in the equation a + (b-a) * random(). a = 1 b = SAMPLE_SIZE res = [] for _ in xrange(1, SAMPLE_SIZE): res.append(random.uniform(a, b)) plt.hist(res, buckets) plt.subplot(623) plt.xlabel("random.triangular") # Return a random floating point number N such that low <= N <= high and with the specified mode between those bounds. The low and high bounds default to zero and one. The mode argument defaults to the midpoint between the bounds, giving a symmetric distribution. low = 1 high = SAMPLE_SIZE res = [] for _ in xrange(1, SAMPLE_SIZE): res.append(random.triangular(low, high)) plt.hist(res, buckets) plt.subplot(624) plt.xlabel("random.betavariate") # Beta distribution. Conditions on the parameters are alpha > 0 and beta > 0. Returned values range between 0 and 1. alpha = 1 beta = 10 res = [] for _ in xrange(1, SAMPLE_SIZE): res.append(random.betavariate(alpha, beta)) plt.hist(res, buckets) plt.subplot(625) plt.xlabel("random.expovariate") # Exponential distribution. lambd is 1.0 divided by the desired mean. It should be nonzero. (The parameter would be called “lambda”, but that is a reserved word in Python.) Returned values range from 0 to positive infinity if lambd is positive, and from negative infinity to 0 if lambd is negative.
blens = [] blens += [beat * 0.25] * 5 blens += [beat * 0.5] * 25 blens += [beat] * 25 random.seed(1992) drift = 0 while pos < tlength: length = random.choice(blens) freqs = get_freqs(count // 3) params = [] reps = random.choice([1,2,3,4,8]) dist = random.choice(blens) / reps for _ in range(reps): freq = freqs[(count2 // random.randint(1,3)) % len(freqs)] * 2**random.randint(0, 3) amp = random.triangular(0.05, 0.15) note = make_note(freq, amp, length) out.dub(note, pos) count2 += 1 pos += dist + drift drift += random.triangular(-0.002, 0.005) count += 1 out.write('%s/osc2d_out.wav' % PATH) elapsed_time = time.time() - start_time print('Render time: %s seconds' % round(elapsed_time, 2)) print('Output length: %s seconds' % out.dur)
# depending on floating-point rounding in the equation a + (b-a)*random() a = 1 b = SAMPLE_SIZE res = [random.uniform(a, b) for _ in range(1, SAMPLE_SIZE)] plt.hist(res, buckets) plt.subplot(623) plt.xlabel("random.triangular") # Return a random floating point number N such that low <= N <= high # and with the specified mode between those bounds # The low and high bounds default to zero and one # The mode argument defaults to the midpoint between the bounds, giving # a symmetric distribution low = 1 high = SAMPLE_SIZE res = [random.triangular(low, high) for _ in range(1, SAMPLE_SIZE)] plt.hist(res, buckets) plt.subplot(624) plt.xlabel("random.betavariate") alpha = 1 beta = 10 res = [random.betavariate(alpha, beta) for _ in range(1, SAMPLE_SIZE)] plt.hist(res, buckets) plt.subplot(625) plt.xlabel("random.expovaraite") lambd = 1.0 / ((SAMPLE_SIZE + 1) / 2.) res = [random.expovariate(lambd) for _ in range(1, SAMPLE_SIZE)] plt.hist(res, buckets)
def _build_main_request(self, subrequests, player_position=None): self.log.debug('Generating main RPC request...') request = RequestEnvelope() request.status_code = 2 request.request_id = self.get_rpc_id() request.accuracy = random.choice( (5, 5, 5, 5, 10, 10, 10, 30, 30, 50, 65, random.uniform(66, 80))) if player_position: request.latitude, request.longitude, altitude = player_position # generate sub requests before Signature generation request = self._build_sub_requests(request, subrequests) ticket = self._auth_provider.get_ticket() if ticket: self.log.debug( 'Found Session Ticket - using this instead of oauth token') request.auth_ticket.expire_timestamp_ms, request.auth_ticket.start, request.auth_ticket.end = ticket ticket_serialized = request.auth_ticket.SerializeToString() else: self.log.debug( 'No Session Ticket found - using OAUTH Access Token') request.auth_info.provider = self._auth_provider.get_name() request.auth_info.token.contents = self._auth_provider.get_access_token( ) request.auth_info.token.unknown2 = self.token2 ticket_serialized = request.auth_info.SerializeToString( ) #Sig uses this when no auth_ticket available sig = Signature() sig.session_hash = self.session_hash sig.timestamp = get_time(ms=True) sig.timestamp_since_start = get_time(ms=True) - RpcApi.START_TIME if sig.timestamp_since_start < 5000: sig.timestamp_since_start = random.randint(5000, 8000) self._hash_engine.hash(sig.timestamp, request.latitude, request.longitude, request.accuracy, ticket_serialized, sig.session_hash, request.requests) sig.location_hash1 = self._hash_engine.get_location_auth_hash() sig.location_hash2 = self._hash_engine.get_location_hash() for req_hash in self._hash_engine.get_request_hashes(): sig.request_hash.append(ctypes.c_uint64(req_hash).value) loc = sig.location_fix.add() sen = sig.sensor_info.add() sen.timestamp_snapshot = random.randint( sig.timestamp_since_start - 5000, sig.timestamp_since_start - 100) loc.timestamp_snapshot = random.randint( sig.timestamp_since_start - 5000, sig.timestamp_since_start - 1000) loc.provider = random.choice( ('network', 'network', 'network', 'network', 'fused')) loc.latitude = request.latitude loc.longitude = request.longitude loc.altitude = altitude or random.triangular(300, 400, 350) if random.random() > .95: # no reading for roughly 1 in 20 updates loc.course = -1 loc.speed = -1 else: self.course = random.triangular(0, 360, self.course) loc.course = self.course loc.speed = random.triangular(0.2, 4.25, 1) loc.provider_status = 3 loc.location_type = 1 if request.accuracy >= 65: loc.vertical_accuracy = random.triangular(35, 100, 65) loc.horizontal_accuracy = random.choice( (request.accuracy, 65, 65, random.uniform(66, 80), 200)) else: if request.accuracy > 10: loc.vertical_accuracy = random.choice( (24, 32, 48, 48, 64, 64, 96, 128)) else: loc.vertical_accuracy = random.choice((3, 4, 6, 6, 8, 12, 24)) loc.horizontal_accuracy = request.accuracy sen.linear_acceleration_x = random.triangular(-3, 1, 0) sen.linear_acceleration_y = random.triangular(-2, 3, 0) sen.linear_acceleration_z = random.triangular(-4, 2, 0) sen.magnetic_field_x = random.triangular(-50, 50, 0) sen.magnetic_field_y = random.triangular(-60, 50, -5) sen.magnetic_field_z = random.triangular(-60, 40, -30) sen.magnetic_field_accuracy = random.choice((-1, 1, 1, 2, 2, 2, 2)) sen.attitude_pitch = random.triangular(-1.5, 1.5, 0.2) sen.attitude_yaw = random.uniform(-3, 3) sen.attitude_roll = random.triangular(-2.8, 2.5, 0.25) sen.rotation_rate_x = random.triangular(-6, 4, 0) sen.rotation_rate_y = random.triangular(-5.5, 5, 0) sen.rotation_rate_z = random.triangular(-5, 3, 0) sen.gravity_x = random.triangular(-1, 1, 0.15) sen.gravity_y = random.triangular(-1, 1, -.2) sen.gravity_z = random.triangular(-1, .7, -0.8) sen.status = 3 sig.unknown25 = 5348175887752539474 if self.device_info: for key in self.device_info: setattr(sig.device_info, key, self.device_info[key]) if self.device_info['device_brand'] == 'Apple': sig.activity_status.stationary = True else: sig.activity_status.stationary = True signature_proto = sig.SerializeToString() try: if request.requests[0].request_type in ( RequestType.Value('GET_MAP_OBJECTS'), RequestType.Value('GET_PLAYER')): plat_eight = UnknownPtr8Request() plat_eight.message = '15c79df0558009a4242518d2ab65de2a59e09499' plat8 = request.platform_requests.add() plat8.type = 8 plat8.request_message = plat_eight.SerializeToString() except (IndexError, AttributeError): pass sig_request = SendEncryptedSignatureRequest() sig_request.encrypted_signature = pycrypt(signature_proto, sig.timestamp_since_start) plat = request.platform_requests.add() plat.type = 6 plat.request_message = sig_request.SerializeToString() request.ms_since_last_locationfix = int( random.triangular(300, 30000, 10000)) self.log.debug('Generated protobuf request: \n\r%s', request) return request
def gerar_dados_aleatorios(): global VEL, APPS, TM, IMD, BMS, BSPD, PRESS1, HV sinal = [("0", 1), ("1", 50)] list = [prize for prize, weight in sinal for i in range(weight)] bateria = 100 temperatura = random.uniform(24,25) vel = 40 pressao = 5 while 1: # Dados de dois estados dos componentes do Shutdown IMD = random.choice(list) BMS = random.choice(list) BSPD = random.choice(list) # Dados do nível da bateria do HV aux1 = random.randrange(2) bateria = bateria - aux1 if bateria > 0 : HV = bateria else: HV = 0 # Dados da temperatura do motor aux2= random.random() temperatura = temperatura + aux2/2 if temperatura < 60: TM = temperatura else: TM = 60 # Dados da velocidade aux3=random.triangular(-3,3,0) vel = vel + aux3 if 0 < vel < 90: VEL = vel # Dados das Pressões no fluido de freio aux4 = random.uniform(-3,3) pressao = pressao + aux4 if 0 < pressao <= 80: PRESS1 = pressao if -2 < pressao < 0: PRESS1 = PRESS2 = random.uniform(60,70) if -4 < pressao < -2: PRESS1 = PRESS2 = random.uniform(0,3) if pressao <= -4: PRESS1 = PRESS2 = random.uniform(50,70) if pressao > 80: PRESS1 = PRESS2 = random.uniform(0,10) if 0 < pressao < 2: PRESS2 = pressao if 2 <= pressao < 10: PRESS2 = pressao - random.random() if 10 <= pressao <= 80: PRESS2 = pressao - random.uniform(0,5) APPS = (PRESS1 + PRESS2) /2 * 1.25 print(VEL)
def service(self, patient): service_time = random.triangular(8, 20, 12) yield self.env.timeout(service_time) print("Imaging service started for patient %s." % (patient))
def _build_main_request(self, subrequests, platforms, player_position=None): self.log.debug('Generating main RPC request...') request = RequestEnvelope() request.status_code = 2 request.request_id = self.request_id # 5: 43%, 10: 30%, 30: 5%, 50: 4%, 65: 10%, 200: 1%, float: 7% request.accuracy = weighted_choice([(5, 43), (10, 30), (30, 5), (50, 4), (65, 10), (200, 1), (random.uniform(65, 200), 7)]) if player_position: request.latitude, request.longitude, altitude = player_position # generate sub requests before Signature generation request = self._build_sub_requests(request, subrequests) request = self._build_platform_requests(request, platforms) ticket = self._auth_provider.get_ticket() if ticket: self.log.debug( 'Found Session Ticket - using this instead of oauth token') request.auth_ticket.expire_timestamp_ms, request.auth_ticket.start, request.auth_ticket.end = ticket ticket_serialized = request.auth_ticket.SerializeToString() else: self.log.debug( 'No Session Ticket found - using OAUTH Access Token') auth_provider = self._auth_provider request.auth_info.provider = auth_provider.get_name() request.auth_info.token.contents = auth_provider.get_access_token() request.auth_info.token.unknown2 = self.token2 # Sig uses this when no auth_ticket available. ticket_serialized = request.auth_info.SerializeToString() sig = Signature() sig.session_hash = self.state.session_hash sig.timestamp = get_time(ms=True) sig.timestamp_since_start = get_time(ms=True) - self.start_time self._hash_engine.hash(sig.timestamp, request.latitude, request.longitude, request.accuracy, ticket_serialized, sig.session_hash, request.requests) sig.location_hash1 = self._hash_engine.get_location_auth_hash() sig.location_hash2 = self._hash_engine.get_location_hash() for req_hash in self._hash_engine.get_request_hashes(): sig.request_hash.append(ctypes.c_uint64(req_hash).value) loc = sig.location_fix.add() sen = sig.sensor_info.add() sen.timestamp_snapshot = sig.timestamp_since_start - int( random.triangular(93, 4900, 3000)) loc.timestamp_snapshot = sig.timestamp_since_start - int( random.triangular(320, 3000, 1000)) loc.provider = 'fused' loc.latitude = request.latitude loc.longitude = request.longitude loc.altitude = altitude or random.uniform(150, 250) if random.random() > .85: # no reading for roughly 1 in 7 updates loc.course = -1 loc.speed = -1 else: loc.course = self.state.course loc.speed = random.triangular(0.25, 9.7, 8.2) loc.provider_status = 3 loc.location_type = 1 if isinstance(request.accuracy, float): loc.horizontal_accuracy = weighted_choice([(request.accuracy, 50), (65, 40), (200, 10)]) loc.vertical_accuracy = weighted_choice([(random.uniform(10, 96), 50), (10, 34), (12, 5), (16, 3), (24, 4), (32, 2), (48, 1), (96, 1)]) else: loc.horizontal_accuracy = request.accuracy if request.accuracy >= 10: loc.vertical_accuracy = weighted_choice([(6, 4), (8, 34), (10, 35), (12, 11), (16, 4), (24, 8), (32, 3), (48, 1)]) else: loc.vertical_accuracy = weighted_choice([(3, 15), (4, 39), (6, 14), (8, 13), (10, 14), (12, 5)]) sen.magnetic_field_accuracy = weighted_choice([(-1, 8), (0, 2), (1, 42), (2, 48)]) if sen.magnetic_field_accuracy == -1: sen.magnetic_field_x = 0 sen.magnetic_field_y = 0 sen.magnetic_field_z = 0 else: sen.magnetic_field_x = self.state.magnetic_field_x sen.magnetic_field_y = self.state.magnetic_field_y sen.magnetic_field_z = self.state.magnetic_field_z sen.linear_acceleration_x = random.triangular(-1.5, 2.5, 0) sen.linear_acceleration_y = random.triangular(-1.2, 1.4, 0) sen.linear_acceleration_z = random.triangular(-1.4, .9, 0) sen.attitude_pitch = random.triangular(-1.56, 1.57, 0.475) sen.attitude_yaw = random.triangular(-1.56, 3.14, .1) sen.attitude_roll = random.triangular(-3.14, 3.14, 0) sen.rotation_rate_x = random.triangular(-3.2, 3.52, 0) sen.rotation_rate_y = random.triangular(-3.1, 4.88, 0) sen.rotation_rate_z = random.triangular(-6, 3.7, 0) sen.gravity_x = random.triangular(-1, 1, 0.01) sen.gravity_y = random.triangular(-1, 1, -.4) sen.gravity_z = random.triangular(-1, 1, -.4) sen.status = 3 sig.unknown25 = 0x4AE22D4661C83701 if self.device_info: for key in self.device_info: setattr(sig.device_info, key, self.device_info[key]) if self.device_info['device_brand'] == 'Apple': sig.activity_status.stationary = True else: sig.activity_status.stationary = True signature_proto = sig.SerializeToString() if self._needsPtr8(subrequests): plat_eight = UnknownPtr8Request() plat_eight.message = '15c79df0558009a4242518d2ab65de2a59e09499' plat8 = request.platform_requests.add() plat8.type = 8 plat8.request_message = plat_eight.SerializeToString() sig_request = SendEncryptedSignatureRequest() sig_request.encrypted_signature = pycrypt(signature_proto, sig.timestamp_since_start) plat = request.platform_requests.add() plat.type = 6 plat.request_message = sig_request.SerializeToString() request.ms_since_last_locationfix = sig.timestamp_since_start - loc.timestamp_snapshot self.log.debug('Generated protobuf request: \n\r%s', request) return request
def test_mul(self): t = self.random_time() i = random.randint(1, 1000) self.assertEqual(t * i, sf.Time(microseconds=t.as_microseconds() * i)) f = random.triangular(0.0, 100.0) self.assertEqual(t * f, sf.Time(seconds=t.as_seconds() * f))
def test_div(self): t = self.random_time() i = random.randint(1, 1000) self.assertEqual(t / i, sf.Time(microseconds=t.as_microseconds() / i)) f = random.triangular(0.0, 100.0) self.assertEqual(t / f, sf.Time(seconds=t.as_seconds() / f))
def triangular_sample(n): return [random.triangular(0, 100) for i in range(n)]
#!/usr/bin/env python # simple script emulating an executor generating benchmark results from __future__ import print_function import sys import random print(sys.argv) print("Harness Name: ", sys.argv[1]) print("Bench Name:", sys.argv[2]) print("Warmup: ", sys.argv[3]) WARMUP = int(sys.argv[3]) for i in range(0, WARMUP): print("RESULT-total: ", random.triangular(700, 850) * 2) print("RESULT-total: ", random.triangular(700, 850))
def _create_creature_pos(self): x = random.triangular(0, self.world.size) y = random.triangular(0, self.world.size) return int(x), int(y)
def triangular_random(length): return triangular(0, length, length)
def main(): count = 0 kafka_topic = re.sub('[^a-zA-Z0-9]', '_', channel) kafka_producer = kafka.KafkaProducer(bootstrap_servers=kafka_endpoint) print('[ INFO ] Using Kafka Topic = ' + str(kafka_topic)) time.sleep(5) if simulate_feed == False: from satori.rtm.client import make_client, SubscriptionMode with make_client(endpoint=endpoint, appkey=appkey) as client: class SubscriptionObserver(object): def on_subscription_data(self, data): for message in data['messages']: message['_timestamp'] = int(time.time()) kafka_producer.send(kafka_topic, bytes(json.dumps(message))) count += 1 subscription_observer = SubscriptionObserver() client.subscribe(channel, SubscriptionMode.SIMPLE, subscription_observer) try: while True: time.sleep(1) print("Messages sent to Kafka: " + str(count)) except KeyboardInterrupt: pass elif simulate_feed == True: while True: time.sleep(1) # Simulate Data Feed datetimestamp = datetime.datetime.now() payload = random.choice([ { "cryptocurrency": "BTC", "name": "bitcoin", "price": round(random.triangular(7000, 13000, 9282), 2) }, { "cryptocurrency": "BCH", "name": "bitcoin cash", "price": round(random.triangular(400, 800, 650), 2) }, { "cryptocurrency": "ETH", "name": "ethereum", "price": round(random.triangular(400, 800, 650), 2) }, { "cryptocurrency": "LTC", "name": "litecoin", "price": round(random.triangular(1200, 1600, 1400), 2) }, ]) message = { "exchange": random.choice( ['Coinbase', 'Coinmama', 'Bitpanda', 'Kraken', 'cex.io']), "cryptocurrency": payload['cryptocurrency'], "basecurrency": "USD", "type": "market", "price": payload['price'], "size": random.randint(1, 100), "bid": round(payload['price'] * random.triangular(0.95, 1, 0.98), 2), "ask": round(payload['price'] * random.triangular(1, 1.05, 1.1), 2), "open": round(payload['price'] * random.triangular(0.95, 1.05, 1), 2), "high": round(payload['price'] * random.triangular(0.95, 1.05, 1), 2), "low": round(payload['price'] * random.triangular(0.95, 1.05, 1), 2), "volume": random.randint(1, 10000), "_timestamp": int(time.time()), "timestamp": datetimestamp.strftime('%Y-%m-%dT%H:%M:%S.%fZ') } kafka_producer.send(kafka_topic, json.dumps(message).encode('utf-8')) count += 1 print("Messages sent to Kafka: " + str(count)) print(json.dumps(message)) else: print( '[ ERROR ] Simulate_feed variable may not set and also check to make sure Kafka host and port are correct.' ) sys.exit()
def get_index(num_samples): return int((num_samples * DIFF_POS) + random.triangular(-RAND_DIFF_WIDTH, RAND_DIFF_WIDTH))
def random_transform(self): return sf.Transform(*[random.triangular(0.0, 5.0) for i in range(9)])
def populate(num_rats, min_wt, max_wt, mode_wt): """Initialize a population with a triangular distribution of weights.""" return [int(random.triangular(min_wt, max_wt, mode_wt))\ for i in range(num_rats)]
def random_rect(self): return sf.FloatRect(random.triangular(0.0, 100.0), random.triangular(0.0, 100.0), random.triangular(0.0, 100.0), random.triangular(0.0, 100.0))
def service(self, patient): service_time = random.triangular(4, 10, 6) yield self.env.timeout(service_time) print("Lab service started for patient %s." % (patient))
def randomORF(length, maxlength=None): length -= 2 if maxlength and maxlength > length: length = int(round(random.triangular(length, maxlength - 2))) cdns = ( "TTT", "TTC", "TTA", "TTG", "TCT", "TCC", "TCA", "TCG", "TAT", "TAC", "TGT", "TGC", "TGG", "CTT", "CTC", "CTA", "CTG", "CCT", "CCC", "CCA", "CCG", "CAT", "CAC", "CAA", "CAG", "CGT", "CGC", "CGA", "CGG", "ATT", "ATC", "ATA", "ATG", "ACT", "ACC", "ACA", "ACG", "AAT", "AAC", "AAA", "AAG", "AGT", "AGC", "AGA", "AGG", "GTT", "GTC", "GTA", "GTG", "GCT", "GCC", "GCA", "GCG", "GAT", "GAC", "GAA", "GAG", "GGT", "GGC", "GGA", "GGG", ) starts = ("ATG", ) stops = ("TAA", "TAG", "TGA") return (random.choice(starts) + "".join([random.choice(cdns) for x in range(length)]) + random.choice(stops))
def course(self): self._course = random.triangular(0, 359.99, self._course) return self._course
def crossover_triangular(xs, ys): return [ random.triangular(low=min(x, y), high=max(x, y)) for x, y in zip(xs, ys) ]
def randomDNA(length, maxlength=None): """ string! """ if maxlength and maxlength > length: length = int(round(random.triangular(length, maxlength))) return "".join([random.choice("GATC") for x in range(length)])
assert x1 == x2 tries = 8000 stat = [0, 0, 0, 0, 0, 0] for i in range(tries): dice = random.randint(1, 6) stat[dice - 1] += 1 print("STATISTICS ON {0} DICE THROWS".format(tries)) print("-----------------------------") for i in range(0, 6): percent = (float(stat[i]) * 100.) / float(tries) print("{0} : {1} ({2:.1f}%)".format(i + 1, stat[i], percent)) random.triangular(10, 20, 17) random.normalvariate(10, 4) random.lognormvariate(3, 1.6) random.expovariate(3) random.vonmisesvariate(2, 1) random.gauss(10, 4) random.betavariate(10, 4) random.paretovariate(5) random.weibullvariate(10, 6) # issue 169 first = list(range(20)) random.seed(31416) random.shuffle(first) second = list(range(20)) random.seed(31416)
import uuid import random import datetime import time services = [] clients = [] for i in range(0, 20): services.append(uuid.uuid4()) for i in range(0, 100): clients.append('.'.join('%s' % random.randint(0, 255) for i in range(4)) + "," + str(uuid.uuid4())) print "client-address,client-guid,request-time,service-guid,retries-request,packets-requested,packets-serviced,max-hole-size" for i in range(0, 300): #print str(random.choice(clients)) + "," + (datetime.datetime.now() + datetime.timedelta(seconds=random.randint(0, 86400))).strftime("%Y-%m-%d %H:%M:%S ADT") + "," + str(random.choice(services)) \ print str(random.choice(clients)) + "," + str(int(time.mktime((datetime.datetime.now() + datetime.timedelta(seconds=random.randint(0, 86400))).timetuple()))*1000 + random.randint(0,999)) + "," + str(random.choice(services)) \ + "," + str(int(random.triangular(0, 10, 7))) + "," + str(int(random.triangular(0, 20, 15))) + "," + str(int(random.triangular(0, 20, 15))) + "," + str(int(random.triangular(0, 20, 15)))
def make_wavetable(): wtsize = random.randint(2, random.randint(3, 50)) wavetable = [0] + [random.triangular(-1, 1) for _ in range(wtsize - 2)] + [0] return wavetable
def r(): return random.triangular(0.0, 100.0)
# -*- encoding: utf-8 -*- import random print(random.seed()) print(random.random()) # 0~1 print(random.uniform(10, 1)) # same as print(random.uniform(1,10) print(random.randint(1, 10)) # [1, 10] print(random.randrange(1, 10)) # [1,10) print(random.triangular(0, 10, 3)) # 三角分布 print(random.gauss(5, 10)) # 高斯分布 print(random.betavariate(2, 5)) # beta β分布 print(random.expovariate(10)) # 指数分布 print(random.gammavariate(5, 10)) # 伽马分布 print(random.lognormvariate(5, 10)) # 对数正态分布 print(random.normalvariate(5, 10)) # 正态分布 print(random.vonmisesvariate(2, 5)) # 冯米塞斯分布 print(random.paretovariate(2)) # 帕累托分布 print(random.weibullvariate(2, 5)) # 韦伯分布 li = [random.randint(1, 100) for x in range(0, 10)] print(li) random.shuffle(li) # return None print(li) print(random.choice(li)) print(random.choices(li, weights=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k=3)) # same as print(random.choices(li,cum_weights=[1,3,6,10,15,21,28,36,45,55],k=3)) # means li[0] has 1/55 probability to be selected, etc print(random.sample(li, 3))
def make_note(freq, amp, length): lfo = dsp.SINE lfo_freq = random.triangular(0.001, 15) # Frequency modulation wavetable mod = wavetables.randline(random.randint(10, 30)) # Frequency of the freq mod wavetable mod_freq = random.triangular(0.001, 2) # Range / depth of the freq mod wavetable mod_range = random.triangular(0, 0.025) pulsewidth = random.random() # Fill up a stack of wavetables to give to the Osc. # The lfo wavetable above will control the morph position # in the wavetable stack during the render. stack = [] numtables = random.randint(3, 30) for _ in range(numtables): if random.random() > 0.25: stack += [ random.choice([dsp.SINE, dsp.TRI]) ] else: stack += [ wavetables.randline(random.randint(3, random.randint(5, 50))) ] # ADSR params a = random.triangular(0.1, 1) d = random.triangular(0.01, 3) s = random.triangular(0.03, 0.15) r = random.triangular(0.1, 10) # Render a note note = oscs.Osc( stack=stack, window=dsp.SINE, mod=mod, pulsewidth=pulsewidth, mod_freq=mod_freq, mod_range=mod_range, lfo=lfo, lfo_freq=lfo_freq ).play(length=length, freq=freq, amp=amp).adsr(a=a,d=d,s=s,r=r) # Sometimes mix in a granulated layer of the note if random.random() > 0.75: a = random.triangular(5, 10) d = random.triangular(0.1, 20) s = random.triangular(0.01, 0.1) r = random.triangular(5, 10) minlength = (note.dur/50)*1000 maxlength = (note.dur/3)*1000 arp = note.cloud(length * random.triangular(1.5, 3), window=dsp.HANN, grainlength=wavetables.randline(random.randint(10, 100), lowvalue=minlength, highvalue=maxlength), spread=1, speed=random.choice([1, 1.5, 2]), jitter=random.triangular(0, 0.05), grid=wavetables.randline(random.randint(5, 50), lowvalue=0.1, highvalue=random.triangular(0.25, 0.75)), ).adsr(a,d,s,r) note.dub(arp, 0) return note
def make_wavetable(): wtsize = random.randint(2, random.randint(3, 50)) wavetable = [0] + [random.triangular(-1, 1) for _ in range(wtsize - 2)] + [0] return wavetable out = dsp.buffer() chords = 'ii vi V7 I69' dubhead = 0 for chord in chords.split(' ') * 8: chordlength = random.triangular(2, 3) # in seconds freqs = tune.chord(chord, key='e', octave=2) numnotes = random.randint(3, 6) notes = [] for _ in range(numnotes): notelength = random.triangular(0.1, 2) freq = random.choice(freqs) amp = random.triangular(0.1, 0.25) note = oscs.Osc(wavetable=make_wavetable()).play(notelength, freq, amp) note = note.env(dsp.RND) note = note.taper(0.01) note = note.pan(random.random())