def game_run(): global choice choice = { 0:" ",1:" ",2:" " } global seq os.system('clear') print "Welcome to The Monty Hall Show!!" print "There are three blocks named 'A', 'B' and 'C'\n" dum = raw_input("") print "There are three objects behind the blocks, but only one of the object is precious!!\n" dum = raw_input("") print "First you have to choose a block, then I ( Monty Hall) am going to show you one of the block where the non-precious object is present leaving you another chance of whether to switch or stick\n" dum = raw_input("") print "You have all freedom to either switch or stick to your first choice\n" dum = raw_input("") print "Shall we start the game then\n" dum = raw_input("") seq = init() key = read_in() dum = raw_input("Well.. You have made a choice.. Now you'll see a sheep block among the other two which you did not choose.. Again you will be given a chance of choice between the rest.. Lets see it") choice = MontyH.to_show(choice,seq,key) Draw.display(choice) x = raw_input("Do you want to switch your choice ?( Y for yes and any other key to continue with the same choice )") if ( x == 'Y' ): key = read_in() disclose(key) else: disclose(key)
def first_fit(): for each in Processes_Objects: allocator(Holes_Objects, each, 'f') fix_holes() if Graph: Draw.draw_graph(Holes_Objects, Processes_Objects, Block_List) show_progress(Holes_Objects)
def init_game(): global matrix u1c = 'X'; u2c = 'O' os.system('clear') print "Tic Tac Toe is a two player game. A borad will be shown to you. You need to choose a box where you want to put your sign. You can choose a box as 1,1 for the first box and 1,2 for the second box in first row.\n" print "Program will ask for input from the user specifically.\n" x = raw_input("Shall we start ??") os.system('clear') user1 = raw_input("Player 1: Enter your name:\t") x = raw_input("REMEMBER:\tYour sign is %c\n\n"%(u1c)) os.system('clear') user2 = raw_input("Player 2: Enter your name:\t") x = raw_input("REMEMBER:\tYour sign is %c\n\n"%(u2c)) os.system('clear') x = raw_input("Good Luck %s and %s..\n"%(user1,user2)) os.system('clear') n = 3 Draw.write_board(n) matrix = Draw.init_mat() if ( game_proc(user1,user2,n) == True ): choice = { 1:user1, 2:user2 } print "Nice moves by both %s and %s, let's see the result\n"%(user1,user2) x = raw_input("Shall We ??\n") wval = Winner.find_winner(matrix) if ( wval in choice ): print "Player %s wins!!"%(choice.get(wval)) else: print "It's a TIE!!"
def deallocate(pid): """ :param pid: Integer -> PID of process to be de-allocated """ global Processes_Objects to_be_deleted = None for each in Processes_Objects: # Found the process if pid is each.pid: # Get the hole the process is currently allocated to hole_pid = each.allocated_to.pid # Deallocate the process each.deallocate() to_be_deleted = each # Merge the hole if hole_pid + 1 <= Hole.Hole.count: merge(hole_pid, hole_pid + 1) if to_be_deleted is not None: Processes_Objects.remove(to_be_deleted) fix_holes() if Graph: Draw.draw_graph(Holes_Objects, Processes_Objects, Block_List) show_progress(Holes_Objects)
def removeJob(self, removed_job_str): removed_job = getattr(self.jobs, removed_job_str) ## For now this is the solution, fill the entire screen. When the todo below is finished, ## I'll just fill the job instead. Draw.fillJob(self.screen, self.bgcolor, removed_job) for job in self.getJobsIn(removed_job_str): job.force_draw = True delattr(self.jobs, removed_job_str)
def disclose(key): global choice choice = MontyH.show_final(choice,seq) Draw.display(choice) if ( seq[key] == "GOLD" ): print "Woohoooo!! Congrats" else: print "Thank you for playing"
def main(): blnKNNTrainingSuccessful = DetectChars.loadKNNDataAndTrainKNN() # treniranje KNN-a if blnKNNTrainingSuccessful == False: # Ukoliko nije uspesno izvrseno treniranje vraca se poruka o tome print ("\nerror: KNN traning was not successful\n") return imgOriginalScene = cv2.imread("6.png") # otvaranje slike if imgOriginalScene is None: # ukoliko slika nije uspesno otvorena vraca se poruka o tome print("\nerror: image not read from file \n\n") os.system("pause") return possiblePlates = DetectPlates.detectPlatesInScene(imgOriginalScene) # detektovanje samih tablica possiblePlates = DetectChars.detectCharsInPlates(possiblePlates) # detektovanje karaktera na tablicama cv2.imshow("Original image", imgOriginalScene) if len(possiblePlates) == 0: print("\nno license plates were detected\n") else: possiblePlates.sort(key = lambda possiblePlate: len(possiblePlate.strChars), reverse = True) licPlate = possiblePlates[0] if len(licPlate.strChars) == 0: print("\nno characters were detected\n\n") return # end if Draw.drawRedRectangleAroundPlate(imgOriginalScene, licPlate) print("\nlicense plate read from image = " + licPlate.strChars + "\n") print("----------------------------------------") Draw.writeLicensePlateCharsOnImage(imgOriginalScene, licPlate) cv2.imshow("Result", imgOriginalScene) cv2.imwrite("result.png", imgOriginalScene) cv2.waitKey(0) return
def do(self, action, step, rainbow): if len(action) > 1: p = action[1] else: p = 1.0 self.timebuff += step cmd = action[0].lower() if cmd == "draw": if rainbow: self.incColor() if self.incThickYN: self.incThick(self.reverseThick, False) elif self.incThickYN: self.incThick(self.reverseThick, True) if self.timebuff > 1.0: truncate = int(self.timebuff) self.after(truncate, self.draw(float(p), True)) self.timebuff -= truncate else: self.draw(float(p)) elif cmd == "turn": Draw.turn(float(p)) elif cmd == "skip": Draw.skip(float(p)) elif cmd == "back": Draw.back(float(p)) elif cmd == "color": if not rainbow: self.color = Color.getHexString(p) elif cmd == "thick": self.thick = int(p) else: print("Unknown command " + cmd)
def drawAll(self, newWindow= True): if self.generated == True: self.butt_print.config(state= 'disabled') self.timebuff = 0.0 self.color = Color.white() self.thick = 2 l = float(self.slid_linesize.get()) a = float(self.slid_angle.get()) Draw.init(self.startingPoint, l, a) if self.fullScreen.get() == 1: if newWindow: self.curr_canvas = dc.BigCanvas(self).canvas self.canvas.delete("all") else: self.curr_canvas = self.canvas self.curr_canvas.delete("all") self.curr_canvas.config(bg= Color.getHexString(self.bgColor.get())) rainbow = self.rainbowCheck.get() == 1 if rainbow or self.incThickYN: self.incStep = 1.0/float(self.getDrawCount(self.output)) self.percent = 0.0 for c in self.output: if c == '[': Draw.push() elif c == ']': Draw.pop() else: for r in Rule.getDrawings(): if c == r[0]: if len(r) > 2: params = (r[1], r[2]) else: params = (r[1],) s = float(self.slid_timer.get()) self.do(params, s, rainbow) break self.butt_print.config(state= 'normal')
def twelveBitVolumeRender(): histogram = DataParse.loadStack(300, 200, 3000, mode="12bit") Draw.volumeRender(histogram, mode="greyscale", prune=0)
from ResetDeck import * # Imports the Reset function for Deck.txt from Draw import * # Imports the Draw class which allows us to draw cards from Deck.txt ResetDeck() # Resets Deck.txt to default Card=Draw() # Draws a card using the class Draw Card1=Card.Card # Turns the card drawn over to Card1 Card=Draw() Card2=Card.Card Card=Draw() Card3=Card.Card Card=Draw() Card4=Card.Card Card=Draw() Card5=Card.Card print([Card1,Card2,Card3,Card4,Card5]) # Prints the 5 cards drawn
def update_display(matrix,x,y,char): os.system('clear') Draw.update_mat(matrix,x,y,char) Draw.update_board(matrix)
def draw_weights(player, row, filename): weights = model.params[(player, "weights")].get_value() Draw.draw(weights[row], board_size, board_size, filename)
if not debug: inputData = True while inputData: print("Entrez les dimensions de la grille:") m = int(input("lignes: ")) n = int(input("colonnes : ")) if n > 0 and m > 0: inputData = False else: print( "Veuillez entrer des dimensions entières strictement positives." ) print("Soit " + str(n * m) + " intersections entre couloirs") d.drawGrid(n, m) corridorWidth = 0 while corridorWidth <= 0: corridorWidth = float(input("Largeur de couloir en mètres:")) print( "Entrez les coordonnées des points par lesquels le chariot doit passer. (0,0) représente l'intersection en bas à gauche, (0," + str(n - 1) + ") représente l'intersection en bas à droite.") print("Le premier point saisi sera le point de départ.") inputData = True breakPoints = [] while inputData: x = int(input("Abscisse: "))
def reset(self): #moves cars back to starting positions Draw.moveTo(self.__draw, self.__x, self.__y)
def fourChannelDraw(): histogram = DataParse.fourChannelTest() Draw.fourChannelDraw(histogram)
def showQuestionBox( question, y ): #this function shows the lie/fact in the right location to the client Draw.setColor(Draw.WHITE) Draw.filledRect(0, y, 6000, 100) Draw.setColor(Draw.BLACK) Draw.setFontSize(15) Draw.setFontBold(True) Draw.string(question, 10, y + 45)
def oneRoundOfQuestions(listFacts, listLies, list_QuestionsAskedAlready): Draw.clear() Draw.setColor(Draw.BLACK) Draw.setFontSize(28) Draw.string("Choose the fact that you think is false", 180, 20) #instructions #No fact or lie should be repeated throughout one game fact1 = choosingAQuestion(listFacts, list_QuestionsAskedAlready) #fact 1 fact2 = choosingAQuestion(listFacts, list_QuestionsAskedAlready) #fact 2 lie = choosingAQuestion(listLies, list_QuestionsAskedAlready) #lie combined = [fact1, fact2, lie] random.shuffle( combined ) #shuffles the options so the lie isn't in the same place each time showQuestionBox(combined[0], 100) #shows client first choice showQuestionBox(combined[1], 300) #shows client second choice showQuestionBox(combined[2], 500) #shows client third choice validClick = False while validClick == False: while not Draw.mousePressed(): #wait until client clicks pass y = Draw.mouseY( ) #find the y location of the mouse click. depending on where it is choose that box or do nothing until they click on a box if y >= 100 and y <= 200: #this means the client chose the first choice result = choosingAnAnswer( combined[0], lie ) #result equals the return of 0 or 1 depending if their choice was the right answer while not Draw.mousePressed(): #wait until they click pass validClick = True elif y >= 300 and y <= 400: #this means the client chose the second choice result = choosingAnAnswer( combined[1], lie ) #result equals the return of 0 or 1 depending if their choice was the right answer while not Draw.mousePressed(): #wait until they click pass validClick = True elif y >= 500 and y <= 600: #this means the client chose the third choice result = choosingAnAnswer( combined[2], lie ) #result equals the return of 0 or 1 depending if their choice was the right answer while not Draw.mousePressed(): #wait until they click pass validClick = True return result #if client got the answer right returns a 1 if not a 0. this then gets incremented to total right
def showBoxFirstPage(y, string, sizeTrue, sizeFalse): #creates the boxes that are on the first page Draw.setColor(Draw.DARK_GRAY) Draw.filledRect(0, y + 25, 900, 50) Draw.setColor(Draw.WHITE) Draw.setFontSize(20) Draw.setFontBold(True) Draw.string( string + " " + "(" + str(sizeTrue + sizeFalse) + " " + 'Questions' + ")", 410, y + 40) #shows the category and how many questions there are in each topic
def firstPage( ): #title page showcasing the three categories: nature, history,sports Draw.clear() Draw.setBackground(Draw.ORANGE) Draw.setColor(Draw.WHITE) #This shows the game title Draw.filledRect(300, 25, 300, 50) Draw.setColor(Draw.BLACK) Draw.setFontSize(20) Draw.setFontBold(True) Draw.string("Fun Facts Quiz", 380, 40) Draw.string("Choose a Category of Questions", 295, 125) #instructions Draw.setFontSize(10) Draw.string("Created by Deborah Coopersmith", 10, 10) showBoxFirstPage(200, "Nature", len(list_natureTrue), len(list_natureFalse)) #nature category showBoxFirstPage(400, "History", len(list_humanTrue), len(list_humanFalse)) #history category showBoxFirstPage(600, "Sports", len(list_sportsTrue), len(list_sportsFalse)) #sports category Draw.show() #client clicks the category they want while not Draw.mousePressed(): #wait for user to click pass #get click y = Draw.mouseY() #depending on which area they click open up the category they want if y >= 225 and y <= (225 + 50): secondPage(list_natureTrue, list_natureFalse) #open nature category elif y >= 425 and y <= (425 + 50): secondPage(list_humanTrue, list_humanFalse) #open history category elif y >= 625 and y <= (625 + 50): secondPage(list_sportsTrue, list_sportsFalse) #open sports category
def draw(self, array): # Initialize the arrays to hold the numbers and the bars self.__array = array if self.__bars: for i in self.__bars: Draw.delete(i) self.__bars = [] # Set values for the color spectrum freq = 0.2 phase = 2 * math.pi / 3 center = 128 width = 127 # Draw a bordering box Draw.setColor(Draw.BLACK) Draw.rect(self.__xOrigin - 1, self.__yOrigin - 1, BOX + 2, BOX // 3 + 2) # Loop through each bar in the array for i in range(len(array)): # Set the three color components and height of that bar. red = int(math.sin(freq * array[i]) * width + center) green = int(math.sin(freq * array[i] + phase) * width + center) blue = int(math.sin(freq * array[i] + 2 * phase) * width + center) height = int(BOX // 3 / BARS * (array[i] + 1)) # Set the color, draw the bar, and add it to the array. Draw.setColor(Draw.color(red, green, blue)) bar = Draw.filledRect(i*int(BOX/BARS) +self.__xOrigin, \ self.__yOrigin+ BOX//3-height,\ int(BOX/BARS), height) self.__bars += [bar] # If you haven't yet made the bottom display, draw it if self.__comp == None: # Draw a display below the graph indicating the type of sort and # number of comparisons done. font = min(Y, BOX // 11) Draw.setColor(Draw.BLACK) Draw.setFontSize(font) Draw.string(self.__name + " Sort", self.__xOrigin, \ self.__yOrigin + BOX//3 + ARROW + Y) Draw.string("Comparisons:", self.__xOrigin, \ self.__yOrigin + BOX//3 + ARROW + Y*3) # Save as attributes the item used for drawing the string and # the x and y coordinates of that element self.__compX = self.__xOrigin + int(font * 9) self.__compY = self.__yOrigin + BOX // 3 + ARROW + Y * 3 self.__comp = Draw.string(0, self.__compX, self.__compY)
def draw_tree(self): self.view.Canvas.delete("all") self.nodes = self.tree.get_all_children() Draw.draw_tree(self, self.tree, 600, 130)
def axonColorComparison(): axons = DataParse.readExcelColorSamples() Draw.axonComparison(axons, 2)
def kMeans(): histogram = DataParse.loadStack() data, centroidList, distance = Cluster.kMeans(histogram, main.CLUSTERS) Draw.clusterDraw(data, centroidList, histogram)
def questionResults(remark, saying): #whether the client got it right or wrong Draw.clear() Draw.setColor(Draw.BLACK) Draw.setFontSize(35) Draw.setFontBold(True) Draw.string(remark, 50, 160) #says whether they succeeded or got it wrong Draw.setFontSize(20) Draw.string( random.choice(saying), 50, 210 ) #give a saying from the global variable sorry if they were wrong or congrats if they were right Draw.setFontSize(15) Draw.string( "Click anywhere to move on to the next question", 50, 310 ) #notify the client to move on to the next question or if this was their last question code moves on to endGame function Draw.show()
# draw.put_objectID_into_object(image_np, centroid, objectID) if objectID not in location_object: location_object[objectID] = [centroid] else: if len(location_object[objectID]) >= 10: del location_object[objectID][0] else: location_object[objectID].append(centroid) # Kiểm tra nếu độ dịch chuyển của xe đó < 2 thì là đang dừng for (objectID, data) in objects.items(): data = location_object[objectID] if len(data) > 5: distance = calculateDistance(data) if distance > 1 and distance < 4: draw.put_objectID_into_object_slow(image_np, data[-1], message_SL) send_data() # print(distance) elif distance <= 1: #print(objectID) draw.put_objectID_into_object_stop(image_np, data[-1], message_ST) send_data() cv2.imshow("image", image_np) out.write(image_np) # Press 'q' to quit if cv2.waitKey(1) == ord('q'): break cap.release() out.release()
def endGameScore(string, integer): Draw.clear() Draw.setColor(Draw.BLACK) Draw.setFontSize(20) Draw.setFontBold(True) Draw.string(string, 60, 180) #shows how many they go tight Draw.string("Click to move on to the next page", 60, 210) if integer == 0: #if integer is 0 shows red screen Draw.setBackground(Draw.RED) else: #if integer 1 show green screen Draw.setBackground(Draw.GREEN) Draw.show() while not Draw.mousePressed(): #wait until client clicks pass Draw.clear() Draw.setFontSize(30) #allow the client to play again Draw.string("Want to play again? If so, click on the screen", 60, 180) #client needs to click to restart game Draw.show() while not Draw.mousePressed(): #wait until the client clicks pass
def move(self, message, totalInversions): #moves car based on inversions removed step = 480 / totalInversions #total distance/total inversions= #one "step" per inversion removed Draw.moveTo(self.__draw,\ self.__x+(totalInversions-message[2])*step,self.__y)
def main(): Draw.setCanvasSize(900, 900) #makes the canvas size 900 by 900 while True: firstPage() #client can play as many times as they like
def offsetPolyline(_polylineGUID, _offsetDistance): # works for CONVEX # offset direction is inwards # parameters: # _polylineGUID # _offsetDistance # # version: 2012/07/05A name = "offsetPolyline" debug = False # EVALUATION doc = scriptcontext.doc obj = doc.Objects.Find(_polylineGUID) if obj == None: print(name + ": No Object") crv = obj.CurveGeometry if not crv.IsPolyline(): print(name + ": Curve is not polyline") return None if not crv.IsClosed: print(name + ": Curve is not closed") d = crv.PointAtEnd.DistanceTo(crv.PointAtStart) return None L = [] pts= rs.CurvePoints(_polylineGUID) for i in range((len(pts)-1)): #print("") iP = (i-1) % (len(pts)-1) iC = (i+1) % (len(pts)-1) iN = (i+2) % (len(pts)-1) #print(str(iP) + " " + str(i) + " " + str(iC)+ " " + str(iN)) v1 = rs.VectorCreate(pts[iP], pts[i]) v2 = rs.VectorCreate(pts[iN], pts[iC]) a1 = rs.VectorAngle(v1,v2) a2 = rs.VectorAngle(rs.VectorReverse(v1),v2) if a1 < a2: if debug: print(str(a1) + " < " + str(a2)) # use first else: v1 = rs.VectorReverse(v1) if debug: print(str(a2) + " < " + str(a1)) # use second v = ((v1[0] + v2[0])/2, (v1[1] + v2[1])/2,(v1[2] + v2[2])/2) vY = rs.VectorUnitize(v) vX = rs.VectorCreate(pts[i], pts[iC]) vZ= rs.VectorCrossProduct(vX, vY) ptMid = ((pts[i][0] + pts[iC][0])/2, (pts[i][1] + pts[iC][1])/2, (pts[i][2] + pts[iC][2])/2) p = rs.PlaneFromNormal(ptMid, vZ, vX) #DEBUG if debug: Draw.drawPalneAxeAndArrows(p, _offsetDistance) # make sure green arrawsa are pointing inwards ptA = movePoint(pts[i], rs.VectorScale( rs.VectorUnitize( p[2] ), _offsetDistance)) ptB = movePoint(pts[iC], rs.VectorScale( rs.VectorUnitize( p[2] ), _offsetDistance)) ln = rs.AddLine(ptA, ptB) L.append(ln) P = [] for i in range(len(L)): lineAPts = lineEndPoints(L[i]) lineBPts = lineEndPoints(L[(i+1) % len(L)]) intersection = rs.LineLineIntersection((lineAPts[0], lineAPts[1]), (lineBPts[0],lineBPts[1])) ptI = intersection[0] P.append(ptI) rs.DeleteObjects(L) P.append(P[0]) return rs.AddPolyline(P)
rawpath = planner.path() from Draw import * ################### SMOOTHING spath = smooth(grid=grid, path=rawpath[:]) ################### WAYPOINTING waypoints = waypointing(path=spath, speed=0.5) ################### FORCE FIELD waypoints = forceField(planner=planner, waypoints=waypoints, neighborhood=2) ################### WAYPOINTING AGAIN waypoints = waypointing(path=waypoints, speed=0.5) ################### DRAWING d = Draw(rows=grid.rows, cols=grid.cols, cellSize=20) d.drawGrid() d.fillCells(grid=grid.obstacleGrid, color='green') d.fillCells(grid=grid.closedGrid, color='grey') d.drawLine(path=rawpath, color='red') d.drawLine(path=spath, color='orange') d.drawLine(path=waypoints, color='blue') # d.drawPoints(pointset=waypoints, color='blue') d.loop()
def runTest(Train=True): step = 0 ##跨越episode的总步数计数 t_all = [] ##agent,baseline,baseline_f,random,random2 r_all = [] x_all = [[], [], [], [], []] profit_all = [[], [], [], [], []] pay_all = [[], [], [], [], []] volume_episode = [[], [], [], [], []] profit_episode = [[], [], [], [], []] pay_episode = [[], [], [], [], []] income_episode = [[], [], [], [], []] profit_p_episode = [[], [], [], [], []] value_episode = [[], [], [], [], []] value_p_episode = [[], [], [], [], []] for episode in range(episode_cnt_test): # initial observation observation = env.reset(test=True) ##feature数组 volume_episode_cnt = [0, 0, 0, 0, 0] pay_episode_cnt = [0, 0, 0, 0, 0] income_episode_cnt = [0, 0, 0, 0, 0] profit_episode_cnt = [0, 0, 0, 0, 0] profit_p_episode_cnt = [0, 0, 0, 0, 0] value_episode_cnt = [0, 0, 0, 0, 0] value_p_episode_cnt = [0, 0, 0, 0, 0] var = 3 # control exploration actions = [] while True: # RL choose action based on observation if insurance: arr = ddpg.choose_action(observation) arr = np.clip(np.random.normal(arr, var), -1, 1) action_value = np.clip( int((float(arr[0]) + 1) / 2 * 10) / 10, 0, 0.9) action = arr else: action = ddpg.choose_action(observation) action = np.clip(np.random.normal(action, var), 0, 1) r = observation[0] r_all.append(r) t_all.append(env.getT()) x_all[0].append(env.getAction_Income( action_value, isFloat=True)) ##x 仅仅是定价 ,后面的profit才是真是收益 x_all[1].append(env.getAction_Income(env.getBaseAction())) x_all[2].append(env.getAction_Income(env.getBaseAction_f())) pf_cmp0, i_cmp0, py_cmp0, v_cmp0, pf_p0, v_p0 = env.getAction_Profit( action_value, isFloat=True) pf_cmp1, i_cmp1, py_cmp1, v_cmp1, pf_p1, v_p1 = env.getAction_Profit( env.getBaseAction()) pf_cmp2, i_cmp2, py_cmp2, v_cmp2, pf_p2, v_p2 = env.getAction_Profit( env.getBaseAction_f()) # if is_Theory: pf_cmp3, i_cmp3, py_cmp3, v_cmp3, pf_p3, v_p3 = env.getAction_Profit( env.getTheoryPrice(), isFloat=True) x_all[3].append( env.getAction_Income(env.getTheoryPrice(), isFloat=True)) else: pf_cmp3, i_cmp3, py_cmp3, v_cmp3, pf_p3, v_p3 = 0, 0, 0, 0, 0, 0 i_cmp_list = [i_cmp0, i_cmp1, i_cmp2, i_cmp3] py_cmp_list = [py_cmp0, py_cmp1, py_cmp2, py_cmp3] pf_cmp_list = [pf_cmp0, pf_cmp1, pf_cmp2, pf_cmp3] v_cmp_list = [v_cmp0, v_cmp1, v_cmp2, v_cmp3] pf_p_list = [pf_p0, pf_p1, pf_p2, pf_p3] v_p_list = [v_p0, v_p1, v_p2, v_p3] volume_list = list(map(lambda x: env.getVolume(x), pf_cmp_list)) income_episode_cnt = addToList(income_episode_cnt, i_cmp_list, n) pay_episode_cnt = addToList(pay_episode_cnt, py_cmp_list, n) profit_episode_cnt = addToList(profit_episode_cnt, pf_cmp_list, n) volume_episode_cnt = addToList(volume_episode_cnt, volume_list, n) profit_p_episode_cnt = addToList(profit_p_episode_cnt, pf_p_list, n) value_episode_cnt = addToList(value_episode_cnt, v_cmp_list, n) value_p_episode_cnt = addToList(value_p_episode_cnt, v_p_list, n) pay_all = appendToList(pay_all, [py_cmp0, py_cmp1, py_cmp2, py_cmp3], n) profit_all = appendToList(profit_all, [pf_cmp0, pf_cmp1, pf_cmp2, pf_cmp3], n) # RL take action and get next observation and reward ##reward int , done boolean observation_, r, done = env.step(action_value, isFloat=True) if Train: ddpg.store_transition(observation, action, r / 10, observation_) # 总共学了200步以上后,每隔5步进行一次学习 if ddpg.pointer > MEMORY_CAPACITY: var *= .9995 # decay the action randomness ddpg.learn() observation = observation_ # break while loop when end of this episode if done: # if (episode == episode_cnt-1): # Draw.drawHist(actions, "actions", ranges=(0, 16)) for i in range(len(LEGEND)): profit_episode[i].append(profit_episode_cnt[i]) volume_episode[i].append(volume_episode_cnt[i]) pay_episode[i].append(pay_episode_cnt[i]) income_episode[i].append(income_episode_cnt[i]) profit_p_episode[i].append(profit_p_episode_cnt[i]) value_episode[i].append(value_episode_cnt[i]) value_p_episode[i].append(value_p_episode_cnt[i]) break step += 1 # end of game print('game over') text = ("" if not Train else "_train") drawXT([r_all], t_all, LEGEND, "r", "t" + text, avg=False) Draw.plotMulti(profit_episode[:n], "rewards_episode" + text, legend=LEGEND[:n]) if not Train: drawXT(x_all, r_all, LEGEND, "r", "x", avg=True) drawXT(profit_all, r_all, LEGEND, "r", "profit", avg=True) drawXT(x_all, t_all, LEGEND, "t", "x", avg=True) drawXT(profit_all, t_all, LEGEND, "t", "profit", avg=True) Draw.plotMulti(volume_episode[:n], "volume_episode_test", legend=LEGEND[:n]) Draw.plotMulti(pay_episode[:n], "pay_episode_test", legend=LEGEND[:n]) Draw.plotMulti(income_episode[:n], "income_episode_test", legend=LEGEND[:n]) print_list = list( map( lambda i: list( map(lambda x: np.mean(x), [ profit_episode[i], pay_episode[i], income_episode[i], volume_episode[i], value_episode[i], profit_p_episode[ i], value_p_episode[i] ])), np.arange(0, len(LEGEND[:n]), 1))) print_df = pd.DataFrame(print_list, columns=[ "profit", "pay", "income", "volume", "value", "profit_p", "value_p" ], index=LEGEND[:n]) print_df.to_csv("results/print-list" + text + ".csv", index=True, sep=',')
if btnBluePlus.getPressedButton(50, 540, 50, 50) and blue < 255: blue += alter if btnBlueMinus.getPressedButton(1200, 540, 50, 50) and blue > 1: blue -= alter def AlterAllColors(): AlterRedColor() AlterGreenColor() AlterBlueColor() #Objects events = Event.Events() colors = Colors.Colors() keyboard = Keyboard.KeyBoard() draw = Draw.Draw() text = Text.Text() btnPlus = Button.Button() btnMinus = Button.Button() btnPlusWidth = Button.Button() btnPlusHeight = Button.Button() btnMinusWidth = Button.Button() btnMinusHeight = Button.Button() btnRedPlus = Button.Button() btnRedMinus = Button.Button() btnBluePlus = Button.Button() btnBlueMinus = Button.Button()
def initgame(game_info): global game, draw game = Game.game(game_info) draw = Draw.draw(game_info) game.initcore() draw.initdraw(game)
# temp=powerlaw.rvs(4) # rvs.append(temp) # rvs2=[1/i for i in rvs] # hist=np.arange(0,10,.5) # fit=plw.Fit(rvs2,xmin=1) # print (fit.alpha) # print (fit.sigma) # plt.hist(rvs2,bins=hist) # plt.show() import Model5 import Environment import Individual import Cal_para import Draw args_model=[0.6,-0.21] args_time=[2,1,10000] args_steps=[-1.80,5] args_grid=[[20,20],[10,2,10,2],200] time=100 temp_routeList=[] Envir=Environment.normal_network_Environment( 0,100,.1) #model=Model5.HomeOrWork_Model(args_model=args_model,args_t=args_time,args_steps=args_steps,environment=Envir,visited_Place=[],homeposition=random.choice(Envir.locations),workposition=random.choice(Envir.locations)) model=Individual.Nomal_Individual(args_model=args_model,args_t=args_time,args_step=args_steps,simulate_time=time,Environment=Envir) model.simulate() print (9) cal=Cal_para.Cal_para(model.data_mid.route,Envir) dis=cal.get_visit_location_number_disput() draw=Draw.Draw(cal,[model.home_loc,model.work_loc]) draw.draw_visit_location_number_disput() draw.draw_location_disput(model.data_mid) print (1)
def volumeRender(): histogram = DataParse.loadStack(300, 200, 3000, mode="8bit", segmented=False) Draw.volumeRender(histogram, mode="fullcolor", prune=0)
def introScreen(): Draw.setColor(Draw.BLUE) Draw.filledRect(150, 250, 600, 200) Draw.setColor(Draw.RED) Draw.setFontSize(100) Draw.string("PLAY", 250, 300)
def volumeRenderLowerCorner(): histogram = DataParse.loadStack() histogram = Utils.magnifyLowerLeft(histogram, .25) Draw.volumeRender(histogram, mode="greyscale", prune=0)
def board(): #initialize the variables that will calculate each col, row, #and the size of each cell/piece on the game board pixelBegFirstRow = 1 pixelBegFirstCol = 20 numPixelsRows = 500 + pixelBegFirstRow numPixelsCols = 700 + pixelBegFirstCol # Mathematical calculations for rows sizeRow = numPixelsRows // len(gameBoard) pixelBegLastRow = numPixelsRows - sizeRow + pixelBegFirstRow # Mathematical calculations for columns sizeCol = numPixelsCols // len(gameBoard[0]) pixelBegLastCol = numPixelsCols - sizeCol + pixelBegFirstCol sizeOval = 50 #graphic representation of the gameboard Draw.clear() Draw.setColor(Draw.BLUE) Draw.filledRect(80, 80, numPixelsCols, numPixelsRows) for row in range(pixelBegFirstRow, pixelBegLastRow, sizeRow): for col in range(pixelBegFirstCol, pixelBegLastCol, sizeCol): #setting the color for the circles if gameBoard[row // sizeRow][col // sizeCol] == Draw.RED: Draw.setColor(Draw.RED) elif gameBoard[row // sizeRow][col // sizeCol] == Draw.YELLOW: Draw.setColor(Draw.YELLOW) else: Draw.setColor(Draw.WHITE) Draw.filledOval(sizeCol + col, sizeRow + row, sizeOval, sizeOval)
def histogram(): histogram = DataParse.loadStack() Draw.draw(histogram)
def gameOver(totalRedBestRun, totalYellowBestRun): #If someone won, draw the gameOver plaque if totalRedBestRun[0] == 4 or totalYellowBestRun[0] == 4: Draw.setColor(Draw.WHITE) Draw.filledRect(150, 250, 600, 200) Draw.setColor(Draw.RED) Draw.setFontSize(70) if totalRedBestRun[0] == 4: #player won, make exciting sign! Draw.string("YOU WON!!", 165, 300) Draw.show() time.sleep(3) introScreen() return True elif totalYellowBestRun[0] == 4: #comp won, write "you lost" Draw.string("You lost", 165, 300) Draw.show() time.sleep(3) introScreen() return True return False
def sliceDraw(): histogram = DataParse.loadStack() data, centroidList, distance = Cluster.kMeans(histogram, main.CLUSTERS) Draw.drawSlice(data, centroidList)
def draw(self, n, step=False): p1, p2 = Draw.move(n) self.curr_canvas.create_line(p1[0], p1[1], p2[0], p2[1], fill= self.color, width= self.thick) if step: self.curr_canvas.update_idletasks()
def run(self): if not hasattr(self, "running") or not hasattr(self, "eventHandler"): raise GameError("Game has not been properly initialized") timers = Struct( print_framerate = 0, ) while self.running: for timer in timers: timers[timer] += 1 self.clock.tick(self.ticktime) self.events = Pygame.event.get() self.interrupts = [] if timers.print_framerate == TETRIS_FRAMERATE * DISPLAY_TETRIS_FRAMERATE_INTERVAL: timers.print_framerate = 0 Log.notice("Framerate: {}".format(int(round(self.clock.get_fps())))) ## The events and updates should be handled in reverse order (the things on top go first) queue = sorted(self.jobs, key=lambda obj: getattr(self.jobs, obj).queue, reverse=True) for objname in queue: if objname not in self.jobs: ## In case a Job modifies self.jobs, removing this job. continue obj = self.getJob(objname) if obj.handling_events: for event in self.events: if event.type not in self.lock: obj.eventHandler(event) ## XXX: This second check of update_required is necessarry because the eventHandler may either modify ## or call methods that modify parameters in obj. if obj.update_required: obj.update() queue = sorted(self.jobs, key=lambda obj: getattr(self.jobs, obj).queue) ## Handle resizing (redraw everything underneath the resized job) for objname in queue: obj = self.getJob(objname) if obj.__dict__.get("resize"): for job in self.getJobsIn(objname): job.force_draw = True obj.resize = False ## Unlike the events and updates, drawing is handled so that the lowest go first for objname in queue: if objname not in self.jobs: ## In case a Job modifies self.jobs, removing this job. continue obj = self.getJob(objname) if objname not in self.jobs: ## In case a Job modifies self.jobs, removing itself during update. continue if obj.draw_required: if obj.fill: Draw.fillJob(self.screen, obj.fill, obj) obj.draw() Pygame.display.flip() for event in self.events: if event.type not in self.lock: self.eventHandler(event) if self.running: self.running() ## Remove locks self.lock = {} self.handleInterrupts() return self.ret
def main(): Draw.setCanvasSize(750, 605) #draw finish line Draw.setColor(Draw.BLACK) Draw.rect(580, 75, 70, 455) for i in range(7): Draw.filledRect(580, 75 + 70 * i, 35, 35) for i in range(6): Draw.filledRect(615, 110 + 70 * i, 35, 35) #draw racetrack Draw.setColor(Draw.DARK_GRAY) Draw.filledRect(100, 75, 480, 455) Draw.setColor(Draw.WHITE) for i in range(4): for j in range(0, 470, 20): Draw.filledRect(110 + j, 157 + 92 * i, 10, 5) #create cars bubbleCar = Car(100, 83, Draw.RED, "B") selectionCar = Car(100, 175, Draw.YELLOW, "S") insertionCar = Car(100, 267, Draw.GREEN, " I") mergeCar = Car(100, 359, Draw.BLUE, "M") quickCar = Car(100, 451, Draw.VIOLET, "Q") cars = {"bubble":bubbleCar, "selection":selectionCar, \ "insertion":insertionCar,"merge":mergeCar, "quick":quickCar} #Race 1: random array of 10 #create array a = [0] * 10 for i in range(len(a)): a[i] = random.randint(0, 99) print("Random array 10:", a) #draw title title = drawTitle("Round 1: Random Array", a) #start race race(a, cars) time.sleep(3) #reset board Draw.delete(title) for k in cars: cars[k].reset() #Race 2: random array of 100 #create array b = [0] * 100 for i in range(len(b)): b[i] = random.randint(0, 99) print("Random array 100:", b) #draw title title = drawTitle("Round 2: Random Array", b) #start race race(b, cars) time.sleep(3) #reset board Draw.delete(title) for k in cars: cars[k].reset() #Race 3: almost sorted 100 #create sorted array c = [0] * 100 for i in range(len(c) - 1): #leave last element unsorted c[i] = i #swap 10 random pairs for i in range(10): n = random.randint(0, len(c) - 2) temp = c[n] c[n] = c[n + 1] c[n + 1] = temp print("Almost sorted:", c) #draw title title = drawTitle("Round 3: Almost Sorted Array", c) #start race race(c, cars)
'splitter': ('random', 'best'), 'min_samples_leaf': range(1, 30), 'max_leaf_nodes': range(2, 30) }] clf = GridSearchCV(DecisionTreeClassifier(), parameters, cv=5, scoring='f1', verbose=0, n_jobs=-1) y_pred = clf.fit(x_train.loc[:, best_features], y_train).predict(x_test.loc[:, best_features]) print(clf.cv_results_['mean_test_score']) print(clf.best_params_) Draw.plot_confusion_matrix(y_test, y_pred, title='Decision Tree') plt.show() #%% parameter tuning - K-nearest neighbour def KNN(): start_num = 1 end_num = 100 temp_list = [] for step in range(start_num, end_num): knn_model = KNeighborsClassifier(n_neighbors=step) y_pred = knn_model.fit(x_train, y_train).predict(x_test) score = f1_score(y_test, y_pred, average='binary') temp_list.append(((score, step), step))
def createPromptArea(t, x, y, wide, promptHeight): Draw.setFontSize(20) Draw.setColor(Draw.GRAY) Draw.setFontBold(False) Draw.string("Press Enter to proceed", 0, y - 30) Draw.setColor(Draw.GRAY) Draw.filledRect(x, y, wide, promptHeight) Draw.setColor(Draw.WHITE) Draw.setFontBold(True) centerAlignedStr(t, y + 50) Draw.show()
def init(): Draw.display(choice) seq_list = MontyH.arrange() return seq_list
def getStringWidth(s): box = Draw.bbox(Draw.string(s, -100, -100)) width = box[2] - box[0] return width
def getClick(): x = Draw.mouseX() y = Draw.mouseY() return x, y
def homePage(): Draw.clear() display = True #until the user clicks on the button area, display the home page while display: #draw the home page Draw.setFontSize(35) Draw.setFontBold(False) Draw.setColor(Draw.DARK_BLUE) centerAlignedStr("Welcome to:", 50) centerAlignedStr("Create Your Own Income Statement", 90) #draw the button to get to the "next page" --> prompt areas Draw.filledRect(375, 450, 250, 100) Draw.setColor(Draw.WHITE) Draw.setFontBold(True) Draw.setFontSize(20) Draw.string("Click here to get started", 387, 490) #when the user clicks on the button, stop displaying the home page if Draw.mousePressed(): if Draw.mouseX() >375 and Draw.mouseX() < 375 + 250 and\ Draw.mouseY() >450 and Draw.mouseY() < 450 + 100: display = False Draw.show()
def checkDate(m, d): Draw.clear() months30 = ["November", "April", "June", "September"] if m in months30 and int(d) == 31 or m == "February" and int(d) > 29: return False return True
import Draw Draw.initializeGraphics(['test']) Draw.runGraphics()
def race(a, cars): #count inversions and assign initial number to each sort totalInversions = bubbleInversions = selectionInversions \ = insertionInversions = mergeInversions = quickInversions = \ countInversions(a) print("total inversions=", totalInversions) #create queue q = multiprocessing.Queue() prioritized = PriorityQueue(q) jobs = [ multiprocessing.Process(target=bubbleSort, args=(a,q,bubbleInversions)),\ multiprocessing.Process(target=selectionSort, args=(a,q,selectionInversions)),\ multiprocessing.Process(target=insertionSort, args=(a,q,insertionInversions)),\ multiprocessing.Process(target=mergeSort, args=(a,q,mergeInversions)),\ multiprocessing.Process(target=quickSort, args=(a,q,quickInversions)) ] #starting message time.sleep(1) flash("On your marks", 260) flash("get set", 300) flash("SORT!", 300) #initialize comparisons string Draw.setFontSize(20) comps = 0 compstr = Draw.string(str(comps), 232, 50) Draw.show() #initialize start and end time startTime = 0 endTime = 0 #start the processes for p in jobs: p.start() time.sleep(3) #give time for messages to get to priority queue # stop when all processes are done running or 10 secs after winner wins numDone = 0 while numDone < len(jobs) and endTime - startTime < 10: if startTime > 0: endTime = time.time() #keeps track of time since winner # Get the next message that one of the processes has sent message = prioritized.get() print(message) #update number of comparisons Draw.delete(compstr) comps = message[0] compstr = Draw.string(str(comps), 232, 50) Draw.show() #see which sort the message is from, and move its car to the number #of steps corresponding to its inversions removed if message[1] != "done": cars[message[1]].move(message, totalInversions) # if the process has announced that it is done, increment "done"s by 1 else: numDone += 1 #the first one done is the winner if numDone == 1: winner = message[2] startTime = time.time() #start 10 sec timer #display winner Draw.setFontSize(30) result = Draw.string("Winner: " + winner, 210, 540) Draw.show() time.sleep(2) #clear comparison and winner strings Draw.delete([compstr, result])