def draw_dependencies(gammas, phis, ds, amps): ''' Draw 2 graphics: phi(gamma), d(gamma) dependencies and amplitude(gamma) dependency :param gammas: list of gamma values :param phis: list of phis values :param ds: list of d values :param amps: list of amplitude values ''' # draw phi, d dependencies phid_figure_name = 'cubic_oscillating_phi0d0{}_x0={:.5},beta={:.5}'.format( SUFFIX_NAME, x0, beta) drawer_phid = drawer.Drawer(x_label=r'$\gamma$', figure_name=phid_figure_name, save_dir=SAVE_DIRECTORY) drawer_phid.drawAxis(show_Ox=True) drawer_phid.drawTwoCurves(gammas, phis, ds, r'$\varphi_0$', r'$d_0$', 'darkcyan', 'darkorange') # draw amplitude dependency amp_figure_name = 'cubic_oscillating_A{}_x0={:.5},beta={:.5}'.format( SUFFIX_NAME, x0, beta) drawer_amp = drawer.Drawer(x_label=r'$\gamma$', y_label='$A_c$', figure_name=amp_figure_name, save_dir=SAVE_DIRECTORY) drawer_amp.drawAxis(show_Ox=True) drawer_amp.drawCurve(gammas, amps, curve_color='crimson')
def draw_dependencies(gammas, phis, ds, amps): ''' Draw 2 graphics: phi(gamma), d(gamma) dependencies and amplitude(gamma) dependency :param gammas: list of gamma values :param phis: list of phis values :param ds: list of d values :param amps: list of amplitude values ''' # draw phi, d dependencies phid_figure_name = 'cubic_divergent_phi0d0_x0={:.5},g[{:.5},{:.5}],beta={:.5}'.format( x0, g_min, g_max, beta) drawer_phid = drawer.Drawer(x_label=r'$\gamma$', figure_name=phid_figure_name, save_dir=SAVE_DIRECTORY) drawer_phid.drawAxis(show_Ox=True) drawer_phid.drawTwoCurves(gammas, phis, ds, curve1_lbl=r'$\varphi_0$', curve2_lbl=r'$d_0$', curve1_color='darkcyan', curve2_color='darkorange') # draw amplitude dependency amp_figure_name = 'cubic_divergent_Au_x0={:.5},beta={:.5}'.format(x0, beta) drawer_amp = drawer.Drawer(x_label=r'$\gamma$', y_label='$A_u$', figure_name=amp_figure_name, save_dir=SAVE_DIRECTORY) drawer_amp.drawAxis(show_Ox=True) drawer_amp.drawCurve(gammas, amps, curve_color='crimson')
def draw_dependencies(gammas, phis, ds, amps): ''' Draw 3 graphics: phi(gamma) dependency, d(gamma) dependency and amplitude(gamma) dependency :param gammas: list of gamma values :param phis: list of phis values :param ds: list of d values :param amps: list of amplitude values ''' # draw phi dependency phi_pict = 'oscillating_phi0{}_x0={:.5}'.format(SUFFIX_NAME, x0) drawer_phi = drawer.Drawer(x_label=r'$\gamma$', y_label=r'$\varphi_0$', figure_name=phi_pict, save_dir=SAVE_DIRECTORY) drawer_phi.drawAxis(show_Ox=True) drawer_phi.drawCurve(gammas, phis, curve_color='darkcyan') # draw d dependency d_pict = 'oscillating_d0{}_x0={:.5}'.format(SUFFIX_NAME, x0) drawer_d = drawer.Drawer(x_label=r'$\gamma$', y_label='$d_0$', figure_name=d_pict, save_dir=SAVE_DIRECTORY) drawer_d.drawAxis(show_Ox=True) drawer_d.drawCurve(gammas, ds, curve_color='orange') # draw amplitude dependency amp_pict = 'oscillating_Ac{}_x0={:.5}'.format(SUFFIX_NAME, x0) drawer_amp = drawer.Drawer(x_label=r'$\gamma$', y_label='$A_c$', figure_name=amp_pict, save_dir=SAVE_DIRECTORY) drawer_amp.drawAxis(show_Ox=True) drawer_amp.drawCurve(gammas, amps, curve_color='crimson')
def _configure(self, qtile, screen): if self not in [screen.top, screen.bottom]: raise confreader.ConfigError( "Bars must be at the top or the bottom of the screen.") if len(filter(lambda w: w.width_type == STRETCH, self.widgets)) > 1: raise confreader.ConfigError("Only one STRETCH widget allowed!") Gap._configure(self, qtile, screen) self.window = window.Internal.create(self.qtile, self.x, self.y, self.width, self.height, self.opacity) self.drawer = drawer.Drawer(self.qtile, self.window.window.wid, self.width, self.height) self.drawer.clear(self.background) self.window.handle_Expose = self.handle_Expose self.window.handle_ButtonPress = self.handle_ButtonPress self.window.handle_ButtonRelease = self.handle_ButtonRelease qtile.windowMap[self.window.window.wid] = self.window self.window.unhide() for i in self.widgets: qtile.registerWidget(i) i._configure(qtile, self) self._resize(self.width, self.widgets) # FIXME: These should be targeted better. hook.subscribe.setgroup(self.draw) hook.subscribe.changegroup(self.draw)
def main(): set_brightness(.05) switchColor(1) draw = drawer.Drawer(output = True) switchColor(2) print('---Switch is strating') #intializeDrawer() flip = False xSquare = framer(6) try: for xS in xSquare: draw.square(xS[0],xS[1],xS[2],xS[3]/xS[2]) #line(50,50,length=50,angle=0) #line(50,50,length=55,angle=.1) #line(50,50,length=60,angle=.2) #line(50,50,length=65,angle=.4) #line(50,50,length=70,angle=.8) #line(50,50,length=75,angle=1.6) #for k in range(0,10): #draw.square(100,70,10*k/2.0,noise = 3,speed=500) #for j in range(0,10): #square((k+1)*11,(j+1)*11,10,angle=math.pi*(k*j)/(400)) #draw.circle((k+1)*11,(j+1)*11,k+j) except Exception as e: print(traceback.format_exc()) draw.toPosition(0,0) draw.closeDrawer() switchColor(1)
def __init__(self): Tk.__init__(self) self.frame_height = [800, 800] self.frame_width = [200, 1500] # Frames self.signal_frame = drawer.Drawer(tk = self, grid_position = None,#(0, 1), height = self.frame_height[1], width = self.frame_width[1]) self.value_frame = ControlFrame(tk = self, height = self.frame_height[0], width = self.frame_width[0], bg = '#EEFFEE') self.value_frame.grid(row = 0, column = 0) self.signal_frame.grid(row = 0, column = 1) # UDP self.udp_port = 9999 self.udp_server = UDPServer(self.udp_port) self.n_signal_samples = 2000 self.signal_limits = [-2**11, 2**11] self.spectrum_limits = [0, 10000] self.signal_contraction = 1.1 self.signal_buffer = deque([0] * self.n_signal_samples, maxlen = self.n_signal_samples) self.spectrum_buffer = deque([0] * self.n_signal_samples, maxlen = self.n_signal_samples) self.saved_signal = [] self.n_saved = 10000 # self.saved_file = open('saved.txt', 'w') # Setup self.setup()
def run(): try: search_file = sys.argv[1] with open(search_file) as f: result = json.loads(f.read()) agents = list() for ag in result["agents"]: try: model_x = model.models[ag["x"]["type"]](*ag["x"]["params"]) model_y = model.models[ag["y"]["type"]](*ag["y"]["params"]) agents.append(agent.Agent(model_x, model_y)) except TypeError: agents.append(path.make(list())) for p in ag: agents[-1].append(stpoint.make(p["x"], p["y"], p["t"])) b_path = path.make(list()) for st_p in result["path"]: b_path.append(stpoint.make(st_p["x"], st_p["y"], st_p["t"])) fig = plt.figure() ax_dr = fig.add_subplot(111, projection="3d") dr = drawer.Drawer(fig, ax_dr) dr.draw_path(b_path) for ag in agents: dr.draw_agent(ag, b_path.get_max_time()) dr.show() except IndexError: print_usage()
def main(): set_brightness(.05) switchColor(1) draw = drawer.Drawer(output=True) switchColor(2) print('---Switch is strating') #intializeDrawer() flip = False xSquare = [] for k in range(0, 8): checked = False while not checked: x0 = 30 + 200 * random.random() y0 = 30 + 150 * random.random() R0 = 5 + 15 * random.random() if x0 - R0 > 10 and x0 + R0 < 250 and y0 - R0 > 10 and y0 + R0 < 170: checked = True xSquare.append([x0, y0, R0]) print('and the sqaures are : ') print(xSquare) try: for xS in xSquare: draw.square(xS[0], xS[1], xS[2]) for k in range(10, 300): x = np.arange(10, 250, .2) if flip: x = np.flip(x) y = 10 + k * .6 + 2 * np.sin( (6 * math.pi * ((x - 10) / 240))**(1 + k / 300)) y2 = np.copy(y[(x >= xS[0] - xS[2]) & (x <= xS[0] + xS[2]) & (y >= xS[1] - xS[2]) & (y <= xS[1] + xS[2])]) x2 = np.copy(x[(x >= xS[0] - xS[2]) & (x <= xS[0] + xS[2]) & (y >= xS[1] - xS[2]) & (y <= xS[1] + xS[2])]) if len(x2) > 2: draw.lines(x2, y2) flip = not flip #line(50,50,length=50,angle=0) #line(50,50,length=55,angle=.1) #line(50,50,length=60,angle=.2) #line(50,50,length=65,angle=.4) #line(50,50,length=70,angle=.8) #line(50,50,length=75,angle=1.6) #for k in range(0,10): #draw.square(100,70,10*k/2.0,noise = 3,speed=500) #for j in range(0,10): #square((k+1)*11,(j+1)*11,10,angle=math.pi*(k*j)/(400)) #draw.circle((k+1)*11,(j+1)*11,k+j) except Exception as e: print(traceback.format_exc()) draw.toPosition(0, 0) draw.closeDrawer() switchColor(1)
def draw_dependencies(gammas, ds, amps): ''' Draw 2 graphics: d(gamma) dependency and amplitude(gamma) dependency :param gammas: list of gamma values :param ds: list of d values :param amps: list of amplitude values ''' # draw d dependency d_figure_name = 'integral_divergent_d0_g[{:.5},{:.5}]'.format(g_min, g_max) drawer_d = drawer.Drawer(x_label=r'$\gamma$', y_label='d', figure_name=d_figure_name, save_dir=SAVE_DIRECTORY) drawer_d.drawAxis(show_Ox=True) drawer_d.drawCurve(gammas, ds, curve_color='darkorange') # draw amplitude dependency amp_figure_name = 'integral_Au_g[{:.5},{:.5}]'.format(g_min, g_max) drawer_amp = drawer.Drawer(x_label=r'$\gamma$', y_label='$A_u$', figure_name=amp_figure_name, save_dir=SAVE_DIRECTORY) drawer_amp.drawAxis(show_Ox=True) drawer_amp.drawCurve(gammas, amps, curve_color='crimson')
def main(): args = sys.argv if len(args) != 3: print("Usage: ./main.py <file_to_draw> <luminance_thresh (0-255)>") return file = sys.argv[1] luminanceThresh = int(sys.argv[2]) strokeDuration = 1 pointMethod = directionTravel.PointTravel(luminanceThresh) points = pointMethod.getPoints(file) artist = drawer.Drawer(1) artist.drawPoints(points)
def main(): ros = rosenbrock.Rosenbrock() sph = sphere.Sphere() qua = quartic.Quartic() ras = rastrigin.Rastrigin() aux = np.array([]) graph = np.array([]) ejecuciones = 1 draw = drawer.Drawer() individuos = 32 dimensiones = 16 intervalos = 8 a = 1 Q = 20 evaporacion = 0.9 t0 = 0.00001 generaciones = 100 bestFitnessPos = 100 graphName = "Quartic" + str(dimensiones) + "D" aco = ACO.ACO(individuos, dimensiones, intervalos, a, Q, evaporacion, t0, ras, generaciones, bestFitnessPos) for i in range(ejecuciones): aux = aco.run() if i == 0: graph = aux else: #Sumamos el resto de las ejecuciones. for a in range(len(aux)): graph[a] = graph[a] + aux[a] for x in range(len(graph)): graph[x] = graph[ x] / ejecuciones #Obtenemos el promedio de cada posicion draw.drawIndividual(graph, graphName) file = open(graphName + ".txt", "w") for y in range(len(graph)): file.write(str(graph[y]) + "\n") file.close()
def __init__(self, height=400, width=1000): Tk.__init__(self) self.title("SoundEEG") self.height = height self.width = width self.width_ratio = 7 self.signal_frame = drawer.Drawer( tk=self, grid_position=None, height=self.height, width=self.width * self.width_ratio // (self.width_ratio + 1)) self.signal_frame.grid(row=0, column=0) self.control_frame = SoundEEG_Control(tk=self) self.control_frame.grid(row=0, column=1) self.control_fields = dict(self.DEFAULT_CTL_FIELDS) self.control_fields['connect']['command'] = self.connect self.control_fields['choose_wav']['command'] = self.choose_wav self.control_fields['play+EEG']['command'] = self.playEEG # Objects self.wav_player = wavplayer.WavPlayer() self.bci_comm = neurorec.GanglionControl()
def main(): # ras = rastrigin.rastrigin() # qua = quartic.quartic() # sph = sphere.sphere() # ros = rosenbrock.rosenbrock() # # aux = np.array([]) # graph = np.array([]) # ejecuciones = 5 draw = drawer.Drawer() # # dimensions = 16 # num_particles = 50 # max_iterations = 2000 #Generaciones # weight = 0.729 #Inercia de la velocidad. # cognitive_learning = 1.49445 #Proporcion de aprendizaje cognitivo. # social_learning = 1.49445 #Proporcion de aprendizaje social. # # graphName = "Quartic" + str(dimensions) + "D" # # for i in range(ejecuciones): # aux = PSO.PSOrun(max_iterations, num_particles, dimensions, qua, weight, # cognitive_learning, social_learning) # if i == 0: # graph = aux # else: #Sumamos el resto de las ejecuciones. # for a in range(len(aux)): # graph[a] = graph[a] + aux[a] # # for x in range(len(graph)): # graph[x] = graph[x]/ejecuciones #Obtenemos el promedio de cada posicion # # draw.drawIndividual(graph, graphName) # # file = open(graphName + ".txt", "w") # for y in range(len(graph)): # file.write(str(graph[y]) + "\n") # file.close() draw.drawGroup("Quartic")
def __init__(self, username, proxy_uri, spectator_mode=False): self.username = username try: self.proxy = Pyro4.Proxy(proxy_uri) except: raise Exception("Invalid URI") if not spectator_mode: register_response: dict = self.proxy.push_command("START " + username) if register_response['status'] != "OK": raise Exception(register_response['message']) self.board_id = register_response['board_id'] self.player_id = register_response['player_id'] else: self.board_id = "X" self.player_id = "X" latest_board: dict = self.proxy.push_command("UPDATE") self.board = board.Board(latest_board['data']) self.drawer = drawer.Drawer(self.board, self.username, str(self.board_id), self.player_id, self.proxy, spectator_mode)
def main(): sph = sphere.sphere() ros = rosenbrock.rosenbrock() qua = quartic.quartic() ras = rastrigin.rastrigin() draw = drawer.Drawer() aux = np.array([]) graph = np.array([]) executions = 5 stepSize_parameter = 0.5 #[0.4, 0.9] (F in DE) crossover_rate = 0.7 #[0.1, 1.0] (c in DE) individuals = 30 generations = 2000 dimensions = 2 graphName = "Sphere" + str(dimensions) + "D" for i in range(executions): aux = DE.differentialEvolution(sph, dimensions, individuals, stepSize_parameter, crossover_rate, generations) if i == 0: #For the first vector, we just make a copy to the one we'll be adding to. graph = aux else: #For the rest, we just add. for a in range(len(aux)): graph[a] = graph[a] + aux[a] for x in range(len(graph)): graph[x] = graph[x]/executions #We obtain the average for each vector position. draw.drawIndividual(graph, graphName) file = open(graphName + ".txt", "w") for y in range(len(graph)): file.write(str(graph[y]) + "\n") file.close()
f_a = second_border_func_val(u=a, v=0.0) func_values.append(f_a) print('Roots:\na = 0.0') a_roots = [0.0] for idx in range(1, len(a_values) - 1): a_left, f_left = a_values[idx], func_values[idx] a_right, f_right = a_values[idx + 1], func_values[idx + 1] if (f_left * f_right <= 0.0): a_star = flexible_bisection_root_search(a_left, f_left, a_right, f_right) print(f'a = {a_star}') a_roots.append(a_star) # draw function F(a) fa_pict = 'Fa_gamma={:.4}_alpha={:.5}'.format(gamma, alpha) dr = drawer.Drawer(x_label='a', y_label='F', figure_name=fa_pict, save_dir=SAVE_DIRECTORY) dr.drawAxis(show_Ox=True, show_Oy=True) #dr.drawPoints(a_roots, [0.0] * len(a_roots)) dr.drawCurve(a_values, func_values, curve_color='chocolate', up=None, bottom=None) # draw function u(x) for each a_* if DRAW_U_FUNCS: if len(a_roots) > 1: for a_star in a_roots[1:]: xs, us = build_original_u_func(a_star) #print (us) u_pict = 'u(x)_gamma={:.4}_alpha={:.5}_a={:.4}'.format(
import drawer import implementation import interact_interface import threading import time # driver code if __name__ == "__main__": interact_interface.Interact() obj = drawer.Drawer() ob = obj.please_draw() i = implementation.Implementation(obj) mark_lists = i.Start(obj) obj.draw_marks(mark_lists, ob)
else: return dichotonomy_root_search(y, right_border, func, **kwargs) elif (f < -EPS): if f_left < 0 and f_right > 0: return dichotonomy_root_search(y, right_border, func, **kwargs) else: return dichotonomy_root_search(left_border, y, func, **kwargs) else: return y # variables only for inner usage _x0 = 0.45 _g_min = 6.8 _g_max = 6.9 _points = 11 # only for inner usage if __name__ == '__main__': _gammas = np.linspace(_g_min, _g_max, _points) _alphas_u = [get_alpha_u(g, _x0) for g in _gammas] print('\tgamma\talpha') for idx in range(len(_gammas)): print('{:>9.6} {:>9.6}'.format(_gammas[idx], _alphas_u[idx])) _g_loc = get_gamma_local_min(_gammas, _alphas_u) _a_loc = get_alpha_min(_alphas_u) if _g_loc != _gammas[-1]: print('\na_loc_min = {:.12}'.format(_a_loc)) print('g_loc = {:.12}'.format(_g_loc)) drawer_alphau = drawer.Drawer(x_label=r'$\gamma$', y_label=r'$\alpha_u$') drawer_alphau.drawCurve(_gammas, _alphas_u, curve_color='b')
def __init__(self, square_size=64, max_x=15, max_y=7, moana_image="images/babymoana.jpg", moana_boat_image="images/moana_boat.jpg", maui_image="images/maui_bird_by_biz.jpg", sharkhead_image="images/maui.jpg", crab_image="images/crab_by_biz.jpg", dad_image="images/moana_dad.jpg", lava_image="images/lava_monster_by_biz.jpg", island_image="images/tifiti_by_biz.jpg", hook_image="images/fishhook.jpg", boat_image="images/boat.jpg", heart_image="images/heart_by_biz.jpg", shell_bin_image="images/shell_bin_by_biz.jpg", shells_image="images/shell.png", mud_image="images/lava_by_biz.jpg"): """Set up the game. Add one Moana character, a bunch of shells and a bunch of obstacles. Beware: this does nothing intelligent about making sure all shells are reachable or checking that the character doesn't get trapped in a corner surrounded by obstacles. No pathfinding algorithms were invoked in the writing of this game. Args: square_size: (int) the size of each grid square. The images on the grid should be square and should be this size or it'll look like a mess. max_x, max_y: (int) how many squares on each side of the grid. """ pygame.init() pygame.mixer.music.load("sounds/shells.wav") pygame.mixer.music.play() self.game_over = False self.clock = pygame.time.Clock() self.image_lib = {} self.done = False self.drawer = drawer.Drawer(square_size, max_x, max_y) self.crab = things.SelfMovingThing(self.get_image(crab_image), self.drawer, x=int(max_x / 2)) self.dad = things.SelfMovingThing(self.get_image(dad_image), self.drawer, y=int(max_y / 2)) self.mud = things.StationaryThings(self.get_image(mud_image), self.drawer, obstacle=True) self.mud.place_randomly(15) self.shells = things.StationaryThings(self.get_image(shells_image), self.drawer) self.shells.place_randomly(50) self.hook = things.StationaryThings(self.get_image(hook_image), self.drawer) self.hook.place_randomly(1) self.boat = things.StationaryThings(self.get_image(boat_image), self.drawer) self.boat.place_randomly(1) self.heart = things.StationaryThings(self.get_image(heart_image), self.drawer) self.shell_bin = things.StationaryThings( self.get_image(shell_bin_image), self.drawer) self.shell_bin.place_randomly(1) self.moana = things.MovingThing(self.get_image(moana_image), self.drawer, x=0) self.moana.add_replacement_image(self.get_image(moana_boat_image)) self.maui = things.MovingThing(self.get_image(sharkhead_image), self.drawer, x=max_x - 1) self.maui.add_replacement_image(self.get_image(maui_image)) self.island = things.MovingThing(self.get_image(lava_image), self.drawer, x=0, y=0) self.island.add_replacement_image(self.get_image(island_image)) self.drawer.set_background((255, 64, 0)) # orange self.update_score_text("Get the hook!") self.has_hook = False self.has_boat = False
''' Script for building and visualization alpha_u dependency (critical values of alpha, when zero solution of LINEARIZED BOUNDARY-VALUE PROBLEM with INTEGRAL DEVIATION in boundary conditions loses its stability in DIVERGENT way) ''' import numpy as np import drawer g_min = -4.1 g_max = 4.1 n_gammas = 8201 SAVE_DIRECTORY = '../Tracer/Variations/Integral Boundary Condition' if __name__ == '__main__': gammas = list(np.linspace(g_min, g_max, n_gammas)) alphas_u = list(map(lambda x: -x, gammas)) drawer_alphau = drawer.Drawer(x_label=r'$\gamma$', y_label=r'$\alpha_u$', save_dir=SAVE_DIRECTORY) drawer_alphau.drawAxis(show_Ox=True, show_Oy=True) drawer_alphau.drawCurve(gammas, alphas_u, curve_color='b')
import numpy as np import drawer x0 = 0.0 gamma = 5.1 def get_v_func_val(g, x): ''' Calculate and return value of v(x) for fixed gamma :param g: fixed gamma value :param x: x value :return: v(x) for fixed gamma ''' if g <= 0: mu = np.sqrt(-g) return np.cosh(mu*x) else: mu = np.sqrt(g) return np.cos(mu*x) if __name__ == '__main__': xs = np.linspace(0, 1, 10000) vs = [get_v_func_val(gamma, x) for x in xs] # draw v function v_figure_name = 'x0={:.2}__g={:.4}'.format(x0, gamma) drawer_v = drawer.Drawer(x_label='x', y_label='v', figure_name=v_figure_name) drawer_v.drawCurve(xs, vs, curve_color='slateblue')
def main(): set_brightness(.05) switchColor(1) try: frames = kinecter.getFrames(30) dX, dY, angle, angleZ = kinecter.derivateFrames(frames) noProblem = True except Exception as e: print(traceback.format_exc()) noProblem = False draw = drawer.Drawer(output=True) switchColor(2) print('---Switch is strating') #intializeDrawer() flip = False speed = 5 z = frames[6] A = angle[6] nLines = 100 try: for k in range(0, nLines): xLines = [] yLines = [] kx = random.randint(0, 640) ky = random.randint(0, 480) x, y = scaler(kx, ky) zTest = z[kx, ky] while (not np.isnan(zTest)): xLines.append(x) yLines.append(y) dx = x + speed * np.cos(A[kx, ky]) dy = y + speed * np.cos(A[kx, ky]) dkx, dky = scaler(x, y, invert=True) if (dxk > -1) and (dxk < 640) and (dyk > -1) and ( dyk < 480) and size < 100 * np.sin(A[kx, ky]): x = dx y = dy kx = dkx ky = dky zTest = z[kx, ky] else: zTest = np.isnan draw.lines(xLines, yLines) #line(50,50,length=50,angle=0) #line(50,50,length=55,angle=.1) #line(50,50,length=60,angle=.2) #line(50,50,length=65,angle=.4) #line(50,50,length=70,angle=.8) #line(50,50,length=75,angle=1.6) #for k in range(0,10): #draw.square(100,70,10*k/2.0,noise = 3,speed=500) #for j in range(0,10): #square((k+1)*11,(j+1)*11,10,angle=math.pi*(k*j)/(400)) #draw.circle((k+1)*11,(j+1)*11,k+j) except Exception as e: print(traceback.format_exc()) draw.toPosition(0, 0) draw.closeDrawer() switchColor(1)
SUFFIX_NAME = '_after_tangent' if AFTER_TANGENT else '' DATA_PATH = '../Tracer/Results' + f'/x0={x0:.2f}' CSV_FILE = DATA_PATH + f'/x0={x0:.2f}' + '_analytical.csv' AFTER_TANGENT_FILE = DATA_PATH + f'/x0={x0:.2f}' + '_analytical_after_tangent.csv' SAVE_DIRECTORY = '../Tracer/Results/Omegas' PICT_NAME = SAVE_DIRECTORY + f'/omegas_x0={x0:.2f}' + SUFFIX_NAME + '.png' def read_params(): ''' Read params for visualization :return list of gamma values, list of omega values ''' gs, ws = [], [] if AFTER_TANGENT: if os.path.exists(AFTER_TANGENT_FILE): df = pd.read_csv(AFTER_TANGENT_FILE, sep=';') gs, ws = list(df['gamma']), list(df['w']) else: df = pd.read_csv(CSV_FILE, sep=';') gs, ws = list(df['gamma']), list(df['w']) return gs, ws if __name__ == '__main__': gs, ws = read_params() # draw omega dependency drawer_w = drawer.Drawer(x_label=r'$\gamma$', y_label=r'$\omega$', save_dir=SAVE_DIRECTORY) drawer_w.drawCurve(gs, ws, curve_color='g', save_name=PICT_NAME)
df = pd.DataFrame(func_values).sort_values(by=[COLUMNS[0]]) a_s, f_s = tuple(map(lambda x: df[x].tolist(), COLUMNS)) print('Searching for roots...\na = 0') a_roots = [0.0] for idx in range(1, len(a_s) - 1): a_left, f_left = a_s[idx], f_s[idx] a_right, f_right = a_s[idx + 1], f_s[idx + 1] if (f_left * f_right <= 0.0): a_star = flexible_bisection_root_search(a_left, f_left, a_right, f_right, numerical_method) print(f'a = {a_star:g}') a_roots.append(a_star) # draw function F(a) fa_pict = 'Fa_gamma={:.4}_alpha={:.5}'.format(gamma, alpha) dr = drawer.Drawer(x_label=COLUMNS[0], y_label=COLUMNS[1], figure_name=fa_pict, save_dir=SAVE_DIRECTORY) dr.drawAxis(show_Ox=True, show_Oy=True) #dr.drawPoints(a_roots, [0.0] * len(a_roots)) dr.drawCurve(a_s, f_s, curve_color='chocolate', up=None, bottom=None) # draw function u(x) for each a_* if DRAW_U_FUNCS: if len(a_roots) > 1: for a_star in a_roots[1:]: xs, us = build_original_u_func(a_star) #print (us) u_pict = 'u(x)_gamma={:.4}_alpha={:.5}_a={:.4}'.format( gamma, alpha, a_star) dr = drawer.Drawer(x_label='x', y_label='u', figure_name=u_pict,
def __init__(self): if hasattr(sys, 'frozen'): self.local_path = os.path.realpath(os.path.dirname(sys.executable)) sys.path.append(self.local_path) else: self.local_path = os.path.realpath(os.path.dirname(__file__)) #self.__init_config() self.wtree_path = os.path.join(self.local_path, 'editor.ui') self.builder = Gtk.Builder() self.builder.add_from_file(self.wtree_path) self.builder.connect_signals(self) self.main_window = self.builder.get_object('main_window') self.main_window.connect('delete-event', self.on_main_window_delete_event) self.main_window.connect('destroy', Gtk.main_quit) self.treeview = self.builder.get_object('treeview') self.treeview.connect('row-activated', self.on_treeview_row_activated) self.main_window.show_all() self.main_box = self.builder.get_object('hbox1') self.main_box.hide() self.project_dialog = dialogs.ProjectDialog(self.builder, self.main_window) self.search_dialog = dialogs.SearchDialog(self.builder, self.main_window) self.file_list = self.builder.get_object('file_list') self.__load_config() self.main_box.show_all() self.teste = self.builder.get_object('viewport3') self.teste2 = self.builder.get_object('textview1') self.teste2.modify_font(Pango.FontDescription(fontDescription)) self.teste3 = self.builder.get_object('textview2') self.teste3.modify_font(Pango.FontDescription(fontDescription)) self.buf = self.teste3.get_buffer() self.panel_separator = self.builder.get_object("hpaned1") self.drawing_area = drawer.Drawer( self.config_files, bg=os.path.join(self.config_path, self.main_config['BackgroundFolder']), font=os.path.join(self.config_path, self.main_config['FontFolder'])) self.drawing_area.mask_event(Gdk.EventMask.BUTTON_PRESS_MASK) self.writing_area = writer.Writer() self.teste2.set_buffer(self.writing_area) self.writing_area.connect('changed', self.on_writing_area_changed) self.writing_area.connect('mark-set', self.on_writing_area_mark_set) self.s_id_1 = self.writing_area.connect( 'modified-changed', self.on_writing_area_modified_changed) self.drawing_area.connect('draw', self.on_drawing_area_expose_event) self.drawing_area.show() self.teste.add(self.drawing_area) self.file_list_iter = [] self.__init_file_list()
def get_dict_roots(ws, ys): ''' Form and return dictionary of roots, where sign function changes its sign (dict_key - omega value, dict_value - alpha_c (oscillating case) value) :param ws: :param ys: :return: ''' res = {} for idx in range(1, len(ws)): if ys[idx - 1] * ys[idx] < 0: w_star = (ws[idx - 1] + ws[idx]) / 2.0 res[str(w_star)] = utils.get_alpha_c(gamma, w_star, x0) return res if __name__ == '__main__': print(f'gamma = {gamma}\n') ws = np.linspace(w_start, w_end, n_points) ys = [get_sign_func_val(w) for w in ws] # find roots star = get_dict_roots(ws, ys) print('gamma;w_star;alpha_c') for w, a in star.items(): print('{:.9};{:.9};{:.9}'.format(gamma, float(w), a)) # draw function dr = drawer.Drawer(x_label=r'$\omega$') dr.drawAxis(show_Ox=True) dr.drawCurve(ws, ys, curve_color='k')
datapath = os.path.join('..', 'data') confpath = os.path.join('..', 'conf') random.seed() subjectid = "" sessionid = "" while subjectid == "" or subjectid == None: subjectid = raw_input("Subject ID: ") print subjectid sessionid = 0 random.seed(subjectid + str(time.time())) drawer = drawer.Drawer() scorer = scorer.Scorer() acceptedkeys = ['s', 'd', 'f', 'j', 'k', 'l'] sessionid = 0 exptname = "skill3" gensettings = readConfig(os.path.join(confpath, 'configuration.txt')) colort = readConfig(os.path.join(confpath, 'colors.txt')) colors = [] for k, v in colort.iteritems(): colors.append(map(int, v)) print colors letters = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
return False def validate_args(args): if args.scale < 1: print("The scale may not be smaller than 1") exit(-1) if not os.path.isfile(args.file): print("The file \"{}\" does not exist or is not a file", args.file) exit(-1) if __name__ == '__main__': args = parser.parse_args() validate_args(args) nonogram = nonogram.Nonogram(args) drawer = drawer.Drawer(nonogram, args) nonogram.apply_first_step() drawer.draw_numbers() drawer.draw_field(True) if not args.first_step: solve(0, drawer) drawer.draw_field(True) drawer.cleanup()