def setup_spinnman_interfaces(self): """Set up the interfaces for communicating with the SpiNNaker board """ self.dao.set_hostname(self.hostname) self.txrx = Transceiver(self.hostname) # Start local tubotron if requested if conf.config.getboolean("Visualiser", "enable"): self.wait_for_run = conf.config.getboolean( "Visualiser", "pause_before_run" ) if self.wait_for_run: self.visualiser = Visualiser( self.dao, start_simulation_method=getattr(self, "run_now") ) else: self.visualiser = Visualiser(self.dao) self.visualiser.set_port(self.visualiser_port) tubotron_port = conf.config.getint("Tubotron", "port") tubotron_tag = conf.config.getint("Tubotron", "tag") tubotron_host = conf.config.get("Tubotron", "hostname") self.set_tag_output(tubotron_tag, tubotron_port, tubotron_host) if conf.config.getboolean("Tubotron", "enable"): if tubotron_host == "localhost": self.tubotron = Tubotron(tubotron_port) if conf.config.has_option("Tubotron", "leaveRunning"): self.leaveTubotronRunning = conf.config.getboolean( "Tubotron", "leaveRunning")
def setup_spinnman_interfaces(self): """Set up the interfaces for communicating with the SpiNNaker board """ self.dao.set_hostname(self.hostname) self.txrx = Transceiver(self.hostname) # Start local tubotron if requested if conf.config.getboolean("Visualiser", "enable"): self.wait_for_run = conf.config.getboolean("Visualiser", "pause_before_run") if self.wait_for_run: self.visualiser = Visualiser(self.dao, start_simulation_method=getattr( self, "run_now")) else: self.visualiser = Visualiser(self.dao) self.visualiser.set_port(self.visualiser_port) tubotron_port = conf.config.getint("Tubotron", "port") tubotron_tag = conf.config.getint("Tubotron", "tag") tubotron_host = conf.config.get("Tubotron", "hostname") self.set_tag_output(tubotron_tag, tubotron_port, tubotron_host) if conf.config.getboolean("Tubotron", "enable"): if tubotron_host == "localhost": self.tubotron = Tubotron(tubotron_port) if conf.config.has_option("Tubotron", "leaveRunning"): self.leaveTubotronRunning = conf.config.getboolean( "Tubotron", "leaveRunning")
def trigger_page(): """ Renders the trigger page. This page contains an instance of a TriggerForm. The TriggerForm contains input fields for the simulation. If the submit button is pressed, a simulation is triggered and the results are generated using the Visualiser class. If all succeeds, forward to endpoint "visualise" """ form = TriggerForm() # if the form is valid and the submit button was pressed if form.validate_on_submit(): # get the static path from the current application to store the visualisations static_path = os.path.join(current_app.root_path, current_app.static_folder) # clean up the previous simulation results Cleaner().remove_previous_simulation_results(static_path=static_path) # retrieve number of requests from the form number_of_requests = form.number_of_requests_field.data # Create an instance of the bounding box class, using the form data bounding_box = BoundingBox((form.x1_field.data, form.y1_field.data, form.x2_field.data, form.y2_field.data)) # Create an instance of the StaticDataReader class. static_data = StaticDataReader( berlin_bounds_file=current_app.config['BERLIN_BOUNDS_FILE'], berlin_stops_file=current_app.config['BERLIN_STOPS_FILE']) # Create an instance of the Simulator class. simulator = Simulator( bounding_box=bounding_box.bounding_box, path_to_stops=current_app.config['BERLIN_STOPS_FILE']) # Run a simulation simulation_results = simulator.simulate(number_of_requests) # Create an instance of the Visualiser class. visualiser = Visualiser(bounding_box=bounding_box, simulation_results=simulation_results, static_path=static_path, static_data=static_data) # Generate visualisations visualiser.generate_overview_figure() visualiser.generate_closeup_figure() visualiser.generate_gmap() # redirect to the visualise endpoint return redirect( url_for('routes.visualise', visualiser_id=visualiser.id)) # render a template for the trigger page. return render_template('trigger_page.html', title="MI Code Challenge", form=form)
def setUpClass(self): """ Sets up the class. The data only has to be read in once, so this is done in the class setup method. """ # TODO: Remove warn ngs filter when migrating to geopandas > 0.7.0 ! warnings.simplefilter('ignore', category=FutureWarning) warnings.simplefilter('ignore', category=DeprecationWarning) static_data = StaticDataReader('data/berlin_bounds.poly', 'data/berlin_stops.geojson') bounding_box_tuple = (13.34014892578125, 52.52791908000258, 13.506317138671875, 52.562995039558004) simulator = Simulator(bounding_box=bounding_box_tuple) simulation_results = simulator.simulate(number_of_requests=6) self.visualiser = Visualiser( bounding_box=BoundingBox(bounding_box_tuple), simulation_results=simulation_results, static_data=static_data, static_path='webapp/static')
[2, 3, 2, 3] [2, 3, 3, 2] [3, 2, 2, 3] [3, 2, 3, 2] [3, 3, 2, 2] [3, 7] [7, 3] """ @vs(ignore_args=['node_num'], show_argument_name=False, show_return_value=False) def f(sum, ans): # If sum becoms 0 we have found the required list if sum == 0: print(ans) # Include every other element to make the sum # Number that is included also can be included for elem in nums: if sum - elem >= 0: f(sum=sum - elem, ans=ans + [elem]) # We want to make the sum from list nums nums = [2, 3, 7] sum = 10 # Call solve with sum and an empty list f(sum=sum, ans=[]) vs.write_image("make_sum.png")
class Controller(object): """ A Controller is instantiated by a front-end in order to map a model to SpiNNaker, load it to the machine, run it and retrieve the results. The Controller provides functions for the front-end to trigger each of these stages and instantiates a :py:class:`pacman103.core.dao.DAO` object in which front-end inputs and results of the mapping processes are stored and a :py:class:`pacman103.core.transceiver.Transceiver` through which simulations are loaded to SpiNNaker and observed. :param module front_end: front-end package :param string hostname: hostname of the SpiNNaker machine on which the simulation is to be run. :param dict kwargs: key word arguments, of which there are currently none. """ partitioner_algorithms_list = conf.get_valid_components( partitioner_algorithms, "Partitioner" ) placer_algorithms_list = conf.get_valid_components( placer_algorithms, "Placer" ) key_allocator_algorithms_list = conf.get_valid_components( key_allocator_algorithms, "KeyAllocator" ) routing_algorithms_list = conf.get_valid_components( routing_algorithms, "Routing" ) utility = None def __init__(self, front_end, hostname, reload_time=None, **kwargs): self.hostname = hostname self.dao = dao.DAO(front_end) self.reload_time = reload_time self.txrx = None self.app_id = None self.tubotron = None self.leaveTubotronRunning = False self.visualiser = None self.wait_for_run = False self.visualiser_port = None #setting tuborotron to false, so that in theory our strange tubotron doesnt operate conf.config.set("Tubotron", "enable", "False") #ABS changed so that iptag is sotred into dao instead of # transmitting immediately def set_tag_output(self, tag, port, hostname="localhost", timeout=10): self.dao.add_iptag(IPTag(tag=tag, port=port, hostname=hostname, timeout=timeout)) def add_vertex(self, vertex): """ Adds a vertex object to the datastore. This is simply a convenience function that wraps :py:func:`pacman103.core.dao.DAO.add_vertex` to save the front-end from directly interacting with the datastore. :param `pacman103.lib.graph.Vertex` vertex: Vertex object to be added. """ return self.dao.add_vertex(vertex) def get_multi_cast_vertex(self): return self.dao.multi_cast_vertex def add_edge(self, edge): """ Adds an edge object to the datastore. This is simply a convenience function that wraps :py:func:`pacman103.core.dao.DAO.add_edge` to save the front-end from directly interacting with the datastore. :param `pacman103.lib.graph.Edge` edge: Edge object to be added. """ self.dao.add_edge(edge) def add_rng(self, rngIndex, rngInfo): """Adds a random number generator object to the datastore. This is simply a convenience function that wraps :py:func:`pacman103.core.dao.DAO.add_rng` to save the front-end from directly interacting with the datastore. """ logger.debug("Controller adding RNG") self.dao.add_rng(rngIndex, rngInfo) def add_random_distribution(self, distIndex, distInfo): """ Adds a random distribution object to the datastore. This is simply a convenience function that wraps :py:func:`pacman103.core.dao.DAO.add_randomDistribution` to save the front-end from directly interacting with the datastore. """ logger.debug("Controller adding random dist") self.dao.add_randomDistribution(distIndex, distInfo) def generate_output(self): """ Generates simulation data structures and prepares load targets and execution targets. """ if self.reload_time is None: output_generator.generate_output(self.dao) else: output_generator.reload_output(self.dao, self.reload_time) def load_write_mem(self): """ Loads the simulation memory writes to the board via the transceiver. """ self.txrx.load_write_mem(self.dao) def load_targets(self): """ Loads the simulation executables and data structures to the board via the transceiver. """ self.txrx.load_targets(self.dao) def map_model(self): """Map an input graph to a SpiNNaker machine via the partitioning, placement and routing stages. See :py:mod:`pacman103.core.mapper` for more details. *Side effects*: populates the datastore with information proceeding from each stage of mapping. """ self.setup_spinnman_interfaces() report_dir = self.dao.get_reports_directory() enabledReports = False if (conf.config.getboolean("Reports", "reportsEnabled")): enabledReports = True if enabledReports: reports.generate_network_report(self.dao) reports.generate_machine_report(self.dao) #check if each flag has been set before running a method #partitioning verts into subverts if not self.dao.done_partitioner: self.execute_partitioning() # placing subverts onto machine structure # (can be done by preivous systems if merged) if not self.dao.done_placer: self.execute_placer() if enabledReports: reports.generate_placement_reports(self.dao) #allocate keys to subedges so that its done up front # (no report, as covered by the router report) if not self.dao.done_key_allocation: self.execute_key_alloc() #route packets from subverts through subedges if not self.dao.done_router: self.filterSubEdges(self.dao) self.execute_routing() if enabledReports: reports.generate_routing_report(self.dao) #if not self.dao.done_inverse_mapper: # InverseMapper.build_inverse_map(self.dao) if enabledReports: reports.generate_coremap_report(self.dao) def execute_partitioning(self): """Handle the execution of a partitioning algorithm """ try: partitioner_class = Controller.partitioner_algorithms_list[ conf.config.get("Partitioner", "algorithm")] partitioner = partitioner_class(self.dao) partitioner.partition() except KeyError as e: raise ValueError("Invalid partitioner algorithm specified. " " I don't know '%s'." % e) def execute_placer(self): """Handle the exeuction of a placer algorithm """ try: placer_class = Controller.placer_algorithms_list[ conf.config.get("Placer", "algorithm") ] placer = placer_class(self.dao) placer.place_all() except KeyError as e: raise ValueError("Invalid partitioner algorithm specified. " " I don't know '%s'." % e) def execute_key_alloc(self): """Handle the execution of a key allocator """ try: key_allocator_class = Controller.key_allocator_algorithms_list[ conf.config.get("Key_allocator", "algorithm")] key_allocer = key_allocator_class(self.dao) key_allocer.allocate_keys() except KeyError as e: raise ValueError("Invalid key alloc algorithm specified. " " I don't know '%s'." % conf.config.get("Key_allocator", "algorithm") ) def execute_routing(self): """Execute routing """ try: router = Router(self.dao) router.route() except KeyError as e: raise ValueError("Invalid partitioner algorithm specified. " " I don't know '%s'." % e) def start_visualiser(self): """Start the Visualiser thread """ if (conf.config.getboolean("Visualiser", "enable") and not conf.config.getboolean("Visualiser", "have_board")): self.visualiser.start() def set_visulaiser_port(self, port): """Set the port that the Visualiser listens to for packets """ self.visualiser_port = port def setup_spinnman_interfaces(self): """Set up the interfaces for communicating with the SpiNNaker board """ self.dao.set_hostname(self.hostname) self.txrx = Transceiver(self.hostname) # Start local tubotron if requested if conf.config.getboolean("Visualiser", "enable"): self.wait_for_run = conf.config.getboolean( "Visualiser", "pause_before_run" ) if self.wait_for_run: self.visualiser = Visualiser( self.dao, start_simulation_method=getattr(self, "run_now") ) else: self.visualiser = Visualiser(self.dao) self.visualiser.set_port(self.visualiser_port) tubotron_port = conf.config.getint("Tubotron", "port") tubotron_tag = conf.config.getint("Tubotron", "tag") tubotron_host = conf.config.get("Tubotron", "hostname") self.set_tag_output(tubotron_tag, tubotron_port, tubotron_host) if conf.config.getboolean("Tubotron", "enable"): if tubotron_host == "localhost": self.tubotron = Tubotron(tubotron_port) if conf.config.has_option("Tubotron", "leaveRunning"): self.leaveTubotronRunning = conf.config.getboolean( "Tubotron", "leaveRunning") def run(self, app_id): """Trigger execution of the simulation on SpiNNaker via the transceiver. """ self.app_id = app_id if (conf.config.getboolean("Visualiser", "enable") and conf.config.getboolean("Visualiser", "have_board")): self.visualiser.start() if not self.wait_for_run: self.run_now() else: print "Waiting for run command..." self.visualiser.wait_for_finish() def run_now(self): """Start a already loaded application """ if self.tubotron is not None: self.tubotron.start() if (self.dao.run_time is not None and self.dao.run_time > 0 and not self.leaveTubotronRunning): self.tubotron.set_timeout((self.dao.run_time / 1000.0) + 1) self.txrx.run(self.dao, self.app_id) def stop(self): """Stop a running application """ if self.tubotron is not None: self.tubotron.stop() def filterSubEdges(self, dao): """Go through the newly created list of sub-edges and call a model specific function on each one, this allows the application to prune sub-edges that are not really needed. """ logger.info("* Running pre-routing sub-edge pruning *") new_subedges = list() progress = ProgressBar(len(dao.subedges)) for subedge in dao.subedges: if subedge.edge.filterSubEdge(subedge): subedge.pruneable = True else: new_subedges.append(subedge) progress.update() dao.subedges = new_subedges progress.end()
from visualiser.visualiser import Visualiser as vs st = [] @vs(show_argument_name=False, node_properties_kwargs={ "shape": "record", "color": "#f57542", "style": "filled", "fillcolor": "grey" }) def combi(prefix, s): if len(s) == 0: return " " else: st.append(prefix + s[0]) combi(prefix=prefix + s[0], s=s[1:]) combi(prefix=prefix, s=s[1:]) return st print(combi(prefix="", s='abc')) vs.make_animation("combinations.gif", delay=3)
def main(): # Call function print(fact(n=6)) # Save recursion tree to a file vs.make_animation("factorial.gif", delay=2)
def main(): # Call function print(fib(6)) vs.write_image("tree.png")
def main(): # Call function print(merge_sort([5, 0, 1, 9])) # Save recursion tree to a file vs.make_animation("merge_sort.gif", delay=1.3)
class Controller(object): """ A Controller is instantiated by a front-end in order to map a model to SpiNNaker, load it to the machine, run it and retrieve the results. The Controller provides functions for the front-end to trigger each of these stages and instantiates a :py:class:`pacman103.core.dao.DAO` object in which front-end inputs and results of the mapping processes are stored and a :py:class:`pacman103.core.transceiver.Transceiver` through which simulations are loaded to SpiNNaker and observed. :param module front_end: front-end package :param string hostname: hostname of the SpiNNaker machine on which the simulation is to be run. :param dict kwargs: key word arguments, of which there are currently none. """ partitioner_algorithms_list = conf.get_valid_components( partitioner_algorithms, "Partitioner") placer_algorithms_list = conf.get_valid_components(placer_algorithms, "Placer") key_allocator_algorithms_list = conf.get_valid_components( key_allocator_algorithms, "KeyAllocator") routing_algorithms_list = conf.get_valid_components( routing_algorithms, "Routing") utility = None def __init__(self, front_end, hostname, reload_time=None, **kwargs): self.hostname = hostname self.dao = dao.DAO(front_end) self.reload_time = reload_time self.txrx = None self.app_id = None self.tubotron = None self.leaveTubotronRunning = False self.visualiser = None self.wait_for_run = False self.visualiser_port = None #setting tuborotron to false, so that in theory our strange tubotron doesnt operate conf.config.set("Tubotron", "enable", "False") #ABS changed so that iptag is sotred into dao instead of # transmitting immediately def set_tag_output(self, tag, port, hostname="localhost", timeout=10): self.dao.add_iptag( IPTag(tag=tag, port=port, hostname=hostname, timeout=timeout)) def add_vertex(self, vertex): """ Adds a vertex object to the datastore. This is simply a convenience function that wraps :py:func:`pacman103.core.dao.DAO.add_vertex` to save the front-end from directly interacting with the datastore. :param `pacman103.lib.graph.Vertex` vertex: Vertex object to be added. """ return self.dao.add_vertex(vertex) def get_multi_cast_vertex(self): return self.dao.multi_cast_vertex def add_edge(self, edge): """ Adds an edge object to the datastore. This is simply a convenience function that wraps :py:func:`pacman103.core.dao.DAO.add_edge` to save the front-end from directly interacting with the datastore. :param `pacman103.lib.graph.Edge` edge: Edge object to be added. """ self.dao.add_edge(edge) def add_rng(self, rngIndex, rngInfo): """Adds a random number generator object to the datastore. This is simply a convenience function that wraps :py:func:`pacman103.core.dao.DAO.add_rng` to save the front-end from directly interacting with the datastore. """ logger.debug("Controller adding RNG") self.dao.add_rng(rngIndex, rngInfo) def add_random_distribution(self, distIndex, distInfo): """ Adds a random distribution object to the datastore. This is simply a convenience function that wraps :py:func:`pacman103.core.dao.DAO.add_randomDistribution` to save the front-end from directly interacting with the datastore. """ logger.debug("Controller adding random dist") self.dao.add_randomDistribution(distIndex, distInfo) def generate_output(self): """ Generates simulation data structures and prepares load targets and execution targets. """ if self.reload_time is None: output_generator.generate_output(self.dao) else: output_generator.reload_output(self.dao, self.reload_time) def load_write_mem(self): """ Loads the simulation memory writes to the board via the transceiver. """ self.txrx.load_write_mem(self.dao) def load_targets(self): """ Loads the simulation executables and data structures to the board via the transceiver. """ self.txrx.load_targets(self.dao) def map_model(self): """Map an input graph to a SpiNNaker machine via the partitioning, placement and routing stages. See :py:mod:`pacman103.core.mapper` for more details. *Side effects*: populates the datastore with information proceeding from each stage of mapping. """ self.setup_spinnman_interfaces() report_dir = self.dao.get_reports_directory() enabledReports = False if (conf.config.getboolean("Reports", "reportsEnabled")): enabledReports = True if enabledReports: reports.generate_network_report(self.dao) reports.generate_machine_report(self.dao) #check if each flag has been set before running a method #partitioning verts into subverts if not self.dao.done_partitioner: self.execute_partitioning() # placing subverts onto machine structure # (can be done by preivous systems if merged) if not self.dao.done_placer: self.execute_placer() if enabledReports: reports.generate_placement_reports(self.dao) #allocate keys to subedges so that its done up front # (no report, as covered by the router report) if not self.dao.done_key_allocation: self.execute_key_alloc() #route packets from subverts through subedges if not self.dao.done_router: self.filterSubEdges(self.dao) self.execute_routing() if enabledReports: reports.generate_routing_report(self.dao) #if not self.dao.done_inverse_mapper: # InverseMapper.build_inverse_map(self.dao) if enabledReports: reports.generate_coremap_report(self.dao) def execute_partitioning(self): """Handle the execution of a partitioning algorithm """ try: partitioner_class = Controller.partitioner_algorithms_list[ conf.config.get("Partitioner", "algorithm")] partitioner = partitioner_class(self.dao) partitioner.partition() except KeyError as e: raise ValueError("Invalid partitioner algorithm specified. " " I don't know '%s'." % e) def execute_placer(self): """Handle the exeuction of a placer algorithm """ try: placer_class = Controller.placer_algorithms_list[conf.config.get( "Placer", "algorithm")] placer = placer_class(self.dao) placer.place_all() except KeyError as e: raise ValueError("Invalid partitioner algorithm specified. " " I don't know '%s'." % e) def execute_key_alloc(self): """Handle the execution of a key allocator """ try: key_allocator_class = Controller.key_allocator_algorithms_list[ conf.config.get("Key_allocator", "algorithm")] key_allocer = key_allocator_class(self.dao) key_allocer.allocate_keys() except KeyError as e: raise ValueError("Invalid key alloc algorithm specified. " " I don't know '%s'." % conf.config.get("Key_allocator", "algorithm")) def execute_routing(self): """Execute routing """ try: router = Router(self.dao) router.route() except KeyError as e: raise ValueError("Invalid partitioner algorithm specified. " " I don't know '%s'." % e) def start_visualiser(self): """Start the Visualiser thread """ if (conf.config.getboolean("Visualiser", "enable") and not conf.config.getboolean("Visualiser", "have_board")): self.visualiser.start() def set_visulaiser_port(self, port): """Set the port that the Visualiser listens to for packets """ self.visualiser_port = port def setup_spinnman_interfaces(self): """Set up the interfaces for communicating with the SpiNNaker board """ self.dao.set_hostname(self.hostname) self.txrx = Transceiver(self.hostname) # Start local tubotron if requested if conf.config.getboolean("Visualiser", "enable"): self.wait_for_run = conf.config.getboolean("Visualiser", "pause_before_run") if self.wait_for_run: self.visualiser = Visualiser(self.dao, start_simulation_method=getattr( self, "run_now")) else: self.visualiser = Visualiser(self.dao) self.visualiser.set_port(self.visualiser_port) tubotron_port = conf.config.getint("Tubotron", "port") tubotron_tag = conf.config.getint("Tubotron", "tag") tubotron_host = conf.config.get("Tubotron", "hostname") self.set_tag_output(tubotron_tag, tubotron_port, tubotron_host) if conf.config.getboolean("Tubotron", "enable"): if tubotron_host == "localhost": self.tubotron = Tubotron(tubotron_port) if conf.config.has_option("Tubotron", "leaveRunning"): self.leaveTubotronRunning = conf.config.getboolean( "Tubotron", "leaveRunning") def run(self, app_id): """Trigger execution of the simulation on SpiNNaker via the transceiver. """ self.app_id = app_id if (conf.config.getboolean("Visualiser", "enable") and conf.config.getboolean("Visualiser", "have_board")): self.visualiser.start() if not self.wait_for_run: self.run_now() else: print "Waiting for run command..." self.visualiser.wait_for_finish() def run_now(self): """Start a already loaded application """ if self.tubotron is not None: self.tubotron.start() if (self.dao.run_time is not None and self.dao.run_time > 0 and not self.leaveTubotronRunning): self.tubotron.set_timeout((self.dao.run_time / 1000.0) + 1) self.txrx.run(self.dao, self.app_id) def stop(self): """Stop a running application """ if self.tubotron is not None: self.tubotron.stop() def filterSubEdges(self, dao): """Go through the newly created list of sub-edges and call a model specific function on each one, this allows the application to prune sub-edges that are not really needed. """ logger.info("* Running pre-routing sub-edge pruning *") new_subedges = list() progress = ProgressBar(len(dao.subedges)) for subedge in dao.subedges: if subedge.edge.filterSubEdge(subedge): subedge.pruneable = True else: new_subedges.append(subedge) progress.update() dao.subedges = new_subedges progress.end()
if right_side_m > 0 and right_side_c > right_side_m: return False visited[(m, c, s)] = True if s == 1: op = -1 else: op = 1 solved = False for i in range(5): next_m, next_c, next_side = m + op * options[i][0], c + op * options[ i][1], int(not s) if is_valid(next_m, next_c): if (next_m, next_c, next_side) not in visited: solved = (solved or dfs( m=next_m, c=next_c, s=next_side, level=level + 1)) if solved: return True return solved if (dfs(m=3, c=3, s=1, level=0)): print("SOlution Found") # Save recursion tree to a file vs.make_animation("missionaries.gif", delay=2)
def main(): amount = 5 coins = [1, 2, 5] print(f(coins=coins, amount=amount, n=len(coins))) vs.make_animation("coin_change.gif", delay=3)
def main(): # Call function print(fib(n=6)) # Save recursion tree to a file vs.make_animation("fibonacci.gif", delay=2)
from visualiser.visualiser import Visualiser as vs """ Problem Link: https://stackoverflow.com/questions/33808653/recursion-tree-with-fibonacci-python/60126306#60126306 """ @vs(node_properties_kwargs={ "shape": "record", "color": "#f57542", "style": "filled", "fillcolor": "grey" }) def binary(length, outstr=""): if len(outstr) == length: print(outstr) else: for i in ["0", "1"]: binary(length=length, outstr=outstr + i) binary(length=3, outstr="") vs.make_animation("binary_string.gif", delay=2)
class TestVisualiser(unittest.TestCase): """ Testcase for the Visualiser Class """ @classmethod def setUpClass(self): """ Sets up the class. The data only has to be read in once, so this is done in the class setup method. """ # TODO: Remove warn ngs filter when migrating to geopandas > 0.7.0 ! warnings.simplefilter('ignore', category=FutureWarning) warnings.simplefilter('ignore', category=DeprecationWarning) static_data = StaticDataReader('data/berlin_bounds.poly', 'data/berlin_stops.geojson') bounding_box_tuple = (13.34014892578125, 52.52791908000258, 13.506317138671875, 52.562995039558004) simulator = Simulator(bounding_box=bounding_box_tuple) simulation_results = simulator.simulate(number_of_requests=6) self.visualiser = Visualiser( bounding_box=BoundingBox(bounding_box_tuple), simulation_results=simulation_results, static_data=static_data, static_path='webapp/static') def setUp(self): pass def test_generate_overview_figure(self): """ Asserts a overview figure is generated after calling the function. """ self.visualiser.generate_overview_figure() self.assertTrue( isfile( f"{self.visualiser.static_path}/{self.visualiser.id}_overview_plot.png" )) def test_generate_closeup_figure(self): """ Asserts a closeup figure is generated after calling the function. """ self.visualiser.generate_closeup_figure() self.assertTrue( isfile( f"{self.visualiser.static_path}/{self.visualiser.id}_closeup_plot.png" )) def test_generate_gmap(self): """ Asserts a html map is generated after calling the function. """ self.visualiser.generate_gmap() self.assertTrue( isfile( f"{self.visualiser.static_path}/{self.visualiser.id}_map.html") ) def tearDown(self): pass if __name__ == "__main__": unittest.main()
def main(): # Call function print(max_revenue(5,prices)) # Save recursion tree to a file vs.make_animation("fibonacci.gif", delay=1)
def main(): # Call function print(lis([-4, 10, 3, 7, 15], 0, -1)) # Save recursion tree to a file vs.make_animation("lis.gif", delay=2)
from visualiser.visualiser import Visualiser as vs """ Given an array of numbers, find all the subsets: eg: nums = [1, 2, 3] Output: [[], [1], [2], [2, 1], [3], [3, 1], [3, 2], [3, 2 , 1]] You can find my explanation here: https://qr.ae/TWHmsi """ subsets = [] @vs(ignore_args=["nums"], show_return_value=False, show_argument_name=False) def f(nums, i, current_subset): # If no more elements left if i == 0: subsets.append(current_subset) return # Exclude Current element f(nums=nums, i=i - 1, current_subset=current_subset) # Include current element f(nums=nums, i=i - 1, current_subset=current_subset + [nums[i - 1]]) if __name__ == "__main__": nums = [1, 2, 3] f(nums=nums, i=len(nums), current_subset=[]) # Save recursion tree to a file vs.make_animation("subset.gif", delay=3)